app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

verify-outbound-envelope.ts (4641B)


      1 import {
      2   reservedSendSnapshot,
      3   reservedSendRumorWire,
      4   type ReservedSendIdentity
      5 } from '../messaging/send-identity.ts';
      6 import {
      7   privateGiftwrapSnapshot,
      8   privateGiftwrapSeal,
      9   type PrivateGiftwrap
     10 } from './giftwrap-builder.ts';
     11 import { privateSealSnapshot, privateSealReservation } from './seal-builder.ts';
     12 import { verifyOutboundLayerData } from './outbound-envelope-layers.ts';
     13 import {
     14   recoveredSelfEnvelopeSnapshot,
     15   type RecoveredSelfEnvelope
     16 } from './self-recovery-reader.ts';
     17 declare const outboundBrand: unique symbol;
     18 export type VerifiedOutboundEnvelope = Readonly<{ [outboundBrand]: true }>;
     19 type Saved = Readonly<{
     20   reserved: ReservedSendIdentity;
     21   wrap: PrivateGiftwrap;
     22 }>;
     23 const proofs = new WeakMap<VerifiedOutboundEnvelope, Saved>();
     24 const recoveredProofs = new WeakMap<
     25   VerifiedOutboundEnvelope,
     26   { reserved: ReservedSendIdentity; source: RecoveredSelfEnvelope }
     27 >();
     28 function inspect(reserved: ReservedSendIdentity, wrap: PrivateGiftwrap) {
     29   const record = reservedSendSnapshot(reserved),
     30     rumor = reservedSendRumorWire(reserved),
     31     outer = privateGiftwrapSnapshot(wrap),
     32     seal = privateGiftwrapSeal(wrap),
     33     inner = seal && privateSealSnapshot(seal);
     34   if (
     35     !record ||
     36     !rumor ||
     37     !outer ||
     38     !seal ||
     39     !inner ||
     40     privateSealReservation(seal) !== reserved ||
     41     outer.command !== record.id ||
     42     outer.owner !== record.owner ||
     43     outer.peer !== record.peer ||
     44     outer.rumorHash !== record.rumorHash ||
     45     inner.command !== outer.command ||
     46     inner.rumorHash !== outer.rumorHash ||
     47     inner.role !== outer.role ||
     48     inner.destination !== outer.destination ||
     49     !verifyOutboundLayerData(
     50       rumor,
     51       rumor,
     52       inner.wire,
     53       outer.wire,
     54       record.owner,
     55       record.peer,
     56       outer.role
     57     )
     58   )
     59     return undefined;
     60   const original = JSON.parse(rumor) as { id: string; created_at: number };
     61   if (
     62     original.id !== record.rumorHash ||
     63     original.created_at !== record.createdAt
     64   )
     65     return undefined;
     66   return outer;
     67 }
     68 // Only genuine current factory roundtrip associations enter this proof. Pure
     69 // detached validation cannot mint it. No receipt, durability or Send follows.
     70 export function verifyOutboundEnvelope(
     71   reserved: ReservedSendIdentity,
     72   wrap: PrivateGiftwrap,
     73   review: unknown
     74 ): VerifiedOutboundEnvelope | undefined {
     75   if (review !== 'reviewed_outbound_layers' || !inspect(reserved, wrap))
     76     return undefined;
     77   const token = Object.freeze({}) as VerifiedOutboundEnvelope;
     78   proofs.set(token, { reserved, wrap });
     79   return token;
     80 }
     81 export function verifiedOutboundSnapshot(token: VerifiedOutboundEnvelope) {
     82   const saved = proofs.get(token);
     83   if (saved) return inspect(saved.reserved, saved.wrap);
     84   const recovery = recoveredProofs.get(token);
     85   return recovery && inspectRecovered(recovery.reserved, recovery.source);
     86 }
     87 function inspectRecovered(
     88   reserved: ReservedSendIdentity,
     89   source: RecoveredSelfEnvelope
     90 ) {
     91   const original = recoveredSelfEnvelopeSnapshot(source),
     92     record = reservedSendSnapshot(reserved),
     93     wire = reservedSendRumorWire(reserved);
     94   if (
     95     !original ||
     96     !record ||
     97     wire !== original.rumorWire ||
     98     record.owner !== original.record.owner ||
     99     record.id !== original.record.id ||
    100     record.peer !== original.record.peer ||
    101     record.rumorHash !== original.record.rumorHash ||
    102     record.createdAt !== original.record.createdAt ||
    103     !verifyOutboundLayerData(
    104       wire,
    105       wire,
    106       original.sealWire,
    107       original.record.self.wire,
    108       record.owner,
    109       record.peer,
    110       'self'
    111     )
    112   )
    113     return undefined;
    114   return {
    115     owner: record.owner,
    116     peer: record.peer,
    117     destination: record.owner,
    118     role: 'self' as const,
    119     command: record.id,
    120     rumorHash: record.rumorHash,
    121     wire: original.record.self.wire
    122   };
    123 }
    124 export function verifyRecoveredSelfEnvelope(
    125   reserved: ReservedSendIdentity,
    126   source: RecoveredSelfEnvelope,
    127   review: unknown
    128 ): VerifiedOutboundEnvelope | undefined {
    129   if (
    130     review !== 'reviewed_recovered_self' ||
    131     !inspectRecovered(reserved, source)
    132   )
    133     return undefined;
    134   const token = Object.freeze({}) as VerifiedOutboundEnvelope;
    135   recoveredProofs.set(token, { reserved, source });
    136   return token;
    137 }
    138 // Extra full-wire custody fence for actual recovery, absent for new factories.
    139 export function verifiedOutboundRecoverySource(
    140   token: VerifiedOutboundEnvelope
    141 ): string | undefined {
    142   const recovery = recoveredProofs.get(token);
    143   return recovery && inspectRecovered(recovery.reserved, recovery.source)
    144     ? recoveredSelfEnvelopeSnapshot(recovery.source)?.storedWire
    145     : undefined;
    146 }