@toon-protocol/rig 2.0.1 → 2.2.0

package/dist/standalone-mode-64CKUVU2.js

@@ -0,0 +1,865 @@
+import {
+  resolveIdentity
+} from "./chunk-CW4HJNMU.js";
+import {
+  fetchRemoteState,
+  queryRelay
+} from "./chunk-JBB7HBQC.js";
+import {
+  StandalonePublisher
+} from "./chunk-OIJNRACA.js";
+import {
+  ChannelMapStore,
+  RIG_CHANNEL_MAP_FILENAME
+} from "./chunk-SW7ZHMGS.js";
+import "./chunk-X2CZPPDM.js";
+
+// src/cli/standalone-mode.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { EvmSigner, deriveNostrKeyFromMnemonic } from "@toon-protocol/client";
+import {
+  decodeEventFromToon,
+  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,
+  GenesisPeerLoader,
+  isEventExpired,
+  parseIlpPeerInfo
+} from "@toon-protocol/core";
+var ILP_PEER_INFO_KIND = 10032;
+var DISCOVERY_TIMEOUT_MS = 5e3;
+function parseRoutes(content) {
+  try {
+    const parsed = JSON.parse(content);
+    const routes = parsed.routes;
+    if (typeof routes !== "object" || routes === null) return void 0;
+    const { publish, store } = routes;
+    const out = {
+      ...typeof publish === "string" && publish.length > 0 ? { publish } : {},
+      ...typeof store === "string" && store.length > 0 ? { store } : {}
+    };
+    return out.publish || out.store ? out : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function discoverAnnouncedPeers(relayUrl, options = {}) {
+  const factory = options.webSocketFactory ?? defaultDiscoveryWebSocketFactory();
+  const events = await queryRelay(
+    relayUrl,
+    { kinds: [ILP_PEER_INFO_KIND], limit: 100 },
+    options.timeoutMs ?? DISCOVERY_TIMEOUT_MS,
+    factory
+  );
+  const latestByAuthor = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.kind !== ILP_PEER_INFO_KIND) continue;
+    const prev = latestByAuthor.get(event.pubkey);
+    if (!prev || event.created_at > prev.created_at) {
+      latestByAuthor.set(event.pubkey, event);
+    }
+  }
+  const peers = [];
+  for (const event of latestByAuthor.values()) {
+    if (isEventExpired(event)) {
+      continue;
+    }
+    let info;
+    try {
+      info = parseIlpPeerInfo(event);
+    } catch {
+      continue;
+    }
+    const routes = parseRoutes(event.content);
+    peers.push({
+      pubkey: event.pubkey,
+      info,
+      ...routes ? { routes } : {},
+      createdAt: event.created_at
+    });
+  }
+  return peers;
+}
+function defaultDiscoveryWebSocketFactory() {
+  return (url) => {
+    const ctor = globalThis.WebSocket;
+    if (!ctor) {
+      throw new Error(
+        "No global WebSocket constructor (Node >= 22 required) for announce discovery"
+      );
+    }
+    return new ctor(url);
+  };
+}
+function pickPaymentPeer(peers, seedPubkeys) {
+  const seeded = peers.filter((p) => seedPubkeys.includes(p.pubkey));
+  if (seeded.length > 0) {
+    return seeded.sort((a, b) => b.createdAt - a.createdAt)[0];
+  }
+  const payable = peers.filter(
+    (p) => (p.info.httpEndpoint || p.info.btpEndpoint) && p.info.settlementAddresses && Object.keys(p.info.settlementAddresses).length > 0
+  );
+  if (payable.length === 0) return void 0;
+  const publishEdges = payable.filter(
+    (p) => p.routes?.publish !== void 0 && p.routes.publish === p.info.ilpAddress
+  );
+  const pool = publishEdges.length > 0 ? publishEdges : payable;
+  return pool.sort((a, b) => b.createdAt - a.createdAt)[0];
+}
+var DEVNET_ZONE = "devnet.toonprotocol.dev";
+var DEVNET_CHAIN_RPC_URLS = {
+  "evm:31337": "https://evm-rpc.devnet.toonprotocol.dev",
+  "solana:devnet": "https://solana-rpc.devnet.toonprotocol.dev"
+};
+function hostOf(url) {
+  if (!url) return void 0;
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return void 0;
+  }
+}
+function isDevnetZonePeer(peer) {
+  if (!peer) return false;
+  return [
+    hostOf(peer.info.httpEndpoint),
+    hostOf(peer.info.btpEndpoint),
+    hostOf(peer.info.relayUrl)
+  ].some((h) => h !== void 0 && (h === DEVNET_ZONE || h.endsWith(`.${DEVNET_ZONE}`)));
+}
+function evmChainIdOf(chain) {
+  const parts = chain.split(":");
+  if (parts[0] !== "evm") return void 0;
+  const raw = parts.length >= 3 ? parts[2] : parts[1];
+  const id = Number.parseInt(raw ?? "", 10);
+  return Number.isNaN(id) ? void 0 : id;
+}
+function evmPresetForChain(chain) {
+  const id = evmChainIdOf(chain);
+  if (id === void 0) return void 0;
+  for (const preset of Object.values(CHAIN_PRESETS)) {
+    if (preset.chainId === id) {
+      return {
+        rpcUrl: preset.rpcUrl,
+        usdcAddress: preset.usdcAddress,
+        tokenNetworkAddress: preset.tokenNetworkAddress
+      };
+    }
+  }
+  return void 0;
+}
+function resolveChainSettlement(chain, explicit, announce) {
+  const family = chain.split(":")[0] ?? chain;
+  const preset = evmPresetForChain(chain);
+  const devnetRpc = isDevnetZonePeer(announce) ? DEVNET_CHAIN_RPC_URLS[chain] : void 0;
+  const rpcUrl = explicit.chainRpcUrls?.[chain] ?? devnetRpc ?? preset?.rpcUrl;
+  const tokenAddress = explicit.preferredTokens?.[chain] ?? announce?.info.preferredTokens?.[chain] ?? (preset?.usdcAddress || void 0);
+  const tokenNetwork = explicit.tokenNetworks?.[chain] ?? announce?.info.tokenNetworks?.[chain] ?? (preset?.tokenNetworkAddress || void 0);
+  return {
+    chain,
+    family,
+    ...rpcUrl ? { rpcUrl } : {},
+    ...tokenAddress ? { tokenAddress } : {},
+    ...tokenNetwork ? { tokenNetwork } : {}
+  };
+}
+var TokenNetworkUnderivableError = class extends Error {
+  constructor(chain, announce, relayUrl) {
+    const announceRef = announce ? `the kind:10032 announce from ${announce.pubkey.slice(0, 16)}\u2026 on ${relayUrl}` : `no kind:10032 announce was found on ${relayUrl}`;
+    super(
+      `cannot derive the TokenNetwork contract for settlement chain "${chain}": ${announceRef} carries no tokenNetworks["${chain}"], and no built-in chain preset matches its chain id \u2014 add tokenNetworks["${chain}"] to the client config (or pick another chain via TOON_CLIENT_CHAIN / the chain config field)`
+    );
+    this.name = "TokenNetworkUnderivableError";
+  }
+};
+async function selectSettlementChain(options) {
+  const { explicitChain, announcedChains } = options;
+  if (explicitChain) {
+    if (explicitChain.includes(":")) {
+      return {
+        chain: explicitChain,
+        reason: "explicit",
+        detail: `chain ${explicitChain} set by config`
+      };
+    }
+    const familyMatch = announcedChains.find(
+      (c) => (c.split(":")[0] ?? c) === explicitChain
+    );
+    if (!familyMatch) {
+      throw new Error(
+        `configured chain family "${explicitChain}" is not announced by the payment peer (announced: ${announcedChains.join(", ") || "none"}) \u2014 set a full chain id (e.g. "evm:31337") to force it`
+      );
+    }
+    return {
+      chain: familyMatch,
+      reason: "explicit",
+      detail: `chain family "${explicitChain}" set by config \u2192 ${familyMatch}`
+    };
+  }
+  const live = (options.records ?? []).filter((r) => !r.closed && announcedChains.includes(r.chain)).sort((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt));
+  const persisted = live[0];
+  if (persisted) {
+    return {
+      chain: persisted.chain,
+      reason: "persisted-channel",
+      detail: `existing payment channel on ${persisted.chain} (rig channel map)`
+    };
+  }
+  const evmChains = announcedChains.filter((c) => c.startsWith("evm:"));
+  if (options.evmAddress && options.probeBalance) {
+    for (const chain of evmChains) {
+      const settlement = options.resolveSettlement(chain);
+      if (!settlement.rpcUrl || !settlement.tokenAddress) continue;
+      try {
+        const balance = await options.probeBalance({
+          rpcUrl: settlement.rpcUrl,
+          tokenAddress: settlement.tokenAddress,
+          owner: options.evmAddress
+        });
+        if (balance > 0n) {
+          return {
+            chain,
+            reason: "funded",
+            detail: `wallet holds ${balance} token base units on ${chain}`
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  const fallback = evmChains[0] ?? announcedChains[0];
+  if (!fallback) {
+    throw new Error(
+      "the payment peer announces no settlement chains \u2014 cannot select a chain for paid writes (set supportedChains/chain in the client config)"
+    );
+  }
+  return {
+    chain: fallback,
+    reason: "default",
+    detail: evmChains[0] ? `first EVM chain announced by the payment peer` : `first chain announced by the payment peer (no EVM chain announced)`
+  };
+}
+var BALANCE_OF_SELECTOR = "0x70a08231";
+async function evmTokenBalance(args) {
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const owner = args.owner.replace(/^0x/, "").toLowerCase().padStart(64, "0");
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), args.timeoutMs ?? 5e3);
+  try {
+    const res = await fetchImpl(args.rpcUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "eth_call",
+        params: [
+          { to: args.tokenAddress, data: `${BALANCE_OF_SELECTOR}${owner}` },
+          "latest"
+        ]
+      }),
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      throw new Error(`eth_call failed: HTTP ${res.status}`);
+    }
+    const body = await res.json();
+    if (typeof body.result !== "string") {
+      throw new Error(`eth_call failed: ${body.error?.message ?? "no result"}`);
+    }
+    return BigInt(body.result === "0x" ? "0x0" : body.result);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function loadGenesisSeed() {
+  return GenesisPeerLoader.loadGenesisPeers()[0];
+}
+function genesisSeedPubkeys() {
+  return GenesisPeerLoader.loadGenesisPeers().map((p) => p.pubkey);
+}
+
+// src/cli/standalone-mode.ts
+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; ` : "";
+    super(
+      `no write uplink configured: ${discovered}set TOON_CLIENT_PROXY_URL (connector payment proxy) or TOON_CLIENT_BTP_URL, or add proxyUrl/btpUrl to ${configPath}`
+    );
+    this.name = "MissingUplinkError";
+  }
+};
+function configDir(env) {
+  return env["TOON_CLIENT_HOME"] ?? join(homedir(), ".toon-client");
+}
+function readClientConfig(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw new Error(
+      `failed to read client config at ${path}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function proxyBaseOf(httpEndpoint) {
+  return httpEndpoint.replace(/\/+$/, "").replace(/\/ilp$/i, "");
+}
+async function resolveNetworkTopology(inputs) {
+  const { env, file, configPath, relayUrl, announce, genesisSeed, warn } = inputs;
+  const explicitProxyUrl = env["TOON_CLIENT_PROXY_URL"] ?? file.proxyUrl;
+  const explicitBtpUrl = env["TOON_CLIENT_BTP_URL"] ?? file.btpUrl;
+  const explicitDestination = env["TOON_CLIENT_DESTINATION"] ?? file.destination;
+  const explicitPublish = env["TOON_CLIENT_PUBLISH_DESTINATION"] ?? file.publishDestination;
+  const explicitStore = env["TOON_CLIENT_STORE_DESTINATION"] ?? file.storeDestination;
+  const explicitChain = env["TOON_CLIENT_CHAIN"] ?? file.chain;
+  const explicitMaps = {
+    ...file.chainRpcUrls ? { chainRpcUrls: file.chainRpcUrls } : {},
+    ...file.preferredTokens ? { preferredTokens: file.preferredTokens } : {},
+    ...file.tokenNetworks ? { tokenNetworks: file.tokenNetworks } : {}
+  };
+  let proxyUrl = explicitProxyUrl;
+  let btpUrl = explicitBtpUrl;
+  if (!proxyUrl && !btpUrl) {
+    if (announce?.info.httpEndpoint) {
+      proxyUrl = proxyBaseOf(announce.info.httpEndpoint);
+    } else if (announce?.info.btpEndpoint) {
+      btpUrl = announce.info.btpEndpoint;
+    } else if (genesisSeed?.btpEndpoint) {
+      btpUrl = genesisSeed.btpEndpoint;
+    } else if (inputs.requireUplink !== false) {
+      throw new MissingUplinkError(configPath, relayUrl);
+    }
+  }
+  const destination = explicitDestination ?? announce?.info.ilpAddress ?? genesisSeed?.ilpAddress ?? "g.proxy";
+  const publishDestination = explicitPublish ?? announce?.routes?.publish;
+  const storeDestination = explicitStore ?? announce?.routes?.store;
+  const knownPeers = announce ? [
+    {
+      pubkey: announce.pubkey,
+      relayUrl,
+      btpEndpoint: announce.info.btpEndpoint ?? ""
+    }
+  ] : genesisSeed ? [
+    {
+      pubkey: genesisSeed.pubkey,
+      relayUrl: genesisSeed.relayUrl,
+      btpEndpoint: genesisSeed.btpEndpoint
+    }
+  ] : [];
+  const announcedChains = announce?.info.supportedChains ?? [];
+  const resolveSettlement = (chain) => resolveChainSettlement(chain, explicitMaps, announce);
+  let selection;
+  let supportedChains;
+  let preferredTokens;
+  let tokenNetworks;
+  let chainRpcUrls;
+  if (file.supportedChains?.length) {
+    supportedChains = file.supportedChains;
+    preferredTokens = { ...file.preferredTokens };
+    tokenNetworks = { ...file.tokenNetworks };
+    chainRpcUrls = { ...file.chainRpcUrls };
+    for (const chain of supportedChains) {
+      const s = resolveSettlement(chain);
+      if (s.tokenAddress && !preferredTokens[chain]) {
+        preferredTokens[chain] = s.tokenAddress;
+      }
+      if (s.tokenNetwork && !tokenNetworks[chain]) {
+        tokenNetworks[chain] = s.tokenNetwork;
+      }
+      if (s.rpcUrl && !chainRpcUrls[chain]) {
+        chainRpcUrls[chain] = s.rpcUrl;
+      }
+      if (s.family === "evm") {
+        if (!tokenNetworks[chain]) {
+          throw new TokenNetworkUnderivableError(chain, announce, relayUrl);
+        }
+        if (!chainRpcUrls[chain]) {
+          throw new Error(
+            `no RPC URL is derivable for settlement chain "${chain}" \u2014 add chainRpcUrls["${chain}"] to ${configPath}`
+          );
+        }
+      }
+    }
+    selection = {
+      chain: supportedChains[0],
+      reason: "explicit",
+      detail: "supportedChains set by config"
+    };
+  } else if (explicitChain || announcedChains.length > 0) {
+    const { secretKey } = deriveNostrKeyFromMnemonic(
+      inputs.identity.mnemonic,
+      inputs.identity.accountIndex
+    );
+    const evmAddress = new EvmSigner(secretKey).address;
+    selection = await selectSettlementChain({
+      ...explicitChain ? { explicitChain } : {},
+      announcedChains,
+      records: inputs.channelRecords(),
+      evmAddress,
+      resolveSettlement,
+      probeBalance: inputs.probeBalance ?? evmTokenBalance
+    });
+    const settlement = resolveSettlement(selection.chain);
+    if (settlement.family === "evm") {
+      if (!settlement.tokenNetwork) {
+        throw new TokenNetworkUnderivableError(
+          selection.chain,
+          announce,
+          relayUrl
+        );
+      }
+      if (!settlement.rpcUrl) {
+        throw new Error(
+          `no RPC URL is derivable for settlement chain "${selection.chain}" \u2014 add chainRpcUrls["${selection.chain}"] to ${configPath}`
+        );
+      }
+    }
+    supportedChains = [selection.chain];
+    preferredTokens = settlement.tokenAddress ? { [selection.chain]: settlement.tokenAddress } : void 0;
+    tokenNetworks = settlement.tokenNetwork ? { [selection.chain]: settlement.tokenNetwork } : void 0;
+    chainRpcUrls = settlement.rpcUrl ? { [selection.chain]: settlement.rpcUrl } : void 0;
+    if (selection.reason !== "explicit") {
+      warn(
+        `rig: settlement chain ${selection.chain} selected \u2014 ${selection.detail}; set TOON_CLIENT_CHAIN (or supportedChains in the client config) to override`
+      );
+    }
+  } else {
+    warn(
+      `rig: no settlement chains are configured or announced \u2014 paid writes will fail until a chain is configured (supportedChains) or the payment peer announces its chains on ${relayUrl}`
+    );
+  }
+  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 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 {
+    ...proxyUrl ? { proxyUrl } : {},
+    ...btpUrl ? { btpUrl } : {},
+    destination,
+    ...publishDestination ? { publishDestination } : {},
+    ...storeDestination ? { storeDestination } : {},
+    knownPeers,
+    ...selection ? { selection } : {},
+    ...supportedChains ? { supportedChains } : {},
+    ...preferredTokens && Object.keys(preferredTokens).length > 0 ? { preferredTokens } : {},
+    ...tokenNetworks && Object.keys(tokenNetworks).length > 0 ? { tokenNetworks } : {},
+    ...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);
+    return {
+      chain: r.chain,
+      lastUsedAt: r.lastUsedAt,
+      closed: watermark?.closedAt !== void 0 || watermark?.settledAt !== void 0
+    };
+  });
+}
+async function createStandaloneContext(options) {
+  const { env } = options;
+  const warn = (line) => options.warn(line);
+  const dir = configDir(env);
+  const configPath = join(dir, "config.json");
+  const file = readClientConfig(configPath);
+  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 channelStorePath = file.channelStorePath ?? join(dir, "channels.json");
+  const channelMap = new ChannelMapStore({
+    mapPath: join(dir, RIG_CHANNEL_MAP_FILENAME),
+    watermarkPath: channelStorePath
+  });
+  const cache = new TopologyCache({
+    path: join(dir, TOPOLOGY_CACHE_FILENAME),
+    ttlMs: topologyCacheTtlMs(env),
+    validate: isNetworkTopology
+  });
+  const cacheKey = topologyCacheKey({
+    relayUrl,
+    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 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 TopologyRecoveringPublisher(
+    buildPublisher(topology),
+    cached ? async () => {
+      cache.invalidate(cacheKey);
+      return buildPublisher(await resolveLiveTopology());
+    } : void 0,
+    warn
+  );
+  return {
+    ownerPubkey: publisher.getPublicKey(),
+    identitySource: identity.source,
+    identitySourceLabel: identity.sourceLabel,
+    publisher,
+    defaultRelayUrls: [relayUrl],
+    fetchRemote: (args) => fetchRemoteState(args),
+    // Money lifecycle (#263): same guard/start/channel-map machinery as the
+    // paid-write path, surfaced for fund/balance/channel open|close|settle.
+    money: {
+      openChannel: (opts) => publisher.openChannelExplicit(opts),
+      closeChannel: (record) => publisher.closeRecordedChannel(record),
+      settleChannel: (record) => publisher.settleRecordedChannel(record),
+      walletBalances: () => publisher.readWalletBalances()
+    },
+    stop: () => publisher.stop()
+  };
+}
+export {
+  MissingUplinkError,
+  createStandaloneContext,
+  resolveNetworkTopology
+};
+//# sourceMappingURL=standalone-mode-64CKUVU2.js.map