@toon-protocol/client-mcp 0.10.8 → 0.11.0

package/dist/{chunk-ADBNZA5O.js → chunk-KVK6OZVD.js}

@@ -15,7 +15,7 @@ import {
   isEventExpired,
   parseIlpPeerInfo,
   readConfigFile
-} from "./chunk-3ZBC2HUB.js";
+} from "./chunk-CMGJ3NFT.js";
 import {
   __require
 } from "./chunk-F22GNSF6.js";
@@ -36,7 +36,7 @@ var CONFIG_HELP = {
   proxyUrl: "Connector-proxy base URL (deployed devnet/testnet edge). When set, paid writes route through `POST /ilp` and no BTP socket is needed. Set `destination` to the apex ILP address (e.g. g.proxy for devnet).",
   faucetUrl: "Devnet faucet base URL (e.g. https://faucet.devnet.toonprotocol.dev) used to drip test funds before publishing.",
   btpUrl: "BTP WebSocket URL of the apex/connector for paid writes. Optional when `proxyUrl` is set.",
-  relayUrl: "Town relay WebSocket URL for FREE reads. Default ws://localhost:7100.",
+  relayUrl: "Relay WebSocket URL for FREE reads. Default ws://localhost:7100.",
   destination: "Default ILP publish destination (apex address). Default g.proxy.",
   keystorePath: "Auto-generated encrypted identity. Do not hand-edit; back up your seed phrase."
 };
@@ -1398,17 +1398,37 @@ function delay(ms) {
 
 // src/daemon/client-runner.ts
 var MERGED_BUFFER = 5e3;
+var BALANCES_READ_TIMEOUT_MS = 5e3;
+var BALANCES_READ_ATTEMPTS = 2;
 var ClientRunner = class {
   config;
   createClient;
   createRelay;
   log;
   targetsPath;
+  /**
+   * Identity-level chain-read client. Reading your OWN on-chain wallet balance is
+   * a pure (wallet keys + chain RPC) operation that has nothing to do with the
+   * ILP/payment peer, so it lives at the daemon level rather than inside an apex.
+   * Built once from the daemon's own `toonClientConfig` (the same keys + chain
+   * RPC config every apex shares) and REUSED as the default apex's client, so a
+   * funded apex's `start()` (which derives Solana/Mina keys) also benefits this
+   * reader. `getBalances` uses it directly, so balances work even with zero
+   * apexes registered (follow-up to #199/#200).
+   */
+  identityClient;
   startedAt = Date.now();
   /** Apex write targets, keyed by btpUrl. */
   apexes = /* @__PURE__ */ new Map();
   /** Relay read targets, keyed by relayUrl. */
   relays = /* @__PURE__ */ new Map();
+  /**
+   * Async faucet drip jobs, keyed by chain. A drip is launched in the background
+   * (the Mina faucet legitimately takes ~75s — longer than the MCP host's ~60s
+   * tool-call budget) and its terminal state is observed via {@link getFundStatus}
+   * / re-reading balances rather than by blocking the caller.
+   */
+  fundJobs = /* @__PURE__ */ new Map();
   /** Runner-level merged read buffer across all relays (de-duped by event.id). */
   merged = [];
   mergedSeen = /* @__PURE__ */ new Set();
@@ -1438,9 +1458,10 @@ var ClientRunner = class {
       decodeEvent: (raw) => decodeEventFromToon(new TextEncoder().encode(raw))
     }));
     this.registerRelay(this.defaultRelayUrl);
+    this.identityClient = this.createClient(this.config.toonClientConfig);
     const defaultApex = this.makeApex({
       btpUrl: this.defaultBtpUrl,
-      client: this.createClient(this.config.toonClientConfig),
+      client: this.identityClient,
       ...this.config.apex ? { negotiation: this.config.apex } : {},
       childPeers: this.config.apexChildPeers ?? [],
       destination: this.config.destination,
@@ -1920,7 +1941,7 @@ var ClientRunner = class {
    * (the typical "fund me before I open a channel" flow). The daemon holds the
    * faucet URL + the keys, so the MCP caller never needs either.
    */
-  async fundWallet(req = {}) {
+  fundWallet(req = {}) {
     const faucetUrl = this.config.faucetUrl;
     if (!faucetUrl) {
       throw new InvalidPayloadError(
@@ -1937,13 +1958,47 @@ var ClientRunner = class {
         `no ${chain} address available to fund \u2014 pass an explicit address (this client has no ${chain} key configured).`
       );
     }
-    const { response } = await fundWallet(
-      faucetUrl,
-      address,
+    const existing = this.fundJobs.get(chain);
+    if (existing && existing.status === "pending") {
+      return { ...existing };
+    }
+    const job = {
       chain,
-      this.config.faucetTimeoutMs !== void 0 ? { timeout: this.config.faucetTimeoutMs } : {}
-    );
-    return { chain, address, faucetUrl, response };
+      address,
+      faucetUrl,
+      status: "pending",
+      startedAt: Date.now()
+    };
+    this.fundJobs.set(chain, job);
+    const faucetTimeout = this.config.faucetTimeoutMs ?? (chain === "mina" ? 13e4 : 9e4);
+    void fundWallet(faucetUrl, address, chain, { timeout: faucetTimeout }).then(({ response }) => {
+      job.status = "success";
+      job.response = response;
+      job.finishedAt = Date.now();
+      this.log(`[runner] faucet drip succeeded: ${chain} \u2192 ${address}`);
+    }).catch((err) => {
+      try {
+        const msg = errMsg2(err);
+        const timedOut = /timed out|timeout|aborted/i.test(msg);
+        job.status = timedOut ? "timeout" : "error";
+        job.error = timedOut ? `${msg} \u2014 the on-chain drip may still have settled; re-check balances before re-funding.` : msg;
+        job.finishedAt = Date.now();
+        this.log(
+          `[runner] faucet drip ${timedOut ? "timed out" : "failed"}: ${chain} \u2192 ${address}: ${msg}`
+        );
+      } catch {
+      }
+    });
+    return { ...job };
+  }
+  /**
+   * Snapshots of tracked faucet drip jobs — all of them, or just the one for
+   * `chain`. Lets a caller poll for the terminal state of an async drip without
+   * re-dripping.
+   */
+  getFundStatus(chain) {
+    const jobs = chain ? this.fundJobs.has(chain) ? [{ ...this.fundJobs.get(chain) }] : [] : [...this.fundJobs.values()].map((j) => ({ ...j }));
+    return { jobs };
   }
   /** Full registry of relay + apex targets with per-target status. */
   getTargets() {
@@ -2186,14 +2241,39 @@ var ClientRunner = class {
   }
   /**
    * On-chain wallet balances. The wallet is identity-level (same keys across
-   * apexes), so read from the first available apex's client; per-chain reads are
-   * best-effort inside the client (a failing chain is simply omitted).
+   * apexes), so this reads from the daemon's {@link identityClient} — NOT an apex
+   * — and therefore works even with zero apexes / no payment peer configured
+   * (reading your own balance is a pure wallet-keys + chain-RPC operation).
+   * Per-chain reads are best-effort inside the client (a failing chain is simply
+   * omitted).
+   *
+   * Each underlying read hits per-chain RPC providers that can stall
+   * indefinitely on devnet (a provider being `detail: "configured"` in
+   * toon_status means it is WIRED, not that its RPC is live). A stall here used
+   * to block the whole control request until the client aborted, surfacing as a
+   * misleading "relay/apex unreachable" timeout (#199). Bound each attempt well
+   * under the control-plane timeout and retry once so a single transient
+   * provider stall FAST-FAILS with an honest "balances handler / provider
+   * stalled" error instead of hanging.
    */
   async getBalances() {
-    const apex = this.apexes.values().next().value;
-    if (!apex) return { balances: [] };
-    const balances = await apex.client.getBalances();
-    return { balances };
+    let lastErr;
+    for (let attempt = 1; attempt <= BALANCES_READ_ATTEMPTS; attempt++) {
+      try {
+        const balances = await withTimeout(
+          this.identityClient.getBalances(),
+          BALANCES_READ_TIMEOUT_MS,
+          `chain balance read timed out after ${BALANCES_READ_TIMEOUT_MS}ms`
+        );
+        return { balances };
+      } catch (err) {
+        lastErr = err;
+      }
+    }
+    throw new BalancesUnavailableError(
+      `the balances control handler's chain RPC/provider read did not return (${BALANCES_READ_ATTEMPTS} attempts, ${BALANCES_READ_TIMEOUT_MS}ms each) \u2014 the on-chain provider stalled, not the relay or apex. Retry shortly.`,
+      lastErr instanceof Error ? lastErr.message : void 0
+    );
   }
   /**
    * Deposit additional collateral into an open channel. Routes to the apex whose
@@ -2345,12 +2425,37 @@ var InvalidPayloadError = class extends Error {
     this.name = "InvalidPayloadError";
   }
 };
+var BalancesUnavailableError = class extends Error {
+  retryable = true;
+  /** The underlying provider error message, when one was captured. */
+  providerError;
+  constructor(message, providerError) {
+    super(message);
+    this.name = "BalancesUnavailableError";
+    if (providerError !== void 0) this.providerError = providerError;
+  }
+};
 function nowSeconds() {
   return Math.floor(Date.now() / 1e3);
 }
 function delay2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
+function withTimeout(promise, ms, message) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve2(value);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
 function matchesFilter(event, filter) {
   if (filter.ids && !filter.ids.includes(event.id)) return false;
   if (filter.kinds && !filter.kinds.includes(event.kind)) return false;
@@ -2494,7 +2599,13 @@ function registerRoutes(app, runner) {
     }
   });
   app.get("/channels", async () => runner.getChannels());
-  app.get("/balances", async () => runner.getBalances());
+  app.get("/balances", async (_req, reply) => {
+    try {
+      return await runner.getBalances();
+    } catch (err) {
+      return mapError(reply, err);
+    }
+  });
   app.post("/channels/deposit", async (req, reply) => {
     try {
       return await runner.depositToChannel(req.body);
@@ -2547,11 +2658,15 @@ function registerRoutes(app, runner) {
   );
   app.post("/fund-wallet", async (req, reply) => {
     try {
-      return await runner.fundWallet(req.body ?? {});
+      return runner.fundWallet(req.body ?? {});
     } catch (err) {
       return mapError(reply, err);
     }
   });
+  app.get(
+    "/fund-wallet/status",
+    async (req) => runner.getFundStatus(req.query?.chain)
+  );
   app.get("/targets", async () => runner.getTargets());
   app.post("/relays", async (req, reply) => {
     const url = req.body?.relayUrl;
@@ -2627,6 +2742,12 @@ function mapError(reply, err) {
   if (err instanceof PublishRejectedError) {
     return sendError(reply, 502, "rejected", { detail: err.message });
   }
+  if (err instanceof BalancesUnavailableError) {
+    return sendError(reply, 504, "balances_unavailable", {
+      detail: err.message,
+      retryable: true
+    });
+  }
   if (err instanceof TargetError) {
     const status = /no such/i.test(err.message) ? 404 : 400;
     return sendError(reply, status, "invalid_target", { detail: err.message });
@@ -2662,4 +2783,4 @@ export {
   PublishRejectedError,
   registerRoutes
 };
-//# sourceMappingURL=chunk-ADBNZA5O.js.map
+//# sourceMappingURL=chunk-KVK6OZVD.js.map