@toon-protocol/client-mcp 0.14.0 → 0.14.1

package/dist/{chunk-SL7UGVOC.js → chunk-N7MWQMBC.js}

@@ -2,7 +2,7 @@ import { createRequire as __cr } from 'module'; const require = __cr(import.meta
 import {
   ControlApiError,
   DaemonUnreachableError
-} from "./chunk-UXCFHAUC.js";
+} from "./chunk-P7YF72JB.js";
 
 // ../views/dist/tool-names.js
 var PUBLISH_TOOL = "toon_publish_unsigned";
@@ -1811,4 +1811,4 @@ export {
   TOOL_DEFINITIONS,
   dispatchTool
 };
-//# sourceMappingURL=chunk-SL7UGVOC.js.map
+//# sourceMappingURL=chunk-N7MWQMBC.js.map

package/dist/{chunk-UXCFHAUC.js → chunk-P7YF72JB.js}

@@ -10333,6 +10333,38 @@ async function readEvmTokenBalance(opts) {
   if (decimals !== void 0) out.assetScale = Number(decimals);
   return out;
 }
+async function readEvmNativeBalance(opts) {
+  const chainId = parseEvmChainId(opts.chainKey);
+  const client = createPublicClient2({
+    transport: http2(opts.rpcUrl),
+    chain: defineChain2({
+      id: chainId,
+      name: opts.chainKey,
+      nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+      rpcUrls: { default: { http: [opts.rpcUrl] } }
+    })
+  });
+  const wei = await client.getBalance({ address: opts.owner });
+  return { symbol: "ETH", amount: wei.toString(), decimals: 18 };
+}
+async function readSolanaNativeBalance(opts) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const res = await fetchImpl(opts.rpcUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "getBalance",
+      params: [opts.owner, { commitment: "confirmed" }]
+    })
+  });
+  if (!res.ok) throw new Error(`Solana RPC request failed: HTTP ${res.status}`);
+  const json = await res.json();
+  if (json.error) throw new Error(`Solana RPC error: ${json.error.message ?? "unknown"}`);
+  const lamports = BigInt(json.result?.value ?? 0);
+  return { symbol: "SOL", amount: lamports.toString(), decimals: 9 };
+}
 async function readSolanaTokenBalance(opts) {
   const fetchImpl = opts.fetchImpl ?? fetch;
   const res = await fetchImpl(opts.rpcUrl, {
@@ -10380,6 +10412,95 @@ async function readMinaBalance(opts) {
     assetScale: 9
   };
 }
+var errText = (e) => e instanceof Error ? e.message : String(e);
+function foldNative(out, settled, errors) {
+  if (settled.status === "fulfilled") out.native = settled.value;
+  else errors.push(errText(settled.reason));
+}
+function foldToken(out, settled, tokenAddress, errors) {
+  if (settled.status === "rejected") {
+    errors.push(errText(settled.reason));
+    return;
+  }
+  const bal = settled.value;
+  if (!bal) return;
+  out.tokens.push({
+    symbol: bal.asset,
+    amount: bal.amount,
+    decimals: bal.assetScale,
+    ...tokenAddress ? { address: tokenAddress } : {}
+  });
+}
+function finalizeChain(out, errors) {
+  if (errors.length > 0) out.error = errors[0];
+  if (out.native === void 0 && out.tokens.length === 0) out.unreadable = true;
+}
+async function readWalletBalances(sources) {
+  const { fetchImpl } = sources;
+  const tasks = [];
+  if (sources.evm) {
+    const { chainKey, rpcUrl, owner, tokenAddress } = sources.evm;
+    tasks.push(
+      (async () => {
+        const out = { chain: "evm", chainKey, address: owner, tokens: [] };
+        const errors = [];
+        const [nativeR, tokenR] = await Promise.allSettled([
+          readEvmNativeBalance({ rpcUrl, chainKey, owner }),
+          tokenAddress ? readEvmTokenBalance({ rpcUrl, chainKey, tokenAddress, owner }) : Promise.resolve(void 0)
+        ]);
+        foldNative(out, nativeR, errors);
+        foldToken(out, tokenR, tokenAddress, errors);
+        finalizeChain(out, errors);
+        return out;
+      })()
+    );
+  }
+  if (sources.solana) {
+    const { chainKey = "solana", rpcUrl, owner, tokenMint } = sources.solana;
+    tasks.push(
+      (async () => {
+        const out = { chain: "solana", chainKey, address: owner, tokens: [] };
+        const errors = [];
+        const [nativeR, tokenR] = await Promise.allSettled([
+          readSolanaNativeBalance({ rpcUrl, owner, fetchImpl }),
+          tokenMint ? readSolanaTokenBalance({ rpcUrl, mint: tokenMint, owner, fetchImpl }) : Promise.resolve(void 0)
+        ]);
+        foldNative(out, nativeR, errors);
+        if (tokenR.status === "fulfilled" && tokenR.value && tokenR.value.asset === void 0) {
+          tokenR.value.asset = "USDC";
+        }
+        foldToken(out, tokenR, tokenMint, errors);
+        finalizeChain(out, errors);
+        return out;
+      })()
+    );
+  }
+  if (sources.mina) {
+    const { chainKey = "mina", graphqlUrl, owner } = sources.mina;
+    tasks.push(
+      (async () => {
+        const out = { chain: "mina", chainKey, address: owner, tokens: [] };
+        const errors = [];
+        const nativeR = await Promise.allSettled([readMinaBalance({ graphqlUrl, owner, fetchImpl })]);
+        foldNative(
+          out,
+          nativeR[0].status === "fulfilled" ? {
+            status: "fulfilled",
+            value: {
+              symbol: nativeR[0].value.asset,
+              amount: nativeR[0].value.amount,
+              decimals: nativeR[0].value.assetScale
+            }
+          } : nativeR[0],
+          errors
+        );
+        finalizeChain(out, errors);
+        return out;
+      })()
+    );
+  }
+  return Promise.all(tasks);
+}
 var ARWEAVE_TX_ID_REGEX = /^[A-Za-z0-9_-]{43}$/;
 async function requestBlobStorage(client, secretKey, params) {
   const bid = params.bid ?? (params.ilpAmount !== void 0 ? String(params.ilpAmount) : void 0);
@@ -11523,6 +11644,74 @@ var ToonClient = class {
     }
     return out;
   }
+  /**
+   * The FULL multi-chain wallet view (#299): for every chain the identity is
+   * configured for, the native coin (ETH / SOL / MINA) AND every configured
+   * token (USDC), grouped per chain with the identity's address on that chain.
+   * A superset of {@link getBalances} — which stays scoped to the channel's
+   * settlement token — kept as a separate reader so channel-settlement callers
+   * are unaffected.
+   *
+   * FREE: read-only RPC, no signing, no payment. Works on an UNSTARTED client:
+   * the Solana/Mina addresses (which the signers only register during
+   * `start()`) are derived on demand from the retained mnemonic — the SAME keys
+   * `start()` would register and that `rig fund` prints — so all configured
+   * chains appear even before a start. Best-effort per chain: an unreachable
+   * RPC yields `{ unreadable: true }` for that chain, never failing the others.
+   */
+  async getWalletBalances() {
+    const sources = {};
+    let derived;
+    let derivedTried = false;
+    const ensureDerived = async () => {
+      if (derivedTried) return derived;
+      derivedTried = true;
+      if (this.config.mnemonic) {
+        derived = await deriveFullIdentity(
+          this.config.mnemonic,
+          this.config.mnemonicAccountIndex ?? 0
+        );
+      }
+      return derived;
+    };
+    const evmAddress = this.getEvmAddress();
+    const rpcUrls = this.config.chainRpcUrls;
+    const tokens = this.config.preferredTokens;
+    if (evmAddress && rpcUrls) {
+      const usableEvm = (c) => c.startsWith("evm") && Boolean(rpcUrls[c]);
+      const settlementKeys = Object.keys(this.config.settlementAddresses ?? {});
+      const chainKeys = this.config.supportedChains ?? Object.keys(rpcUrls);
+      const chainKey = settlementKeys.find(usableEvm) ?? chainKeys.find(usableEvm);
+      if (chainKey && rpcUrls[chainKey]) {
+        sources.evm = {
+          chainKey,
+          rpcUrl: rpcUrls[chainKey],
+          owner: evmAddress,
+          ...tokens?.[chainKey] ? { tokenAddress: tokens[chainKey] } : {}
+        };
+      }
+    }
+    const sol = this.config.solanaChannel;
+    if (sol?.rpcUrl) {
+      const solAddress = this.getSolanaAddress() ?? (await ensureDerived())?.solana.publicKey;
+      if (solAddress) {
+        sources.solana = {
+          chainKey: "solana",
+          rpcUrl: sol.rpcUrl,
+          owner: solAddress,
+          ...sol.tokenMint ? { tokenMint: sol.tokenMint } : {}
+        };
+      }
+    }
+    const mina = this.config.minaChannel;
+    if (mina?.graphqlUrl) {
+      const minaAddress = this.getMinaAddress() ?? (await ensureDerived())?.mina.publicKey;
+      if (minaAddress) {
+        sources.mina = { chainKey: "mina", graphqlUrl: mina.graphqlUrl, owner: minaAddress };
+      }
+    }
+    return readWalletBalances(sources);
+  }
   /**
    * Resolves an ILP destination address to a peer ID.
    * Convention: destination "g.toon.peer1" → peerId "peer1" (last segment).
@@ -12945,4 +13134,4 @@ export {
 @scure/bip32/lib/esm/index.js:
   (*! scure-bip32 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=chunk-UXCFHAUC.js.map
+//# sourceMappingURL=chunk-P7YF72JB.js.map