oas-resolve · anchored

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub struct AnchorRecord {
/// Subject DID this anchor is bound to.

pub did: String,
/// Lifecycle status reported by the GAL: `"active"`, `"rotating"`,

/// `"revoked"`. Anything other than `"active"` is rejected.

pub status: String,
/// Block height at which this anchor version was published. Must be

/// less than or equal to the GAL's current finalized block.

pub anchored_at_block: u64,
/// BLAKE3 commitment to the canonical off-chain DID document.

pub metadata_commitment: String
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct AnchorStatus {
pub revoked: bool,
/// Optional human-readable reason commitment.

#[serde(default, skip_serializing_if = "Option::is_none")]
pub reason_commitment: Option<String>
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub struct OrgLineageRoot {
/// Org DID (typically MHR or ENR).

pub org_did: String,
/// `blake3:`-prefixed hex of the on-chain Merkle root.

pub merkle_root: String,
/// On-chain status: `"active"` / `"rotating"` / `"revoked"`.

pub status: String,
/// Block height at which this version of the root was published.

pub anchored_at_block: u64
}

#[derive(Debug, thiserror::Error)]
pub enum AnchorError {
    /// Underlying transport / RPC failure.
    #[error("anchor transport error: {0}")]
    Transport(String),
    /// Backend returned a structurally invalid record.
    #[error("invalid anchor record: {0}")]
    InvalidRecord(String),
}

#[async_trait]
pub trait LineageAnchor: Send + Sync {
    /// Revocation-first check. Returns `revoked: true` for subjects with
    /// any cascade kind (single, cascade-root, cascade-org).
    async fn check_revocation(&self, did: &str) -> Result<AnchorStatus, AnchorError>;

    /// Fetch the typed HMR anchor for a DID, or `None` if absent.
    async fn get_hmr(&self, did: &str) -> Result<Option<AnchorRecord>, AnchorError>;

    /// Fetch the typed MHR anchor for a DID, or `None` if absent.
    async fn get_mhr(&self, did: &str) -> Result<Option<AnchorRecord>, AnchorError>;

    /// Fetch the typed ENR anchor for a DID, or `None` if absent.
    async fn get_enr(&self, did: &str) -> Result<Option<AnchorRecord>, AnchorError>;

    /// Fetch the typed `OrgLineageRoot` for an org DID, or `None` if
    /// the GAL has no Merkle commitment for that DID.
    ///
    /// Default impl returns `None` — implementations that want to
    /// participate in Rule 7 (org Merkle inclusion) override this.
    async fn get_org_root(&self, _org_did: &str) -> Result<Option<OrgLineageRoot>, AnchorError> ;

    /// Current finalized block height. The guard uses this to reject
    /// anchors whose `anchored_at_block` lies in the future.
    async fn current_finalized_block(&self) -> Result<u64, AnchorError>;
}

pub struct MemoryAnchor {

}

pub fn new() -> Self;

pub fn set_block(&self, block: u64);

pub fn insert_hmr(&self, anchor: AnchorRecord);

pub fn insert_mhr(&self, anchor: AnchorRecord);

pub fn insert_enr(&self, anchor: AnchorRecord);

pub fn insert_revocation(&self, did: &str, reason: Option<&str>);

pub fn insert_org_root(&self, root: OrgLineageRoot);

pub struct AnchoredResolver<R, G>
where
    R: Resolver,
    G: LineageAnchor, {

}

pub fn new(inner: R, anchor: G) -> Self;

pub fn document_metadata_commitment(doc: &OasDocument) -> Result<String, ResolveError>;

pub fn org_leaf_hash(child_did: &str) -> String;