🥮 mooncakes.io

    moonloom

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

    multiformats
    multibase
    multicodec
    multihash
    cid
    multiaddr
    Download zip
    Version
    0.1.1
    License
    Apache-2.0
    Repository
    Last updated
    9 hours ago
    Downloads
    2

    Dependencies

    #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.

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

    #Features

    • Canonical unsigned varint encoding and strict decoding.
    • Multibase for base16, base32, base58btc, base64, and URL-safe base64.
    • One registry for CID, hash, content format, and Multiaddr protocol metadata.
    • Multihash with identity, sha2-256, and sha2-512.
    • CIDv0 and CIDv1 creation, parsing, canonical text, and verification.
    • Typed Multiaddr model, strict text parser, binary codec, and RFC 5952 IPv6 canonical text.
    • Reusable bounded WireReader and WireWriter primitives.
    • Typed errors, byte offsets, and configurable resource limits.
    • Multibase, Multihash, CID, and Multiaddr CLI commands.
    • wasm, wasm-gc, JS, and Native target checking.

    #Install

    moon add ggbond44439/moonloom@0.1.1

    In another MoonBit package:

    import {
  "ggbond44439/moonloom" @moonloom,
}

    #Quick start

    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(
      @moonloom.RAW_CODEC,
      @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(()),
    )

    #CLI

    moonloom --help
moonloom version

moonloom multibase encode [--base <name>] <text>
moonloom multibase decode <multibase-text>

moonloom multihash digest [--algorithm sha2-256|sha2-512] <text>
moonloom multihash inspect <multibase-multihash>
moonloom multihash verify <multibase-multihash> <text>

moonloom cid encode [--version 0|1] [--codec <name>] [--algorithm <name>] <text>
moonloom cid decode <cid>
moonloom cid verify <cid> <text>

moonloom multiaddr parse <text>
moonloom multiaddr encode <text>
moonloom multiaddr decode [--format base64|hex] <data>

    Run the local CLI with:

    moon run cmd/main -- version
moon run cmd/main -- cid encode hello

    #Examples

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

    #Standards

    • RFC 4648 base encodings
    • Multiformats Multibase, Multicodec, Multihash, CID, and Multiaddr
    • RFC 5952 IPv6 canonical text
    • SHA-2 through the Apache-2.0 MoonCrypt package

    #Build and test

    moon check --target all
moon test --target all
moon build
moon package --list

    #Status

    MoonLoom 0.1.1 is the format-core release for the 2026 September MoonBit Hackathon. The library, CLI, examples, interoperability 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