pub use statechronicle_commit::durable::{
CommittedMutation, DurableError, DurableOutcome, MutationIdentity, RecoveryOutcome, recover,
};
pub use statechronicle_executor::preparation::{
PreparationConfig, PreparationPorts, PreparedBatch, PreparedMutation, Preparer,
};
use statechronicle_commit::durable::commit_verified;
use statechronicle_commit::error::CommitError;
use statechronicle_commit::persist::{
CommittedEvent, DurableCommitRequest, SignedCommitVerifier, projections_for,
validate_tenant_commit,
};
use statechronicle_commit::roots::event_root;
use statechronicle_commit::sign::{CommitSigner, sign_commit_with_signer};
use statechronicle_domain::commit::Commit;
use statechronicle_domain::intent::KeyId;
use statechronicle_domain::signed::Signed;
use statechronicle_domain::state::StateProjection;
use statechronicle_ports::authorization::Authorizer;
use statechronicle_ports::ledger_store::{LedgerRecovery, OutboxRecord};
#[derive(Debug)]
pub struct SignedMutation {
prepared: PreparedMutation,
commit: Signed<Commit>,
projections: Vec<StateProjection>,
outbox: Vec<OutboxRecord>,
}
impl SignedMutation {
pub fn sign(
prepared: PreparedMutation,
body: &Commit,
key_id: KeyId,
signer: &dyn CommitSigner,
outbox: Vec<OutboxRecord>,
) -> Result<Self, CommitError> {
let tenant = validate_tenant_commit(body)?;
if *tenant != prepared.validated().intent.tenant_id {
return Err(CommitError::MixedTenant);
}
let count = u64::try_from(prepared.events().len())
.map_err(|error| CommitError::InvalidEvent(error.to_string()))?;
if count != body.event_count || event_root(prepared.events())? != body.event_merkle_root {
return Err(CommitError::EventRootMismatch);
}
let commit = sign_commit_with_signer(body, key_id, signer)?;
let projections = projections_for(&commit.body.commit_id, &entries(&prepared));
Ok(Self {
prepared,
commit,
projections,
outbox,
})
}
pub const fn prepared(&self) -> &PreparedMutation {
&self.prepared
}
pub const fn signed_commit(&self) -> &Signed<Commit> {
&self.commit
}
pub async fn commit<S: LedgerRecovery + ?Sized>(
&self,
ledger: &S,
authorizer: &dyn Authorizer,
verifier: &dyn SignedCommitVerifier,
) -> Result<DurableOutcome, DurableError> {
commit_verified(
ledger,
authorizer,
verifier,
DurableCommitRequest {
principal: self.prepared.principal(),
intent: &self.prepared.validated().intent,
payload_digest: self.prepared.payload_digest(),
entries: &entries(&self.prepared),
commit: &self.commit,
projections: &self.projections,
outbox: &self.outbox,
},
)
.await
}
}
fn entries(prepared: &PreparedMutation) -> Vec<CommittedEvent<'_>> {
prepared
.events()
.iter()
.map(|event| CommittedEvent {
event,
state_type: event.after.state.state_type(),
})
.collect()
}
pub use statechronicle_commit::durable_batch::{
BatchIdentity, BatchMember, BatchRecoveryOutcome, CommittedBatch, DurableBatchError,
DurableBatchOutcome, recover_batch,
};
use statechronicle_commit::durable_batch::{DurableBatchRequest, commit_batch_verified};
use statechronicle_ports::ledger_batch::LedgerBatchRecovery;
#[derive(Debug)]
pub struct SignedBatch {
prepared: PreparedBatch,
commit: Signed<Commit>,
projections: Vec<StateProjection>,
outbox: Vec<OutboxRecord>,
}
impl SignedBatch {
pub fn sign(
prepared: PreparedBatch,
body: &Commit,
key_id: KeyId,
signer: &dyn CommitSigner,
outbox: Vec<OutboxRecord>,
) -> Result<Self, CommitError> {
let tenant = validate_tenant_commit(body)?;
if prepared
.mutations()
.iter()
.any(|member| member.validated().intent.tenant_id != *tenant)
{
return Err(CommitError::MixedTenant);
}
let events: Vec<_> = prepared.events().cloned().collect();
let count = u64::try_from(events.len())
.map_err(|error| CommitError::InvalidEvent(error.to_string()))?;
if count != body.event_count || event_root(&events)? != body.event_merkle_root {
return Err(CommitError::EventRootMismatch);
}
let commit = sign_commit_with_signer(body, key_id, signer)?;
let projections = projections_for(&commit.body.commit_id, &batch_entries(&prepared));
Ok(Self {
prepared,
commit,
projections,
outbox,
})
}
pub const fn prepared(&self) -> &PreparedBatch {
&self.prepared
}
pub const fn signed_commit(&self) -> &Signed<Commit> {
&self.commit
}
pub async fn commit<S: LedgerBatchRecovery + ?Sized>(
&self,
ledger: &S,
authorizer: &dyn Authorizer,
verifier: &dyn SignedCommitVerifier,
) -> Result<DurableBatchOutcome, DurableBatchError> {
commit_batch_verified(
ledger,
authorizer,
verifier,
DurableBatchRequest {
members: &batch_members(&self.prepared),
entries: &batch_entries(&self.prepared),
commit: &self.commit,
projections: &self.projections,
outbox: &self.outbox,
},
)
.await
}
pub async fn recover<S: LedgerBatchRecovery + ?Sized>(
&self,
ledger: &S,
authorizer: &dyn Authorizer,
verifier: &dyn SignedCommitVerifier,
) -> Result<BatchRecoveryOutcome, DurableBatchError> {
recover_batch(ledger, authorizer, verifier, &batch_members(&self.prepared)).await
}
}
fn batch_members(prepared: &PreparedBatch) -> Vec<BatchMember<'_>> {
prepared
.mutations()
.iter()
.map(|member| BatchMember {
principal: member.principal(),
intent: &member.validated().intent,
payload_digest: member.payload_digest(),
})
.collect()
}
fn batch_entries(prepared: &PreparedBatch) -> Vec<CommittedEvent<'_>> {
prepared
.events()
.map(|event| CommittedEvent {
event,
state_type: event.after.state.state_type(),
})
.collect()
}