@toon-protocol/rig 2.1.0 → 2.2.0

package/dist/{standalone-mode-FCKTQ33Y.js → standalone-mode-64CKUVU2.js}

@@ -1,22 +1,21 @@
-import {
-  fetchRemoteState,
-  queryRelay
-} from "./chunk-PLKZAUTG.js";
 import {
   resolveIdentity
 } from "./chunk-CW4HJNMU.js";
-import "./chunk-HPSOQP7Q.js";
+import {
+  fetchRemoteState,
+  queryRelay
+} from "./chunk-JBB7HBQC.js";
 import {
   StandalonePublisher
-} from "./chunk-3EKP7PMM.js";
+} from "./chunk-OIJNRACA.js";
 import {
   ChannelMapStore,
   RIG_CHANNEL_MAP_FILENAME
-} from "./chunk-O6TXHKWG.js";
+} from "./chunk-SW7ZHMGS.js";
 import "./chunk-X2CZPPDM.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 { EvmSigner, deriveNostrKeyFromMnemonic } from "@toon-protocol/client";
@@ -25,6 +24,161 @@ import {
   encodeEventToToon
 } from "@toon-protocol/core";
 
+// src/standalone/topology-cache.ts
+import { createHash } from "crypto";
+import { mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { dirname } from "path";
+var TOPOLOGY_CACHE_FILENAME = "rig-topology-cache.json";
+var DEFAULT_TOPOLOGY_TTL_MS = 15 * 60 * 1e3;
+var TOPOLOGY_TTL_ENV = "RIG_TOPOLOGY_TTL_MS";
+function topologyCacheTtlMs(env) {
+  const raw = env[TOPOLOGY_TTL_ENV];
+  if (raw === void 0 || raw === "") return DEFAULT_TOPOLOGY_TTL_MS;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_TOPOLOGY_TTL_MS;
+}
+function topologyCacheKey(args) {
+  return createHash("sha256").update(`${args.relayUrl}
+${args.identity}
+${args.fingerprint}`).digest("hex");
+}
+function explicitConfigFingerprint(env, file) {
+  const envKeys = [
+    "TOON_CLIENT_PROXY_URL",
+    "TOON_CLIENT_BTP_URL",
+    "TOON_CLIENT_DESTINATION",
+    "TOON_CLIENT_PUBLISH_DESTINATION",
+    "TOON_CLIENT_STORE_DESTINATION",
+    "TOON_CLIENT_CHAIN",
+    "TOON_CLIENT_NETWORK"
+  ];
+  const fileKeys = [
+    "network",
+    "btpUrl",
+    "proxyUrl",
+    "destination",
+    "publishDestination",
+    "storeDestination",
+    "chain",
+    "supportedChains",
+    "settlementAddresses",
+    "preferredTokens",
+    "tokenNetworks",
+    "chainRpcUrls"
+  ];
+  const picked = {};
+  for (const key of envKeys) {
+    if (env[key] !== void 0) picked[`env:${key}`] = env[key];
+  }
+  for (const key of fileKeys) {
+    if (file[key] !== void 0) picked[`file:${key}`] = file[key];
+  }
+  return JSON.stringify(picked);
+}
+var TopologyCache = class {
+  path;
+  ttlMs;
+  validate;
+  now;
+  constructor(options) {
+    this.path = options.path;
+    this.ttlMs = options.ttlMs;
+    this.validate = options.validate;
+    this.now = options.now ?? Date.now;
+  }
+  /** True when the cache is disabled (`RIG_TOPOLOGY_TTL_MS=0`). */
+  get disabled() {
+    return this.ttlMs <= 0;
+  }
+  /**
+   * A fresh, structurally-valid entry for `key` — or undefined (expired,
+   * missing, invalid, corrupt file, or disabled). Also reports the entry age
+   * for the "topology from cache" stderr line.
+   */
+  read(key) {
+    if (this.disabled) return void 0;
+    const entry = this.readFile().entries[key];
+    if (!entry) return void 0;
+    const cachedAt = Date.parse(entry.cachedAt);
+    if (!Number.isFinite(cachedAt)) return void 0;
+    const ageMs = this.now() - cachedAt;
+    if (ageMs < 0 || ageMs > this.ttlMs) return void 0;
+    if (!this.validate(entry.topology)) return void 0;
+    return { topology: entry.topology, ageMs };
+  }
+  /** Persist `topology` under `key` (prunes expired entries; best-effort). */
+  write(key, topology) {
+    if (this.disabled) return;
+    try {
+      const file = this.readFile();
+      const nowMs = this.now();
+      const fresh = Object.fromEntries(
+        Object.entries(file.entries).filter(([, entry]) => {
+          const at = Date.parse(entry.cachedAt);
+          return Number.isFinite(at) && nowMs - at <= this.ttlMs;
+        })
+      );
+      fresh[key] = {
+        cachedAt: new Date(nowMs).toISOString(),
+        topology
+      };
+      mkdirSync(dirname(this.path), { recursive: true });
+      writeFileSync(
+        this.path,
+        JSON.stringify(
+          { version: 1, entries: fresh },
+          null,
+          2
+        ),
+        { mode: 384 }
+      );
+    } catch {
+    }
+  }
+  /** Drop `key` (a cached topology failed to bootstrap). Best-effort. */
+  invalidate(key) {
+    try {
+      const file = this.readFile();
+      if (!(key in file.entries)) return;
+      const remaining = Object.fromEntries(
+        Object.entries(file.entries).filter(([k]) => k !== key)
+      );
+      if (Object.keys(remaining).length === 0) {
+        unlinkSync(this.path);
+        return;
+      }
+      writeFileSync(
+        this.path,
+        JSON.stringify(
+          { version: 1, entries: remaining },
+          null,
+          2
+        ),
+        { mode: 384 }
+      );
+    } catch {
+    }
+  }
+  readFile() {
+    const empty = { version: 1, entries: {} };
+    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 || typeof parsed.entries !== "object" || parsed.entries === null) {
+        return empty;
+      }
+      return parsed;
+    } catch {
+      return empty;
+    }
+  }
+};
+
 // src/standalone/network-bootstrap.ts
 import {
   CHAIN_PRESETS,
@@ -300,7 +454,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(
@@ -438,7 +592,7 @@ async function resolveNetworkTopology(inputs) {
   const network = env["TOON_CLIENT_NETWORK"] ?? file.network;
   if (network && network !== "custom" && !file.supportedChains?.length) {
     warn(
-      `rig: ignoring the "${network}" network preset for settlement \u2014 the chain comes from the announce/config (#260); set supportedChains explicitly to use preset chains`
+      `rig: ignoring the "${network}" network preset for settlement \u2014 the settlement chain comes from the payment peer's announce and your config, because preset chains can point at networks your wallet has no funds on; set supportedChains explicitly to use preset chains`
     );
   }
   return {
@@ -455,6 +609,87 @@ async function resolveNetworkTopology(inputs) {
     ...chainRpcUrls && Object.keys(chainRpcUrls).length > 0 ? { chainRpcUrls } : {}
   };
 }
+function isNetworkTopology(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const t = value;
+  return typeof t["destination"] === "string" && Array.isArray(t["knownPeers"]);
+}
+var NON_RECOVERABLE_START_ERRORS = /* @__PURE__ */ new Set([
+  "DaemonIdentityConflictError",
+  "StandaloneLockError",
+  "ChannelMapCorruptError"
+]);
+var TopologyRecoveringPublisher = class {
+  inner;
+  rebuild;
+  warn;
+  constructor(inner, rebuild, warn) {
+    this.inner = inner;
+    this.rebuild = rebuild;
+    this.warn = warn;
+  }
+  getPublicKey() {
+    return this.inner.getPublicKey();
+  }
+  getFeeRates() {
+    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.
+   */
+  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();
+      try {
+        await this.inner.stop();
+      } catch {
+      }
+      this.inner = fresh;
+      await start(this.inner);
+      return this.inner;
+    }
+  }
+  async publishEvent(event, relayUrls) {
+    const p = await this.ensure((x) => x.start());
+    return p.publishEvent(event, relayUrls);
+  }
+  async uploadGitObject(upload) {
+    const p = await this.ensure((x) => x.start());
+    return p.uploadGitObject(upload);
+  }
+  // ── money lifecycle passthroughs (#263) — same recovery contract ─────────
+  async openChannelExplicit(opts) {
+    const p = await this.ensure((x) => x.start());
+    return p.openChannelExplicit(opts);
+  }
+  async closeRecordedChannel(record) {
+    const p = await this.ensure((x) => x.startClientOnly());
+    return p.closeRecordedChannel(record);
+  }
+  async settleRecordedChannel(record) {
+    const p = await this.ensure((x) => x.startClientOnly());
+    return p.settleRecordedChannel(record);
+  }
+  /** Free read on the unstarted client — no bootstrap, no recovery needed. */
+  readWalletBalances() {
+    return this.inner.readWalletBalances();
+  }
+  async stop() {
+    await this.inner.stop();
+  }
+};
 function chainRecordsFor(map, identity) {
   return map.list().filter((r) => r.identity === identity).map((r) => {
     const watermark = map.readWatermark(r.channelId);
@@ -474,101 +709,136 @@ async function createStandaloneContext(options) {
   const identity = await resolveIdentity(options);
   const genesisSeed = loadGenesisSeed();
   const relayUrl = options.relayUrl ?? env["TOON_CLIENT_RELAY_URL"] ?? file.relayUrl ?? genesisSeed?.relayUrl ?? "ws://localhost:7100";
-  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);
-  let announce;
-  if (!fullyExplicit) {
-    try {
-      const peers = await discoverAnnouncedPeers(relayUrl, {
-        timeoutMs: DISCOVERY_TIMEOUT_MS
-      });
-      announce = pickPaymentPeer(peers, genesisSeedPubkeys());
-      if (!announce) {
-        warn(
-          `rig: no payment-peer announce (kind:10032) found on ${relayUrl} \u2014 falling back to the genesis peer seed`
-        );
-      }
-    } catch (err) {
-      warn(
-        `rig: announce discovery on ${relayUrl} failed (${err instanceof Error ? err.message : String(err)}) \u2014 falling back to the genesis peer seed`
-      );
-    }
-  }
   const channelStorePath = file.channelStorePath ?? join(dir, "channels.json");
   const channelMap = new ChannelMapStore({
     mapPath: join(dir, RIG_CHANNEL_MAP_FILENAME),
     watermarkPath: channelStorePath
   });
-  const topology = await resolveNetworkTopology({
-    env,
-    file,
-    configPath,
+  const cache = new TopologyCache({
+    path: join(dir, TOPOLOGY_CACHE_FILENAME),
+    ttlMs: topologyCacheTtlMs(env),
+    validate: isNetworkTopology
+  });
+  const cacheKey = topologyCacheKey({
     relayUrl,
-    announce,
-    genesisSeed,
-    identity: {
-      mnemonic: identity.mnemonic,
-      accountIndex: identity.accountIndex,
-      pubkey: identity.pubkey
-    },
-    channelRecords: () => chainRecordsFor(channelMap, identity.pubkey),
-    ...options.requireUplink !== void 0 ? { requireUplink: options.requireUplink } : {},
-    warn
+    identity: identity.pubkey,
+    fingerprint: explicitConfigFingerprint(
+      env,
+      file
+    )
   });
+  const resolveLiveTopology = async () => {
+    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);
+    let announce;
+    if (!fullyExplicit) {
+      try {
+        const peers = await discoverAnnouncedPeers(relayUrl, {
+          timeoutMs: DISCOVERY_TIMEOUT_MS
+        });
+        announce = pickPaymentPeer(peers, genesisSeedPubkeys());
+        if (!announce) {
+          warn(
+            `rig: no payment-peer announce (kind:10032) found on ${relayUrl} \u2014 falling back to the genesis peer seed`
+          );
+        }
+      } catch (err) {
+        warn(
+          `rig: announce discovery on ${relayUrl} failed (${err instanceof Error ? err.message : String(err)}) \u2014 falling back to the genesis peer seed`
+        );
+      }
+    }
+    const resolved = await resolveNetworkTopology({
+      env,
+      file,
+      configPath,
+      relayUrl,
+      announce,
+      genesisSeed,
+      identity: {
+        mnemonic: identity.mnemonic,
+        accountIndex: identity.accountIndex,
+        pubkey: identity.pubkey
+      },
+      channelRecords: () => chainRecordsFor(channelMap, identity.pubkey),
+      ...options.requireUplink !== void 0 ? { requireUplink: options.requireUplink } : {},
+      warn
+    });
+    if (options.requireUplink !== false) cache.write(cacheKey, resolved);
+    return resolved;
+  };
+  const cached = cache.read(cacheKey);
+  if (cached) {
+    warn(
+      `rig: network topology from cache (${Math.round(cached.ageMs / 1e3)}s old; ${TOPOLOGY_TTL_ENV}=0 disables) \u2014 skipping announce discovery`
+    );
+  }
+  const topology = cached?.topology ?? await resolveLiveTopology();
   const eventFee = BigInt(file.feePerEvent ?? "1");
-  const clientConfig = {
-    // validateConfig requires connectorUrl OR proxyUrl; with BTP-only config a
-    // dummy connectorUrl satisfies it (unused at runtime — same convention as
-    // the daemon).
-    ...topology.proxyUrl ? { proxyUrl: topology.proxyUrl } : { connectorUrl: "http://127.0.0.1:1" },
-    mnemonic: identity.mnemonic,
-    mnemonicAccountIndex: identity.accountIndex,
-    ilpInfo: {
-      pubkey: "00".repeat(32),
-      ilpAddress: "g.toon.client",
-      btpEndpoint: topology.btpUrl ?? "",
-      assetCode: "USD",
-      assetScale: 6
-    },
-    toonEncoder: encodeEventToToon,
-    toonDecoder: decodeEventFromToon,
-    ...topology.btpUrl ? { btpUrl: topology.btpUrl, btpAuthToken: "" } : {},
-    destinationAddress: topology.destination,
-    // The embedded client bootstraps against the known peer above; its
-    // `relayUrl` config only seeds ArDrive-merged peers, so it stays unset.
-    relayUrl: "",
-    knownPeers: topology.knownPeers,
-    channelStorePath,
-    ...topology.supportedChains ? { supportedChains: topology.supportedChains } : {},
-    ...file.settlementAddresses ? { settlementAddresses: file.settlementAddresses } : {},
-    ...topology.preferredTokens ? { preferredTokens: topology.preferredTokens } : {},
-    ...topology.tokenNetworks ? { tokenNetworks: topology.tokenNetworks } : {},
-    ...topology.chainRpcUrls ? { chainRpcUrls: topology.chainRpcUrls } : {},
-    ...file.solanaChannel ? { solanaChannel: file.solanaChannel } : {},
-    ...file.minaChannel ? { minaChannel: file.minaChannel } : {}
+  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" },
+      mnemonic: identity.mnemonic,
+      mnemonicAccountIndex: identity.accountIndex,
+      ilpInfo: {
+        pubkey: "00".repeat(32),
+        ilpAddress: "g.toon.client",
+        btpEndpoint: topo.btpUrl ?? "",
+        assetCode: "USD",
+        assetScale: 6
+      },
+      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.
+      relayUrl: "",
+      knownPeers: topo.knownPeers,
+      channelStorePath,
+      ...topo.supportedChains ? { supportedChains: topo.supportedChains } : {},
+      ...file.settlementAddresses ? { settlementAddresses: file.settlementAddresses } : {},
+      ...topo.preferredTokens ? { preferredTokens: topo.preferredTokens } : {},
+      ...topo.tokenNetworks ? { tokenNetworks: topo.tokenNetworks } : {},
+      ...topo.chainRpcUrls ? { chainRpcUrls: topo.chainRpcUrls } : {},
+      ...file.solanaChannel ? { solanaChannel: file.solanaChannel } : {},
+      ...file.minaChannel ? { minaChannel: file.minaChannel } : {}
+    };
+    return new StandalonePublisher({
+      clientConfig,
+      eventFee,
+      channelMap,
+      warn,
+      ...topo.publishDestination ? { publishDestination: topo.publishDestination } : {},
+      ...topo.storeDestination ? { storeDestination: topo.storeDestination } : {},
+      // `rig channel open --peer` (#263): anchor the channel (and its map
+      // key) to an explicit peer destination instead of the configured
+      // default.
+      ...options.channelDestination ? { channelDestination: options.channelDestination } : {},
+      // The peer's announce does not carry TokenNetwork/token parameters, so
+      // the client's negotiation leaves them empty (#260 root cause 3) — the
+      // publisher back-fills them from the derived per-chain maps before the
+      // channel opens.
+      ...topo.tokenNetworks || topo.preferredTokens ? {
+        negotiationFallbacks: {
+          ...topo.tokenNetworks ? { tokenNetworks: topo.tokenNetworks } : {},
+          ...topo.preferredTokens ? { preferredTokens: topo.preferredTokens } : {}
+        }
+      } : {}
+    });
   };
-  const publisher = new StandalonePublisher({
-    clientConfig,
-    eventFee,
-    channelMap,
-    warn,
-    ...topology.publishDestination ? { publishDestination: topology.publishDestination } : {},
-    ...topology.storeDestination ? { storeDestination: topology.storeDestination } : {},
-    // `rig channel open --peer` (#263): anchor the channel (and its map key)
-    // to an explicit peer destination instead of the configured default.
-    ...options.channelDestination ? { channelDestination: options.channelDestination } : {},
-    // The peer's announce does not carry TokenNetwork/token parameters, so
-    // the client's negotiation leaves them empty (#260 root cause 3) — the
-    // publisher back-fills them from the derived per-chain maps before the
-    // channel opens.
-    ...topology.tokenNetworks || topology.preferredTokens ? {
-      negotiationFallbacks: {
-        ...topology.tokenNetworks ? { tokenNetworks: topology.tokenNetworks } : {},
-        ...topology.preferredTokens ? { preferredTokens: topology.preferredTokens } : {}
-      }
-    } : {}
-  });
+  const publisher = new TopologyRecoveringPublisher(
+    buildPublisher(topology),
+    cached ? async () => {
+      cache.invalidate(cacheKey);
+      return buildPublisher(await resolveLiveTopology());
+    } : void 0,
+    warn
+  );
   return {
     ownerPubkey: publisher.getPublicKey(),
     identitySource: identity.source,
@@ -592,4 +862,4 @@ export {
   createStandaloneContext,
   resolveNetworkTopology
 };
-//# sourceMappingURL=standalone-mode-FCKTQ33Y.js.map
+//# sourceMappingURL=standalone-mode-64CKUVU2.js.map