@toon-protocol/rig 2.0.0 → 2.1.0

package/dist/standalone-mode-FCKTQ33Y.js

@@ -0,0 +1,595 @@
+import {
+  fetchRemoteState,
+  queryRelay
+} from "./chunk-PLKZAUTG.js";
+import {
+  resolveIdentity
+} from "./chunk-CW4HJNMU.js";
+import "./chunk-HPSOQP7Q.js";
+import {
+  StandalonePublisher
+} from "./chunk-3EKP7PMM.js";
+import {
+  ChannelMapStore,
+  RIG_CHANNEL_MAP_FILENAME
+} from "./chunk-O6TXHKWG.js";
+import "./chunk-X2CZPPDM.js";
+
+// src/cli/standalone-mode.ts
+import { readFileSync } 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/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(readFileSync(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 chain comes from the announce/config (#260); 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 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 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,
+    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
+  });
+  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 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 } : {}
+      }
+    } : {}
+  });
+  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-FCKTQ33Y.js.map