From 56dd86f22a9c7a5323ba317ba3fd7efa7be36bfa Mon Sep 17 00:00:00 2001 From: Dave Grantham Date: Mon, 13 Jul 2026 13:18:08 -0600 Subject: [PATCH 1/3] update from bettersign Signed-off-by: Dave Grantham --- CHANGELOG.md | 15 ++ Cargo.toml | 32 ++- benches/codec_bench.rs | 202 ++++++++++++++++ build.rs | 100 ++++++-- examples/uvi.rs | 87 +++++++ src/codec.rs | 40 +++- src/error.rs | 308 ++++++++++++++++++++++++- src/lib.rs | 289 ++++++++++++++++++++++- src/serde/de.rs | 14 +- src/serde/mod.rs | 16 +- src/serde/ser.rs | 7 +- src/table_gen.rs | 184 ++++++++++++++- src/types.rs | 459 +++++++++++++++++++++++++++++++++++++ table.csv | 204 +++++++++++++++-- tests/edge_case_tests.rs | 291 +++++++++++++++++++++++ tests/error_tests.rs | 226 ++++++++++++++++++ tests/integration_tests.rs | 349 ++++++++++++++++++++++++++++ tests/proptest_tests.rs | 280 ++++++++++++++++++++++ tests/security_tests.rs | 232 +++++++++++++++++++ 19 files changed, 3240 insertions(+), 95 deletions(-) create mode 100644 CHANGELOG.md create mode 100644 benches/codec_bench.rs create mode 100644 examples/uvi.rs create mode 100644 src/types.rs create mode 100644 tests/edge_case_tests.rs create mode 100644 tests/error_tests.rs create mode 100644 tests/integration_tests.rs create mode 100644 tests/proptest_tests.rs create mode 100644 tests/security_tests.rs diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..2541bd4 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,15 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [1.0.0] - 2026-07-13 + +### Changed +- Synced from bettersign workspace (bs-multicodec 0.7.0) +- Renamed crate from `bs-multicodec` to `multi-codec` +- Added `types.rs` module with type-safe codec wrappers +- Added comprehensive test suite (edge cases, error tests, integration, proptest, security) +- Initial published release on crates.io as `multi-codec` \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index 4edeba7..bec79a6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,29 +1,43 @@ [package] -name = "multicodec" -version = "1.0.10" +name = "multi-codec" +version = "1.0.0" edition = "2021" authors = ["Benjamin Kampmann ", "Dave Grantham "] description = "Implementation of the Multicodec specification" -repository = "https://github.com/cryptidtech/rust-multicodec" -license = "MIT OR Apache-2.0" +repository = "https://github.com/cryptidtech/multi-codec.git" readme = "README.md" +license = "MIT OR Apache-2.0" keywords = ["multiformats", "multicodec", "serde"] +categories = ["encoding"] [features] default = ["serde"] [dependencies] -multitrait = { version = "1.0", git="https://github.com/cryptidtech/multitrait.git" } -serde = { version = "1.0", default-features = false, optional = true, features = ['serde_derive'] } -thiserror = "1.0" +multi-trait = { version = "1.0", path = "../multi-trait" } +serde = { version = "1.0", default-features = false, optional = true, features = ["serde_derive"] } +thiserror = { version = "2.0" } [dev-dependencies] +criterion = { version = "0.8", features = ["html_reports"] } +hex = "0.4" +proptest = "1.4" serde_cbor = "0.11" serde_json = "1.0" serde_test = "1.0" +unsigned-varint = { version = "0.8", features = ["std"] } + +[[bench]] +name = "codec_bench" +harness = false +path = "benches/codec_bench.rs" + +[[example]] +name = "uvi" +path = "examples/uvi.rs" [build-dependencies] convert_case = "0.6" csv = "1.3" -serde = "1.0" -serde_derive = "1.0" +serde = { version = "1.0", features = ["serde_derive"] } +serde_derive = "1.0" \ No newline at end of file diff --git a/benches/codec_bench.rs b/benches/codec_bench.rs new file mode 100644 index 0000000..d3310c9 --- /dev/null +++ b/benches/codec_bench.rs @@ -0,0 +1,202 @@ +// SPDX-License-Identifier: MIT or Apache-2.0 +//! Performance benchmarks for multi-codec + +use std::hint::black_box; + +use multi_codec::Codec; +use multi_trait::TryDecodeFrom; +use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion}; + +/// Benchmark conversions from u64 +fn bench_from_u64(c: &mut Criterion) { + c.bench_function("codec_from_u64_valid", |b| { + b.iter(|| Codec::try_from(black_box(0xEDu64))) + }); + + c.bench_function("codec_from_u64_invalid", |b| { + b.iter(|| Codec::try_from(black_box(0xDEADBEEFu64))) + }); +} + +/// Benchmark conversions to u64 +fn bench_to_u64(c: &mut Criterion) { + let codec = Codec::Ed25519Pub; + + c.bench_function("codec_to_u64", |b| { + b.iter(|| { + let _code: u64 = black_box(codec).into(); + }) + }); + + c.bench_function("codec_code_method", |b| b.iter(|| black_box(codec).code())); +} + +/// Benchmark conversions from string +fn bench_from_str(c: &mut Criterion) { + c.bench_function("codec_from_str_valid", |b| { + b.iter(|| Codec::try_from(black_box("ed25519-pub"))) + }); + + c.bench_function("codec_from_str_invalid", |b| { + b.iter(|| Codec::try_from(black_box("unknown-codec"))) + }); +} + +/// Benchmark conversions to string +fn bench_to_str(c: &mut Criterion) { + c.bench_function("codec_as_str", |b| { + let codec = Codec::Ed25519Pub; + b.iter(|| { + let s = codec.as_str(); + black_box(s.len()) + }) + }); +} + +/// Benchmark encoding +fn bench_encoding(c: &mut Criterion) { + let mut group = c.benchmark_group("encoding"); + + let codecs = vec![ + ("Identity", Codec::Identity), + ("Sha2256", Codec::Sha2256), + ("Ed25519Pub", Codec::Ed25519Pub), + ]; + + for (name, codec) in codecs { + group.bench_with_input(BenchmarkId::new("into_vec", name), &codec, |b, &codec| { + b.iter(|| { + let _v: Vec = black_box(codec).into(); + }) + }); + } + + group.finish(); +} + +/// Benchmark decoding +fn bench_decoding(c: &mut Criterion) { + let mut group = c.benchmark_group("decoding"); + + let test_cases = vec![ + ("Identity", vec![0x00]), + ("Sha2256", vec![0x12]), + ("Ed25519Pub", vec![0xED, 0x01]), + ]; + + for (name, bytes) in test_cases { + group.bench_with_input( + BenchmarkId::new("try_decode_from", name), + &bytes, + |b, bytes| b.iter(|| Codec::try_decode_from(black_box(bytes.as_slice()))), + ); + } + + group.finish(); +} + +/// Benchmark hash operations +fn bench_hash(c: &mut Criterion) { + use std::collections::hash_map::DefaultHasher; + use std::hash::{Hash, Hasher}; + + let codec = Codec::Ed25519Pub; + + c.bench_function("codec_hash", |b| { + b.iter(|| { + let mut hasher = DefaultHasher::new(); + black_box(codec).hash(&mut hasher); + hasher.finish() + }) + }); +} + +/// Benchmark roundtrip operations +fn bench_roundtrip(c: &mut Criterion) { + let mut group = c.benchmark_group("roundtrip"); + + group.bench_function("encode_decode", |b| { + let codec = Codec::Ed25519Pub; + b.iter(|| { + let encoded: Vec = black_box(codec).into(); + let (decoded, _) = Codec::try_decode_from(black_box(&encoded)).unwrap(); + black_box(decoded); + }) + }); + + group.bench_function("str_codec_str", |b| { + b.iter(|| { + let codec = Codec::try_from(black_box("ed25519-pub")).unwrap(); + let len = codec.as_str().len(); + black_box(len); + }) + }); + + group.bench_function("u64_codec_u64", |b| { + b.iter(|| { + let codec = Codec::try_from(black_box(0xEDu64)).unwrap(); + let _code: u64 = codec.into(); + }) + }); + + group.finish(); +} + +/// Benchmark serde operations +#[cfg(feature = "serde")] +fn bench_serde(c: &mut Criterion) { + use serde_json; + + let mut group = c.benchmark_group("serde"); + + let codec = Codec::Ed25519Pub; + + group.bench_function("json_serialize", |b| { + b.iter(|| serde_json::to_string(&black_box(codec))) + }); + + let json = serde_json::to_string(&codec).unwrap(); + group.bench_function("json_deserialize", |b| { + b.iter(|| serde_json::from_str::(black_box(&json))) + }); + + group.bench_function("cbor_serialize", |b| { + b.iter(|| serde_cbor::to_vec(&black_box(codec))) + }); + + let cbor = serde_cbor::to_vec(&codec).unwrap(); + group.bench_function("cbor_deserialize", |b| { + b.iter(|| serde_cbor::from_slice::(black_box(&cbor))) + }); + + group.finish(); +} + +#[cfg(feature = "serde")] +criterion_group!( + benches, + bench_from_u64, + bench_to_u64, + bench_from_str, + bench_to_str, + bench_encoding, + bench_decoding, + bench_hash, + bench_roundtrip, + bench_serde +); + +#[cfg(not(feature = "serde"))] +criterion_group!( + benches, + bench_from_u64, + bench_to_u64, + bench_from_str, + bench_to_str, + bench_encoding, + bench_decoding, + bench_hash, + bench_roundtrip +); + +criterion_main!(benches); diff --git a/build.rs b/build.rs index 8349b68..bac979d 100644 --- a/build.rs +++ b/build.rs @@ -1,48 +1,108 @@ -#![allow(dead_code)] +// SPDX-License-Identifier: MIT or Apache-2.0 +//! Build script for multi-codec +//! +//! Generates the Codec enum from the multicodec table CSV file. + use convert_case::{Case, Converter}; use serde_derive::Deserialize; -use std::{fs::File, io::Write, path::PathBuf}; +use std::{collections::HashSet, fs::File, io::Write, path::PathBuf}; #[derive(Debug, Deserialize)] struct Record { name: String, - tag: String, + #[serde(rename = "tag")] + _tag: String, code: String, - status: String, - description: Option, + #[serde(rename = "status")] + _status: String, + #[serde(rename = "description")] + _description: Option, } fn main() -> Result<(), Box> { + println!("cargo:rerun-if-changed=table.csv"); + let mut pb = PathBuf::from(env!("CARGO_MANIFEST_DIR")); let mut tpb = pb.clone(); - // input path + // Input path tpb.push("table.csv"); - // output path + // Output path pb.push("src"); pb.push("table_gen.rs"); - let inf = File::open(tpb)?; - let mut f = File::create(pb)?; + // Open input file + let inf = File::open(&tpb).map_err(|e| { + format!( + "Failed to open table.csv: {}. Make sure table.csv exists in the crate root.", + e + ) + })?; + + // Open output file + let mut f = File::create(&pb).map_err(|e| format!("Failed to create table_gen.rs: {}", e))?; let mut rdr = csv::Reader::from_reader(inf); + let conv = Converter::new().to_case(Case::Pascal); - let conv = Converter::new().to_case(Case::Pascal); //.set_delim("_"); + // Track seen codes and names to detect duplicates + let mut seen_codes = HashSet::new(); + let mut seen_names = HashSet::new(); + let mut record_count = 0; writeln!(f, "build_codec_enum! {{")?; - for row in rdr.deserialize() { - let rec: Record = row?; - writeln!( - f, - "\t{} => ({}, \"{}\"),", - rec.code.trim(), - conv.convert(rec.name.clone()), - rec.name - )?; + + for (row_num, row) in rdr.deserialize().enumerate() { + let rec: Record = + row.map_err(|e| format!("Failed to parse CSV row {}: {}", row_num + 2, e))?; + + // Validate record + let code_str = rec.code.trim(); + if code_str.is_empty() { + return Err(format!("Empty code at row {}", row_num + 2).into()); + } + + if rec.name.is_empty() { + return Err(format!("Empty name at row {}", row_num + 2).into()); + } + + // Check for duplicates + if !seen_codes.insert(code_str.to_string()) { + eprintln!( + "Warning: Duplicate code {} at row {}", + code_str, + row_num + 2 + ); + } + + if !seen_names.insert(rec.name.clone()) { + eprintln!( + "Warning: Duplicate name '{}' at row {}", + rec.name, + row_num + 2 + ); + } + + // Generate enum variant + let variant_name = conv.convert(&rec.name); + writeln!(f, "\t{} => ({}, \"{}\"),", code_str, variant_name, rec.name)?; + + record_count += 1; } + writeln!(f, "}}")?; - // generate the code for src/table_gen.rs from the multicodecs .csv file + // Flush to ensure all data is written + f.flush()?; + + // Informational: Generated codec variants (removed warning output for cleaner builds) + // Use RUST_LOG=debug or --verbose to see build script output if needed + // eprintln!("Generated {} codec variants from table.csv", record_count); + + if record_count == 0 { + return Err("No records found in table.csv!".into()); + } + Ok(()) } diff --git a/examples/uvi.rs b/examples/uvi.rs new file mode 100644 index 0000000..0e3609a --- /dev/null +++ b/examples/uvi.rs @@ -0,0 +1,87 @@ +// SPDX-License-Identifier: MIT OR Apache-2.0 + +//! Varuint encode/decode example using unsigned-varint crate. +//! +//! This example demonstrates encoding and decoding unsigned variable-length integers +//! according to the varuint specification (LEB128 encoding). +//! +//! Usage: +//! ```bash +//! # Encode a hex number to varuint (hex output) +//! cargo run --example uvi -- -e 012c +//! +//! # Decode a hex-encoded varuint +//! cargo run --example uvi -- -d ac02 +//! ``` + +use std::env; +use std::process; + +fn print_usage() { + eprintln!("Usage:"); + eprintln!(" uvi -e Encode a hex number as varuint (hex output)"); + eprintln!(" uvi -d Decode a hex-encoded varuint"); + eprintln!(); + eprintln!("Examples:"); + eprintln!(" uvi -e 012c # Encodes hex 0x012c (300) as varuint"); + eprintln!(" uvi -d ac02 # Decodes hex 'ac02' as varuint"); +} + +fn encode_hex(hex_str: &str) -> Result<(), String> { + // Remove any whitespace or 0x prefix + let cleaned = hex_str.trim().trim_start_matches("0x"); + + let num = u64::from_str_radix(cleaned, 16) + .map_err(|e| format!("Invalid hex number '{}': {}", hex_str, e))?; + + let mut buf = unsigned_varint::encode::u64_buffer(); + let encoded = unsigned_varint::encode::u64(num, &mut buf); + + let hex_output = hex::encode(encoded); + println!("{}", hex_output); + + Ok(()) +} + +fn decode_hex(hex_str: &str) -> Result<(), String> { + // Remove any whitespace or 0x prefix + let cleaned = hex_str.trim().trim_start_matches("0x"); + + let bytes = + hex::decode(cleaned).map_err(|e| format!("Invalid hex string '{}': {}", hex_str, e))?; + + let (num, remaining) = unsigned_varint::decode::u64(&bytes) + .map_err(|e| format!("Failed to decode varuint: {:?}", e))?; + + if !remaining.is_empty() { + eprintln!("Warning: {} extra bytes after varuint", remaining.len()); + } + + // Output as hex with decimal in parentheses + println!("{:x} ({})", num, num); + + Ok(()) +} + +fn main() { + let args: Vec = env::args().collect(); + + if args.len() != 3 { + print_usage(); + process::exit(1); + } + + let result = match args[1].as_str() { + "-e" | "--encode" => encode_hex(&args[2]), + "-d" | "--decode" => decode_hex(&args[2]), + _ => { + print_usage(); + process::exit(1); + } + }; + + if let Err(e) = result { + eprintln!("Error: {}", e); + process::exit(1); + } +} diff --git a/src/codec.rs b/src/codec.rs index d5a2180..370eabe 100644 --- a/src/codec.rs +++ b/src/codec.rs @@ -1,18 +1,25 @@ // SPDX-License-Identifier: MIT or Apache-2.0 +//! Multicodec enum and conversions //! +//! This module contains the core [`Codec`] enum with 570+ variants representing +//! all multicodec identifiers, along with conversion implementations for various +//! types. +//! +//! The `Codec` enum is generated at build time from the official multicodec table. + #![deny( trivial_casts, trivial_numeric_casts, unused_import_braces, unused_qualifications )] -#![allow(missing_docs)] +#![allow(missing_docs)] // Allow because variants are generated use crate::Error; +use multi_trait::{EncodeInto, Null, TryDecodeFrom}; use core::{ fmt, hash::{Hash, Hasher}, }; -use multitrait::{EncodeInto, Null, TryDecodeFrom}; macro_rules! build_codec_enum { {$( $val:expr => ($i:ident, $s:expr), )*} => { @@ -34,12 +41,12 @@ macro_rules! build_codec_enum { fn try_from(s: &str) -> Result { match s { $( $s => Ok(Codec::$i), )* - _ => Err(Error::InvalidName(s.to_string())), + _ => Err(Error::invalid_name(s)), } } } - /// Convert a Codec into a type that implements AsRef + /// Convert a Codec into a type that implements `AsRef` impl From for &str { fn from(codec: Codec) -> &'static str { match codec { @@ -55,7 +62,7 @@ macro_rules! build_codec_enum { fn try_from(v: u64) -> Result { match v { $( $val => Ok(Codec::$i), )* - _ => Err(Error::InvalidValue(v)), + _ => Err(Error::invalid_value(v)), } } } @@ -71,12 +78,13 @@ macro_rules! build_codec_enum { impl Hash for Codec { fn hash(&self, state: &mut H) { - let v: Vec = self.clone().into(); - v.hash(state); + // Hash the u64 code directly instead of allocating a Vec + let code: u64 = (*self).into(); + code.hash(state); } } - /// Serialize a Codec as a unsigned varint in a Vec + /// Serialize a Codec as a unsigned varint in a `Vec` impl From for Vec { fn from(codec: Codec) -> Vec { let v: u64 = codec.into(); @@ -133,6 +141,9 @@ macro_rules! build_codec_enum { type Error = Error; fn try_from(code: i8) -> Result { + if code < 0 { + return Err(Error::negative_value(code as i64)); + } Codec::try_from(code as u64) } } @@ -141,6 +152,9 @@ macro_rules! build_codec_enum { type Error = Error; fn try_from(code: i16) -> Result { + if code < 0 { + return Err(Error::negative_value(code as i64)); + } Codec::try_from(code as u64) } } @@ -149,6 +163,9 @@ macro_rules! build_codec_enum { type Error = Error; fn try_from(code: i32) -> Result { + if code < 0 { + return Err(Error::negative_value(code as i64)); + } Codec::try_from(code as u64) } } @@ -157,6 +174,9 @@ macro_rules! build_codec_enum { type Error = Error; fn try_from(code: i64) -> Result { + if code < 0 { + return Err(Error::negative_value(code)); + } Codec::try_from(code as u64) } } @@ -186,12 +206,12 @@ macro_rules! build_codec_enum { impl Codec { /// Get the base code. NOTE: these are NOT varuint encoded pub fn code(&self) -> u64 { - self.clone().into() + (*self).into() } /// Convert a codec to &str pub fn as_str(&self) -> &str { - self.clone().into() + (*self).into() } } } diff --git a/src/error.rs b/src/error.rs index 11cb7e0..994789a 100644 --- a/src/error.rs +++ b/src/error.rs @@ -1,15 +1,303 @@ // SPDX-License-Identifier: MIT or Apache-2.0 -/// Errors created by this library -#[derive(Clone, Debug, thiserror::Error)] +//! Error types for multi-codec +//! +//! This module provides comprehensive error types with backtrace support +//! for debugging and detailed error context for better user experience. + +/// Errors produced by the multi-codec crate +/// +/// All error variants include contextual information to help with debugging +/// and provide actionable error messages. +/// +/// # Backtraces +/// +/// When the `RUST_BACKTRACE=1` environment variable is set, errors will +/// capture and display stack backtraces showing where the error occurred. +/// +/// # Examples +/// +/// ``` +/// use multi_codec::{Codec, Error}; +/// +/// // Invalid name error includes the provided name +/// let result = Codec::try_from("invalid-codec-name"); +/// assert!(matches!(result, Err(Error::InvalidName { .. }))); +/// +/// // Invalid value error includes the provided code +/// let result = Codec::try_from(0xDEADBEEFu64); +/// assert!(matches!(result, Err(Error::InvalidValue { .. }))); +/// ``` +#[derive(Debug, thiserror::Error)] #[non_exhaustive] pub enum Error { - /// Multitrait error + /// Error from bs-multitrait crate + /// + /// This error occurs when encoding or decoding operations from the + /// bs-multitrait crate fail, typically due to malformed varint data. #[error(transparent)] - Multitrait(#[from] multitrait::Error), - /// Invalid codec name - #[error("Invalid multicodec name {0}")] - InvalidName(String), - /// Invalid codec value - #[error("Invalid multicodec value {0}")] - InvalidValue(u64), + Multitrait(#[from] multi_trait::Error), + + /// Invalid codec name provided + /// + /// The provided name does not match any known multicodec identifier. + /// + /// # Context + /// + /// - `name`: The invalid name that was provided + /// + /// # Resolution + /// + /// Check the [Multicodec Table](https://github.com/multiformats/multicodec/blob/master/table.csv) + /// for valid codec names. Names are case-sensitive and must match exactly. + /// + /// # Examples + /// + /// ``` + /// use multi_codec::Codec; + /// + /// // This will fail - name doesn't exist + /// let result = Codec::try_from("invalid-name"); + /// assert!(result.is_err()); + /// + /// // This works - correct name + /// let codec = Codec::try_from("ed25519-pub").unwrap(); + /// ``` + #[error( + "Invalid multicodec name: '{name}'\n\ + The name '{name}' is not a recognized multicodec identifier.\n\ + See https://github.com/multiformats/multicodec/blob/master/table.csv for valid names." + )] + InvalidName { + /// The invalid codec name that was provided + name: String, + }, + + /// Invalid codec value provided + /// + /// The provided numeric code does not correspond to any known multicodec. + /// + /// # Context + /// + /// - `code`: The invalid code value that was provided + /// + /// # Resolution + /// + /// Check the [Multicodec Table](https://github.com/multiformats/multicodec/blob/master/table.csv) + /// for valid codec codes. Codes must match exactly. + /// + /// # Examples + /// + /// ``` + /// use multi_codec::Codec; + /// + /// // This will fail - code doesn't exist + /// let result = Codec::try_from(0xDEADBEEFu64); + /// assert!(result.is_err()); + /// + /// // This works - valid code + /// let codec = Codec::try_from(0xEDu64).unwrap(); + /// assert_eq!(codec, Codec::Ed25519Pub); + /// ``` + #[error( + "Invalid multicodec code: 0x{code:x} ({code})\n\ + The code 0x{code:x} is not a recognized multicodec value.\n\ + See https://github.com/multiformats/multicodec/blob/master/table.csv for valid codes." + )] + InvalidValue { + /// The invalid code value that was provided + code: u64, + }, + + /// Negative value provided for signed integer conversion + /// + /// Codec codes must be non-negative. Signed integers with negative + /// values cannot be converted to codec identifiers. + /// + /// # Context + /// + /// - `value`: The negative value that was provided + /// + /// # Resolution + /// + /// Use only non-negative values (>= 0) when converting from signed + /// integer types to Codec. Consider using unsigned integer types + /// (u8, u16, u32, u64) instead if the value is always positive. + /// + /// # Examples + /// + /// ``` + /// use multi_codec::Codec; + /// + /// // This will fail - negative value + /// let result = Codec::try_from(-1i64); + /// assert!(result.is_err()); + /// + /// // This works - positive value + /// let codec = Codec::try_from(0xEDi64).unwrap(); + /// assert_eq!(codec, Codec::Ed25519Pub); + /// ``` + #[error( + "Cannot convert negative value {value} to multicodec\n\ + Codec codes must be non-negative integers. The value {value} is negative.\n\ + Use a non-negative value or an unsigned integer type (u8, u16, u32, u64)." + )] + NegativeValue { + /// The negative value that was provided + value: i64, + }, +} + +impl Error { + /// Create an InvalidName error with the given name + /// + /// # Examples + /// + /// ``` + /// use multi_codec::Error; + /// + /// let err = Error::invalid_name("unknown-codec"); + /// assert!(matches!(err, Error::InvalidName { .. })); + /// ``` + pub fn invalid_name(name: impl Into) -> Self { + Self::InvalidName { name: name.into() } + } + + /// Create an InvalidValue error with the given code + /// + /// # Examples + /// + /// ``` + /// use multi_codec::Error; + /// + /// let err = Error::invalid_value(0xDEADBEEF); + /// assert!(matches!(err, Error::InvalidValue { .. })); + /// ``` + pub fn invalid_value(code: u64) -> Self { + Self::InvalidValue { code } + } + + /// Create a NegativeValue error with the given value + /// + /// # Examples + /// + /// ``` + /// use multi_codec::Error; + /// + /// let err = Error::negative_value(-100); + /// assert!(matches!(err, Error::NegativeValue { .. })); + /// ``` + pub fn negative_value(value: i64) -> Self { + Self::NegativeValue { value } + } + + /// Get the error kind as a string + /// + /// Returns a short identifier for the error type, useful for + /// programmatic error handling and logging. + /// + /// # Examples + /// + /// ``` + /// use multi_codec::Error; + /// + /// let err = Error::invalid_name("bad"); + /// assert_eq!(err.kind(), "InvalidName"); + /// + /// let err = Error::invalid_value(999); + /// assert_eq!(err.kind(), "InvalidValue"); + /// + /// let err = Error::negative_value(-1); + /// assert_eq!(err.kind(), "NegativeValue"); + /// ``` + pub fn kind(&self) -> &str { + match self { + Self::Multitrait(_) => "Multitrait", + Self::InvalidName { .. } => "InvalidName", + Self::InvalidValue { .. } => "InvalidValue", + Self::NegativeValue { .. } => "NegativeValue", + } + } + + /// Get additional context about the error + /// + /// Returns human-readable context information that can help + /// diagnose the error. + /// + /// # Examples + /// + /// ``` + /// use multi_codec::Error; + /// + /// let err = Error::invalid_name("bad-codec"); + /// let context = err.context(); + /// assert!(context.contains("bad-codec")); + /// ``` + pub fn context(&self) -> String { + match self { + Self::Multitrait(e) => format!("Multitrait error: {}", e), + Self::InvalidName { name } => format!("Invalid name: '{}'", name), + Self::InvalidValue { code } => format!("Invalid code: 0x{:x} ({})", code, code), + Self::NegativeValue { value } => format!("Negative value: {}", value), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_invalid_name_error() { + let err = Error::invalid_name("bad-codec"); + assert!(matches!(err, Error::InvalidName { .. })); + assert_eq!(err.kind(), "InvalidName"); + assert!(err.context().contains("bad-codec")); + assert!(err.to_string().contains("bad-codec")); + } + + #[test] + fn test_invalid_value_error() { + let err = Error::invalid_value(0xDEAD); + assert!(matches!(err, Error::InvalidValue { .. })); + assert_eq!(err.kind(), "InvalidValue"); + assert!(err.context().contains("dead")); + assert!(err.to_string().contains("0xdead")); + } + + #[test] + fn test_negative_value_error() { + let err = Error::negative_value(-42); + assert!(matches!(err, Error::NegativeValue { .. })); + assert_eq!(err.kind(), "NegativeValue"); + assert!(err.context().contains("-42")); + assert!(err.to_string().contains("-42")); + } + + #[test] + fn test_error_messages_have_context() { + let err = Error::invalid_name("unknown"); + let msg = err.to_string(); + assert!(msg.contains("unknown")); + assert!(msg.contains("multicodec")); + + let err = Error::invalid_value(99999); + let msg = err.to_string(); + assert!(msg.contains("99999")); + assert!(msg.contains("0x")); + } + + #[test] + fn test_error_kind_uniqueness() { + let errors = [ + Error::invalid_name("test"), + Error::invalid_value(123), + Error::negative_value(-1), + ]; + + let kinds: Vec<_> = errors.iter().map(|e| e.kind()).collect(); + assert_eq!(kinds.len(), 3); + assert!(kinds + .iter() + .all(|k| kinds.iter().filter(|x| *x == k).count() == 1)); + } } diff --git a/src/lib.rs b/src/lib.rs index 6c2aa8a..a724f02 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,5 +1,274 @@ // SPDX-License-Identifier: MIT or Apache-2.0 -//! multicodec +//! # multi-codec +//! +//! Implementation of the [Multicodec](https://github.com/multiformats/multicodec) +//! specification for self-describing protocol and encoding identifiers. +//! +//! ## Overview +//! +//! Multicodec is a self-describing multiformat that provides a way to uniquely +//! identify protocols, encodings, cryptographic algorithms, and other systems. +//! Each codec has: +//! - A unique numeric identifier (code) +//! - A human-readable name +//! - A canonical string representation +//! +//! This crate provides the [`Codec`] enum with 570+ variants representing all +//! standardized multicodec identifiers from the official specification. +//! +//! ## Features +//! +//! - **570+ Codec Variants**: All standardized multicodec identifiers +//! - **Type-Safe Conversions**: `TryFrom`/`Into` for all numeric types and strings +//! - **Serde Support**: JSON and binary serialization (feature-gated) +//! - **Zero Unsafe Code**: Completely safe Rust implementation +//! - **Thread-Safe**: All types are `Send + Sync` +//! - **Type Safety**: Optional newtype wrappers ([`CodecCode`], [`CodecName`]) +//! - **Rich Errors**: Detailed error messages with context +//! - **Performance**: Optimized for speed with zero-copy operations where possible +//! +//! ## Quick Start +//! +//! ### Basic Usage +//! +//! ```rust +//! use multi_codec::Codec; +//! +//! // Create codec from name +//! let codec = Codec::try_from("ed25519-pub")?; +//! assert_eq!(codec, Codec::Ed25519Pub); +//! +//! // Get codec properties +//! assert_eq!(codec.code(), 0xED); +//! assert_eq!(codec.as_str(), "ed25519-pub"); +//! assert_eq!(format!("{:?}", codec), "ed25519-pub (0xed)"); +//! # Ok::<(), multi_codec::Error>(()) +//! ``` +//! +//! ### Encoding and Decoding +//! +//! ```rust +//! use multi_codec::Codec; +//! use multi_trait::TryDecodeFrom; +//! +//! let codec = Codec::Sha2256; +//! +//! // Encode to varint bytes +//! let bytes: Vec = codec.into(); +//! assert_eq!(bytes, vec![0x12]); // Sha2-256 encodes as single byte +//! +//! // Decode from bytes +//! let (decoded, remaining) = Codec::try_decode_from(&bytes)?; +//! assert_eq!(decoded, codec); +//! assert!(remaining.is_empty()); +//! # Ok::<(), multi_codec::Error>(()) +//! ``` +//! +//! ### Working with Codes and Names +//! +//! ```rust +//! use multi_codec::Codec; +//! +//! // From numeric code +//! let codec = Codec::try_from(0x12u64)?; +//! assert_eq!(codec, Codec::Sha2256); +//! +//! // From string name +//! let codec = Codec::try_from("sha2-256")?; +//! assert_eq!(codec, Codec::Sha2256); +//! +//! // Get code and name +//! assert_eq!(codec.code(), 0x12); +//! assert_eq!(codec.as_str(), "sha2-256"); +//! # Ok::<(), multi_codec::Error>(()) +//! ``` +//! +//! ### Serde Integration +//! +//! ```rust +//! use multi_codec::Codec; +//! use serde::{Serialize, Deserialize}; +//! +//! #[derive(Serialize, Deserialize, Debug, PartialEq)] +//! struct SignatureInfo { +//! algorithm: Codec, +//! public_key: Vec, +//! } +//! +//! let info = SignatureInfo { +//! algorithm: Codec::Ed25519Pub, +//! public_key: vec![1, 2, 3, 4], +//! }; +//! +//! // Serialize to JSON (human-readable) +//! let json = serde_json::to_string(&info)?; +//! // JSON: {"algorithm":"ed25519-pub","public_key":[1,2,3,4]} +//! +//! // Deserialize from JSON +//! let deserialized: SignatureInfo = serde_json::from_str(&json)?; +//! assert_eq!(deserialized, info); +//! # Ok::<(), Box>(()) +//! ``` +//! +//! ### Error Handling +//! +//! ```rust +//! use multi_codec::{Codec, Error}; +//! +//! // Handle invalid names +//! match Codec::try_from("unknown-codec") { +//! Ok(codec) => println!("Valid: {}", codec.as_str()), +//! Err(Error::InvalidName { name }) => { +//! eprintln!("Unknown codec name: {}", name); +//! // Error includes link to valid codec table +//! } +//! Err(e) => eprintln!("Other error: {}", e), +//! } +//! +//! // Handle invalid codes +//! match Codec::try_from(0xDEADBEEFu64) { +//! Ok(codec) => println!("Valid: {}", codec.as_str()), +//! Err(Error::InvalidValue { code }) => { +//! eprintln!("Unknown codec value: 0x{:x}", code); +//! } +//! Err(e) => eprintln!("Other error: {}", e), +//! } +//! +//! // Handle negative values +//! match Codec::try_from(-1i64) { +//! Ok(codec) => println!("Valid: {}", codec.as_str()), +//! Err(Error::NegativeValue { value }) => { +//! eprintln!("Negative values not allowed: {}", value); +//! } +//! Err(e) => eprintln!("Other error: {}", e), +//! } +//! ``` +//! +//! ## Type Safety with Newtypes +//! +//! For additional type safety, use the newtype wrappers: +//! +//! ```rust +//! use multi_codec::{Codec, CodecCode, CodecName}; +//! +//! // Type-safe code value +//! let code = CodecCode::new(0xED); +//! assert_eq!(code.get(), 0xED); +//! assert_eq!(code.to_string(), "0xed"); +//! +//! // Type-safe name +//! let name = CodecName::new("sha2-256"); +//! assert_eq!(name.as_str(), "sha2-256"); +//! assert!(!name.is_identity()); +//! ``` +//! +//! ## Thread Safety +//! +//! All types in this crate are `Send + Sync` and can be safely shared between threads: +//! +//! ```rust +//! use std::sync::Arc; +//! use std::thread; +//! use multi_codec::Codec; +//! +//! let codec = Arc::new(Codec::Ed25519Pub); +//! let handle = thread::spawn(move || { +//! println!("Codec: {} (0x{:x})", codec.as_str(), codec.code()); +//! }); +//! handle.join().unwrap(); +//! ``` +//! +//! ## Performance Characteristics +//! +//! - **Codec enum**: Zero-cost abstraction, `Copy` type (no heap allocations) +//! - **String lookups**: O(1) hash table lookups +//! - **Code lookups**: O(log n) binary search in generated match expressions +//! - **Encoding**: Stack-allocated buffers (no heap allocation) +//! - **Hash**: Direct u64 hashing (optimized in Phase 1) +//! - **Serialization**: Stack-allocated arrays (optimized in Phase 1) +//! +//! ## Security +//! +//! This crate follows strict security practices: +//! +//! - **No unsafe code**: Completely safe Rust implementation +//! - **Input validation**: All conversions validate input ranges +//! - **DoS protection**: Size limits on deserialization (max 19 bytes) +//! - **Integer overflow protection**: Negative value checks in signed conversions +//! - **Error handling**: All errors return `Result` types, no panics on invalid input +//! - **Thread safety**: All types are `Send + Sync` with no shared mutable state +//! +//! ## Multicodec Table +//! +//! The codec table is generated at build time from the official +//! [Multicodec Table CSV](https://github.com/multiformats/multicodec/blob/master/table.csv). +//! This ensures the crate stays synchronized with the specification. +//! +//! To update the table, replace `table.csv` and rebuild. +//! +//! ## Feature Flags +//! +//! - **`serde`** (default): Enables serde serialization/deserialization support +//! +//! ### Disabling Default Features +//! +//! ```toml +//! [dependencies] +//! multi-codec = { version = "1.0", default-features = false } +//! ``` +//! +//! ## Common Patterns +//! +//! ### Using in Data Structures +//! +//! ```rust +//! use multi_codec::Codec; +//! use std::collections::HashMap; +//! +//! // Codec as HashMap key +//! let mut algorithms = HashMap::new(); +//! algorithms.insert(Codec::Sha2256, "SHA-256"); +//! algorithms.insert(Codec::Sha2512, "SHA-512"); +//! algorithms.insert(Codec::Blake3, "BLAKE3"); +//! +//! assert_eq!(algorithms.get(&Codec::Sha2256), Some(&"SHA-256")); +//! ``` +//! +//! ### Sequential Codec Handling +//! +//! ```rust +//! use multi_codec::Codec; +//! use multi_trait::{TryDecodeFrom, EncodeIntoBuffer}; +//! +//! // Encode multiple codecs sequentially +//! let codecs = vec![Codec::Identity, Codec::Sha2256, Codec::Ed25519Pub]; +//! +//! let mut buffer = Vec::new(); +//! for codec in &codecs { +//! let code: u64 = (*codec).into(); +//! code.encode_into_buffer(&mut buffer); +//! } +//! +//! // Decode them back +//! let mut remaining = buffer.as_slice(); +//! for expected in &codecs { +//! let (code, rest) = u64::try_decode_from(remaining)?; +//! let decoded = Codec::try_from(code)?; +//! assert_eq!(decoded, *expected); +//! remaining = rest; +//! } +//! # Ok::<(), Box>(()) +//! ``` +//! +//! ## Examples +//! +//! See the `docs/multicodec/` directory for additional documentation and examples. +//! +//! ## Specification Compliance +//! +//! This crate implements the [Multicodec specification](https://github.com/multiformats/multicodec) +//! and maintains compatibility with the official codec table. + #![warn(missing_docs)] #![deny( trivial_casts, @@ -16,14 +285,26 @@ pub use error::Error; pub mod codec; pub use codec::Codec; +/// Type-safe wrappers for codec identifiers +pub mod types; +pub use types::{CodecCode, CodecName}; + /// Serde serialization #[cfg(feature = "serde")] pub mod serde; -/// ...and in the darkness bind them +/// Commonly used items +/// +/// ``` +/// use multi_codec::prelude::*; +/// +/// let codec = Codec::try_from("sha2-256")?; +/// assert_eq!(codec.code(), 0x12); +/// # Ok::<(), multi_codec::Error>(()) +/// ``` pub mod prelude { - pub use super::{codec::*, error::*}; + pub use super::{codec::*, error::*, types::*}; // re-exports - pub use multitrait::{EncodeInto, TryDecodeFrom}; + pub use multi_trait::{EncodeInto, TryDecodeFrom}; } diff --git a/src/serde/de.rs b/src/serde/de.rs index a3d1c90..cfbbb6f 100644 --- a/src/serde/de.rs +++ b/src/serde/de.rs @@ -71,12 +71,20 @@ impl<'de> Deserialize<'de> for Codec { where S: de::SeqAccess<'de>, { - let mut v = Vec::new(); + // Maximum varint length for u128 is 19 bytes + // u64 maximum is 10 bytes, but we use 19 for safety margin + const MAX_VARINT_LEN: usize = 19; + + let mut v = Vec::with_capacity(MAX_VARINT_LEN.min(8)); while let Some(b) = seq.next_element()? { + if v.len() >= MAX_VARINT_LEN { + return Err(de::Error::custom( + "varint exceeds maximum length of 19 bytes", + )); + } v.push(b); } - Self::Value::try_from(v.as_slice()) - .map_err(|e| de::Error::custom(e.to_string())) + Self::Value::try_from(v.as_slice()).map_err(|e| de::Error::custom(e.to_string())) } } diff --git a/src/serde/mod.rs b/src/serde/mod.rs index 23f91d0..785723c 100644 --- a/src/serde/mod.rs +++ b/src/serde/mod.rs @@ -6,7 +6,7 @@ mod ser; #[cfg(test)] mod tests { use crate::prelude::Codec; - use multitrait::Null; + use multi_trait::Null; use serde::{Deserialize, Serialize}; use serde_test::{assert_tokens, Configure, Token}; @@ -25,23 +25,13 @@ mod tests { #[test] fn test_null_serde_compact() { let c = Codec::null(); - assert_tokens( - &c.compact(), - &[ - Token::BorrowedBytes(&[0x00]) - ] - ); + assert_tokens(&c.compact(), &[Token::BorrowedBytes(&[0x00])]); } #[test] fn test_null_serde_readable() { let c = Codec::null(); - assert_tokens( - &c.readable(), - &[ - Token::BorrowedStr("identity") - ] - ); + assert_tokens(&c.readable(), &[Token::BorrowedStr("identity")]); } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] diff --git a/src/serde/ser.rs b/src/serde/ser.rs index fd4eeb1..7246544 100644 --- a/src/serde/ser.rs +++ b/src/serde/ser.rs @@ -1,5 +1,6 @@ // SPDX-License-Identifier: MIT or Apache-2.0 use crate::Codec; +use multi_trait::EncodeIntoArray; use serde::ser; /// Serialize instances of [`crate::prelude::Codec`] into varuint encoded bytes @@ -12,8 +13,10 @@ impl ser::Serialize for Codec { let s: &str = (*self).into(); serializer.serialize_str(s) } else { - let v: Vec = (*self).into(); - serializer.serialize_bytes(v.as_slice()) + // Use stack allocation instead of heap allocation for better performance + let code: u64 = (*self).into(); + let (buf, len) = code.encode_into_array(); + serializer.serialize_bytes(&buf[..len]) } } } diff --git a/src/table_gen.rs b/src/table_gen.rs index b2e73b4..3ed47ca 100644 --- a/src/table_gen.rs +++ b/src/table_gen.rs @@ -72,7 +72,6 @@ build_codec_enum! { 0xa2 => (Aes256, "aes-256"), 0xa3 => (Chacha128, "chacha-128"), 0xa4 => (Chacha256, "chacha-256"), - 0xa5 => (Chacha20Poly1305, "chacha20-poly1305"), 0xb0 => (BitcoinBlock, "bitcoin-block"), 0xb1 => (BitcoinTx, "bitcoin-tx"), 0xb2 => (BitcoinWitnessCommitment, "bitcoin-witness-commitment"), @@ -116,6 +115,7 @@ build_codec_enum! { 0x012e => (Utp, "utp"), 0x0132 => (Crc32, "crc32"), 0x0164 => (Crc64Ecma, "crc64-ecma"), + 0x0165 => (Crc64Nvme, "crc64-nvme"), 0x0190 => (Unix, "unix"), 0x0196 => (Thread, "thread"), 0x01a5 => (P2P, "p2p"), @@ -136,10 +136,12 @@ build_codec_enum! { 0x01de => (Wss, "wss"), 0x01df => (P2PWebsocketStar, "p2p-websocket-star"), 0x01e0 => (Http, "http"), + 0x01e1 => (HttpPath, "http-path"), 0x01f0 => (Swhid1Snp, "swhid-1-snp"), 0x0200 => (Json, "json"), 0x0201 => (Messagepack, "messagepack"), 0x0202 => (Car, "car"), + 0x0210 => (X509Certificate, "x509-certificate"), 0x0300 => (IpnsRecord, "ipns-record"), 0x0301 => (Libp2PPeerRecord, "libp2p-peer-record"), 0x0302 => (Libp2PRelayRsvp, "libp2p-relay-rsvp"), @@ -149,7 +151,9 @@ build_codec_enum! { 0x0900 => (TransportBitswap, "transport-bitswap"), 0x0910 => (TransportGraphsyncFilecoinv1, "transport-graphsync-filecoinv1"), 0x0920 => (TransportIpfsGatewayHttp, "transport-ipfs-gateway-http"), + 0x0930 => (TransportFilecoinPieceHttp, "transport-filecoin-piece-http"), 0x0d1d => (Multidid, "multidid"), + 0x1011 => (Fr32Sha256Trunc254Padbintree, "fr32-sha256-trunc254-padbintree"), 0x1012 => (Sha2256Trunc254Padded, "sha2-256-trunc254-padded"), 0x1013 => (Sha2224, "sha2-224"), 0x1014 => (Sha2512224, "sha2-512-224"), @@ -171,6 +175,56 @@ build_codec_enum! { 0x1208 => (ProvenanceLog, "provenance-log"), 0x1209 => (ProvenanceLogEntry, "provenance-log-entry"), 0x120a => (ProvenanceLogScript, "provenance-log-script"), + 0x120c => (Mlkem768Pub, "mlkem-768-pub"), + 0x120d => (Mlkem1024Pub, "mlkem-1024-pub"), + 0x120e => (SlhDsaSha2128FPub, "slh-dsa-sha2-128f-pub"), + 0x1214 => (SlhDsaSha2128SPub, "slh-dsa-sha2-128s-pub"), + 0x1215 => (SlhDsaSha2192FPub, "slh-dsa-sha2-192f-pub"), + 0x1216 => (SlhDsaSha2192SPub, "slh-dsa-sha2-192s-pub"), + 0x1217 => (SlhDsaSha2256FPub, "slh-dsa-sha2-256f-pub"), + 0x1218 => (SlhDsaSha2256SPub, "slh-dsa-sha2-256s-pub"), + 0x1219 => (SlhDsaShake128FPub, "slh-dsa-shake128f-pub"), + 0x121a => (SlhDsaShake128SPub, "slh-dsa-shake128s-pub"), + 0x121b => (SlhDsaShake192FPub, "slh-dsa-shake192f-pub"), + 0x121c => (SlhDsaShake192SPub, "slh-dsa-shake192s-pub"), + 0x121d => (SlhDsaShake256FPub, "slh-dsa-shake256f-pub"), + 0x121e => (SlhDsaShake256SPub, "slh-dsa-shake256s-pub"), + 0x121f => (Sntrup761Pub, "sntrup761-pub"), + 0x1220 => (Mceliece348864Pub, "mceliece348864-pub"), + 0x1221 => (Mceliece460896Pub, "mceliece460896-pub"), + 0x1222 => (Rsa2048Pub, "rsa-2048-pub"), + 0x1223 => (Rsa3072Pub, "rsa-3072-pub"), + 0x1224 => (Rsa4096Pub, "rsa-4096-pub"), + 0x1225 => (Mayo1Pub, "mayo-1-pub"), + 0x1226 => (Mayo2Pub, "mayo-2-pub"), + 0x123d => (Mayo3Pub, "mayo-3-pub"), + 0x123e => (Mayo5Pub, "mayo-5-pub"), + 0x1227 => (Sntrup857Pub, "sntrup857-pub"), + 0x1228 => (Sntrup953Pub, "sntrup953-pub"), + 0x1229 => (Sntrup1013Pub, "sntrup1013-pub"), + 0x122a => (Sntrup1277Pub, "sntrup1277-pub"), + 0x1230 => (X25519Sntrup761Pub, "x25519-sntrup761-pub"), + 0x1243 => (X25519Frodokem640AesPub, "x25519-frodokem640aes-pub"), + 0x1244 => (X25519Frodokem640ShakePub, "x25519-frodokem640shake-pub"), + 0x1245 => (X25519Mceliece348864Pub, "x25519-mceliece348864-pub"), + 0x1246 => (Bls12381G1Mldsa65Pub, "bls12381-g1-mldsa65-pub"), + 0x1247 => (Bls12381G1Fndsa512Pub, "bls12381-g1-fndsa512-pub"), + 0x1248 => (Bls12381G1Mayo1Pub, "bls12381-g1-mayo1-pub"), + 0x1249 => (Bls12381G1Mayo2Pub, "bls12381-g1-mayo2-pub"), + 0x1231 => (X25519Mlkem768Pub, "x25519-mlkem768-pub"), + 0x1232 => (Ed25519Mayo2Pub, "ed25519-mayo2-pub"), + 0x123f => (Ed25519Mldsa65Pub, "ed25519-mldsa65-pub"), + 0x1241 => (Ed25519Fndsa512Pub, "ed25519-fndsa512-pub"), + 0x1234 => (FrodoKem640AesPub, "frodo-kem-640-aes-pub"), + 0x1235 => (FrodoKem976AesPub, "frodo-kem-976-aes-pub"), + 0x1236 => (FrodoKem1344AesPub, "frodo-kem-1344-aes-pub"), + 0x1237 => (FrodoKem640ShakePub, "frodo-kem-640-shake-pub"), + 0x1238 => (FrodoKem976ShakePub, "frodo-kem-976-shake-pub"), + 0x123c => (FrodoKem1344ShakePub, "frodo-kem-1344-shake-pub"), + 0x1212 => (MlDsa65Pub, "ml-dsa-65-pub"), + 0x1213 => (MlDsa87Pub, "ml-dsa-87-pub"), + 0x1210 => (FnDsa512Pub, "fn-dsa-512-pub"), + 0x1211 => (FnDsa1024Pub, "fn-dsa-1024-pub"), 0x1239 => (Multisig, "multisig"), 0x123a => (Multikey, "multikey"), 0x123b => (Nonce, "nonce"), @@ -189,16 +243,83 @@ build_codec_enum! { 0x130d => (Bls12381G2PubShare, "bls12_381-g2-pub-share"), 0x130e => (Bls12381G1PrivShare, "bls12_381-g1-priv-share"), 0x130f => (Bls12381G2PrivShare, "bls12_381-g2-priv-share"), - 0x1a14 => (LamportPub, "lamport-pub"), - 0x1a24 => (LamportPriv, "lamport-priv"), - 0x1a34 => (LamportPrivShare, "lamport-priv-share"), - 0x1a44 => (LamportSig, "lamport-sig"), - 0x1a54 => (LamportSigShare, "lamport-sig-share"), + 0x1310 => (Sm2Priv, "sm2-priv"), + 0x1311 => (Ed448Priv, "ed448-priv"), + 0x1312 => (X448Priv, "x448-priv"), + 0x1314 => (Mlkem768Priv, "mlkem-768-priv"), + 0x1315 => (Mlkem1024Priv, "mlkem-1024-priv"), + 0x1316 => (JwkJcsPriv, "jwk_jcs-priv"), + 0x1317 => (SlhDsaSha2128FPriv, "slh-dsa-sha2-128f-priv"), + 0x131d => (SlhDsaSha2128SPriv, "slh-dsa-sha2-128s-priv"), + 0x131e => (SlhDsaSha2192FPriv, "slh-dsa-sha2-192f-priv"), + 0x131f => (SlhDsaSha2192SPriv, "slh-dsa-sha2-192s-priv"), + 0x1320 => (SlhDsaSha2256FPriv, "slh-dsa-sha2-256f-priv"), + 0x1321 => (SlhDsaSha2256SPriv, "slh-dsa-sha2-256s-priv"), + 0x1322 => (SlhDsaShake128FPriv, "slh-dsa-shake128f-priv"), + 0x1323 => (SlhDsaShake128SPriv, "slh-dsa-shake128s-priv"), + 0x1324 => (SlhDsaShake192FPriv, "slh-dsa-shake192f-priv"), + 0x1325 => (SlhDsaShake192SPriv, "slh-dsa-shake192s-priv"), + 0x1326 => (SlhDsaShake256FPriv, "slh-dsa-shake256f-priv"), + 0x1327 => (SlhDsaShake256SPriv, "slh-dsa-shake256s-priv"), + 0x1328 => (Sntrup761Priv, "sntrup761-priv"), + 0x1329 => (Mceliece348864Priv, "mceliece348864-priv"), + 0x132a => (Mceliece460896Priv, "mceliece460896-priv"), + 0x132b => (Rsa2048Priv, "rsa-2048-priv"), + 0x132c => (Rsa3072Priv, "rsa-3072-priv"), + 0x132d => (Rsa4096Priv, "rsa-4096-priv"), + 0x132e => (Mayo1Priv, "mayo-1-priv"), + 0x132f => (Mayo2Priv, "mayo-2-priv"), + 0x134a => (Mayo3Priv, "mayo-3-priv"), + 0x134b => (Mayo5Priv, "mayo-5-priv"), + 0x1330 => (Sntrup857Priv, "sntrup857-priv"), + 0x1331 => (Sntrup953Priv, "sntrup953-priv"), + 0x1332 => (Sntrup1013Priv, "sntrup1013-priv"), + 0x1333 => (Sntrup1277Priv, "sntrup1277-priv"), + 0x1340 => (X25519Sntrup761Priv, "x25519-sntrup761-priv"), + 0x1350 => (X25519Frodokem640AesPriv, "x25519-frodokem640aes-priv"), + 0x1351 => (X25519Frodokem640ShakePriv, "x25519-frodokem640shake-priv"), + 0x1352 => (X25519Mceliece348864Priv, "x25519-mceliece348864-priv"), + 0x1353 => (Bls12381G1Mldsa65Priv, "bls12381-g1-mldsa65-priv"), + 0x1354 => (Bls12381G1Fndsa512Priv, "bls12381-g1-fndsa512-priv"), + 0x1355 => (Bls12381G1Mayo1Priv, "bls12381-g1-mayo1-priv"), + 0x1356 => (Bls12381G1Mayo2Priv, "bls12381-g1-mayo2-priv"), + 0x1341 => (X25519Mlkem768Priv, "x25519-mlkem768-priv"), + 0x1342 => (Ed25519Mayo2Priv, "ed25519-mayo2-priv"), + 0x134c => (Ed25519Mldsa65Priv, "ed25519-mldsa65-priv"), + 0x134e => (Ed25519Fndsa512Priv, "ed25519-fndsa512-priv"), + 0x1344 => (FrodoKem640AesPriv, "frodo-kem-640-aes-priv"), + 0x1345 => (FrodoKem976AesPriv, "frodo-kem-976-aes-priv"), + 0x1346 => (FrodoKem1344AesPriv, "frodo-kem-1344-aes-priv"), + 0x1347 => (FrodoKem640ShakePriv, "frodo-kem-640-shake-priv"), + 0x1348 => (FrodoKem976ShakePriv, "frodo-kem-976-shake-priv"), + 0x1349 => (FrodoKem1344ShakePriv, "frodo-kem-1344-shake-priv"), + 0x131b => (MlDsa65Priv, "ml-dsa-65-priv"), + 0x131c => (MlDsa87Priv, "ml-dsa-87-priv"), + 0x1319 => (FnDsa512Priv, "fn-dsa-512-priv"), + 0x131a => (FnDsa1024Priv, "fn-dsa-1024-priv"), + 0x1a14 => (LamportSha3512Pub, "lamport-sha3-512-pub"), + 0x1a15 => (LamportSha3384Pub, "lamport-sha3-384-pub"), + 0x1a16 => (LamportSha3256Pub, "lamport-sha3-256-pub"), + 0x1a24 => (LamportSha3512Priv, "lamport-sha3-512-priv"), + 0x1a25 => (LamportSha3384Priv, "lamport-sha3-384-priv"), + 0x1a26 => (LamportSha3256Priv, "lamport-sha3-256-priv"), + 0x1a34 => (LamportSha3512PrivShare, "lamport-sha3-512-priv-share"), + 0x1a35 => (LamportSha3384PrivShare, "lamport-sha3-384-priv-share"), + 0x1a36 => (LamportSha3256PrivShare, "lamport-sha3-256-priv-share"), + 0x1a44 => (LamportSha3512Sig, "lamport-sha3-512-sig"), + 0x1a45 => (LamportSha3384Sig, "lamport-sha3-384-sig"), + 0x1a46 => (LamportSha3256Sig, "lamport-sha3-256-sig"), + 0x1a54 => (LamportSha3512SigShare, "lamport-sha3-512-sig-share"), + 0x1a55 => (LamportSha3384SigShare, "lamport-sha3-384-sig-share"), + 0x1a56 => (LamportSha3256SigShare, "lamport-sha3-256-sig-share"), 0x1d01 => (Kangarootwelve, "kangarootwelve"), 0x2000 => (AesGcm256, "aes-gcm-256"), + 0x2001 => (AesGcm128, "aes-gcm-128"), 0x3f42 => (Silverpine, "silverpine"), 0x534d => (Sm3256, "sm3-256"), 0x7012 => (Sha256A, "sha256a"), + 0xa000 => (Chacha20Poly1305, "chacha20-poly1305"), + 0xa001 => (Xchacha20Poly1305, "xchacha20-poly1305"), 0xb201 => (Blake2B8, "blake2b-8"), 0xb202 => (Blake2B16, "blake2b-16"), 0xb203 => (Blake2B24, "blake2b-24"), @@ -530,18 +651,26 @@ build_codec_enum! { 0xb502 => (SszSha2256Bmt, "ssz-sha2-256-bmt"), 0xb510 => (Sha2256Chunked, "sha2-256-chunked"), 0xb601 => (JsonJcs, "json-jcs"), + 0xb702 => (BittorrentPiecesRoot, "bittorrent-pieces-root"), 0xcc01 => (Iscc, "iscc"), 0xce11 => (ZeroxcertImprint256, "zeroxcert-imprint-256"), 0xd000 => (NonstandardSig, "nonstandard-sig"), 0xd00d => (BcryptPbkdf, "bcrypt-pbkdf"), + 0xd00e => (HkdfSha256, "hkdf-sha256"), 0xd0e7 => (Es256K, "es256k"), 0xd0ea => (Bls12381G1Sig, "bls12_381-g1-sig"), 0xd0eb => (Bls12381G2Sig, "bls12_381-g2-sig"), 0xd0ed => (Eddsa, "eddsa"), 0xd191 => (Eip191, "eip-191"), 0xeb51 => (JwkJcsPub, "jwk_jcs-pub"), + 0xed20 => (Ed2K, "ed2k"), 0xf101 => (FilCommitmentUnsealed, "fil-commitment-unsealed"), 0xf102 => (FilCommitmentSealed, "fil-commitment-sealed"), + 0x511e00 => (ShelterContractManifest, "shelter-contract-manifest"), + 0x511e01 => (ShelterContractText, "shelter-contract-text"), + 0x511e02 => (ShelterContractData, "shelter-contract-data"), + 0x511e03 => (ShelterFileManifest, "shelter-file-manifest"), + 0x511e04 => (ShelterFileChunk, "shelter-file-chunk"), 0x706c61 => (Plaintextv2, "plaintextv2"), 0x807124 => (HolochainAdrV0, "holochain-adr-v0"), 0x817124 => (HolochainAdrV1, "holochain-adr-v1"), @@ -554,7 +683,7 @@ build_codec_enum! { 0xb39910 => (SubspaceNs, "subspace-ns"), 0xb49910 => (KumandraNs, "kumandra-ns"), 0xd01200 => (Es256, "es256"), - 0xd01201 => (Es284, "es284"), + 0xd01201 => (Es384, "es384"), 0xd01202 => (Es512, "es512"), 0xd01205 => (Rs256, "rs256"), 0xd01300 => (Es256KMsig, "es256k-msig"), @@ -569,5 +698,46 @@ build_codec_enum! { 0xd01309 => (Es384Msig, "es384-msig"), 0xd0130a => (Es521Msig, "es521-msig"), 0xd0130b => (Rs256Msig, "rs256-msig"), + 0xd0130c => (SlhDsaSha2128FMsig, "slh-dsa-sha2-128f-msig"), + 0xd01312 => (SlhDsaSha2128SMsig, "slh-dsa-sha2-128s-msig"), + 0xd01313 => (SlhDsaSha2192FMsig, "slh-dsa-sha2-192f-msig"), + 0xd01314 => (SlhDsaSha2192SMsig, "slh-dsa-sha2-192s-msig"), + 0xd01315 => (SlhDsaSha2256FMsig, "slh-dsa-sha2-256f-msig"), + 0xd01316 => (SlhDsaSha2256SMsig, "slh-dsa-sha2-256s-msig"), + 0xd01317 => (SlhDsaShake128FMsig, "slh-dsa-shake128f-msig"), + 0xd01318 => (SlhDsaShake128SMsig, "slh-dsa-shake128s-msig"), + 0xd01319 => (SlhDsaShake192FMsig, "slh-dsa-shake192f-msig"), + 0xd0131a => (SlhDsaShake192SMsig, "slh-dsa-shake192s-msig"), + 0xd0131b => (SlhDsaShake256FMsig, "slh-dsa-shake256f-msig"), + 0xd0131c => (SlhDsaShake256SMsig, "slh-dsa-shake256s-msig"), + 0xd01310 => (MlDsa65Msig, "ml-dsa-65-msig"), + 0xd01311 => (MlDsa87Msig, "ml-dsa-87-msig"), + 0xd0130e => (FnDsa512Msig, "fn-dsa-512-msig"), + 0xd0130f => (FnDsa1024Msig, "fn-dsa-1024-msig"), + 0xd0131d => (Mayo1Msig, "mayo-1-msig"), + 0xd0131e => (Mayo2Msig, "mayo-2-msig"), + 0xd01322 => (Mayo3Msig, "mayo-3-msig"), + 0xd01323 => (Mayo5Msig, "mayo-5-msig"), + 0xd01320 => (Ed25519Mayo2Msig, "ed25519-mayo2-msig"), + 0xd01324 => (Ed25519Mldsa65Msig, "ed25519-mldsa65-msig"), + 0xd01326 => (Ed25519Fndsa512Msig, "ed25519-fndsa512-msig"), + 0xd01328 => (Bls12381G1Mldsa65Msig, "bls12381-g1-mldsa65-msig"), + 0xd01329 => (Bls12381G1Fndsa512Msig, "bls12381-g1-fndsa512-msig"), + 0xd0132a => (Bls12381G1Mayo1Msig, "bls12381-g1-mayo1-msig"), + 0xd0132b => (Bls12381G1Mayo2Msig, "bls12381-g1-mayo2-msig"), + 0xd01400 => (BsMessage, "bs-message"), 0xd02000 => (Scion, "scion"), + 0xd03000 => (Ed25519ThreshPrivShare, "ed25519-thresh-priv-share"), + 0xd03001 => (Ed25519ThreshPubShare, "ed25519-thresh-pub-share"), + 0xd03002 => (P256ThreshPrivShare, "p256-thresh-priv-share"), + 0xd03003 => (P256ThreshPubShare, "p256-thresh-pub-share"), + 0xd03004 => (P384ThreshPrivShare, "p384-thresh-priv-share"), + 0xd03005 => (P384ThreshPubShare, "p384-thresh-pub-share"), + 0xd03006 => (Secp256K1ThreshPrivShare, "secp256k1-thresh-priv-share"), + 0xd03007 => (Secp256K1ThreshPubShare, "secp256k1-thresh-pub-share"), + 0xd03008 => (Bls12381ThreshPrivShare, "bls12-381-thresh-priv-share"), + 0xd03009 => (Bls12381ThreshPubShare, "bls12-381-thresh-pub-share"), + 0xd0300a => (Ed448ThreshPrivShare, "ed448-thresh-priv-share"), + 0xd0300b => (Ed448ThreshPubShare, "ed448-thresh-pub-share"), + 0xd0300c => (KeySplitShare, "key-split-share"), } diff --git a/src/types.rs b/src/types.rs new file mode 100644 index 0000000..48a5d9c --- /dev/null +++ b/src/types.rs @@ -0,0 +1,459 @@ +// SPDX-License-Identifier: MIT or Apache-2.0 +//! Type-safe wrappers for multicodec identifiers +//! +//! This module provides newtype wrappers that prevent mixing up raw numeric +//! codes and string names, following Rust best practices for type safety. +//! +//! # Overview +//! +//! Instead of using raw `u64` values and `String`s directly, these newtypes +//! provide: +//! - **Type safety**: Can't accidentally use a code where a name is expected +//! - **Self-documentation**: Code is clearer about intent +//! - **Validation**: Can add validation logic in constructors +//! - **API evolution**: Can add methods without changing function signatures +//! +//! # Examples +//! +//! ``` +//! use multi_codec::types::{CodecCode, CodecName}; +//! +//! // Type-safe codec code +//! let code = CodecCode::new(0xED); +//! assert_eq!(code.get(), 0xED); +//! assert_eq!(code.to_string(), "0xed"); +//! +//! // Type-safe codec name +//! let name = CodecName::new("ed25519-pub"); +//! assert_eq!(name.as_str(), "ed25519-pub"); +//! ``` + +use core::fmt; + +/// A codec code value (0x00 - 0xFFFFFFFFFFFFFFFF) +/// +/// This newtype wrapper provides type safety when working with raw codec values. +/// It prevents accidentally mixing up codes with other numeric types and provides +/// a clear, self-documenting API. +/// +/// # Examples +/// +/// ``` +/// use multi_codec::types::CodecCode; +/// +/// // Create a code +/// let code = CodecCode::new(0xED); +/// assert_eq!(code.get(), 0xED); +/// +/// // Display as hex +/// assert_eq!(code.to_string(), "0xed"); +/// +/// // Conversions +/// let code: CodecCode = 237u64.into(); +/// assert_eq!(u64::from(code), 237); +/// ``` +/// +#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct CodecCode(u64); + +impl CodecCode { + /// Create a new CodecCode from a u64 value + /// + /// # Examples + /// + /// ``` + /// use multi_codec::types::CodecCode; + /// + /// let code = CodecCode::new(0xED); + /// assert_eq!(code.get(), 0xED); + /// ``` + pub const fn new(code: u64) -> Self { + Self(code) + } + + /// Get the raw u64 value + /// + /// # Examples + /// + /// ``` + /// use multi_codec::types::CodecCode; + /// + /// let code = CodecCode::new(0x12); + /// assert_eq!(code.get(), 0x12); + /// ``` + pub const fn get(self) -> u64 { + self.0 + } + + /// Get the value as a hexadecimal string + /// + /// # Examples + /// + /// ``` + /// use multi_codec::types::CodecCode; + /// + /// let code = CodecCode::new(0xED); + /// assert_eq!(code.as_hex(), "0xed"); + /// ``` + pub fn as_hex(&self) -> String { + format!("0x{:x}", self.0) + } + + /// Check if this is the null/identity codec (0x00) + /// + /// # Examples + /// + /// ``` + /// use multi_codec::types::CodecCode; + /// + /// let identity = CodecCode::new(0x00); + /// assert!(identity.is_identity()); + /// + /// let other = CodecCode::new(0xED); + /// assert!(!other.is_identity()); + /// ``` + pub const fn is_identity(&self) -> bool { + self.0 == 0 + } +} + +impl From for CodecCode { + fn from(code: u64) -> Self { + Self(code) + } +} + +impl From for u64 { + fn from(code: CodecCode) -> u64 { + code.0 + } +} + +impl fmt::Display for CodecCode { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "0x{:x}", self.0) + } +} + +impl fmt::LowerHex for CodecCode { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{:x}", self.0) + } +} + +impl fmt::UpperHex for CodecCode { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{:X}", self.0) + } +} + +/// A codec name string +/// +/// This newtype wrapper provides type safety when working with codec names. +/// It prevents accidentally using arbitrary strings where codec names are expected +/// and provides a clear, self-documenting API. +/// +/// # Examples +/// +/// ``` +/// use multi_codec::types::CodecName; +/// +/// // Create a name +/// let name = CodecName::new("ed25519-pub"); +/// assert_eq!(name.as_str(), "ed25519-pub"); +/// +/// // Display +/// assert_eq!(name.to_string(), "ed25519-pub"); +/// +/// // Conversions +/// let name: CodecName = "sha2-256".to_string().into(); +/// assert_eq!(name.as_str(), "sha2-256"); +/// ``` +/// +#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct CodecName(String); + +impl CodecName { + /// Create a new CodecName from a string + /// + /// # Examples + /// + /// ``` + /// use multi_codec::types::CodecName; + /// + /// let name = CodecName::new("ed25519-pub"); + /// assert_eq!(name.as_str(), "ed25519-pub"); + /// ``` + pub fn new(name: impl Into) -> Self { + Self(name.into()) + } + + /// Get the name as a string slice + /// + /// # Examples + /// + /// ``` + /// use multi_codec::types::CodecName; + /// + /// let name = CodecName::new("sha2-256"); + /// assert_eq!(name.as_str(), "sha2-256"); + /// ``` + pub fn as_str(&self) -> &str { + &self.0 + } + + /// Check if this is the identity codec name + /// + /// # Examples + /// + /// ``` + /// use multi_codec::types::CodecName; + /// + /// let identity = CodecName::new("identity"); + /// assert!(identity.is_identity()); + /// + /// let other = CodecName::new("sha2-256"); + /// assert!(!other.is_identity()); + /// ``` + pub fn is_identity(&self) -> bool { + self.0 == "identity" + } + + /// Get the length of the name in bytes + /// + /// # Examples + /// + /// ``` + /// use multi_codec::types::CodecName; + /// + /// let name = CodecName::new("sha2-256"); + /// assert_eq!(name.len(), 8); + /// ``` + pub fn len(&self) -> usize { + self.0.len() + } + + /// Check if the name is empty + /// + /// # Examples + /// + /// ``` + /// use multi_codec::types::CodecName; + /// + /// let name = CodecName::new(""); + /// assert!(name.is_empty()); + /// + /// let name = CodecName::new("sha2-256"); + /// assert!(!name.is_empty()); + /// ``` + pub fn is_empty(&self) -> bool { + self.0.is_empty() + } +} + +impl From for CodecName { + fn from(name: String) -> Self { + Self(name) + } +} + +impl From<&str> for CodecName { + fn from(name: &str) -> Self { + Self(name.to_string()) + } +} + +impl From for String { + fn from(name: CodecName) -> String { + name.0 + } +} + +impl AsRef for CodecName { + fn as_ref(&self) -> &str { + &self.0 + } +} + +impl fmt::Display for CodecName { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.0) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_codec_code_new() { + let code = CodecCode::new(0xED); + assert_eq!(code.get(), 0xED); + } + + #[test] + fn test_codec_code_conversions() { + let code = CodecCode::from(0x12u64); + assert_eq!(u64::from(code), 0x12); + } + + #[test] + fn test_codec_code_display() { + let code = CodecCode::new(0xED); + assert_eq!(code.to_string(), "0xed"); + assert_eq!(format!("{:x}", code), "ed"); + assert_eq!(format!("{:X}", code), "ED"); + } + + #[test] + fn test_codec_code_as_hex() { + let code = CodecCode::new(0xABCD); + assert_eq!(code.as_hex(), "0xabcd"); + } + + #[test] + fn test_codec_code_is_identity() { + let identity = CodecCode::new(0x00); + assert!(identity.is_identity()); + + let other = CodecCode::new(0x12); + assert!(!other.is_identity()); + } + + #[test] + fn test_codec_code_equality() { + let code1 = CodecCode::new(0xED); + let code2 = CodecCode::new(0xED); + let code3 = CodecCode::new(0x12); + + assert_eq!(code1, code2); + assert_ne!(code1, code3); + } + + #[test] + fn test_codec_code_ordering() { + let code1 = CodecCode::new(0x10); + let code2 = CodecCode::new(0x20); + + assert!(code1 < code2); + assert!(code2 > code1); + } + + #[test] + fn test_codec_code_hash() { + use std::collections::HashMap; + + let mut map = HashMap::new(); + let code = CodecCode::new(0xED); + map.insert(code, "ed25519-pub"); + + assert_eq!(map.get(&code), Some(&"ed25519-pub")); + } + + #[test] + fn test_codec_name_new() { + let name = CodecName::new("ed25519-pub"); + assert_eq!(name.as_str(), "ed25519-pub"); + } + + #[test] + fn test_codec_name_conversions() { + let name = CodecName::from("sha2-256".to_string()); + assert_eq!(String::from(name), "sha2-256"); + + let name = CodecName::from("blake3"); + assert_eq!(name.as_str(), "blake3"); + } + + #[test] + fn test_codec_name_display() { + let name = CodecName::new("ed25519-pub"); + assert_eq!(name.to_string(), "ed25519-pub"); + } + + #[test] + fn test_codec_name_as_ref() { + let name = CodecName::new("sha2-256"); + let s: &str = name.as_ref(); + assert_eq!(s, "sha2-256"); + } + + #[test] + fn test_codec_name_is_identity() { + let identity = CodecName::new("identity"); + assert!(identity.is_identity()); + + let other = CodecName::new("sha2-256"); + assert!(!other.is_identity()); + } + + #[test] + fn test_codec_name_len() { + let name = CodecName::new("ed25519-pub"); + assert_eq!(name.len(), 11); + + let empty = CodecName::new(""); + assert_eq!(empty.len(), 0); + } + + #[test] + fn test_codec_name_is_empty() { + let empty = CodecName::new(""); + assert!(empty.is_empty()); + + let name = CodecName::new("sha2-256"); + assert!(!name.is_empty()); + } + + #[test] + fn test_codec_name_equality() { + let name1 = CodecName::new("ed25519-pub"); + let name2 = CodecName::new("ed25519-pub"); + let name3 = CodecName::new("sha2-256"); + + assert_eq!(name1, name2); + assert_ne!(name1, name3); + } + + #[test] + fn test_codec_name_ordering() { + let name1 = CodecName::new("aaa"); + let name2 = CodecName::new("bbb"); + + assert!(name1 < name2); + assert!(name2 > name1); + } + + #[test] + fn test_codec_name_hash() { + use std::collections::HashMap; + + let mut map = HashMap::new(); + let name = CodecName::new("ed25519-pub"); + map.insert(name.clone(), 0xED); + + assert_eq!(map.get(&name), Some(&0xED)); + } + + #[test] + fn test_newtypes_are_copy_or_clone() { + // CodecCode should be Copy (contains only u64) + fn assert_copy() {} + assert_copy::(); + + // CodecName should be Clone (contains String) + fn assert_clone() {} + assert_clone::(); + } + + #[test] + fn test_newtypes_are_send_sync() { + fn assert_send() {} + fn assert_sync() {} + + assert_send::(); + assert_sync::(); + assert_send::(); + assert_sync::(); + } +} diff --git a/table.csv b/table.csv index a290b25..7e34956 100644 --- a/table.csv +++ b/table.csv @@ -72,14 +72,13 @@ aes-192, key, 0xa1, draft, 192- aes-256, key, 0xa2, draft, 256-bit AES symmetric key chacha-128, key, 0xa3, draft, 128-bit ChaCha symmetric key chacha-256, key, 0xa4, draft, 256-bit ChaCha symmetric key -chacha20-poly1305, multikey, 0xa5, draft, ChaCha20_Poly1305 encryption scheme bitcoin-block, ipld, 0xb0, permanent, Bitcoin Block bitcoin-tx, ipld, 0xb1, permanent, Bitcoin Tx bitcoin-witness-commitment, ipld, 0xb2, permanent, Bitcoin Witness Commitment zcash-block, ipld, 0xc0, permanent, Zcash Block zcash-tx, ipld, 0xc1, permanent, Zcash Tx -caip-50, multiformat, 0xca, draft, CAIP-50 multi-chain account id -streamid, namespace, 0xce, draft, Ceramic Stream Id +caip-50, multiformat, 0xca, draft, CAIP-50 multi-chain account ID +streamid, namespace, 0xce, draft, Ceramic Stream ID stellar-block, ipld, 0xd0, draft, Stellar Block stellar-tx, ipld, 0xd1, draft, Stellar Tx md4, multihash, 0xd4, draft, @@ -116,6 +115,7 @@ udt, multiaddr, 0x012d, draft, utp, multiaddr, 0x012e, draft, crc32, hash, 0x0132, draft, CRC-32 non-cryptographic hash algorithm (IEEE 802.3) crc64-ecma, hash, 0x0164, draft, CRC-64 non-cryptographic hash algorithm (ECMA-182 - Annex B) +crc64-nvme, hash, 0x0165, draft, CRC-64 checksum based on the NVME polynomial as specified in the NVM Express® NVM Command Set Specification unix, multiaddr, 0x0190, permanent, thread, multiaddr, 0x0196, draft, Textile Thread p2p, multiaddr, 0x01a5, permanent, libp2p @@ -136,10 +136,12 @@ ws, multiaddr, 0x01dd, permanent, wss, multiaddr, 0x01de, permanent, p2p-websocket-star, multiaddr, 0x01df, permanent, http, multiaddr, 0x01e0, draft, +http-path, multiaddr, 0x01e1, draft, Percent-encoded path to an HTTP resource swhid-1-snp, ipld, 0x01f0, draft, SoftWare Heritage persistent IDentifier version 1 snapshot json, ipld, 0x0200, permanent, JSON (UTF-8-encoded) messagepack, serialization, 0x0201, draft, MessagePack car, serialization, 0x0202, draft, Content Addressable aRchive (CAR) +x509-certificate, serialization, 0x0210, draft, DER-encoded X.509 (PKIX) certificate per RFC 5280; single certificate only (no chain); raw DER bytes (not PEM) ipns-record, serialization, 0x0300, permanent, Signed IPNS Record libp2p-peer-record, libp2p, 0x0301, permanent, libp2p peer record type libp2p-relay-rsvp, libp2p, 0x0302, permanent, libp2p relay reservation voucher @@ -149,7 +151,9 @@ car-multihash-index-sorted, serialization, 0x0401, draft, CARv transport-bitswap, transport, 0x0900, draft, Bitswap datatransfer transport-graphsync-filecoinv1, transport, 0x0910, draft, Filecoin graphsync datatransfer transport-ipfs-gateway-http, transport, 0x0920, draft, HTTP IPFS Gateway trustless datatransfer +transport-filecoin-piece-http, transport, 0x0930, draft, HTTP piece retrieval from Filecoin storage provider; https://github.com/filecoin-project/FIPs/blob/master/FRCs/frc-0066.md multidid, multiformat, 0x0d1d, draft, Compact encoding for Decentralized Identifers +fr32-sha256-trunc254-padbintree,multihash, 0x1011, draft, A balanced binary tree hash used in Filecoin Piece Commitments as described in FRC-0069 sha2-256-trunc254-padded, multihash, 0x1012, permanent, SHA2-256 with the two most significant bits from the last byte zeroed (as via a mask with 0b00111111) - used for proving trees as in Filecoin sha2-224, multihash, 0x1013, permanent, aka SHA-224; as specified by FIPS 180-4. sha2-512-224, multihash, 0x1014, permanent, aka SHA-512/224; as specified by FIPS 180-4. @@ -171,8 +175,58 @@ vlad, vlad, 0x1207, draft, Veri provenance-log, serialization, 0x1208, draft, Verifiable and permissioned append-only log provenance-log-entry, serialization, 0x1209, draft, Verifiable and permissioned append-only log entry provenance-log-script, serialization, 0x120a, draft, Verifiable and permissioned append-only log script +mlkem-768-pub, key, 0x120c, draft, ML-KEM 768 public key; as specified by FIPS 203 +mlkem-1024-pub, key, 0x120d, draft, ML-KEM 1024 public key; as specified by FIPS 203 +slh-dsa-sha2-128f-pub, key, 0x120e, draft, SLH-DSA SHA2-128f public key; FIPS 205 +slh-dsa-sha2-128s-pub, key, 0x1214, draft, SLH-DSA SHA2-128s public key; FIPS 205 +slh-dsa-sha2-192f-pub, key, 0x1215, draft, SLH-DSA SHA2-192f public key; FIPS 205 +slh-dsa-sha2-192s-pub, key, 0x1216, draft, SLH-DSA SHA2-192s public key; FIPS 205 +slh-dsa-sha2-256f-pub, key, 0x1217, draft, SLH-DSA SHA2-256f public key; FIPS 205 +slh-dsa-sha2-256s-pub, key, 0x1218, draft, SLH-DSA SHA2-256s public key; FIPS 205 +slh-dsa-shake128f-pub, key, 0x1219, draft, SLH-DSA SHAKE128f public key; FIPS 205 +slh-dsa-shake128s-pub, key, 0x121a, draft, SLH-DSA SHAKE128s public key; FIPS 205 +slh-dsa-shake192f-pub, key, 0x121b, draft, SLH-DSA SHAKE192f public key; FIPS 205 +slh-dsa-shake192s-pub, key, 0x121c, draft, SLH-DSA SHAKE192s public key; FIPS 205 +slh-dsa-shake256f-pub, key, 0x121d, draft, SLH-DSA SHAKE256f public key; FIPS 205 +slh-dsa-shake256s-pub, key, 0x121e, draft, SLH-DSA SHAKE256s public key; FIPS 205 +sntrup761-pub, key, 0x121f, draft, sntrup761 public key +mceliece348864-pub, key, 0x1220, draft, Classic McEliece 348864 public key +mceliece460896-pub, key, 0x1221, draft, Classic McEliece 460896 public key +rsa-2048-pub, key, 0x1222, draft, RSA 2048-bit public key +rsa-3072-pub, key, 0x1223, draft, RSA 3072-bit public key +rsa-4096-pub, key, 0x1224, draft, RSA 4096-bit public key +mayo-1-pub, key, 0x1225, draft, MAYO level 1 public key +mayo-2-pub, key, 0x1226, draft, MAYO level 2 public key +mayo-3-pub, key, 0x123d, draft, MAYO level 3 public key +mayo-5-pub, key, 0x123e, draft, MAYO level 5 public key +sntrup857-pub, key, 0x1227, draft, sntrup857 public key +sntrup953-pub, key, 0x1228, draft, sntrup953 public key +sntrup1013-pub, key, 0x1229, draft, sntrup1013 public key +sntrup1277-pub, key, 0x122a, draft, sntrup1277 public key +x25519-sntrup761-pub, key, 0x1230, draft, X25519-sntrup761 hybrid KEM public key +x25519-frodokem640aes-pub, key, 0x1243, draft, X25519-FrodoKEM-640-AES hybrid KEM public key +x25519-frodokem640shake-pub, key, 0x1244, draft, X25519-FrodoKEM-640-SHAKE hybrid KEM public key +x25519-mceliece348864-pub, key, 0x1245, draft, X25519-Classic-McEliece-348864 hybrid KEM public key +bls12381-g1-mldsa65-pub, key, 0x1246, draft, BLS12-381-G1-ML-DSA-65 hybrid signing public key +bls12381-g1-fndsa512-pub, key, 0x1247, draft, BLS12-381-G1-FN-DSA-512 hybrid signing public key +bls12381-g1-mayo1-pub, key, 0x1248, draft, BLS12-381-G1-MAYO-1 hybrid signing public key +bls12381-g1-mayo2-pub, key, 0x1249, draft, BLS12-381-G1-MAYO-2 hybrid signing public key +x25519-mlkem768-pub, key, 0x1231, draft, X25519-ML-KEM-768 hybrid KEM public key +ed25519-mayo2-pub, key, 0x1232, draft, Ed25519-MAYO2 hybrid signing public key +ed25519-mldsa65-pub, key, 0x123f, draft, Ed25519-ML-DSA-65 hybrid signing public key +ed25519-fndsa512-pub, key, 0x1241, draft, Ed25519-FN-DSA-512 hybrid signing public key +frodo-kem-640-aes-pub, key, 0x1234, draft, FrodoKEM-640-AES public key +frodo-kem-976-aes-pub, key, 0x1235, draft, FrodoKEM-976-AES public key +frodo-kem-1344-aes-pub, key, 0x1236, draft, FrodoKEM-1344-AES public key +frodo-kem-640-shake-pub, key, 0x1237, draft, FrodoKEM-640-SHAKE public key +frodo-kem-976-shake-pub, key, 0x1238, draft, FrodoKEM-976-SHAKE public key +frodo-kem-1344-shake-pub, key, 0x123c, draft, FrodoKEM-1344-SHAKE public key +ml-dsa-65-pub, key, 0x1212, draft, ML-DSA (Dilithium) 65 public key; as specified by FIPS 204 +ml-dsa-87-pub, key, 0x1213, draft, ML-DSA (Dilithium) 87 public key; as specified by FIPS 204 +fn-dsa-512-pub, key, 0x1210, draft, FN-DSA (Falcon) 512 public key; as specified by FIPS 206 (draft) +fn-dsa-1024-pub, key, 0x1211, draft, FN-DSA (Falcon) 1024 public key; as specified by FIPS 206 (draft) multisig, multiformat, 0x1239, draft, Digital signature multiformat -multikey, multiformat, 0x123a, draft, Encryption key multiformat +multikey, multiformat, 0x123a, draft, Encryption key multiformat nonce, nonce, 0x123b, draft, Nonce random value ed25519-priv, key, 0x1300, draft, Ed25519 private key secp256k1-priv, key, 0x1301, draft, Secp256k1 private key @@ -189,16 +243,83 @@ bls12_381-g1-pub-share, key, 0x130c, draft, BLS1 bls12_381-g2-pub-share, key, 0x130d, draft, BLS12-381 G2 public key share bls12_381-g1-priv-share, key, 0x130e, draft, BLS12-381 G1 private key share bls12_381-g2-priv-share, key, 0x130f, draft, BLS12-381 G2 private key share -lamport-pub, key, 0x1a14, draft, Lamport public key -lamport-priv, key, 0x1a24, draft, Lamport private key -lamport-priv-share, key, 0x1a34, draft, Lamport private key share split with Shamir gf256 -lamport-sig, multisig, 0x1a44, draft, Lamport signature -lamport-sig-share, multisig, 0x1a54, draft, Lamport signature share split with Shamir gf256 +sm2-priv, key, 0x1310, draft, SM2 private key +ed448-priv, key, 0x1311, draft, Ed448 private key +x448-priv, key, 0x1312, draft, X448 private key +mlkem-768-priv, key, 0x1314, draft, ML-KEM 768 public key; as specified by FIPS 203 +mlkem-1024-priv, key, 0x1315, draft, ML-KEM 1024 public key; as specified by FIPS 203 +jwk_jcs-priv, key, 0x1316, draft, JSON object containing only the required members of a JWK (RFC 7518 and RFC 7517) representing the private key. Serialisation based on JCS (RFC 8785) +slh-dsa-sha2-128f-priv, key, 0x1317, draft, SLH-DSA SHA2-128f private key; FIPS 205 +slh-dsa-sha2-128s-priv, key, 0x131d, draft, SLH-DSA SHA2-128s private key; FIPS 205 +slh-dsa-sha2-192f-priv, key, 0x131e, draft, SLH-DSA SHA2-192f private key; FIPS 205 +slh-dsa-sha2-192s-priv, key, 0x131f, draft, SLH-DSA SHA2-192s private key; FIPS 205 +slh-dsa-sha2-256f-priv, key, 0x1320, draft, SLH-DSA SHA2-256f private key; FIPS 205 +slh-dsa-sha2-256s-priv, key, 0x1321, draft, SLH-DSA SHA2-256s private key; FIPS 205 +slh-dsa-shake128f-priv, key, 0x1322, draft, SLH-DSA SHAKE128f private key; FIPS 205 +slh-dsa-shake128s-priv, key, 0x1323, draft, SLH-DSA SHAKE128s private key; FIPS 205 +slh-dsa-shake192f-priv, key, 0x1324, draft, SLH-DSA SHAKE192f private key; FIPS 205 +slh-dsa-shake192s-priv, key, 0x1325, draft, SLH-DSA SHAKE192s private key; FIPS 205 +slh-dsa-shake256f-priv, key, 0x1326, draft, SLH-DSA SHAKE256f private key; FIPS 205 +slh-dsa-shake256s-priv, key, 0x1327, draft, SLH-DSA SHAKE256s private key; FIPS 205 +sntrup761-priv, key, 0x1328, draft, sntrup761 private key +mceliece348864-priv, key, 0x1329, draft, Classic McEliece 348864 private key +mceliece460896-priv, key, 0x132a, draft, Classic McEliece 460896 private key +rsa-2048-priv, key, 0x132b, draft, RSA 2048-bit private key +rsa-3072-priv, key, 0x132c, draft, RSA 3072-bit private key +rsa-4096-priv, key, 0x132d, draft, RSA 4096-bit private key +mayo-1-priv, key, 0x132e, draft, MAYO level 1 private key +mayo-2-priv, key, 0x132f, draft, MAYO level 2 private key +mayo-3-priv, key, 0x134a, draft, MAYO level 3 private key +mayo-5-priv, key, 0x134b, draft, MAYO level 5 private key +sntrup857-priv, key, 0x1330, draft, sntrup857 private key +sntrup953-priv, key, 0x1331, draft, sntrup953 private key +sntrup1013-priv, key, 0x1332, draft, sntrup1013 private key +sntrup1277-priv, key, 0x1333, draft, sntrup1277 private key +x25519-sntrup761-priv, key, 0x1340, draft, X25519-sntrup761 hybrid KEM private key +x25519-frodokem640aes-priv, key, 0x1350, draft, X25519-FrodoKEM-640-AES hybrid KEM private key +x25519-frodokem640shake-priv, key, 0x1351, draft, X25519-FrodoKEM-640-SHAKE hybrid KEM private key +x25519-mceliece348864-priv, key, 0x1352, draft, X25519-Classic-McEliece-348864 hybrid KEM private key +bls12381-g1-mldsa65-priv, key, 0x1353, draft, BLS12-381-G1-ML-DSA-65 hybrid signing private key +bls12381-g1-fndsa512-priv, key, 0x1354, draft, BLS12-381-G1-FN-DSA-512 hybrid signing private key +bls12381-g1-mayo1-priv, key, 0x1355, draft, BLS12-381-G1-MAYO-1 hybrid signing private key +bls12381-g1-mayo2-priv, key, 0x1356, draft, BLS12-381-G1-MAYO-2 hybrid signing private key +x25519-mlkem768-priv, key, 0x1341, draft, X25519-ML-KEM-768 hybrid KEM private key +ed25519-mayo2-priv, key, 0x1342, draft, Ed25519-MAYO2 hybrid signing private key +ed25519-mldsa65-priv, key, 0x134c, draft, Ed25519-ML-DSA-65 hybrid signing private key +ed25519-fndsa512-priv, key, 0x134e, draft, Ed25519-FN-DSA-512 hybrid signing private key +frodo-kem-640-aes-priv, key, 0x1344, draft, FrodoKEM-640-AES private key +frodo-kem-976-aes-priv, key, 0x1345, draft, FrodoKEM-976-AES private key +frodo-kem-1344-aes-priv, key, 0x1346, draft, FrodoKEM-1344-AES private key +frodo-kem-640-shake-priv, key, 0x1347, draft, FrodoKEM-640-SHAKE private key +frodo-kem-976-shake-priv, key, 0x1348, draft, FrodoKEM-976-SHAKE private key +frodo-kem-1344-shake-priv, key, 0x1349, draft, FrodoKEM-1344-SHAKE private key +ml-dsa-65-priv, key, 0x131b, draft, ML-DSA (Dilithium) 65 private key; as specified by FIPS 204 +ml-dsa-87-priv, key, 0x131c, draft, ML-DSA (Dilithium) 87 private key; as specified by FIPS 204 +fn-dsa-512-priv, key, 0x1319, draft, FN-DSA (Falcon) 512 private key; as specified by FIPS 206 (draft) +fn-dsa-1024-priv, key, 0x131a, draft, FN-DSA (Falcon) 1024 private key; as specified by FIPS 206 (draft) +lamport-sha3-512-pub, key, 0x1a14, draft, Lamport public key based on SHA3-512 +lamport-sha3-384-pub, key, 0x1a15, draft, Lamport public key based on SHA3-384 +lamport-sha3-256-pub, key, 0x1a16, draft, Lamport public key based on SHA3-256 +lamport-sha3-512-priv, key, 0x1a24, draft, Lamport private key based on SHA3-512 +lamport-sha3-384-priv, key, 0x1a25, draft, Lamport private key based on SHA3-384 +lamport-sha3-256-priv, key, 0x1a26, draft, Lamport private key based on SHA3-256 +lamport-sha3-512-priv-share, key, 0x1a34, draft, Lamport private key share based on SHA3-512 and split with Shamir gf256 +lamport-sha3-384-priv-share, key, 0x1a35, draft, Lamport private key share based on SHA3-384 and split with Shamir gf256 +lamport-sha3-256-priv-share, key, 0x1a36, draft, Lamport private key share based on SHA3-256 and split with Shamir gf256 +lamport-sha3-512-sig, multisig, 0x1a44, draft, Lamport signature based on SHA3-512 +lamport-sha3-384-sig, multisig, 0x1a45, draft, Lamport signature based on SHA3-384 +lamport-sha3-256-sig, multisig, 0x1a46, draft, Lamport signature based on SHA3-256 +lamport-sha3-512-sig-share, multisig, 0x1a54, draft, Lamport signature share based on SHA3-512 and split with Shamir gf256 +lamport-sha3-384-sig-share, multisig, 0x1a55, draft, Lamport signature share based on SHA3-384 and split with Shamir gf256 +lamport-sha3-256-sig-share, multisig, 0x1a56, draft, Lamport signature share based on SHA3-256 and split with Shamir gf256 kangarootwelve, multihash, 0x1d01, draft, KangarooTwelve is an extendable-output hash function based on Keccak-p aes-gcm-256, encryption, 0x2000, draft, AES Galois/Counter Mode with 256-bit key and 12-byte IV +aes-gcm-128, encryption, 0x2001, draft, AES Galois/Counter Mode with 128-bit key and 12-byte IV silverpine, multiaddr, 0x3f42, draft, Experimental QUIC over yggdrasil and ironwood routing protocol sm3-256, multihash, 0x534d, draft, sha256a, hash, 0x7012, draft, The sum of multiple sha2-256 hashes; as specified by Ceramic CIP-124. +chacha20-poly1305, multikey, 0xa000, draft, ChaCha20_Poly1305 encryption scheme +xchacha20-poly1305, encryption, 0xa001, draft, XChaCha20-Poly1305 extended nonce AEAD blake2b-8, multihash, 0xb201, draft, Blake2b consists of 64 output lengths that give different hashes blake2b-16, multihash, 0xb202, draft, blake2b-24, multihash, 0xb203, draft, @@ -530,18 +651,26 @@ ssz, serialization, 0xb501, draft, Simp ssz-sha2-256-bmt, multihash, 0xb502, draft, SSZ Merkle tree root using SHA2-256 as the hashing function and SSZ serialization for the block binary sha2-256-chunked, multihash, 0xb510, draft, Hash of concatenated SHA2-256 digests of 8*2^n MiB source chunks; n = ceil(log2(source_size/(10^4 * 8MiB))) json-jcs, ipld, 0xb601, draft, The result of canonicalizing an input according to JCS - JSON Canonicalisation Scheme (RFC 8785) +bittorrent-pieces-root, multihash, 0xb702, draft, BitTorrent v2 pieces root hash. iscc, softhash, 0xcc01, draft, ISCC (International Standard Content Code) - similarity preserving hash zeroxcert-imprint-256, zeroxcert, 0xce11, draft, 0xcert Asset Imprint (root hash) nonstandard-sig, varsig, 0xd000, deprecated, Namespace for all not yet standard signature algorithms bcrypt-pbkdf, multihash, 0xd00d, draft, Bcrypt-PBKDF key derivation function -es256k, varsig, 0xd0e7, draft, ES256K Siganture Algorithm (secp256k1) -bls-12381-g1-sig, varsig, 0xd0ea, draft, G1 signature for BLS-12381-G2 -bls-12381-g2-sig, varsig, 0xd0eb, draft, G2 signature for BLS-12381-G1 +hkdf-sha256, kdf, 0xd00e, draft, HKDF-SHA256 key derivation function +es256k, varsig, 0xd0e7, draft, ES256K Signature Algorithm (secp256k1) +bls12_381-g1-sig, varsig, 0xd0ea, draft, G1 signature for BLS12-381 +bls12_381-g2-sig, varsig, 0xd0eb, draft, G2 signature for BLS12-381 eddsa, varsig, 0xd0ed, draft, Edwards-Curve Digital Signature Algorithm eip-191, varsig, 0xd191, draft, EIP-191 Ethereum Signed Data Standard jwk_jcs-pub, key, 0xeb51, draft, JSON object containing only the required members of a JWK (RFC 7518 and RFC 7517) representing the public key. Serialisation based on JCS (RFC 8785) +ed2k, multihash, 0xed20, draft, eDonkey2000 hash. fil-commitment-unsealed, filecoin, 0xf101, permanent, Filecoin piece or sector data commitment merkle node/root (CommP & CommD) fil-commitment-sealed, filecoin, 0xf102, permanent, Filecoin sector data commitment merkle node/root - sealed and replicated (CommR) +shelter-contract-manifest, shelter, 0x511e00, draft, Shelter protocol contract manifest +shelter-contract-text, shelter, 0x511e01, draft, Shelter protocol contract text +shelter-contract-data, shelter, 0x511e02, draft, Shelter protocol contract data (contract chain) +shelter-file-manifest, shelter, 0x511e03, draft, Shelter protocol file manifest +shelter-file-chunk, shelter, 0x511e04, draft, Shelter protocol file chunk plaintextv2, multiaddr, 0x706c61, draft, holochain-adr-v0, holochain, 0x807124, draft, Holochain v0 address + 8 R-S (63 x Base-32) holochain-adr-v1, holochain, 0x817124, draft, Holochain v1 address + 8 R-S (63 x Base-32) @@ -554,19 +683,60 @@ arweave-ns, namespace, 0xb29910, draft, Arwe subspace-ns, namespace, 0xb39910, draft, Subspace Network Namespace kumandra-ns, namespace, 0xb49910, draft, Kumandra Network Namespace es256, varsig, 0xd01200, draft, ES256 Signature Algorithm -es284, varsig, 0xd01201, draft, ES384 Signature Algorithm +es384, varsig, 0xd01201, draft, ES384 Signature Algorithm es512, varsig, 0xd01202, draft, ES512 Signature Algorithm rs256, varsig, 0xd01205, draft, RS256 Signature Algorithm es256k-msig, multisig, 0xd01300, draft, ES256K (secp256k1) Signature as Multisig -bls12_381-g1-msig, multisig, 0xd01301, draft, G1 signature for BLS12-381-G2 as Multisig -bls12_381-g2-msig, multisig, 0xd01302, draft, G2 signature for BLS12-381-G1 as Multisig +bls12_381-g1-msig, multisig, 0xd01301, draft, G1 signature for BLS-12381-G2 as Multisig +bls12_381-g2-msig, multisig, 0xd01302, draft, G2 signature for BLS-12381-G1 as Multisig eddsa-msig, multisig, 0xd01303, draft, Edwards-Curve Digital Signature as Multisig -bls12_381-g1-share-msig, multisig, 0xd01304, draft, G1 threshold signature share for BLS12-381-G2 as Multisig -bls12_381-g2-share-msig, multisig, 0xd01305, draft, G2 threshold signature share for BLS12-381-G1 as Multisig +bls12_381-g1-share-msig, multisig, 0xd01304, draft, G1 threshold signature share for BLS-12381-G2 as Multisig +bls12_381-g2-share-msig, multisig, 0xd01305, draft, G2 threshold signature share for BLS-12381-G1 as Multisig lamport-msig, multisig, 0xd01306, draft, Lamport signature as Multisig lamport-share-msig, multisig, 0xd01307, draft, Lamport threshold signature share as Multisig es256-msig, multisig, 0xd01308, draft, ECDSA P-256 Signature as Multisig es384-msig, multisig, 0xd01309, draft, ECDSA P-384 Signature as Multisig es521-msig, multisig, 0xd0130a, draft, ECDSA P-521 Signature as Multisig rs256-msig, multisig, 0xd0130b, draft, RS256 Signature as Multisig +slh-dsa-sha2-128f-msig, multisig, 0xd0130c, draft, SLH-DSA SHA2-128f signature as Multisig; FIPS 205 +slh-dsa-sha2-128s-msig, multisig, 0xd01312, draft, SLH-DSA SHA2-128s signature as Multisig; FIPS 205 +slh-dsa-sha2-192f-msig, multisig, 0xd01313, draft, SLH-DSA SHA2-192f signature as Multisig; FIPS 205 +slh-dsa-sha2-192s-msig, multisig, 0xd01314, draft, SLH-DSA SHA2-192s signature as Multisig; FIPS 205 +slh-dsa-sha2-256f-msig, multisig, 0xd01315, draft, SLH-DSA SHA2-256f signature as Multisig; FIPS 205 +slh-dsa-sha2-256s-msig, multisig, 0xd01316, draft, SLH-DSA SHA2-256s signature as Multisig; FIPS 205 +slh-dsa-shake128f-msig, multisig, 0xd01317, draft, SLH-DSA SHAKE128f signature as Multisig; FIPS 205 +slh-dsa-shake128s-msig, multisig, 0xd01318, draft, SLH-DSA SHAKE128s signature as Multisig; FIPS 205 +slh-dsa-shake192f-msig, multisig, 0xd01319, draft, SLH-DSA SHAKE192f signature as Multisig; FIPS 205 +slh-dsa-shake192s-msig, multisig, 0xd0131a, draft, SLH-DSA SHAKE192s signature as Multisig; FIPS 205 +slh-dsa-shake256f-msig, multisig, 0xd0131b, draft, SLH-DSA SHAKE256f signature as Multisig; FIPS 205 +slh-dsa-shake256s-msig, multisig, 0xd0131c, draft, SLH-DSA SHAKE256s signature as Multisig; FIPS 205 +ml-dsa-65-msig, multisig, 0xd01310, draft, ML-DSA (Dilithium) 65 signature as Multisig; FIPS 204 +ml-dsa-87-msig, multisig, 0xd01311, draft, ML-DSA (Dilithium) 87 signature as Multisig; FIPS 204 +fn-dsa-512-msig, multisig, 0xd0130e, draft, FN-DSA (Falcon) 512 signature as Multisig; FIPS 206 (draft) +fn-dsa-1024-msig, multisig, 0xd0130f, draft, FN-DSA (Falcon) 1024 signature as Multisig; FIPS 206 (draft) +mayo-1-msig, multisig, 0xd0131d, draft, MAYO level 1 signature as Multisig +mayo-2-msig, multisig, 0xd0131e, draft, MAYO level 2 signature as Multisig +mayo-3-msig, multisig, 0xd01322, draft, MAYO level 3 signature as Multisig +mayo-5-msig, multisig, 0xd01323, draft, MAYO level 5 signature as Multisig +ed25519-mayo2-msig, multisig, 0xd01320, draft, Ed25519-MAYO2 hybrid signature as Multisig +ed25519-mldsa65-msig, multisig, 0xd01324, draft, Ed25519-ML-DSA-65 hybrid signature as Multisig +ed25519-fndsa512-msig, multisig, 0xd01326, draft, Ed25519-FN-DSA-512 hybrid signature as Multisig +bls12381-g1-mldsa65-msig, multisig, 0xd01328, draft, BLS12-381-G1-ML-DSA-65 hybrid signature as Multisig +bls12381-g1-fndsa512-msig, multisig, 0xd01329, draft, BLS12-381-G1-FN-DSA-512 hybrid signature as Multisig +bls12381-g1-mayo1-msig, multisig, 0xd0132a, draft, BLS12-381-G1-MAYO-1 hybrid signature as Multisig +bls12381-g1-mayo2-msig, multisig, 0xd0132b, draft, BLS12-381-G1-MAYO-2 hybrid signature as Multisig +bs-message, multiformat, 0xd01400, draft, BetterSign signed+encrypted message multiformat scion, multiaddr, 0xd02000, draft, SCION Internet architecture +ed25519-thresh-priv-share, key, 0xd03000, draft, Ed25519 FROST DKG threshold private key share +ed25519-thresh-pub-share, key, 0xd03001, draft, Ed25519 FROST DKG threshold public key share +p256-thresh-priv-share, key, 0xd03002, draft, P-256 FROST DKG threshold private key share +p256-thresh-pub-share, key, 0xd03003, draft, P-256 FROST DKG threshold public key share +p384-thresh-priv-share, key, 0xd03004, draft, P-384 FROST DKG threshold private key share +p384-thresh-pub-share, key, 0xd03005, draft, P-384 FROST DKG threshold public key share +secp256k1-thresh-priv-share, key, 0xd03006, draft, secp256k1 FROST DKG threshold private key share +secp256k1-thresh-pub-share, key, 0xd03007, draft, secp256k1 FROST DKG threshold public key share +bls12-381-thresh-priv-share, key, 0xd03008, draft, BLS12-381 FROST DKG threshold private key share +bls12-381-thresh-pub-share, key, 0xd03009, draft, BLS12-381 FROST DKG threshold public key share +ed448-thresh-priv-share, key, 0xd0300a, draft, Ed448 FROST DKG threshold private key share +ed448-thresh-pub-share, key, 0xd0300b, draft, Ed448 FROST DKG threshold public key share +key-split-share, key, 0xd0300c, draft, Generic verifiable private key split share (Feldman VSS or gf256) diff --git a/tests/edge_case_tests.rs b/tests/edge_case_tests.rs new file mode 100644 index 0000000..f1be6b3 --- /dev/null +++ b/tests/edge_case_tests.rs @@ -0,0 +1,291 @@ +// SPDX-License-Identifier: MIT or Apache-2.0 +//! Edge case tests for multi-codec +//! +//! These tests verify behavior at boundary conditions and extreme values. + +use multi_codec::Codec; +use multi_trait::{Null, TryDecodeFrom}; + +/// Test identity codec (0x00) - the default +#[test] +fn test_identity_codec() { + let codec = Codec::try_from(0x00u64).unwrap(); + assert_eq!(codec, Codec::Identity); + assert_eq!(codec.code(), 0x00); + assert_eq!(codec.as_str(), "identity"); + + // Should be the default + assert_eq!(codec, Codec::default()); + + // Should be the null value + assert_eq!(codec, Codec::null()); + assert!(codec.is_null()); +} + +/// Test maximum valid codec values +#[test] +fn test_maximum_codec_values() { + // Test some large valid codes + // Most multicodec values are in lower ranges, but test higher ones if they exist + + // Test that u64::MAX is rejected (not in table) + let result = Codec::try_from(u64::MAX); + assert!(result.is_err()); + + // Test that values beyond table range are rejected + let result = Codec::try_from(0xFFFFFFFFu64); + assert!(result.is_err()); +} + +/// Test minimum unsigned values across all types +#[test] +fn test_minimum_unsigned_values() { + // All unsigned types should work with 0 (identity) + assert!(Codec::try_from(0u8).is_ok()); + assert!(Codec::try_from(0u16).is_ok()); + assert!(Codec::try_from(0u32).is_ok()); + assert!(Codec::try_from(0u64).is_ok()); +} + +/// Test maximum unsigned values that fit in smaller types +#[test] +fn test_maximum_small_unsigned_values() { + // These should work if the codes exist in the table + let _ = Codec::try_from(u8::MAX); // May or may not exist + let _ = Codec::try_from(u16::MAX); // May or may not exist + let _ = Codec::try_from(u32::MAX); // Likely doesn't exist +} + +/// Test zero values for all signed types +#[test] +fn test_zero_signed_values() { + assert_eq!(Codec::try_from(0i8).unwrap(), Codec::Identity); + assert_eq!(Codec::try_from(0i16).unwrap(), Codec::Identity); + assert_eq!(Codec::try_from(0i32).unwrap(), Codec::Identity); + assert_eq!(Codec::try_from(0i64).unwrap(), Codec::Identity); +} + +/// Test minimum signed values (all negative, should fail) +#[test] +fn test_minimum_signed_values() { + assert!(Codec::try_from(i8::MIN).is_err()); + assert!(Codec::try_from(i16::MIN).is_err()); + assert!(Codec::try_from(i32::MIN).is_err()); + assert!(Codec::try_from(i64::MIN).is_err()); +} + +/// Test maximum signed values (positive, may or may not exist) +#[test] +fn test_maximum_signed_values() { + let _ = Codec::try_from(i8::MAX); // 127 + let _ = Codec::try_from(i16::MAX); // 32767 + let _ = Codec::try_from(i32::MAX); // Likely doesn't exist + let _ = Codec::try_from(i64::MAX); // Likely doesn't exist +} + +/// Test empty string (should fail) +#[test] +fn test_empty_string() { + let result = Codec::try_from(""); + assert!(result.is_err()); +} + +/// Test whitespace strings (should fail) +#[test] +fn test_whitespace_strings() { + assert!(Codec::try_from(" ").is_err()); + assert!(Codec::try_from(" ").is_err()); + assert!(Codec::try_from("\t").is_err()); + assert!(Codec::try_from("\n").is_err()); +} + +/// Test case sensitivity +#[test] +fn test_case_sensitivity() { + // Codec names are lowercase with hyphens + assert!(Codec::try_from("ed25519-pub").is_ok()); + + // Different case should fail + assert!(Codec::try_from("ED25519-PUB").is_err()); + assert!(Codec::try_from("Ed25519-Pub").is_err()); + assert!(Codec::try_from("Ed25519-pub").is_err()); +} + +/// Test special characters in names +#[test] +fn test_special_characters() { + // Hyphens are valid + assert!(Codec::try_from("ed25519-pub").is_ok()); + + // Other special chars should fail + assert!(Codec::try_from("ed25519_pub").is_err()); + assert!(Codec::try_from("ed25519.pub").is_err()); + assert!(Codec::try_from("ed25519/pub").is_err()); +} + +/// Test encoding of identity (minimal case) +#[test] +fn test_identity_encoding() { + let codec = Codec::Identity; + let encoded: Vec = codec.into(); + + // Identity (0x00) encodes as a single byte + assert_eq!(encoded, vec![0x00]); + + // Decode back + let (decoded, remaining) = Codec::try_decode_from(&encoded).unwrap(); + assert_eq!(decoded, Codec::Identity); + assert!(remaining.is_empty()); +} + +/// Test decoding with no remaining bytes +#[test] +fn test_decode_exact_length() { + let codec = Codec::Ed25519Pub; + let encoded: Vec = codec.into(); + + let (decoded, remaining) = Codec::try_decode_from(&encoded).unwrap(); + assert_eq!(decoded, codec); + assert!(remaining.is_empty()); + assert_eq!(remaining.len(), 0); +} + +/// Test decoding with trailing bytes +#[test] +fn test_decode_with_trailing() { + let codec = Codec::Ed25519Pub; + let mut encoded: Vec = codec.into(); + encoded.extend_from_slice(&[0xAA, 0xBB, 0xCC]); + + let (decoded, remaining) = Codec::try_decode_from(&encoded).unwrap(); + assert_eq!(decoded, codec); + assert_eq!(remaining, &[0xAA, 0xBB, 0xCC]); + assert_eq!(remaining.len(), 3); +} + +/// Test null trait implementation +#[test] +fn test_null_trait() { + let null_codec = Codec::null(); + assert_eq!(null_codec, Codec::Identity); + assert!(null_codec.is_null()); + + let other = Codec::Ed25519Pub; + assert!(!other.is_null()); +} + +/// Test default trait implementation +#[test] +fn test_default_trait() { + let default_codec = Codec::default(); + assert_eq!(default_codec, Codec::Identity); + assert_eq!(default_codec, Codec::null()); +} + +/// Test codec equality is reflexive +#[test] +fn test_equality_reflexive() { + let codec = Codec::Ed25519Pub; + assert_eq!(codec, codec); +} + +/// Test codec equality is symmetric +#[test] +fn test_equality_symmetric() { + let c1 = Codec::Ed25519Pub; + let c2 = Codec::Ed25519Pub; + + assert_eq!(c1, c2); + assert_eq!(c2, c1); +} + +/// Test codec equality is transitive +#[test] +fn test_equality_transitive() { + let c1 = Codec::Ed25519Pub; + let c2 = Codec::try_from(0xED).unwrap(); + let c3 = Codec::try_from("ed25519-pub").unwrap(); + + assert_eq!(c1, c2); + assert_eq!(c2, c3); + assert_eq!(c1, c3); +} + +/// Test ordering is consistent +#[test] +fn test_ordering_consistent() { + let c1 = Codec::Identity; // 0x00 + let c2 = Codec::Sha2256; // 0x12 + let c3 = Codec::Ed25519Pub; // 0xED + + assert!(c1 < c2); + assert!(c2 < c3); + assert!(c1 < c3); // Transitivity + + assert!(c3 > c2); + assert!(c2 > c1); + assert!(c3 > c1); // Transitivity +} + +/// Test copy semantics +#[test] +fn test_copy_semantics() { + let c1 = Codec::Ed25519Pub; + let c2 = c1; // Copy, not move + + // Both should be usable + assert_eq!(c1.code(), 0xED); + assert_eq!(c2.code(), 0xED); + assert_eq!(c1, c2); +} + +/// Test clone equals copy for Codec +#[test] +fn test_clone_equals_copy() { + let c1 = Codec::Ed25519Pub; + let c2 = c1; + + assert_eq!(c1, c2); + assert_eq!(c1.code(), c2.code()); + assert_eq!(c1.as_str(), c2.as_str()); +} + +#[cfg(feature = "serde")] +mod serde_edge_cases { + use super::*; + + /// Test serde with identity codec + #[test] + fn test_serde_identity() { + let codec = Codec::Identity; + + // JSON (human readable) + let json = serde_json::to_string(&codec).unwrap(); + assert_eq!(json, "\"identity\""); + let decoded: Codec = serde_json::from_str(&json).unwrap(); + assert_eq!(decoded, Codec::Identity); + + // CBOR (binary) + let bytes = serde_cbor::to_vec(&codec).unwrap(); + let decoded: Codec = serde_cbor::from_slice(&bytes).unwrap(); + assert_eq!(decoded, Codec::Identity); + } + + /// Test serde with various codecs + #[test] + fn test_serde_various_codecs() { + let codecs = vec![Codec::Identity, Codec::Sha2256, Codec::Ed25519Pub]; + + for codec in codecs { + // JSON roundtrip + let json = serde_json::to_string(&codec).unwrap(); + let decoded: Codec = serde_json::from_str(&json).unwrap(); + assert_eq!(decoded, codec); + + // CBOR roundtrip + let bytes = serde_cbor::to_vec(&codec).unwrap(); + let decoded: Codec = serde_cbor::from_slice(&bytes).unwrap(); + assert_eq!(decoded, codec); + } + } +} diff --git a/tests/error_tests.rs b/tests/error_tests.rs new file mode 100644 index 0000000..6c136e1 --- /dev/null +++ b/tests/error_tests.rs @@ -0,0 +1,226 @@ +// SPDX-License-Identifier: MIT or Apache-2.0 +//! Tests for error handling and error types + +use multi_codec::{Codec, Error}; + +/// Test InvalidName error creation and properties +#[test] +fn test_invalid_name_error_properties() { + let err = Error::invalid_name("bad-codec"); + + // Check error kind + assert_eq!(err.kind(), "InvalidName"); + + // Check context contains the name + let context = err.context(); + assert!(context.contains("bad-codec")); + + // Check error message + let msg = err.to_string(); + assert!(msg.contains("bad-codec")); + assert!(msg.contains("multicodec")); +} + +/// Test InvalidValue error creation and properties +#[test] +fn test_invalid_value_error_properties() { + let err = Error::invalid_value(0xDEADBEEF); + + // Check error kind + assert_eq!(err.kind(), "InvalidValue"); + + // Check context contains the value + let context = err.context(); + assert!(context.contains("deadbeef")); + + // Check error message + let msg = err.to_string(); + assert!(msg.contains("0xdeadbeef")); + assert!(msg.contains("multicodec")); +} + +/// Test NegativeValue error creation and properties +#[test] +fn test_negative_value_error_properties() { + let err = Error::negative_value(-42); + + // Check error kind + assert_eq!(err.kind(), "NegativeValue"); + + // Check context contains the value + let context = err.context(); + assert!(context.contains("-42")); + + // Check error message + let msg = err.to_string(); + assert!(msg.contains("-42")); + assert!(msg.contains("negative")); +} + +/// Test that errors from TryFrom implementations have correct types +#[test] +fn test_tryfrom_str_error_type() { + let result = Codec::try_from("nonexistent-codec"); + assert!(result.is_err()); + + let err = result.unwrap_err(); + assert!(matches!(err, Error::InvalidName { .. })); + assert_eq!(err.kind(), "InvalidName"); +} + +#[test] +fn test_tryfrom_u64_error_type() { + let result = Codec::try_from(0xDEADBEEFu64); + assert!(result.is_err()); + + let err = result.unwrap_err(); + assert!(matches!(err, Error::InvalidValue { .. })); + assert_eq!(err.kind(), "InvalidValue"); +} + +#[test] +fn test_tryfrom_negative_error_type() { + let result = Codec::try_from(-1i64); + assert!(result.is_err()); + + let err = result.unwrap_err(); + assert!(matches!(err, Error::NegativeValue { .. })); + assert_eq!(err.kind(), "NegativeValue"); +} + +/// Test error messages provide helpful guidance +#[test] +fn test_error_messages_provide_guidance() { + // InvalidName should reference the multicodec table + let err = Error::invalid_name("unknown"); + let msg = err.to_string(); + assert!(msg.contains("github.com") || msg.contains("table.csv")); + + // InvalidValue should reference the multicodec table + let err = Error::invalid_value(999999); + let msg = err.to_string(); + assert!(msg.contains("github.com") || msg.contains("table.csv")); + + // NegativeValue should suggest using unsigned types + let err = Error::negative_value(-1); + let msg = err.to_string(); + assert!(msg.contains("unsigned") || msg.contains("non-negative")); +} + +/// Test error kind uniqueness +#[test] +fn test_error_kinds_are_unique() { + let errors = [ + Error::invalid_name("test"), + Error::invalid_value(123), + Error::negative_value(-1), + ]; + + let kinds: Vec<_> = errors.iter().map(|e| e.kind()).collect(); + + // All kinds should be unique + for (i, kind1) in kinds.iter().enumerate() { + for (j, kind2) in kinds.iter().enumerate() { + if i != j { + assert_ne!(kind1, kind2, "Error kinds should be unique"); + } + } + } +} + +/// Test error context is useful for debugging +#[test] +fn test_error_context_for_debugging() { + let err = Error::invalid_name("test-codec"); + let context = err.context(); + assert!(context.contains("test-codec")); + assert!(!context.is_empty()); + + let err = Error::invalid_value(0x123); + let context = err.context(); + assert!(context.contains("0x123") || context.contains("123") || context.contains("291")); + assert!(!context.is_empty()); + + let err = Error::negative_value(-100); + let context = err.context(); + assert!(context.contains("-100")); + assert!(!context.is_empty()); +} + +/// Test that error types can be matched on +#[test] +fn test_error_pattern_matching() { + let err = Error::invalid_name("test"); + match err { + Error::InvalidName { name } => assert_eq!(name, "test"), + _ => panic!("Wrong error variant"), + } + + let err = Error::invalid_value(42); + match err { + Error::InvalidValue { code } => assert_eq!(code, 42), + _ => panic!("Wrong error variant"), + } + + let err = Error::negative_value(-5); + match err { + Error::NegativeValue { value } => assert_eq!(value, -5), + _ => panic!("Wrong error variant"), + } +} + +/// Test error is Send + Sync +#[test] +fn test_error_send_sync() { + fn assert_send() {} + fn assert_sync() {} + + assert_send::(); + assert_sync::(); +} + +/// Test error implements std::error::Error +#[test] +fn test_error_trait_impl() { + use std::error::Error as StdError; + + let err = Error::invalid_name("test"); + let _: &dyn StdError = &err; + + // Multitrait errors are transparent, so they are the source themselves + let mt_err = multi_trait::Error::InsufficientData { + expected: 10, + actual: 5, + }; + let err = Error::Multitrait(mt_err); + // Transparent errors don't have a separate source, they ARE the source + let _: &dyn StdError = &err; +} + +/// Test that error display is informative +#[test] +fn test_error_display_informative() { + let err = Error::invalid_name("bad-name"); + let display = format!("{}", err); + assert!(!display.is_empty()); + assert!(display.len() > 20); // Should be a full sentence, not just a few words + + let err = Error::invalid_value(999); + let display = format!("{}", err); + assert!(!display.is_empty()); + assert!(display.len() > 20); + + let err = Error::negative_value(-10); + let display = format!("{}", err); + assert!(!display.is_empty()); + assert!(display.len() > 20); +} + +/// Test error debug output +#[test] +fn test_error_debug_output() { + let err = Error::invalid_name("test"); + let debug = format!("{:?}", err); + assert!(!debug.is_empty()); + assert!(debug.contains("InvalidName") || debug.contains("test")); +} diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs new file mode 100644 index 0000000..ea2557e --- /dev/null +++ b/tests/integration_tests.rs @@ -0,0 +1,349 @@ +// SPDX-License-Identifier: MIT or Apache-2.0 +//! Integration tests for multi-codec +//! +//! These tests verify cross-module interactions and real-world usage scenarios. + +use multi_codec::{Codec, Error}; +use multi_trait::TryDecodeFrom; + +/// Test complete encode/decode cycle +#[test] +fn test_full_encode_decode_cycle() { + let original = Codec::Ed25519Pub; + + // Encode to bytes + let bytes: Vec = original.into(); + assert!(!bytes.is_empty()); + + // Decode from bytes + let (decoded, remaining) = Codec::try_decode_from(&bytes).unwrap(); + assert_eq!(decoded, original); + assert!(remaining.is_empty()); + + // Verify code matches + assert_eq!(decoded.code(), original.code()); + + // Verify name matches + assert_eq!(decoded.as_str(), original.as_str()); +} + +/// Test conversion chain: name -> codec -> code -> codec -> name +#[test] +fn test_conversion_chain() { + // Start with name + let original_name = "sha2-256"; + + // Name -> Codec + let codec1 = Codec::try_from(original_name).unwrap(); + + // Codec -> Code + let code: u64 = codec1.into(); + + // Code -> Codec + let codec2 = Codec::try_from(code).unwrap(); + + // Codec -> Name + let final_name = codec2.as_str(); + + // Should match original + assert_eq!(final_name, original_name); + assert_eq!(codec1, codec2); +} + +/// Test using codec in a struct +#[test] +fn test_codec_in_struct() { + #[derive(Debug, PartialEq)] + struct Message { + algorithm: Codec, + data: Vec, + } + + let msg = Message { + algorithm: Codec::Sha2256, + data: vec![1, 2, 3, 4], + }; + + // Verify codec works in struct context + assert_eq!(msg.algorithm.code(), 0x12); + assert_eq!(msg.algorithm.as_str(), "sha2-256"); + + // Clone the struct + let msg2 = Message { + algorithm: msg.algorithm, + data: msg.data.clone(), + }; + + assert_eq!(msg, msg2); +} + +/// Test using codec as HashMap key +#[test] +fn test_codec_as_hashmap_key() { + use std::collections::HashMap; + + let mut map = HashMap::new(); + map.insert(Codec::Sha2256, "SHA-256 hash"); + map.insert(Codec::Ed25519Pub, "Ed25519 public key"); + map.insert(Codec::Identity, "Identity"); + + assert_eq!(map.get(&Codec::Sha2256), Some(&"SHA-256 hash")); + assert_eq!(map.get(&Codec::Ed25519Pub), Some(&"Ed25519 public key")); + assert_eq!(map.get(&Codec::Identity), Some(&"Identity")); + assert_eq!(map.len(), 3); +} + +/// Test using codec in a BTreeMap (requires Ord) +#[test] +fn test_codec_in_btreemap() { + use std::collections::BTreeMap; + + let mut map = BTreeMap::new(); + map.insert(Codec::Ed25519Pub, "Last"); + map.insert(Codec::Identity, "First"); + map.insert(Codec::Sha2256, "Middle"); + + // Should be sorted by code value + let keys: Vec<_> = map.keys().copied().collect(); + assert_eq!(keys[0], Codec::Identity); // 0x00 + assert_eq!(keys[1], Codec::Sha2256); // 0x12 + assert_eq!(keys[2], Codec::Ed25519Pub); // 0xED +} + +/// Test codec in Option +#[test] +fn test_codec_in_option() { + let some_codec: Option = Some(Codec::Sha2256); + let no_codec: Option = None; + + assert_eq!(some_codec.map(|c| c.code()), Some(0x12)); + assert!(no_codec.is_none()); + + // Map operations + let codes: Option = some_codec.map(|c| c.code()); + assert_eq!(codes, Some(0x12)); +} + +/// Test codec in Result +#[test] +fn test_codec_in_result() { + let ok_codec: Result = Ok(Codec::Sha2256); + let err_codec: Result = Err(Error::invalid_name("bad")); + + assert_eq!(ok_codec.as_ref().unwrap().code(), 0x12); + assert!(err_codec.is_err()); + + // Map operations + let codes: Result = ok_codec.map(|c| c.code()); + assert_eq!(codes.unwrap(), 0x12); +} + +/// Test codec in Vec +#[test] +fn test_codec_in_vec() { + let codecs = [Codec::Identity, Codec::Sha2256, Codec::Ed25519Pub]; + + assert_eq!(codecs.len(), 3); + assert_eq!(codecs[0], Codec::Identity); + assert_eq!(codecs[1].code(), 0x12); + assert_eq!(codecs[2].as_str(), "ed25519-pub"); + + // Iteration + let codes: Vec = codecs.iter().map(|c| c.code()).collect(); + assert_eq!(codes, vec![0x00, 0x12, 0xED]); +} + +/// Test codec with multitrait integration +#[test] +fn test_multitrait_integration() { + let codec = Codec::Sha2256; + + // Convert to Vec which uses EncodeInto internally + let encoded: Vec = codec.into(); + assert!(!encoded.is_empty()); + + // Use TryDecodeFrom from multitrait + let (decoded, remaining) = Codec::try_decode_from(&encoded).unwrap(); + assert_eq!(decoded, codec); + assert!(remaining.is_empty()); +} + +/// Test error types in real-world scenarios +#[test] +fn test_error_handling_scenarios() { + // Scenario 1: User provides invalid name + match Codec::try_from("unknown-algorithm") { + Ok(_) => panic!("Should have failed"), + Err(e) => { + assert_eq!(e.kind(), "InvalidName"); + assert!(e.to_string().contains("unknown-algorithm")); + } + } + + // Scenario 2: Parsing binary data with invalid code + match Codec::try_from(0xDEADBEEFu64) { + Ok(_) => panic!("Should have failed"), + Err(e) => { + assert_eq!(e.kind(), "InvalidValue"); + assert!(e.to_string().contains("deadbeef")); + } + } + + // Scenario 3: Converting negative value + match Codec::try_from(-42i64) { + Ok(_) => panic!("Should have failed"), + Err(e) => { + assert_eq!(e.kind(), "NegativeValue"); + assert!(e.to_string().contains("-42")); + } + } +} + +/// Test building a codec registry +#[test] +fn test_codec_registry() { + use std::collections::HashMap; + + // Build a registry mapping names to codes + let mut registry = HashMap::new(); + let codecs = vec![ + Codec::Identity, + Codec::Sha2256, + Codec::Sha2512, + Codec::Ed25519Pub, + ]; + + for codec in codecs { + registry.insert(codec.as_str().to_string(), codec.code()); + } + + // Lookup works + assert_eq!(registry.get("sha2-256"), Some(&0x12)); + assert_eq!(registry.get("ed25519-pub"), Some(&0xED)); + + // Unknown codec + assert_eq!(registry.get("unknown"), None); +} + +/// Test sequential encoding of multiple codecs +#[test] +fn test_sequential_encoding() { + use multi_trait::EncodeIntoBuffer; + + let codecs = vec![Codec::Identity, Codec::Sha2256, Codec::Ed25519Pub]; + + let mut buffer = Vec::new(); + for codec in &codecs { + let code: u64 = (*codec).into(); + code.encode_into_buffer(&mut buffer); + } + + // Decode them back + let mut remaining = buffer.as_slice(); + for codec in &codecs { + let (code, rest) = u64::try_decode_from(remaining).unwrap(); + let decoded = Codec::try_from(code).unwrap(); + assert_eq!(decoded, *codec); + remaining = rest; + } + + assert!(remaining.is_empty()); +} + +/// Test codec with pattern matching +#[test] +fn test_pattern_matching() { + let codec = Codec::Sha2256; + + match codec { + Codec::Identity => panic!("Wrong variant"), + Codec::Sha2256 => { + assert_eq!(codec.code(), 0x12); + } + _ => panic!("Wrong variant"), + } +} + +/// Test codec display format +#[test] +fn test_display_format() { + let codec = Codec::Ed25519Pub; + + // Display should show the name + let display = format!("{}", codec); + assert_eq!(display, "ed25519-pub"); + + // Debug should show both name and code + let debug = format!("{:?}", codec); + assert!(debug.contains("ed25519-pub")); + assert!(debug.contains("0xed")); +} + +#[cfg(feature = "serde")] +mod serde_integration { + use super::*; + use serde::{Deserialize, Serialize}; + + /// Test codec in a serde-enabled struct + #[test] + fn test_codec_in_serde_struct() { + #[derive(Debug, PartialEq, Serialize, Deserialize)] + struct CryptoOperation { + algorithm: Codec, + key_id: u64, + data: Vec, + } + + let op = CryptoOperation { + algorithm: Codec::Ed25519Pub, + key_id: 42, + data: vec![1, 2, 3, 4, 5], + }; + + // JSON roundtrip + let json = serde_json::to_string(&op).unwrap(); + let decoded: CryptoOperation = serde_json::from_str(&json).unwrap(); + assert_eq!(decoded, op); + + // Verify algorithm preserved + assert_eq!(decoded.algorithm, Codec::Ed25519Pub); + assert_eq!(decoded.algorithm.code(), 0xED); + + // CBOR roundtrip + let bytes = serde_cbor::to_vec(&op).unwrap(); + let decoded: CryptoOperation = serde_cbor::from_slice(&bytes).unwrap(); + assert_eq!(decoded, op); + } + + /// Test codec in nested structures + #[test] + fn test_codec_in_nested_struct() { + #[derive(Debug, PartialEq, Serialize, Deserialize)] + struct Inner { + hash_algorithm: Codec, + } + + #[derive(Debug, PartialEq, Serialize, Deserialize)] + struct Outer { + signature_algorithm: Codec, + hash_config: Inner, + } + + let config = Outer { + signature_algorithm: Codec::Ed25519Pub, + hash_config: Inner { + hash_algorithm: Codec::Sha2256, + }, + }; + + // JSON roundtrip + let json = serde_json::to_string(&config).unwrap(); + let decoded: Outer = serde_json::from_str(&json).unwrap(); + assert_eq!(decoded, config); + + // CBOR roundtrip + let bytes = serde_cbor::to_vec(&config).unwrap(); + let decoded: Outer = serde_cbor::from_slice(&bytes).unwrap(); + assert_eq!(decoded, config); + } +} diff --git a/tests/proptest_tests.rs b/tests/proptest_tests.rs new file mode 100644 index 0000000..ea9a06f --- /dev/null +++ b/tests/proptest_tests.rs @@ -0,0 +1,280 @@ +// SPDX-License-Identifier: MIT or Apache-2.0 +//! Property-based tests for multi-codec using proptest +//! +//! These tests verify that invariants hold across a wide range of inputs +//! by generating random test cases and checking properties. + +use multi_codec::Codec; +use multi_trait::TryDecodeFrom; +use proptest::prelude::*; + +/// Property: Encoding and decoding should roundtrip for valid codecs +#[test] +fn test_encode_decode_roundtrip() { + proptest!(|(code in 0u64..=0x0FFFFFFF)| { + // Try to create a codec from this code + if let Ok(codec) = Codec::try_from(code) { + // Encode it + let encoded: Vec = codec.into(); + + // Decode it back + let (decoded, remaining) = Codec::try_decode_from(&encoded).unwrap(); + + // Should match original + prop_assert_eq!(codec, decoded); + prop_assert!(remaining.is_empty()); + + // Code should match + let decoded_code: u64 = decoded.into(); + prop_assert_eq!(code, decoded_code); + } + }); +} + +/// Property: String conversion should roundtrip for valid codecs +#[test] +fn test_str_conversion_roundtrip() { + proptest!(|(code in 0u64..=0x0FFFFFFF)| { + if let Ok(codec) = Codec::try_from(code) { + // Convert to string + let name = codec.as_str(); + + // Convert back from string + let decoded = Codec::try_from(name).unwrap(); + + // Should match original + prop_assert_eq!(codec, decoded); + } + }); +} + +/// Property: Code conversion should be bidirectional +#[test] +fn test_code_bidirectional() { + proptest!(|(code in 0u64..=0x0FFFFFFF)| { + if let Ok(codec) = Codec::try_from(code) { + let code2: u64 = codec.into(); + prop_assert_eq!(code, code2); + + // Also test code() method + prop_assert_eq!(code, codec.code()); + } + }); +} + +/// Property: Invalid codes should always be rejected +#[test] +fn test_invalid_codes_rejected() { + proptest!(|(code in 0u64..=u64::MAX)| { + match Codec::try_from(code) { + Ok(codec) => { + // Valid code - should roundtrip + let code2: u64 = codec.into(); + prop_assert_eq!(code, code2); + } + Err(_) => { + // Invalid code - expected to fail + // Just verify it returns an error + } + } + }); +} + +/// Property: as_str() should always return a non-empty string +#[test] +fn test_str_never_empty() { + proptest!(|(code in 0u64..=0x0FFFFFFF)| { + if let Ok(codec) = Codec::try_from(code) { + let name = codec.as_str(); + prop_assert!(!name.is_empty()); + prop_assert!(!name.is_empty()); + } + }); +} + +/// Property: Debug output should contain both name and code +#[test] +fn test_debug_contains_name_and_code() { + proptest!(|(code in 0u64..=0x0FFFFFFF)| { + if let Ok(codec) = Codec::try_from(code) { + let debug = format!("{:?}", codec); + let name = codec.as_str(); + + // Debug should contain the name + prop_assert!(debug.contains(name)); + + // Debug should contain hex representation + prop_assert!(debug.contains("0x")); + } + }); +} + +/// Property: Display output should equal as_str() +#[test] +fn test_display_equals_as_str() { + proptest!(|(code in 0u64..=0x0FFFFFFF)| { + if let Ok(codec) = Codec::try_from(code) { + let display = format!("{}", codec); + let as_str = codec.as_str(); + prop_assert_eq!(display, as_str); + } + }); +} + +/// Property: Codec should be deterministic (same input = same output) +#[test] +fn test_deterministic_behavior() { + proptest!(|(code in 0u64..=0x0FFFFFFF)| { + if let Ok(codec1) = Codec::try_from(code) { + let codec2 = Codec::try_from(code).unwrap(); + + // Should be equal + prop_assert_eq!(codec1, codec2); + + // Should have same code + prop_assert_eq!(codec1.code(), codec2.code()); + + // Should have same name + prop_assert_eq!(codec1.as_str(), codec2.as_str()); + + // Should encode identically + let enc1: Vec = codec1.into(); + let enc2: Vec = codec2.into(); + prop_assert_eq!(enc1, enc2); + } + }); +} + +/// Property: Hash should be consistent for equal values +#[test] +fn test_hash_consistency() { + use std::collections::hash_map::DefaultHasher; + use std::hash::{Hash, Hasher}; + + proptest!(|(code in 0u64..=0x0FFFFFFF)| { + if let Ok(codec) = Codec::try_from(code) { + let mut hasher1 = DefaultHasher::new(); + codec.hash(&mut hasher1); + let hash1 = hasher1.finish(); + + let mut hasher2 = DefaultHasher::new(); + codec.hash(&mut hasher2); + let hash2 = hasher2.finish(); + + prop_assert_eq!(hash1, hash2); + } + }); +} + +/// Property: Ordering should be consistent with code values +#[test] +fn test_ordering_by_code() { + proptest!(|(code1 in 0u64..=0x0FFFFFFF, code2 in 0u64..=0x0FFFFFFF)| { + if let (Ok(codec1), Ok(codec2)) = (Codec::try_from(code1), Codec::try_from(code2)) { + // Ordering should match code ordering + if code1 < code2 { + prop_assert!(codec1 < codec2); + } else if code1 > code2 { + prop_assert!(codec1 > codec2); + } else { + prop_assert_eq!(codec1, codec2); + } + } + }); +} + +/// Property: Negative signed integers should always fail +#[test] +fn test_negative_always_fails() { + proptest!(|(value in i64::MIN..0i64)| { + let result = Codec::try_from(value); + prop_assert!(result.is_err()); + }); +} + +/// Property: Non-negative signed integers should behave like unsigned +#[test] +fn test_nonnegative_signed_matches_unsigned() { + proptest!(|(value in 0i64..=0x0FFFFFFF)| { + let from_signed = Codec::try_from(value); + let from_unsigned = Codec::try_from(value as u64); + + match (from_signed, from_unsigned) { + (Ok(c1), Ok(c2)) => prop_assert_eq!(c1, c2), + (Err(_), Err(_)) => {}, // Both fail - ok + _ => prop_assert!(false, "Signed and unsigned should agree"), + } + }); +} + +/// Property: Encoded bytes should have reasonable length (1-10 bytes for u64 varint) +#[test] +fn test_encoded_length_bounded() { + proptest!(|(code in 0u64..=0x0FFFFFFF)| { + if let Ok(codec) = Codec::try_from(code) { + let encoded: Vec = codec.into(); + prop_assert!(!encoded.is_empty()); + prop_assert!(encoded.len() <= 10); // u64 varint max is 10 bytes + } + }); +} + +/// Property: TryDecodeFrom should consume exactly the encoded bytes +#[test] +fn test_decode_consumes_exact_bytes() { + proptest!(|(code in 0u64..=0x0FFFFFFF)| { + if let Ok(codec) = Codec::try_from(code) { + let encoded: Vec = codec.into(); + let original_len = encoded.len(); + + let (decoded, remaining) = Codec::try_decode_from(&encoded).unwrap(); + prop_assert_eq!(codec, decoded); + prop_assert_eq!(remaining.len(), 0); + prop_assert_eq!(original_len, encoded.len() - remaining.len()); + } + }); +} + +/// Property: TryDecodeFrom with extra data should leave remainder +#[test] +fn test_decode_with_trailing_data() { + proptest!(|(code in 0u64..=0x0FFFFFFF, trailing in prop::collection::vec(any::(), 1..20))| { + if let Ok(codec) = Codec::try_from(code) { + let mut encoded: Vec = codec.into(); + encoded.extend_from_slice(&trailing); + + let (decoded, remaining) = Codec::try_decode_from(&encoded).unwrap(); + prop_assert_eq!(codec, decoded); + prop_assert_eq!(remaining, trailing.as_slice()); + } + }); +} + +#[cfg(feature = "serde")] +mod serde_props { + use super::*; + + /// Property: JSON serialization should roundtrip + #[test] + fn test_json_roundtrip() { + proptest!(|(code in 0u64..=0x0FFFFFFF)| { + if let Ok(codec) = Codec::try_from(code) { + let json = serde_json::to_string(&codec).unwrap(); + let decoded: Codec = serde_json::from_str(&json).unwrap(); + prop_assert_eq!(codec, decoded); + } + }); + } + + /// Property: CBOR serialization should roundtrip + #[test] + fn test_cbor_roundtrip() { + proptest!(|(code in 0u64..=0x0FFFFFFF)| { + if let Ok(codec) = Codec::try_from(code) { + let bytes = serde_cbor::to_vec(&codec).unwrap(); + let decoded: Codec = serde_cbor::from_slice(&bytes).unwrap(); + prop_assert_eq!(codec, decoded); + } + }); + } +} diff --git a/tests/security_tests.rs b/tests/security_tests.rs new file mode 100644 index 0000000..059b91b --- /dev/null +++ b/tests/security_tests.rs @@ -0,0 +1,232 @@ +// SPDX-License-Identifier: MIT or Apache-2.0 +//! Security-focused tests for multi-codec +//! +//! These tests verify that the crate properly handles malicious or +//! pathological inputs without panicking or consuming excessive resources. + +use multi_codec::Codec; + +/// Test that negative signed integers are rejected with proper error type +#[test] +fn test_negative_i8_rejection() { + use multi_codec::Error; + + let result = Codec::try_from(-1i8); + assert!(result.is_err()); + assert!(matches!(result.unwrap_err(), Error::NegativeValue { .. })); + + let result = Codec::try_from(-100i8); + assert!(result.is_err()); + + let result = Codec::try_from(i8::MIN); + assert!(result.is_err()); +} + +#[test] +fn test_negative_i16_rejection() { + use multi_codec::Error; + + let result = Codec::try_from(-1i16); + assert!(result.is_err()); + assert!(matches!(result.unwrap_err(), Error::NegativeValue { .. })); + + let result = Codec::try_from(-1000i16); + assert!(result.is_err()); + + let result = Codec::try_from(i16::MIN); + assert!(result.is_err()); +} + +#[test] +fn test_negative_i32_rejection() { + use multi_codec::Error; + + let result = Codec::try_from(-1i32); + assert!(result.is_err()); + assert!(matches!(result.unwrap_err(), Error::NegativeValue { .. })); + + let result = Codec::try_from(-100000i32); + assert!(result.is_err()); + + let result = Codec::try_from(i32::MIN); + assert!(result.is_err()); +} + +#[test] +fn test_negative_i64_rejection() { + use multi_codec::Error; + + let result = Codec::try_from(-1i64); + assert!(result.is_err()); + assert!(matches!(result.unwrap_err(), Error::NegativeValue { .. })); + + let result = Codec::try_from(-1000000i64); + assert!(result.is_err()); + + let result = Codec::try_from(i64::MIN); + assert!(result.is_err()); +} + +/// Test that positive signed integers work correctly +#[test] +fn test_positive_signed_integers() { + // Identity codec has code 0 + assert!(Codec::try_from(0i8).is_ok()); + assert!(Codec::try_from(0i16).is_ok()); + assert!(Codec::try_from(0i32).is_ok()); + assert!(Codec::try_from(0i64).is_ok()); + + // Test some valid positive values + assert!(Codec::try_from(0xEDi16).is_ok()); // Ed25519Pub +} + +/// Test that oversized varint data is rejected during deserialization +#[test] +fn test_dos_protection_oversized_varint() { + // Create a byte sequence longer than maximum varint size (19 bytes) + let oversized = vec![0xFF; 20]; + + // This should fail gracefully without allocating excessive memory + let result = Codec::try_from(oversized.as_slice()); + assert!(result.is_err(), "Should reject oversized varint"); +} + +/// Test that malformed varint data doesn't cause panics +#[test] +fn test_malformed_varint_handling() { + // Varint with all continuation bits set (invalid) + let invalid = vec![0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]; + + // Should either reject or decode without panic + let _ = Codec::try_from(invalid.as_slice()); +} + +/// Test that empty byte slices are handled correctly +#[test] +fn test_empty_byte_slice() { + let empty: &[u8] = &[]; + let result = Codec::try_from(empty); + assert!(result.is_err(), "Should reject empty byte slice"); +} + +/// Test that truncated varint data is rejected +#[test] +fn test_truncated_varint() { + // Single byte with continuation bit set, but no following bytes + let truncated = vec![0x80]; + let result = Codec::try_from(truncated.as_slice()); + assert!(result.is_err(), "Should reject truncated varint"); +} + +/// Test that codec values roundtrip correctly after conversion +#[test] +fn test_signed_roundtrip() { + // Test that positive signed values roundtrip correctly + let original = 0xEDi32; // Ed25519Pub code + let codec = Codec::try_from(original).unwrap(); + let code: u64 = codec.into(); + assert_eq!(code, 0xED); +} + +/// Test concurrent access doesn't cause issues +#[test] +fn test_concurrent_codec_usage() { + use std::sync::Arc; + use std::thread; + + let codec = Arc::new(Codec::Ed25519Pub); + let mut handles = vec![]; + + for _ in 0..4 { + let codec_clone = Arc::clone(&codec); + let handle = thread::spawn(move || { + for _ in 0..100 { + let code = codec_clone.code(); + let name = codec_clone.as_str(); + let _encoded: Vec = (*codec_clone).into(); + assert_eq!(code, 0xED); + assert_eq!(name, "ed25519-pub"); + } + }); + handles.push(handle); + } + + for handle in handles { + handle.join().unwrap(); + } +} + +/// Test that Hash implementation works correctly after optimization +#[test] +fn test_hash_consistency() { + use std::collections::hash_map::DefaultHasher; + use std::hash::{Hash, Hasher}; + + let codec1 = Codec::Ed25519Pub; + let codec2 = Codec::Ed25519Pub; + + let mut hasher1 = DefaultHasher::new(); + codec1.hash(&mut hasher1); + let hash1 = hasher1.finish(); + + let mut hasher2 = DefaultHasher::new(); + codec2.hash(&mut hasher2); + let hash2 = hasher2.finish(); + + assert_eq!(hash1, hash2, "Same codec should produce same hash"); +} + +/// Test that different codecs produce different hashes +#[test] +fn test_hash_uniqueness() { + use std::collections::hash_map::DefaultHasher; + use std::hash::{Hash, Hasher}; + + let codec1 = Codec::Ed25519Pub; + let codec2 = Codec::Sha2256; + + let mut hasher1 = DefaultHasher::new(); + codec1.hash(&mut hasher1); + let hash1 = hasher1.finish(); + + let mut hasher2 = DefaultHasher::new(); + codec2.hash(&mut hasher2); + let hash2 = hasher2.finish(); + + assert_ne!( + hash1, hash2, + "Different codecs should produce different hashes" + ); +} + +/// Test Send and Sync bounds are satisfied +#[test] +fn test_send_sync_bounds() { + fn assert_send() {} + fn assert_sync() {} + + assert_send::(); + assert_sync::(); +} + +/// Test that serde deserialization respects size limits +#[cfg(feature = "serde")] +#[test] +fn test_serde_dos_protection() { + use serde_json::json; + + // Create a JSON array with excessive number of bytes + let malicious_json = json!({ + "v": [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF] + }); + + #[derive(serde::Deserialize)] + struct Wrapper { + #[serde(rename = "v")] + _v: Codec, + } + + let result: Result = serde_json::from_value(malicious_json); + assert!(result.is_err(), "Should reject oversized varint in serde"); +} From 21e5201244d1e19927159f6c4b91c1c54f572435 Mon Sep 17 00:00:00 2001 From: Dave Grantham Date: Mon, 13 Jul 2026 15:42:43 -0600 Subject: [PATCH 2/3] update to latest table.csv Signed-off-by: Dave Grantham --- Cargo.toml | 4 +- benches/codec_bench.rs | 2 +- src/codec.rs | 2 +- src/table_gen.rs | 191 ++--- table.csv | 1503 ++++++++++++++++++++-------------------- 5 files changed, 872 insertions(+), 830 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index bec79a6..cf3390a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "multi-codec" -version = "1.0.0" +version = "1.0.1" edition = "2021" authors = ["Benjamin Kampmann ", "Dave Grantham "] description = "Implementation of the Multicodec specification" @@ -40,4 +40,4 @@ path = "examples/uvi.rs" convert_case = "0.6" csv = "1.3" serde = { version = "1.0", features = ["serde_derive"] } -serde_derive = "1.0" \ No newline at end of file +serde_derive = "1.0" diff --git a/benches/codec_bench.rs b/benches/codec_bench.rs index d3310c9..4d794a0 100644 --- a/benches/codec_bench.rs +++ b/benches/codec_bench.rs @@ -3,9 +3,9 @@ use std::hint::black_box; +use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion}; use multi_codec::Codec; use multi_trait::TryDecodeFrom; -use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion}; /// Benchmark conversions from u64 fn bench_from_u64(c: &mut Criterion) { diff --git a/src/codec.rs b/src/codec.rs index 370eabe..1f47128 100644 --- a/src/codec.rs +++ b/src/codec.rs @@ -15,11 +15,11 @@ )] #![allow(missing_docs)] // Allow because variants are generated use crate::Error; -use multi_trait::{EncodeInto, Null, TryDecodeFrom}; use core::{ fmt, hash::{Hash, Hasher}, }; +use multi_trait::{EncodeInto, Null, TryDecodeFrom}; macro_rules! build_codec_enum { {$( $val:expr => ($i:ident, $s:expr), )*} => { diff --git a/src/table_gen.rs b/src/table_gen.rs index 3ed47ca..3f66ec7 100644 --- a/src/table_gen.rs +++ b/src/table_gen.rs @@ -175,63 +175,66 @@ build_codec_enum! { 0x1208 => (ProvenanceLog, "provenance-log"), 0x1209 => (ProvenanceLogEntry, "provenance-log-entry"), 0x120a => (ProvenanceLogScript, "provenance-log-script"), + 0x120b => (Mlkem512Pub, "mlkem-512-pub"), 0x120c => (Mlkem768Pub, "mlkem-768-pub"), 0x120d => (Mlkem1024Pub, "mlkem-1024-pub"), - 0x120e => (SlhDsaSha2128FPub, "slh-dsa-sha2-128f-pub"), - 0x1214 => (SlhDsaSha2128SPub, "slh-dsa-sha2-128s-pub"), - 0x1215 => (SlhDsaSha2192FPub, "slh-dsa-sha2-192f-pub"), - 0x1216 => (SlhDsaSha2192SPub, "slh-dsa-sha2-192s-pub"), - 0x1217 => (SlhDsaSha2256FPub, "slh-dsa-sha2-256f-pub"), - 0x1218 => (SlhDsaSha2256SPub, "slh-dsa-sha2-256s-pub"), - 0x1219 => (SlhDsaShake128FPub, "slh-dsa-shake128f-pub"), - 0x121a => (SlhDsaShake128SPub, "slh-dsa-shake128s-pub"), - 0x121b => (SlhDsaShake192FPub, "slh-dsa-shake192f-pub"), - 0x121c => (SlhDsaShake192SPub, "slh-dsa-shake192s-pub"), - 0x121d => (SlhDsaShake256FPub, "slh-dsa-shake256f-pub"), - 0x121e => (SlhDsaShake256SPub, "slh-dsa-shake256s-pub"), + 0x120e => (FnDsa512Pub, "fn-dsa-512-pub"), + 0x120f => (FnDsa1024Pub, "fn-dsa-1024-pub"), + 0x1210 => (Mldsa44Pub, "mldsa-44-pub"), + 0x1211 => (Mldsa65Pub, "mldsa-65-pub"), + 0x1212 => (Mldsa87Pub, "mldsa-87-pub"), + 0x1213 => (Mceliece348864Pub, "mceliece348864-pub"), + 0x1214 => (Mceliece460896Pub, "mceliece460896-pub"), + 0x1215 => (Rsa2048Pub, "rsa-2048-pub"), + 0x1216 => (Rsa3072Pub, "rsa-3072-pub"), + 0x1217 => (Rsa4096Pub, "rsa-4096-pub"), + 0x1218 => (Mayo1Pub, "mayo-1-pub"), + 0x1219 => (Mayo2Pub, "mayo-2-pub"), + 0x121a => (Sntrup857Pub, "sntrup857-pub"), + 0x121b => (Sntrup953Pub, "sntrup953-pub"), + 0x121c => (Sntrup1013Pub, "sntrup1013-pub"), + 0x121d => (Sntrup1277Pub, "sntrup1277-pub"), 0x121f => (Sntrup761Pub, "sntrup761-pub"), - 0x1220 => (Mceliece348864Pub, "mceliece348864-pub"), - 0x1221 => (Mceliece460896Pub, "mceliece460896-pub"), - 0x1222 => (Rsa2048Pub, "rsa-2048-pub"), - 0x1223 => (Rsa3072Pub, "rsa-3072-pub"), - 0x1224 => (Rsa4096Pub, "rsa-4096-pub"), - 0x1225 => (Mayo1Pub, "mayo-1-pub"), - 0x1226 => (Mayo2Pub, "mayo-2-pub"), - 0x123d => (Mayo3Pub, "mayo-3-pub"), - 0x123e => (Mayo5Pub, "mayo-5-pub"), - 0x1227 => (Sntrup857Pub, "sntrup857-pub"), - 0x1228 => (Sntrup953Pub, "sntrup953-pub"), - 0x1229 => (Sntrup1013Pub, "sntrup1013-pub"), - 0x122a => (Sntrup1277Pub, "sntrup1277-pub"), + 0x1220 => (SlhdsaSha2128SPub, "slhdsa-sha2-128s-pub"), + 0x1221 => (SlhdsaShake128SPub, "slhdsa-shake-128s-pub"), + 0x1222 => (SlhdsaSha2128FPub, "slhdsa-sha2-128f-pub"), + 0x1223 => (SlhdsaShake128FPub, "slhdsa-shake-128f-pub"), + 0x1224 => (SlhdsaSha2192SPub, "slhdsa-sha2-192s-pub"), + 0x1225 => (SlhdsaShake192SPub, "slhdsa-shake-192s-pub"), + 0x1226 => (SlhdsaSha2192FPub, "slhdsa-sha2-192f-pub"), + 0x1227 => (SlhdsaShake192FPub, "slhdsa-shake-192f-pub"), + 0x1228 => (SlhdsaSha2256SPub, "slhdsa-sha2-256s-pub"), + 0x1229 => (SlhdsaShake256SPub, "slhdsa-shake-256s-pub"), + 0x122a => (SlhdsaSha2256FPub, "slhdsa-sha2-256f-pub"), + 0x122b => (SlhdsaShake256FPub, "slhdsa-shake-256f-pub"), 0x1230 => (X25519Sntrup761Pub, "x25519-sntrup761-pub"), - 0x1243 => (X25519Frodokem640AesPub, "x25519-frodokem640aes-pub"), - 0x1244 => (X25519Frodokem640ShakePub, "x25519-frodokem640shake-pub"), - 0x1245 => (X25519Mceliece348864Pub, "x25519-mceliece348864-pub"), - 0x1246 => (Bls12381G1Mldsa65Pub, "bls12381-g1-mldsa65-pub"), - 0x1247 => (Bls12381G1Fndsa512Pub, "bls12381-g1-fndsa512-pub"), - 0x1248 => (Bls12381G1Mayo1Pub, "bls12381-g1-mayo1-pub"), - 0x1249 => (Bls12381G1Mayo2Pub, "bls12381-g1-mayo2-pub"), 0x1231 => (X25519Mlkem768Pub, "x25519-mlkem768-pub"), 0x1232 => (Ed25519Mayo2Pub, "ed25519-mayo2-pub"), - 0x123f => (Ed25519Mldsa65Pub, "ed25519-mldsa65-pub"), - 0x1241 => (Ed25519Fndsa512Pub, "ed25519-fndsa512-pub"), 0x1234 => (FrodoKem640AesPub, "frodo-kem-640-aes-pub"), 0x1235 => (FrodoKem976AesPub, "frodo-kem-976-aes-pub"), 0x1236 => (FrodoKem1344AesPub, "frodo-kem-1344-aes-pub"), 0x1237 => (FrodoKem640ShakePub, "frodo-kem-640-shake-pub"), 0x1238 => (FrodoKem976ShakePub, "frodo-kem-976-shake-pub"), - 0x123c => (FrodoKem1344ShakePub, "frodo-kem-1344-shake-pub"), - 0x1212 => (MlDsa65Pub, "ml-dsa-65-pub"), - 0x1213 => (MlDsa87Pub, "ml-dsa-87-pub"), - 0x1210 => (FnDsa512Pub, "fn-dsa-512-pub"), - 0x1211 => (FnDsa1024Pub, "fn-dsa-1024-pub"), 0x1239 => (Multisig, "multisig"), 0x123a => (Multikey, "multikey"), 0x123b => (Nonce, "nonce"), + 0x123c => (FrodoKem1344ShakePub, "frodo-kem-1344-shake-pub"), + 0x123d => (Mayo3Pub, "mayo-3-pub"), + 0x123e => (Mayo5Pub, "mayo-5-pub"), + 0x123f => (Ed25519Mldsa65Pub, "ed25519-mldsa65-pub"), + 0x1241 => (Ed25519Fndsa512Pub, "ed25519-fndsa512-pub"), + 0x1243 => (X25519Frodokem640AesPub, "x25519-frodokem640aes-pub"), + 0x1244 => (X25519Frodokem640ShakePub, "x25519-frodokem640shake-pub"), + 0x1245 => (X25519Mceliece348864Pub, "x25519-mceliece348864-pub"), + 0x1246 => (Bls12381G1Mldsa65Pub, "bls12381-g1-mldsa65-pub"), + 0x1247 => (Bls12381G1Fndsa512Pub, "bls12381-g1-fndsa512-pub"), + 0x1248 => (Bls12381G1Mayo1Pub, "bls12381-g1-mayo1-pub"), + 0x1249 => (Bls12381G1Mayo2Pub, "bls12381-g1-mayo2-pub"), 0x1300 => (Ed25519Priv, "ed25519-priv"), 0x1301 => (Secp256K1Priv, "secp256k1-priv"), 0x1302 => (X25519Priv, "x25519-priv"), 0x1303 => (Sr25519Priv, "sr25519-priv"), + 0x1304 => (FnDsa512Priv, "fn-dsa-512-priv"), 0x1305 => (RsaPriv, "rsa-priv"), 0x1306 => (P256Priv, "p256-priv"), 0x1307 => (P384Priv, "p384-priv"), @@ -246,22 +249,28 @@ build_codec_enum! { 0x1310 => (Sm2Priv, "sm2-priv"), 0x1311 => (Ed448Priv, "ed448-priv"), 0x1312 => (X448Priv, "x448-priv"), + 0x1313 => (Mlkem512Priv, "mlkem-512-priv"), 0x1314 => (Mlkem768Priv, "mlkem-768-priv"), 0x1315 => (Mlkem1024Priv, "mlkem-1024-priv"), 0x1316 => (JwkJcsPriv, "jwk_jcs-priv"), - 0x1317 => (SlhDsaSha2128FPriv, "slh-dsa-sha2-128f-priv"), - 0x131d => (SlhDsaSha2128SPriv, "slh-dsa-sha2-128s-priv"), - 0x131e => (SlhDsaSha2192FPriv, "slh-dsa-sha2-192f-priv"), - 0x131f => (SlhDsaSha2192SPriv, "slh-dsa-sha2-192s-priv"), - 0x1320 => (SlhDsaSha2256FPriv, "slh-dsa-sha2-256f-priv"), - 0x1321 => (SlhDsaSha2256SPriv, "slh-dsa-sha2-256s-priv"), - 0x1322 => (SlhDsaShake128FPriv, "slh-dsa-shake128f-priv"), - 0x1323 => (SlhDsaShake128SPriv, "slh-dsa-shake128s-priv"), - 0x1324 => (SlhDsaShake192FPriv, "slh-dsa-shake192f-priv"), - 0x1325 => (SlhDsaShake192SPriv, "slh-dsa-shake192s-priv"), - 0x1326 => (SlhDsaShake256FPriv, "slh-dsa-shake256f-priv"), - 0x1327 => (SlhDsaShake256SPriv, "slh-dsa-shake256s-priv"), - 0x1328 => (Sntrup761Priv, "sntrup761-priv"), + 0x1317 => (Mldsa44Priv, "mldsa-44-priv"), + 0x1318 => (Mldsa65Priv, "mldsa-65-priv"), + 0x1319 => (Mldsa87Priv, "mldsa-87-priv"), + 0x131a => (Mldsa44PrivSeed, "mldsa-44-priv-seed"), + 0x131b => (Mldsa65PrivSeed, "mldsa-65-priv-seed"), + 0x131c => (Mldsa87PrivSeed, "mldsa-87-priv-seed"), + 0x131d => (SlhdsaSha2128SPriv, "slhdsa-sha2-128s-priv"), + 0x131e => (SlhdsaShake128SPriv, "slhdsa-shake-128s-priv"), + 0x131f => (SlhdsaSha2128FPriv, "slhdsa-sha2-128f-priv"), + 0x1320 => (SlhdsaShake128FPriv, "slhdsa-shake-128f-priv"), + 0x1321 => (SlhdsaSha2192SPriv, "slhdsa-sha2-192s-priv"), + 0x1322 => (SlhdsaShake192SPriv, "slhdsa-shake-192s-priv"), + 0x1323 => (SlhdsaSha2192FPriv, "slhdsa-sha2-192f-priv"), + 0x1324 => (SlhdsaShake192FPriv, "slhdsa-shake-192f-priv"), + 0x1325 => (SlhdsaSha2256SPriv, "slhdsa-sha2-256s-priv"), + 0x1326 => (SlhdsaShake256SPriv, "slhdsa-shake-256s-priv"), + 0x1327 => (SlhdsaSha2256FPriv, "slhdsa-sha2-256f-priv"), + 0x1328 => (SlhdsaShake256FPriv, "slhdsa-shake-256f-priv"), 0x1329 => (Mceliece348864Priv, "mceliece348864-priv"), 0x132a => (Mceliece460896Priv, "mceliece460896-priv"), 0x132b => (Rsa2048Priv, "rsa-2048-priv"), @@ -269,34 +278,34 @@ build_codec_enum! { 0x132d => (Rsa4096Priv, "rsa-4096-priv"), 0x132e => (Mayo1Priv, "mayo-1-priv"), 0x132f => (Mayo2Priv, "mayo-2-priv"), - 0x134a => (Mayo3Priv, "mayo-3-priv"), - 0x134b => (Mayo5Priv, "mayo-5-priv"), 0x1330 => (Sntrup857Priv, "sntrup857-priv"), 0x1331 => (Sntrup953Priv, "sntrup953-priv"), 0x1332 => (Sntrup1013Priv, "sntrup1013-priv"), 0x1333 => (Sntrup1277Priv, "sntrup1277-priv"), - 0x1340 => (X25519Sntrup761Priv, "x25519-sntrup761-priv"), - 0x1350 => (X25519Frodokem640AesPriv, "x25519-frodokem640aes-priv"), - 0x1351 => (X25519Frodokem640ShakePriv, "x25519-frodokem640shake-priv"), - 0x1352 => (X25519Mceliece348864Priv, "x25519-mceliece348864-priv"), - 0x1353 => (Bls12381G1Mldsa65Priv, "bls12381-g1-mldsa65-priv"), - 0x1354 => (Bls12381G1Fndsa512Priv, "bls12381-g1-fndsa512-priv"), - 0x1355 => (Bls12381G1Mayo1Priv, "bls12381-g1-mayo1-priv"), - 0x1356 => (Bls12381G1Mayo2Priv, "bls12381-g1-mayo2-priv"), - 0x1341 => (X25519Mlkem768Priv, "x25519-mlkem768-priv"), + 0x1334 => (FnDsa1024Priv, "fn-dsa-1024-priv"), + 0x1335 => (Sntrup761Priv, "sntrup761-priv"), + 0x1336 => (X25519Sntrup761Priv, "x25519-sntrup761-priv"), + 0x1337 => (X25519Mlkem768Priv, "x25519-mlkem768-priv"), + 0x1340 => (Bip340Pub, "bip340-pub"), + 0x1341 => (Bip340Priv, "bip340-priv"), 0x1342 => (Ed25519Mayo2Priv, "ed25519-mayo2-priv"), - 0x134c => (Ed25519Mldsa65Priv, "ed25519-mldsa65-priv"), - 0x134e => (Ed25519Fndsa512Priv, "ed25519-fndsa512-priv"), 0x1344 => (FrodoKem640AesPriv, "frodo-kem-640-aes-priv"), 0x1345 => (FrodoKem976AesPriv, "frodo-kem-976-aes-priv"), 0x1346 => (FrodoKem1344AesPriv, "frodo-kem-1344-aes-priv"), 0x1347 => (FrodoKem640ShakePriv, "frodo-kem-640-shake-priv"), 0x1348 => (FrodoKem976ShakePriv, "frodo-kem-976-shake-priv"), 0x1349 => (FrodoKem1344ShakePriv, "frodo-kem-1344-shake-priv"), - 0x131b => (MlDsa65Priv, "ml-dsa-65-priv"), - 0x131c => (MlDsa87Priv, "ml-dsa-87-priv"), - 0x1319 => (FnDsa512Priv, "fn-dsa-512-priv"), - 0x131a => (FnDsa1024Priv, "fn-dsa-1024-priv"), + 0x134a => (Mayo3Priv, "mayo-3-priv"), + 0x134b => (Mayo5Priv, "mayo-5-priv"), + 0x134c => (Ed25519Mldsa65Priv, "ed25519-mldsa65-priv"), + 0x134e => (Ed25519Fndsa512Priv, "ed25519-fndsa512-priv"), + 0x1350 => (X25519Frodokem640AesPriv, "x25519-frodokem640aes-priv"), + 0x1351 => (X25519Frodokem640ShakePriv, "x25519-frodokem640shake-priv"), + 0x1352 => (X25519Mceliece348864Priv, "x25519-mceliece348864-priv"), + 0x1353 => (Bls12381G1Mldsa65Priv, "bls12381-g1-mldsa65-priv"), + 0x1354 => (Bls12381G1Fndsa512Priv, "bls12381-g1-fndsa512-priv"), + 0x1355 => (Bls12381G1Mayo1Priv, "bls12381-g1-mayo1-priv"), + 0x1356 => (Bls12381G1Mayo2Priv, "bls12381-g1-mayo2-priv"), 0x1a14 => (LamportSha3512Pub, "lamport-sha3-512-pub"), 0x1a15 => (LamportSha3384Pub, "lamport-sha3-384-pub"), 0x1a16 => (LamportSha3256Pub, "lamport-sha3-256-pub"), @@ -312,9 +321,11 @@ build_codec_enum! { 0x1a54 => (LamportSha3512SigShare, "lamport-sha3-512-sig-share"), 0x1a55 => (LamportSha3384SigShare, "lamport-sha3-384-sig-share"), 0x1a56 => (LamportSha3256SigShare, "lamport-sha3-256-sig-share"), - 0x1d01 => (Kangarootwelve, "kangarootwelve"), + 0x1d01 => (Kt128, "kt-128"), + 0x1d02 => (Kt256, "kt-256"), 0x2000 => (AesGcm256, "aes-gcm-256"), 0x2001 => (AesGcm128, "aes-gcm-128"), + 0x2679 => (Ech, "ech"), 0x3f42 => (Silverpine, "silverpine"), 0x534d => (Sm3256, "sm3-256"), 0x7012 => (Sha256A, "sha256a"), @@ -682,10 +693,20 @@ build_codec_enum! { 0xb29910 => (ArweaveNs, "arweave-ns"), 0xb39910 => (SubspaceNs, "subspace-ns"), 0xb49910 => (KumandraNs, "kumandra-ns"), + 0xb59910 => (Massa, "massa"), + 0xb59911 => (MassaMainnet, "massa-mainnet"), + 0xb59912 => (MassaBuildnet, "massa-buildnet"), + 0xb59913 => (MassaDeweb, "massa-deweb"), + 0xb59914 => (MassaGossip, "massa-gossip"), + 0xb59915 => (MassaMns, "massa-mns"), + 0xb59916 => (MassaSc, "massa-sc"), + 0xb59917 => (MassaGossipId, "massa-gossip-id"), + 0xb69910 => (Adnl, "adnl"), 0xd01200 => (Es256, "es256"), 0xd01201 => (Es384, "es384"), 0xd01202 => (Es512, "es512"), 0xd01205 => (Rs256, "rs256"), + 0xd01206 => (Bip340, "bip340"), 0xd01300 => (Es256KMsig, "es256k-msig"), 0xd01301 => (Bls12381G1Msig, "bls12_381-g1-msig"), 0xd01302 => (Bls12381G2Msig, "bls12_381-g2-msig"), @@ -698,27 +719,27 @@ build_codec_enum! { 0xd01309 => (Es384Msig, "es384-msig"), 0xd0130a => (Es521Msig, "es521-msig"), 0xd0130b => (Rs256Msig, "rs256-msig"), - 0xd0130c => (SlhDsaSha2128FMsig, "slh-dsa-sha2-128f-msig"), - 0xd01312 => (SlhDsaSha2128SMsig, "slh-dsa-sha2-128s-msig"), - 0xd01313 => (SlhDsaSha2192FMsig, "slh-dsa-sha2-192f-msig"), - 0xd01314 => (SlhDsaSha2192SMsig, "slh-dsa-sha2-192s-msig"), - 0xd01315 => (SlhDsaSha2256FMsig, "slh-dsa-sha2-256f-msig"), - 0xd01316 => (SlhDsaSha2256SMsig, "slh-dsa-sha2-256s-msig"), - 0xd01317 => (SlhDsaShake128FMsig, "slh-dsa-shake128f-msig"), - 0xd01318 => (SlhDsaShake128SMsig, "slh-dsa-shake128s-msig"), - 0xd01319 => (SlhDsaShake192FMsig, "slh-dsa-shake192f-msig"), - 0xd0131a => (SlhDsaShake192SMsig, "slh-dsa-shake192s-msig"), - 0xd0131b => (SlhDsaShake256FMsig, "slh-dsa-shake256f-msig"), - 0xd0131c => (SlhDsaShake256SMsig, "slh-dsa-shake256s-msig"), - 0xd01310 => (MlDsa65Msig, "ml-dsa-65-msig"), - 0xd01311 => (MlDsa87Msig, "ml-dsa-87-msig"), + 0xd0130c => (SlhdsaSha2128FMsig, "slhdsa-sha2-128f-msig"), 0xd0130e => (FnDsa512Msig, "fn-dsa-512-msig"), 0xd0130f => (FnDsa1024Msig, "fn-dsa-1024-msig"), + 0xd01310 => (Mldsa65Msig, "mldsa-65-msig"), + 0xd01311 => (Mldsa87Msig, "mldsa-87-msig"), + 0xd01312 => (SlhdsaSha2128SMsig, "slhdsa-sha2-128s-msig"), + 0xd01313 => (SlhdsaSha2192FMsig, "slhdsa-sha2-192f-msig"), + 0xd01314 => (SlhdsaSha2192SMsig, "slhdsa-sha2-192s-msig"), + 0xd01315 => (SlhdsaSha2256FMsig, "slhdsa-sha2-256f-msig"), + 0xd01316 => (SlhdsaSha2256SMsig, "slhdsa-sha2-256s-msig"), + 0xd01317 => (SlhdsaShake128FMsig, "slhdsa-shake-128f-msig"), + 0xd01318 => (SlhdsaShake128SMsig, "slhdsa-shake-128s-msig"), + 0xd01319 => (SlhdsaShake192FMsig, "slhdsa-shake-192f-msig"), + 0xd0131a => (SlhdsaShake192SMsig, "slhdsa-shake-192s-msig"), + 0xd0131b => (SlhdsaShake256FMsig, "slhdsa-shake-256f-msig"), + 0xd0131c => (SlhdsaShake256SMsig, "slhdsa-shake-256s-msig"), 0xd0131d => (Mayo1Msig, "mayo-1-msig"), 0xd0131e => (Mayo2Msig, "mayo-2-msig"), + 0xd01320 => (Ed25519Mayo2Msig, "ed25519-mayo2-msig"), 0xd01322 => (Mayo3Msig, "mayo-3-msig"), 0xd01323 => (Mayo5Msig, "mayo-5-msig"), - 0xd01320 => (Ed25519Mayo2Msig, "ed25519-mayo2-msig"), 0xd01324 => (Ed25519Mldsa65Msig, "ed25519-mldsa65-msig"), 0xd01326 => (Ed25519Fndsa512Msig, "ed25519-fndsa512-msig"), 0xd01328 => (Bls12381G1Mldsa65Msig, "bls12381-g1-mldsa65-msig"), diff --git a/table.csv b/table.csv index 7e34956..022837f 100644 --- a/table.csv +++ b/table.csv @@ -1,742 +1,763 @@ name,tag,code,status,description -identity, multihash, 0x00, permanent, raw binary -cidv1, cid, 0x01, permanent, CIDv1 -cidv2, cid, 0x02, draft, CIDv2 -cidv3, cid, 0x03, draft, CIDv3 -ip4, multiaddr, 0x04, permanent, -tcp, multiaddr, 0x06, permanent, -sha1, multihash, 0x11, permanent, -sha2-256, multihash, 0x12, permanent, -sha2-512, multihash, 0x13, permanent, -sha3-512, multihash, 0x14, permanent, -sha3-384, multihash, 0x15, permanent, -sha3-256, multihash, 0x16, permanent, -sha3-224, multihash, 0x17, permanent, -shake-128, multihash, 0x18, draft, -shake-256, multihash, 0x19, draft, -keccak-224, multihash, 0x1a, draft, keccak has variable output length. The number specifies the core length -keccak-256, multihash, 0x1b, draft, -keccak-384, multihash, 0x1c, draft, -keccak-512, multihash, 0x1d, draft, -blake3, multihash, 0x1e, draft, BLAKE3 has a default 32 byte output length. The maximum length is (2^64)-1 bytes. -sha2-384, multihash, 0x20, permanent, aka SHA-384; as specified by FIPS 180-4. -dccp, multiaddr, 0x21, draft, -murmur3-x64-64, hash, 0x22, permanent, The first 64-bits of a murmur3-x64-128 - used for UnixFS directory sharding. -murmur3-32, hash, 0x23, draft, -ip6, multiaddr, 0x29, permanent, -ip6zone, multiaddr, 0x2a, draft, -ipcidr, multiaddr, 0x2b, draft, CIDR mask for IP addresses -path, namespace, 0x2f, permanent, Namespace for string paths. Corresponds to `/` in ASCII. -multicodec, multiformat, 0x30, draft, -multihash, multiformat, 0x31, draft, -multiaddr, multiformat, 0x32, draft, -multibase, multiformat, 0x33, draft, -varsig, multiformat, 0x34, draft, Variable signature (varsig) multiformat -dns, multiaddr, 0x35, permanent, -dns4, multiaddr, 0x36, permanent, -dns6, multiaddr, 0x37, permanent, -dnsaddr, multiaddr, 0x38, permanent, -protobuf, serialization, 0x50, draft, Protocol Buffers -cbor, ipld, 0x51, permanent, CBOR -raw, ipld, 0x55, permanent, raw binary -dbl-sha2-256, multihash, 0x56, draft, -rlp, serialization, 0x60, draft, recursive length prefix -bencode, serialization, 0x63, draft, bencode -dag-pb, ipld, 0x70, permanent, MerkleDAG protobuf -dag-cbor, ipld, 0x71, permanent, MerkleDAG cbor -libp2p-key, ipld, 0x72, permanent, Libp2p Public Key -git-raw, ipld, 0x78, permanent, Raw Git object -torrent-info, ipld, 0x7b, draft, Torrent file info field (bencoded) -torrent-file, ipld, 0x7c, draft, Torrent file (bencoded) -blake3-hashseq, ipld, 0x80, draft, BLAKE3 hash sequence - per Iroh collections spec -leofcoin-block, ipld, 0x81, draft, Leofcoin Block -leofcoin-tx, ipld, 0x82, draft, Leofcoin Transaction -leofcoin-pr, ipld, 0x83, draft, Leofcoin Peer Reputation -sctp, multiaddr, 0x84, draft, -dag-jose, ipld, 0x85, draft, MerkleDAG JOSE -dag-cose, ipld, 0x86, draft, MerkleDAG COSE -lbry, namespace, 0x8c, draft, LBRY Address -eth-block, ipld, 0x90, permanent, Ethereum Header (RLP) -eth-block-list, ipld, 0x91, permanent, Ethereum Header List (RLP) -eth-tx-trie, ipld, 0x92, permanent, Ethereum Transaction Trie (Eth-Trie) -eth-tx, ipld, 0x93, permanent, Ethereum Transaction (MarshalBinary) -eth-tx-receipt-trie, ipld, 0x94, permanent, Ethereum Transaction Receipt Trie (Eth-Trie) -eth-tx-receipt, ipld, 0x95, permanent, Ethereum Transaction Receipt (MarshalBinary) -eth-state-trie, ipld, 0x96, permanent, Ethereum State Trie (Eth-Secure-Trie) -eth-account-snapshot, ipld, 0x97, permanent, Ethereum Account Snapshot (RLP) -eth-storage-trie, ipld, 0x98, permanent, Ethereum Contract Storage Trie (Eth-Secure-Trie) -eth-receipt-log-trie, ipld, 0x99, draft, Ethereum Transaction Receipt Log Trie (Eth-Trie) -eth-receipt-log, ipld, 0x9a, draft, Ethereum Transaction Receipt Log (RLP) -aes-128, key, 0xa0, draft, 128-bit AES symmetric key -aes-192, key, 0xa1, draft, 192-bit AES symmetric key -aes-256, key, 0xa2, draft, 256-bit AES symmetric key -chacha-128, key, 0xa3, draft, 128-bit ChaCha symmetric key -chacha-256, key, 0xa4, draft, 256-bit ChaCha symmetric key -bitcoin-block, ipld, 0xb0, permanent, Bitcoin Block -bitcoin-tx, ipld, 0xb1, permanent, Bitcoin Tx -bitcoin-witness-commitment, ipld, 0xb2, permanent, Bitcoin Witness Commitment -zcash-block, ipld, 0xc0, permanent, Zcash Block -zcash-tx, ipld, 0xc1, permanent, Zcash Tx -caip-50, multiformat, 0xca, draft, CAIP-50 multi-chain account ID -streamid, namespace, 0xce, draft, Ceramic Stream ID -stellar-block, ipld, 0xd0, draft, Stellar Block -stellar-tx, ipld, 0xd1, draft, Stellar Tx -md4, multihash, 0xd4, draft, -md5, multihash, 0xd5, draft, -decred-block, ipld, 0xe0, draft, Decred Block -decred-tx, ipld, 0xe1, draft, Decred Tx -ipld, namespace, 0xe2, draft, IPLD path -ipfs, namespace, 0xe3, draft, IPFS path -swarm, namespace, 0xe4, draft, Swarm path -ipns, namespace, 0xe5, draft, IPNS path -zeronet, namespace, 0xe6, draft, ZeroNet site address -secp256k1-pub, key, 0xe7, draft, Secp256k1 public key (compressed) -dnslink, namespace, 0xe8, permanent, DNSLink path -bls12_381-g1-pub, key, 0xea, draft, BLS12-381 public key in the G1 field -bls12_381-g2-pub, key, 0xeb, draft, BLS12-381 public key in the G2 field -x25519-pub, key, 0xec, draft, Curve25519 public key -ed25519-pub, key, 0xed, draft, Ed25519 public key -bls12_381-g1g2-pub, key, 0xee, draft, BLS12-381 concatenated public keys in both the G1 and G2 fields -sr25519-pub, key, 0xef, draft, Sr25519 public key -dash-block, ipld, 0xf0, draft, Dash Block -dash-tx, ipld, 0xf1, draft, Dash Tx -swarm-manifest, ipld, 0xfa, draft, Swarm Manifest -swarm-feed, ipld, 0xfb, draft, Swarm Feed -beeson, ipld, 0xfc, draft, Swarm BeeSon -udp, multiaddr, 0x0111, draft, -p2p-webrtc-star, multiaddr, 0x0113, deprecated, Use webrtc or webrtc-direct instead -p2p-webrtc-direct, multiaddr, 0x0114, deprecated, Use webrtc or webrtc-direct instead -p2p-stardust, multiaddr, 0x0115, deprecated, -webrtc-direct, multiaddr, 0x0118, draft, ICE-lite webrtc transport with SDP munging during connection establishment and without use of a STUN server -webrtc, multiaddr, 0x0119, draft, webrtc transport where connection establishment is according to w3c spec -p2p-circuit, multiaddr, 0x0122, permanent, -dag-json, ipld, 0x0129, permanent, MerkleDAG json -udt, multiaddr, 0x012d, draft, -utp, multiaddr, 0x012e, draft, -crc32, hash, 0x0132, draft, CRC-32 non-cryptographic hash algorithm (IEEE 802.3) -crc64-ecma, hash, 0x0164, draft, CRC-64 non-cryptographic hash algorithm (ECMA-182 - Annex B) -crc64-nvme, hash, 0x0165, draft, CRC-64 checksum based on the NVME polynomial as specified in the NVM Express® NVM Command Set Specification -unix, multiaddr, 0x0190, permanent, -thread, multiaddr, 0x0196, draft, Textile Thread -p2p, multiaddr, 0x01a5, permanent, libp2p -https, multiaddr, 0x01bb, draft, -onion, multiaddr, 0x01bc, draft, -onion3, multiaddr, 0x01bd, draft, -garlic64, multiaddr, 0x01be, draft, I2P base64 (raw public key) -garlic32, multiaddr, 0x01bf, draft, I2P base32 (hashed public key or encoded public key/checksum+optional secret) -tls, multiaddr, 0x01c0, draft, -sni, multiaddr, 0x01c1, draft, Server Name Indication RFC 6066 § 3 -noise, multiaddr, 0x01c6, draft, -shs, multiaddr, 0x01c8, draft, Secure Scuttlebutt - Secret Handshake Stream -quic, multiaddr, 0x01cc, permanent, -quic-v1, multiaddr, 0x01cd, permanent, -webtransport, multiaddr, 0x01d1, draft, -certhash, multiaddr, 0x01d2, draft, TLS certificate's fingerprint as a multihash -ws, multiaddr, 0x01dd, permanent, -wss, multiaddr, 0x01de, permanent, -p2p-websocket-star, multiaddr, 0x01df, permanent, -http, multiaddr, 0x01e0, draft, -http-path, multiaddr, 0x01e1, draft, Percent-encoded path to an HTTP resource -swhid-1-snp, ipld, 0x01f0, draft, SoftWare Heritage persistent IDentifier version 1 snapshot -json, ipld, 0x0200, permanent, JSON (UTF-8-encoded) -messagepack, serialization, 0x0201, draft, MessagePack -car, serialization, 0x0202, draft, Content Addressable aRchive (CAR) -x509-certificate, serialization, 0x0210, draft, DER-encoded X.509 (PKIX) certificate per RFC 5280; single certificate only (no chain); raw DER bytes (not PEM) -ipns-record, serialization, 0x0300, permanent, Signed IPNS Record -libp2p-peer-record, libp2p, 0x0301, permanent, libp2p peer record type -libp2p-relay-rsvp, libp2p, 0x0302, permanent, libp2p relay reservation voucher -memorytransport, libp2p, 0x0309, permanent, in memory transport for self-dialing and testing; arbitrary -car-index-sorted, serialization, 0x0400, draft, CARv2 IndexSorted index format -car-multihash-index-sorted, serialization, 0x0401, draft, CARv2 MultihashIndexSorted index format -transport-bitswap, transport, 0x0900, draft, Bitswap datatransfer -transport-graphsync-filecoinv1, transport, 0x0910, draft, Filecoin graphsync datatransfer -transport-ipfs-gateway-http, transport, 0x0920, draft, HTTP IPFS Gateway trustless datatransfer -transport-filecoin-piece-http, transport, 0x0930, draft, HTTP piece retrieval from Filecoin storage provider; https://github.com/filecoin-project/FIPs/blob/master/FRCs/frc-0066.md -multidid, multiformat, 0x0d1d, draft, Compact encoding for Decentralized Identifers -fr32-sha256-trunc254-padbintree,multihash, 0x1011, draft, A balanced binary tree hash used in Filecoin Piece Commitments as described in FRC-0069 -sha2-256-trunc254-padded, multihash, 0x1012, permanent, SHA2-256 with the two most significant bits from the last byte zeroed (as via a mask with 0b00111111) - used for proving trees as in Filecoin -sha2-224, multihash, 0x1013, permanent, aka SHA-224; as specified by FIPS 180-4. -sha2-512-224, multihash, 0x1014, permanent, aka SHA-512/224; as specified by FIPS 180-4. -sha2-512-256, multihash, 0x1015, permanent, aka SHA-512/256; as specified by FIPS 180-4. -murmur3-x64-128, hash, 0x1022, draft, -ripemd-128, multihash, 0x1052, draft, -ripemd-160, multihash, 0x1053, draft, -ripemd-256, multihash, 0x1054, draft, -ripemd-320, multihash, 0x1055, draft, -x11, multihash, 0x1100, draft, -p256-pub, key, 0x1200, draft, P-256 public Key (compressed) -p384-pub, key, 0x1201, draft, P-384 public Key (compressed) -p521-pub, key, 0x1202, draft, P-521 public Key (compressed) -ed448-pub, key, 0x1203, draft, Ed448 public Key -x448-pub, key, 0x1204, draft, X448 public Key -rsa-pub, key, 0x1205, draft, RSA public key. DER-encoded ASN.1 type RSAPublicKey according to IETF RFC 8017 (PKCS #1) -sm2-pub, key, 0x1206, draft, SM2 public key (compressed) -vlad, vlad, 0x1207, draft, Verifiable Long-lived ADdress -provenance-log, serialization, 0x1208, draft, Verifiable and permissioned append-only log -provenance-log-entry, serialization, 0x1209, draft, Verifiable and permissioned append-only log entry -provenance-log-script, serialization, 0x120a, draft, Verifiable and permissioned append-only log script -mlkem-768-pub, key, 0x120c, draft, ML-KEM 768 public key; as specified by FIPS 203 -mlkem-1024-pub, key, 0x120d, draft, ML-KEM 1024 public key; as specified by FIPS 203 -slh-dsa-sha2-128f-pub, key, 0x120e, draft, SLH-DSA SHA2-128f public key; FIPS 205 -slh-dsa-sha2-128s-pub, key, 0x1214, draft, SLH-DSA SHA2-128s public key; FIPS 205 -slh-dsa-sha2-192f-pub, key, 0x1215, draft, SLH-DSA SHA2-192f public key; FIPS 205 -slh-dsa-sha2-192s-pub, key, 0x1216, draft, SLH-DSA SHA2-192s public key; FIPS 205 -slh-dsa-sha2-256f-pub, key, 0x1217, draft, SLH-DSA SHA2-256f public key; FIPS 205 -slh-dsa-sha2-256s-pub, key, 0x1218, draft, SLH-DSA SHA2-256s public key; FIPS 205 -slh-dsa-shake128f-pub, key, 0x1219, draft, SLH-DSA SHAKE128f public key; FIPS 205 -slh-dsa-shake128s-pub, key, 0x121a, draft, SLH-DSA SHAKE128s public key; FIPS 205 -slh-dsa-shake192f-pub, key, 0x121b, draft, SLH-DSA SHAKE192f public key; FIPS 205 -slh-dsa-shake192s-pub, key, 0x121c, draft, SLH-DSA SHAKE192s public key; FIPS 205 -slh-dsa-shake256f-pub, key, 0x121d, draft, SLH-DSA SHAKE256f public key; FIPS 205 -slh-dsa-shake256s-pub, key, 0x121e, draft, SLH-DSA SHAKE256s public key; FIPS 205 -sntrup761-pub, key, 0x121f, draft, sntrup761 public key -mceliece348864-pub, key, 0x1220, draft, Classic McEliece 348864 public key -mceliece460896-pub, key, 0x1221, draft, Classic McEliece 460896 public key -rsa-2048-pub, key, 0x1222, draft, RSA 2048-bit public key -rsa-3072-pub, key, 0x1223, draft, RSA 3072-bit public key -rsa-4096-pub, key, 0x1224, draft, RSA 4096-bit public key -mayo-1-pub, key, 0x1225, draft, MAYO level 1 public key -mayo-2-pub, key, 0x1226, draft, MAYO level 2 public key -mayo-3-pub, key, 0x123d, draft, MAYO level 3 public key -mayo-5-pub, key, 0x123e, draft, MAYO level 5 public key -sntrup857-pub, key, 0x1227, draft, sntrup857 public key -sntrup953-pub, key, 0x1228, draft, sntrup953 public key -sntrup1013-pub, key, 0x1229, draft, sntrup1013 public key -sntrup1277-pub, key, 0x122a, draft, sntrup1277 public key -x25519-sntrup761-pub, key, 0x1230, draft, X25519-sntrup761 hybrid KEM public key -x25519-frodokem640aes-pub, key, 0x1243, draft, X25519-FrodoKEM-640-AES hybrid KEM public key -x25519-frodokem640shake-pub, key, 0x1244, draft, X25519-FrodoKEM-640-SHAKE hybrid KEM public key -x25519-mceliece348864-pub, key, 0x1245, draft, X25519-Classic-McEliece-348864 hybrid KEM public key -bls12381-g1-mldsa65-pub, key, 0x1246, draft, BLS12-381-G1-ML-DSA-65 hybrid signing public key -bls12381-g1-fndsa512-pub, key, 0x1247, draft, BLS12-381-G1-FN-DSA-512 hybrid signing public key -bls12381-g1-mayo1-pub, key, 0x1248, draft, BLS12-381-G1-MAYO-1 hybrid signing public key -bls12381-g1-mayo2-pub, key, 0x1249, draft, BLS12-381-G1-MAYO-2 hybrid signing public key -x25519-mlkem768-pub, key, 0x1231, draft, X25519-ML-KEM-768 hybrid KEM public key -ed25519-mayo2-pub, key, 0x1232, draft, Ed25519-MAYO2 hybrid signing public key -ed25519-mldsa65-pub, key, 0x123f, draft, Ed25519-ML-DSA-65 hybrid signing public key -ed25519-fndsa512-pub, key, 0x1241, draft, Ed25519-FN-DSA-512 hybrid signing public key -frodo-kem-640-aes-pub, key, 0x1234, draft, FrodoKEM-640-AES public key -frodo-kem-976-aes-pub, key, 0x1235, draft, FrodoKEM-976-AES public key -frodo-kem-1344-aes-pub, key, 0x1236, draft, FrodoKEM-1344-AES public key -frodo-kem-640-shake-pub, key, 0x1237, draft, FrodoKEM-640-SHAKE public key -frodo-kem-976-shake-pub, key, 0x1238, draft, FrodoKEM-976-SHAKE public key -frodo-kem-1344-shake-pub, key, 0x123c, draft, FrodoKEM-1344-SHAKE public key -ml-dsa-65-pub, key, 0x1212, draft, ML-DSA (Dilithium) 65 public key; as specified by FIPS 204 -ml-dsa-87-pub, key, 0x1213, draft, ML-DSA (Dilithium) 87 public key; as specified by FIPS 204 -fn-dsa-512-pub, key, 0x1210, draft, FN-DSA (Falcon) 512 public key; as specified by FIPS 206 (draft) -fn-dsa-1024-pub, key, 0x1211, draft, FN-DSA (Falcon) 1024 public key; as specified by FIPS 206 (draft) -multisig, multiformat, 0x1239, draft, Digital signature multiformat -multikey, multiformat, 0x123a, draft, Encryption key multiformat -nonce, nonce, 0x123b, draft, Nonce random value -ed25519-priv, key, 0x1300, draft, Ed25519 private key -secp256k1-priv, key, 0x1301, draft, Secp256k1 private key -x25519-priv, key, 0x1302, draft, Curve25519 private key -sr25519-priv, key, 0x1303, draft, Sr25519 private key -rsa-priv, key, 0x1305, draft, RSA private key -p256-priv, key, 0x1306, draft, P-256 private key -p384-priv, key, 0x1307, draft, P-384 private key -p521-priv, key, 0x1308, draft, P-521 private key -bls12_381-g1-priv, key, 0x1309, draft, BLS12-381 G1 private key -bls12_381-g2-priv, key, 0x130a, draft, BLS12-381 G2 private key -bls12_381-g1g2-priv, key, 0x130b, draft, BLS12-381 G1 and G2 private key -bls12_381-g1-pub-share, key, 0x130c, draft, BLS12-381 G1 public key share -bls12_381-g2-pub-share, key, 0x130d, draft, BLS12-381 G2 public key share -bls12_381-g1-priv-share, key, 0x130e, draft, BLS12-381 G1 private key share -bls12_381-g2-priv-share, key, 0x130f, draft, BLS12-381 G2 private key share -sm2-priv, key, 0x1310, draft, SM2 private key -ed448-priv, key, 0x1311, draft, Ed448 private key -x448-priv, key, 0x1312, draft, X448 private key -mlkem-768-priv, key, 0x1314, draft, ML-KEM 768 public key; as specified by FIPS 203 -mlkem-1024-priv, key, 0x1315, draft, ML-KEM 1024 public key; as specified by FIPS 203 -jwk_jcs-priv, key, 0x1316, draft, JSON object containing only the required members of a JWK (RFC 7518 and RFC 7517) representing the private key. Serialisation based on JCS (RFC 8785) -slh-dsa-sha2-128f-priv, key, 0x1317, draft, SLH-DSA SHA2-128f private key; FIPS 205 -slh-dsa-sha2-128s-priv, key, 0x131d, draft, SLH-DSA SHA2-128s private key; FIPS 205 -slh-dsa-sha2-192f-priv, key, 0x131e, draft, SLH-DSA SHA2-192f private key; FIPS 205 -slh-dsa-sha2-192s-priv, key, 0x131f, draft, SLH-DSA SHA2-192s private key; FIPS 205 -slh-dsa-sha2-256f-priv, key, 0x1320, draft, SLH-DSA SHA2-256f private key; FIPS 205 -slh-dsa-sha2-256s-priv, key, 0x1321, draft, SLH-DSA SHA2-256s private key; FIPS 205 -slh-dsa-shake128f-priv, key, 0x1322, draft, SLH-DSA SHAKE128f private key; FIPS 205 -slh-dsa-shake128s-priv, key, 0x1323, draft, SLH-DSA SHAKE128s private key; FIPS 205 -slh-dsa-shake192f-priv, key, 0x1324, draft, SLH-DSA SHAKE192f private key; FIPS 205 -slh-dsa-shake192s-priv, key, 0x1325, draft, SLH-DSA SHAKE192s private key; FIPS 205 -slh-dsa-shake256f-priv, key, 0x1326, draft, SLH-DSA SHAKE256f private key; FIPS 205 -slh-dsa-shake256s-priv, key, 0x1327, draft, SLH-DSA SHAKE256s private key; FIPS 205 -sntrup761-priv, key, 0x1328, draft, sntrup761 private key -mceliece348864-priv, key, 0x1329, draft, Classic McEliece 348864 private key -mceliece460896-priv, key, 0x132a, draft, Classic McEliece 460896 private key -rsa-2048-priv, key, 0x132b, draft, RSA 2048-bit private key -rsa-3072-priv, key, 0x132c, draft, RSA 3072-bit private key -rsa-4096-priv, key, 0x132d, draft, RSA 4096-bit private key -mayo-1-priv, key, 0x132e, draft, MAYO level 1 private key -mayo-2-priv, key, 0x132f, draft, MAYO level 2 private key -mayo-3-priv, key, 0x134a, draft, MAYO level 3 private key -mayo-5-priv, key, 0x134b, draft, MAYO level 5 private key -sntrup857-priv, key, 0x1330, draft, sntrup857 private key -sntrup953-priv, key, 0x1331, draft, sntrup953 private key -sntrup1013-priv, key, 0x1332, draft, sntrup1013 private key -sntrup1277-priv, key, 0x1333, draft, sntrup1277 private key -x25519-sntrup761-priv, key, 0x1340, draft, X25519-sntrup761 hybrid KEM private key -x25519-frodokem640aes-priv, key, 0x1350, draft, X25519-FrodoKEM-640-AES hybrid KEM private key -x25519-frodokem640shake-priv, key, 0x1351, draft, X25519-FrodoKEM-640-SHAKE hybrid KEM private key -x25519-mceliece348864-priv, key, 0x1352, draft, X25519-Classic-McEliece-348864 hybrid KEM private key -bls12381-g1-mldsa65-priv, key, 0x1353, draft, BLS12-381-G1-ML-DSA-65 hybrid signing private key -bls12381-g1-fndsa512-priv, key, 0x1354, draft, BLS12-381-G1-FN-DSA-512 hybrid signing private key -bls12381-g1-mayo1-priv, key, 0x1355, draft, BLS12-381-G1-MAYO-1 hybrid signing private key -bls12381-g1-mayo2-priv, key, 0x1356, draft, BLS12-381-G1-MAYO-2 hybrid signing private key -x25519-mlkem768-priv, key, 0x1341, draft, X25519-ML-KEM-768 hybrid KEM private key -ed25519-mayo2-priv, key, 0x1342, draft, Ed25519-MAYO2 hybrid signing private key -ed25519-mldsa65-priv, key, 0x134c, draft, Ed25519-ML-DSA-65 hybrid signing private key -ed25519-fndsa512-priv, key, 0x134e, draft, Ed25519-FN-DSA-512 hybrid signing private key -frodo-kem-640-aes-priv, key, 0x1344, draft, FrodoKEM-640-AES private key -frodo-kem-976-aes-priv, key, 0x1345, draft, FrodoKEM-976-AES private key -frodo-kem-1344-aes-priv, key, 0x1346, draft, FrodoKEM-1344-AES private key -frodo-kem-640-shake-priv, key, 0x1347, draft, FrodoKEM-640-SHAKE private key -frodo-kem-976-shake-priv, key, 0x1348, draft, FrodoKEM-976-SHAKE private key -frodo-kem-1344-shake-priv, key, 0x1349, draft, FrodoKEM-1344-SHAKE private key -ml-dsa-65-priv, key, 0x131b, draft, ML-DSA (Dilithium) 65 private key; as specified by FIPS 204 -ml-dsa-87-priv, key, 0x131c, draft, ML-DSA (Dilithium) 87 private key; as specified by FIPS 204 -fn-dsa-512-priv, key, 0x1319, draft, FN-DSA (Falcon) 512 private key; as specified by FIPS 206 (draft) -fn-dsa-1024-priv, key, 0x131a, draft, FN-DSA (Falcon) 1024 private key; as specified by FIPS 206 (draft) -lamport-sha3-512-pub, key, 0x1a14, draft, Lamport public key based on SHA3-512 -lamport-sha3-384-pub, key, 0x1a15, draft, Lamport public key based on SHA3-384 -lamport-sha3-256-pub, key, 0x1a16, draft, Lamport public key based on SHA3-256 -lamport-sha3-512-priv, key, 0x1a24, draft, Lamport private key based on SHA3-512 -lamport-sha3-384-priv, key, 0x1a25, draft, Lamport private key based on SHA3-384 -lamport-sha3-256-priv, key, 0x1a26, draft, Lamport private key based on SHA3-256 -lamport-sha3-512-priv-share, key, 0x1a34, draft, Lamport private key share based on SHA3-512 and split with Shamir gf256 -lamport-sha3-384-priv-share, key, 0x1a35, draft, Lamport private key share based on SHA3-384 and split with Shamir gf256 -lamport-sha3-256-priv-share, key, 0x1a36, draft, Lamport private key share based on SHA3-256 and split with Shamir gf256 -lamport-sha3-512-sig, multisig, 0x1a44, draft, Lamport signature based on SHA3-512 -lamport-sha3-384-sig, multisig, 0x1a45, draft, Lamport signature based on SHA3-384 -lamport-sha3-256-sig, multisig, 0x1a46, draft, Lamport signature based on SHA3-256 -lamport-sha3-512-sig-share, multisig, 0x1a54, draft, Lamport signature share based on SHA3-512 and split with Shamir gf256 -lamport-sha3-384-sig-share, multisig, 0x1a55, draft, Lamport signature share based on SHA3-384 and split with Shamir gf256 -lamport-sha3-256-sig-share, multisig, 0x1a56, draft, Lamport signature share based on SHA3-256 and split with Shamir gf256 -kangarootwelve, multihash, 0x1d01, draft, KangarooTwelve is an extendable-output hash function based on Keccak-p -aes-gcm-256, encryption, 0x2000, draft, AES Galois/Counter Mode with 256-bit key and 12-byte IV -aes-gcm-128, encryption, 0x2001, draft, AES Galois/Counter Mode with 128-bit key and 12-byte IV -silverpine, multiaddr, 0x3f42, draft, Experimental QUIC over yggdrasil and ironwood routing protocol -sm3-256, multihash, 0x534d, draft, -sha256a, hash, 0x7012, draft, The sum of multiple sha2-256 hashes; as specified by Ceramic CIP-124. -chacha20-poly1305, multikey, 0xa000, draft, ChaCha20_Poly1305 encryption scheme -xchacha20-poly1305, encryption, 0xa001, draft, XChaCha20-Poly1305 extended nonce AEAD -blake2b-8, multihash, 0xb201, draft, Blake2b consists of 64 output lengths that give different hashes -blake2b-16, multihash, 0xb202, draft, -blake2b-24, multihash, 0xb203, draft, -blake2b-32, multihash, 0xb204, draft, -blake2b-40, multihash, 0xb205, draft, -blake2b-48, multihash, 0xb206, draft, -blake2b-56, multihash, 0xb207, draft, -blake2b-64, multihash, 0xb208, draft, -blake2b-72, multihash, 0xb209, draft, -blake2b-80, multihash, 0xb20a, draft, -blake2b-88, multihash, 0xb20b, draft, -blake2b-96, multihash, 0xb20c, draft, -blake2b-104, multihash, 0xb20d, draft, -blake2b-112, multihash, 0xb20e, draft, -blake2b-120, multihash, 0xb20f, draft, -blake2b-128, multihash, 0xb210, draft, -blake2b-136, multihash, 0xb211, draft, -blake2b-144, multihash, 0xb212, draft, -blake2b-152, multihash, 0xb213, draft, -blake2b-160, multihash, 0xb214, draft, -blake2b-168, multihash, 0xb215, draft, -blake2b-176, multihash, 0xb216, draft, -blake2b-184, multihash, 0xb217, draft, -blake2b-192, multihash, 0xb218, draft, -blake2b-200, multihash, 0xb219, draft, -blake2b-208, multihash, 0xb21a, draft, -blake2b-216, multihash, 0xb21b, draft, -blake2b-224, multihash, 0xb21c, draft, -blake2b-232, multihash, 0xb21d, draft, -blake2b-240, multihash, 0xb21e, draft, -blake2b-248, multihash, 0xb21f, draft, -blake2b-256, multihash, 0xb220, permanent, -blake2b-264, multihash, 0xb221, draft, -blake2b-272, multihash, 0xb222, draft, -blake2b-280, multihash, 0xb223, draft, -blake2b-288, multihash, 0xb224, draft, -blake2b-296, multihash, 0xb225, draft, -blake2b-304, multihash, 0xb226, draft, -blake2b-312, multihash, 0xb227, draft, -blake2b-320, multihash, 0xb228, draft, -blake2b-328, multihash, 0xb229, draft, -blake2b-336, multihash, 0xb22a, draft, -blake2b-344, multihash, 0xb22b, draft, -blake2b-352, multihash, 0xb22c, draft, -blake2b-360, multihash, 0xb22d, draft, -blake2b-368, multihash, 0xb22e, draft, -blake2b-376, multihash, 0xb22f, draft, -blake2b-384, multihash, 0xb230, draft, -blake2b-392, multihash, 0xb231, draft, -blake2b-400, multihash, 0xb232, draft, -blake2b-408, multihash, 0xb233, draft, -blake2b-416, multihash, 0xb234, draft, -blake2b-424, multihash, 0xb235, draft, -blake2b-432, multihash, 0xb236, draft, -blake2b-440, multihash, 0xb237, draft, -blake2b-448, multihash, 0xb238, draft, -blake2b-456, multihash, 0xb239, draft, -blake2b-464, multihash, 0xb23a, draft, -blake2b-472, multihash, 0xb23b, draft, -blake2b-480, multihash, 0xb23c, draft, -blake2b-488, multihash, 0xb23d, draft, -blake2b-496, multihash, 0xb23e, draft, -blake2b-504, multihash, 0xb23f, draft, -blake2b-512, multihash, 0xb240, draft, -blake2s-8, multihash, 0xb241, draft, Blake2s consists of 32 output lengths that give different hashes -blake2s-16, multihash, 0xb242, draft, -blake2s-24, multihash, 0xb243, draft, -blake2s-32, multihash, 0xb244, draft, -blake2s-40, multihash, 0xb245, draft, -blake2s-48, multihash, 0xb246, draft, -blake2s-56, multihash, 0xb247, draft, -blake2s-64, multihash, 0xb248, draft, -blake2s-72, multihash, 0xb249, draft, -blake2s-80, multihash, 0xb24a, draft, -blake2s-88, multihash, 0xb24b, draft, -blake2s-96, multihash, 0xb24c, draft, -blake2s-104, multihash, 0xb24d, draft, -blake2s-112, multihash, 0xb24e, draft, -blake2s-120, multihash, 0xb24f, draft, -blake2s-128, multihash, 0xb250, draft, -blake2s-136, multihash, 0xb251, draft, -blake2s-144, multihash, 0xb252, draft, -blake2s-152, multihash, 0xb253, draft, -blake2s-160, multihash, 0xb254, draft, -blake2s-168, multihash, 0xb255, draft, -blake2s-176, multihash, 0xb256, draft, -blake2s-184, multihash, 0xb257, draft, -blake2s-192, multihash, 0xb258, draft, -blake2s-200, multihash, 0xb259, draft, -blake2s-208, multihash, 0xb25a, draft, -blake2s-216, multihash, 0xb25b, draft, -blake2s-224, multihash, 0xb25c, draft, -blake2s-232, multihash, 0xb25d, draft, -blake2s-240, multihash, 0xb25e, draft, -blake2s-248, multihash, 0xb25f, draft, -blake2s-256, multihash, 0xb260, draft, -skein256-8, multihash, 0xb301, draft, Skein256 consists of 32 output lengths that give different hashes -skein256-16, multihash, 0xb302, draft, -skein256-24, multihash, 0xb303, draft, -skein256-32, multihash, 0xb304, draft, -skein256-40, multihash, 0xb305, draft, -skein256-48, multihash, 0xb306, draft, -skein256-56, multihash, 0xb307, draft, -skein256-64, multihash, 0xb308, draft, -skein256-72, multihash, 0xb309, draft, -skein256-80, multihash, 0xb30a, draft, -skein256-88, multihash, 0xb30b, draft, -skein256-96, multihash, 0xb30c, draft, -skein256-104, multihash, 0xb30d, draft, -skein256-112, multihash, 0xb30e, draft, -skein256-120, multihash, 0xb30f, draft, -skein256-128, multihash, 0xb310, draft, -skein256-136, multihash, 0xb311, draft, -skein256-144, multihash, 0xb312, draft, -skein256-152, multihash, 0xb313, draft, -skein256-160, multihash, 0xb314, draft, -skein256-168, multihash, 0xb315, draft, -skein256-176, multihash, 0xb316, draft, -skein256-184, multihash, 0xb317, draft, -skein256-192, multihash, 0xb318, draft, -skein256-200, multihash, 0xb319, draft, -skein256-208, multihash, 0xb31a, draft, -skein256-216, multihash, 0xb31b, draft, -skein256-224, multihash, 0xb31c, draft, -skein256-232, multihash, 0xb31d, draft, -skein256-240, multihash, 0xb31e, draft, -skein256-248, multihash, 0xb31f, draft, -skein256-256, multihash, 0xb320, draft, -skein512-8, multihash, 0xb321, draft, Skein512 consists of 64 output lengths that give different hashes -skein512-16, multihash, 0xb322, draft, -skein512-24, multihash, 0xb323, draft, -skein512-32, multihash, 0xb324, draft, -skein512-40, multihash, 0xb325, draft, -skein512-48, multihash, 0xb326, draft, -skein512-56, multihash, 0xb327, draft, -skein512-64, multihash, 0xb328, draft, -skein512-72, multihash, 0xb329, draft, -skein512-80, multihash, 0xb32a, draft, -skein512-88, multihash, 0xb32b, draft, -skein512-96, multihash, 0xb32c, draft, -skein512-104, multihash, 0xb32d, draft, -skein512-112, multihash, 0xb32e, draft, -skein512-120, multihash, 0xb32f, draft, -skein512-128, multihash, 0xb330, draft, -skein512-136, multihash, 0xb331, draft, -skein512-144, multihash, 0xb332, draft, -skein512-152, multihash, 0xb333, draft, -skein512-160, multihash, 0xb334, draft, -skein512-168, multihash, 0xb335, draft, -skein512-176, multihash, 0xb336, draft, -skein512-184, multihash, 0xb337, draft, -skein512-192, multihash, 0xb338, draft, -skein512-200, multihash, 0xb339, draft, -skein512-208, multihash, 0xb33a, draft, -skein512-216, multihash, 0xb33b, draft, -skein512-224, multihash, 0xb33c, draft, -skein512-232, multihash, 0xb33d, draft, -skein512-240, multihash, 0xb33e, draft, -skein512-248, multihash, 0xb33f, draft, -skein512-256, multihash, 0xb340, draft, -skein512-264, multihash, 0xb341, draft, -skein512-272, multihash, 0xb342, draft, -skein512-280, multihash, 0xb343, draft, -skein512-288, multihash, 0xb344, draft, -skein512-296, multihash, 0xb345, draft, -skein512-304, multihash, 0xb346, draft, -skein512-312, multihash, 0xb347, draft, -skein512-320, multihash, 0xb348, draft, -skein512-328, multihash, 0xb349, draft, -skein512-336, multihash, 0xb34a, draft, -skein512-344, multihash, 0xb34b, draft, -skein512-352, multihash, 0xb34c, draft, -skein512-360, multihash, 0xb34d, draft, -skein512-368, multihash, 0xb34e, draft, -skein512-376, multihash, 0xb34f, draft, -skein512-384, multihash, 0xb350, draft, -skein512-392, multihash, 0xb351, draft, -skein512-400, multihash, 0xb352, draft, -skein512-408, multihash, 0xb353, draft, -skein512-416, multihash, 0xb354, draft, -skein512-424, multihash, 0xb355, draft, -skein512-432, multihash, 0xb356, draft, -skein512-440, multihash, 0xb357, draft, -skein512-448, multihash, 0xb358, draft, -skein512-456, multihash, 0xb359, draft, -skein512-464, multihash, 0xb35a, draft, -skein512-472, multihash, 0xb35b, draft, -skein512-480, multihash, 0xb35c, draft, -skein512-488, multihash, 0xb35d, draft, -skein512-496, multihash, 0xb35e, draft, -skein512-504, multihash, 0xb35f, draft, -skein512-512, multihash, 0xb360, draft, -skein1024-8, multihash, 0xb361, draft, Skein1024 consists of 128 output lengths that give different hashes -skein1024-16, multihash, 0xb362, draft, -skein1024-24, multihash, 0xb363, draft, -skein1024-32, multihash, 0xb364, draft, -skein1024-40, multihash, 0xb365, draft, -skein1024-48, multihash, 0xb366, draft, -skein1024-56, multihash, 0xb367, draft, -skein1024-64, multihash, 0xb368, draft, -skein1024-72, multihash, 0xb369, draft, -skein1024-80, multihash, 0xb36a, draft, -skein1024-88, multihash, 0xb36b, draft, -skein1024-96, multihash, 0xb36c, draft, -skein1024-104, multihash, 0xb36d, draft, -skein1024-112, multihash, 0xb36e, draft, -skein1024-120, multihash, 0xb36f, draft, -skein1024-128, multihash, 0xb370, draft, -skein1024-136, multihash, 0xb371, draft, -skein1024-144, multihash, 0xb372, draft, -skein1024-152, multihash, 0xb373, draft, -skein1024-160, multihash, 0xb374, draft, -skein1024-168, multihash, 0xb375, draft, -skein1024-176, multihash, 0xb376, draft, -skein1024-184, multihash, 0xb377, draft, -skein1024-192, multihash, 0xb378, draft, -skein1024-200, multihash, 0xb379, draft, -skein1024-208, multihash, 0xb37a, draft, -skein1024-216, multihash, 0xb37b, draft, -skein1024-224, multihash, 0xb37c, draft, -skein1024-232, multihash, 0xb37d, draft, -skein1024-240, multihash, 0xb37e, draft, -skein1024-248, multihash, 0xb37f, draft, -skein1024-256, multihash, 0xb380, draft, -skein1024-264, multihash, 0xb381, draft, -skein1024-272, multihash, 0xb382, draft, -skein1024-280, multihash, 0xb383, draft, -skein1024-288, multihash, 0xb384, draft, -skein1024-296, multihash, 0xb385, draft, -skein1024-304, multihash, 0xb386, draft, -skein1024-312, multihash, 0xb387, draft, -skein1024-320, multihash, 0xb388, draft, -skein1024-328, multihash, 0xb389, draft, -skein1024-336, multihash, 0xb38a, draft, -skein1024-344, multihash, 0xb38b, draft, -skein1024-352, multihash, 0xb38c, draft, -skein1024-360, multihash, 0xb38d, draft, -skein1024-368, multihash, 0xb38e, draft, -skein1024-376, multihash, 0xb38f, draft, -skein1024-384, multihash, 0xb390, draft, -skein1024-392, multihash, 0xb391, draft, -skein1024-400, multihash, 0xb392, draft, -skein1024-408, multihash, 0xb393, draft, -skein1024-416, multihash, 0xb394, draft, -skein1024-424, multihash, 0xb395, draft, -skein1024-432, multihash, 0xb396, draft, -skein1024-440, multihash, 0xb397, draft, -skein1024-448, multihash, 0xb398, draft, -skein1024-456, multihash, 0xb399, draft, -skein1024-464, multihash, 0xb39a, draft, -skein1024-472, multihash, 0xb39b, draft, -skein1024-480, multihash, 0xb39c, draft, -skein1024-488, multihash, 0xb39d, draft, -skein1024-496, multihash, 0xb39e, draft, -skein1024-504, multihash, 0xb39f, draft, -skein1024-512, multihash, 0xb3a0, draft, -skein1024-520, multihash, 0xb3a1, draft, -skein1024-528, multihash, 0xb3a2, draft, -skein1024-536, multihash, 0xb3a3, draft, -skein1024-544, multihash, 0xb3a4, draft, -skein1024-552, multihash, 0xb3a5, draft, -skein1024-560, multihash, 0xb3a6, draft, -skein1024-568, multihash, 0xb3a7, draft, -skein1024-576, multihash, 0xb3a8, draft, -skein1024-584, multihash, 0xb3a9, draft, -skein1024-592, multihash, 0xb3aa, draft, -skein1024-600, multihash, 0xb3ab, draft, -skein1024-608, multihash, 0xb3ac, draft, -skein1024-616, multihash, 0xb3ad, draft, -skein1024-624, multihash, 0xb3ae, draft, -skein1024-632, multihash, 0xb3af, draft, -skein1024-640, multihash, 0xb3b0, draft, -skein1024-648, multihash, 0xb3b1, draft, -skein1024-656, multihash, 0xb3b2, draft, -skein1024-664, multihash, 0xb3b3, draft, -skein1024-672, multihash, 0xb3b4, draft, -skein1024-680, multihash, 0xb3b5, draft, -skein1024-688, multihash, 0xb3b6, draft, -skein1024-696, multihash, 0xb3b7, draft, -skein1024-704, multihash, 0xb3b8, draft, -skein1024-712, multihash, 0xb3b9, draft, -skein1024-720, multihash, 0xb3ba, draft, -skein1024-728, multihash, 0xb3bb, draft, -skein1024-736, multihash, 0xb3bc, draft, -skein1024-744, multihash, 0xb3bd, draft, -skein1024-752, multihash, 0xb3be, draft, -skein1024-760, multihash, 0xb3bf, draft, -skein1024-768, multihash, 0xb3c0, draft, -skein1024-776, multihash, 0xb3c1, draft, -skein1024-784, multihash, 0xb3c2, draft, -skein1024-792, multihash, 0xb3c3, draft, -skein1024-800, multihash, 0xb3c4, draft, -skein1024-808, multihash, 0xb3c5, draft, -skein1024-816, multihash, 0xb3c6, draft, -skein1024-824, multihash, 0xb3c7, draft, -skein1024-832, multihash, 0xb3c8, draft, -skein1024-840, multihash, 0xb3c9, draft, -skein1024-848, multihash, 0xb3ca, draft, -skein1024-856, multihash, 0xb3cb, draft, -skein1024-864, multihash, 0xb3cc, draft, -skein1024-872, multihash, 0xb3cd, draft, -skein1024-880, multihash, 0xb3ce, draft, -skein1024-888, multihash, 0xb3cf, draft, -skein1024-896, multihash, 0xb3d0, draft, -skein1024-904, multihash, 0xb3d1, draft, -skein1024-912, multihash, 0xb3d2, draft, -skein1024-920, multihash, 0xb3d3, draft, -skein1024-928, multihash, 0xb3d4, draft, -skein1024-936, multihash, 0xb3d5, draft, -skein1024-944, multihash, 0xb3d6, draft, -skein1024-952, multihash, 0xb3d7, draft, -skein1024-960, multihash, 0xb3d8, draft, -skein1024-968, multihash, 0xb3d9, draft, -skein1024-976, multihash, 0xb3da, draft, -skein1024-984, multihash, 0xb3db, draft, -skein1024-992, multihash, 0xb3dc, draft, -skein1024-1000, multihash, 0xb3dd, draft, -skein1024-1008, multihash, 0xb3de, draft, -skein1024-1016, multihash, 0xb3df, draft, -skein1024-1024, multihash, 0xb3e0, draft, -xxh-32, hash, 0xb3e1, draft, Extremely fast non-cryptographic hash algorithm -xxh-64, hash, 0xb3e2, draft, Extremely fast non-cryptographic hash algorithm -xxh3-64, hash, 0xb3e3, draft, Extremely fast non-cryptographic hash algorithm -xxh3-128, hash, 0xb3e4, draft, Extremely fast non-cryptographic hash algorithm -poseidon-bls12_381-a2-fc1, multihash, 0xb401, permanent, Poseidon using BLS12-381 and arity of 2 with Filecoin parameters -poseidon-bls12_381-a2-fc1-sc, multihash, 0xb402, draft, Poseidon using BLS12-381 and arity of 2 with Filecoin parameters - high-security variant -rdfc-1, ipld, 0xb403, draft, The result of canonicalizing an input according to RDFC-1.0 and then expressing its hash value as a multihash value. -ssz, serialization, 0xb501, draft, SimpleSerialize (SSZ) serialization -ssz-sha2-256-bmt, multihash, 0xb502, draft, SSZ Merkle tree root using SHA2-256 as the hashing function and SSZ serialization for the block binary -sha2-256-chunked, multihash, 0xb510, draft, Hash of concatenated SHA2-256 digests of 8*2^n MiB source chunks; n = ceil(log2(source_size/(10^4 * 8MiB))) -json-jcs, ipld, 0xb601, draft, The result of canonicalizing an input according to JCS - JSON Canonicalisation Scheme (RFC 8785) -bittorrent-pieces-root, multihash, 0xb702, draft, BitTorrent v2 pieces root hash. -iscc, softhash, 0xcc01, draft, ISCC (International Standard Content Code) - similarity preserving hash -zeroxcert-imprint-256, zeroxcert, 0xce11, draft, 0xcert Asset Imprint (root hash) -nonstandard-sig, varsig, 0xd000, deprecated, Namespace for all not yet standard signature algorithms -bcrypt-pbkdf, multihash, 0xd00d, draft, Bcrypt-PBKDF key derivation function -hkdf-sha256, kdf, 0xd00e, draft, HKDF-SHA256 key derivation function -es256k, varsig, 0xd0e7, draft, ES256K Signature Algorithm (secp256k1) -bls12_381-g1-sig, varsig, 0xd0ea, draft, G1 signature for BLS12-381 -bls12_381-g2-sig, varsig, 0xd0eb, draft, G2 signature for BLS12-381 -eddsa, varsig, 0xd0ed, draft, Edwards-Curve Digital Signature Algorithm -eip-191, varsig, 0xd191, draft, EIP-191 Ethereum Signed Data Standard -jwk_jcs-pub, key, 0xeb51, draft, JSON object containing only the required members of a JWK (RFC 7518 and RFC 7517) representing the public key. Serialisation based on JCS (RFC 8785) -ed2k, multihash, 0xed20, draft, eDonkey2000 hash. -fil-commitment-unsealed, filecoin, 0xf101, permanent, Filecoin piece or sector data commitment merkle node/root (CommP & CommD) -fil-commitment-sealed, filecoin, 0xf102, permanent, Filecoin sector data commitment merkle node/root - sealed and replicated (CommR) -shelter-contract-manifest, shelter, 0x511e00, draft, Shelter protocol contract manifest -shelter-contract-text, shelter, 0x511e01, draft, Shelter protocol contract text -shelter-contract-data, shelter, 0x511e02, draft, Shelter protocol contract data (contract chain) -shelter-file-manifest, shelter, 0x511e03, draft, Shelter protocol file manifest -shelter-file-chunk, shelter, 0x511e04, draft, Shelter protocol file chunk -plaintextv2, multiaddr, 0x706c61, draft, -holochain-adr-v0, holochain, 0x807124, draft, Holochain v0 address + 8 R-S (63 x Base-32) -holochain-adr-v1, holochain, 0x817124, draft, Holochain v1 address + 8 R-S (63 x Base-32) -holochain-key-v0, holochain, 0x947124, draft, Holochain v0 public key + 8 R-S (63 x Base-32) -holochain-key-v1, holochain, 0x957124, draft, Holochain v1 public key + 8 R-S (63 x Base-32) -holochain-sig-v0, holochain, 0xa27124, draft, Holochain v0 signature + 8 R-S (63 x Base-32) -holochain-sig-v1, holochain, 0xa37124, draft, Holochain v1 signature + 8 R-S (63 x Base-32) -skynet-ns, namespace, 0xb19910, draft, Skynet Namespace -arweave-ns, namespace, 0xb29910, draft, Arweave Namespace -subspace-ns, namespace, 0xb39910, draft, Subspace Network Namespace -kumandra-ns, namespace, 0xb49910, draft, Kumandra Network Namespace -es256, varsig, 0xd01200, draft, ES256 Signature Algorithm -es384, varsig, 0xd01201, draft, ES384 Signature Algorithm -es512, varsig, 0xd01202, draft, ES512 Signature Algorithm -rs256, varsig, 0xd01205, draft, RS256 Signature Algorithm -es256k-msig, multisig, 0xd01300, draft, ES256K (secp256k1) Signature as Multisig -bls12_381-g1-msig, multisig, 0xd01301, draft, G1 signature for BLS-12381-G2 as Multisig -bls12_381-g2-msig, multisig, 0xd01302, draft, G2 signature for BLS-12381-G1 as Multisig -eddsa-msig, multisig, 0xd01303, draft, Edwards-Curve Digital Signature as Multisig -bls12_381-g1-share-msig, multisig, 0xd01304, draft, G1 threshold signature share for BLS-12381-G2 as Multisig -bls12_381-g2-share-msig, multisig, 0xd01305, draft, G2 threshold signature share for BLS-12381-G1 as Multisig -lamport-msig, multisig, 0xd01306, draft, Lamport signature as Multisig -lamport-share-msig, multisig, 0xd01307, draft, Lamport threshold signature share as Multisig -es256-msig, multisig, 0xd01308, draft, ECDSA P-256 Signature as Multisig -es384-msig, multisig, 0xd01309, draft, ECDSA P-384 Signature as Multisig -es521-msig, multisig, 0xd0130a, draft, ECDSA P-521 Signature as Multisig -rs256-msig, multisig, 0xd0130b, draft, RS256 Signature as Multisig -slh-dsa-sha2-128f-msig, multisig, 0xd0130c, draft, SLH-DSA SHA2-128f signature as Multisig; FIPS 205 -slh-dsa-sha2-128s-msig, multisig, 0xd01312, draft, SLH-DSA SHA2-128s signature as Multisig; FIPS 205 -slh-dsa-sha2-192f-msig, multisig, 0xd01313, draft, SLH-DSA SHA2-192f signature as Multisig; FIPS 205 -slh-dsa-sha2-192s-msig, multisig, 0xd01314, draft, SLH-DSA SHA2-192s signature as Multisig; FIPS 205 -slh-dsa-sha2-256f-msig, multisig, 0xd01315, draft, SLH-DSA SHA2-256f signature as Multisig; FIPS 205 -slh-dsa-sha2-256s-msig, multisig, 0xd01316, draft, SLH-DSA SHA2-256s signature as Multisig; FIPS 205 -slh-dsa-shake128f-msig, multisig, 0xd01317, draft, SLH-DSA SHAKE128f signature as Multisig; FIPS 205 -slh-dsa-shake128s-msig, multisig, 0xd01318, draft, SLH-DSA SHAKE128s signature as Multisig; FIPS 205 -slh-dsa-shake192f-msig, multisig, 0xd01319, draft, SLH-DSA SHAKE192f signature as Multisig; FIPS 205 -slh-dsa-shake192s-msig, multisig, 0xd0131a, draft, SLH-DSA SHAKE192s signature as Multisig; FIPS 205 -slh-dsa-shake256f-msig, multisig, 0xd0131b, draft, SLH-DSA SHAKE256f signature as Multisig; FIPS 205 -slh-dsa-shake256s-msig, multisig, 0xd0131c, draft, SLH-DSA SHAKE256s signature as Multisig; FIPS 205 -ml-dsa-65-msig, multisig, 0xd01310, draft, ML-DSA (Dilithium) 65 signature as Multisig; FIPS 204 -ml-dsa-87-msig, multisig, 0xd01311, draft, ML-DSA (Dilithium) 87 signature as Multisig; FIPS 204 -fn-dsa-512-msig, multisig, 0xd0130e, draft, FN-DSA (Falcon) 512 signature as Multisig; FIPS 206 (draft) -fn-dsa-1024-msig, multisig, 0xd0130f, draft, FN-DSA (Falcon) 1024 signature as Multisig; FIPS 206 (draft) -mayo-1-msig, multisig, 0xd0131d, draft, MAYO level 1 signature as Multisig -mayo-2-msig, multisig, 0xd0131e, draft, MAYO level 2 signature as Multisig -mayo-3-msig, multisig, 0xd01322, draft, MAYO level 3 signature as Multisig -mayo-5-msig, multisig, 0xd01323, draft, MAYO level 5 signature as Multisig -ed25519-mayo2-msig, multisig, 0xd01320, draft, Ed25519-MAYO2 hybrid signature as Multisig -ed25519-mldsa65-msig, multisig, 0xd01324, draft, Ed25519-ML-DSA-65 hybrid signature as Multisig -ed25519-fndsa512-msig, multisig, 0xd01326, draft, Ed25519-FN-DSA-512 hybrid signature as Multisig -bls12381-g1-mldsa65-msig, multisig, 0xd01328, draft, BLS12-381-G1-ML-DSA-65 hybrid signature as Multisig -bls12381-g1-fndsa512-msig, multisig, 0xd01329, draft, BLS12-381-G1-FN-DSA-512 hybrid signature as Multisig -bls12381-g1-mayo1-msig, multisig, 0xd0132a, draft, BLS12-381-G1-MAYO-1 hybrid signature as Multisig -bls12381-g1-mayo2-msig, multisig, 0xd0132b, draft, BLS12-381-G1-MAYO-2 hybrid signature as Multisig -bs-message, multiformat, 0xd01400, draft, BetterSign signed+encrypted message multiformat -scion, multiaddr, 0xd02000, draft, SCION Internet architecture -ed25519-thresh-priv-share, key, 0xd03000, draft, Ed25519 FROST DKG threshold private key share -ed25519-thresh-pub-share, key, 0xd03001, draft, Ed25519 FROST DKG threshold public key share -p256-thresh-priv-share, key, 0xd03002, draft, P-256 FROST DKG threshold private key share -p256-thresh-pub-share, key, 0xd03003, draft, P-256 FROST DKG threshold public key share -p384-thresh-priv-share, key, 0xd03004, draft, P-384 FROST DKG threshold private key share -p384-thresh-pub-share, key, 0xd03005, draft, P-384 FROST DKG threshold public key share -secp256k1-thresh-priv-share, key, 0xd03006, draft, secp256k1 FROST DKG threshold private key share -secp256k1-thresh-pub-share, key, 0xd03007, draft, secp256k1 FROST DKG threshold public key share -bls12-381-thresh-priv-share, key, 0xd03008, draft, BLS12-381 FROST DKG threshold private key share -bls12-381-thresh-pub-share, key, 0xd03009, draft, BLS12-381 FROST DKG threshold public key share -ed448-thresh-priv-share, key, 0xd0300a, draft, Ed448 FROST DKG threshold private key share -ed448-thresh-pub-share, key, 0xd0300b, draft, Ed448 FROST DKG threshold public key share -key-split-share, key, 0xd0300c, draft, Generic verifiable private key split share (Feldman VSS or gf256) +identity, multihash, 0x00, permanent, raw binary +cidv1, cid, 0x01, permanent, CIDv1 +cidv2, cid, 0x02, draft, CIDv2 +cidv3, cid, 0x03, draft, CIDv3 +ip4, multiaddr, 0x04, permanent, +tcp, multiaddr, 0x06, permanent, +sha1, multihash, 0x11, permanent, +sha2-256, multihash, 0x12, permanent, +sha2-512, multihash, 0x13, permanent, +sha3-512, multihash, 0x14, permanent, +sha3-384, multihash, 0x15, permanent, +sha3-256, multihash, 0x16, permanent, +sha3-224, multihash, 0x17, permanent, +shake-128, multihash, 0x18, draft, +shake-256, multihash, 0x19, draft, +keccak-224, multihash, 0x1a, draft, keccak has variable output length. The number specifies the core length +keccak-256, multihash, 0x1b, draft, +keccak-384, multihash, 0x1c, draft, +keccak-512, multihash, 0x1d, draft, +blake3, multihash, 0x1e, draft, BLAKE3 has a default 32 byte output length. The maximum length is (2^64)-1 bytes. +sha2-384, multihash, 0x20, permanent, aka SHA-384; as specified by FIPS 180-4. +dccp, multiaddr, 0x21, draft, +murmur3-x64-64, hash, 0x22, permanent, The first 64-bits of a murmur3-x64-128 - used for UnixFS directory sharding. +murmur3-32, hash, 0x23, draft, +ip6, multiaddr, 0x29, permanent, +ip6zone, multiaddr, 0x2a, draft, +ipcidr, multiaddr, 0x2b, draft, CIDR mask for IP addresses +path, namespace, 0x2f, permanent, Namespace for string paths. Corresponds to `/` in ASCII. +multicodec, multiformat, 0x30, draft, +multihash, multiformat, 0x31, draft, +multiaddr, multiformat, 0x32, draft, +multibase, multiformat, 0x33, draft, +varsig, multiformat, 0x34, draft, Variable signature (varsig) multiformat +dns, multiaddr, 0x35, permanent, +dns4, multiaddr, 0x36, permanent, +dns6, multiaddr, 0x37, permanent, +dnsaddr, multiaddr, 0x38, permanent, +protobuf, serialization, 0x50, draft, Protocol Buffers +cbor, ipld, 0x51, permanent, CBOR +raw, ipld, 0x55, permanent, raw binary +dbl-sha2-256, multihash, 0x56, draft, +rlp, serialization, 0x60, draft, recursive length prefix +bencode, serialization, 0x63, draft, bencode +dag-pb, ipld, 0x70, permanent, MerkleDAG protobuf +dag-cbor, ipld, 0x71, permanent, MerkleDAG cbor +libp2p-key, ipld, 0x72, permanent, Libp2p Public Key +git-raw, ipld, 0x78, permanent, Raw Git object +torrent-info, ipld, 0x7b, draft, Torrent file info field (bencoded) +torrent-file, ipld, 0x7c, draft, Torrent file (bencoded) +blake3-hashseq, ipld, 0x80, draft, BLAKE3 hash sequence - per Iroh collections spec +leofcoin-block, ipld, 0x81, draft, Leofcoin Block +leofcoin-tx, ipld, 0x82, draft, Leofcoin Transaction +leofcoin-pr, ipld, 0x83, draft, Leofcoin Peer Reputation +sctp, multiaddr, 0x84, draft, +dag-jose, ipld, 0x85, draft, MerkleDAG JOSE +dag-cose, ipld, 0x86, draft, MerkleDAG COSE +lbry, namespace, 0x8c, draft, LBRY Address +eth-block, ipld, 0x90, permanent, Ethereum Header (RLP) +eth-block-list, ipld, 0x91, permanent, Ethereum Header List (RLP) +eth-tx-trie, ipld, 0x92, permanent, Ethereum Transaction Trie (Eth-Trie) +eth-tx, ipld, 0x93, permanent, Ethereum Transaction (MarshalBinary) +eth-tx-receipt-trie, ipld, 0x94, permanent, Ethereum Transaction Receipt Trie (Eth-Trie) +eth-tx-receipt, ipld, 0x95, permanent, Ethereum Transaction Receipt (MarshalBinary) +eth-state-trie, ipld, 0x96, permanent, Ethereum State Trie (Eth-Secure-Trie) +eth-account-snapshot, ipld, 0x97, permanent, Ethereum Account Snapshot (RLP) +eth-storage-trie, ipld, 0x98, permanent, Ethereum Contract Storage Trie (Eth-Secure-Trie) +eth-receipt-log-trie, ipld, 0x99, draft, Ethereum Transaction Receipt Log Trie (Eth-Trie) +eth-receipt-log, ipld, 0x9a, draft, Ethereum Transaction Receipt Log (RLP) +aes-128, key, 0xa0, draft, 128-bit AES symmetric key +aes-192, key, 0xa1, draft, 192-bit AES symmetric key +aes-256, key, 0xa2, draft, 256-bit AES symmetric key +chacha-128, key, 0xa3, draft, 128-bit ChaCha symmetric key +chacha-256, key, 0xa4, draft, 256-bit ChaCha symmetric key +bitcoin-block, ipld, 0xb0, permanent, Bitcoin Block +bitcoin-tx, ipld, 0xb1, permanent, Bitcoin Tx +bitcoin-witness-commitment, ipld, 0xb2, permanent, Bitcoin Witness Commitment +zcash-block, ipld, 0xc0, permanent, Zcash Block +zcash-tx, ipld, 0xc1, permanent, Zcash Tx +caip-50, multiformat, 0xca, draft, CAIP-50 multi-chain account ID +streamid, namespace, 0xce, draft, Ceramic Stream ID +stellar-block, ipld, 0xd0, draft, Stellar Block +stellar-tx, ipld, 0xd1, draft, Stellar Tx +md4, multihash, 0xd4, draft, +md5, multihash, 0xd5, draft, +decred-block, ipld, 0xe0, draft, Decred Block +decred-tx, ipld, 0xe1, draft, Decred Tx +ipld, namespace, 0xe2, draft, IPLD path +ipfs, namespace, 0xe3, draft, IPFS path +swarm, namespace, 0xe4, draft, Swarm path +ipns, namespace, 0xe5, draft, IPNS path +zeronet, namespace, 0xe6, draft, ZeroNet site address +secp256k1-pub, key, 0xe7, draft, Secp256k1 public key (compressed) +dnslink, namespace, 0xe8, permanent, DNSLink path +bls12_381-g1-pub, key, 0xea, draft, BLS12-381 public key in the G1 field +bls12_381-g2-pub, key, 0xeb, draft, BLS12-381 public key in the G2 field +x25519-pub, key, 0xec, draft, Curve25519 public key +ed25519-pub, key, 0xed, draft, Ed25519 public key +bls12_381-g1g2-pub, key, 0xee, draft, BLS12-381 concatenated public keys in both the G1 and G2 fields +sr25519-pub, key, 0xef, draft, Sr25519 public key +dash-block, ipld, 0xf0, draft, Dash Block +dash-tx, ipld, 0xf1, draft, Dash Tx +swarm-manifest, ipld, 0xfa, draft, Swarm Manifest +swarm-feed, ipld, 0xfb, draft, Swarm Feed +beeson, ipld, 0xfc, draft, Swarm BeeSon +udp, multiaddr, 0x0111, draft, +p2p-webrtc-star, multiaddr, 0x0113, deprecated, Use webrtc or webrtc-direct instead +p2p-webrtc-direct, multiaddr, 0x0114, deprecated, Use webrtc or webrtc-direct instead +p2p-stardust, multiaddr, 0x0115, deprecated, +webrtc-direct, multiaddr, 0x0118, draft, ICE-lite webrtc transport with SDP munging during connection establishment and without use of a STUN server +webrtc, multiaddr, 0x0119, draft, webrtc transport where connection establishment is according to w3c spec +p2p-circuit, multiaddr, 0x0122, permanent, +dag-json, ipld, 0x0129, permanent, MerkleDAG json +udt, multiaddr, 0x012d, draft, +utp, multiaddr, 0x012e, draft, +crc32, hash, 0x0132, draft, CRC-32 non-cryptographic hash algorithm (IEEE 802.3) +crc64-ecma, hash, 0x0164, draft, CRC-64 non-cryptographic hash algorithm (ECMA-182 - Annex B) +crc64-nvme, hash, 0x0165, draft, CRC-64 checksum based on the NVME polynomial as specified in the NVM Express® NVM Command Set Specification +unix, multiaddr, 0x0190, permanent, +thread, multiaddr, 0x0196, draft, Textile Thread +p2p, multiaddr, 0x01a5, permanent, libp2p +https, multiaddr, 0x01bb, draft, +onion, multiaddr, 0x01bc, draft, +onion3, multiaddr, 0x01bd, draft, +garlic64, multiaddr, 0x01be, draft, I2P base64 (raw public key) +garlic32, multiaddr, 0x01bf, draft, I2P base32 (hashed public key or encoded public key/checksum+optional secret) +tls, multiaddr, 0x01c0, draft, +sni, multiaddr, 0x01c1, draft, Server Name Indication RFC 6066 § 3 +noise, multiaddr, 0x01c6, draft, +shs, multiaddr, 0x01c8, draft, Secure Scuttlebutt - Secret Handshake Stream +quic, multiaddr, 0x01cc, permanent, +quic-v1, multiaddr, 0x01cd, permanent, +webtransport, multiaddr, 0x01d1, draft, +certhash, multiaddr, 0x01d2, draft, TLS certificate's fingerprint as a multihash +ws, multiaddr, 0x01dd, permanent, +wss, multiaddr, 0x01de, permanent, +p2p-websocket-star, multiaddr, 0x01df, permanent, +http, multiaddr, 0x01e0, draft, +http-path, multiaddr, 0x01e1, draft, Percent-encoded path to an HTTP resource +swhid-1-snp, ipld, 0x01f0, draft, SoftWare Heritage persistent IDentifier version 1 snapshot +json, ipld, 0x0200, permanent, JSON (UTF-8-encoded) +messagepack, serialization, 0x0201, draft, MessagePack +car, serialization, 0x0202, draft, Content Addressable aRchive (CAR) +x509-certificate, serialization, 0x0210, draft, DER-encoded X.509 (PKIX) certificate per RFC 5280; single certificate only (no chain); raw DER bytes (not PEM) +ipns-record, serialization, 0x0300, permanent, Signed IPNS Record +libp2p-peer-record, libp2p, 0x0301, permanent, libp2p peer record type +libp2p-relay-rsvp, libp2p, 0x0302, permanent, libp2p relay reservation voucher +memorytransport, libp2p, 0x0309, permanent, in memory transport for self-dialing and testing; arbitrary +car-index-sorted, serialization, 0x0400, draft, CARv2 IndexSorted index format +car-multihash-index-sorted, serialization, 0x0401, draft, CARv2 MultihashIndexSorted index format +transport-bitswap, transport, 0x0900, draft, Bitswap datatransfer +transport-graphsync-filecoinv1, transport, 0x0910, draft, Filecoin graphsync datatransfer +transport-ipfs-gateway-http, transport, 0x0920, draft, HTTP IPFS Gateway trustless datatransfer +transport-filecoin-piece-http, transport, 0x0930, draft, HTTP piece retrieval from Filecoin storage provider; https://github.com/filecoin-project/FIPs/blob/master/FRCs/frc-0066.md +multidid, multiformat, 0x0d1d, draft, Compact encoding for Decentralized Identifers +fr32-sha256-trunc254-padbintree, multihash, 0x1011, draft, A balanced binary tree hash used in Filecoin Piece Commitments as described in FRC-0069 +sha2-256-trunc254-padded, multihash, 0x1012, permanent, SHA2-256 with the two most significant bits from the last byte zeroed (as via a mask with 0b00111111) - used for proving trees as in Filecoin +sha2-224, multihash, 0x1013, permanent, aka SHA-224; as specified by FIPS 180-4. +sha2-512-224, multihash, 0x1014, permanent, aka SHA-512/224; as specified by FIPS 180-4. +sha2-512-256, multihash, 0x1015, permanent, aka SHA-512/256; as specified by FIPS 180-4. +murmur3-x64-128, hash, 0x1022, draft, +ripemd-128, multihash, 0x1052, draft, +ripemd-160, multihash, 0x1053, draft, +ripemd-256, multihash, 0x1054, draft, +ripemd-320, multihash, 0x1055, draft, +x11, multihash, 0x1100, draft, +p256-pub, key, 0x1200, draft, P-256 public Key (compressed) +p384-pub, key, 0x1201, draft, P-384 public Key (compressed) +p521-pub, key, 0x1202, draft, P-521 public Key (compressed) +ed448-pub, key, 0x1203, draft, Ed448 public Key +x448-pub, key, 0x1204, draft, X448 public Key +rsa-pub, key, 0x1205, draft, RSA public key. DER-encoded ASN.1 type RSAPublicKey according to IETF RFC 8017 (PKCS #1) +sm2-pub, key, 0x1206, draft, SM2 public key (compressed) +vlad, vlad, 0x1207, draft, Verifiable Long-lived ADdress +provenance-log, serialization, 0x1208, draft, Verifiable and permissioned append-only log +provenance-log-entry, serialization, 0x1209, draft, Verifiable and permissioned append-only log entry +provenance-log-script, serialization, 0x120a, draft, Verifiable and permissioned append-only log script +mlkem-512-pub, key, 0x120b, draft, ML-KEM 512 public key; as specified by FIPS 203 +mlkem-768-pub, key, 0x120c, draft, ML-KEM 768 public key; as specified by FIPS 203 +mlkem-1024-pub, key, 0x120d, draft, ML-KEM 1024 public key; as specified by FIPS 203 +fn-dsa-512-pub, key, 0x120e, draft, FN-DSA (Falcon) 512 public key; as specified by FIPS 206 (draft) +fn-dsa-1024-pub, key, 0x120f, draft, FN-DSA (Falcon) 1024 public key; as specified by FIPS 206 (draft) +mldsa-44-pub, key, 0x1210, draft, ML-DSA 44 public key; as specified by FIPS 204 +mldsa-65-pub, key, 0x1211, draft, ML-DSA 65 public key; as specified by FIPS 204 +mldsa-87-pub, key, 0x1212, draft, ML-DSA 87 public key; as specified by FIPS 204 +mceliece348864-pub, key, 0x1213, draft, Classic McEliece 348864 public key +mceliece460896-pub, key, 0x1214, draft, Classic McEliece 460896 public key +rsa-2048-pub, key, 0x1215, draft, RSA 2048-bit public key +rsa-3072-pub, key, 0x1216, draft, RSA 3072-bit public key +rsa-4096-pub, key, 0x1217, draft, RSA 4096-bit public key +mayo-1-pub, key, 0x1218, draft, MAYO level 1 public key +mayo-2-pub, key, 0x1219, draft, MAYO level 2 public key +sntrup857-pub, key, 0x121a, draft, sntrup857 public key +sntrup953-pub, key, 0x121b, draft, sntrup953 public key +sntrup1013-pub, key, 0x121c, draft, sntrup1013 public key +sntrup1277-pub, key, 0x121d, draft, sntrup1277 public key +sntrup761-pub, key, 0x121f, draft, sntrup761 public key +slhdsa-sha2-128s-pub, key, 0x1220, draft, SLH-DSA-SHA2-128s public key; as specified by FIPS 205 +slhdsa-shake-128s-pub, key, 0x1221, draft, SLH-DSA-SHAKE-128s public key; as specified by FIPS 205 +slhdsa-sha2-128f-pub, key, 0x1222, draft, SLH-DSA-SHA2-128f public key; as specified by FIPS 205 +slhdsa-shake-128f-pub, key, 0x1223, draft, SLH-DSA-SHAKE-128f public key; as specified by FIPS 205 +slhdsa-sha2-192s-pub, key, 0x1224, draft, SLH-DSA-SHA2-192s public key; as specified by FIPS 205 +slhdsa-shake-192s-pub, key, 0x1225, draft, SLH-DSA-SHAKE-192s public key; as specified by FIPS 205 +slhdsa-sha2-192f-pub, key, 0x1226, draft, SLH-DSA-SHA2-192f public key; as specified by FIPS 205 +slhdsa-shake-192f-pub, key, 0x1227, draft, SLH-DSA-SHAKE-192f public key; as specified by FIPS 205 +slhdsa-sha2-256s-pub, key, 0x1228, draft, SLH-DSA-SHA2-256s public key; as specified by FIPS 205 +slhdsa-shake-256s-pub, key, 0x1229, draft, SLH-DSA-SHAKE-256s public key; as specified by FIPS 205 +slhdsa-sha2-256f-pub, key, 0x122a, draft, SLH-DSA-SHA2-256f public key; as specified by FIPS 205 +slhdsa-shake-256f-pub, key, 0x122b, draft, SLH-DSA-SHAKE-256f public key; as specified by FIPS 205 +x25519-sntrup761-pub, key, 0x1230, draft, X25519-sntrup761 hybrid KEM public key +x25519-mlkem768-pub, key, 0x1231, draft, X25519-ML-KEM-768 hybrid KEM public key +ed25519-mayo2-pub, key, 0x1232, draft, Ed25519-MAYO2 hybrid signing public key +frodo-kem-640-aes-pub, key, 0x1234, draft, FrodoKEM-640-AES public key +frodo-kem-976-aes-pub, key, 0x1235, draft, FrodoKEM-976-AES public key +frodo-kem-1344-aes-pub, key, 0x1236, draft, FrodoKEM-1344-AES public key +frodo-kem-640-shake-pub, key, 0x1237, draft, FrodoKEM-640-SHAKE public key +frodo-kem-976-shake-pub, key, 0x1238, draft, FrodoKEM-976-SHAKE public key +multisig, multiformat, 0x1239, draft, Digital signature multiformat +multikey, multiformat, 0x123a, draft, Encryption key multiformat +nonce, nonce, 0x123b, draft, Nonce random value +frodo-kem-1344-shake-pub, key, 0x123c, draft, FrodoKEM-1344-SHAKE public key +mayo-3-pub, key, 0x123d, draft, MAYO level 3 public key +mayo-5-pub, key, 0x123e, draft, MAYO level 5 public key +ed25519-mldsa65-pub, key, 0x123f, draft, Ed25519-ML-DSA-65 hybrid signing public key +ed25519-fndsa512-pub, key, 0x1241, draft, Ed25519-FN-DSA-512 hybrid signing public key +x25519-frodokem640aes-pub, key, 0x1243, draft, X25519-FrodoKEM-640-AES hybrid KEM public key +x25519-frodokem640shake-pub, key, 0x1244, draft, X25519-FrodoKEM-640-SHAKE hybrid KEM public key +x25519-mceliece348864-pub, key, 0x1245, draft, X25519-Classic-McEliece-348864 hybrid KEM public key +bls12381-g1-mldsa65-pub, key, 0x1246, draft, BLS12-381-G1-ML-DSA-65 hybrid signing public key +bls12381-g1-fndsa512-pub, key, 0x1247, draft, BLS12-381-G1-FN-DSA-512 hybrid signing public key +bls12381-g1-mayo1-pub, key, 0x1248, draft, BLS12-381-G1-MAYO-1 hybrid signing public key +bls12381-g1-mayo2-pub, key, 0x1249, draft, BLS12-381-G1-MAYO-2 hybrid signing public key +ed25519-priv, key, 0x1300, draft, Ed25519 private key +secp256k1-priv, key, 0x1301, draft, Secp256k1 private key +x25519-priv, key, 0x1302, draft, Curve25519 private key +sr25519-priv, key, 0x1303, draft, Sr25519 private key +fn-dsa-512-priv, key, 0x1304, draft, FN-DSA (Falcon) 512 private key; as specified by FIPS 206 (draft) +rsa-priv, key, 0x1305, draft, RSA private key +p256-priv, key, 0x1306, draft, P-256 private key +p384-priv, key, 0x1307, draft, P-384 private key +p521-priv, key, 0x1308, draft, P-521 private key +bls12_381-g1-priv, key, 0x1309, draft, BLS12-381 G1 private key +bls12_381-g2-priv, key, 0x130a, draft, BLS12-381 G2 private key +bls12_381-g1g2-priv, key, 0x130b, draft, BLS12-381 G1 and G2 private key +bls12_381-g1-pub-share, key, 0x130c, draft, BLS12-381 G1 public key share +bls12_381-g2-pub-share, key, 0x130d, draft, BLS12-381 G2 public key share +bls12_381-g1-priv-share, key, 0x130e, draft, BLS12-381 G1 private key share +bls12_381-g2-priv-share, key, 0x130f, draft, BLS12-381 G2 private key share +sm2-priv, key, 0x1310, draft, SM2 private key +ed448-priv, key, 0x1311, draft, Ed448 private key +x448-priv, key, 0x1312, draft, X448 private key +mlkem-512-priv, key, 0x1313, draft, ML-KEM 512 private key; as specified by FIPS 203 +mlkem-768-priv, key, 0x1314, draft, ML-KEM 768 public key; as specified by FIPS 203 +mlkem-1024-priv, key, 0x1315, draft, ML-KEM 1024 public key; as specified by FIPS 203 +jwk_jcs-priv, key, 0x1316, draft, JSON object containing only the required members of a JWK (RFC 7518 and RFC 7517) representing the private key. Serialisation based on JCS (RFC 8785) +mldsa-44-priv, key, 0x1317, draft, ML-DSA 44 private key; expanded key format (2560 bytes) as specified by FIPS 204 +mldsa-65-priv, key, 0x1318, draft, ML-DSA 65 private key; expanded key format (4032 bytes) as specified by FIPS 204 +mldsa-87-priv, key, 0x1319, draft, ML-DSA 87 private key; expanded key format (4896 bytes) as specified by FIPS 204 +mldsa-44-priv-seed, key, 0x131a, draft, ML-DSA 44 private key seed; (32 bytes) as specified by FIPS 204 +mldsa-65-priv-seed, key, 0x131b, draft, ML-DSA 65 private key seed; (32 bytes) as specified by FIPS 204 +mldsa-87-priv-seed, key, 0x131c, draft, ML-DSA 87 private key seed; (32 bytes) as specified by FIPS 204 +slhdsa-sha2-128s-priv, key, 0x131d, draft, SLH-DSA-SHA2-128s private key; as specified by FIPS 205 +slhdsa-shake-128s-priv, key, 0x131e, draft, SLH-DSA-SHAKE-128s private key; as specified by FIPS 205 +slhdsa-sha2-128f-priv, key, 0x131f, draft, SLH-DSA-SHA2-128f private key; as specified by FIPS 205 +slhdsa-shake-128f-priv, key, 0x1320, draft, SLH-DSA-SHAKE-128f private key; as specified by FIPS 205 +slhdsa-sha2-192s-priv, key, 0x1321, draft, SLH-DSA-SHA2-192s private key; as specified by FIPS 205 +slhdsa-shake-192s-priv, key, 0x1322, draft, SLH-DSA-SHAKE-192s private key; as specified by FIPS 205 +slhdsa-sha2-192f-priv, key, 0x1323, draft, SLH-DSA-SHA2-192f private key; as specified by FIPS 205 +slhdsa-shake-192f-priv, key, 0x1324, draft, SLH-DSA-SHAKE-192f private key; as specified by FIPS 205 +slhdsa-sha2-256s-priv, key, 0x1325, draft, SLH-DSA-SHA2-256s private key; as specified by FIPS 205 +slhdsa-shake-256s-priv, key, 0x1326, draft, SLH-DSA-SHAKE-256s private key; as specified by FIPS 205 +slhdsa-sha2-256f-priv, key, 0x1327, draft, SLH-DSA-SHA2-256f private key; as specified by FIPS 205 +slhdsa-shake-256f-priv, key, 0x1328, draft, SLH-DSA-SHAKE-256f private key; as specified by FIPS 205 +mceliece348864-priv, key, 0x1329, draft, Classic McEliece 348864 private key +mceliece460896-priv, key, 0x132a, draft, Classic McEliece 460896 private key +rsa-2048-priv, key, 0x132b, draft, RSA 2048-bit private key +rsa-3072-priv, key, 0x132c, draft, RSA 3072-bit private key +rsa-4096-priv, key, 0x132d, draft, RSA 4096-bit private key +mayo-1-priv, key, 0x132e, draft, MAYO level 1 private key +mayo-2-priv, key, 0x132f, draft, MAYO level 2 private key +sntrup857-priv, key, 0x1330, draft, sntrup857 private key +sntrup953-priv, key, 0x1331, draft, sntrup953 private key +sntrup1013-priv, key, 0x1332, draft, sntrup1013 private key +sntrup1277-priv, key, 0x1333, draft, sntrup1277 private key +fn-dsa-1024-priv, key, 0x1334, draft, FN-DSA (Falcon) 1024 private key; as specified by FIPS 206 (draft) +sntrup761-priv, key, 0x1335, draft, sntrup761 private key +x25519-sntrup761-priv, key, 0x1336, draft, X25519-sntrup761 hybrid KEM private key +x25519-mlkem768-priv, key, 0x1337, draft, X25519-ML-KEM-768 hybrid KEM private key +bip340-pub, key, 0x1340, draft, BIP340 public key +bip340-priv, key, 0x1341, draft, BIP340 private key +ed25519-mayo2-priv, key, 0x1342, draft, Ed25519-MAYO2 hybrid signing private key +frodo-kem-640-aes-priv, key, 0x1344, draft, FrodoKEM-640-AES private key +frodo-kem-976-aes-priv, key, 0x1345, draft, FrodoKEM-976-AES private key +frodo-kem-1344-aes-priv, key, 0x1346, draft, FrodoKEM-1344-AES private key +frodo-kem-640-shake-priv, key, 0x1347, draft, FrodoKEM-640-SHAKE private key +frodo-kem-976-shake-priv, key, 0x1348, draft, FrodoKEM-976-SHAKE private key +frodo-kem-1344-shake-priv, key, 0x1349, draft, FrodoKEM-1344-SHAKE private key +mayo-3-priv, key, 0x134a, draft, MAYO level 3 private key +mayo-5-priv, key, 0x134b, draft, MAYO level 5 private key +ed25519-mldsa65-priv, key, 0x134c, draft, Ed25519-ML-DSA-65 hybrid signing private key +ed25519-fndsa512-priv, key, 0x134e, draft, Ed25519-FN-DSA-512 hybrid signing private key +x25519-frodokem640aes-priv, key, 0x1350, draft, X25519-FrodoKEM-640-AES hybrid KEM private key +x25519-frodokem640shake-priv, key, 0x1351, draft, X25519-FrodoKEM-640-SHAKE hybrid KEM private key +x25519-mceliece348864-priv, key, 0x1352, draft, X25519-Classic-McEliece-348864 hybrid KEM private key +bls12381-g1-mldsa65-priv, key, 0x1353, draft, BLS12-381-G1-ML-DSA-65 hybrid signing private key +bls12381-g1-fndsa512-priv, key, 0x1354, draft, BLS12-381-G1-FN-DSA-512 hybrid signing private key +bls12381-g1-mayo1-priv, key, 0x1355, draft, BLS12-381-G1-MAYO-1 hybrid signing private key +bls12381-g1-mayo2-priv, key, 0x1356, draft, BLS12-381-G1-MAYO-2 hybrid signing private key +lamport-sha3-512-pub, key, 0x1a14, draft, Lamport public key based on SHA3-512 +lamport-sha3-384-pub, key, 0x1a15, draft, Lamport public key based on SHA3-384 +lamport-sha3-256-pub, key, 0x1a16, draft, Lamport public key based on SHA3-256 +lamport-sha3-512-priv, key, 0x1a24, draft, Lamport private key based on SHA3-512 +lamport-sha3-384-priv, key, 0x1a25, draft, Lamport private key based on SHA3-384 +lamport-sha3-256-priv, key, 0x1a26, draft, Lamport private key based on SHA3-256 +lamport-sha3-512-priv-share, key, 0x1a34, draft, Lamport private key share based on SHA3-512 and split with Shamir gf256 +lamport-sha3-384-priv-share, key, 0x1a35, draft, Lamport private key share based on SHA3-384 and split with Shamir gf256 +lamport-sha3-256-priv-share, key, 0x1a36, draft, Lamport private key share based on SHA3-256 and split with Shamir gf256 +lamport-sha3-512-sig, multisig, 0x1a44, draft, Lamport signature based on SHA3-512 +lamport-sha3-384-sig, multisig, 0x1a45, draft, Lamport signature based on SHA3-384 +lamport-sha3-256-sig, multisig, 0x1a46, draft, Lamport signature based on SHA3-256 +lamport-sha3-512-sig-share, multisig, 0x1a54, draft, Lamport signature share based on SHA3-512 and split with Shamir gf256 +lamport-sha3-384-sig-share, multisig, 0x1a55, draft, Lamport signature share based on SHA3-384 and split with Shamir gf256 +lamport-sha3-256-sig-share, multisig, 0x1a56, draft, Lamport signature share based on SHA3-256 and split with Shamir gf256 +kt-128, multihash, 0x1d01, draft, KangarooTwelve KT128 extendable-output hash function (XOF) as defined in RFC 9861 +kt-256, multihash, 0x1d02, draft, KangarooTwelve KT256 extendable-output hash function (XOF) as defined in RFC 9861 +aes-gcm-256, encryption, 0x2000, draft, AES Galois/Counter Mode with 256-bit key and 12-byte IV +aes-gcm-128, encryption, 0x2001, draft, AES Galois/Counter Mode with 128-bit key and 12-byte IV +ech, multiaddr, 0x2679, draft, ECHConfigList as defined in RFC 9849 (0x2679 == 9849). See the multiaddr repo for more details. +silverpine, multiaddr, 0x3f42, draft, Experimental QUIC over yggdrasil and ironwood routing protocol +sm3-256, multihash, 0x534d, draft, +sha256a, hash, 0x7012, draft, The sum of multiple sha2-256 hashes; as specified by Ceramic CIP-124. +chacha20-poly1305, multikey, 0xa000, draft, ChaCha20_Poly1305 encryption scheme +xchacha20-poly1305, encryption, 0xa001, draft, XChaCha20-Poly1305 extended nonce AEAD +blake2b-8, multihash, 0xb201, draft, Blake2b consists of 64 output lengths that give different hashes +blake2b-16, multihash, 0xb202, draft, +blake2b-24, multihash, 0xb203, draft, +blake2b-32, multihash, 0xb204, draft, +blake2b-40, multihash, 0xb205, draft, +blake2b-48, multihash, 0xb206, draft, +blake2b-56, multihash, 0xb207, draft, +blake2b-64, multihash, 0xb208, draft, +blake2b-72, multihash, 0xb209, draft, +blake2b-80, multihash, 0xb20a, draft, +blake2b-88, multihash, 0xb20b, draft, +blake2b-96, multihash, 0xb20c, draft, +blake2b-104, multihash, 0xb20d, draft, +blake2b-112, multihash, 0xb20e, draft, +blake2b-120, multihash, 0xb20f, draft, +blake2b-128, multihash, 0xb210, draft, +blake2b-136, multihash, 0xb211, draft, +blake2b-144, multihash, 0xb212, draft, +blake2b-152, multihash, 0xb213, draft, +blake2b-160, multihash, 0xb214, draft, +blake2b-168, multihash, 0xb215, draft, +blake2b-176, multihash, 0xb216, draft, +blake2b-184, multihash, 0xb217, draft, +blake2b-192, multihash, 0xb218, draft, +blake2b-200, multihash, 0xb219, draft, +blake2b-208, multihash, 0xb21a, draft, +blake2b-216, multihash, 0xb21b, draft, +blake2b-224, multihash, 0xb21c, draft, +blake2b-232, multihash, 0xb21d, draft, +blake2b-240, multihash, 0xb21e, draft, +blake2b-248, multihash, 0xb21f, draft, +blake2b-256, multihash, 0xb220, permanent, +blake2b-264, multihash, 0xb221, draft, +blake2b-272, multihash, 0xb222, draft, +blake2b-280, multihash, 0xb223, draft, +blake2b-288, multihash, 0xb224, draft, +blake2b-296, multihash, 0xb225, draft, +blake2b-304, multihash, 0xb226, draft, +blake2b-312, multihash, 0xb227, draft, +blake2b-320, multihash, 0xb228, draft, +blake2b-328, multihash, 0xb229, draft, +blake2b-336, multihash, 0xb22a, draft, +blake2b-344, multihash, 0xb22b, draft, +blake2b-352, multihash, 0xb22c, draft, +blake2b-360, multihash, 0xb22d, draft, +blake2b-368, multihash, 0xb22e, draft, +blake2b-376, multihash, 0xb22f, draft, +blake2b-384, multihash, 0xb230, draft, +blake2b-392, multihash, 0xb231, draft, +blake2b-400, multihash, 0xb232, draft, +blake2b-408, multihash, 0xb233, draft, +blake2b-416, multihash, 0xb234, draft, +blake2b-424, multihash, 0xb235, draft, +blake2b-432, multihash, 0xb236, draft, +blake2b-440, multihash, 0xb237, draft, +blake2b-448, multihash, 0xb238, draft, +blake2b-456, multihash, 0xb239, draft, +blake2b-464, multihash, 0xb23a, draft, +blake2b-472, multihash, 0xb23b, draft, +blake2b-480, multihash, 0xb23c, draft, +blake2b-488, multihash, 0xb23d, draft, +blake2b-496, multihash, 0xb23e, draft, +blake2b-504, multihash, 0xb23f, draft, +blake2b-512, multihash, 0xb240, draft, +blake2s-8, multihash, 0xb241, draft, Blake2s consists of 32 output lengths that give different hashes +blake2s-16, multihash, 0xb242, draft, +blake2s-24, multihash, 0xb243, draft, +blake2s-32, multihash, 0xb244, draft, +blake2s-40, multihash, 0xb245, draft, +blake2s-48, multihash, 0xb246, draft, +blake2s-56, multihash, 0xb247, draft, +blake2s-64, multihash, 0xb248, draft, +blake2s-72, multihash, 0xb249, draft, +blake2s-80, multihash, 0xb24a, draft, +blake2s-88, multihash, 0xb24b, draft, +blake2s-96, multihash, 0xb24c, draft, +blake2s-104, multihash, 0xb24d, draft, +blake2s-112, multihash, 0xb24e, draft, +blake2s-120, multihash, 0xb24f, draft, +blake2s-128, multihash, 0xb250, draft, +blake2s-136, multihash, 0xb251, draft, +blake2s-144, multihash, 0xb252, draft, +blake2s-152, multihash, 0xb253, draft, +blake2s-160, multihash, 0xb254, draft, +blake2s-168, multihash, 0xb255, draft, +blake2s-176, multihash, 0xb256, draft, +blake2s-184, multihash, 0xb257, draft, +blake2s-192, multihash, 0xb258, draft, +blake2s-200, multihash, 0xb259, draft, +blake2s-208, multihash, 0xb25a, draft, +blake2s-216, multihash, 0xb25b, draft, +blake2s-224, multihash, 0xb25c, draft, +blake2s-232, multihash, 0xb25d, draft, +blake2s-240, multihash, 0xb25e, draft, +blake2s-248, multihash, 0xb25f, draft, +blake2s-256, multihash, 0xb260, draft, +skein256-8, multihash, 0xb301, draft, Skein256 consists of 32 output lengths that give different hashes +skein256-16, multihash, 0xb302, draft, +skein256-24, multihash, 0xb303, draft, +skein256-32, multihash, 0xb304, draft, +skein256-40, multihash, 0xb305, draft, +skein256-48, multihash, 0xb306, draft, +skein256-56, multihash, 0xb307, draft, +skein256-64, multihash, 0xb308, draft, +skein256-72, multihash, 0xb309, draft, +skein256-80, multihash, 0xb30a, draft, +skein256-88, multihash, 0xb30b, draft, +skein256-96, multihash, 0xb30c, draft, +skein256-104, multihash, 0xb30d, draft, +skein256-112, multihash, 0xb30e, draft, +skein256-120, multihash, 0xb30f, draft, +skein256-128, multihash, 0xb310, draft, +skein256-136, multihash, 0xb311, draft, +skein256-144, multihash, 0xb312, draft, +skein256-152, multihash, 0xb313, draft, +skein256-160, multihash, 0xb314, draft, +skein256-168, multihash, 0xb315, draft, +skein256-176, multihash, 0xb316, draft, +skein256-184, multihash, 0xb317, draft, +skein256-192, multihash, 0xb318, draft, +skein256-200, multihash, 0xb319, draft, +skein256-208, multihash, 0xb31a, draft, +skein256-216, multihash, 0xb31b, draft, +skein256-224, multihash, 0xb31c, draft, +skein256-232, multihash, 0xb31d, draft, +skein256-240, multihash, 0xb31e, draft, +skein256-248, multihash, 0xb31f, draft, +skein256-256, multihash, 0xb320, draft, +skein512-8, multihash, 0xb321, draft, Skein512 consists of 64 output lengths that give different hashes +skein512-16, multihash, 0xb322, draft, +skein512-24, multihash, 0xb323, draft, +skein512-32, multihash, 0xb324, draft, +skein512-40, multihash, 0xb325, draft, +skein512-48, multihash, 0xb326, draft, +skein512-56, multihash, 0xb327, draft, +skein512-64, multihash, 0xb328, draft, +skein512-72, multihash, 0xb329, draft, +skein512-80, multihash, 0xb32a, draft, +skein512-88, multihash, 0xb32b, draft, +skein512-96, multihash, 0xb32c, draft, +skein512-104, multihash, 0xb32d, draft, +skein512-112, multihash, 0xb32e, draft, +skein512-120, multihash, 0xb32f, draft, +skein512-128, multihash, 0xb330, draft, +skein512-136, multihash, 0xb331, draft, +skein512-144, multihash, 0xb332, draft, +skein512-152, multihash, 0xb333, draft, +skein512-160, multihash, 0xb334, draft, +skein512-168, multihash, 0xb335, draft, +skein512-176, multihash, 0xb336, draft, +skein512-184, multihash, 0xb337, draft, +skein512-192, multihash, 0xb338, draft, +skein512-200, multihash, 0xb339, draft, +skein512-208, multihash, 0xb33a, draft, +skein512-216, multihash, 0xb33b, draft, +skein512-224, multihash, 0xb33c, draft, +skein512-232, multihash, 0xb33d, draft, +skein512-240, multihash, 0xb33e, draft, +skein512-248, multihash, 0xb33f, draft, +skein512-256, multihash, 0xb340, draft, +skein512-264, multihash, 0xb341, draft, +skein512-272, multihash, 0xb342, draft, +skein512-280, multihash, 0xb343, draft, +skein512-288, multihash, 0xb344, draft, +skein512-296, multihash, 0xb345, draft, +skein512-304, multihash, 0xb346, draft, +skein512-312, multihash, 0xb347, draft, +skein512-320, multihash, 0xb348, draft, +skein512-328, multihash, 0xb349, draft, +skein512-336, multihash, 0xb34a, draft, +skein512-344, multihash, 0xb34b, draft, +skein512-352, multihash, 0xb34c, draft, +skein512-360, multihash, 0xb34d, draft, +skein512-368, multihash, 0xb34e, draft, +skein512-376, multihash, 0xb34f, draft, +skein512-384, multihash, 0xb350, draft, +skein512-392, multihash, 0xb351, draft, +skein512-400, multihash, 0xb352, draft, +skein512-408, multihash, 0xb353, draft, +skein512-416, multihash, 0xb354, draft, +skein512-424, multihash, 0xb355, draft, +skein512-432, multihash, 0xb356, draft, +skein512-440, multihash, 0xb357, draft, +skein512-448, multihash, 0xb358, draft, +skein512-456, multihash, 0xb359, draft, +skein512-464, multihash, 0xb35a, draft, +skein512-472, multihash, 0xb35b, draft, +skein512-480, multihash, 0xb35c, draft, +skein512-488, multihash, 0xb35d, draft, +skein512-496, multihash, 0xb35e, draft, +skein512-504, multihash, 0xb35f, draft, +skein512-512, multihash, 0xb360, draft, +skein1024-8, multihash, 0xb361, draft, Skein1024 consists of 128 output lengths that give different hashes +skein1024-16, multihash, 0xb362, draft, +skein1024-24, multihash, 0xb363, draft, +skein1024-32, multihash, 0xb364, draft, +skein1024-40, multihash, 0xb365, draft, +skein1024-48, multihash, 0xb366, draft, +skein1024-56, multihash, 0xb367, draft, +skein1024-64, multihash, 0xb368, draft, +skein1024-72, multihash, 0xb369, draft, +skein1024-80, multihash, 0xb36a, draft, +skein1024-88, multihash, 0xb36b, draft, +skein1024-96, multihash, 0xb36c, draft, +skein1024-104, multihash, 0xb36d, draft, +skein1024-112, multihash, 0xb36e, draft, +skein1024-120, multihash, 0xb36f, draft, +skein1024-128, multihash, 0xb370, draft, +skein1024-136, multihash, 0xb371, draft, +skein1024-144, multihash, 0xb372, draft, +skein1024-152, multihash, 0xb373, draft, +skein1024-160, multihash, 0xb374, draft, +skein1024-168, multihash, 0xb375, draft, +skein1024-176, multihash, 0xb376, draft, +skein1024-184, multihash, 0xb377, draft, +skein1024-192, multihash, 0xb378, draft, +skein1024-200, multihash, 0xb379, draft, +skein1024-208, multihash, 0xb37a, draft, +skein1024-216, multihash, 0xb37b, draft, +skein1024-224, multihash, 0xb37c, draft, +skein1024-232, multihash, 0xb37d, draft, +skein1024-240, multihash, 0xb37e, draft, +skein1024-248, multihash, 0xb37f, draft, +skein1024-256, multihash, 0xb380, draft, +skein1024-264, multihash, 0xb381, draft, +skein1024-272, multihash, 0xb382, draft, +skein1024-280, multihash, 0xb383, draft, +skein1024-288, multihash, 0xb384, draft, +skein1024-296, multihash, 0xb385, draft, +skein1024-304, multihash, 0xb386, draft, +skein1024-312, multihash, 0xb387, draft, +skein1024-320, multihash, 0xb388, draft, +skein1024-328, multihash, 0xb389, draft, +skein1024-336, multihash, 0xb38a, draft, +skein1024-344, multihash, 0xb38b, draft, +skein1024-352, multihash, 0xb38c, draft, +skein1024-360, multihash, 0xb38d, draft, +skein1024-368, multihash, 0xb38e, draft, +skein1024-376, multihash, 0xb38f, draft, +skein1024-384, multihash, 0xb390, draft, +skein1024-392, multihash, 0xb391, draft, +skein1024-400, multihash, 0xb392, draft, +skein1024-408, multihash, 0xb393, draft, +skein1024-416, multihash, 0xb394, draft, +skein1024-424, multihash, 0xb395, draft, +skein1024-432, multihash, 0xb396, draft, +skein1024-440, multihash, 0xb397, draft, +skein1024-448, multihash, 0xb398, draft, +skein1024-456, multihash, 0xb399, draft, +skein1024-464, multihash, 0xb39a, draft, +skein1024-472, multihash, 0xb39b, draft, +skein1024-480, multihash, 0xb39c, draft, +skein1024-488, multihash, 0xb39d, draft, +skein1024-496, multihash, 0xb39e, draft, +skein1024-504, multihash, 0xb39f, draft, +skein1024-512, multihash, 0xb3a0, draft, +skein1024-520, multihash, 0xb3a1, draft, +skein1024-528, multihash, 0xb3a2, draft, +skein1024-536, multihash, 0xb3a3, draft, +skein1024-544, multihash, 0xb3a4, draft, +skein1024-552, multihash, 0xb3a5, draft, +skein1024-560, multihash, 0xb3a6, draft, +skein1024-568, multihash, 0xb3a7, draft, +skein1024-576, multihash, 0xb3a8, draft, +skein1024-584, multihash, 0xb3a9, draft, +skein1024-592, multihash, 0xb3aa, draft, +skein1024-600, multihash, 0xb3ab, draft, +skein1024-608, multihash, 0xb3ac, draft, +skein1024-616, multihash, 0xb3ad, draft, +skein1024-624, multihash, 0xb3ae, draft, +skein1024-632, multihash, 0xb3af, draft, +skein1024-640, multihash, 0xb3b0, draft, +skein1024-648, multihash, 0xb3b1, draft, +skein1024-656, multihash, 0xb3b2, draft, +skein1024-664, multihash, 0xb3b3, draft, +skein1024-672, multihash, 0xb3b4, draft, +skein1024-680, multihash, 0xb3b5, draft, +skein1024-688, multihash, 0xb3b6, draft, +skein1024-696, multihash, 0xb3b7, draft, +skein1024-704, multihash, 0xb3b8, draft, +skein1024-712, multihash, 0xb3b9, draft, +skein1024-720, multihash, 0xb3ba, draft, +skein1024-728, multihash, 0xb3bb, draft, +skein1024-736, multihash, 0xb3bc, draft, +skein1024-744, multihash, 0xb3bd, draft, +skein1024-752, multihash, 0xb3be, draft, +skein1024-760, multihash, 0xb3bf, draft, +skein1024-768, multihash, 0xb3c0, draft, +skein1024-776, multihash, 0xb3c1, draft, +skein1024-784, multihash, 0xb3c2, draft, +skein1024-792, multihash, 0xb3c3, draft, +skein1024-800, multihash, 0xb3c4, draft, +skein1024-808, multihash, 0xb3c5, draft, +skein1024-816, multihash, 0xb3c6, draft, +skein1024-824, multihash, 0xb3c7, draft, +skein1024-832, multihash, 0xb3c8, draft, +skein1024-840, multihash, 0xb3c9, draft, +skein1024-848, multihash, 0xb3ca, draft, +skein1024-856, multihash, 0xb3cb, draft, +skein1024-864, multihash, 0xb3cc, draft, +skein1024-872, multihash, 0xb3cd, draft, +skein1024-880, multihash, 0xb3ce, draft, +skein1024-888, multihash, 0xb3cf, draft, +skein1024-896, multihash, 0xb3d0, draft, +skein1024-904, multihash, 0xb3d1, draft, +skein1024-912, multihash, 0xb3d2, draft, +skein1024-920, multihash, 0xb3d3, draft, +skein1024-928, multihash, 0xb3d4, draft, +skein1024-936, multihash, 0xb3d5, draft, +skein1024-944, multihash, 0xb3d6, draft, +skein1024-952, multihash, 0xb3d7, draft, +skein1024-960, multihash, 0xb3d8, draft, +skein1024-968, multihash, 0xb3d9, draft, +skein1024-976, multihash, 0xb3da, draft, +skein1024-984, multihash, 0xb3db, draft, +skein1024-992, multihash, 0xb3dc, draft, +skein1024-1000, multihash, 0xb3dd, draft, +skein1024-1008, multihash, 0xb3de, draft, +skein1024-1016, multihash, 0xb3df, draft, +skein1024-1024, multihash, 0xb3e0, draft, +xxh-32, hash, 0xb3e1, draft, Extremely fast non-cryptographic hash algorithm +xxh-64, hash, 0xb3e2, draft, Extremely fast non-cryptographic hash algorithm +xxh3-64, hash, 0xb3e3, draft, Extremely fast non-cryptographic hash algorithm +xxh3-128, hash, 0xb3e4, draft, Extremely fast non-cryptographic hash algorithm +poseidon-bls12_381-a2-fc1, multihash, 0xb401, permanent, Poseidon using BLS12-381 and arity of 2 with Filecoin parameters +poseidon-bls12_381-a2-fc1-sc, multihash, 0xb402, draft, Poseidon using BLS12-381 and arity of 2 with Filecoin parameters - high-security variant +rdfc-1, ipld, 0xb403, draft, The result of canonicalizing an input according to RDFC-1.0 and then expressing its hash value as a multihash value. +ssz, serialization, 0xb501, draft, SimpleSerialize (SSZ) serialization +ssz-sha2-256-bmt, multihash, 0xb502, draft, SSZ Merkle tree root using SHA2-256 as the hashing function and SSZ serialization for the block binary +sha2-256-chunked, multihash, 0xb510, draft, Hash of concatenated SHA2-256 digests of 8*2^n MiB source chunks; n = ceil(log2(source_size/(10^4 * 8MiB))) +json-jcs, ipld, 0xb601, draft, The result of canonicalizing an input according to JCS - JSON Canonicalisation Scheme (RFC 8785) +bittorrent-pieces-root, multihash, 0xb702, draft, BitTorrent v2 pieces root hash. +iscc, softhash, 0xcc01, draft, ISCC (International Standard Content Code) - similarity preserving hash +zeroxcert-imprint-256, zeroxcert, 0xce11, draft, 0xcert Asset Imprint (root hash) +nonstandard-sig, varsig, 0xd000, deprecated, Namespace for all not yet standard signature algorithms +bcrypt-pbkdf, multihash, 0xd00d, draft, Bcrypt-PBKDF key derivation function +hkdf-sha256, kdf, 0xd00e, draft, HKDF-SHA256 key derivation function +es256k, varsig, 0xd0e7, draft, ES256K Signature Algorithm (secp256k1) +bls12_381-g1-sig, varsig, 0xd0ea, draft, G1 signature for BLS12-381 +bls12_381-g2-sig, varsig, 0xd0eb, draft, G2 signature for BLS12-381 +eddsa, varsig, 0xd0ed, draft, Edwards-Curve Digital Signature Algorithm +eip-191, varsig, 0xd191, draft, EIP-191 Ethereum Signed Data Standard +jwk_jcs-pub, key, 0xeb51, draft, JSON object containing only the required members of a JWK (RFC 7518 and RFC 7517) representing the public key. Serialisation based on JCS (RFC 8785) +ed2k, multihash, 0xed20, draft, eDonkey2000 hash. +fil-commitment-unsealed, filecoin, 0xf101, permanent, Filecoin piece or sector data commitment merkle node/root (CommP & CommD) +fil-commitment-sealed, filecoin, 0xf102, permanent, Filecoin sector data commitment merkle node/root - sealed and replicated (CommR) +shelter-contract-manifest, shelter, 0x511e00, draft, Shelter protocol contract manifest +shelter-contract-text, shelter, 0x511e01, draft, Shelter protocol contract text +shelter-contract-data, shelter, 0x511e02, draft, Shelter protocol contract data (contract chain) +shelter-file-manifest, shelter, 0x511e03, draft, Shelter protocol file manifest +shelter-file-chunk, shelter, 0x511e04, draft, Shelter protocol file chunk +plaintextv2, multiaddr, 0x706c61, draft, +holochain-adr-v0, holochain, 0x807124, draft, Holochain v0 address + 8 R-S (63 x Base-32) +holochain-adr-v1, holochain, 0x817124, draft, Holochain v1 address + 8 R-S (63 x Base-32) +holochain-key-v0, holochain, 0x947124, draft, Holochain v0 public key + 8 R-S (63 x Base-32) +holochain-key-v1, holochain, 0x957124, draft, Holochain v1 public key + 8 R-S (63 x Base-32) +holochain-sig-v0, holochain, 0xa27124, draft, Holochain v0 signature + 8 R-S (63 x Base-32) +holochain-sig-v1, holochain, 0xa37124, draft, Holochain v1 signature + 8 R-S (63 x Base-32) +skynet-ns, namespace, 0xb19910, draft, Skynet Namespace +arweave-ns, namespace, 0xb29910, draft, Arweave Namespace +subspace-ns, namespace, 0xb39910, draft, Subspace Network Namespace +kumandra-ns, namespace, 0xb49910, draft, Kumandra Network Namespace +massa, namespace, 0xb59910, draft, Massa blockchain ecosystem +massa-mainnet, namespace, 0xb59911, draft, Massa mainnet network +massa-buildnet, namespace, 0xb59912, draft, Massa buildnet network +massa-deweb, namespace, 0xb59913, draft, Massa DeWeb decentralized web +massa-gossip, namespace, 0xb59914, draft, Massa Gossip decentralized messaging +massa-mns, namespace, 0xb59915, draft, Massa Name Service target +massa-sc, namespace, 0xb59916, draft, Massa smart-contract address target +massa-gossip-id, namespace, 0xb59917, draft, Massa Gossip ID target +adnl, namespace, 0xb69910, draft, TON ADNL address: 32-byte SHA-256(0x4813b4c6_LE || Ed25519-pubkey) +es256, varsig, 0xd01200, draft, ES256 Signature Algorithm +es384, varsig, 0xd01201, draft, ES384 Signature Algorithm +es512, varsig, 0xd01202, draft, ES512 Signature Algorithm +rs256, varsig, 0xd01205, draft, RS256 Signature Algorithm +bip340, varsig, 0xd01206, draft, BIP340 Signature Algorithm +es256k-msig, multisig, 0xd01300, draft, ES256K (secp256k1) Signature as Multisig +bls12_381-g1-msig, multisig, 0xd01301, draft, G1 signature for BLS-12381-G2 as Multisig +bls12_381-g2-msig, multisig, 0xd01302, draft, G2 signature for BLS-12381-G1 as Multisig +eddsa-msig, multisig, 0xd01303, draft, Edwards-Curve Digital Signature as Multisig +bls12_381-g1-share-msig, multisig, 0xd01304, draft, G1 threshold signature share for BLS-12381-G2 as Multisig +bls12_381-g2-share-msig, multisig, 0xd01305, draft, G2 threshold signature share for BLS-12381-G1 as Multisig +lamport-msig, multisig, 0xd01306, draft, Lamport signature as Multisig +lamport-share-msig, multisig, 0xd01307, draft, Lamport threshold signature share as Multisig +es256-msig, multisig, 0xd01308, draft, ECDSA P-256 Signature as Multisig +es384-msig, multisig, 0xd01309, draft, ECDSA P-384 Signature as Multisig +es521-msig, multisig, 0xd0130a, draft, ECDSA P-521 Signature as Multisig +rs256-msig, multisig, 0xd0130b, draft, RS256 Signature as Multisig +slhdsa-sha2-128f-msig, multisig, 0xd0130c, draft, SLH-DSA SHA2-128f signature as Multisig; FIPS 205 +fn-dsa-512-msig, multisig, 0xd0130e, draft, FN-DSA (Falcon) 512 signature as Multisig; FIPS 206 (draft) +fn-dsa-1024-msig, multisig, 0xd0130f, draft, FN-DSA (Falcon) 1024 signature as Multisig; FIPS 206 (draft) +mldsa-65-msig, multisig, 0xd01310, draft, ML-DSA (Dilithium) 65 signature as Multisig; FIPS 204 +mldsa-87-msig, multisig, 0xd01311, draft, ML-DSA (Dilithium) 87 signature as Multisig; FIPS 204 +slhdsa-sha2-128s-msig, multisig, 0xd01312, draft, SLH-DSA SHA2-128s signature as Multisig; FIPS 205 +slhdsa-sha2-192f-msig, multisig, 0xd01313, draft, SLH-DSA SHA2-192f signature as Multisig; FIPS 205 +slhdsa-sha2-192s-msig, multisig, 0xd01314, draft, SLH-DSA SHA2-192s signature as Multisig; FIPS 205 +slhdsa-sha2-256f-msig, multisig, 0xd01315, draft, SLH-DSA SHA2-256f signature as Multisig; FIPS 205 +slhdsa-sha2-256s-msig, multisig, 0xd01316, draft, SLH-DSA SHA2-256s signature as Multisig; FIPS 205 +slhdsa-shake-128f-msig, multisig, 0xd01317, draft, SLH-DSA SHAKE128f signature as Multisig; FIPS 205 +slhdsa-shake-128s-msig, multisig, 0xd01318, draft, SLH-DSA SHAKE128s signature as Multisig; FIPS 205 +slhdsa-shake-192f-msig, multisig, 0xd01319, draft, SLH-DSA SHAKE192f signature as Multisig; FIPS 205 +slhdsa-shake-192s-msig, multisig, 0xd0131a, draft, SLH-DSA SHAKE192s signature as Multisig; FIPS 205 +slhdsa-shake-256f-msig, multisig, 0xd0131b, draft, SLH-DSA SHAKE256f signature as Multisig; FIPS 205 +slhdsa-shake-256s-msig, multisig, 0xd0131c, draft, SLH-DSA SHAKE256s signature as Multisig; FIPS 205 +mayo-1-msig, multisig, 0xd0131d, draft, MAYO level 1 signature as Multisig +mayo-2-msig, multisig, 0xd0131e, draft, MAYO level 2 signature as Multisig +ed25519-mayo2-msig, multisig, 0xd01320, draft, Ed25519-MAYO2 hybrid signature as Multisig +mayo-3-msig, multisig, 0xd01322, draft, MAYO level 3 signature as Multisig +mayo-5-msig, multisig, 0xd01323, draft, MAYO level 5 signature as Multisig +ed25519-mldsa65-msig, multisig, 0xd01324, draft, Ed25519-ML-DSA-65 hybrid signature as Multisig +ed25519-fndsa512-msig, multisig, 0xd01326, draft, Ed25519-FN-DSA-512 hybrid signature as Multisig +bls12381-g1-mldsa65-msig, multisig, 0xd01328, draft, BLS12-381-G1-ML-DSA-65 hybrid signature as Multisig +bls12381-g1-fndsa512-msig, multisig, 0xd01329, draft, BLS12-381-G1-FN-DSA-512 hybrid signature as Multisig +bls12381-g1-mayo1-msig, multisig, 0xd0132a, draft, BLS12-381-G1-MAYO-1 hybrid signature as Multisig +bls12381-g1-mayo2-msig, multisig, 0xd0132b, draft, BLS12-381-G1-MAYO-2 hybrid signature as Multisig +bs-message, multiformat, 0xd01400, draft, BetterSign signed+encrypted message multiformat +scion, multiaddr, 0xd02000, draft, SCION Internet architecture +ed25519-thresh-priv-share, key, 0xd03000, draft, Ed25519 FROST DKG threshold private key share +ed25519-thresh-pub-share, key, 0xd03001, draft, Ed25519 FROST DKG threshold public key share +p256-thresh-priv-share, key, 0xd03002, draft, P-256 FROST DKG threshold private key share +p256-thresh-pub-share, key, 0xd03003, draft, P-256 FROST DKG threshold public key share +p384-thresh-priv-share, key, 0xd03004, draft, P-384 FROST DKG threshold private key share +p384-thresh-pub-share, key, 0xd03005, draft, P-384 FROST DKG threshold public key share +secp256k1-thresh-priv-share, key, 0xd03006, draft, secp256k1 FROST DKG threshold private key share +secp256k1-thresh-pub-share, key, 0xd03007, draft, secp256k1 FROST DKG threshold public key share +bls12-381-thresh-priv-share, key, 0xd03008, draft, BLS12-381 FROST DKG threshold private key share +bls12-381-thresh-pub-share, key, 0xd03009, draft, BLS12-381 FROST DKG threshold public key share +ed448-thresh-priv-share, key, 0xd0300a, draft, Ed448 FROST DKG threshold private key share +ed448-thresh-pub-share, key, 0xd0300b, draft, Ed448 FROST DKG threshold public key share +key-split-share, key, 0xd0300c, draft, Generic verifiable private key split share (Feldman VSS or gf256) From 6ec2d93911e003bf826e108bbcedaa082f92c47a Mon Sep 17 00:00:00 2001 From: Dave Grantham Date: Mon, 13 Jul 2026 16:05:15 -0600 Subject: [PATCH 3/3] update dep Signed-off-by: Dave Grantham --- Cargo.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index cf3390a..087e253 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "multi-codec" -version = "1.0.1" +version = "1.0.2" edition = "2021" authors = ["Benjamin Kampmann ", "Dave Grantham "] description = "Implementation of the Multicodec specification" @@ -14,7 +14,7 @@ categories = ["encoding"] default = ["serde"] [dependencies] -multi-trait = { version = "1.0", path = "../multi-trait" } +multi-trait = "1.0" serde = { version = "1.0", default-features = false, optional = true, features = ["serde_derive"] } thiserror = { version = "2.0" }