@toon-protocol/rig 3.6.0 → 4.0.0

package/dist/standalone-mode-5MNNJC2D.js

@@ -1,928 +0,0 @@
-import {
-  MinaZkAppStore,
-  TOPOLOGY_CACHE_FILENAME,
-  TOPOLOGY_TTL_ENV,
-  TopologyCache,
-  explicitConfigFingerprint,
-  resolveIdentity,
-  topologyCacheKey,
-  topologyCacheTtlMs
-} from "./chunk-PWNZWQOH.js";
-import {
-  StandalonePublisher,
-  deriveRouteDestinations
-} from "./chunk-IZ6KLYQ6.js";
-import {
-  ChannelMapStore,
-  RIG_CHANNEL_MAP_FILENAME,
-  standaloneForced
-} from "./chunk-LCYCKWAT.js";
-import "./chunk-B5ISARMU.js";
-import {
-  DISCOVERY_TIMEOUT_MS,
-  MinaChannelUnderivableError,
-  SolanaChannelUnderivableError,
-  TokenNetworkUnderivableError,
-  discoverAnnouncedPeers,
-  evmChainIdOf,
-  evmTokenBalance,
-  genesisSeedPubkeys,
-  loadGenesisSeed,
-  pickPaymentPeer,
-  resolveChainSettlement,
-  selectSettlementChain,
-  solanaTokenBalance
-} from "./chunk-UZZ2RN7A.js";
-import {
-  fetchRemoteState
-} from "./chunk-2KJJ7LSO.js";
-
-// src/cli/standalone-mode.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import {
-  EvmSigner,
-  deriveFullIdentity,
-  deriveNostrKeyFromMnemonic
-} from "@toon-protocol/client";
-import {
-  decodeEventFromToon,
-  encodeEventToToon,
-  resolveClientNetwork
-} from "@toon-protocol/core";
-
-// 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; ` : "";
-    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 buildMinaAutoDeploy(dir, identityPubkey, chain, warn) {
-  const store = MinaZkAppStore.forHome(dir);
-  let existing;
-  try {
-    existing = store.lookup(identityPubkey, chain);
-  } catch (err) {
-    warn(
-      `rig: unreadable Mina zkApp store at ${store.filePath} (${err instanceof Error ? err.message : String(err)}) \u2014 a fresh zkApp may be deployed`
-    );
-  }
-  return {
-    ...existing ? {
-      deployed: {
-        zkAppAddress: existing.zkAppAddress,
-        zkAppPrivateKey: existing.zkAppPrivateKey
-      }
-    } : {},
-    // Persist the zkApp key BEFORE the deploy tx is sent (bug #3): a crash or
-    // failed cache-invalidation retry between send and confirmation then finds
-    // this record next run and REDEPLOYS the same address, instead of paying
-    // the ~1.1-MINA account-creation fee for a brand-new zkApp every attempt.
-    onDeploying: (record) => {
-      store.save({
-        identity: identityPubkey,
-        chain,
-        zkAppAddress: record.zkAppAddress,
-        zkAppPrivateKey: record.zkAppPrivateKey,
-        feePayer: record.feePayer,
-        deployedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        source: "rig auto-deploy (npm @toon-protocol/mina-zkapp build, pending)"
-      });
-      warn(
-        `rig: recorded pending Mina zkApp ${record.zkAppAddress} before deploy \u2014 key saved to ${store.filePath} (reused on retry)`
-      );
-    },
-    onDeployed: (record) => {
-      store.save({
-        identity: identityPubkey,
-        chain,
-        zkAppAddress: record.zkAppAddress,
-        zkAppPrivateKey: record.zkAppPrivateKey,
-        feePayer: record.feePayer,
-        ...record.deployTxHash !== void 0 ? { deployTxHash: record.deployTxHash } : {},
-        ...record.vkHash !== void 0 ? { vkHash: record.vkHash } : {},
-        deployedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        source: "rig auto-deploy (npm @toon-protocol/mina-zkapp build)"
-      });
-      warn(
-        `rig: deployed a dedicated Mina PaymentChannel zkApp ${record.zkAppAddress} \u2014 key saved to ${store.filePath}`
-      );
-    },
-    onProgress: (line) => warn(`rig: mina: ${line}`)
-  };
-}
-function deriveMinaChannel(settlement, announce, relayUrl) {
-  const { rpcUrl, zkAppAddress, minaTokenId, networkId } = settlement;
-  if (!rpcUrl || !zkAppAddress) {
-    const missing = [
-      ...rpcUrl ? [] : ["graphqlUrl"],
-      ...zkAppAddress ? [] : ["zkAppAddress"]
-    ];
-    throw new MinaChannelUnderivableError(
-      settlement.chain,
-      missing,
-      announce,
-      relayUrl
-    );
-  }
-  return {
-    graphqlUrl: rpcUrl,
-    zkAppAddress,
-    ...minaTokenId ? { tokenId: minaTokenId } : {},
-    ...networkId ? { networkId } : {}
-  };
-}
-function deriveSolanaChannel(settlement, announce, relayUrl) {
-  const { rpcUrl, programId, tokenAddress } = settlement;
-  if (!rpcUrl || !programId || !tokenAddress) {
-    const missing = [
-      ...rpcUrl ? [] : ["rpcUrl"],
-      ...programId ? [] : ["programId"],
-      ...tokenAddress ? [] : ["tokenMint"]
-    ];
-    throw new SolanaChannelUnderivableError(
-      settlement.chain,
-      missing,
-      announce,
-      relayUrl
-    );
-  }
-  return { rpcUrl, programId, tokenMint: tokenAddress };
-}
-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) {
-    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 derived = deriveRouteDestinations(destination);
-    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) {
-      routePrices = {
-        ...publishPrice !== void 0 ? { publish: publishPrice } : {},
-        ...storePrice !== void 0 ? { store: storePrice } : {}
-      };
-    }
-  }
-  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;
-  let solanaChannel;
-  let minaChannel;
-  if (file.supportedChains?.length) {
-    const listed = file.supportedChains;
-    const kept = [];
-    let firstDropError;
-    preferredTokens = { ...file.preferredTokens };
-    tokenNetworks = { ...file.tokenNetworks };
-    chainRpcUrls = { ...file.chainRpcUrls };
-    for (const chain of listed) {
-      const s = resolveSettlement(chain);
-      let key = chain;
-      if (s.family === "evm" && !announcedChains.includes(chain)) {
-        const chainId = evmChainIdOf(chain);
-        const equivalent = chainId !== void 0 ? announcedChains.find((c) => evmChainIdOf(c) === chainId) : void 0;
-        if (equivalent) {
-          warn(
-            `rig: aligning configured settlement chain "${chain}" to the announced spelling "${equivalent}" (same EVM chain id ${chainId}) \u2014 chain negotiation matches identifiers exactly`
-          );
-          key = equivalent;
-        }
-      }
-      if (kept.includes(key)) continue;
-      if (s.tokenAddress && !preferredTokens[key]) {
-        preferredTokens[key] = s.tokenAddress;
-      }
-      if (s.tokenNetwork && !tokenNetworks[key]) {
-        tokenNetworks[key] = s.tokenNetwork;
-      }
-      if (s.rpcUrl && !chainRpcUrls[key]) {
-        chainRpcUrls[key] = s.rpcUrl;
-      }
-      if (s.family === "evm") {
-        if (!tokenNetworks[key]) {
-          throw new TokenNetworkUnderivableError(chain, announce, relayUrl);
-        }
-        if (!chainRpcUrls[key]) {
-          throw new Error(
-            `no RPC URL is derivable for settlement chain "${chain}" \u2014 add chainRpcUrls["${chain}"] to ${configPath}`
-          );
-        }
-      }
-      if (s.family === "solana" && !file.solanaChannel) {
-        if (solanaChannel) {
-          kept.push(key);
-          continue;
-        }
-        try {
-          solanaChannel = deriveSolanaChannel(s, announce, relayUrl);
-        } catch (err) {
-          firstDropError ??= err;
-          warn(
-            `rig: dropping settlement chain ${chain} from the configured supportedChains \u2014 ${err instanceof Error ? err.message : String(err)}`
-          );
-          continue;
-        }
-      }
-      if (s.family === "mina" && !file.minaChannel) {
-        if (minaChannel) {
-          kept.push(key);
-          continue;
-        }
-        try {
-          minaChannel = deriveMinaChannel(s, announce, relayUrl);
-        } catch (err) {
-          firstDropError ??= err;
-          warn(
-            `rig: dropping settlement chain ${chain} from the configured supportedChains \u2014 ${err instanceof Error ? err.message : String(err)}`
-          );
-          continue;
-        }
-      }
-      kept.push(key);
-    }
-    if (kept.length === 0) {
-      throw firstDropError;
-    }
-    supportedChains = kept;
-    const advertised = new Set(kept);
-    const prune = (map) => Object.fromEntries(
-      Object.entries(map).filter(([chain]) => advertised.has(chain))
-    );
-    preferredTokens = prune(preferredTokens);
-    tokenNetworks = prune(tokenNetworks);
-    chainRpcUrls = prune(chainRpcUrls);
-    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;
-    let solanaAddress;
-    if (!explicitChain && announcedChains.some((c) => c.startsWith("solana:"))) {
-      const fullIdentity = await deriveFullIdentity(
-        inputs.identity.mnemonic,
-        inputs.identity.accountIndex
-      );
-      solanaAddress = fullIdentity.solana.publicKey || void 0;
-      fullIdentity.nostr.secretKey.fill(0);
-      fullIdentity.evm.privateKey.fill(0);
-      fullIdentity.solana.secretKey.fill(0);
-    }
-    selection = await selectSettlementChain({
-      ...explicitChain ? { explicitChain } : {},
-      announcedChains,
-      records: inputs.channelRecords(),
-      evmAddress,
-      ...solanaAddress ? { solanaAddress } : {},
-      resolveSettlement,
-      probeBalance: inputs.probeBalance ?? evmTokenBalance,
-      probeSolanaBalance: inputs.probeSolanaBalance ?? solanaTokenBalance
-    });
-    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}`
-        );
-      }
-    }
-    if (settlement.family === "solana" && !file.solanaChannel) {
-      solanaChannel = deriveSolanaChannel(settlement, announce, relayUrl);
-    }
-    if (settlement.family === "mina" && !file.minaChannel) {
-      minaChannel = deriveMinaChannel(settlement, announce, relayUrl);
-    }
-    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 if (explicitChain && selection.chain !== explicitChain) {
-      warn(
-        `rig: aligning configured settlement chain "${explicitChain}" to the announced spelling "${selection.chain}" \u2014 ${selection.detail}`
-      );
-    }
-  } 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, ...btpUrlDerived ? { btpUrlDerived } : {} } : {},
-    destination,
-    ...publishDestination ? { publishDestination } : {},
-    ...storeDestination ? { storeDestination } : {},
-    ...storeBtpUrl ? { storeBtpUrl } : {},
-    ...routePrices ? { routePrices } : {},
-    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 } : {},
-    ...solanaChannel ? { solanaChannel } : {},
-    ...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;
-  return typeof t["destination"] === "string" && Array.isArray(t["knownPeers"]);
-}
-var NON_RECOVERABLE_START_ERRORS = /* @__PURE__ */ new Set([
-  "DaemonIdentityConflictError",
-  "StandaloneLockError",
-  "ChannelMapCorruptError",
-  // An unfunded Mina fee payer is a wallet-funding problem, not topology
-  // staleness — re-resolving the topology cannot fix it, so retrying would
-  // just re-run the (already fail-fast) preflight for nothing.
-  "MinaFeePayerUnfundedError"
-]);
-var TopologyRecoveringPublisher = class {
-  inner;
-  recoveries;
-  warn;
-  constructor(inner, recoveries, warn) {
-    this.inner = inner;
-    this.recoveries = [...recoveries];
-    this.warn = warn;
-  }
-  getPublicKey() {
-    return this.inner.getPublicKey();
-  }
-  getFeeRates() {
-    return this.inner.getFeeRates();
-  }
-  /**
-   * 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) {
-    for (; ; ) {
-      try {
-        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;
-      }
-    }
-  }
-  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);
-  }
-  async uploadBlob(upload) {
-    const p = await this.ensure((x) => x.start());
-    return p.uploadBlob(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. */
-  readWalletChainBalances(...args) {
-    return this.inner.readWalletChainBalances(...args);
-  }
-  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 skipDaemonCheck = standaloneForced(env);
-  if (skipDaemonCheck) {
-    warn(
-      "rig: force-standalone (RIG_STANDALONE) \u2014 bypassing any running toon-clientd; this rig process signs its own claims (stop the daemon if it is also writing on this identity)"
-    );
-  }
-  const genesisSeed = loadGenesisSeed();
-  const relayUrl = options.relayUrl ?? env["TOON_CLIENT_RELAY_URL"] ?? file.relayUrl ?? genesisSeed?.relayUrl ?? // Last resort: the genesis seed normally supplies the relay, so this is
-  // only reached when no seed/config/env relay is present. Point at the
-  // 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
-  });
-  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 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(
-        file.tokenNetworks?.[chain] && file.preferredTokens?.[chain] && file.chainRpcUrls?.[chain]
-      )
-    );
-    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) && storeUplinkKnown && solanaExplicitlyComplete && minaExplicitlyComplete;
-    let announce;
-    let discoveredPeers;
-    if (!fullyExplicit) {
-      try {
-        const peers = await discoverAnnouncedPeers(relayUrl, {
-          timeoutMs: DISCOVERY_TIMEOUT_MS
-        });
-        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`
-        );
-      }
-    }
-    const resolved = await resolveNetworkTopology({
-      env,
-      file,
-      configPath,
-      relayUrl,
-      announce,
-      ...discoveredPeers ? { peers: discoveredPeers } : {},
-      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 = {
-      ...resolveUplinkConfig(topo),
-      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,
-      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 } : {},
-      // Solana channel params: an explicit config object wins verbatim; else
-      // the topology's derivation (announce/presets — see resolveNetworkTopology).
-      ...file.solanaChannel ? { solanaChannel: file.solanaChannel } : topo.solanaChannel ? { solanaChannel: topo.solanaChannel } : {},
-      // Mina channel params: an explicit config object wins verbatim; else the
-      // topology's derivation (announce zkApp/tokenId + preset graphqlUrl —
-      // see resolveNetworkTopology / deriveMinaChannel).
-      // An explicit config object keeps today's pin-a-zkApp semantics
-      // verbatim. The DERIVED path additionally gets `autoDeploy`: the
-      // announce/preset zkApp is shared and single-pair, so a fresh identity
-      // can never open on it — the client checks on-chain ownership and
-      // deploys a dedicated per-pair zkApp when needed, persisting the key
-      // through the rig zkApp store (losing it would strand ~1.1 MINA).
-      ...file.minaChannel ? { minaChannel: file.minaChannel } : topo.minaChannel ? {
-        minaChannel: {
-          ...topo.minaChannel,
-          autoDeploy: buildMinaAutoDeploy(
-            dir,
-            identity.pubkey,
-            `mina:${topo.minaChannel.networkId ?? "devnet"}`,
-            warn
-          )
-        }
-      } : {}
-    };
-    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,
-      ...skipDaemonCheck ? { skipDaemonCheck: true } : {},
-      ...topo.publishDestination ? { publishDestination: topo.publishDestination } : {},
-      ...topo.storeDestination ? { storeDestination: topo.storeDestination } : {},
-      // Route-price floors (F06): every per-packet claim must advance the
-      // channel by at least the destination route's announced price.
-      ...topo.routePrices ? {
-        routePrices: {
-          ...topo.routePrices.publish !== void 0 ? { publish: BigInt(topo.routePrices.publish) } : {},
-          ...topo.routePrices.store !== void 0 ? { store: BigInt(topo.routePrices.store) } : {}
-        }
-      } : {},
-      // `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),
-    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;
-  let walletViewFallback;
-  if (walletViewNetwork === "devnet" || walletViewNetwork === "testnet" || walletViewNetwork === "mainnet") {
-    const presets = resolveClientNetwork(walletViewNetwork);
-    walletViewFallback = {
-      ...presets.solanaChannel ? { solanaChannel: presets.solanaChannel } : {},
-      ...presets.minaChannel ? { minaChannel: presets.minaChannel } : {}
-    };
-  }
-  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),
-      walletChainBalances: () => publisher.readWalletChainBalances(walletViewFallback)
-    },
-    stop: () => publisher.stop()
-  };
-}
-export {
-  MissingUplinkError,
-  OFFICIAL_BTP_URL,
-  OFFICIAL_PROXY_URL,
-  OFFICIAL_PUBLISH_DESTINATION,
-  bootstrapRecoveries,
-  buildMinaAutoDeploy,
-  createStandaloneContext,
-  isBtpTransportError,
-  resolveNetworkTopology,
-  resolveUplinkConfig
-};
-//# sourceMappingURL=standalone-mode-5MNNJC2D.js.map