lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }