🥮 mooncakes.io
    Sign in

    moonloom

    MoonLoom is a self-describing content-addressing toolkit for MoonBit.

    multiformats
    multibase
    multicodec
    multihash
    cid
    multiaddr
    Download zip
    Version
    0.1.0
    License
    Apache-2.0
    Repository
    Last updated
    last month
    Downloads
    66

    #MoonLoom

    MoonLoom is a pure MoonBit toolkit for self-describing content addressing. It brings Multibase, Multicodec, Multihash, CID, and Multiaddr into one small, strict, deterministic library.

    The project is intentionally not a full IPFS implementation. MoonLoom focuses on the format layer: creating canonical identifiers, converting between text and bytes, validating input, and preserving interoperability with the Multiformats ecosystem.

    #Current milestone

    The format core is implemented and tested:

    • Canonical unsigned varint encoding and strict decoding.
    • Multibase codecs for base16, base32, base58btc, base64, and URL-safe base64.
    • A single registry covering CID, hash, content format, and Multiaddr protocol metadata, including value kinds and canonical names.
    • Multihash binary encoding with identity, sha2-256, and sha2-512.
    • Multihash verification through an explicit hash-provider boundary.
    • CIDv0 and CIDv1 encoding, decoding, canonical text output, and content verification.
    • A typed Multiaddr domain model with reusable protocol, protocol-value, path-segment, IPv4, and IPv6 types.
    • A strict Multiaddr text parser for supported IP, DNS, port, peer, and unit protocols.
    • Deterministic Multiaddr binary encoding and decoding using the shared varint and protocol registry.
    • Canonical Multiaddr text output with RFC 5952 IPv6 compression.
    • A reusable cli package with process-independent command parsing, help, version, global --json, and deterministic exit codes.
    • Multibase and Multihash CLI commands for encoding, digesting, inspection, and verification.
    • CID CLI commands for CIDv0/CIDv1 creation, inspection, and content verification.
    • Multiaddr CLI commands for canonical parsing, binary encoding, and base64 or hex decoding.
    • Typed errors with byte offsets and configurable resource limits.
    • Reusable bounded WireReader and WireWriter primitives shared by all Multiformats codecs.
    • Stable public API conventions for construction, parsing, verification, and extension seams, documented in docs/api-contracts.md.
    • Cross-target-friendly MoonBit code with no FFI dependency.

    The remaining milestones add Multiaddr, the CLI, interop vectors, and Mooncakes publication.

    #Quick start

    let encoded = @moonloom.encode_u64(300UL)
    assert_eq(encoded, b"\xac\x02")

    let text = @moonloom.multibase_encode(@moonloom.Base32, b"hello")
    assert_eq(text, Ok("bnbswy3dp"))

    let provider = @moonloom.sha2_provider()
    let cid = match @moonloom.cid_from_content(
      85UL,
      @moonloom.Sha2_256,
      b"hello",
      provider,
      @moonloom.Limits::default(),
    ) {
      Ok(value) => value
      Err(err) => fail(err.to_string())
    }

    assert_eq(
      cid.to_text(),
      Ok("bafkreibm6jg3ux5qumhcn2b3flc3tyu6dmlb4xa7u5bf44yegnrjhc4yeq"),
    )
    assert_eq(
      cid.verify(b"hello", provider, @moonloom.Limits::default()),
      Ok(()),
    )

    #Why MoonLoom

    MoonBit increasingly needs to exchange content-addressed data with other ecosystems: build artifacts, offline caches, package integrity manifests, decentralized identifiers, and peer addresses. Those formats already have precise specifications and conformance vectors, but MoonBit lacked one shared, bounded implementation.

    MoonLoom is useful in at least three practical scenarios:

    1. Create and verify a stable CID for a build artifact or offline cache entry.
    2. Convert CIDs, multihashes, and future Multiaddrs between text and binary for cross-language protocol fixtures.
    3. Verify content obtained from a cache, mirror, or peer before accepting it.

    #Design rules

    • Canonical output by default.
    • Strict decoding with typed errors and byte offsets.
    • Every parser and content verifier is bounded by Limits.
    • No panic for malformed external input.
    • Registry data is centralized and reviewed.
    • Text and binary round trips are deterministic.
    • Cryptographic algorithms are provided by adapters, never reimplemented here.
    • SHA-2 support is delegated to Apache-2.0 MoonCrypt.

    #Interoperability

    Standard vectors and malformed-input coverage are documented in docs/interop.md.

    #Examples

    The repository includes three runnable examples:

    moon run examples/artifact_cid
moon run examples/multiaddr_normalize
moon run examples/cross_language_fixture

    See examples/README.md for details.

    #Build and test

    moon check --target all
moon test --target all
moon build

    #Status

    MoonLoom 0.1.0 is the format-core release candidate for the 2026 September MoonBit Hackathon. The library, CLI, examples, cross-language vectors, and CI matrix are complete for the scoped formats.

    #License

    Apache-2.0.

    Base

    source
    pub(all) enum Base {
      Base16
      Base16Upper
      Base32
      Base32Upper
      Base32Pad
      Base32PadUpper
      Base58Btc
      Base64
      Base64Pad
      Base64Url
      Base64UrlPad
    } derive(Eq, 
    Debug    )

    Multibase encodings supported by MoonLoom's first milestone.

    Base::equal

    source
    fn Base::equal(Base, Base) -> Bool

    Base::from_name

    source
    fn Base::from_name(name : StringView) -> Base?

    Base::from_prefix

    source
    fn Base::from_prefix(prefix : Char) -> Base?

    Base::name

    source
    fn Base::name(self : Base) -> String

    Base::not_equal

    source
    fn Base::not_equal(x : Base, y : Base) -> Bool

    Base::prefix

    source
    fn Base::prefix(self : Base) -> Char

    Base::to_repr

    source

    Cid

    source
    pub(all) struct Cid {
      version : UInt64
      codec : UInt64
      hash : Multihash
    } derive(Eq, 
    Debug    )

    CIDv0 or CIDv1 value.

    Cid::codec_name

    source
    fn Cid::codec_name(self : Cid) -> String?

    Cid::decode_bytes

    source
    fn Cid::decode_bytes(input : BytesView, limits : Limits) -> Result[Cid, MoonLoomError]

    Cid::equal

    source
    fn Cid::equal(Cid, Cid) -> Bool

    Cid::hash_algorithm

    source
    fn Cid::hash_algorithm(self : Cid) -> HashAlgorithm?

    Cid::is_v0

    source
    fn Cid::is_v0(self : Cid) -> Bool

    Cid::not_equal

    source
    fn Cid::not_equal(x : Cid, y : Cid) -> Bool

    Cid::parse

    source
    fn Cid::parse(text : StringView, limits : Limits) -> Result[Cid, MoonLoomError]

    Cid::to_bytes

    source
    fn Cid::to_bytes(self : Cid) -> Bytes

    Cid::to_repr

    source

    Cid::to_text

    source
    fn Cid::to_text(self : Cid) -> Result[String, MoonLoomError]

    Cid::v0

    source
    fn Cid::v0(hash : Multihash, limits : Limits) -> Result[Cid, MoonLoomError]

    Cid::v1

    source
    fn Cid::v1(codec : UInt64, hash : Multihash, limits : Limits) -> Result[Cid, MoonLoomError]

    Cid::verify

    source
    fn Cid::verify(self : Cid, content : BytesView, provider : HashProvider, limits : Limits) -> Result[Unit, MoonLoomError]

    CodecCategory

    source
    pub(all) enum CodecCategory {
      Cid
      Format
      Hash
      Multiaddr
    } derive(Eq, 
    Debug    )

    High-level namespace for a multicodec entry.

    CodecCategory::equal

    source

    CodecCategory::from_name

    source
    fn CodecCategory::from_name(name : StringView) -> CodecCategory?

    CodecCategory::name

    source
    fn CodecCategory::name(self : CodecCategory) -> String

    CodecCategory::not_equal

    source
    fn CodecCategory::not_equal(x : CodecCategory, y : CodecCategory) -> Bool

    CodecCategory::to_repr

    source

    CodecInfo

    source
    pub(all) struct CodecInfo {
      code : UInt64
      name : String
      category : CodecCategory
    } derive(Eq, 
    Debug    )

    One curated entry from the multicodec registry.

    CodecInfo::equal

    source
    fn CodecInfo::equal(CodecInfo, CodecInfo) -> Bool

    CodecInfo::not_equal

    source
    fn CodecInfo::not_equal(x : CodecInfo, y : CodecInfo) -> Bool

    CodecInfo::to_repr

    source

    DecodedMultibase

    source
    pub(all) struct DecodedMultibase {
      base : Base
      data : Bytes
    } derive(Eq, 
    Debug    )

    Result of decoding a Multibase string.

    DecodedMultibase::equal

    source

    DecodedMultibase::not_equal

    source
    fn DecodedMultibase::not_equal(x : DecodedMultibase, y : DecodedMultibase) -> Bool

    DecodedMultibase::to_repr

    source

    HashAlgorithm

    source
    pub(all) enum HashAlgorithm {
      Identity
      Sha2_256
      Sha2_512
    } derive(Eq, 
    Debug    )

    Hash algorithms currently understood by MoonLoom.

    HashAlgorithm::code

    source
    fn HashAlgorithm::code(self : HashAlgorithm) -> UInt64

    HashAlgorithm::equal

    source

    HashAlgorithm::expected_digest_size

    source
    fn HashAlgorithm::expected_digest_size(self : HashAlgorithm) -> Int?

    HashAlgorithm::from_code

    source
    fn HashAlgorithm::from_code(code : UInt64) -> HashAlgorithm?

    HashAlgorithm::from_name

    source
    fn HashAlgorithm::from_name(name : StringView) -> HashAlgorithm?

    HashAlgorithm::name

    source
    fn HashAlgorithm::name(self : HashAlgorithm) -> String

    HashAlgorithm::not_equal

    source
    fn HashAlgorithm::not_equal(x : HashAlgorithm, y : HashAlgorithm) -> Bool

    HashAlgorithm::to_repr

    source

    HashProvider

    source
    pub struct HashProvider {
      digest : (HashAlgorithm, BytesView) -> Result[Bytes, MoonLoomError]
    }

    Provider seam for cryptographic hash implementations.

    HashProvider::hash

    source
    fn HashProvider::hash(self : HashProvider, algorithm : HashAlgorithm, data : BytesView) -> Result[Bytes, MoonLoomError]

    HashProvider::new

    source
    fn HashProvider::new(digest : (HashAlgorithm, BytesView) -> Result[Bytes, MoonLoomError]) -> HashProvider

    Ipv4Address

    source
    pub struct Ipv4Address {
      octets : Bytes
    } derive(Eq, 
    Debug    )

    Ipv4Address::equal

    source
    fn Ipv4Address::equal(Ipv4Address, Ipv4Address) -> Bool

    Ipv4Address::from_octets

    source
    fn Ipv4Address::from_octets(value : BytesView) -> Result[Ipv4Address, MoonLoomError]

    Ipv4Address::new

    source
    fn Ipv4Address::new(a : Int, b : Int, c : Int, d : Int) -> Result[Ipv4Address, MoonLoomError]

    Ipv4Address::not_equal

    source
    fn Ipv4Address::not_equal(x : Ipv4Address, y : Ipv4Address) -> Bool

    Ipv4Address::octets

    source
    fn Ipv4Address::octets(self : Ipv4Address) -> BytesView

    Ipv4Address::to_repr

    source

    Ipv4Address::to_text

    source
    fn Ipv4Address::to_text(self : Ipv4Address) -> String

    Ipv6Address

    source
    pub struct Ipv6Address {
      octets : Bytes
    } derive(Eq, 
    Debug    )

    Ipv6Address::equal

    source
    fn Ipv6Address::equal(Ipv6Address, Ipv6Address) -> Bool

    Ipv6Address::from_octets

    source
    fn Ipv6Address::from_octets(value : BytesView) -> Result[Ipv6Address, MoonLoomError]

    Ipv6Address::not_equal

    source
    fn Ipv6Address::not_equal(x : Ipv6Address, y : Ipv6Address) -> Bool

    Ipv6Address::octets

    source
    fn Ipv6Address::octets(self : Ipv6Address) -> BytesView

    Ipv6Address::to_repr

    source

    Ipv6Address::to_text

    source
    fn Ipv6Address::to_text(self : Ipv6Address) -> String

    Limits

    source
    pub struct Limits {
      max_input_bytes : Int
      max_varint_bytes : Int
      max_digest_bytes : Int
      max_multiaddr_bytes : Int
    }

    Resource limits shared by all formats.

    Limits::check_digest

    source
    fn Limits::check_digest(self : Limits, context : String, length : Int) -> Result[Unit, MoonLoomError]

    Validate a digest length before allocation or decoding.

    Limits::check_input

    source
    fn Limits::check_input(self : Limits, context : String, length : Int) -> Result[Unit, MoonLoomError]

    Limits::check_multiaddr

    source
    fn Limits::check_multiaddr(self : Limits, length : Int) -> Result[Unit, MoonLoomError]

    Validate a Multiaddr byte length before allocation or decoding.

    Limits::default

    source
    fn Limits::default() -> Limits

    Limits::max_digest_bytes

    source
    fn Limits::max_digest_bytes(self : Limits) -> Int

    Limits::max_input_bytes

    source
    fn Limits::max_input_bytes(self : Limits) -> Int

    Limits::max_multiaddr_bytes

    source
    fn Limits::max_multiaddr_bytes(self : Limits) -> Int

    Limits::max_varint_bytes

    source
    fn Limits::max_varint_bytes(self : Limits) -> Int

    Limits::new

    source
    fn Limits::new(max_input_bytes? : Int, max_varint_bytes? : Int, max_digest_bytes? : Int, max_multiaddr_bytes? : Int) -> Limits

    MoonLoomError

    source
    pub(all) enum MoonLoomError {
      InputTooLong(String, Int, Int)
      OffsetOutOfBounds(Int)
      Truncated(String, Int)
      InvalidVarint(String, Int)
      NonCanonicalVarint(Int)
      UnknownBase(Char)
      InvalidBaseCharacter(Char, Int)
      InvalidPadding(String, Int)
      UnknownCodec(UInt64)
      UnknownCodecName(String)
      InvalidField(String, Int)
      UnsupportedHashAlgorithm(String)
      DigestLengthMismatch(String, Int, Int)
      HashMismatch
      InvalidMultihash(String, Int)
      InvalidCid(String, Int)
      CidCodecMismatch(UInt64)
      InvalidCodec(UInt64)
      InvalidProtocolValue(String)
      InvalidPort(Int)
      UnknownProtocol(String)
    } derive(Eq, 
    Debug    )

    Errors returned by MoonLoom parsing and encoding APIs.

    Lengths and offsets are measured in bytes. String contexts identify the format boundary that rejected the input.

    MoonLoomError::equal

    source

    MoonLoomError::not_equal

    source
    fn MoonLoomError::not_equal(x : MoonLoomError, y : MoonLoomError) -> Bool

    MoonLoomError::output

    source
    fn MoonLoomError::output(self : MoonLoomError, logger : &Logger) -> Unit

    MoonLoomError::to_repr

    source

    MoonLoomError::to_string

    source
    fn MoonLoomError::to_string(self : MoonLoomError) -> String

    Multiaddr

    source
    pub struct Multiaddr {
      segments : Array[PathSegment]
    } derive(Eq, 
    Debug    )

    Type-safe Multiaddr domain model. Text and binary codecs are layered on top.

    Multiaddr::empty

    source
    fn Multiaddr::empty() -> Multiaddr

    Multiaddr::equal

    source
    fn Multiaddr::equal(Multiaddr, Multiaddr) -> Bool

    Multiaddr::from_segments

    source
    fn Multiaddr::from_segments(segments : Array[PathSegment], limits : Limits) -> Result[Multiaddr, MoonLoomError]

    Multiaddr::get

    source
    fn Multiaddr::get(self : Multiaddr, index : Int) -> PathSegment?

    Multiaddr::is_empty

    source
    fn Multiaddr::is_empty(self : Multiaddr) -> Bool

    Multiaddr::length

    source
    fn Multiaddr::length(self : Multiaddr) -> Int

    Multiaddr::not_equal

    source
    fn Multiaddr::not_equal(x : Multiaddr, y : Multiaddr) -> Bool

    Multiaddr::parse

    source
    fn Multiaddr::parse(text : StringView, limits : Limits) -> Result[Multiaddr, MoonLoomError]

    Multiaddr::parse_bytes

    source
    fn Multiaddr::parse_bytes(input : BytesView, limits : Limits) -> Result[Multiaddr, MoonLoomError]

    Multiaddr::push

    source
    fn Multiaddr::push(self : Multiaddr, segment : PathSegment, limits : Limits) -> Result[Multiaddr, MoonLoomError]

    Multiaddr::segments

    source
    fn Multiaddr::segments(self : Multiaddr) -> ArrayView[PathSegment]

    Multiaddr::to_bytes

    source
    fn Multiaddr::to_bytes(self : Multiaddr, limits : Limits) -> Result[Bytes, MoonLoomError]

    Multiaddr::to_repr

    source

    Multiaddr::to_text

    source
    fn Multiaddr::to_text(self : Multiaddr) -> Result[String, MoonLoomError]

    Multihash

    source
    pub(all) struct Multihash {
      code : UInt64
      digest : Bytes
    } derive(Eq, 
    Debug    )

    Multihash::algorithm

    source
    fn Multihash::algorithm(self : Multihash) -> HashAlgorithm?

    Multihash::create

    source
    fn Multihash::create(algorithm : HashAlgorithm, digest : BytesView, limits : Limits) -> Result[Multihash, MoonLoomError]

    Multihash::decode

    source
    fn Multihash::decode(input : BytesView, limits : Limits) -> Result[(Multihash, Int), MoonLoomError]

    Multihash::encode

    source
    fn Multihash::encode(self : Multihash) -> Bytes

    Multihash::equal

    source
    fn Multihash::equal(Multihash, Multihash) -> Bool

    Multihash::from_text

    source
    fn Multihash::from_text(text : StringView, limits : Limits) -> Result[Multihash, MoonLoomError]

    Multihash::identity

    source
    fn Multihash::identity(data : BytesView, limits : Limits) -> Result[Multihash, MoonLoomError]

    Multihash::is_identity

    source
    fn Multihash::is_identity(self : Multihash) -> Bool

    Multihash::not_equal

    source
    fn Multihash::not_equal(x : Multihash, y : Multihash) -> Bool

    Multihash::to_repr

    source

    Multihash::to_text

    source
    fn Multihash::to_text(self : Multihash, base : Base) -> Result[String, MoonLoomError]

    Multihash::to_text_canonical

    source
    fn Multihash::to_text_canonical(self : Multihash) -> Result[String, MoonLoomError]

    Multihash::verify

    source
    fn Multihash::verify(self : Multihash, content : BytesView, provider : HashProvider, limits : Limits) -> Result[Unit, MoonLoomError]

    PathSegment

    source
    pub struct PathSegment {
      protocol : Protocol
      value : ProtocolValue
    } derive(Eq, 
    Debug    )

    A typed protocol/value pair.

    PathSegment::equal

    source
    fn PathSegment::equal(PathSegment, PathSegment) -> Bool

    PathSegment::new

    source
    fn PathSegment::new(protocol : Protocol, value : ProtocolValue) -> Result[PathSegment, MoonLoomError]

    PathSegment::not_equal

    source
    fn PathSegment::not_equal(x : PathSegment, y : PathSegment) -> Bool

    PathSegment::protocol

    source
    fn PathSegment::protocol(self : PathSegment) -> Protocol

    PathSegment::to_repr

    source

    PathSegment::value

    source

    Protocol

    source
    pub(all) enum Protocol {
      Ip4
      Ip6
      Dns
      Dns4
      Dns6
      Dnsaddr
      Tcp
      Udp
      P2p
      Http
      Https
      Ws
      Wss
      Unknown(UInt64)
    } derive(Eq, 
    Debug    )

    Protocol identifiers used by the first Multiaddr model.

    Protocol::accepts_value

    source
    fn Protocol::accepts_value(self : Protocol, value : ProtocolValue) -> Bool

    Protocol::code

    source
    fn Protocol::code(self : Protocol) -> UInt64

    Protocol::diagnostic_name

    source
    fn Protocol::diagnostic_name(self : Protocol) -> String

    Protocol::equal

    source
    fn Protocol::equal(Protocol, Protocol) -> Bool

    Protocol::expected_value_kind

    source
    fn Protocol::expected_value_kind(self : Protocol) -> ProtocolValueKind

    Protocol::from_code

    source
    fn Protocol::from_code(code : UInt64) -> Protocol

    Protocol::from_name

    source
    fn Protocol::from_name(name : StringView) -> Protocol?

    Protocol::name

    source
    fn Protocol::name(self : Protocol) -> String?

    Protocol::not_equal

    source
    fn Protocol::not_equal(x : Protocol, y : Protocol) -> Bool

    Protocol::to_repr

    source

    ProtocolInfo

    source
    pub(all) struct ProtocolInfo {
      protocol : Protocol
      code : UInt64
      name : String
      value_kind : ProtocolValueKind
    } derive(Eq, 
    Debug    )

    ProtocolInfo::equal

    source

    ProtocolInfo::not_equal

    source
    fn ProtocolInfo::not_equal(x : ProtocolInfo, y : ProtocolInfo) -> Bool

    ProtocolInfo::to_repr

    source

    ProtocolValue

    source
    pub(all) enum ProtocolValue {
      Empty
      Ipv4(Ipv4Address)
      Ipv6(Ipv6Address)
      Domain(String)
      Port(Int)
      PeerId(String)
      Text(String)
      Raw(Bytes)
    } derive(Eq, 
    Debug    )

    Typed values accepted by the Multiaddr domain model.

    ProtocolValue::equal

    source

    ProtocolValue::kind

    source

    ProtocolValue::not_equal

    source
    fn ProtocolValue::not_equal(x : ProtocolValue, y : ProtocolValue) -> Bool

    ProtocolValue::to_repr

    source

    ProtocolValueKind

    source
    pub(all) enum ProtocolValueKind {
      Empty
      Ipv4
      Ipv6
      Domain
      Port
      PeerId
      Text
      Raw
    } derive(Eq, 
    Debug    )

    ProtocolValueKind::equal

    source

    ProtocolValueKind::not_equal

    source
    fn ProtocolValueKind::not_equal(x : ProtocolValueKind, y : ProtocolValueKind) -> Bool

    ProtocolValueKind::to_repr

    source

    WireReader

    source
    pub struct WireReader {
      input : BytesView
      offset : Int
      limits : Limits
    }

    Bounded binary reader used by protocol codecs.

    WireReader::is_done

    source
    fn WireReader::is_done(self : WireReader) -> Bool

    WireReader::new

    source
    fn WireReader::new(input : BytesView, limits : Limits) -> Result[WireReader, MoonLoomError]

    WireReader::position

    source
    fn WireReader::position(self : WireReader) -> Int

    WireReader::read_fixed

    source
    fn WireReader::read_fixed(self : WireReader, context : String, length : Int) -> Result[BytesView, MoonLoomError]

    WireReader::read_length_prefixed

    source
    fn WireReader::read_length_prefixed(self : WireReader, context : String) -> Result[BytesView, MoonLoomError]

    WireReader::read_u16_be

    source
    fn WireReader::read_u16_be(self : WireReader, context : String) -> Result[Int, MoonLoomError]

    WireReader::read_varint

    source
    fn WireReader::read_varint(self : WireReader, context : String) -> Result[UInt64, MoonLoomError]

    WireReader::remaining

    source
    fn WireReader::remaining(self : WireReader) -> Int

    WireReader::remaining_view

    source
    fn WireReader::remaining_view(self : WireReader) -> BytesView

    WireWriter

    source
    pub struct WireWriter {
      buffer : 
    Buffer
    }

    Append-only binary writer used by protocol codecs.

    WireWriter::length

    source
    fn WireWriter::length(self : WireWriter) -> Int

    WireWriter::new

    source
    fn WireWriter::new() -> WireWriter

    WireWriter::to_bytes

    source
    fn WireWriter::to_bytes(self : WireWriter) -> Bytes

    WireWriter::write_byte

    source
    fn WireWriter::write_byte(self : WireWriter, value : Byte) -> Unit

    WireWriter::write_bytes

    source
    fn WireWriter::write_bytes(self : WireWriter, value : BytesView) -> Unit

    WireWriter::write_length_prefixed

    source
    fn WireWriter::write_length_prefixed(self : WireWriter, value : BytesView) -> Unit

    WireWriter::write_u16_be

    source
    fn WireWriter::write_u16_be(self : WireWriter, value : Int) -> Unit

    WireWriter::write_varint

    source
    fn WireWriter::write_varint(self : WireWriter, value : UInt64) -> Unit

    CID_VERSION_0

    source
    let CID_VERSION_0 : UInt64

    CID_VERSION_1

    source
    let CID_VERSION_1 : UInt64

    DAG_PB_CODEC

    source
    let DAG_PB_CODEC : UInt64

    RAW_CODEC

    source
    let RAW_CODEC : UInt64

    Common codec identifier for raw bytes.

    cid_from_content

    source
    fn cid_from_content(codec : UInt64, algorithm : HashAlgorithm, content : BytesView, provider : HashProvider, limits : Limits) -> Result[Cid, MoonLoomError]

    cid_v0_from_content

    source
    fn cid_v0_from_content(content : BytesView, provider : HashProvider, limits : Limits) -> Result[Cid, MoonLoomError]

    codec_table

    source
    fn codec_table() -> Array[CodecInfo]

    decode_u64

    source
    fn decode_u64(input : BytesView) -> Result[(UInt64, Int), MoonLoomError]

    Decode an unsigned varint with the default resource limits.

    decode_u64_with_limits

    source
    fn decode_u64_with_limits(input : BytesView, limits : Limits) -> Result[(UInt64, Int), MoonLoomError]

    Decode one unsigned varint and return the value together with the number of bytes consumed. Trailing bytes are intentionally left to the caller.

    encode_u64

    source
    fn encode_u64(value : UInt64) -> Bytes

    Encode an unsigned 64-bit integer using the Multiformats unsigned varint representation (unsigned LEB128, minimal form).

    multibase_decode

    source
    fn multibase_decode(text : StringView, limits : Limits) -> Result[DecodedMultibase, MoonLoomError]

    multibase_encode

    source
    fn multibase_encode(base : Base, data : BytesView) -> Result[String, MoonLoomError]

    multicodec_code

    source
    fn multicodec_code(name : StringView) -> UInt64?

    multicodec_count

    source
    fn multicodec_count() -> Int

    multicodec_info

    source
    fn multicodec_info(code : UInt64) -> CodecInfo?

    multicodec_name

    source
    fn multicodec_name(code : UInt64) -> String?

    protocol_info

    source
    fn protocol_info(protocol : Protocol) -> ProtocolInfo?

    protocol_info_by_code

    source
    fn protocol_info_by_code(code : UInt64) -> ProtocolInfo?

    protocol_table

    source
    fn protocol_table() -> Array[ProtocolInfo]

    sha2_provider

    source
    fn sha2_provider() -> HashProvider

    Built-in provider backed by the reviewed MoonCrypt SHA-2 implementation.

    supported_bases

    source
    fn supported_bases() -> Array[Base]

    supported_hash_algorithms

    source
    fn supported_hash_algorithms() -> Array[HashAlgorithm]

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io