mfmts 1.2.0.0 → 1.2.0.1

raw patch · 14 files changed

+153/−158 lines, 14 filesdep ~xcodecPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: xcodec

API changes (from Hackage documentation)

Files

• CHANGELOG.md +5/−0
• README.md +53/−63
• cid/MultiFormats/CID.hs +12/−12
• cid/MultiFormats/CID/Component/Codec.hs +2/−2
• cid/MultiFormats/CID/Component/Decoder.hs +3/−3
• cid/MultiFormats/CID/Component/Hash.hs +8/−8
• cid/MultiFormats/CID/Component/Version.hs +9/−9
• cid/MultiFormats/CID/Extractor.hs +5/−5
• mfmts.cabal +2/−2
• multibase/MultiFormats/MultiBase/DigitSystems.hs +19/−19
• multibase/MultiFormats/MultiBase/DigitTranscoder.hs +17/−17
• multicodec/MultiFormats/MultiCodec.hs +1/−1
• multihash/MultiFormats/MultiHash.hs +1/−1
• varint/MultiFormats/VarInt.hs +16/−16

@@ -4,6 +4,11 @@ Major release 1.2 ----------------- +## Version 1.2.0.1 (07-21-26)++This upgrade applies the changes made by the XCodec v2.0 update, and upgrades+all the modules effected.+ ## Version 1.2.0.0 (07-08-26)  This version introduces the new XCodec changes and renames modules to match the

@@ -6,16 +6,19 @@ ---------------------------------------------------------------  This project implements the specifications described by Protocol Lab's-[multiformats](https://github.com/multiformats/multiformats) written in Haskell.+[multiformats](https://github.com/multiformats/multiformats) written in Haskell,+and split across several directories described below. -`cid` - Content identitiers for hashed data+`cid` - Content identifiers for hashed data ------------------------------------------- -Provides functionality for the multiformats CID binary format. These modules-provide parsing CIDs from multibase prefixed digit strings, extracting CID data+Provides functionality for the multiformats [CID](+https://github.com/multiformats/cid) binary format. These modules provide+parsing CIDs from multibase prefixed digit strings, extracting CID data from byte strings and serializing CIDs stored in memory into its binary format. -CID GitHub README example in GHCI:+Multiformats CID GitHub [README example](+https://github.com/multiformats/cid#variant---human-readable-form) in GHCI: ```haskell λ> {-# LANGUAGE OverloadedStrings #-} λ> import MultiFormats.CID (CID)@@ -25,23 +28,17 @@ Right CIDv1(DataCodec=MultiCodec(raw=0x55), HashCodec=MultiHash(sha2-256=0x12), HashDigest[32]=0x6e6ff7950a36187a801613426e858dce686cd7d7e3c0fc42ee0330072d245c95) ``` -- CID specification - [https://github.com/multiformats/cid](-https://github.com/multiformats/cid)-- CID example from README - [-https://github.com/multiformats/cid#variant---human-readable-form](-https://github.com/multiformats/cid#variant---human-readable-form)-- Official IPFS Golang implementation - [https://github.com/ipfs/go-cid](-https://github.com/ipfs/go-cid)- `multibase` - Multibase prefix data transcoding ----------------------------------------------- -Implements encoders and decoders for numeric basesystems identified by a-specified prefix symbol. It implements transcoders from the [basesystems](-https://git.sr.ht/~z0/basesystems) library, allowing for different types of-bytestring data to be specified as type parameters.+Implements [multibase](https://github.com/multiformats/multibase) encoders and+decoders for numeric basesystems identified by a specified prefix symbol. It+uses `Transcoders` from the [xcodec](https://git.sr.ht/~z0/xcodec) library,+allowing for different types of bytestring data to be specified as type+parameters. -Multibase GitHub README example in GHCI:+Multibase GitHub [README example](+https://github.com/multiformats/multibase#multibase-by-example) in GHCI: ```haskell λ> {-# LANGUAGE OverloadedStrings #-} λ> import MultiFormats.MultiBase.DigitTranscoder (decodeFromPrefix)@@ -63,20 +60,16 @@ Just "Multibase is awesome! \\o/" ``` -- Multibase specification - [https://github.com/multiformats/multibase](-https://github.com/multiformats/multibase)-- Multibase example - [-https://github.com/multiformats/multibase#multibase-by-example](-https://github.com/multiformats/multibase#multibase-by-example)- `multicodec` - Magic number specifications ------------------------------------------  Provides lookup table and query functions for codecs defined from multiformats-multicodec. These are magic numbers that represent certain data encoded within-CIDs, mulithash and other related projects. This module has code which-is generated by a python script in the [ipfshs](https://todo.sr.ht/~z0/ipfshs)-repo, and is automatically generated from CSV.+[multicodec](https://github.com/multiformats/multicodec). These are magic+number identifiers that represent certain data encoded within CIDs, mulithash+and other related projects. This module is generated by a Python script in the+[ipfshs](https://todo.sr.ht/~z0/ipfshs) repo by using the [CSV file](+https://github.com/multiformats/multicodec/blob/master/table.csv) provided from+the multicodec GitHub.  Example of looking up codecs: ```haskell@@ -91,19 +84,14 @@ Nothing ``` -- Multicodec specification - [https://github.com/multiformats/multicodec](-https://github.com/multiformats/multicodec)-- Multicodec value table - [-https://github.com/multiformats/multicodec/blob/master/table.csv](-https://github.com/multiformats/multicodec/blob/master/table.csv)- `multihash` - Multicodec hash function identifiers -------------------------------------------------- -Multihashes are a type of multicodec for identifying hash functions. This-code provides a lookup table for hash functions from the multicodec module, and-a way to get hash digests from specific functions over bytestrings, and to-verify multicodec values as valid multihash codecs.+[Multihashes](https://github.com/multiformats/multihash) are a type of+multicodec for identifying hash functions. This module provides a lookup table+for hash functions from the multicodec module, a way to get hash digests from+specific functions over bytestrings, and to verify multicodec values as valid+multihash codecs.  Example of looking up hash functions and applying them: ```haskell@@ -126,37 +114,30 @@ "7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069" ``` -- Multihash specification - [https://github.com/multiformats/multihash](-https://github.com/multiformats/multihash)-- Multiformat's Golang implementation - [-https://github.com/multiformats/go-multihash](-https://github.com/multiformats/go-multihash)- `varint` - Unsigned variable length integers -------------------------------------------- -Provides parsing and serialization for multiformats unsigned binary varints,-with the special caveat from multiformats that requires them always to be-minimally encoded, so this project also verifies that the varint inputs comply-with the rules of the multiformats specification.+Provides parsing and serialization for unsigned binary varints, with the caveat+from the multiformats specification that requires them always to be minimally+encoded. -Varint GitHub README example in GHCI using `packValue` from the [basesystems](-https://git.sr.ht/~z0/basesystems) library to transfer constants into-bytestrings. We can then use `extractVarInt` to get the varint representation-from the bytes:+Varint GitHub [README example](https://github.com/multiformats/unsigned-varint)+in GHCI using `packValue` from the [xcodec](https://git.sr.ht/~z0/xcodec)+library to transfer constants into bytestrings. We can then use `extractVarInt`+to get the varint representation from the bytes: ```haskell-λ> import Data.BaseSystem.BinaryTranscoder (packValue) λ> import Data.ByteString.Short (ShortByteString) λ> import MultiFormats.VarInt (VarInt, extractVarInt) λ> import MultiFormats.VarInt.Errors qualified as VarInt-λ> -- Make alias so we don't get type warnings+λ> import XCodec.Transcoder (packValue)+λ> -- Alias to suppress type warnings λ> let packInteger x = packValue (x :: Integer) λ> -- 7-bit values fit into 1 byte: λ> extractVarInt (packInteger 0x01) :: VarInt.Okay (VarInt, ShortByteString) Right (1,"") λ> extractVarInt (packInteger 0x7f) :: VarInt.Okay (VarInt, ShortByteString) Right (127,"")-λ> -- 8-bit and larger values have their MSB set until a zero MSB byte is found:+λ> -- 8-bit and larger values have MSB=1 until a byte with MSB=0 is found: λ> extractVarInt (packInteger 0x8001) :: VarInt.Okay (VarInt, ShortByteString) Right (128,"") λ> extractVarInt (packInteger 0xff01) :: VarInt.Okay (VarInt, ShortByteString)@@ -167,22 +148,31 @@ Right (16384,"") ``` -- Varint specification - [https://github.com/multiformats/unsigned-varint](-https://github.com/multiformats/unsigned-varint)- Development ----------- -Unit tests are provided on the main [ipfshs repo](https://git.sr.ht/~z0/ipfshs),-and bugs can be reported on [ipfshs ticket tracker](-https://todo.sr.ht/~z0/ipfshs).+This project is part of [ipfshs](https://sr.ht/~z0/ipfshs); unit tests are+provided on the main page and bugs can be reported on its [ticket tracker](+https://todo.sr.ht/~z0/ipfshs). Patches and pull requests can be submitted with+[`git send-email`](https://git-send-email.io/). To build and test this project+against all of ipfshs read [this](https://sr.ht/~z0/ipfshs/#development)+section on setting up an ipfshs development environment. +This project can also be built as a standalone library with [`cabal`](+https://github.com/haskell/cabal#ways-to-get-the-cabal-install-binary).++```shell+$ git clone https://git.sr.ht/~z0/mfmts+$ cd mfmts+$ cabal build+```+ Licensing --------- -The `mfmts` project and its modules are free software and licensed under the+The mfmts project and its modules are free software and licensed under the [AGPLv3](https://www.gnu.org/licenses/agpl-3.0.en.html) license. See-[LICENSE.txt](LICENSE.txt).+[`LICENSE.txt`](LICENSE.txt).  Copyright © 2026 Zoey McBride | [zoeymcbride@mailbox.org]( mailto:zoeymcbride@mailbox.org)

@@ -28,8 +28,6 @@ import Data.List (intercalate) import Data.Maybe (fromJust) import Data.Text qualified as Text-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)-import Data.XCodec.BinaryTranscoder qualified as BXC import MultiFormats.CID.Component.Codec qualified as CID import MultiFormats.CID.Component.Decoder qualified as CID import MultiFormats.CID.Component.Hash qualified as CID@@ -43,6 +41,8 @@ import MultiFormats.MultiCodec (MultiCodec (..), resolveMultiCodec) import MultiFormats.MultiHash (MultiHash (..), resolveMultiHash) import MultiFormats.VarInt (VarInt)+import XCodec.Transcoder (Transcoder)+import XCodec.Transcoder qualified as XC  -- | Defines the data-type for CID data. data CID = CID@@ -113,18 +113,18 @@ -- encoded string. Fails when there is extra bytes past the CID. instance Parser CID where   parser cidstr = do-    -- Decode to bytes based on the String's encoding. Use SBS as BXC because+    -- Decode to bytes based on the String's encoding. Use SBS as XC because     -- the bytestring is discarded after this function.     CID.Decoder cidbytes <- parser cidstr :: Okay (CID.Decoder ShortByteString)     -- Extracts the CID's data from bytes.     (cid, trailing) <- extractor cidbytes     -- Fail if there is any leftovers. Otherwise fully evaluate the CID.-    if BXC.totalOctets trailing > 0+    if XC.totalOctets trailing > 0       then Left (InvalidData TrailingBytes)       else Right $!! cid  -- | Extracts a CID from a ByteString. Allows trailing bytes.-instance (BinaryTranscoder t) => Extractor CID t where+instance (Transcoder tc) => Extractor CID tc where   extractor bytes = do     -- First, extract the version from bytes     (version, rest) <- extractor bytes@@ -135,18 +135,18 @@       CIDv1 -> extractCIDv1 rest  -- | Applies the extraction after version# for CIDv0 was extracted.-extractCIDv0 :: (BinaryTranscoder t) => Extraction CID t+extractCIDv0 :: (Transcoder tc) => Extraction CID tc extractCIDv0 ondata   -- Fail if there isn't enough bytes   | totalbytes /= CID.v0HashBytes = Left (InvalidHash IncorrectLength)   -- Create the CIDv0 from data   | otherwise = Right (mkCIDv0 ciddata, rest)   where-    totalbytes = BXC.totalOctets ondata-    (ciddata, rest) = BXC.splitOffset CID.v0HashBytes ondata+    totalbytes = XC.totalOctets ondata+    (ciddata, rest) = XC.splitOffset CID.v0HashBytes ondata  -- | Applies the extraction after version# for CIDv1 was extracted.-extractCIDv1 :: (BinaryTranscoder t) => Extraction CID t+extractCIDv1 :: (Transcoder tc) => Extraction CID tc extractCIDv1 oncodec = do   -- Extract the 1st MultiCodec from the bytes.   (CID.Codec multicodec, onhash) <- extractor oncodec@@ -190,16 +190,16 @@  -- | Provides the contructor for CIDv0s, see: -- https://github.com/multiformats/cid?tab=readme-ov-file#cidv0-mkCIDv0 :: (BinaryTranscoder t) => t -> CID+mkCIDv0 :: (Transcoder tc) => tc -> CID mkCIDv0 digest =   CID     { cidVersion = CIDv0,       cidDataCodec = codec "dag-pb",       cidHashCodec = hash "sha2-256",       cidHashSize = varlen digest,-      cidHashBuilder = BXC.unpackSerial digest+      cidHashBuilder = XC.unpackBuilder digest     }   where     codec str = fromJust $!! resolveMultiCodec str     hash str = fromJust $!! resolveMultiHash str-    varlen bxc = fromIntegral $! BXC.totalOctets bxc+    varlen xc = fromIntegral $! XC.totalOctets xc

@@ -8,7 +8,7 @@  import Control.DeepSeq (NFData (..), force) import Data.Bifunctor (first)-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)+import XCodec.Transcoder (Transcoder) import MultiFormats.CID.Extractor (Extractor (extractor)) import MultiFormats.MultiCodec (MultiCodec (MultiCodec)) @@ -20,5 +20,5 @@   rnf (Codec mc) = rnf mc  -- | Extracts the MultiCodec from VarInt in bytes and wraps in Codec.-instance (BinaryTranscoder t) => Extractor Codec t where+instance (Transcoder tc) => Extractor Codec tc where   extractor bytes = first (force . Codec . MultiCodec) <$> extractor bytes

@@ -7,18 +7,18 @@ module MultiFormats.CID.Component.Decoder (Decoder (Decoder)) where  import Data.Text qualified as Text-import Data.XCodec.BinaryTranscoder (BinaryTranscoder) import MultiFormats.CID.Component.Version (isTextCIDv0) import MultiFormats.CID.Errors import MultiFormats.CID.Parser import MultiFormats.MultiBase.DigitTranscoder (hasValidPrefix) import MultiFormats.MultiBase.DigitTranscoder qualified as DXC+import XCodec.Transcoder (Transcoder)  -- | Implements decoding CID from String's base encoding.-newtype Decoder b = Decoder b+newtype Decoder t = Decoder t  -- | Decodes a CID to bytes.-instance (BinaryTranscoder b) => Parser (Decoder b) where+instance (Transcoder tc) => Parser (Decoder tc) where   parser str =     let choosedecoder           | Text.null str = Left (InvalidData EmptyCID)

@@ -6,16 +6,16 @@ --   Stability   : experimental module MultiFormats.CID.Component.Hash (Hash (Hash)) where -import Control.DeepSeq (force, NFData (..))+import Control.DeepSeq (NFData (..), force)+import Data.Bifunctor (first) import Data.ByteString.Builder (Builder)-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)-import Data.XCodec.BinaryTranscoder qualified as BXC import MultiFormats.CID.Component.Codec qualified as CID import MultiFormats.CID.Errors import MultiFormats.CID.Extractor (Extractor (extractor)) import MultiFormats.MultiHash (MultiHash, resolveHashCodec) import MultiFormats.VarInt (VarInt)-import Data.Bifunctor (first)+import XCodec.Transcoder (Transcoder)+import XCodec.Transcoder qualified as XC  data Hash = Hash   { -- | Stores the MultiCodec for the hash function used.@@ -32,7 +32,7 @@  -- | Extracts the MultiHash codec and hash digest via a varint size following -- the MultiHash codec.-instance (BinaryTranscoder t) => Extractor Hash t where+instance (Transcoder tc) => Extractor Hash tc where   extractor bytes = do     -- Get the CodecCode from the first varint     (CID.Codec codec, onsize) <- extractor bytes@@ -43,13 +43,13 @@     case resolveHashCodec codec of       Nothing -> Left (InvalidHash $ UnknownHashCodec codec)       Just hash-        | isize < BXC.totalOctets ondigest -> Left (InvalidHash IncorrectLength)+        | isize < XC.totalOctets ondigest -> Left (InvalidHash IncorrectLength)         | otherwise -> Right $ extractHashDigest hash usize ondigest         where           -- Gets the varint size as generic integral type           isize = fromIntegral usize           -- Extracts the hash data from the bytes           extractHashDigest !multihash !size rest =-            let (hashdata, final) = BXC.splitOffset isize rest-                hashbuilder = BXC.unpackSerial hashdata+            let (hashdata, final) = XC.splitOffset isize rest+                hashbuilder = XC.unpackBuilder hashdata              in first force (Hash multihash size hashbuilder, final)

@@ -20,11 +20,11 @@ import Control.DeepSeq (NFData (..)) import Data.Text (Text) import Data.Text qualified as Text-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)-import Data.XCodec.BinaryTranscoder qualified as BXC import MultiFormats.CID.Constants import MultiFormats.CID.Errors import MultiFormats.CID.Extractor (Extraction, Extractor (extractor))+import XCodec.Transcoder (Transcoder)+import XCodec.Transcoder qualified as XC  -- | Implements available CID versions. data Version = CIDv0 | CIDv1 deriving (Show, Eq, Enum)@@ -34,9 +34,9 @@   rnf _ = ()  -- | Extracts and validates the CID versioning information from bytes.-instance (BinaryTranscoder t) => Extractor Version t where+instance (Transcoder tc) => Extractor Version tc where   extractor cidbytes =-    case BXC.uncons cidbytes of+    case XC.uncons cidbytes of       Nothing -> Left (InvalidData EmptyCID)       Just (magic, _)         -- Only CIDv0 will start with 0x12, and it must be followed w/ a@@ -47,7 +47,7 @@         | otherwise -> extractVersion1 cidbytes  -- | Performs extraction for CIDv1.-extractVersion1 :: (BinaryTranscoder t) => Extraction Version t+extractVersion1 :: (Transcoder tc) => Extraction Version tc extractVersion1 bytes =   extractor bytes >>= \(varint1, rest) ->     if invalidCIDv1 varint1@@ -57,11 +57,11 @@     invalidCIDv1 v1 = v1 /= v1FirstVarInt  -- | Performs extraction for CIDv0.-extractVersion0 :: (BinaryTranscoder t) => Extraction Version t+extractVersion0 :: (Transcoder tc) => Extraction Version tc extractVersion0 ciddata =-  let (lead, rest) = BXC.splitOffset 2 ciddata-      total = BXC.totalOctets ciddata-   in case BXC.unpackOctets lead of+  let (lead, rest) = XC.splitOffset 2 ciddata+      total = XC.totalOctets ciddata+   in case XC.unpackOctets lead of         [b1, b2]           | invalidCIDv0 b1 b2 total -> Left (InvalidEncoding MalformedCIDv0)           | otherwise -> Right (CIDv0, rest)

@@ -14,21 +14,21 @@   ) where -import Data.Bifunctor (first) import Control.DeepSeq (force)-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)+import Data.Bifunctor (first) import MultiFormats.CID.Errors import MultiFormats.VarInt (VarInt, extractVarInt)+import XCodec.Transcoder (Transcoder)  -- | Alias for `extractor` method. Extracts `a` from ByteString. type Extraction a t = t -> Okay (a, t)  -- | Generic function signature for extracting CID components.-class (BinaryTranscoder t) => Extractor a t where-  extractor :: t -> Okay (a, t)+class (Transcoder tc) => Extractor a tc where+  extractor :: tc -> Okay (a, tc)  -- | Extractor for VarInts in CID data. Converts VarInt.Error to CID.Error.-instance (BinaryTranscoder t) => Extractor VarInt t where+instance (Transcoder tc) => Extractor VarInt tc where   extractor =     -- Either reconstruct the either or strictly evaulate into the context.     either (Left . InvalidVarInt) (Right . first force) . extractVarInt

@@ -1,5 +1,5 @@ cabal-version: 3.0-version:       1.2.0.0+version:       1.2.0.1 name:          mfmts build-type:    Simple author:        Zoey McBride@@ -39,7 +39,7 @@     build-depends:         base >= 4.18 && < 5,         basesystems ^>= 1.2,-        xcodec ^>= 1.1,+        xcodec ^>= 2.0,         text >= 2.1 && < 2.2,         array ^>= 0.5,         bytestring ^>= 0.12,

@@ -26,77 +26,77 @@ where  import Data.Maybe (fromJust)-import Data.XCodec.BinaryTranscoder (BinaryTranscoder) import MultiFormats.MultiBase.DigitTranscoder (MultiBase, resolvePrefix)+import XCodec.Transcoder (Transcoder)  -- | Creates the multibase from Char, and crashes if Char is an invalid prefix.-mk :: (BinaryTranscoder bxc) => Char -> MultiBase bxc+mk :: (Transcoder tc) => Char -> MultiBase tc mk = fromJust . resolvePrefix  -- | Binary has prefix "0".-multibase2 :: (BinaryTranscoder bxc) => MultiBase bxc+multibase2 :: (Transcoder tc) => MultiBase tc multibase2 = mk '0'  -- | Decimal has prefix "9".-multibase10 :: (BinaryTranscoder bxc) => MultiBase bxc+multibase10 :: (Transcoder tc) => MultiBase tc multibase10 = mk '9'  -- | Hex-lower has prefix "f".-multibase16lower :: (BinaryTranscoder bxc) => MultiBase bxc+multibase16lower :: (Transcoder tc) => MultiBase tc multibase16lower = mk 'f'  -- | Hex-upper has prefix "F".-multibase16upper :: (BinaryTranscoder bxc) => MultiBase bxc+multibase16upper :: (Transcoder tc) => MultiBase tc multibase16upper = mk 'F'  -- | base32lower (no pad) has prefix "b".-multibase32lowerNP :: (BinaryTranscoder bxc) => MultiBase bxc+multibase32lowerNP :: (Transcoder tc) => MultiBase tc multibase32lowerNP = mk 'b'  -- | base32uppper (no pad) has prefix "B".-multibase32upperNP :: (BinaryTranscoder bxc) => MultiBase bxc+multibase32upperNP :: (Transcoder tc) => MultiBase tc multibase32upperNP = mk 'B'  -- | base32lower (with pad) has prefix "c".-multibase32lower :: (BinaryTranscoder bxc) => MultiBase bxc+multibase32lower :: (Transcoder tc) => MultiBase tc multibase32lower = mk 'c'  -- | base32upper (with pad) has prefix "C".-multibase32upper :: (BinaryTranscoder bxc) => MultiBase bxc+multibase32upper :: (Transcoder tc) => MultiBase tc multibase32upper = mk 'C'  -- | Hex-base32lower (no pad) has prefix "v".-multibase32hexlowerNP :: (BinaryTranscoder bxc) => MultiBase bxc+multibase32hexlowerNP :: (Transcoder tc) => MultiBase tc multibase32hexlowerNP = mk 'v'  -- | Hex-base32upper (no pad) has prefix "V".-multibase32hexupperNP :: (BinaryTranscoder bxc) => MultiBase bxc+multibase32hexupperNP :: (Transcoder tc) => MultiBase tc multibase32hexupperNP = mk 'V'  -- | Hex-base32lower (with pad) has prefix "t".-multibase32hexlower :: (BinaryTranscoder bxc) => MultiBase bxc+multibase32hexlower :: (Transcoder tc) => MultiBase tc multibase32hexlower = mk 't'  -- | Hex-base32upper (with pad) has prefix "T".-multibase32hexupper :: (BinaryTranscoder bxc) => MultiBase bxc+multibase32hexupper :: (Transcoder tc) => MultiBase tc multibase32hexupper = mk 'T'  -- | Bitcoin base58 has prefix "z".-multibase58btc :: (BinaryTranscoder bxc) => MultiBase bxc+multibase58btc :: (Transcoder tc) => MultiBase tc multibase58btc = mk 'z'  -- | base64 (no pad) has prefix "m".-multibase64NP :: (BinaryTranscoder bxc) => MultiBase bxc+multibase64NP :: (Transcoder tc) => MultiBase tc multibase64NP = mk 'm'  -- | base64 (with pad) has prefix "M".-multibase64 :: (BinaryTranscoder bxc) => MultiBase bxc+multibase64 :: (Transcoder tc) => MultiBase tc multibase64 = mk 'M'  -- | base64url (no pad) has prefix "u".-multibase64urlNP :: (BinaryTranscoder bxc) => MultiBase bxc+multibase64urlNP :: (Transcoder tc) => MultiBase tc multibase64urlNP = mk 'u'  -- | base64url (with pad) has prefix "U".-multibase64url :: (BinaryTranscoder bxc) => MultiBase bxc+multibase64url :: (Transcoder tc) => MultiBase tc multibase64url = mk 'U'

@@ -31,36 +31,36 @@ import Data.Maybe (fromMaybe) import Data.Text (Text) import Data.Text qualified as Text-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)+import XCodec.Transcoder (Transcoder)  -- | Stores a multibase basesystem's prefix and its implementations for -- digitDecoder/digitEncoder from Data.BaseSystems.DigitTranscoder.-data MultiBase bxc = MultiBase+data MultiBase t = MultiBase   { -- | The name of the basesystem for displaying in show (prepends "multi").     multibaseName :: String,     -- | The basesystem's idenitifying symbol.     multibasePrefix :: Alpha.Symbol,     -- | Encodes the binary transcoder to Text.-    multibaseEncoder :: bxc -> Text,+    multibaseEncoder :: t -> Text,     -- | Decodes the binary transcoder from Text.-    multibaseDecoder :: Text -> Maybe bxc+    multibaseDecoder :: Text -> Maybe t   }  -- | Implements equality for multibase on prefixes.-instance Eq (MultiBase bxc) where+instance Eq (MultiBase t) where   (==) = (==) `on` multibasePrefix  -- | Implements ordering for multibase on prefixes.-instance Ord (MultiBase bxc) where+instance Ord (MultiBase t) where   compare = compare `on` multibasePrefix  -- | Prepends multi to the basesystem name.-instance Show (MultiBase bxc) where+instance Show (MultiBase t) where   show mb = "multi" ++ multibaseName mb  -- | Implements a DigitTranscoder for all MulitBases parameterized by--- BinaryTranscoder.-instance (BinaryTranscoder bxc) => DigitTranscoder (MultiBase bxc) bxc where+-- Transcoder.+instance (Transcoder tc) => DigitTranscoder (MultiBase tc) tc where   -- digitEncoder: Use the encoder provided in the MultiBase data.   digitEncoder = multibaseEncoder @@ -69,14 +69,14 @@  -- | Provides decoder for MultiBase strings with any implemented prefix -- character.-decodeFromPrefix :: (BinaryTranscoder bxc) => Text -> Maybe bxc+decodeFromPrefix :: (Transcoder tc) => Text -> Maybe tc decodeFromPrefix text = do   (prefix, rest) <- Text.uncons text   decode <- multibaseDecoder <$> resolvePrefix prefix   decode rest  -- | Decodes for CIDv0 from base58btc w/o MultiBase prefix.-decodeCIDv0 :: (BinaryTranscoder bxc) => Text -> Maybe bxc+decodeCIDv0 :: (Transcoder tc) => Text -> Maybe tc decodeCIDv0 = digitDecoder Digits.base58btc  -- | Checks if the Text has a valid prefix character.@@ -92,11 +92,11 @@     lookupTable = prefixSymbolTable :: IntMap (MultiBase ByteString)  -- | Resolves a MultiBase system from the first Symbol in a String.-resolveTextPrefix :: (BinaryTranscoder bxc) => Text -> Maybe (MultiBase bxc)+resolveTextPrefix :: (Transcoder tc) => Text -> Maybe (MultiBase tc) resolveTextPrefix text = Text.uncons text >>= \(ch, _) -> resolvePrefix ch  -- | Resolves a MultiBase system from a basesystem prefix Symbol.-resolvePrefix :: (BinaryTranscoder bxc) => Alpha.Symbol -> Maybe (MultiBase bxc)+resolvePrefix :: (Transcoder tc) => Alpha.Symbol -> Maybe (MultiBase tc) resolvePrefix prefix = ord prefix `IntMap.lookup` prefixSymbolTable  -- | Creates the lookup table between prefix symbols and multibase systems.@@ -106,7 +106,7 @@ -- https://github.com/multiformats/multibase/blob/master/multibase.csv -- Data.Map on IntMap performance: -- https://hackage-content.haskell.org/package/containers-0.8/docs/Data-Map.html-prefixSymbolTable :: (BinaryTranscoder bxc) => IntMap (MultiBase bxc)+prefixSymbolTable :: (Transcoder tc) => IntMap (MultiBase tc) prefixSymbolTable =   IntMap.fromList     [ mk '0' Digits.base2,@@ -134,10 +134,10 @@ -- | Creates a multibase system from a prefix and digit transcoder -- implementation. mkMultiBase ::-  (BinaryTranscoder bxc, DigitTranscoder dxc bxc, Show dxc) =>+  (Transcoder tc, DigitTranscoder dc tc, Show dc) =>   Alpha.Symbol ->-  dxc ->-  MultiBase bxc+  dc ->+  MultiBase tc mkMultiBase prefix digits =   MultiBase     { multibaseName = show digits,

@@ -24,8 +24,8 @@ import Data.Map qualified as LazyMap import Data.Maybe (fromMaybe) import Data.Text qualified as Text-import Data.XCodec.BinaryTranscoder (packValueBE) import MultiFormats.VarInt (VarInt)+import XCodec.Transcoder (packValueBE)  -- | Represents MultiCodec code. newtype MultiCodec = MultiCodec {multiCodecValue :: VarInt} deriving (Eq, Ord)

@@ -32,13 +32,13 @@ import Data.Map qualified as LazyMap import Data.Maybe (fromMaybe, mapMaybe) import Data.Text qualified as Text-import Data.XCodec.BinaryTranscoder (packValueBE) import Foreign.ForeignPtr (newForeignPtr) import Foreign.Marshal.Alloc (finalizerFree) import Foreign.Marshal.Array (copyArray, mallocArray) import GHC.IO (unsafePerformIO) import MultiFormats.MultiCodec (MultiCodec (..)) import MultiFormats.MultiCodec qualified as MC+import XCodec.Transcoder (packValueBE)  -- | Alias for the type of function signture we want from a hash function. type HashFunction = Builder -> LazyByteString

@@ -21,9 +21,9 @@ import Data.ByteString.Builder qualified as Builder import Data.ByteString.Short qualified as SBS import Data.Word (Word16, Word64, Word8)-import Data.XCodec.BinaryTranscoder (BinaryTranscoder)-import Data.XCodec.BinaryTranscoder qualified as BXC import MultiFormats.VarInt.Errors (Error (..), Okay)+import XCodec.Transcoder (Transcoder)+import XCodec.Transcoder qualified as XC  -- | VarInt spec uses unsigned 64 bit integers. type VarInt = Word64@@ -55,30 +55,30 @@  -- | Splits ByteString into it's first occurring VarInt and the remaining -- ByteString after.-spanVarInt :: (BinaryTranscoder t) => t -> Okay (t, t)-spanVarInt bxc+spanVarInt :: (Transcoder tc) => tc -> Okay (tc, tc)+spanVarInt xc   -- Fail if empty bytes.-  | BXC.null bxc = Left EmptyBytes+  | XC.null xc = Left EmptyBytes   -- Otherwise, collect the bytes with MSB=1.   | otherwise =-      case BXC.spanOctetsTop isMSB1 bxc of+      case XC.spanOctetsTop isMSB1 xc of         -- The varint is the leading bytes with the MSB=1 and a final         -- terminating byte with MSB=0.         (msb1s, msb0s)           -- Verify if a final byte exists.-          | BXC.null msb0s -> Left MissingTermination+          | XC.null msb0s -> Left MissingTermination           -- The loop invariant ensures &msb1s + 1 has MSB=0, so compute this           -- offset and split the data there.           | otherwise ->-              let nulloffset = BXC.totalOctets msb1s + 1-               in Right (BXC.splitOffset nulloffset bxc)+              let nulloffset = XC.totalOctets msb1s + 1+               in Right (XC.splitOffset nulloffset xc)   where     -- Checks if the most-significant bit (MSB) is set to 1     isMSB1 !byte = (byte .&. msb1) /= 0  -- | Concats the lower 7 bits from bytes into single int value.-buildVarInt :: (BinaryTranscoder t) => t -> VarInt-buildVarInt = foldr build 0 . BXC.unpackOctets+buildVarInt :: (Transcoder tc) => tc -> VarInt+buildVarInt = foldr build 0 . XC.unpackOctets   where     -- Shifts the accumulator 7 bits (1 byte minus MSB value) and ORs the     -- current byte into place, and remove the MSB set bit.@@ -88,23 +88,23 @@ -- of varints, (ie, we can fit 2 bytes of 7 bits into 1 byte of 7 bits). The -- only case of this is when a final 0x8100 should be a 0x79... I think! {-# INLINE nonMinimal #-}-nonMinimal :: (BinaryTranscoder bxc) => bxc -> Bool+nonMinimal :: (Transcoder tc) => tc -> Bool nonMinimal vardata = last16bits == invalidsuffix   where     -- Puts the last two bytes of the transcoder into a Word16.-    last16bits = fromIntegral $! BXC.unpackValueBE (BXC.takeOctetsEnd 2 vardata)+    last16bits = fromIntegral $! XC.unpackValueBE (XC.takeOctetsEnd 2 vardata)     -- This value is the same to the value from bytes 0x7F, so it's not minimal     invalidsuffix = (fromIntegral msb1lsb1 :: Word16) .<<. 8  -- | Checks if a VarInt encoded ByteString overflows a Word64. {-# INLINE aboveCapacity #-}-aboveCapacity :: (BinaryTranscoder t) => t -> Bool+aboveCapacity :: (Transcoder tc) => tc -> Bool aboveCapacity vardata =-  let wholelen = BXC.totalOctets vardata+  let wholelen = XC.totalOctets vardata    in not (1 <= wholelen && wholelen <= bytesCapacity)  -- | Extracts the first minimally encoded varint from a ByteString.-extractVarInt :: (BinaryTranscoder t) => t -> Okay (VarInt, t)+extractVarInt :: (Transcoder tc) => tc -> Okay (VarInt, tc) extractVarInt = spanVarInt >=> spanBuild   where     -- Verifies the result from running spanVarInt