{"id":28907311,"url":"https://github.com/edjcase/motoko_multiformats","last_synced_at":"2026-02-02T01:32:50.531Z","repository":{"id":300299025,"uuid":"1005189853","full_name":"edjCase/motoko_multiformats","owner":"edjCase","description":"A multiformats library for Motoko covering multibase, multicodec, multihash, ...","archived":false,"fork":false,"pushed_at":"2025-09-06T20:34:16.000Z","size":84,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2025-09-06T22:22:08.463Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":"Motoko","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/edjCase.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-06-19T20:26:16.000Z","updated_at":"2025-09-06T20:34:20.000Z","dependencies_parsed_at":"2025-07-11T22:16:45.346Z","dependency_job_id":"d678911b-415e-446d-b498-3e4af3a7800a","html_url":"https://github.com/edjCase/motoko_multiformats","commit_stats":null,"previous_names":["edjcase/motoko_multiformats"],"tags_count":0,"template":false,"template_full_name":"edjCase/motoko-library-template","purl":"pkg:github/edjCase/motoko_multiformats","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/edjCase%2Fmotoko_multiformats","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/edjCase%2Fmotoko_multiformats/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/edjCase%2Fmotoko_multiformats/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/edjCase%2Fmotoko_multiformats/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/edjCase","download_url":"https://codeload.github.com/edjCase/motoko_multiformats/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/edjCase%2Fmotoko_multiformats/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28999718,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-02-02T01:32:03.847Z","status":"ssl_error","status_checked_at":"2026-02-02T01:32:03.458Z","response_time":56,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2025-06-21T15:31:10.042Z","updated_at":"2026-02-02T01:32:50.526Z","avatar_url":"https://github.com/edjCase.png","language":"Motoko","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Motoko Multiformats\n\nA comprehensive Motoko library for working with Multiformats, including multicodec, multihash, multibase, and variable-length integers. This library provides IPFS/IPLD-compatible implementations for encoding and decoding various data formats.\n\n## Features\n\n- **MultiBase**: Encode/decode data with various base encodings (Base58, Base32, Base64, Base16) with proper prefix handling\n- **MultiCodec**: Support for IPFS/IPLD codec types and cryptographic key formats\n- **MultiHash**: Hash algorithm identification and multihash format support\n\n## Installation\n\n### MOPS\n\n```bash\nmops install multiformats\n```\n\nTo setup MOPS package manager, follow the instructions from the [MOPS Site](https://j4mwm-bqaaa-aaaam-qajbq-cai.ic0.app/)\n\n## Usage\n\n```motoko\nimport Multiformats \"mo:multiformats\";\n\n// Access individual modules\nlet { MultiBase; MultiCodec; MultiHash; VarInt } = Multiformats;\n```\n\n## API Reference\n\n### MultiBase\n\nMultiBase provides encoding and decoding for various base formats with standardized prefixes.\n\n#### Types\n\n**`MultiBase`**\n\nRepresents the multibase encoding format with its character prefix:\n\n```motoko\npublic type MultiBase = {\n    #base58btc;    // 'z' prefix\n    #base32;       // 'b' prefix\n    #base32Upper;  // 'B' prefix\n    #base64;       // 'm' prefix\n    #base64Url;    // 'u' prefix\n    #base64UrlPad; // 'U' prefix\n    #base16;       // 'f' prefix\n    #base16Upper;  // 'F' prefix\n};\n```\n\n**`MultiBaseOrIdentity`**\n\nExtends MultiBase to include identity encoding (no encoding):\n\n```motoko\npublic type MultiBaseOrIdentity = MultiBase or {\n    #identity; // 0x00 byte prefix (no encoding)\n};\n```\n\n#### Functions\n\n**`toText(bytes: Iter.Iter\u003cNat8\u003e, encoding: MultiBase): Text`**\n\nConverts bytes to multibase text with proper prefix:\n\n```motoko\nlet bytes: [Nat8] = [0x01, 0x02, 0x03];\nlet text = MultiBase.toText(bytes.vals(), #base58btc);\n// Returns: \"z3mJ\" (example base58btc encoding)\n```\n\n**`fromText(text: Text): Result.Result\u003c([Nat8], MultiBase), Text\u003e`**\n\nConverts multibase text back to bytes and encoding type:\n\n```motoko\nlet text = \"z3mJ\"; // Example base58btc encoding\nlet result = MultiBase.fromText(text);\n// Returns: #ok(([0x01, 0x02, 0x03], #base58btc))\n```\n\n**`fromTextWithoutPrefix(text: Text, encoding: MultiBase): Result.Result\u003c[Nat8], Text\u003e`**\n\nConverts base text to bytes using a specific encoding type (without prefix):\n\n```motoko\nlet text = \"3mJ\"; // Base58 encoded data without prefix\nlet result = MultiBase.fromTextWithoutPrefix(text, #base58btc);\n// Returns: #ok([0x01, 0x02, 0x03])\n```\n\n**`fromEncodedBytes(bytes: Iter.Iter\u003cNat8\u003e): Result.Result\u003c([Nat8], MultiBaseOrIdentity), Text\u003e`**\n\nConverts multibase-encoded bytes to their original bytes with encoding type. Used for CID byte decoding in DAGCBOR:\n\n```motoko\nlet encodedBytes: [Nat8] = [0x5a, 0x33, 0x6d, 0x4a]; // 'z' prefix + base58 data\nlet result = MultiBase.fromEncodedBytes(encodedBytes.vals());\n// Returns: #ok(([0x01, 0x02, 0x03], #base58btc))\n\nlet identityBytes: [Nat8] = [0x00, 0x01, 0x02, 0x03]; // identity prefix + raw data\nlet result2 = MultiBase.fromEncodedBytes(identityBytes.vals());\n// Returns: #ok(([0x01, 0x02, 0x03], #identity))\n```\n\n**`toEncodedBytes(bytes: Iter.Iter\u003cNat8\u003e, encoding: MultiBaseOrIdentity): [Nat8]`**\n\nConverts bytes to multibase-encoded bytes with encoding type prefix. Complement to `fromEncodedBytes`:\n\n```motoko\nlet bytes: [Nat8] = [0x01, 0x02, 0x03];\nlet encodedBytes = MultiBase.toEncodedBytes(bytes.vals(), #base58btc);\n// Returns: [0x5a, 0x33, 0x6d, 0x4a] ('z' prefix + base58 data as UTF-8)\n\nlet identityBytes = MultiBase.toEncodedBytes(bytes.vals(), #identity);\n// Returns: [0x00, 0x01, 0x02, 0x03] (identity prefix + raw data)\n```\n\n**`baseFromByte(byte: Nat8): ?MultiBaseOrIdentity`**\n\nConverts a byte value to its corresponding MultiBase encoding type:\n\n```motoko\nlet encoding = MultiBase.baseFromByte(0x5a); // 'z' as byte\n// Returns: ?#base58btc\n\nlet identity = MultiBase.baseFromByte(0x00); // identity (no encoding)\n// Returns: ?#identity\n```\n\n**`baseToByte(encoding: MultiBaseOrIdentity): Nat8`**\n\nConverts a MultiBase encoding type to its corresponding byte value:\n\n```motoko\nlet byte = MultiBase.baseToByte(#base58btc);\n// Returns: 0x5a ('z' as byte)\n\nlet identityByte = MultiBase.baseToByte(#identity);\n// Returns: 0x00\n```\n\n**`baseFromChar(char: Char): ?MultiBase`**\n\nConverts a character prefix to its corresponding MultiBase encoding type:\n\n```motoko\nlet encoding = MultiBase.baseFromChar('z');\n// Returns: ?#base58btc\n\nlet invalid = MultiBase.baseFromChar('x');\n// Returns: null\n```\n\n**`baseToChar(encoding: MultiBase): Char`**\n\nConverts a MultiBase encoding type to its corresponding character prefix:\n\n```motoko\nlet char = MultiBase.baseToChar(#base58btc);\n// Returns: 'z'\n\nlet base32Char = MultiBase.baseToChar(#base32);\n// Returns: 'b'\n```\n\n### MultiCodec\n\nMultiCodec provides support for IPFS/IPLD codec identification and cryptographic key formats.\n\n#### Types\n\n**`Codec`**\n\nRepresents various codec types used in IPFS/IPLD and cryptographic keys:\n\n```motoko\npublic type Codec = {\n    // Content/Data Codecs\n    #raw;          // 0x55 - Raw binary data\n    #dagPb;       // 0x70 - DAG-PB (Protocol Buffers)\n    #dagCbor;     // 0x71 - DAG-CBOR\n    #dagJson;     // 0x0129 - DAG-JSON\n\n    // Cryptographic Key Codecs\n    #ed25519Pub;       // 0xed - Ed25519 public key\n    #secp256k1Pub;     // 0xe7 - secp256k1 public key\n    #p256Pub;          // 0x1200 - P-256 public key\n    #p384Pub;          // 0x1201 - P-384 public key\n    #p521Pub;          // 0x1202 - P-521 public key\n    #ed448Pub;         // 0xee - Ed448 public key\n    #x25519Pub;        // 0xec - X25519 public key\n    #x448Pub;          // 0xef - X448 public key\n    #rsaPub;           // 0x1205 - RSA public key\n    #bls12381G1Pub;  // 0xea - BLS12-381 G1 public key\n    #bls12381G2Pub;  // 0xeb - BLS12-381 G2 public key\n\n    // Hash Algorithm Codecs (for multihash compatibility)\n    #sha2256;     // 0x12 - SHA-256\n    #sha2512;     // 0x13 - SHA-512\n    #blake2b256;  // 0xb220 - Blake2b-256\n    #blake2s256;  // 0xb260 - Blake2s-256\n    #sha3256;     // 0x16 - SHA3-256\n    #sha3512;     // 0x14 - SHA3-512\n};\n```\n\n#### Functions\n\n**`toBytes(codec: Codec): [Nat8]`**\n\nEncodes a codec as its multicodec varint representation:\n\n```motoko\nlet bytes = MultiCodec.toBytes(#ed25519Pub);\n// Returns: [0xed] (varint-encoded 237)\n```\n\n**`toBytesBuffer(buffer: Buffer.Buffer\u003cNat8\u003e, codec: Codec)`**\n\nEncodes a codec as its multicodec varint representation into a buffer:\n\n```motoko\nlet buffer = Buffer.Buffer\u003cNat8\u003e(10);\nMultiCodec.toBytesBuffer(buffer, #ed25519Pub);\n// buffer now contains: [0xed]\n```\n\n**`fromBytes(bytes: Iter.Iter\u003cNat8\u003e): Result.Result\u003cCodec, Text\u003e`**\n\nDecodes a multicodec varint from bytes:\n\n```motoko\nlet bytes: [Nat8] = [0xed];\nlet result = MultiCodec.fromBytes(bytes.vals());\n// Returns: #ok(#ed25519Pub)\n```\n\n### MultiHash\n\nMultiHash provides hash algorithm identification and multihash format support.\n\n#### Types\n\n**`Algorithm`**\n\nRepresents hash algorithms supported in multihash format:\n\n```motoko\npublic type Algorithm = {\n    #sha2256;     // SHA-256 (32 bytes)\n    #sha2512;     // SHA-512 (64 bytes)\n    #blake2b256;  // Blake2b-256 (32 bytes)\n    #blake2s256;  // Blake2s-256 (32 bytes)\n    #sha3256;     // SHA3-256 (32 bytes)\n    #sha3512;     // SHA3-512 (64 bytes)\n};\n```\n\n**`MultiHash`**\n\nRepresents a multihash with algorithm and digest:\n\n```motoko\npublic type MultiHash = {\n    algorithm: Algorithm;\n    digest: Blob;\n};\n```\n\n#### Functions\n\n**`toBytes(multihash: MultiHash): [Nat8]`**\n\nEncodes a multihash to its binary representation:\n\n```motoko\nlet multihash: MultiHash = {\n    algorithm = #sha2256;\n    digest = \"\\E3\\B0\\C4\\42...\";\n};\nlet bytes = MultiHash.toBytes(multihash);\n// Returns: [0x12, 0x20, 0xE3, 0xB0, ...]\n```\n\n**`toBytesBuffer(buffer: Buffer.Buffer\u003cNat8\u003e, multihash: MultiHash)`**\n\nEncodes a multihash to its binary representation into a buffer:\n\n```motoko\nlet multihash: MultiHash = {\n    algorithm = #sha2256;\n    digest = \"\\E3\\B0\\C4\\42...\";\n};\nlet buffer = Buffer.Buffer\u003cNat8\u003e(multihash.digest.size() + 10);\nMultiHash.toBytesBuffer(buffer, multihash);\n// buffer now contains: [0x12, 0x20, 0xE3, 0xB0, ...]\n```\n\n**`fromBytes(bytes: Iter.Iter\u003cNat8\u003e): Result.Result\u003cMultiHash, Text\u003e`**\n\nDecodes a multihash from bytes:\n\n```motoko\nlet bytes: [Nat8] = [0x12, 0x20, 0xE3, 0xB0, ...];\nlet result = MultiHash.fromBytes(bytes.vals());\n// Returns: #ok({ algorithm = #sha2256; digest = ... })\n```\n\n### VarInt\n\nVarInt provides variable-length integer encoding and decoding.\n\n#### Functions\n\n**`fromBytes(bytes: Iter.Iter\u003cNat8\u003e): Result.Result\u003cNat, Text\u003e`**\n\nDecodes a variable-length integer from a byte iterator:\n\n```motoko\nlet bytes: [Nat8] = [0xAC, 0x02]; // 300 encoded as varint\nlet result = VarInt.fromBytes(bytes.vals());\n// Returns: #ok(300)\n```\n\n**`toBytes(n: Nat): [Nat8]`**\n\nEncodes a natural number as a variable-length integer:\n\n```motoko\nlet encoded = VarInt.toBytes(300);\n// Returns: [0xAC, 0x02]\n```\n\n**`toBytesBuffer(buffer: Buffer.Buffer\u003cNat8\u003e, n: Nat)`**\n\nEncodes a natural number as a variable-length integer into a buffer:\n\n```motoko\nlet buffer = Buffer.Buffer\u003cNat8\u003e(10);\nVarInt.toBytesBuffer(buffer, 300);\n// buffer now contains: [0xAC, 0x02]\n```\n\n## Testing\n\n```bash\nmops test\n```\n\n## License\n\nMIT License - see LICENSE file for details.\n\n## Contributing\n\nContributions are welcome! Please feel free to submit issues and pull requests.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fedjcase%2Fmotoko_multiformats","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fedjcase%2Fmotoko_multiformats","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fedjcase%2Fmotoko_multiformats/lists"}