use serde::{Deserialize, Deserializer, Serialize, Serializer};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum HashFn {
Blake3,
}
impl HashFn {
pub const fn multicodec(self) -> u64 {
match self {
HashFn::Blake3 => 0x1e,
}
}
pub const fn name(self) -> &'static str {
match self {
HashFn::Blake3 => "blake3",
}
}
pub const fn digest_len(self) -> usize {
match self {
HashFn::Blake3 => 32,
}
}
fn from_name(name: &str) -> Option<Self> {
match name {
"blake3" => Some(HashFn::Blake3),
_ => None,
}
}
fn from_multicodec(code: u64) -> Option<Self> {
match code {
0x1e => Some(HashFn::Blake3),
_ => None,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum HashError {
UnknownFunction,
BadLength,
BadHex,
Truncated,
}
impl std::fmt::Display for HashError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
HashError::UnknownFunction => "unknown hash function",
HashError::BadLength => "digest length mismatch",
HashError::BadHex => "invalid hex in digest",
HashError::Truncated => "truncated multihash",
})
}
}
impl std::error::Error for HashError {}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Hash {
func: HashFn,
digest: [u8; 32],
}
impl Hash {
pub fn of(bytes: &[u8]) -> Self {
Self {
func: HashFn::Blake3,
digest: *blake3::hash(bytes).as_bytes(),
}
}
pub fn from_chunks<'a, I: IntoIterator<Item = &'a [u8]>>(chunks: I) -> Self {
let mut hasher = blake3::Hasher::new();
for chunk in chunks {
hasher.update(chunk);
}
Self {
func: HashFn::Blake3,
digest: *hasher.finalize().as_bytes(),
}
}
pub fn from_reader<R: std::io::Read>(mut reader: R) -> std::io::Result<Self> {
let mut hasher = blake3::Hasher::new();
let mut buffer = [0u8; 65_536];
loop {
let n = reader.read(&mut buffer)?;
if n == 0 {
break;
}
hasher.update(&buffer[..n]);
}
Ok(Self {
func: HashFn::Blake3,
digest: *hasher.finalize().as_bytes(),
})
}
pub fn func(&self) -> HashFn {
self.func
}
pub fn as_bytes(&self) -> &[u8; 32] {
&self.digest
}
pub fn to_hex(&self) -> String {
let mut out = String::with_capacity(self.digest.len() * 2);
for byte in &self.digest {
out.push_str(&format!("{byte:02x}"));
}
out
}
pub fn to_multihash_bytes(&self) -> Vec<u8> {
let mut out = Vec::with_capacity(2 + self.digest.len());
write_uvarint(self.func.multicodec(), &mut out);
write_uvarint(self.func.digest_len() as u64, &mut out);
out.extend_from_slice(&self.digest);
out
}
pub fn from_multihash_bytes(bytes: &[u8]) -> Result<Self, HashError> {
let (code, n1) = read_uvarint(bytes).ok_or(HashError::Truncated)?;
let func = HashFn::from_multicodec(code).ok_or(HashError::UnknownFunction)?;
let rest = &bytes[n1..];
let (len, n2) = read_uvarint(rest).ok_or(HashError::Truncated)?;
let digest_bytes = &rest[n2..];
if len as usize != func.digest_len() || digest_bytes.len() != func.digest_len() {
return Err(HashError::BadLength);
}
let mut digest = [0u8; 32];
digest.copy_from_slice(digest_bytes);
Ok(Self { func, digest })
}
pub fn parse(s: &str) -> Result<Self, HashError> {
let (name, hex) = match s.split_once(':') {
Some((name, hex)) => (name, hex),
None => ("blake3", s),
};
let func = HashFn::from_name(name).ok_or(HashError::UnknownFunction)?;
if hex.len() != func.digest_len() * 2 {
return Err(HashError::BadLength);
}
let mut digest = [0u8; 32];
for (idx, pair) in hex.as_bytes().chunks(2).enumerate() {
let byte_str = std::str::from_utf8(pair).map_err(|_| HashError::BadHex)?;
digest[idx] = u8::from_str_radix(byte_str, 16).map_err(|_| HashError::BadHex)?;
}
Ok(Self { func, digest })
}
}
impl std::fmt::Display for Hash {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "{}:{}", self.func.name(), self.to_hex())
}
}
impl Serialize for Hash {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(&self.to_string())
}
}
impl<'de> Deserialize<'de> for Hash {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let s = String::deserialize(deserializer)?;
Hash::parse(&s).map_err(serde::de::Error::custom)
}
}
fn write_uvarint(mut value: u64, out: &mut Vec<u8>) {
loop {
let mut byte = (value & 0x7f) as u8;
value >>= 7;
if value != 0 {
byte |= 0x80;
}
out.push(byte);
if value == 0 {
break;
}
}
}
fn read_uvarint(bytes: &[u8]) -> Option<(u64, usize)> {
let mut value = 0u64;
let mut shift = 0u32;
for (idx, &byte) in bytes.iter().enumerate() {
if shift >= 64 {
return None;
}
value |= ((byte & 0x7f) as u64) << shift;
if byte & 0x80 == 0 {
return Some((value, idx + 1));
}
shift += 7;
}
None
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ManifestId(pub Hash);
impl ManifestId {
pub fn from_hash(hash: Hash) -> Self {
Self(hash)
}
pub fn of_blob(bytes: &[u8]) -> Self {
Self(Hash::of(bytes))
}
pub fn store_key(&self) -> String {
format!("manifest:{}", self.0.to_hex())
}
}
impl std::fmt::Display for ManifestId {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.0.fmt(formatter)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(transparent)]
pub struct SchemaRef(pub ManifestId);
impl SchemaRef {
pub fn from_id(id: ManifestId) -> Self {
Self(id)
}
}
impl std::fmt::Display for SchemaRef {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.0.fmt(formatter)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(transparent)]
pub struct Timestamp(pub u64);
impl Timestamp {
pub const ZERO: Self = Self(0);
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PrivacyClass {
LocalOnly,
TrustedPeersOnly,
MootScoped,
PublicPortable,
}
impl Default for PrivacyClass {
fn default() -> Self {
Self::LocalOnly
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum ProvenanceOrigin {
Imported { source: String },
Derived,
Generated,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProvenanceRecord {
pub origin: ProvenanceOrigin,
#[serde(default)]
pub upstream: Vec<ManifestId>,
#[serde(default)]
pub tooling: Option<String>,
pub generated_at: Timestamp,
}
impl ProvenanceRecord {
pub fn self_imported(source: impl Into<String>) -> Self {
Self {
origin: ProvenanceOrigin::Imported {
source: source.into(),
},
upstream: Vec::new(),
tooling: None,
generated_at: Timestamp::ZERO,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TrustLevel {
SelfAsserted,
PeerAttested,
CommunityReviewed,
CheckpointAccepted,
}
impl Default for TrustLevel {
fn default() -> Self {
Self::SelfAsserted
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(transparent)]
pub struct SignatureRef(pub String);
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ModerationState {
Unreviewed,
Quarantined,
Accepted,
Rejected,
Superseded,
}
impl Default for ModerationState {
fn default() -> Self {
Self::Unreviewed
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct TrustEnvelope {
pub level: TrustLevel,
#[serde(default)]
pub signatures: Vec<SignatureRef>,
pub moderation_state: ModerationState,
}
impl TrustEnvelope {
pub fn self_asserted() -> Self {
Self {
level: TrustLevel::SelfAsserted,
signatures: Vec::new(),
moderation_state: ModerationState::Unreviewed,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hash_of_known_input_matches_blake3_reference() {
let h = Hash::of(b"");
assert_eq!(h.to_hex().len(), 64);
assert_eq!(Hash::of(b"hello"), Hash::of(b"hello"));
assert_ne!(Hash::of(b"hello"), Hash::of(b"world"));
}
#[test]
fn hash_from_chunks_matches_full_slice() {
let full = b"first chunk + second chunk + third";
let chunks: Vec<&[u8]> = vec![b"first chunk ", b"+ second chunk ", b"+ third"];
assert_eq!(Hash::from_chunks(chunks.into_iter()), Hash::of(full));
}
#[test]
fn hash_from_reader_matches_full_slice() {
let payload: Vec<u8> = (0..8192u32).map(|i| (i % 256) as u8).collect();
let from_slice = Hash::of(&payload);
let from_reader = Hash::from_reader(payload.as_slice()).unwrap();
assert_eq!(from_slice, from_reader);
}
#[test]
fn hash_serializes_as_self_describing_string() {
let h = Hash::of(b"abc");
let json = serde_json::to_string(&h).unwrap();
assert_eq!(json, format!("\"blake3:{}\"", h.to_hex()));
let round: Hash = serde_json::from_str(&json).unwrap();
assert_eq!(round, h);
}
#[test]
fn hash_multihash_bytes_round_trip() {
let h = Hash::of(b"payload");
let mh = h.to_multihash_bytes();
assert_eq!(mh[0], 0x1e);
assert_eq!(mh[1], 0x20);
assert_eq!(mh.len(), 2 + 32);
assert_eq!(Hash::from_multihash_bytes(&mh).unwrap(), h);
}
#[test]
fn hash_parse_accepts_tagged_and_legacy_bare_hex() {
let h = Hash::of(b"legacy");
assert_eq!(Hash::parse(&h.to_string()).unwrap(), h);
assert_eq!(Hash::parse(&h.to_hex()).unwrap(), h);
assert_eq!(
Hash::parse(&format!("blake4:{}", h.to_hex())),
Err(HashError::UnknownFunction)
);
}
#[test]
fn manifest_id_store_key_is_prefix_plus_hex() {
let id = ManifestId::of_blob(b"payload");
let key = id.store_key();
assert!(key.starts_with("manifest:"));
assert_eq!(key.len(), "manifest:".len() + 64);
}
#[test]
fn privacy_class_defaults_to_local_only() {
assert_eq!(PrivacyClass::default(), PrivacyClass::LocalOnly);
}
#[test]
fn trust_envelope_self_asserted_starts_unreviewed() {
let trust = TrustEnvelope::self_asserted();
assert_eq!(trust.level, TrustLevel::SelfAsserted);
assert!(trust.signatures.is_empty());
assert_eq!(trust.moderation_state, ModerationState::Unreviewed);
}
#[test]
fn provenance_self_imported_records_source() {
let prov = ProvenanceRecord::self_imported("hf:test-model");
match prov.origin {
ProvenanceOrigin::Imported { source } => {
assert_eq!(source, "hf:test-model");
}
_ => panic!("expected Imported origin"),
}
assert!(prov.upstream.is_empty());
}
}