sigil-node · mail_durable

pub type ArcMailStore = Arc<DurableMailStore>;

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct MailEvent {
pub block_height: u64,
pub seq: u64,
pub topic: String,
pub actor_did: String,
pub mailbox_id: Option<String>,
pub name: Option<String>,
pub payload: serde_json::Value
}

#[derive(Debug, Clone)]
pub enum MailBatchOp {
    PutMailbox(Arc<MailboxCapabilityRecord>),
    IndexOwner {
        owner_did: String,
        mailbox_id: String,
    },
    IndexWallet {
        wallet_address: String,
        mailbox_id: String,
    },
    PutAlias(Arc<MailAliasRecord>),
    PutPolicy(Arc<MailboxPolicyRecord>),
    SetCurrentPolicy {
        mailbox_id: String,
        version: u64,
    },
    PutKey(Arc<MailPublicKeyRecord>),
    SetCurrentKey {
        mailbox_id: String,
        purpose: String,
        device_commitment: String,
        key_id: String,
    },
    PutDelivery(Arc<DeliveryCommitmentRecord>),
    IndexDeliveryRecipient {
        mailbox_id: String,
        height: u64,
        delivery_id: String,
    },
    IndexDeliverySender {
        sender_route_id: String,
        height: u64,
        delivery_id: String,
    },
    PutEconomics(Arc<SenderEconomicsRecord>),
    PutDelegation(Arc<MailDelegationGrant>),
    IndexDelegationMailbox {
        mailbox_id: String,
        grant_id: String,
    },
    PutAbuse(Arc<AbuseReport>),
    PutSnsName(Arc<SnsNameRecord>),
    IndexSnsOwner {
        owner_did: String,
        name_hash: String,
    },
    SetSnsPrimary {
        subject_did: String,
        name_hash: String,
    },
    PutSnsRecord(Arc<SnsResolverRecord>),
    DeleteSnsRecord {
        name_hash: String,
        kind: String,
    },
    PutSnsDelegation(Arc<NameDelegation>),
    PutSnsRegistrationCommitment(Arc<SnsNameRegistrationCommitment>),
    PutSnsSealedBid(Arc<SnsSealedBidCommitment>),
    PutSnsAuction(Arc<SnsAuctionRecord>),
    PutNonce {
        actor_did: String,
        nonce: String,
    },
    AppendEvent(Arc<MailEvent>),
}

#[derive(Debug, Default, Clone)]
pub struct MailWriteBatch {
pub ops: Vec<MailBatchOp>
}

pub fn new() -> Self;

pub fn push(&mut self, op: MailBatchOp);

pub struct DurableMailStore {

}

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

pub fn get_mailbox(
        &self,
        mailbox_id: &str,
    ) -> Result<Option<MailboxCapabilityRecord>, NodeError>;

pub fn list_all_mailboxes(&self) -> Result<Vec<MailboxCapabilityRecord>, NodeError>;

pub fn list_all_aliases(&self) -> Result<Vec<MailAliasRecord>, NodeError>;

pub fn list_mailboxes_by_owner(
        &self,
        subject_did: &str,
    ) -> Result<Vec<MailboxCapabilityRecord>, NodeError>;

pub fn get_policy(
        &self,
        mailbox_id: &str,
        version: Option<u64>,
    ) -> Result<Option<MailboxPolicyRecord>, NodeError>;

pub fn list_all_policies(&self) -> Result<Vec<MailboxPolicyRecord>, NodeError>;

pub fn list_keys(
        &self,
        mailbox_id: &str,
        purpose: Option<&str>,
    ) -> Result<Vec<MailPublicKeyRecord>, NodeError>;

pub fn list_all_keys(&self) -> Result<Vec<MailPublicKeyRecord>, NodeError>;

pub fn get_key(
        &self,
        mailbox_id: &str,
        key_id: &str,
    ) -> Result<Option<MailPublicKeyRecord>, NodeError>;

pub fn get_delivery(
        &self,
        delivery_id: &str,
    ) -> Result<Option<DeliveryCommitmentRecord>, NodeError>;

pub fn list_all_deliveries(&self) -> Result<Vec<DeliveryCommitmentRecord>, NodeError>;

pub fn list_deliveries_by_recipient(
        &self,
        mailbox_id: &str,
    ) -> Result<Vec<DeliveryCommitmentRecord>, NodeError>;

pub fn list_deliveries_by_sender(
        &self,
        sender_route_id: &str,
    ) -> Result<Vec<DeliveryCommitmentRecord>, NodeError>;

pub fn get_economics(
        &self,
        sender_route_id: &str,
        recipient_mailbox_id: &str,
    ) -> Result<Option<SenderEconomicsRecord>, NodeError>;

pub fn list_all_economics(&self) -> Result<Vec<SenderEconomicsRecord>, NodeError>;

pub fn get_delegation(&self, grant_id: &str) -> Result<Option<MailDelegationGrant>, NodeError>;

pub fn list_all_delegations(&self) -> Result<Vec<MailDelegationGrant>, NodeError>;

pub fn list_delegations(
        &self,
        mailbox_id: &str,
    ) -> Result<Vec<MailDelegationGrant>, NodeError>;

pub fn get_abuse(&self, abuse_id: &str) -> Result<Option<AbuseReport>, NodeError>;

pub fn list_all_abuse(&self) -> Result<Vec<AbuseReport>, NodeError>;

pub fn has_nonce(&self, actor_did: &str, nonce: &str) -> Result<bool, NodeError>;

pub fn get_sns_name(&self, name_hash: &str) -> Result<Option<SnsNameRecord>, NodeError>;

pub fn list_all_sns_names(&self) -> Result<Vec<SnsNameRecord>, NodeError>;

pub fn get_sns_records(&self, name_hash: &str) -> Result<Vec<SnsResolverRecord>, NodeError>;

pub fn list_all_sns_records(&self) -> Result<Vec<SnsResolverRecord>, NodeError>;

pub fn list_all_sns_delegations(&self) -> Result<Vec<NameDelegation>, NodeError>;

pub fn get_sns_registration_commitment(
        &self,
        commitment: &str,
    ) -> Result<Option<SnsNameRegistrationCommitment>, NodeError>;

pub fn list_all_sns_registration_commitments(
        &self,
    ) -> Result<Vec<SnsNameRegistrationCommitment>, NodeError>;

pub fn get_sns_sealed_bid(
        &self,
        commitment: &str,
    ) -> Result<Option<SnsSealedBidCommitment>, NodeError>;

pub fn list_all_sns_sealed_bids(&self) -> Result<Vec<SnsSealedBidCommitment>, NodeError>;

pub fn get_sns_auction(&self, auction_id: &str) -> Result<Option<SnsAuctionRecord>, NodeError>;

pub fn list_all_sns_auctions(&self) -> Result<Vec<SnsAuctionRecord>, NodeError>;

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