codec.rs (8863B)
1 //! Fixed prefix followed by original exact JSON, without escape inflation. 2 use super::*; 3 const PREFIX: usize = 117; 4 const MAGIC: &[u8; 8] = b"RDSTKS1\0"; 5 pub(super) fn encode( 6 original: &claim::codec::Retained, 7 supplied: &StockEvidenceRequest, 8 ) -> Vec<u8> { 9 let mut out = Vec::with_capacity(PREFIX + supplied.with_json(str::len)); 10 out.extend_from_slice(MAGIC); 11 out.extend_from_slice(original.frame.header.operation.as_bytes()); 12 out.extend_from_slice(original.frame.header.transaction.as_bytes()); 13 out.extend_from_slice(original.frame.header.head.as_bytes()); 14 out.push(u8::from(supplied.observed_at_unix_ms().is_some())); 15 out.extend_from_slice( 16 &supplied 17 .observed_at_unix_ms() 18 .map(NonZeroU64::get) 19 .unwrap_or(0) 20 .to_be_bytes(), 21 ); 22 out.extend_from_slice(&(supplied.with_json(str::len) as u32).to_be_bytes()); 23 supplied.with_json(|raw| out.extend_from_slice(raw.as_bytes())); 24 out 25 } 26 pub(super) fn head(header: &ledger::Header, body: &[u8]) -> radroots_domain::CheckpointDigest { 27 let mut hash = Sha256::new(); 28 hash.update(b"radroots.seller_stock.signing_evidence_chain.v1\0"); 29 hash.update(header.namespace.workspace_id().as_bytes()); 30 hash.update(header.namespace.authority().executor_id().as_bytes()); 31 hash.update( 32 header 33 .namespace 34 .authority() 35 .generation() 36 .get() 37 .to_be_bytes(), 38 ); 39 hash.update(header.namespace.route_digest().as_bytes()); 40 hash.update(header.actor.participant().as_bytes()); 41 hash.update( 42 header 43 .actor 44 .grant_id() 45 .map(|value| *value.as_bytes()) 46 .unwrap_or([0; 32]), 47 ); 48 hash.update(header.operation.as_bytes()); 49 hash.update(header.digest.as_bytes()); 50 hash.update(header.transaction.as_bytes()); 51 hash.update(header.revision.get().to_be_bytes()); 52 hash.update([u8::from(header.previous.is_some())]); 53 hash.update( 54 header 55 .previous 56 .map(|value| *value.as_bytes()) 57 .unwrap_or([0; 32]), 58 ); 59 hash.update(Sha256::digest(body)); 60 radroots_domain::CheckpointDigest::from_bytes(hash.finalize().into()) 61 } 62 pub(in crate::workspace::stock) struct Retained { 63 pub frame: ledger::Retained, 64 pub value: StockCapturedEvidence, 65 projection: Projection, 66 local_record: Box<radroots_protocol::commerce::DecodedRecord>, 67 } 68 pub(in crate::workspace::stock) async fn read_entry( 69 connection: &mut SqliteConnection, 70 input: &AttachmentInput, 71 crypto: &WorkspaceCrypto, 72 entry: OperationId, 73 ) -> Result<Option<Retained>, OperationError> { 74 let Some(frame) = ledger::read(connection, input, crypto, entry).await? else { 75 return Ok(None); 76 }; 77 Ok(Some( 78 Box::pin(read_frame(connection, input, crypto, frame)).await?, 79 )) 80 } 81 async fn read_frame( 82 connection: &mut SqliteConnection, 83 input: &AttachmentInput, 84 crypto: &WorkspaceCrypto, 85 frame: ledger::Retained, 86 ) -> Result<Retained, OperationError> { 87 let body = frame.body.as_slice(); 88 if frame.header.family != ledger::Family::SigningEvidence 89 || !(PREFIX..=PREFIX + MAX_RAW).contains(&body.len()) 90 || &body[..8] != MAGIC 91 { 92 return Err(OperationError::RecoveryRequired); 93 } 94 let array = |start, end| { 95 body[start..end] 96 .try_into() 97 .map_err(|_| OperationError::RecoveryRequired) 98 }; 99 let claim = OperationId::from_bytes(array(8, 40)?); 100 let transaction = TransactionId::from_bytes(array(40, 72)?); 101 let original_head = radroots_domain::CheckpointDigest::from_bytes(array(72, 104)?); 102 let at = u64::from_be_bytes( 103 body[105..113] 104 .try_into() 105 .map_err(|_| OperationError::RecoveryRequired)?, 106 ); 107 let observed = match (body[104], at) { 108 (0, 0) => None, 109 (1, n) if n > 0 => NonZeroU64::new(n), 110 _ => return Err(OperationError::RecoveryRequired), 111 }; 112 let length = u32::from_be_bytes( 113 body[113..PREFIX] 114 .try_into() 115 .map_err(|_| OperationError::RecoveryRequired)?, 116 ) as usize; 117 if length != body.len() - PREFIX { 118 return Err(OperationError::RecoveryRequired); 119 } 120 let raw = std::str::from_utf8(&body[PREFIX..]).map_err(|_| OperationError::RecoveryRequired)?; 121 let original = Box::pin(claim::read_entry(connection, input, crypto, claim)) 122 .await? 123 .ok_or(OperationError::RecoveryRequired)?; 124 let header = &frame.header; 125 if original.frame.header.transaction != transaction 126 || original.frame.header.head != original_head 127 || header.actor != original.frame.header.actor 128 || header.related_operation != original.frame.header.related_operation 129 || header.order != original.frame.header.order 130 || header.digest != original.frame.header.digest 131 || header.revision <= original.frame.header.revision 132 || head(header, body) != header.head 133 { 134 return Err(OperationError::RecoveryRequired); 135 } 136 let selected = claim::intent( 137 original.report.bound_plan(), 138 original.report.recipient(), 139 CancellationSignal::new(), 140 )?; 141 let (_, kind) = SigningOutcome::capture(&selected, raw.into(), observed).into_parts(); 142 let OutcomeKind::Obtained(signed) = kind else { 143 return Err(OperationError::RecoveryRequired); 144 }; 145 if signed.observed_at_unix_ms() != observed { 146 return Err(OperationError::RecoveryRequired); 147 } 148 let digest = Sha256::digest(raw.as_bytes()).into(); 149 let rumor = original.report.bound_plan().preparation().rumor(); 150 let logical = 151 radroots_protocol::private_rumor::DecodedRumor::decode(rumor.protected_wire().as_bytes()) 152 .map_err(|_| OperationError::RecoveryRequired)?; 153 let local_record = radroots_protocol::commerce::decode(logical.protected_content().as_bytes()) 154 .map_err(|_| OperationError::RecoveryRequired)?; 155 if local_record.record_id() != rumor.record_id() || logical.event_id() != rumor.event_id() { 156 return Err(OperationError::RecoveryRequired); 157 } 158 let projection = Projection { 159 operation: original.report.bound_plan().plan().operation_id(), 160 recipient: original.report.recipient(), 161 kind: ProjectionKind::Obtained(digest), 162 }; 163 let receipt = StockEvidenceReceipt::from_committed_store( 164 CommitAttempt::new( 165 input.workspace_id(), 166 projection.operation, 167 header.digest, 168 Some(header.transaction), 169 ), 170 original.report.attempt_id(), 171 projection.recipient, 172 digest, 173 observed, 174 )?; 175 let value = StockCapturedEvidence { 176 receipt, 177 raw: Zeroizing::new(raw.into()), 178 }; 179 let retained = Retained { 180 frame, 181 value, 182 projection, 183 local_record: Box::new(local_record), 184 }; 185 retained.confirm(connection).await?; 186 Ok(retained) 187 } 188 impl Retained { 189 pub(in crate::workspace::stock) async fn confirm( 190 &self, 191 connection: &mut SqliteConnection, 192 ) -> Result<(), OperationError> { 193 ledger::confirm_header(connection, &self.frame.header, &self.frame.protected).await?; 194 ledger::confirm_parts( 195 connection, 196 self.frame.header.actor, 197 self.frame.header.operation, 198 self.frame.parts_witness, 199 self.frame.header.parts, 200 ) 201 .await?; 202 self.projection 203 .confirm( 204 connection, 205 self.frame.header.actor.participant(), 206 self.frame.header.operation, 207 ) 208 .await?; 209 let count: i64 = sqlx::query_scalar( 210 "SELECT count(*) FROM stock_movements WHERE actor=? AND operation_id=?", 211 ) 212 .bind(self.frame.header.actor.participant().as_bytes().as_slice()) 213 .bind(self.frame.header.operation.as_bytes().as_slice()) 214 .fetch_one(connection) 215 .await 216 .map_err(|_| OperationError::RecoveryRequired)?; 217 if count != 0 { 218 return Err(OperationError::RecoveryRequired); 219 } 220 Ok(()) 221 } 222 pub(in crate::workspace::stock) fn into_history(self) -> ledger::HistoryEntry { 223 ledger::HistoryEntry { 224 deficit: None, 225 delivery: None, 226 envelope: None, 227 aborted: None, 228 preparation: None, 229 installation: None, 230 header: self.frame.header, 231 protected: self.frame.protected, 232 parts_witness: self.frame.parts_witness, 233 pools: vec![], 234 mapping: None, 235 movements: vec![], 236 signing: Some(self.projection), 237 local_record: Some(self.local_record), 238 } 239 } 240 }