@toon-protocol/client-mcp 0.2.0 → 0.3.0

package/dist/{chunk-NP35YO5O.js → chunk-CQ2QIZ6Z.js}

@@ -6831,26 +6831,49 @@ function getNetworkStatus(config) {
   if (!network || network === "custom") return void 0;
   return resolveClientNetwork(network).status;
 }
+function proxyIlpEndpoint(proxyUrl) {
+  if (!proxyUrl) return void 0;
+  const trimmed = proxyUrl.replace(/\/+$/, "");
+  return /\/ilp$/i.test(trimmed) ? trimmed : `${trimmed}/ilp`;
+}
 function validateConfig(config) {
   if (config.connector !== void 0) {
     throw new ValidationError(
       "Embedded mode not yet implemented in ToonClient. Use connectorUrl for HTTP mode."
     );
   }
-  if (!config.connectorUrl) {
+  if (!config.connectorUrl && !config.proxyUrl) {
     throw new ValidationError(
-      'connectorUrl is required for HTTP mode. Example: "http://localhost:8080"'
+      'connectorUrl (or proxyUrl) is required for HTTP mode. Example: "http://localhost:8080"'
     );
   }
-  try {
-    const url = new URL(config.connectorUrl);
-    if (!url.protocol.startsWith("http")) {
-      throw new Error("Must be HTTP or HTTPS");
+  if (config.connectorUrl) {
+    try {
+      const url = new URL(config.connectorUrl);
+      if (!url.protocol.startsWith("http")) {
+        throw new Error("Must be HTTP or HTTPS");
+      }
+    } catch (error) {
+      throw new ValidationError(
+        `Invalid connectorUrl: must be a valid HTTP/HTTPS URL (e.g., "http://localhost:8080"). Error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  for (const [field, value] of [
+    ["proxyUrl", config.proxyUrl],
+    ["faucetUrl", config.faucetUrl]
+  ]) {
+    if (value === void 0) continue;
+    try {
+      const url = new URL(value);
+      if (!url.protocol.startsWith("http")) {
+        throw new Error("Must be HTTP or HTTPS");
+      }
+    } catch (error) {
+      throw new ValidationError(
+        `Invalid ${field}: must be a valid HTTP/HTTPS URL. Error: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
-  } catch (error) {
-    throw new ValidationError(
-      `Invalid connectorUrl: must be a valid HTTP/HTTPS URL (e.g., "http://localhost:8080"). Error: ${error instanceof Error ? error.message : String(error)}`
-    );
   }
   if (config.secretKey !== void 0) {
     if (!config.secretKey || config.secretKey.length !== 32) {
@@ -6914,25 +6937,6 @@ function validateConfig(config) {
       );
     }
   }
-  if (config.transport) {
-    if (config.transport.type === "socks5") {
-      if (!config.transport.socksProxy?.startsWith("socks5h://")) {
-        throw new ValidationError(
-          'transport.socksProxy must use socks5h:// scheme to prevent DNS leaks. The "h" suffix ensures .anyone hostnames are resolved by the proxy, not locally.'
-        );
-      }
-    } else if (config.transport.type === "gateway") {
-      if (!config.transport.gatewayUrl) {
-        throw new ValidationError(
-          "transport.gatewayUrl is required for gateway transport"
-        );
-      }
-    } else if (config.transport.type !== "direct") {
-      throw new ValidationError(
-        `Unknown transport type: "${config.transport.type}"`
-      );
-    }
-  }
   if (config.chainRpcUrls && config.supportedChains) {
     for (const chain2 of Object.keys(config.chainRpcUrls)) {
       if (!config.supportedChains.includes(chain2)) {
@@ -6949,19 +6953,21 @@ function applyDefaults(rawConfig) {
     config.mnemonic,
     config.mnemonicAccountIndex ?? 0
   ).secretKey : generateSecretKey2());
+  const connectorHttpEndpoint = config.connectorHttpEndpoint ?? proxyIlpEndpoint(config.proxyUrl);
+  const connectorUrl = config.connectorUrl ?? config.proxyUrl?.replace(/\/+$/, "");
   let btpUrl = config.btpUrl;
-  if (!btpUrl && config.connectorUrl) {
+  if (!btpUrl && connectorUrl && !connectorHttpEndpoint) {
     try {
-      const url = new URL(config.connectorUrl);
+      const url = new URL(connectorUrl);
       const wsProtocol = url.protocol === "https:" ? "wss:" : "ws:";
       btpUrl = `${wsProtocol}//${url.hostname}:3000`;
     } catch {
     }
   }
   let destinationAddress = config.destinationAddress;
-  if (!destinationAddress && config.connectorUrl) {
+  if (!destinationAddress && connectorUrl) {
     try {
-      const url = new URL(config.connectorUrl);
+      const url = new URL(connectorUrl);
       if (url.hostname === "localhost" || url.hostname === "127.0.0.1") {
         if (url.port === "8080") {
           destinationAddress = "g.toon.genesis";
@@ -6984,8 +6990,10 @@ function applyDefaults(rawConfig) {
     ...config,
     secretKey,
     evmPrivateKey,
-    connectorUrl: config.connectorUrl,
-    // Already validated as required
+    // Satisfied by connectorUrl OR proxyUrl (validateConfig enforced one of them).
+    connectorUrl,
+    // Surface the derived `POST /ilp` endpoint so HTTP mode selects HttpIlpClient.
+    ...connectorHttpEndpoint ? { connectorHttpEndpoint } : {},
     relayUrl: config.relayUrl ?? "ws://localhost:7100",
     queryTimeout: config.queryTimeout ?? 3e4,
     maxRetries: config.maxRetries ?? 3,
@@ -7045,6 +7053,13 @@ function decodeUtf8(bytes) {
 function isBase64(str) {
   return /^[A-Za-z0-9+/]*={0,2}$/.test(str);
 }
+var REQUEST_LINE = "POST /write HTTP/1.1";
+var HEADERS = ["Host: relay", "Content-Type: application/json"];
+function buildStoreWriteEnvelope(event) {
+  const body = JSON.stringify({ event });
+  const head = [REQUEST_LINE, ...HEADERS].join("\r\n");
+  return encodeUtf8(head + "\r\n\r\n" + body);
+}
 async function withRetry(operation, options) {
   const {
     maxRetries,
@@ -9219,79 +9234,9 @@ var EvmSigner = class {
     };
   }
 };
-function isAnyoneHost(url) {
-  if (!url) return false;
-  try {
-    const withScheme = /:\/\//.test(url) ? url : `ws://${url}`;
-    const host = new URL(withScheme).hostname.toLowerCase();
-    return host.endsWith(".anyone");
-  } catch {
-    return false;
-  }
-}
-async function resolveTransport(transport, originalBtpUrl, originalConnectorUrl, managedProxyOptions) {
-  const hasExplicitProxy = !!transport && (transport.type === "socks5" || transport.type === "gateway");
-  const envProxy = process.env["ANYONE_PROXY_URLS"];
-  if (!hasExplicitProxy && managedProxyOptions?.managedAnonProxy !== false && !envProxy && isAnyoneHost(originalBtpUrl)) {
-    const { startManagedAnonProxy: startManagedAnonProxy2 } = await import("./anon-proxy-W3KMM7GU-FN7ZJY7P.js");
-    const { createSocks5WebSocketFactory, createSocks5Fetch } = await import("./socks5-WTJBYGME-6COK4LXW.js");
-    const proxy = await startManagedAnonProxy2({
-      ...managedProxyOptions?.managedAnonSocksPort !== void 0 ? { socksPort: managedProxyOptions.managedAnonSocksPort } : {}
-    });
-    try {
-      return {
-        createWebSocket: createSocks5WebSocketFactory(proxy.socksProxy),
-        httpClient: createSocks5Fetch(proxy.socksProxy),
-        stopManagedProxy: proxy.stop
-      };
-    } catch (err) {
-      await proxy.stop();
-      throw err;
-    }
-  }
-  if (!transport || transport.type === "direct") {
-    return {};
-  }
-  if (transport.type === "socks5") {
-    const {
-      createSocks5WebSocketFactory,
-      createSocks5Fetch,
-      probeSocks5Proxy
-    } = await import("./socks5-WTJBYGME-6COK4LXW.js");
-    await probeSocks5Proxy(transport.socksProxy);
-    return {
-      createWebSocket: createSocks5WebSocketFactory(transport.socksProxy),
-      httpClient: createSocks5Fetch(transport.socksProxy)
-    };
-  }
-  if (transport.type === "gateway") {
-    const { rewriteUrlsForGateway } = await import("./gateway-QOK47RKS-SEGTXBR3.js");
-    const rewritten = rewriteUrlsForGateway(
-      transport.gatewayUrl,
-      originalBtpUrl,
-      originalConnectorUrl
-    );
-    return {
-      btpUrl: rewritten.btpUrl,
-      connectorUrl: rewritten.connectorUrl
-    };
-  }
-  throw new Error(
-    `Unknown transport type: "${transport.type}"`
-  );
-}
 async function initializeHttpMode(config) {
-  const transport = await resolveTransport(
-    config.transport,
-    config.btpUrl,
-    config.connectorUrl,
-    {
-      ...config.managedAnonProxy !== void 0 ? { managedAnonProxy: config.managedAnonProxy } : {},
-      ...config.managedAnonSocksPort !== void 0 ? { managedAnonSocksPort: config.managedAnonSocksPort } : {}
-    }
-  );
-  const effectiveBtpUrl = transport.btpUrl ?? config.btpUrl;
-  const effectiveConnectorUrl = transport.connectorUrl ?? config.connectorUrl;
+  const effectiveBtpUrl = config.btpUrl;
+  const effectiveConnectorUrl = config.connectorUrl;
   const settlementInfo = buildSettlementInfo(config);
   const discoveredPeer = readDiscoveredIlpPeer({
     btpEndpoint: effectiveBtpUrl,
@@ -9304,8 +9249,7 @@ async function initializeHttpMode(config) {
     btpClient = new BtpRuntimeClient({
       btpUrl: effectiveBtpUrl,
       peerId: config.btpPeerId ?? `client`,
-      authToken: config.btpAuthToken ?? "",
-      createWebSocket: transport.createWebSocket
+      authToken: config.btpAuthToken ?? ""
     });
     await btpClient.connect();
   }
@@ -9317,17 +9261,14 @@ async function initializeHttpMode(config) {
       ...config.btpAuthToken !== void 0 ? { authToken: config.btpAuthToken } : {},
       timeout: config.queryTimeout,
       maxRetries: config.maxRetries,
-      retryDelay: config.retryDelay,
-      ...transport.httpClient !== void 0 ? { httpClient: transport.httpClient } : {},
-      ...transport.createWebSocket !== void 0 ? { createWebSocket: transport.createWebSocket } : {}
+      retryDelay: config.retryDelay
     });
   }
   const runtimeClient = httpIlpClient ?? btpClient ?? new HttpRuntimeClient({
     connectorUrl: effectiveConnectorUrl,
     timeout: config.queryTimeout,
     maxRetries: config.maxRetries,
-    retryDelay: config.retryDelay,
-    httpClient: transport.httpClient
+    retryDelay: config.retryDelay
   });
   let onChainChannelClient = null;
   if (config.chainRpcUrls) {
@@ -9372,10 +9313,7 @@ async function initializeHttpMode(config) {
     runtimeClient,
     adminClient: null,
     btpClient,
-    onChainChannelClient,
-    // Teardown handle for a managed `anon` proxy this init STARTED (undefined
-    // for explicit-proxy/direct/gateway). ToonClient.stop() invokes it.
-    stopManagedProxy: transport.stopManagedProxy
+    onChainChannelClient
   };
 }
 var SolanaSigner = class {
@@ -10514,13 +10452,7 @@ var ToonClient = class {
         }
       }
       const initialization = await initializeHttpMode(this.config);
-      const {
-        bootstrapService,
-        discoveryTracker,
-        runtimeClient,
-        btpClient,
-        stopManagedProxy
-      } = initialization;
+      const { bootstrapService, discoveryTracker, runtimeClient, btpClient } = initialization;
       if (this.channelManager) {
         const cm = this.channelManager;
         const nostrPubkey = this.getPublicKey();
@@ -10608,8 +10540,7 @@ var ToonClient = class {
         discoveryTracker,
         runtimeClient,
         peersDiscovered: bootstrapResults.length,
-        btpClient: btpClient ?? void 0,
-        ...stopManagedProxy ? { stopManagedProxy } : {}
+        btpClient: btpClient ?? void 0
       };
       return {
         peersDiscovered: bootstrapResults.length,
@@ -10645,13 +10576,9 @@ var ToonClient = class {
       const toonData = this.config.toonEncoder(event);
       const basePricePerByte = 10n;
       const amount = options?.ilpAmount !== void 0 ? String(options.ilpAmount) : String(BigInt(toonData.length) * basePricePerByte);
+      const writeData = buildStoreWriteEnvelope(event);
       const destination = options?.destination ?? this.config.destinationAddress;
-      if (!this.state.btpClient) {
-        throw new ToonClientError(
-          "BTP client required for publishing. Configure btpUrl.",
-          "NO_BTP_CLIENT"
-        );
-      }
+      const transport = this.getClaimTransport();
       let claimMessage;
       if (options?.claim) {
         claimMessage = this.buildClaimMessageForProof(options.claim);
@@ -10680,13 +10607,11 @@ var ToonClient = class {
           "MISSING_CLAIM"
         );
       }
-      const response = await this.state.btpClient.sendIlpPacketWithClaim(
+      const response = await transport.sendIlpPacketWithClaim(
         {
           destination,
           amount,
-          data: toBase64(
-            toonData instanceof Uint8Array ? toonData : new Uint8Array(toonData)
-          )
+          data: toBase64(writeData)
         },
         claimMessage
       );
@@ -10766,7 +10691,7 @@ var ToonClient = class {
    *       matching `destination`,
    *   (c) neither -> throw MISSING_CLAIM.
    *
-   * @throws {ToonClientError} INVALID_STATE / NO_BTP_CLIENT / MISSING_CLAIM
+   * @throws {ToonClientError} INVALID_STATE / NO_ILP_TRANSPORT / MISSING_CLAIM
    */
   async sendSwapPacket(params) {
     if (!this.state) {
@@ -10775,18 +10700,13 @@ var ToonClient = class {
         "INVALID_STATE"
       );
     }
-    if (!this.state.btpClient) {
-      throw new ToonClientError(
-        "BTP client required for sending swap packets. Configure btpUrl.",
-        "NO_BTP_CLIENT"
-      );
-    }
+    const transport = this.getClaimTransport();
     const claimMessage = await this.resolveClaimForDestination(
       params.destination,
       params.amount,
       params.claim
     );
-    return this.state.btpClient.sendIlpPacketWithClaim(
+    return transport.sendIlpPacketWithClaim(
       {
         destination: params.destination,
         amount: String(params.amount),
@@ -10826,6 +10746,51 @@ var ToonClient = class {
     }
     return EvmSigner.buildClaimMessage(claim, this.getPublicKey());
   }
+  /**
+   * Resolve the ILP transport for a paid (claim-bearing) write.
+   *
+   * The connector is a payment-proxy: paid writes carry an ILP PREPARE plus the
+   * signed payment-channel claim. Either transport speaks the SAME claim
+   * contract — the BTP `payment-channel-claim` protocolData entry and the
+   * ILP-over-HTTP `ILP-Payment-Channel-Claim` header serialize the same claim
+   * JSON — so we route through whichever transport is ACTIVE rather than
+   * hard-requiring BTP.
+   *
+   * Selection (mirrors `modes/http.ts` runtime-client precedence):
+   *   1. `runtimeClient` when it implements `sendIlpPacketWithClaim` — this is
+   *      the HttpIlpClient (proxy `POST /ilp`) when a `proxyUrl`/
+   *      `connectorHttpEndpoint` is configured, else the BtpRuntimeClient.
+   *   2. `btpClient` as an explicit fallback (always present when `btpUrl` is set).
+   *
+   * The level-3 `HttpRuntimeClient` (connector-admin HTTP, no `btpUrl` AND no
+   * proxy) does NOT implement `sendIlpPacketWithClaim`; in that case there is no
+   * paid-write transport and we throw a clear, actionable error.
+   *
+   * @throws {ToonClientError} NO_ILP_TRANSPORT when no active transport can send
+   *   a packet+claim.
+   */
+  getClaimTransport() {
+    const state = this.state;
+    if (!state) {
+      throw new ToonClientError(
+        "Client not started. Call start() first.",
+        "INVALID_STATE"
+      );
+    }
+    const candidates = [
+      state.runtimeClient,
+      state.btpClient
+    ];
+    for (const candidate of candidates) {
+      if (candidate && typeof candidate.sendIlpPacketWithClaim === "function") {
+        return candidate;
+      }
+    }
+    throw new ToonClientError(
+      "No ILP transport for paid writes. Configure `proxyUrl`/`connectorHttpEndpoint` (route through the connector proxy over ILP-over-HTTP) or `btpUrl` (BTP socket).",
+      "NO_ILP_TRANSPORT"
+    );
+  }
   /**
    * Shared claim-resolution logic used by `publishEvent` and `sendSwapPacket`.
    * TODO(12.5 followup): also factor `publishEvent`'s inline claim resolution
@@ -11014,14 +10979,9 @@ var ToonClient = class {
         "MISSING_CLAIM"
       );
     }
-    if (!this.state.btpClient) {
-      throw new ToonClientError(
-        "BTP client required for sending payments. Configure btpUrl.",
-        "NO_BTP_CLIENT"
-      );
-    }
+    const transport = this.getClaimTransport();
     const claimMessage = this.buildClaimMessageForProof(params.claim);
-    return this.state.btpClient.sendIlpPacketWithClaim(
+    return transport.sendIlpPacketWithClaim(
       ilpParams,
       claimMessage
     );
@@ -11039,14 +10999,10 @@ var ToonClient = class {
     if (!this.state) {
       throw new ToonClientError("Client not started", "INVALID_STATE");
     }
-    const stopManagedProxy = this.state.stopManagedProxy;
     try {
       if (this.state.btpClient) {
         await this.state.btpClient.disconnect();
       }
-      if (stopManagedProxy) {
-        await stopManagedProxy();
-      }
       this.state = null;
     } catch (error) {
       throw new ToonClientError(
@@ -11249,71 +11205,40 @@ function resolveMnemonic(file) {
 }
 function resolveConfig(file) {
   const mnemonic = resolveMnemonic(file);
+  const proxyUrl = process.env["TOON_CLIENT_PROXY_URL"] ?? file.proxyUrl;
+  const faucetUrl = process.env["TOON_CLIENT_FAUCET_URL"] ?? file.faucetUrl;
   const btpUrl = process.env["TOON_CLIENT_BTP_URL"] ?? file.btpUrl;
-  if (!btpUrl) {
-    throw new Error(
-      "No btpUrl configured. Set TOON_CLIENT_BTP_URL or add `btpUrl` to the config file."
-    );
-  }
+  const hasUplink = Boolean(btpUrl || proxyUrl);
   const relayUrl = process.env["TOON_CLIENT_RELAY_URL"] ?? file.relayUrl ?? "ws://localhost:7100";
-  const explicitSocks = process.env["TOON_CLIENT_SOCKS"] ?? file.socksProxy;
   const httpPort = Number(
     process.env["TOON_CLIENT_HTTP_PORT"] ?? file.httpPort ?? 8787
   );
-  const destination = file.destination ?? "g.townhouse.town";
+  const destination = process.env["TOON_CLIENT_DESTINATION"] ?? file.destination ?? "g.townhouse.town";
   const feePerEvent = BigInt(file.feePerEvent ?? "1");
   const network = process.env["TOON_CLIENT_NETWORK"] ?? file.network;
   const chain2 = process.env["TOON_CLIENT_CHAIN"] ?? file.chain ?? "evm";
-  const apex = file.apexChains?.[chain2] ?? file.apex;
-  const managedPort = Number(file.managedAnonSocksPort ?? 9050);
-  const allowManaged = file.managedAnonProxy ?? true;
-  const btpIsAnyone = isAnyoneHost2(btpUrl);
-  const relayIsAnyone = isAnyoneHost2(relayUrl);
-  let transport;
-  let managedAnonProxy;
-  let managedAnonSocksPort;
-  let readsSocksProxy;
-  let manageReadProxy = false;
-  if (explicitSocks) {
-    transport = { type: "socks5", socksProxy: explicitSocks };
-    managedAnonProxy = false;
-    readsSocksProxy = explicitSocks;
-  } else if (allowManaged && btpIsAnyone) {
-    transport = { type: "direct" };
-    managedAnonProxy = true;
-    managedAnonSocksPort = managedPort;
-    readsSocksProxy = `socks5h://127.0.0.1:${managedPort}`;
-  } else if (allowManaged && relayIsAnyone) {
-    transport = { type: "direct" };
-    managedAnonProxy = false;
-    manageReadProxy = true;
-    managedAnonSocksPort = managedPort;
-    readsSocksProxy = `socks5h://127.0.0.1:${managedPort}`;
-  } else {
-    transport = { type: "direct" };
-    managedAnonProxy = false;
-  }
+  const apex = file.apexChains?.[chain2] ?? file.apex ?? buildProxyApexNegotiation(file, chain2, destination);
   const channelStorePath = file.channelStorePath ?? join2(configDir(), "channels.json");
   const apexChannelStorePath = join2(configDir(), "apex-channels.json");
   const toonClientConfig = {
-    // Required by validateConfig but unused at runtime (BTP transport is used).
-    connectorUrl: "http://127.0.0.1:1",
+    // validateConfig requires connectorUrl OR proxyUrl. When only BTP is set
+    // we pass a dummy connectorUrl (unused at runtime — BTP transport is used);
+    // when a proxy is configured, `proxyUrl` satisfies the requirement and the
+    // client derives the `POST /ilp` endpoint + routes writes over HTTP.
+    ...proxyUrl ? { proxyUrl } : { connectorUrl: "http://127.0.0.1:1" },
+    ...faucetUrl ? { faucetUrl } : {},
     mnemonic,
     mnemonicAccountIndex: file.mnemonicAccountIndex ?? 0,
     ilpInfo: {
       pubkey: "00".repeat(32),
       ilpAddress: "g.toon.client",
-      btpEndpoint: btpUrl,
+      btpEndpoint: btpUrl ?? "",
       assetCode: "USD",
       assetScale: 6
     },
     toonEncoder: encodeEventToToon,
     toonDecoder: decodeEventFromToon,
-    btpUrl,
-    btpAuthToken: "",
-    transport,
-    managedAnonProxy,
-    ...managedAnonSocksPort !== void 0 ? { managedAnonSocksPort } : {},
+    ...btpUrl ? { btpUrl, btpAuthToken: "" } : {},
     destinationAddress: destination,
     relayUrl: "",
     // reads use our own RelaySubscription, not bootstrap discovery
@@ -11331,12 +11256,12 @@ function resolveConfig(file) {
   return {
     httpPort,
     relayUrl,
-    ...readsSocksProxy !== void 0 ? { socksProxy: readsSocksProxy } : {},
-    manageReadProxy,
-    ...manageReadProxy ? { readProxySocksPort: managedPort } : {},
+    hasUplink,
+    ...proxyUrl ? { proxyUrl } : {},
+    ...faucetUrl ? { faucetUrl } : {},
     destination,
     feePerEvent,
-    apex,
+    ...apex ? { apex } : {},
     ...file.apexChildPeers ? { apexChildPeers: file.apexChildPeers } : {},
     chain: chain2,
     apexChannelStorePath,
@@ -11344,12 +11269,38 @@ function resolveConfig(file) {
     network
   };
 }
-function isAnyoneHost2(url) {
-  try {
-    return new URL(url).hostname.endsWith(".anyone");
-  } catch {
-    return false;
-  }
+function defaultChainKey(chain2, chainId) {
+  switch (chain2) {
+    case "evm":
+      return `evm:devnet:${chainId}`;
+    case "solana":
+      return "solana:devnet";
+    case "mina":
+      return "mina:devnet";
+  }
+}
+function buildProxyApexNegotiation(file, chain2, destination) {
+  const proxyUrl = process.env["TOON_CLIENT_PROXY_URL"] ?? file.proxyUrl;
+  if (!proxyUrl) return void 0;
+  const settlementAddresses = file.settlementAddresses ?? {};
+  const familyKeys = (rec) => Object.keys(rec).filter((k) => k.split(":")[0] === chain2);
+  const chainKey = familyKeys(settlementAddresses)[0] ?? familyKeys(file.tokenNetworks ?? {})[0] ?? familyKeys(file.preferredTokens ?? {})[0];
+  if (!chainKey) return void 0;
+  const settlementAddress = settlementAddresses[chainKey];
+  if (!settlementAddress) return void 0;
+  const parts = chainKey.split(":");
+  const chainId = chain2 === "evm" && parts.length >= 3 ? Number(parts[2] ?? 0) : 0;
+  const peerId = destination.split(".").at(-1) ?? destination;
+  return {
+    destination,
+    peerId,
+    chain: chain2,
+    chainKey: chainKey || defaultChainKey(chain2, chainId),
+    chainId,
+    settlementAddress,
+    ...file.preferredTokens?.[chainKey] ? { tokenAddress: file.preferredTokens[chainKey] } : {},
+    ...file.tokenNetworks?.[chainKey] ? { tokenNetwork: file.tokenNetworks[chainKey] } : {}
+  };
 }
 
 // src/control-client.ts
@@ -11627,4 +11578,4 @@ export {
 @scure/bip32/lib/esm/index.js:
   (*! scure-bip32 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=chunk-NP35YO5O.js.map
+//# sourceMappingURL=chunk-CQ2QIZ6Z.js.map