sigil-node · username_durable

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct UsernameEvent {
pub block_height: u64,
pub seq: u64,
pub kind: String,
pub name: String,
pub actor_did: String,
pub payload: serde_json::Value
}

pub struct DurableUsernameStore {

}

pub fn open(path: &Path) -> Result<Self, NodeError>;

pub fn get(&self, canonical_name: &str) -> Result<Option<UsernameRecord>, NodeError>;

pub fn lookup_reverse(&self, owner_did: &str) -> Result<Option<String>, NodeError>;

pub fn get_reverse_record(
        &self,
        owner_did: &str,
    ) -> Result<Option<ReverseUsernameRecord>, NodeError>;

pub fn list_for_owner(&self, owner_did: &str) -> Result<Vec<UsernameRecord>, NodeError>;

pub fn list_all(&self) -> Result<Vec<UsernameRecord>, NodeError>;

pub fn get_auction(&self, canonical_name: &str) -> Result<Option<UsernameAuction>, NodeError>;

pub fn list_all_auctions(&self) -> Result<Vec<UsernameAuction>, NodeError>;

pub fn get_dispute(&self, dispute_id: &str) -> Result<Option<UsernameDispute>, NodeError>;

pub fn list_all_disputes(&self) -> Result<Vec<UsernameDispute>, NodeError>;

pub fn commit_batch(&self, batch: &UsernameWriteBatch) -> Result<(), NodeError>;

pub fn put_record(&self, record: &UsernameRecord) -> Result<(), NodeError>;

pub fn delete_record(&self, canonical_name: &str, owner_did: &str) -> Result<(), NodeError>;

pub fn namespace_prefix() -> &'static [u8];

pub fn close(&self) -> Result<(), NodeError>;

pub type ArcUsernameStore = Arc<DurableUsernameStore>;

#[derive(Clone)]
pub enum UsernameBatchOp {
    /// Insert or replace a username record.
    PutRecord(Box<UsernameRecord>),
    /// Add an owner-index entry (presence marker).
    IndexOwner { owner_did: String, name: String },
    /// Remove an owner-index entry.
    DeindexOwner { owner_did: String, name: String },
    /// Delete the record (release / forfeit / expiry-reclaim).
    DeleteRecord { name: String },
    /// Set the reverse-lookup primary for a DID.
    SetReverse { owner_did: String, primary: String },
    /// Clear the reverse-lookup primary for a DID.
    ClearReverse { owner_did: String },
    /// Append an immutable audit event.
    AppendEvent(UsernameEvent),
    /// Insert or replace an auction record.
    PutAuction(Box<UsernameAuction>),
    /// Delete an auction record (after settlement).
    DeleteAuction { name: String },
    /// Insert or replace a dispute record.
    PutDispute(Box<UsernameDispute>),
    /// Delete a dispute record (after resolution + grace).
    DeleteDispute { dispute_id: String },
}

#[derive(Default)]
pub struct UsernameWriteBatch {

}

pub fn new() -> Self;

pub fn put_record(&mut self, record: UsernameRecord);

pub fn index_owner(&mut self, owner_did: impl Into<String>, name: impl Into<String>);

pub fn deindex_owner(&mut self, owner_did: impl Into<String>, name: impl Into<String>);

pub fn delete_record(&mut self, name: impl Into<String>);

pub fn set_reverse(&mut self, owner_did: impl Into<String>, primary: impl Into<String>);

pub fn clear_reverse(&mut self, owner_did: impl Into<String>);

pub fn append_event(&mut self, event: UsernameEvent);

pub fn put_auction(&mut self, auction: UsernameAuction);

pub fn delete_auction(&mut self, name: impl Into<String>);

pub fn put_dispute(&mut self, dispute: UsernameDispute);

pub fn delete_dispute(&mut self, dispute_id: impl Into<String>);

pub fn len(&self) -> usize;

pub fn is_empty(&self) -> bool;