codec.rs (5915B)
1 use super::*; 2 pub(in crate::workspace::stock) struct Retained { 3 pub frame: ledger::Retained, 4 pub report: StockSigningAttempt, 5 projection: Projection, 6 } 7 pub(super) fn head(header: &ledger::Header, body: &[u8]) -> radroots_domain::CheckpointDigest { 8 let mut hash = Sha256::new(); 9 hash.update(b"radroots.seller_stock.signing_claim_chain.v1\0"); 10 hash.update(header.namespace.workspace_id().as_bytes()); 11 hash.update(header.namespace.authority().executor_id().as_bytes()); 12 hash.update( 13 header 14 .namespace 15 .authority() 16 .generation() 17 .get() 18 .to_be_bytes(), 19 ); 20 hash.update(header.namespace.route_digest().as_bytes()); 21 hash.update(header.actor.participant().as_bytes()); 22 hash.update( 23 header 24 .actor 25 .grant_id() 26 .map(|value| *value.as_bytes()) 27 .unwrap_or([0; 32]), 28 ); 29 hash.update(header.operation.as_bytes()); 30 hash.update(header.digest.as_bytes()); 31 hash.update(header.transaction.as_bytes()); 32 hash.update(header.revision.get().to_be_bytes()); 33 hash.update([u8::from(header.previous.is_some())]); 34 hash.update( 35 header 36 .previous 37 .map(|value| *value.as_bytes()) 38 .unwrap_or([0; 32]), 39 ); 40 hash.update(Sha256::digest(body)); 41 radroots_domain::CheckpointDigest::from_bytes(hash.finalize().into()) 42 } 43 pub(in crate::workspace::stock) async fn read_entry( 44 connection: &mut SqliteConnection, 45 input: &AttachmentInput, 46 crypto: &WorkspaceCrypto, 47 entry: OperationId, 48 ) -> Result<Option<Retained>, OperationError> { 49 let Some(frame) = ledger::read(connection, input, crypto, entry).await? else { 50 return Ok(None); 51 }; 52 if frame.header.family != ledger::Family::SigningClaim || frame.body.len() > 16 * 1024 { 53 return Err(OperationError::RecoveryRequired); 54 } 55 let body: Body = super::super::super::closed_record(&frame.body) 56 .map_err(|_| OperationError::RecoveryRequired)?; 57 let plan = Box::pin(signing_plan::read_entry( 58 connection, 59 input, 60 crypto, 61 body.plan_entry, 62 )) 63 .await? 64 .ok_or(OperationError::RecoveryRequired)?; 65 let selected = intent(&plan.bound, body.recipient, CancellationSignal::new())?; 66 let header = &frame.header; 67 if body.version != 1 68 || header.related_operation != Some(body.operation) 69 || header.digest != plan.bound.plan().command_digest() 70 || body.operation != plan.bound.plan().operation_id() 71 || header.actor != plan.frame.header.actor 72 || header.order != plan.frame.header.order 73 || header.revision <= plan.frame.header.revision 74 || body.plan_transaction != plan.frame.header.transaction 75 || body.plan_head != plan.frame.header.head 76 || body.plan_digest != *plan.bound.plan().digest() 77 || body.intent != *selected.binding().digest() 78 || body.deadline != plan.bound.preparation().first_issue_deadline() 79 || body.claimed_at < plan.bound.bound_at() 80 || body.claimed_at >= body.deadline 81 || head(header, &frame.body) != header.head 82 { 83 return Err(OperationError::RecoveryRequired); 84 } 85 let projection = Projection { 86 operation: body.operation, 87 recipient: body.recipient, 88 kind: ProjectionKind::Claim, 89 }; 90 let report = StockSigningAttempt { 91 bound: Arc::new(plan.bound), 92 recipient: body.recipient, 93 entry: EntryIdentity { 94 operation: header.operation, 95 revision: header.revision, 96 head: header.head, 97 protected_digest: Sha256::digest(&frame.protected).into(), 98 }, 99 transaction: header.transaction, 100 claimed_at: body.claimed_at, 101 binding: selected.binding(), 102 }; 103 let retained = Retained { 104 frame, 105 report, 106 projection, 107 }; 108 retained.confirm(connection).await?; 109 Ok(Some(retained)) 110 } 111 impl Retained { 112 pub(in crate::workspace::stock) fn identity(&self) -> EntryIdentity { 113 self.report.entry 114 } 115 pub(in crate::workspace::stock) async fn confirm( 116 &self, 117 connection: &mut SqliteConnection, 118 ) -> Result<(), OperationError> { 119 ledger::confirm_header(connection, &self.frame.header, &self.frame.protected).await?; 120 ledger::confirm_parts( 121 connection, 122 self.frame.header.actor, 123 self.frame.header.operation, 124 self.frame.parts_witness, 125 self.frame.header.parts, 126 ) 127 .await?; 128 self.projection 129 .confirm( 130 connection, 131 self.frame.header.actor.participant(), 132 self.frame.header.operation, 133 ) 134 .await?; 135 let count: i64 = sqlx::query_scalar( 136 "SELECT count(*) FROM stock_movements WHERE actor=? AND operation_id=?", 137 ) 138 .bind(self.frame.header.actor.participant().as_bytes().as_slice()) 139 .bind(self.frame.header.operation.as_bytes().as_slice()) 140 .fetch_one(connection) 141 .await 142 .map_err(|_| OperationError::RecoveryRequired)?; 143 if count != 0 { 144 return Err(OperationError::RecoveryRequired); 145 } 146 Ok(()) 147 } 148 pub(in crate::workspace::stock) fn into_history(self) -> ledger::HistoryEntry { 149 ledger::HistoryEntry { 150 deficit: None, 151 delivery: None, 152 envelope: None, 153 aborted: None, 154 preparation: None, 155 local_record: None, 156 installation: None, 157 header: self.frame.header, 158 protected: self.frame.protected, 159 parts_witness: self.frame.parts_witness, 160 pools: vec![], 161 mapping: None, 162 movements: vec![], 163 signing: Some(self.projection), 164 } 165 } 166 }