sigil-node · storage_market_durable

pub type ArcStorageMarketStore = Arc<DurableStorageMarketStore>;

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

#[derive(Debug, Clone)]
pub enum StorageMarketBatchOp {
    PutProvider(Arc<StorageProviderRecord>),
    PutRequest(Arc<StoragePinRequest>),
    IndexRequestOwner {
        owner_did: String,
        request_id: String,
    },
    PutContract(Arc<StoragePinContract>),
    IndexContractProvider {
        provider_did: String,
        contract_id: String,
    },
    IndexContractRequest {
        request_id: String,
        contract_id: String,
    },
    PutReceipt(Arc<StoragePinReceipt>),
    IndexReceiptContract {
        contract_id: String,
        receipt_id: String,
    },
    PutChallenge(Arc<StorageChallengeRecord>),
    IndexChallengeContract {
        contract_id: String,
        challenge_id: String,
    },
    AppendEvent(Arc<StorageMarketEvent>),
}

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

pub fn new() -> Self;

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

pub fn put_provider(&mut self, record: StorageProviderRecord);

pub fn put_request(&mut self, record: StoragePinRequest);

pub fn put_contract(&mut self, record: StoragePinContract);

pub fn put_receipt(&mut self, record: StoragePinReceipt);

pub fn put_challenge(&mut self, record: StorageChallengeRecord);

pub struct DurableStorageMarketStore {

}

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

pub fn get_provider(
        &self,
        provider_did: &str,
    ) -> Result<Option<StorageProviderRecord>, NodeError>;

pub fn list_providers(&self) -> Result<Vec<StorageProviderRecord>, NodeError>;

pub fn get_request(&self, request_id: &str) -> Result<Option<StoragePinRequest>, NodeError>;

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

pub fn get_contract(&self, contract_id: &str) -> Result<Option<StoragePinContract>, NodeError>;

pub fn list_contracts_by_provider(
        &self,
        provider_did: &str,
    ) -> Result<Vec<StoragePinContract>, NodeError>;

pub fn list_contracts_by_request(
        &self,
        request_id: &str,
    ) -> Result<Vec<StoragePinContract>, NodeError>;

pub fn get_receipt(&self, receipt_id: &str) -> Result<Option<StoragePinReceipt>, NodeError>;

pub fn list_receipts_by_contract(
        &self,
        contract_id: &str,
    ) -> Result<Vec<StoragePinReceipt>, NodeError>;

pub fn get_challenge(
        &self,
        challenge_id: &str,
    ) -> Result<Option<StorageChallengeRecord>, NodeError>;

pub fn list_challenges_by_contract(
        &self,
        contract_id: &str,
    ) -> Result<Vec<StorageChallengeRecord>, NodeError>;

pub fn list_all_requests(&self) -> Result<Vec<StoragePinRequest>, NodeError>;

pub fn list_all_contracts(&self) -> Result<Vec<StoragePinContract>, NodeError>;

pub fn list_all_receipts(&self) -> Result<Vec<StoragePinReceipt>, NodeError>;

pub fn list_all_challenges(&self) -> Result<Vec<StorageChallengeRecord>, NodeError>;

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