app

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

approved-signing.ts (6757B)


      1 import {
      2   finalizeEvent,
      3   getEventHash,
      4   verifiedSymbol,
      5   type EventTemplate
      6 } from 'applesauce-core/helpers';
      7 import { nip44 } from 'applesauce-core/helpers/encryption';
      8 import {
      9   decodePublicRecord,
     10   publicRecordSnapshot,
     11   type PublicRecordHandle
     12 } from '../../../src/lib/persistence/records.ts';
     13 import { capturedArtifactSnapshot } from '../../../src/lib/persistence/artifact-records.ts';
     14 import {
     15   approveCapturedPublicSigning as approveActual,
     16   approvedSigningIdentity,
     17   type ApprovedPublicSigning,
     18   disposableApprovedTemplate,
     19   bindApprovedResponse
     20 } from '../../../src/lib/nostr/approved-signing.ts';
     21 import {
     22   signApprovedExtensionAdapter as signActual,
     23   extensionOwnershipCapture,
     24   type ExtensionAdapter,
     25   type ApprovedSignResult
     26 } from '../../../src/lib/nostr/extension.ts';
     27 import {
     28   openBrowserDatabase,
     29   closeBrowserDatabase
     30 } from '../../../src/lib/persistence/database.ts';
     31 import { createPublicQuotaRepository } from '../../../src/lib/persistence/quota.ts';
     32 import { runCapturedPublicEffect } from '../../../src/lib/runtime/effect-ownership.ts';
     33 export {
     34   createExtensionAdapter,
     35   connectExtensionAdapter,
     36   disconnectExtensionAdapter,
     37   extensionSnapshot
     38 } from '../../../src/lib/nostr/extension.ts';
     39 export {
     40   disposableApprovedTemplate,
     41   bindApprovedResponse,
     42   capturedArtifactSnapshot,
     43   publicRecordSnapshot
     44 };
     45 // Test-only orchestration of the same actual locked signing port. Production
     46 // adapter/identity code never owns database acquisition or a signing bypass.
     47 const capturedRecords = new WeakMap<
     48   ApprovedPublicSigning,
     49   PublicRecordHandle
     50 >();
     51 export function approveCapturedPublicSigning(
     52   record: PublicRecordHandle,
     53   owner: unknown,
     54   id: unknown,
     55   review: unknown
     56 ) {
     57   const approved = approveActual(record, owner, id, review);
     58   if (approved) capturedRecords.set(approved, record);
     59   return approved;
     60 }
     61 export async function signApprovedExtensionAdapter(
     62   adapter: ExtensionAdapter,
     63   approval: ApprovedPublicSigning
     64 ): Promise<ApprovedSignResult> {
     65   const record = capturedRecords.get(approval),
     66     identity = approvedSigningIdentity(approval),
     67     capture = extensionOwnershipCapture(adapter);
     68   if (!record || !identity) return { status: 'invalid_approval' };
     69   if (!capture) return { status: 'unavailable' };
     70   const opened = await openBrowserDatabase();
     71   if (opened.state !== 'ready') return { status: 'unavailable' };
     72   try {
     73     const repository = createPublicQuotaRepository(
     74       opened.owner,
     75       identity.owner
     76     );
     77     if (!repository) return { status: 'unavailable' };
     78     const result = await runCapturedPublicEffect(
     79       repository,
     80       record,
     81       identity.id,
     82       capture,
     83       'reviewed_captured_operation',
     84       (lease) => signActual(adapter, approval, lease)
     85     );
     86     if (result.status === 'completed') return result.value;
     87     return {
     88       status:
     89         result.status === 'busy'
     90           ? 'busy'
     91           : result.status === 'unknown'
     92             ? 'unknown'
     93             : result.status === 'stopped'
     94               ? 'stale'
     95               : 'unavailable'
     96     };
     97   } finally {
     98     closeBrowserDatabase(opened.owner);
     99   }
    100 }
    101 export type Mode =
    102   | 'exact'
    103   | 'author'
    104   | 'kind'
    105   | 'time'
    106   | 'tags'
    107   | 'content'
    108   | 'cached'
    109   | 'mutate'
    110   | 'denied';
    111 // Test-only ephemeral cryptographic material. No literal key, persistence, log,
    112 // production dependency or named-extension qualification is introduced.
    113 export function makeFixture(kind: 30402 | 5 | 10050 = 30402) {
    114   const key = crypto.getRandomValues(new Uint8Array(32));
    115   const source = finalizeEvent(
    116     {
    117       kind: kind === 10050 ? 10050 : 30402,
    118       created_at: 100,
    119       tags:
    120         kind === 10050
    121           ? []
    122           : [
    123               ['d', 'fixture'],
    124               ['published_at', '100']
    125             ],
    126       content: 'public fixture source'
    127     },
    128     key
    129   );
    130   const template = {
    131     pubkey: source.pubkey,
    132     kind,
    133     created_at: 101,
    134     tags:
    135       kind === 5
    136         ? [
    137             ['e', source.id],
    138             ['a', `30402:${source.pubkey}:fixture`]
    139           ]
    140         : kind === 10050
    141           ? []
    142           : [
    143               ['d', 'fixture'],
    144               ['published_at', '100']
    145             ],
    146     content: 'public fixture operation'
    147   };
    148   const id = crypto.randomUUID();
    149   const row = {
    150     schema: 1,
    151     family: kind === 10050 ? 'preference_operation' : 'public_operation',
    152     owner: source.pubkey,
    153     id,
    154     revision: 0,
    155     ...(kind === 10050 ? { consent: 'explicit_review' } : {}),
    156     source: {
    157       type: kind === 10050 ? 'inbox_head' : 'public_head',
    158       wire: JSON.stringify(source)
    159     },
    160     capture: {
    161       kind,
    162       wire: JSON.stringify(template),
    163       hash: getEventHash(template),
    164       targets: ['wss://one.example.org'],
    165       policyFingerprint: 'a'.repeat(64)
    166     },
    167     artifact: null,
    168     receipts: []
    169   };
    170   const record = decodePublicRecord(JSON.stringify(row), row.owner, id);
    171   if (!record.ok) {
    172     key.fill(0);
    173     throw new Error('invalid test fixture');
    174   }
    175   return {
    176     record: record.value,
    177     owner: row.owner,
    178     id,
    179     template,
    180     encrypt(peer: string, text: string) {
    181       const conversation = nip44.v2.utils.getConversationKey(key, peer);
    182       try {
    183         return nip44.v2.encrypt(text, conversation);
    184       } finally {
    185         conversation.fill(0);
    186       }
    187     },
    188     decrypt(peer: string, ciphertext: string) {
    189       const conversation = nip44.v2.utils.getConversationKey(key, peer);
    190       try {
    191         return nip44.v2.decrypt(ciphertext, conversation);
    192       } finally {
    193         conversation.fill(0);
    194       }
    195     },
    196     sign(input: EventTemplate, mode: Mode = 'exact') {
    197       if (mode === 'denied') throw new Error('test-only refusal');
    198       const copy = { ...input, tags: input.tags.map((tag) => [...tag]) };
    199       if (mode === 'kind') copy.kind = 1;
    200       if (mode === 'time') copy.created_at++;
    201       if (mode === 'tags' || mode === 'mutate')
    202         copy.tags.push(['changed', 'fixture']);
    203       if (mode === 'content') copy.content += ' changed';
    204       if (mode === 'mutate') {
    205         input.tags.push(['provider', 'mutation']);
    206         input.content = 'changed disposable copy';
    207       }
    208       if (mode === 'author') {
    209         const other = crypto.getRandomValues(new Uint8Array(32));
    210         try {
    211           return finalizeEvent(copy, other);
    212         } finally {
    213           other.fill(0);
    214         }
    215       }
    216       const event = finalizeEvent(copy, key);
    217       if (mode === 'cached') event.sig = '0'.repeat(128);
    218       // A hostile provider can return the SDK's mutable cached verification flag.
    219       Object.defineProperty(event, verifiedSymbol, {
    220         value: true,
    221         configurable: true
    222       });
    223       return event;
    224     },
    225     close() {
    226       key.fill(0);
    227     }
    228   };
    229 }