@toon-protocol/rig 3.5.2 → 3.6.0

package/dist/{standalone-mode-LBWGU7NV.js → standalone-mode-5MNNJC2D.js}

@@ -7,11 +7,11 @@ import {
   resolveIdentity,
   topologyCacheKey,
   topologyCacheTtlMs
-} from "./chunk-FFQXFV4W.js";
+} from "./chunk-PWNZWQOH.js";
 import {
   StandalonePublisher,
   deriveRouteDestinations
-} from "./chunk-4CAOEXGQ.js";
+} from "./chunk-IZ6KLYQ6.js";
 import {
   ChannelMapStore,
   RIG_CHANNEL_MAP_FILENAME,
@@ -32,13 +32,13 @@ import {
   resolveChainSettlement,
   selectSettlementChain,
   solanaTokenBalance
-} from "./chunk-TTJCBGKW.js";
+} from "./chunk-UZZ2RN7A.js";
 import {
   fetchRemoteState
 } from "./chunk-2KJJ7LSO.js";
 
 // src/cli/standalone-mode.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 import {
@@ -51,8 +51,101 @@ import {
   encodeEventToToon,
   resolveClientNetwork
 } from "@toon-protocol/core";
-var OFFICIAL_PROXY_URL = "https://proxy.devnet.toonprotocol.dev/rust/ilp";
+
+// src/standalone/notice.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+var NOTICE_STORE_FILENAME = "rig-seen-notices.json";
+function normalizeNotice(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const { id, severity, summary, url } = value;
+  if (typeof id !== "string" || id.length === 0) return void 0;
+  if (typeof summary !== "string" || summary.length === 0) return void 0;
+  if (typeof url !== "string" || url.length === 0) return void 0;
+  return {
+    id,
+    summary,
+    url,
+    severity: severity === "action-required" ? "action-required" : "info"
+  };
+}
+function trustedNoticeFrom(peer, seedPubkeys) {
+  if (!peer || !seedPubkeys.includes(peer.pubkey)) return void 0;
+  return normalizeNotice(peer.info.notice);
+}
+var ACTION_REQUIRED_BORDER = "=".repeat(70);
+function formatNoticeLines(notice) {
+  if (notice.severity === "action-required") {
+    return [
+      "",
+      ACTION_REQUIRED_BORDER,
+      `rig: ACTION REQUIRED \u2014 ${notice.summary}`,
+      `rig: ${notice.url}`,
+      ACTION_REQUIRED_BORDER,
+      ""
+    ];
+  }
+  return [`rig: notice \u2014 ${notice.summary} (${notice.url})`];
+}
+var NoticeStore = class {
+  path;
+  constructor(options) {
+    this.path = options.path;
+  }
+  hasSeen(id) {
+    return this.readFile().seenIds.includes(id);
+  }
+  /** Best-effort; a failed write just means the notice reprints next run. */
+  markSeen(id) {
+    const file = this.readFile();
+    if (file.seenIds.includes(id)) return;
+    try {
+      mkdirSync(dirname(this.path), { recursive: true });
+      writeFileSync(
+        this.path,
+        JSON.stringify(
+          {
+            version: 1,
+            seenIds: [...file.seenIds, id]
+          },
+          null,
+          2
+        ),
+        { mode: 384 }
+      );
+    } catch {
+    }
+  }
+  readFile() {
+    const empty = { version: 1, seenIds: [] };
+    let raw;
+    try {
+      raw = readFileSync(this.path, "utf8");
+    } catch {
+      return empty;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null || parsed.version !== 1 || !Array.isArray(parsed.seenIds) || !parsed.seenIds.every((x) => typeof x === "string")) {
+        return empty;
+      }
+      return parsed;
+    } catch {
+      return empty;
+    }
+  }
+};
+function showOperatorNoticeOnce(peer, seedPubkeys, store, warn) {
+  const notice = trustedNoticeFrom(peer, seedPubkeys);
+  if (!notice || store.hasSeen(notice.id)) return;
+  for (const line of formatNoticeLines(notice)) warn(line);
+  store.markSeen(notice.id);
+}
+
+// src/cli/standalone-mode.ts
+var OFFICIAL_PROXY_URL = "https://proxy.relay.devnet.toonprotocol.dev/ilp";
 var OFFICIAL_PUBLISH_DESTINATION = "g.toon.relay";
+var OFFICIAL_BTP_URL = "wss://proxy.relay.devnet.toonprotocol.dev/ilp/btp";
 var MissingUplinkError = class extends Error {
   constructor(configPath, relayUrl) {
     const discovered = relayUrl ? `no announce with a btp/http endpoint was found on ${relayUrl} and the genesis seed has none; ` : "";
@@ -67,7 +160,7 @@ function configDir(env) {
 }
 function readClientConfig(path) {
   try {
-    return JSON.parse(readFileSync(path, "utf8"));
+    return JSON.parse(readFileSync2(path, "utf8"));
   } catch (err) {
     if (err.code === "ENOENT") return {};
     throw new Error(
@@ -181,18 +274,38 @@ async function resolveNetworkTopology(inputs) {
     ...file.tokenNetworks ? { tokenNetworks: file.tokenNetworks } : {}
   };
   let proxyUrl = explicitProxyUrl;
-  const btpUrl = explicitBtpUrl;
+  let btpUrl = explicitBtpUrl;
   if (!proxyUrl && !btpUrl) {
     proxyUrl = OFFICIAL_PROXY_URL;
   }
+  let btpUrlDerived = false;
+  if (!explicitProxyUrl && !explicitBtpUrl) {
+    btpUrl = announce?.info.btpEndpoint || OFFICIAL_BTP_URL;
+    btpUrlDerived = true;
+  }
   const destination = explicitDestination ?? announce?.info.ilpAddress ?? genesisSeed?.ilpAddress ?? "g.proxy";
   const publishDestination = explicitPublish ?? announce?.routes?.publish ?? (proxyUrl === OFFICIAL_PROXY_URL ? OFFICIAL_PUBLISH_DESTINATION : void 0);
   const storeDestination = explicitStore ?? announce?.routes?.store;
+  const explicitStoreBtpUrl = env["TOON_CLIENT_STORE_BTP_URL"] ?? file.storeBtpUrl;
+  let storeBtpUrl;
+  if (storeDestination && storeDestination !== publishDestination) {
+    const storePeer = inputs.peers?.find(
+      (peer) => peer.info.ilpAddress === storeDestination
+    );
+    storeBtpUrl = explicitStoreBtpUrl || storePeer?.info.btpEndpoint || void 0;
+    if (!storeBtpUrl && inputs.peers?.length) {
+      warn(
+        `rig: no announce found for the store route "${storeDestination}" \u2014 store writes (git objects, the rig page) will be attempted on the publish uplink and the terminating connector will refuse them if it does not hold that channel`
+      );
+    }
+  }
   let routePrices;
-  const capabilities = announce?.capabilities;
-  if (capabilities && capabilities.length > 0) {
+  {
     const derived = deriveRouteDestinations(destination);
-    const priceOf = (address) => capabilities.find((c) => c.address === address)?.price;
+    const priceOf = (address) => {
+      const owner = inputs.peers?.find((p) => p.info.ilpAddress === address) ?? announce;
+      return owner?.routePrices?.[address] ?? owner?.capabilities?.find((c) => c.address === address)?.price;
+    };
     const publishPrice = priceOf(publishDestination ?? derived.publish);
     const storePrice = priceOf(storeDestination ?? derived.store);
     if (publishPrice !== void 0 || storePrice !== void 0) {
@@ -386,10 +499,11 @@ async function resolveNetworkTopology(inputs) {
   }
   return {
     ...proxyUrl ? { proxyUrl } : {},
-    ...btpUrl ? { btpUrl } : {},
+    ...btpUrl ? { btpUrl, ...btpUrlDerived ? { btpUrlDerived } : {} } : {},
     destination,
     ...publishDestination ? { publishDestination } : {},
     ...storeDestination ? { storeDestination } : {},
+    ...storeBtpUrl ? { storeBtpUrl } : {},
     ...routePrices ? { routePrices } : {},
     knownPeers,
     ...selection ? { selection } : {},
@@ -401,6 +515,49 @@ async function resolveNetworkTopology(inputs) {
     ...minaChannel ? { minaChannel } : {}
   };
 }
+function resolveUplinkConfig(topo) {
+  return {
+    // validateConfig requires connectorUrl OR proxyUrl; with BTP-only
+    // config a dummy connectorUrl satisfies it (unused at runtime — same
+    // convention as the daemon).
+    ...topo.proxyUrl ? { proxyUrl: topo.proxyUrl } : { connectorUrl: "http://127.0.0.1:1" },
+    ...topo.btpUrl ? {
+      btpUrl: topo.btpUrl,
+      btpAuthToken: "",
+      preferBtpForPaidWrites: true
+    } : {}
+  };
+}
+function isBtpTransportError(err) {
+  const name = err instanceof Error ? err.name : "";
+  return name === "BtpConnectionError" || name === "BtpAuthError";
+}
+function bootstrapRecoveries(args) {
+  let active = args.topology;
+  const detail = (err) => err instanceof Error ? err.message : String(err);
+  const recoveries = [];
+  const reresolve = args.reresolve;
+  if (reresolve) {
+    recoveries.push({
+      applies: () => true,
+      describe: (err) => `rig: bootstrap with the cached network topology failed (${detail(err)}) \u2014 invalidating the cache and re-resolving live`,
+      rebuild: async () => {
+        active = await reresolve();
+        return args.buildPublisher(active);
+      }
+    });
+  }
+  recoveries.push({
+    applies: (err) => active.btpUrlDerived === true && isBtpTransportError(err),
+    describe: (err) => `rig: the discovered BTP uplink ${active.btpUrl} is unreachable (${detail(err)}) \u2014 continuing over the HTTP uplink alone; paid writes an edge accepts only over BTP will still fail, so pin a reachable endpoint with \`rig entry <url>\` if they do`,
+    rebuild: async () => {
+      const { btpUrl: _btpUrl, btpUrlDerived: _derived, ...http } = active;
+      active = http;
+      return args.buildPublisher(active);
+    }
+  });
+  return recoveries;
+}
 function isNetworkTopology(value) {
   if (typeof value !== "object" || value === null) return false;
   const t = value;
@@ -417,11 +574,11 @@ var NON_RECOVERABLE_START_ERRORS = /* @__PURE__ */ new Set([
 ]);
 var TopologyRecoveringPublisher = class {
   inner;
-  rebuild;
+  recoveries;
   warn;
-  constructor(inner, rebuild, warn) {
+  constructor(inner, recoveries, warn) {
     this.inner = inner;
-    this.rebuild = rebuild;
+    this.recoveries = [...recoveries];
     this.warn = warn;
   }
   getPublicKey() {
@@ -431,30 +588,31 @@ var TopologyRecoveringPublisher = class {
     return this.inner.getFeeRates();
   }
   /**
-   * Run the bootstrap step, recovering ONCE from a stale cached topology.
-   * A rebuild failure surfaces the LIVE resolution's error — that is the
-   * network's real state, strictly more actionable than the cached failure.
+   * Run the bootstrap step, retrying against a repaired publisher for as long
+   * as an unused recovery applies. The LAST attempt's error is what surfaces
+   * — after a live re-resolution or an HTTP-only rebuild that is the
+   * network's real state, strictly more actionable than the failure that
+   * triggered the retry.
    */
   async ensure(start) {
-    try {
-      await start(this.inner);
-      return this.inner;
-    } catch (err) {
-      const rebuild = this.rebuild;
-      this.rebuild = void 0;
-      const name = err instanceof Error ? err.name : "";
-      if (!rebuild || NON_RECOVERABLE_START_ERRORS.has(name)) throw err;
-      this.warn(
-        `rig: bootstrap with the cached network topology failed (${err instanceof Error ? err.message : String(err)}) \u2014 invalidating the cache and re-resolving live`
-      );
-      const fresh = await rebuild();
+    for (; ; ) {
       try {
-        await this.inner.stop();
-      } catch {
+        await start(this.inner);
+        return this.inner;
+      } catch (err) {
+        const name = err instanceof Error ? err.name : "";
+        if (NON_RECOVERABLE_START_ERRORS.has(name)) throw err;
+        const index = this.recoveries.findIndex((r) => r.applies(err));
+        if (index < 0) throw err;
+        const [recovery] = this.recoveries.splice(index, 1);
+        this.warn(recovery.describe(err));
+        const fresh = await recovery.rebuild();
+        try {
+          await this.inner.stop();
+        } catch {
+        }
+        this.inner = fresh;
       }
-      this.inner = fresh;
-      await start(this.inner);
-      return this.inner;
     }
   }
   async publishEvent(event, relayUrls) {
@@ -519,6 +677,10 @@ async function createStandaloneContext(options) {
   // shared public devnet relay rather than a dead local default.
   "wss://relay-ws.devnet.toonprotocol.dev";
   const channelStorePath = file.channelStorePath ?? join(dir, "channels.json");
+  const storeChannelStorePath = channelStorePath.replace(
+    /(\.json)?$/,
+    ".store.json"
+  );
   const channelMap = new ChannelMapStore({
     mapPath: join(dir, RIG_CHANNEL_MAP_FILENAME),
     watermarkPath: channelStorePath
@@ -536,6 +698,9 @@ async function createStandaloneContext(options) {
       file
     )
   });
+  const noticeStore = new NoticeStore({
+    path: join(dir, NOTICE_STORE_FILENAME)
+  });
   const resolveLiveTopology = async () => {
     const solanaExplicitlyComplete = (file.supportedChains ?? []).every(
       (chain) => !chain.startsWith("solana:") || Boolean(file.solanaChannel) || Boolean(
@@ -545,21 +710,28 @@ async function createStandaloneContext(options) {
     const minaExplicitlyComplete = (file.supportedChains ?? []).every(
       (chain) => !chain.startsWith("mina:") || Boolean(file.minaChannel)
     );
+    const explicitStoreDest = env["TOON_CLIENT_STORE_DESTINATION"] ?? file.storeDestination;
+    const explicitPublishDest = env["TOON_CLIENT_PUBLISH_DESTINATION"] ?? file.publishDestination;
+    const storeUplinkKnown = !explicitStoreDest || explicitStoreDest === explicitPublishDest || Boolean(env["TOON_CLIENT_STORE_BTP_URL"] ?? file.storeBtpUrl);
     const fullyExplicit = Boolean(
       (env["TOON_CLIENT_PROXY_URL"] ?? file.proxyUrl) || (env["TOON_CLIENT_BTP_URL"] ?? file.btpUrl)
-    ) && Boolean(env["TOON_CLIENT_DESTINATION"] ?? file.destination) && Boolean(file.supportedChains?.length) && solanaExplicitlyComplete && minaExplicitlyComplete;
+    ) && Boolean(env["TOON_CLIENT_DESTINATION"] ?? file.destination) && Boolean(file.supportedChains?.length) && storeUplinkKnown && solanaExplicitlyComplete && minaExplicitlyComplete;
     let announce;
+    let discoveredPeers;
     if (!fullyExplicit) {
       try {
         const peers = await discoverAnnouncedPeers(relayUrl, {
           timeoutMs: DISCOVERY_TIMEOUT_MS
         });
-        announce = pickPaymentPeer(peers, genesisSeedPubkeys());
+        discoveredPeers = peers;
+        const seedPubkeys = genesisSeedPubkeys();
+        announce = pickPaymentPeer(peers, seedPubkeys);
         if (!announce) {
           warn(
             `rig: no payment-peer announce (kind:10032) found on ${relayUrl} \u2014 falling back to the genesis peer seed`
           );
         }
+        showOperatorNoticeOnce(announce, seedPubkeys, noticeStore, warn);
       } catch (err) {
         warn(
           `rig: announce discovery on ${relayUrl} failed (${err instanceof Error ? err.message : String(err)}) \u2014 falling back to the genesis peer seed`
@@ -572,6 +744,7 @@ async function createStandaloneContext(options) {
       configPath,
       relayUrl,
       announce,
+      ...discoveredPeers ? { peers: discoveredPeers } : {},
       genesisSeed,
       identity: {
         mnemonic: identity.mnemonic,
@@ -595,10 +768,7 @@ async function createStandaloneContext(options) {
   const eventFee = BigInt(file.feePerEvent ?? "1");
   const buildPublisher = (topo) => {
     const clientConfig = {
-      // validateConfig requires connectorUrl OR proxyUrl; with BTP-only
-      // config a dummy connectorUrl satisfies it (unused at runtime — same
-      // convention as the daemon).
-      ...topo.proxyUrl ? { proxyUrl: topo.proxyUrl } : { connectorUrl: "http://127.0.0.1:1" },
+      ...resolveUplinkConfig(topo),
       mnemonic: identity.mnemonic,
       mnemonicAccountIndex: identity.accountIndex,
       ilpInfo: {
@@ -610,7 +780,6 @@ async function createStandaloneContext(options) {
       },
       toonEncoder: encodeEventToToon,
       toonDecoder: decodeEventFromToon,
-      ...topo.btpUrl ? { btpUrl: topo.btpUrl, btpAuthToken: "" } : {},
       destinationAddress: topo.destination,
       // The embedded client bootstraps against the known peer above; its
       // `relayUrl` config only seeds ArDrive-merged peers, so it stays unset.
@@ -646,8 +815,31 @@ async function createStandaloneContext(options) {
         }
       } : {}
     };
+    const storeClientConfig = topo.storeBtpUrl ? {
+      ...clientConfig,
+      proxyUrl: void 0,
+      connectorUrl: "http://127.0.0.1:1",
+      btpUrl: topo.storeBtpUrl,
+      btpAuthToken: "",
+      preferBtpForPaidWrites: true,
+      // Its OWN watermark file. A client's channel store and its
+      // `.peers.json` binding sidecar are one unit that the client
+      // rewrites wholesale, so pointing two live clients at one path has
+      // them clobber each other's watermarks — observed as the publish
+      // leg losing its channel ("is not being tracked", then F01) the
+      // moment the store leg opened. Separate files; the legs stay
+      // correlated through rig's own channel map, which is keyed by
+      // anchor and records both.
+      channelStorePath: storeChannelStorePath,
+      ilpInfo: {
+        ...clientConfig.ilpInfo,
+        btpEndpoint: topo.storeBtpUrl
+      },
+      destinationAddress: topo.storeDestination ?? topo.destination
+    } : void 0;
     return new StandalonePublisher({
       clientConfig,
+      ...storeClientConfig ? { storeClientConfig } : {},
       eventFee,
       channelMap,
       warn,
@@ -680,10 +872,18 @@ async function createStandaloneContext(options) {
   };
   const publisher = new TopologyRecoveringPublisher(
     buildPublisher(topology),
-    cached ? async () => {
-      cache.invalidate(cacheKey);
-      return buildPublisher(await resolveLiveTopology());
-    } : void 0,
+    bootstrapRecoveries({
+      topology,
+      buildPublisher,
+      // Only a CACHE-sourced publisher gets the re-resolve recovery;
+      // live-resolved ones have nothing staler to fall back from.
+      ...cached ? {
+        reresolve: async () => {
+          cache.invalidate(cacheKey);
+          return resolveLiveTopology();
+        }
+      } : {}
+    }),
     warn
   );
   const walletViewNetwork = env["TOON_CLIENT_NETWORK"] ?? file.network;
@@ -715,10 +915,14 @@ async function createStandaloneContext(options) {
 }
 export {
   MissingUplinkError,
+  OFFICIAL_BTP_URL,
   OFFICIAL_PROXY_URL,
   OFFICIAL_PUBLISH_DESTINATION,
+  bootstrapRecoveries,
   buildMinaAutoDeploy,
   createStandaloneContext,
-  resolveNetworkTopology
+  isBtpTransportError,
+  resolveNetworkTopology,
+  resolveUplinkConfig
 };
-//# sourceMappingURL=standalone-mode-LBWGU7NV.js.map
+//# sourceMappingURL=standalone-mode-5MNNJC2D.js.map