mars-shard · gal

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum GalEntryType {
    /// An HMR identity anchor.
    HmrAnchor,
    /// An MHR (multi-human root) identity anchor.
    MhrAnchor,
    /// Root of an organization lineage chain.
    OrgLineageRoot,
    /// A revocation record for a previously published entry.
    RevocationRecord,
    /// Assignment of a DID to a specific RSL shard.
    ShardAssignment,
    /// Topology metadata for a shard in the network.
    ShardTopologyEntry,
}

pub fn all() -> &'static [GalEntryType; 6];

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GalEntry {
/// The type of GAL anchor.

pub entry_type: GalEntryType,
/// The DID this anchor references.

pub did: String,
/// SHA-256 content hash of the full entry in RSL.

pub content_hash: String,
/// DID of the publisher who created the anchor.

pub publisher_did: String,
/// When this anchor was created.

pub created_at: chrono::DateTime<chrono::Utc>,
/// When this anchor was last updated.

pub updated_at: chrono::DateTime<chrono::Utc>,
/// Which RSL shard holds the full entry.

pub shard_id: String,
/// Merkle inclusion proof from the shard (optional).

#[serde(skip_serializing_if = "Option::is_none")]
pub proof: Option<Vec<u8>>
}

pub fn validate(&self) -> Result<(), ShardError>;

pub fn hash(&self) -> [u8; 32];

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HmrAnchorData {
/// DID of the HMR.

pub hmr_did: String,
/// DID of the entry being anchored.

pub entry_did: String,
/// SHA-256 hash of the item data.

pub item_data_hash: String,
/// Proof-of-humanity attestation reference.

pub proof_of_humanity: String
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MhrAnchorData {
/// DID of the MHR.

pub mhr_did: String,
/// Hash of the threshold ceremony.

pub ceremony_hash: String,
/// Threshold required (e.g. 3 of 5).

pub threshold: u8,
/// DIDs of participants in the MHR ceremony.

pub participants: Vec<String>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OrgLineageRootData {
/// DID of the organization.

pub org_did: String,
/// DID of the originating human root.

pub human_root_did: String,
/// Ordered chain of DIDs from root to org.

pub lineage_chain: Vec<String>,
/// Generation depth from human root.

pub depth: u32
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RevocationRecord {
/// DID of the revoked entry.

pub entry_did: String,
/// DID of the entity that performed the revocation.

pub revoked_by: String,
/// Human-readable reason for revocation.

pub reason: String,
/// When the revocation occurred.

pub revoked_at: chrono::DateTime<chrono::Utc>,
/// Current propagation status across shards.

pub propagation_status: PropagationStatus
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PropagationStatus {
    /// Revocation initiated, not yet propagated.
    Pending,
    /// Revocation being propagated to shards.
    Propagating,
    /// Revocation fully propagated to all shards.
    Complete,
}

pub struct GalMerkleTree {

}

pub fn new() -> Self;

pub fn insert(&mut self, entry: &GalEntry);

pub fn len(&self) -> usize;

pub fn is_empty(&self) -> bool;

pub fn root(&self) -> [u8; 32];

pub fn proof(&self, index: usize) -> Option<Vec<Vec<u8>>>;

pub fn verify(root: &[u8; 32], entry_hash: &[u8; 32], proof: &[Vec<u8>], index: usize) -> bool;