sigil-node · labor_durable

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct LaborEvent {
/// Block at which the event was emitted.

pub block_height: u64,
/// Sequence number within the block (for ordering).

pub seq: u64,
/// Contract ID this event relates to.

pub contract_id: String,
/// Kind of event (e.g. `"contract_created"`, `"milestone_released"`).

pub kind: String,
/// Free-form JSON payload (actor DIDs, amounts, etc.).

pub payload: serde_json::Value
}

pub struct DurableLaborStore {

}

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

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

pub fn put_contract(&self, contract: &LaborContract) -> Result<(), NodeError>;

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

pub fn list_contracts_by_state(
        &self,
        state: ContractState,
    ) -> Result<Vec<LaborContract>, NodeError>;

pub fn get_job(&self, job_id: &str) -> Result<Option<LaborJob>, NodeError>;

pub fn put_job(&self, job: &LaborJob) -> Result<(), NodeError>;

pub fn list_all_jobs(&self) -> Result<Vec<LaborJob>, NodeError>;

pub fn get_bid(&self, bid_id: &str) -> Result<Option<LaborBid>, NodeError>;

pub fn put_bid(&self, bid: &LaborBid) -> Result<(), NodeError>;

pub fn list_all_bids(&self) -> Result<Vec<LaborBid>, NodeError>;

pub fn list_job_bids(&self, job_id: &str) -> Result<Vec<String>, NodeError>;

pub fn get_milestone(
        &self,
        contract_id: &str,
        milestone_index: u32,
    ) -> Result<Option<Milestone>, NodeError>;

pub fn put_milestone(&self, contract_id: &str, milestone: &Milestone) -> Result<(), NodeError>;

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

pub fn list_milestones_by_state(
        &self,
        contract_id: &str,
        state: MilestoneState,
    ) -> Result<Vec<Milestone>, NodeError>;

pub fn index_worker_contract(
        &self,
        worker_did: &str,
        contract_id: &str,
    ) -> Result<(), NodeError>;

pub fn list_worker_contracts(&self, worker_did: &str) -> Result<Vec<String>, NodeError>;

pub fn put_dispute_index(&self, dispute_id: &str, contract_id: &str) -> Result<(), NodeError>;

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

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

pub fn put_dispute(&self, dispute: &Dispute) -> Result<(), NodeError>;

pub fn list_disputes(&self, state: Option<DisputeState>) -> Result<Vec<Dispute>, NodeError>;

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

pub fn put_escrow(&self, escrow: &LaborEscrow) -> Result<(), NodeError>;

pub fn list_all_escrows(&self) -> Result<Vec<LaborEscrow>, NodeError>;

pub fn append_event(&self, event: &LaborEvent) -> Result<(), NodeError>;

pub fn list_events_in_range(
        &self,
        from_height: u64,
        to_height: u64,
    ) -> Result<Vec<LaborEvent>, NodeError>;

pub fn get_offer(&self, offer_id: &str) -> Result<Option<BountyOffer>, NodeError>;

pub fn put_offer(&self, offer: &BountyOffer) -> Result<(), NodeError>;

pub fn list_offers(&self, state: Option<BountyState>) -> Result<Vec<BountyOffer>, NodeError>;

pub fn get_claim(&self, claim_id: &str) -> Result<Option<BountyClaim>, NodeError>;

pub fn put_claim(&self, claim: &BountyClaim) -> Result<(), NodeError>;

pub fn list_claims(
        &self,
        offer_id: Option<&str>,
        claimant_did: Option<&str>,
    ) -> Result<Vec<BountyClaim>, NodeError>;

pub fn get_claim_index(
        &self,
        offer_id: &str,
        claimant_did: &str,
        deliverable_hash: &str,
    ) -> Result<Option<String>, NodeError>;

pub fn get_claim_attestation(
        &self,
        attestation_id: &str,
    ) -> Result<Option<ClaimAttestation>, NodeError>;

pub fn put_claim_attestation(&self, attestation: &ClaimAttestation) -> Result<(), NodeError>;

pub fn list_claim_attestations(
        &self,
        claim_id: &str,
    ) -> Result<Vec<ClaimAttestation>, NodeError>;

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

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

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

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

pub type ArcLaborStore = Arc<DurableLaborStore>;

#[derive(Clone)]
pub enum LaborBatchOp {
    /// Insert or replace a labor job posting.
    ///
    /// Boxed to reduce enum variant size — `LaborJob` is large.
    PutJob(Box<LaborJob>),
    /// Insert or replace a labor bid.
    ///
    /// Boxed to reduce enum variant size — `LaborBid` is large.
    PutBid(Box<LaborBid>),
    /// Write a job→bid index entry (presence marker).
    IndexJobBid { job_id: String, bid_id: String },
    /// Insert or replace a labor contract record.
    ///
    /// Boxed to reduce enum variant size — `LaborContract` is large.
    PutContract(Box<LaborContract>),
    /// Insert or replace a single milestone for a contract.
    PutMilestone {
        contract_id: String,
        milestone: Milestone,
    },
    /// Write a worker→contract index entry (presence marker).
    IndexWorker {
        worker_did: String,
        contract_id: String,
    },
    /// Write a dispute_id → contract_id index entry.
    IndexDispute {
        dispute_id: String,
        contract_id: String,
    },
    /// Insert or replace a full dispute record.
    PutDispute(Box<Dispute>),
    /// Insert or replace exact escrow accounting for a contract.
    PutEscrow(Box<LaborEscrow>),
    /// Append an immutable audit event.
    AppendEvent(LaborEvent),
    /// Insert or replace an open bounty offer.
    PutOffer(Box<BountyOffer>),
    /// Insert or replace an open bounty claim.
    PutClaim(Box<BountyClaim>),
    /// Write the claimant+deliverable replay guard for a claim.
    IndexClaim {
        offer_id: String,
        claimant_did: String,
        deliverable_hash: String,
        claim_id: String,
    },
    /// Write deterministic per-offer claim ordering.
    IndexOfferClaim {
        offer_id: String,
        claim_sequence: u32,
        claim_id: String,
    },
    /// Insert or replace a claim attestation and its claim index.
    PutClaimAttestation(Box<ClaimAttestation>),
}

#[derive(Default)]
pub struct LaborWriteBatch {

}

pub fn new() -> Self;

pub fn put_job(&mut self, job: LaborJob);

pub fn put_bid(&mut self, bid: LaborBid);

pub fn index_job_bid(&mut self, job_id: impl Into<String>, bid_id: impl Into<String>);

pub fn put_contract(&mut self, contract: LaborContract);

pub fn put_milestone(&mut self, contract_id: impl Into<String>, milestone: Milestone);

pub fn index_worker(&mut self, worker_did: impl Into<String>, contract_id: impl Into<String>);

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

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

pub fn put_escrow(&mut self, escrow: LaborEscrow);

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

pub fn put_offer(&mut self, offer: BountyOffer);

pub fn put_claim(&mut self, claim: BountyClaim);

pub fn index_claim(
        &mut self,
        offer_id: impl Into<String>,
        claimant_did: impl Into<String>,
        deliverable_hash: impl Into<String>,
        claim_id: impl Into<String>,
    );

pub fn index_offer_claim(
        &mut self,
        offer_id: impl Into<String>,
        claim_sequence: u32,
        claim_id: impl Into<String>,
    );

pub fn put_claim_attestation(&mut self, attestation: ClaimAttestation);

pub fn len(&self) -> usize;

pub fn is_empty(&self) -> bool;

pub fn into_ops(self) -> Vec<LaborBatchOp>;