diff --git a/plutus-ledger-api/src/PlutusLedgerApi/V1/Bytes.hs b/plutus-ledger-api/src/PlutusLedgerApi/V1/Bytes.hs
index e45303c9d54..172fbd96f8e 100644
--- a/plutus-ledger-api/src/PlutusLedgerApi/V1/Bytes.hs
+++ b/plutus-ledger-api/src/PlutusLedgerApi/V1/Bytes.hs
@@ -28,12 +28,14 @@ import PlutusTx
 import PlutusTx.Prelude qualified as P
 import Prettyprinter.Extras (Pretty, PrettyShow (..))
 
+{- | An error that is encountered when converting a `ByteString` to a `LedgerBytes`. -}
 data LedgerBytesError =
-    UnpairedDigit
-    | NotHexit Char
+    UnpairedDigit -- ^ Odd number of bytes.
+    | NotHexit Char -- ^ Not a hex digit.
     deriving stock (Show)
     deriving anyclass (Exception)
 
+{- | Convert a hex encoded `ByteString` to a `LedgerBytes`. May return an error (`LedgerBytesError`). -}
 fromHex :: BS.ByteString -> Either LedgerBytesError LedgerBytes
 fromHex = fmap (LedgerBytes . P.toBuiltin) . asBSLiteral
     where
@@ -76,12 +78,17 @@ bytes = P.fromBuiltin . getLedgerBytes
 fromBytes :: BS.ByteString -> LedgerBytes
 fromBytes = LedgerBytes . P.toBuiltin
 
+{- | The `IsString` instance of `LedgerBytes` could throw an exception of `LedgerBytesError`. -}
 instance IsString LedgerBytes where
     fromString = unsafeFromEither . fromHex . fromString
 
+{- | The `Show` instance of `LedgerBytes` is its base16/hex encoded bytestring,
+decoded with UTF-8, unpacked to `String`. -}
 instance Show LedgerBytes where
     show = Text.unpack . encodeByteString . bytes
 
+{- | Encode a ByteString value in base16 (i.e. hexadecimal), then
+decode with UTF-8 to a `Text`. -}
 encodeByteString :: BS.ByteString -> Text.Text
 encodeByteString = TE.decodeUtf8 . Base16.encode
 
diff --git a/plutus-ledger-api/src/PlutusLedgerApi/V1/Contexts.hs b/plutus-ledger-api/src/PlutusLedgerApi/V1/Contexts.hs
index d064ae3ca52..e50ac12a147 100644
--- a/plutus-ledger-api/src/PlutusLedgerApi/V1/Contexts.hs
+++ b/plutus-ledger-api/src/PlutusLedgerApi/V1/Contexts.hs
@@ -227,7 +227,7 @@ pubKeyOutput :: TxOut -> Maybe PubKeyHash
 pubKeyOutput TxOut{txOutAddress} = toPubKeyHash txOutAddress
 
 {-# INLINABLE ownHashes #-}
--- | Get the validator and datum hashes of the output that is curently being validated
+-- | Get the validator and datum hashes of the output that is currently being validated
 ownHashes :: ScriptContext -> (ValidatorHash, DatumHash)
 ownHashes (findOwnInput -> Just TxInInfo{txInInfoResolved=TxOut{txOutAddress=Address (ScriptCredential s) _, txOutDatumHash=Just dh}}) = (s,dh)
 ownHashes _ = traceError "Lg" -- "Can't get validator and datum hashes"
diff --git a/plutus-ledger-api/src/PlutusLedgerApi/V1/Credential.hs b/plutus-ledger-api/src/PlutusLedgerApi/V1/Credential.hs
index a06e00b8017..7fafb451d70 100644
--- a/plutus-ledger-api/src/PlutusLedgerApi/V1/Credential.hs
+++ b/plutus-ledger-api/src/PlutusLedgerApi/V1/Credential.hs
@@ -17,15 +17,25 @@ import Control.DeepSeq (NFData)
 import GHC.Generics (Generic)
 import PlutusLedgerApi.V1.Crypto (PubKeyHash)
 import PlutusLedgerApi.V1.Scripts (ValidatorHash)
-import PlutusTx qualified as PlutusTx
+import PlutusTx qualified
 import PlutusTx.Bool qualified as PlutusTx
 import PlutusTx.Eq qualified as PlutusTx
 import Prettyprinter (Pretty (..), (<+>))
 
--- | Staking credential used to assign rewards
+-- | Staking credential used to assign rewards.
 data StakingCredential
+    -- | The staking hash is the `Credential` required to unlock a transaction output. Either
+    -- a public key credential (`Crypto.PubKeyHash`) or
+    -- a script credential (`Scripts.ValidatorHash`). Both are hashed with /BLAKE2b-244/. 28 byte.
     = StakingHash Credential
-    | StakingPtr Integer Integer Integer -- NB: The fields should really be Word64 / Natural / Natural, but 'Integer' is our only integral type so we need to use it instead.
+    -- | The certificate pointer, constructed by the given
+    -- slot number, transaction and certificate indices.
+    -- NB: The fields should really be all `Word64`, as they are implemented in `Word64`,
+    -- but 'Integer' is our only integral type so we need to use it instead.
+    | StakingPtr
+        Integer -- ^ the slot number
+        Integer -- ^ the transaction index (within the block)
+        Integer -- ^ the certificate index (within the transaction)
     deriving stock (Eq, Ord, Show, Generic)
     deriving anyclass (NFData)
 
@@ -42,10 +52,15 @@ instance PlutusTx.Eq StakingCredential where
         PlutusTx.&& c PlutusTx.== c'
     _ == _ = False
 
--- | Credential required to unlock a transaction output
+-- | Credentials required to unlock a transaction output.
 data Credential
-  = PubKeyCredential PubKeyHash -- ^ The transaction that spends this output must be signed by the private key
-  | ScriptCredential ValidatorHash -- ^ The transaction that spends this output must include the validator script and be accepted by the validator.
+  =
+    -- | The transaction that spends this output must be signed by the private key.
+    -- See `Crypto.PubKeyHash`.
+    PubKeyCredential PubKeyHash
+    -- | The transaction that spends this output must include the validator script and
+    -- be accepted by the validator. See `Scripts.ValidatorHash`.
+  | ScriptCredential ValidatorHash
     deriving stock (Eq, Ord, Show, Generic)
     deriving anyclass (NFData)
 
diff --git a/plutus-ledger-api/src/PlutusLedgerApi/V1/Crypto.hs b/plutus-ledger-api/src/PlutusLedgerApi/V1/Crypto.hs
index 997bdd63f35..f61ccce2071 100644
--- a/plutus-ledger-api/src/PlutusLedgerApi/V1/Crypto.hs
+++ b/plutus-ledger-api/src/PlutusLedgerApi/V1/Crypto.hs
@@ -18,11 +18,20 @@ import PlutusTx.Lift (makeLift)
 import PlutusTx.Prelude qualified as PlutusTx
 import Prettyprinter
 
--- | The hash of a public key. This is frequently used to identify the public key, rather than the key itself.
+{- | The hash of a public key. This is frequently used to identify the public key,
+rather than the key itself. Hashed with /BLAKE2b-224/. 28 bytes.
+
+This is a simple type without any validation, __use with caution__.
+You may want to add checks for its invariants. See the
+ [Shelley ledger specification](https://hydra.iohk.io/build/16861845/download/1/ledger-spec.pdf).
+-}
 newtype PubKeyHash = PubKeyHash { getPubKeyHash :: PlutusTx.BuiltinByteString }
     deriving stock (Eq, Ord, Generic)
     deriving anyclass (NFData)
     deriving newtype (PlutusTx.Eq, PlutusTx.Ord, PlutusTx.ToData, PlutusTx.FromData, PlutusTx.UnsafeFromData)
-    deriving IsString via LedgerBytes
-    deriving (Show, Pretty) via LedgerBytes
+    deriving
+        (IsString        -- ^ from hex encoding
+        , Show           -- ^ using hex encoding
+        , Pretty         -- ^ using hex encoding
+        ) via LedgerBytes
 makeLift ''PubKeyHash
diff --git a/plutus-ledger-api/src/PlutusLedgerApi/V1/DCert.hs b/plutus-ledger-api/src/PlutusLedgerApi/V1/DCert.hs
index df269922707..00ce3623030 100644
--- a/plutus-ledger-api/src/PlutusLedgerApi/V1/DCert.hs
+++ b/plutus-ledger-api/src/PlutusLedgerApi/V1/DCert.hs
@@ -15,7 +15,7 @@ import Control.DeepSeq (NFData)
 import GHC.Generics (Generic)
 import PlutusLedgerApi.V1.Credential (StakingCredential)
 import PlutusLedgerApi.V1.Crypto (PubKeyHash)
-import PlutusTx qualified as PlutusTx
+import PlutusTx qualified
 import PlutusTx.Prelude qualified as P
 import Prettyprinter.Extras
 
diff --git a/plutus-ledger-api/src/PlutusLedgerApi/V1/Scripts.hs b/plutus-ledger-api/src/PlutusLedgerApi/V1/Scripts.hs
index 551229643a3..b9b66e0f855 100644
--- a/plutus-ledger-api/src/PlutusLedgerApi/V1/Scripts.hs
+++ b/plutus-ledger-api/src/PlutusLedgerApi/V1/Scripts.hs
@@ -223,50 +223,104 @@ newtype StakeValidator = StakeValidator { getStakeValidator :: Script }
 instance Haskell.Show StakeValidator where
     show = const "StakeValidator { <script> }"
 
--- | Script runtime representation of a @Digest SHA256@.
+{- | Type representing the /BLAKE2b-224/ hash of a script. 28 bytes.
+
+This is a simple type without any validation, __use with caution__.
+You may want to add checks for its invariants. See the
+ [Shelley ledger specification](https://hydra.iohk.io/build/16861845/download/1/ledger-spec.pdf).
+-}
 newtype ScriptHash =
     ScriptHash { getScriptHash :: Builtins.BuiltinByteString }
-    deriving (IsString, Haskell.Show, Pretty) via LedgerBytes
+    deriving
+        (IsString        -- ^ from hex encoding
+        , Haskell.Show   -- ^ using hex encoding
+        , Pretty         -- ^ using hex encoding
+        ) via LedgerBytes
     deriving stock (Generic)
     deriving newtype (Haskell.Eq, Haskell.Ord, Eq, Ord, ToData, FromData, UnsafeFromData)
     deriving anyclass (NFData)
 
--- | Script runtime representation of a @Digest SHA256@.
+{- | Type representing the /BLAKE2b-224/ hash of a validator. 28 bytes.
+
+This is a simple type without any validation, __use with caution__.
+You may want to add checks for its invariants. See the
+ [Shelley ledger specification](https://hydra.iohk.io/build/16861845/download/1/ledger-spec.pdf).
+-}
 newtype ValidatorHash =
     ValidatorHash Builtins.BuiltinByteString
-    deriving (IsString, Haskell.Show, Pretty) via LedgerBytes
+    deriving
+        (IsString        -- ^ from hex encoding
+        , Haskell.Show   -- ^ using hex encoding
+        , Pretty         -- ^ using hex encoding
+        ) via LedgerBytes
     deriving stock (Generic)
     deriving newtype (Haskell.Eq, Haskell.Ord, Eq, Ord, ToData, FromData, UnsafeFromData)
     deriving anyclass (NFData)
 
--- | Script runtime representation of a @Digest SHA256@.
+{- | Type representing the /BLAKE2b-256/ hash of a datum. 32 bytes.
+
+This is a simple type without any validation, __use with caution__.
+You may want to add checks for its invariants. See the
+ [Shelley ledger specification](https://hydra.iohk.io/build/16861845/download/1/ledger-spec.pdf).
+-}
 newtype DatumHash =
     DatumHash Builtins.BuiltinByteString
-    deriving (IsString, Haskell.Show, Pretty) via LedgerBytes
+    deriving
+        (IsString        -- ^ from hex encoding
+        , Haskell.Show   -- ^ using hex encoding
+        , Pretty         -- ^ using hex encoding
+        ) via LedgerBytes
     deriving stock (Generic)
     deriving newtype (Haskell.Eq, Haskell.Ord, Eq, Ord, ToData, FromData, UnsafeFromData)
     deriving anyclass (NFData)
 
--- | Script runtime representation of a @Digest SHA256@.
+{- | Type representing the /BLAKE2b-256/ hash of a redeemer. 32 bytes.
+
+This is a simple type without any validation, __use with caution__.
+You may want to add checks for its invariants. See the
+ [Shelley ledger specification](https://hydra.iohk.io/build/16861845/download/1/ledger-spec.pdf).
+-}
 newtype RedeemerHash =
     RedeemerHash Builtins.BuiltinByteString
-    deriving (IsString, Haskell.Show, Pretty) via LedgerBytes
+    deriving
+        (IsString        -- ^ from hex encoding
+        , Haskell.Show   -- ^ using hex encoding
+        , Pretty         -- ^ using hex encoding
+        ) via LedgerBytes
     deriving stock (Generic)
     deriving newtype (Haskell.Eq, Haskell.Ord, Eq, Ord, ToData, FromData, UnsafeFromData)
     deriving anyclass (NFData)
 
--- | Script runtime representation of a @Digest SHA256@.
+{- | Type representing the /BLAKE2b-224/ hash of a minting policy. 28 bytes.
+
+This is a simple type without any validation, __use with caution__.
+You may want to add checks for its invariants. See the
+ [Shelley ledger specification](https://hydra.iohk.io/build/16861845/download/1/ledger-spec.pdf).
+-}
 newtype MintingPolicyHash =
     MintingPolicyHash Builtins.BuiltinByteString
-    deriving (IsString, Haskell.Show, Pretty) via LedgerBytes
+    deriving
+        (IsString        -- ^ from hex encoding
+        , Haskell.Show   -- ^ using hex encoding
+        , Pretty         -- ^ using hex encoding
+        ) via LedgerBytes
     deriving stock (Generic)
     deriving newtype (Haskell.Eq, Haskell.Ord, Eq, Ord, ToData, FromData, UnsafeFromData)
     deriving anyclass (NFData)
 
--- | Script runtime representation of a @Digest SHA256@.
+{- | Type representing the /BLAKE2b-224/ hash of a stake validator. 28 bytes.
+
+This is a simple type without any validation, __use with caution__.
+You may want to add checks for its invariants. See the
+ [Shelley ledger specification](https://hydra.iohk.io/build/16861845/download/1/ledger-spec.pdf).
+-}
 newtype StakeValidatorHash =
     StakeValidatorHash Builtins.BuiltinByteString
-    deriving (IsString, Haskell.Show, Pretty) via LedgerBytes
+    deriving
+        (IsString        -- ^ from hex encoding
+        , Haskell.Show   -- ^ using hex encoding
+        , Pretty         -- ^ using hex encoding
+        ) via LedgerBytes
     deriving stock (Generic)
     deriving newtype (Haskell.Eq, Haskell.Ord, Eq, Ord, ToData, FromData, UnsafeFromData)
     deriving anyclass (NFData)
diff --git a/plutus-ledger-api/src/PlutusLedgerApi/V1/Time.hs b/plutus-ledger-api/src/PlutusLedgerApi/V1/Time.hs
index bdde19b235a..a78e9daed82 100644
--- a/plutus-ledger-api/src/PlutusLedgerApi/V1/Time.hs
+++ b/plutus-ledger-api/src/PlutusLedgerApi/V1/Time.hs
@@ -35,7 +35,8 @@ newtype DiffMilliSeconds = DiffMilliSeconds Integer
 
 makeLift ''DiffMilliSeconds
 
--- | POSIX time is measured as the number of milliseconds since 1970-01-01T00:00:00Z
+-- | POSIX time is measured as the number of /milliseconds/ since 1970-01-01T00:00:00Z.
+-- This is not the same as Haskell's `Data.Time.Clock.POSIX.POSIXTime`
 newtype POSIXTime = POSIXTime { getPOSIXTime :: Integer }
   deriving stock (Haskell.Eq, Haskell.Ord, Haskell.Show, Generic)
   deriving anyclass (NFData)
diff --git a/plutus-ledger-api/src/PlutusLedgerApi/V1/Tx.hs b/plutus-ledger-api/src/PlutusLedgerApi/V1/Tx.hs
index 479d780c91e..39033d0ea8a 100644
--- a/plutus-ledger-api/src/PlutusLedgerApi/V1/Tx.hs
+++ b/plutus-ledger-api/src/PlutusLedgerApi/V1/Tx.hs
@@ -48,32 +48,41 @@ import PlutusLedgerApi.V1.Bytes
 import PlutusLedgerApi.V1.Crypto
 import PlutusLedgerApi.V1.Scripts
 import PlutusLedgerApi.V1.Value
+{- | A transaction ID, i.e. the hash of a transaction. Hashed with BLAKE2b-256. 32 byte.
 
--- | A transaction ID, using a SHA256 hash as the transaction id.
+This is a simple type without any validation, __use with caution__.
+You may want to add checks for its invariants. See the
+ [Shelley ledger specification](https://hydra.iohk.io/build/16861845/download/1/ledger-spec.pdf).
+-}
 newtype TxId = TxId { getTxId :: PlutusTx.BuiltinByteString }
     deriving stock (Eq, Ord, Generic)
     deriving anyclass (NFData)
     deriving newtype (PlutusTx.Eq, PlutusTx.Ord)
-    deriving (Show, Pretty, IsString) via LedgerBytes
+    deriving
+        (IsString        -- ^ from hex encoding
+        , Show           -- ^ using hex encoding
+        , Pretty         -- ^ using hex encoding
+        ) via LedgerBytes
 
 -- | A tag indicating the type of script that we are pointing to.
 data ScriptTag = Spend | Mint | Cert | Reward
     deriving stock (Show, Eq, Ord, Generic)
     deriving anyclass (NFData)
 
--- | A redeemer pointer is a pair of a script type tag t and an index i, picking out the ith
--- script of type t in the transaction.
+-- | A redeemer pointer is a pair of a script type tag ('ScriptTag') `t` and an index `i`,
+-- picking out the i-th script of type `t` in the transaction.
 data RedeemerPtr = RedeemerPtr ScriptTag Integer
     deriving stock (Show, Eq, Ord, Generic)
     deriving anyclass (NFData)
 
+-- | Redeemers is a `Map` of redeemer pointer ('RedeemerPtr') and its 'Redeemer'.
 type Redeemers = Map RedeemerPtr Redeemer
 
 -- | A reference to a transaction output. This is a
--- pair of a transaction reference, and an index indicating which of the outputs
+-- pair of a transaction ID (`TxId`), and an index indicating which of the outputs
 -- of that transaction we are referring to.
 data TxOutRef = TxOutRef {
-    txOutRefId  :: TxId,
+    txOutRefId  :: TxId, -- ^ The transaction ID.
     txOutRefIdx :: Integer -- ^ Index into the referenced transaction's outputs
     }
     deriving stock (Show, Eq, Ord, Generic)
@@ -87,8 +96,8 @@ instance PlutusTx.Eq TxOutRef where
     l == r =
         txOutRefId l PlutusTx.== txOutRefId r
         PlutusTx.&& txOutRefIdx l PlutusTx.== txOutRefIdx r
-
--- | A transaction output, consisting of a target address, a value, and optionally a datum hash.
+-- | A transaction output, consisting of a target address ('Address'), a value ('Value'),
+-- and optionally a datum hash ('DatumHash').
 data TxOut = TxOut {
     txOutAddress   :: Address,
     txOutValue     :: Value,
diff --git a/plutus-ledger-api/src/PlutusLedgerApi/V1/Value.hs b/plutus-ledger-api/src/PlutusLedgerApi/V1/Value.hs
index 55b3b0f5e70..75fbcedbc1a 100644
--- a/plutus-ledger-api/src/PlutusLedgerApi/V1/Value.hs
+++ b/plutus-ledger-api/src/PlutusLedgerApi/V1/Value.hs
@@ -53,36 +53,49 @@ import Prelude qualified as Haskell
 
 import Control.DeepSeq (NFData)
 import Data.ByteString qualified as BS
-import Data.Data
+import Data.Data (Data)
 import Data.String (IsString (fromString))
 import Data.Text (Text)
 import Data.Text qualified as Text
 import Data.Text.Encoding qualified as E
 import GHC.Generics (Generic)
 import PlutusLedgerApi.V1.Bytes (LedgerBytes (LedgerBytes), encodeByteString)
-import PlutusLedgerApi.V1.Scripts
-import PlutusTx qualified as PlutusTx
+import PlutusLedgerApi.V1.Scripts (MintingPolicyHash (..))
+import PlutusTx qualified
 import PlutusTx.AssocMap qualified as Map
 import PlutusTx.Lift (makeLift)
 import PlutusTx.Ord qualified as Ord
 import PlutusTx.Prelude as PlutusTx hiding (sort)
-import PlutusTx.These
-import Prettyprinter
-import Prettyprinter.Extras
-
+import PlutusTx.These (These (..))
+import Prettyprinter (Pretty, (<>))
+import Prettyprinter.Extras (PrettyShow (PrettyShow))
+
+{- | ByteString representing the currency, hashed with /BLAKE2b-224/.
+It is empty for `Ada`, 28 bytes for `MintingPolicyHash`.
+Forms an `AssetClass` along with `TokenName`.
+A `Value` is a map from `CurrencySymbol`'s to a map from `TokenName` to an `Integer`.
+
+This is a simple type without any validation, __use with caution__.
+You may want to add checks for its invariants. See the
+ [Shelley ledger specification](https://hydra.iohk.io/build/16861845/download/1/ledger-spec.pdf).
+-}
 newtype CurrencySymbol = CurrencySymbol { unCurrencySymbol :: PlutusTx.BuiltinByteString }
-    deriving (IsString, Haskell.Show, Pretty) via LedgerBytes
+    deriving
+        (IsString        -- ^ from hex encoding
+        , Haskell.Show   -- ^ using hex encoding
+        , Pretty         -- ^ using hex encoding
+        ) via LedgerBytes
     deriving stock (Generic, Data)
     deriving newtype (Haskell.Eq, Haskell.Ord, Eq, Ord, PlutusTx.ToData, PlutusTx.FromData, PlutusTx.UnsafeFromData)
     deriving anyclass (NFData)
 
 {-# INLINABLE mpsSymbol #-}
--- | The currency symbol of a monetary policy hash
+-- | The `CurrencySymbol` of a monetary policy hash
 mpsSymbol :: MintingPolicyHash -> CurrencySymbol
 mpsSymbol (MintingPolicyHash h) = CurrencySymbol h
 
 {-# INLINABLE currencyMPSHash #-}
--- | The minting policy hash of a currency symbol
+-- | The minting policy hash of a `CurrencySymbol`.
 currencyMPSHash :: CurrencySymbol -> MintingPolicyHash
 currencyMPSHash (CurrencySymbol h) = MintingPolicyHash h
 
@@ -91,18 +104,27 @@ currencyMPSHash (CurrencySymbol h) = MintingPolicyHash h
 currencySymbol :: BS.ByteString -> CurrencySymbol
 currencySymbol = CurrencySymbol . PlutusTx.toBuiltin
 
--- | ByteString of a name of a token, shown as UTF-8 string when possible
+{- | ByteString of a name of a token.
+Shown as UTF-8 string when possible.
+Should be no longer than 32 bytes, empty for Ada.
+Forms an `AssetClass` along with a `CurrencySymbol`.
+
+This is a simple type without any validation, __use with caution__.
+You may want to add checks for its invariants. See the
+ [Shelley ledger specification](https://hydra.iohk.io/build/16861845/download/1/ledger-spec.pdf).
+-}
 newtype TokenName = TokenName { unTokenName :: PlutusTx.BuiltinByteString }
     deriving stock (Generic, Data)
     deriving newtype (Haskell.Eq, Haskell.Ord, Eq, Ord, PlutusTx.ToData, PlutusTx.FromData, PlutusTx.UnsafeFromData)
     deriving anyclass (NFData)
     deriving Pretty via (PrettyShow TokenName)
 
+-- | UTF-8 encoding. Doesn't verify length.
 instance IsString TokenName where
     fromString = fromText . Text.pack
 
 {-# INLINABLE tokenName #-}
--- | Creates `TokenName` from raw `ByteString`.
+-- | Creates `TokenName` from raw `BS.ByteString`.
 tokenName :: BS.ByteString -> TokenName
 tokenName = TokenName . PlutusTx.toBuiltin
 
@@ -112,9 +134,11 @@ fromText = tokenName . E.encodeUtf8
 fromTokenName :: (BS.ByteString -> r) -> (Text -> r) -> TokenName -> r
 fromTokenName handleBytestring handleText (TokenName bs) = either (\_ -> handleBytestring $ PlutusTx.fromBuiltin bs) handleText $ E.decodeUtf8' (PlutusTx.fromBuiltin bs)
 
+-- | Encode a `ByteString` to a hex `Text`.
 asBase16 :: BS.ByteString -> Text
 asBase16 bs = Text.concat ["0x", encodeByteString bs]
 
+-- | Wrap the input `Text` in double quotes.
 quoted :: Text -> Text
 quoted s = Text.concat ["\"", s, "\""]
 
@@ -134,7 +158,7 @@ adaSymbol = CurrencySymbol emptyByteString
 adaToken :: TokenName
 adaToken = TokenName emptyByteString
 
--- | An asset class, identified by currency symbol and token name.
+-- | An asset class, identified by a `CurrencySymbol` and a `TokenName`.
 newtype AssetClass = AssetClass { unAssetClass :: (CurrencySymbol, TokenName) }
     deriving stock (Generic, Data)
     deriving newtype (Haskell.Eq, Haskell.Ord, Haskell.Show, Eq, Ord, PlutusTx.ToData, PlutusTx.FromData, PlutusTx.UnsafeFromData)
@@ -145,21 +169,27 @@ newtype AssetClass = AssetClass { unAssetClass :: (CurrencySymbol, TokenName) }
 assetClass :: CurrencySymbol -> TokenName -> AssetClass
 assetClass s t = AssetClass (s, t)
 
--- | A cryptocurrency value. This is a map from 'CurrencySymbol's to a
--- quantity of that currency.
---
--- Operations on currencies are usually implemented /pointwise/. That is,
--- we apply the operation to the quantities for each currency in turn. So
--- when we add two 'Value's the resulting 'Value' has, for each currency,
--- the sum of the quantities of /that particular/ currency in the argument
--- 'Value'. The effect of this is that the currencies in the 'Value' are "independent",
--- and are operated on separately.
---
--- Whenever we need to get the quantity of a currency in a 'Value' where there
--- is no explicit quantity of that currency in the 'Value', then the quantity is
--- taken to be zero.
---
--- See note [Currencies] for more details.
+{- | The 'Value' type represents a collection of amounts of different currencies.
+We can think of 'Value' as a vector space whose dimensions are currencies.
+To create a value of 'Value', we need to specify a currency. This can be done
+using 'Ledger.Ada.adaValueOf'. To get the ada dimension of 'Value' we use
+'Ledger.Ada.fromValue'. Plutus contract authors will be able to define modules
+similar to 'Ledger.Ada' for their own currencies.
+
+Operations on currencies are usually implemented /pointwise/. That is,
+we apply the operation to the quantities for each currency in turn. So
+when we add two 'Value's the resulting 'Value' has, for each currency,
+the sum of the quantities of /that particular/ currency in the argument
+'Value'. The effect of this is that the currencies in the 'Value' are "independent",
+and are operated on separately.
+
+Whenever we need to get the quantity of a currency in a 'Value' where there
+is no explicit quantity of that currency in the 'Value', then the quantity is
+taken to be zero.
+
+There is no 'Ord Value' instance since 'Value' is only a partial order, so 'compare' can't
+do the right thing in some cases.
+ -}
 newtype Value = Value { getValue :: Map.Map CurrencySymbol (Map.Map TokenName Integer) }
     deriving stock (Generic, Data, Haskell.Show)
     deriving anyclass (NFData)
@@ -173,9 +203,6 @@ instance Eq Value where
     {-# INLINABLE (==) #-}
     (==) = eq
 
--- No 'Ord Value' instance since 'Value' is only a partial order, so 'compare' can't
--- do the right thing in some cases.
-
 instance Haskell.Semigroup Value where
     (<>) = unionWith (+)
 
@@ -210,24 +237,6 @@ instance MeetSemiLattice Value where
     {-# INLINABLE (/\) #-}
     (/\) = unionWith Ord.min
 
-{- note [Currencies]
-
-The 'Value' type represents a collection of amounts of different currencies.
-
-We can think of 'Value' as a vector space whose dimensions are
-currencies. At the moment there is only a single currency (Ada), so 'Value'
-contains one-dimensional vectors. When currency-creating transactions are
-implemented, this will change and the definition of 'Value' will change to a
-'Map Currency Int', effectively a vector with infinitely many dimensions whose
-non-zero values are recorded in the map.
-
-To create a value of 'Value', we need to specifiy a currency. This can be done
-using 'Ledger.Ada.adaValueOf'. To get the ada dimension of 'Value' we use
-'Ledger.Ada.fromValue'. Plutus contract authors will be able to define modules
-similar to 'Ledger.Ada' for their own currencies.
-
--}
-
 {-# INLINABLE valueOf #-}
 -- | Get the quantity of the given currency in the 'Value'.
 valueOf :: Value -> CurrencySymbol -> TokenName -> Integer
diff --git a/plutus-tx/src/PlutusTx/IsData/Class.hs b/plutus-tx/src/PlutusTx/IsData/Class.hs
index 641c0b3da55..bad57b322d2 100644
--- a/plutus-tx/src/PlutusTx/IsData/Class.hs
+++ b/plutus-tx/src/PlutusTx/IsData/Class.hs
@@ -46,6 +46,8 @@ class UnsafeFromData (a :: Type) where
     --
     -- When implementing this function, make sure to call 'unsafeFromBuiltinData'
     -- rather than 'fromBuiltinData' when converting substructures!
+    --
+    -- This is a simple type without any validation, __use with caution__.
     unsafeFromBuiltinData :: BuiltinData -> a
 
 instance ToData BuiltinData where