sigil-node · crucible_durable

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CrucibleEvent {
pub block_height: u64,
pub seq: u64,
pub run_id: String,
pub kind: String,
pub payload: serde_json::Value
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum CrucibleBatchOp {
    PutRun(TrainingRun),
    PutRolloutBatch(RolloutBatchCommitment),
    PutRewardAttestation(RewardBatchAttestation),
    PutWeights(WeightPublicationRecord),
    PutSlash(TrainingSlashRecord),
    AppendEvent(CrucibleEvent),
    PutBalance(String, u64),
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CrucibleWriteBatch {

}

pub fn new() -> Self;

pub fn put_run(&mut self, run: TrainingRun);

pub fn put_rollout_batch(&mut self, batch: RolloutBatchCommitment);

pub fn put_reward_attestation(&mut self, attestation: RewardBatchAttestation);

pub fn put_weights(&mut self, weights: WeightPublicationRecord);

pub fn put_slash(&mut self, slash: TrainingSlashRecord);

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

pub fn put_balance(&mut self, did: impl Into<String>, amount: u64);

pub fn ops(&self) -> &[CrucibleBatchOp];

pub struct DurableCrucibleStore {

}

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

pub fn put_run(&self, run: &TrainingRun) -> Result<(), NodeError>;

pub fn get_run(&self, run_id: &str) -> Result<Option<TrainingRun>, NodeError>;

pub fn list_runs(&self) -> Result<Vec<TrainingRun>, NodeError>;

pub fn get_rollout_batch(
        &self,
        run_id: &str,
        batch_id: &str,
    ) -> Result<Option<RolloutBatchCommitment>, NodeError>;

pub fn list_rollout_batches(
        &self,
        run_id: &str,
    ) -> Result<Vec<RolloutBatchCommitment>, NodeError>;

pub fn get_weights(
        &self,
        run_id: &str,
        model_root: &SigilHash,
    ) -> Result<Option<WeightPublicationRecord>, NodeError>;

pub fn list_weights(&self, run_id: &str) -> Result<Vec<WeightPublicationRecord>, NodeError>;

pub fn get_reward_attestation(
        &self,
        run_id: &str,
        attestation_id: &str,
    ) -> Result<Option<RewardBatchAttestation>, NodeError>;

pub fn list_reward_attestations(
        &self,
        run_id: &str,
    ) -> Result<Vec<RewardBatchAttestation>, NodeError>;

pub fn get_slash(
        &self,
        run_id: &str,
        slash_id: &str,
    ) -> Result<Option<TrainingSlashRecord>, NodeError>;

pub fn list_slashes(&self, run_id: &str) -> Result<Vec<TrainingSlashRecord>, NodeError>;

pub fn list_events(&self, run_id: Option<&str>) -> Result<Vec<CrucibleEvent>, NodeError>;

pub fn put_balance(&self, did: &str, amount: u64) -> Result<(), NodeError>;

pub fn get_balance(&self, did: &str) -> Result<Option<u64>, NodeError>;

pub fn list_balances(&self) -> Result<Vec<(String, u64)>, NodeError>;

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

pub type ArcCrucibleStore = Arc<DurableCrucibleStore>;