app

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

admit-conversation.ts (4152B)


      1 import { canonicalPublicKey } from '../contracts/public-key.ts';
      2 import { readIncomingPairRumor } from '../nostr/incoming-wire.ts';
      3 import {
      4   receivedNestedEnvelopeSnapshot,
      5   receivedNestedEnvelopeOwnership,
      6   type ReceivedNestedEnvelope
      7 } from '../nostr/unwrap-admission.ts';
      8 
      9 export type ConversationRole = 'inbound' | 'self_archive';
     10 export type ConversationData = Readonly<{
     11   owner: string;
     12   peer: string;
     13   sender: string;
     14   recipient: string;
     15   role: ConversationRole;
     16   rumorId: string;
     17   createdAt: number;
     18   content: string;
     19   subject: string | null;
     20   replyTo: string | null;
     21 }>;
     22 // Detached inspection grants no sender authentication or effect permission.
     23 // Only the actual SDK nested-custody issuer below admits a current room.
     24 export function inspectConversationData(
     25   raw: unknown,
     26   expectedOwner: unknown,
     27   expectedRole: unknown
     28 ): ConversationData | undefined {
     29   const owner = canonicalPublicKey(expectedOwner);
     30   if (
     31     !owner ||
     32     (expectedRole !== 'inbound' && expectedRole !== 'self_archive') ||
     33     typeof raw !== 'string'
     34   )
     35     return undefined;
     36   try {
     37     const incoming = readIncomingPairRumor(raw);
     38     if (!incoming) return undefined;
     39     const rumor = incoming.original,
     40       decoded = incoming.message,
     41       sender = rumor.pubkey;
     42     const recipient = decoded.recipients[0].public_key;
     43     if (sender === recipient || (owner !== sender && owner !== recipient))
     44       return undefined;
     45     const role = sender === owner ? 'self_archive' : 'inbound';
     46     if (role !== expectedRole) return undefined;
     47     return {
     48       owner,
     49       peer: sender === owner ? recipient : sender,
     50       sender,
     51       recipient,
     52       role,
     53       rumorId: rumor.id,
     54       createdAt: rumor.created_at,
     55       content: decoded.content,
     56       subject: decoded.subject,
     57       // Private parent hash only; no hint, URL or public lookup is authorized.
     58       replyTo: decoded.reply_to?.id ?? null
     59     };
     60   } catch {
     61     return undefined;
     62   }
     63 }
     64 
     65 declare const conversationBrand: unique symbol;
     66 export type AdmittedConversation = Readonly<{ [conversationBrand]: true }>;
     67 const rooms = new WeakMap<
     68   AdmittedConversation,
     69   { nested: ReceivedNestedEnvelope; role: ConversationRole }
     70 >();
     71 // Outer disposable pubkey, body contacts and relay hints are never participants.
     72 // The original inner recipient remains unchanged for self archives. No cache,
     73 // persistent projection, send/readiness authority or reply action is minted.
     74 export function admitReceivedConversation(
     75   envelope: ReceivedNestedEnvelope,
     76   expectedRole: unknown
     77 ): AdmittedConversation | undefined {
     78   const nested = receivedNestedEnvelopeSnapshot(envelope);
     79   if (!nested) return undefined;
     80   const data = inspectConversationData(
     81     nested.rumorWire,
     82     nested.owner,
     83     expectedRole
     84   );
     85   if (!data || !receivedNestedEnvelopeSnapshot(envelope)) return undefined;
     86   const token = Object.freeze({}) as AdmittedConversation;
     87   rooms.set(token, { nested: envelope, role: data.role });
     88   return token;
     89 }
     90 export function conversationSnapshot(
     91   token: AdmittedConversation
     92 ): ConversationData | undefined {
     93   const saved = rooms.get(token);
     94   const nested = saved && receivedNestedEnvelopeSnapshot(saved.nested);
     95   return nested && saved
     96     ? inspectConversationData(nested.rumorWire, nested.owner, saved.role)
     97     : undefined;
     98 }
     99 
    100 // Original immutable identity generation is observed only from the actual
    101 // admitted nested proof; same-owner strings do not import another session.
    102 export function conversationOwnership(token: AdmittedConversation) {
    103   const saved = rooms.get(token);
    104   return saved && receivedNestedEnvelopeOwnership(saved.nested);
    105 }
    106 
    107 // HCP094 ciphertext identity observation from the original authenticated room.
    108 // Detached strings never replace genuine room custody or grant persistence.
    109 export function conversationEnvelopeIdentity(token: AdmittedConversation) {
    110   const saved = rooms.get(token),
    111     nested = saved && receivedNestedEnvelopeSnapshot(saved.nested);
    112   return nested && conversationSnapshot(token)
    113     ? {
    114         owner: nested.owner,
    115         outerId: nested.outerId,
    116         outerWire: nested.outerWire
    117       }
    118     : undefined;
    119 }