app

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

inbox-routing.ts (4396B)


      1 import { canonicalPublicKey } from '../contracts/public-key.ts';
      2 import {
      3   inboxRelayTargets,
      4   publicRelayTargets,
      5   type RelayPolicy
      6 } from '../config/relays.ts';
      7 import { inboxPreferenceSnapshot } from '../nostr/inbox-preferences.ts';
      8 import {
      9   inboxResolutionSnapshot,
     10   inboxResolverCurrentAfterSample,
     11   type InboxResolver
     12 } from './resolve-inbox.ts';
     13 
     14 declare const routeBrand: unique symbol;
     15 export type InboxRoutePlan = Readonly<{ readonly [routeBrand]: true }>;
     16 type Role = 'peer' | 'self_archive';
     17 type Route = Readonly<{
     18   role: Role;
     19   author: string;
     20   targets: string[];
     21   knownBase: Readonly<{ author: string; id: string; createdAt: number }>;
     22   sources: {
     23     source: string;
     24     state: string;
     25     head?: Readonly<{ id: string; createdAt: number }>;
     26   }[];
     27 }>;
     28 export type InboxRouteSnapshot = Readonly<{ peer: Route; archive: Route }>;
     29 // Only admitted snapshots of genuine discovery and policy owners enter this map.
     30 // The plan is preparation evidence, never private-effect or access permission.
     31 const plans = new WeakMap<InboxRoutePlan, string>();
     32 function route(
     33   policy: RelayPolicy,
     34   author: string,
     35   resolver: InboxResolver,
     36   role: Role
     37 ): Route | undefined {
     38   const resolution = inboxResolutionSnapshot(resolver);
     39   const origins = publicRelayTargets(policy, 'read');
     40   if (
     41     resolution.author !== author ||
     42     resolution.status !== 'ready' ||
     43     resolution.coverage !== 'bounded-eose' ||
     44     !resolution.head ||
     45     !resolution.knownBase ||
     46     origins.length === 0 ||
     47     resolution.sources.length !== origins.length ||
     48     !origins.every((origin) =>
     49       resolution.sources.some(
     50         (row) => row.source === origin && row.state === 'eose'
     51       )
     52     )
     53   )
     54     return undefined;
     55   const preference = inboxPreferenceSnapshot(resolution.head);
     56   if (
     57     !preference ||
     58     preference.status !== 'supported' ||
     59     preference.author !== author ||
     60     preference.id !== resolution.knownBase.id ||
     61     preference.createdAt !== resolution.knownBase.createdAt
     62   )
     63     return undefined;
     64   const targets = inboxRelayTargets(policy, preference.relays, 'write').slice();
     65   if (targets.length === 0) return undefined;
     66   return {
     67     role,
     68     author,
     69     targets,
     70     knownBase: { ...resolution.knownBase },
     71     sources: resolution.sources.map((row) => ({
     72       source: row.source,
     73       state: row.state,
     74       ...(row.head ? { head: { ...row.head } } : {})
     75     }))
     76   };
     77 }
     78 function capture(
     79   policy: RelayPolicy,
     80   sender: unknown,
     81   peer: unknown,
     82   own: InboxResolver,
     83   other: InboxResolver
     84 ): InboxRouteSnapshot | undefined {
     85   const senderKey = canonicalPublicKey(sender),
     86     peerKey = canonicalPublicKey(peer);
     87   if (!senderKey || !peerKey || senderKey === peerKey) return undefined;
     88   try {
     89     const archive = route(policy, senderKey, own, 'self_archive'),
     90       recipient = route(policy, peerKey, other, 'peer');
     91     if (
     92       !archive ||
     93       !recipient ||
     94       !inboxResolverCurrentAfterSample(own) ||
     95       !inboxResolverCurrentAfterSample(other)
     96     )
     97       return undefined;
     98     return { peer: recipient, archive };
     99   } catch {
    100     return undefined;
    101   }
    102 }
    103 export function createInboxRoutePlan(
    104   policy: RelayPolicy,
    105   sender: unknown,
    106   peer: unknown,
    107   own: InboxResolver,
    108   other: InboxResolver
    109 ): InboxRoutePlan | undefined {
    110   const snapshot = capture(policy, sender, peer, own, other);
    111   if (!snapshot) return undefined;
    112   const token = Object.freeze({}) as InboxRoutePlan;
    113   plans.set(token, JSON.stringify(snapshot));
    114   return token;
    115 }
    116 export function inboxRoutePlanSnapshot(
    117   token: InboxRoutePlan
    118 ): InboxRouteSnapshot | undefined {
    119   const saved = plans.get(token);
    120   return saved ? (JSON.parse(saved) as InboxRouteSnapshot) : undefined;
    121 }
    122 // Any changed known head, named source version or destination requires explicit
    123 // later review. The original plan remains immutable; no replay or rerouting.
    124 export function recheckInboxRoutePlan(
    125   token: InboxRoutePlan,
    126   policy: RelayPolicy,
    127   own: InboxResolver,
    128   other: InboxResolver
    129 ): 'unchanged' | 'review_required' | 'unavailable' {
    130   const previous = inboxRoutePlanSnapshot(token);
    131   if (!previous) return 'unavailable';
    132   const current = capture(
    133     policy,
    134     previous.archive.author,
    135     previous.peer.author,
    136     own,
    137     other
    138   );
    139   if (!current) return 'unavailable';
    140   return JSON.stringify(current) === plans.get(token)
    141     ? 'unchanged'
    142     : 'review_required';
    143 }