codec.rs (13743B)
1 //! Fixed original source references and bounded exact outer bytes. 2 use super::*; 3 use nostr::JsonUtil; 4 use std::num::NonZeroU64; 5 const MAGIC: &[u8; 8] = b"RDSTE01\0"; 6 const PREFIX: usize = 213; 7 const MAX_RAW: usize = 65536; 8 9 pub(super) struct Original { 10 pub installation: inventory::installation::Retained, 11 pub evidence: issuance::evidence::Retained, 12 } 13 impl Original { 14 pub(super) async fn load( 15 turn: &mut Turn<'_>, 16 request: &StockEnvelopeRequest, 17 ) -> Result<Self, OperationError> { 18 let entry:Option<Vec<u8>>=sqlx::query_scalar("SELECT installation_entry FROM stock_publication_work WHERE actor=? AND operation_id=? AND recipient=?") 19 .bind(turn.selected.participant().as_bytes().as_slice()).bind(request.operation_id().as_bytes().as_slice()).bind(request.recipient().as_bytes().as_slice()) 20 .fetch_optional(&mut *turn.connection).await.map_err(|_|OperationError::RecoveryRequired)?; 21 let entry = OperationId::from_bytes( 22 entry 23 .ok_or(OperationError::MissingHistory)? 24 .try_into() 25 .map_err(|_| OperationError::RecoveryRequired)?, 26 ); 27 let installation = Box::pin(inventory::installation::read_entry( 28 turn.connection, 29 turn.selected, 30 turn.crypto, 31 entry, 32 )) 33 .await? 34 .ok_or(OperationError::RecoveryRequired)?; 35 let summary = Box::pin(issuance::evidence::selection::Summary::read( 36 turn.connection, 37 turn.selected.participant(), 38 request.operation_id(), 39 request.recipient(), 40 )) 41 .await?; 42 let selected = summary.first.ok_or(OperationError::MissingHistory)?; 43 let evidence = Box::pin(issuance::evidence::selection::open( 44 turn.connection, 45 turn.selected, 46 turn.crypto, 47 request.operation_id(), 48 request.recipient(), 49 selected, 50 )) 51 .await?; 52 let value = Self { 53 installation, 54 evidence, 55 }; 56 value.validate()?; 57 if value.installation.receipt.attempt().operation_id() != request.operation_id() 58 || value.evidence.value.receipt().attempt().command_digest() != request.command_digest() 59 { 60 return Err(OperationError::InvalidEvidence); 61 } 62 Ok(value) 63 } 64 fn validate(&self) -> Result<(), OperationError> { 65 let installed = &self.installation; 66 let evidence = &self.evidence; 67 let source = evidence.value.receipt(); 68 if installed.receipt.attempt().operation_id() != source.attempt().operation_id() 69 || installed.frame.header.digest != source.attempt().command_digest() 70 || installed.frame.header.order != evidence.frame.header.order 71 || installed.frame.header.actor.participant() 72 != evidence.frame.header.actor.participant() 73 { 74 return Err(OperationError::RecoveryRequired); 75 } 76 let work = installed 77 .receipt 78 .publication_work() 79 .iter() 80 .find(|work| work.recipient() == source.recipient()) 81 .ok_or(OperationError::RecoveryRequired)?; 82 let event = evidence 83 .value 84 .with_json(|raw| nostr::Event::from_json(raw)) 85 .map_err(|_| OperationError::RecoveryRequired)?; 86 if work.seal_id() != &event.id.to_bytes() 87 || work 88 .evidence_digest() 89 .is_some_and(|digest| digest != source.digest()) 90 { 91 return Err(OperationError::RecoveryRequired); 92 } 93 Ok(()) 94 } 95 } 96 fn reference(out: &mut Vec<u8>, header: &ledger::Header) { 97 out.extend_from_slice(header.operation.as_bytes()); 98 out.extend_from_slice(header.transaction.as_bytes()); 99 out.extend_from_slice(header.head.as_bytes()); 100 } 101 pub(super) fn encode( 102 original: &Original, 103 request: &StockEnvelopeRequest, 104 candidate: &PrivateEnvelopeCandidate, 105 ) -> Zeroizing<Vec<u8>> { 106 let mut bytes = Zeroizing::new(Vec::with_capacity(PREFIX + candidate.raw_json().len())); 107 bytes.extend_from_slice(MAGIC); 108 reference(&mut bytes, &original.installation.frame.header); 109 reference(&mut bytes, &original.evidence.frame.header); 110 bytes.push(u8::from(request.observed_at_unix_ms().is_some())); 111 bytes.extend_from_slice( 112 &request 113 .observed_at_unix_ms() 114 .map(NonZeroU64::get) 115 .unwrap_or(0) 116 .to_be_bytes(), 117 ); 118 bytes.extend_from_slice(&(candidate.raw_json().len() as u32).to_be_bytes()); 119 bytes.extend_from_slice(candidate.raw_json().as_bytes()); 120 bytes 121 } 122 pub(super) fn head(header: &ledger::Header, body: &[u8]) -> CheckpointDigest { 123 let mut hash = Sha256::new(); 124 hash.update(b"radroots.seller_stock.envelope_chain.v1\0"); 125 hash.update(header.namespace.workspace_id().as_bytes()); 126 hash.update(header.namespace.authority().executor_id().as_bytes()); 127 hash.update( 128 header 129 .namespace 130 .authority() 131 .generation() 132 .get() 133 .to_be_bytes(), 134 ); 135 hash.update(header.namespace.route_digest().as_bytes()); 136 hash.update(header.actor.participant().as_bytes()); 137 hash.update( 138 header 139 .actor 140 .grant_id() 141 .map(|v| *v.as_bytes()) 142 .unwrap_or([0; 32]), 143 ); 144 hash.update(header.operation.as_bytes()); 145 hash.update(header.digest.as_bytes()); 146 hash.update(header.transaction.as_bytes()); 147 hash.update(header.revision.get().to_be_bytes()); 148 hash.update([u8::from(header.previous.is_some())]); 149 hash.update(header.previous.map(|v| *v.as_bytes()).unwrap_or([0; 32])); 150 hash.update(Sha256::digest(body)); 151 CheckpointDigest::from_bytes(hash.finalize().into()) 152 } 153 pub(in crate::workspace::stock) struct Retained { 154 pub(in crate::workspace::stock) frame: ledger::Retained, 155 pub source: StockEnvelopeSource, 156 pub(super) projection: Projection, 157 pub(super) installation: OperationId, 158 } 159 impl Retained { 160 pub(in crate::workspace::stock) fn installation_entry(&self) -> OperationId { 161 self.installation 162 } 163 pub(in crate::workspace::stock) async fn confirm( 164 &self, 165 connection: &mut SqliteConnection, 166 ) -> Result<(), OperationError> { 167 ledger::confirm_header(connection, &self.frame.header, &self.frame.protected).await?; 168 ledger::confirm_parts( 169 connection, 170 self.frame.header.actor, 171 self.frame.header.operation, 172 self.frame.parts_witness, 173 self.frame.header.parts, 174 ) 175 .await?; 176 self.projection 177 .confirm( 178 connection, 179 self.frame.header.actor.participant(), 180 self.frame.header.operation, 181 ) 182 .await?; 183 let count: i64 = sqlx::query_scalar( 184 "SELECT count(*) FROM stock_movements WHERE actor=? AND operation_id=?", 185 ) 186 .bind(self.frame.header.actor.participant().as_bytes().as_slice()) 187 .bind(self.frame.header.operation.as_bytes().as_slice()) 188 .fetch_one(connection) 189 .await 190 .map_err(|_| OperationError::RecoveryRequired)?; 191 if count != 0 { 192 return Err(OperationError::RecoveryRequired); 193 } 194 Ok(()) 195 } 196 pub(in crate::workspace::stock) fn into_history(self) -> ledger::HistoryEntry { 197 ledger::HistoryEntry { 198 deficit: None, 199 delivery: None, 200 envelope: Some(self.projection), 201 aborted: None, 202 preparation: None, 203 header: self.frame.header, 204 protected: self.frame.protected, 205 parts_witness: self.frame.parts_witness, 206 pools: vec![], 207 mapping: None, 208 movements: vec![], 209 signing: None, 210 installation: None, 211 local_record: None, 212 } 213 } 214 } 215 pub(in crate::workspace::stock) async fn read_entry( 216 connection: &mut SqliteConnection, 217 input: &AttachmentInput, 218 crypto: &WorkspaceCrypto, 219 binding: &WorkspaceBinding, 220 entry: OperationId, 221 ) -> Result<Option<Retained>, OperationError> { 222 let Some(frame) = Box::pin(ledger::read(connection, input, crypto, entry)).await? else { 223 return Ok(None); 224 }; 225 if frame.header.family == ledger::Family::RewrappedEnvelope { 226 return Ok(Some( 227 Box::pin(super::rewrap::decode_entry( 228 connection, input, crypto, binding, frame, 229 )) 230 .await?, 231 )); 232 } 233 Ok(Some( 234 Box::pin(decode_entry(connection, input, crypto, binding, frame)).await?, 235 )) 236 } 237 pub(super) async fn read_original_entry( 238 connection: &mut SqliteConnection, 239 input: &AttachmentInput, 240 crypto: &WorkspaceCrypto, 241 binding: &WorkspaceBinding, 242 entry: OperationId, 243 ) -> Result<Retained, OperationError> { 244 let frame = Box::pin(ledger::read(connection, input, crypto, entry)) 245 .await? 246 .ok_or(OperationError::RecoveryRequired)?; 247 Box::pin(decode_entry(connection, input, crypto, binding, frame)).await 248 } 249 async fn decode_entry( 250 connection: &mut SqliteConnection, 251 input: &AttachmentInput, 252 crypto: &WorkspaceCrypto, 253 binding: &WorkspaceBinding, 254 frame: ledger::Retained, 255 ) -> Result<Retained, OperationError> { 256 let body = frame.body.as_slice(); 257 if frame.header.family != ledger::Family::Envelope 258 || !(PREFIX..=PREFIX + MAX_RAW).contains(&body.len()) 259 || &body[..8] != MAGIC 260 { 261 return Err(OperationError::RecoveryRequired); 262 } 263 let array = |start, end| { 264 body[start..end] 265 .try_into() 266 .map_err(|_| OperationError::RecoveryRequired) 267 }; 268 let installation = Box::pin(inventory::installation::read_entry( 269 connection, 270 input, 271 crypto, 272 OperationId::from_bytes(array(8, 40)?), 273 )) 274 .await? 275 .ok_or(OperationError::RecoveryRequired)?; 276 let evidence = Box::pin(issuance::evidence::read_entry( 277 connection, 278 input, 279 crypto, 280 OperationId::from_bytes(array(104, 136)?), 281 )) 282 .await? 283 .ok_or(OperationError::RecoveryRequired)?; 284 let original = Original { 285 installation, 286 evidence, 287 }; 288 original.validate()?; 289 let h = &frame.header; 290 if original.installation.frame.header.transaction != TransactionId::from_bytes(array(40, 72)?) 291 || original.installation.frame.header.head != CheckpointDigest::from_bytes(array(72, 104)?) 292 || original.evidence.frame.header.transaction != TransactionId::from_bytes(array(136, 168)?) 293 || original.evidence.frame.header.head != CheckpointDigest::from_bytes(array(168, 200)?) 294 || h.actor != original.evidence.frame.header.actor 295 || h.digest != original.evidence.frame.header.digest 296 || h.related_operation != original.evidence.frame.header.related_operation 297 || h.order != original.evidence.frame.header.order 298 || h.revision <= original.evidence.frame.header.revision 299 || h.revision <= original.installation.frame.header.revision 300 || head(h, body) != h.head 301 { 302 return Err(OperationError::RecoveryRequired); 303 } 304 let at = u64::from_be_bytes( 305 body[201..209] 306 .try_into() 307 .map_err(|_| OperationError::RecoveryRequired)?, 308 ); 309 let observed = match (body[200], at) { 310 (0, 0) => None, 311 (1, n) if n > 0 => NonZeroU64::new(n), 312 _ => return Err(OperationError::RecoveryRequired), 313 }; 314 let length = u32::from_be_bytes( 315 body[209..213] 316 .try_into() 317 .map_err(|_| OperationError::RecoveryRequired)?, 318 ) as usize; 319 if length != body.len() - PREFIX { 320 return Err(OperationError::RecoveryRequired); 321 } 322 let raw = std::str::from_utf8(&body[PREFIX..]).map_err(|_| OperationError::RecoveryRequired)?; 323 let event = nostr::Event::from_json(raw).map_err(|_| OperationError::RecoveryRequired)?; 324 let evidence = original.evidence.value.receipt(); 325 let operation = h 326 .related_operation 327 .ok_or(OperationError::RecoveryRequired)?; 328 // This is actual caller context plus decoded selectors, never a fabricated 329 // authenticated binding. The public receipt remains metadata, not authority. 330 let report = StockEnvelopeRequest::new( 331 binding.clone(), 332 InventoryCheckpointRef::from_host_metadata( 333 input.authority(), 334 Sequence::new(0).map_err(|_| OperationError::RecoveryRequired)?, 335 None, 336 )?, 337 operation, 338 h.digest, 339 evidence.recipient(), 340 observed, 341 )?; 342 let receipt = StockEnvelopeReceipt::from_committed_store( 343 &report, 344 CommitAttempt::new( 345 input.workspace_id(), 346 operation, 347 h.digest, 348 Some(h.transaction), 349 ), 350 evidence, 351 original.installation.frame.header.transaction, 352 EnvelopeEventId::from_bytes(event.id.to_bytes()), 353 Sha256::digest(raw.as_bytes()).into(), 354 InventoryCheckpointRef::from_host_metadata(input.authority(), h.revision, Some(h.head))?, 355 )?; 356 let source = StockEnvelopeSource::from_retained_wire(receipt, raw) 357 .map_err(|_| OperationError::RecoveryRequired)?; 358 let retained = Retained { 359 installation: original.installation.frame.header.operation, 360 projection: Projection::Original { 361 operation, 362 recipient: receipt.recipient(), 363 }, 364 frame, 365 source, 366 }; 367 retained.confirm(connection).await?; 368 Ok(retained) 369 }