@toon-protocol/client 0.14.4 → 0.14.6

package/dist/index.d.ts

@@ -5,6 +5,17 @@ import { NostrEvent, EventTemplate } from 'nostr-tools/pure';
 import { PrivateKeyAccount } from 'viem/accounts';
 export { A2uiDecision, ConsentDecision, ConsentRequest, DispatchGuardInfo, DispatchInput, GenerateContext, GeneratedRenderer, GenerativeDecision, GenerativeFallbackOptions, GenerativeFallbackRenderer, GenerativeFallbackResult, GuardedDispatchInput, IntentClassification, KindRegistry, MIME_A2UI, MIME_MCP_APP, McpUiDecision, NativeDecision, PublishBackOptions, RenderBranch, RenderDecision, RenderTrust, RendererGenerator, RendererPin, RendererPinStore, RendererPublisher, RendererSigner, ResolvedCoordinate, SwapApproval, SwapDecision, SwapRejection, SwapRejectionReason, UiResource, VerifyRendererInput, WidgetIntent, buildConsentRequest, buildRendererEventTemplate, classifyIntent, deterministicGenerator, extractUiResource, guardedRenderDispatch, isTrustDowngrade, publishBackCoordinate, renderDeterministicHtml, renderDispatch, resolveRendererMime, resolveUiCoordinate, resolveUiRenderer, verifyRendererTrust } from './render/index.js';
 
+/** One on-chain wallet token balance. `amount` is base-unit integer, decimal. */
+interface WalletBalance {
+    chain: 'evm' | 'solana' | 'mina';
+    address: string;
+    amount: string;
+    /** Token symbol, when resolved (e.g. `'USDC'`, `'MINA'`). */
+    asset?: string;
+    /** Token decimals, when resolved. */
+    assetScale?: number;
+}
+
 /**
  * Solana payment-channel parameters supplied via `ToonClientConfig.solanaChannel`.
  *
@@ -965,6 +976,8 @@ declare class ToonClient {
      */
     private minaPrivateKey?;
     private channelManager?;
+    /** Concrete on-chain client, kept so deposit/withdraw can reach chain methods. */
+    private onChainChannelClient?;
     private readonly peerNegotiations;
     /**
      * Creates a new ToonClient instance.
@@ -1210,6 +1223,32 @@ declare class ToonClient {
      * Gets the cumulative transferred amount for a tracked channel.
      */
     getChannelCumulativeAmount(channelId: string): bigint;
+    /**
+     * Gets the on-chain deposit total (locked collateral) for a tracked channel.
+     * The available (spendable) balance is this minus the cumulative spent amount.
+     */
+    getChannelDepositTotal(channelId: string): bigint;
+    /**
+     * Deposit additional collateral into an open channel. `amount` is the delta to
+     * add (base units, decimal string or bigint). The daemon signs its own tx; no
+     * key material leaves the client. Reads the current tracked deposit, performs
+     * the on-chain deposit, updates the tracked total, and returns the new total.
+     * EVM is live; Solana/Mina deposit lands in a follow-up.
+     */
+    depositToChannel(channelId: string, amount: string | bigint): Promise<{
+        channelId: string;
+        txHash?: string;
+        depositTotal: string;
+    }>;
+    /**
+     * Read the on-chain settlement-token balance of this client's OWN wallet on
+     * each configured chain (EVM token, Solana SPL, native MINA). A free read — no
+     * signing, no payment. Best-effort per chain: a chain whose config is absent or
+     * whose RPC read fails is omitted rather than failing the whole result, so the
+     * wallet view degrades gracefully. Available after `start()` (Solana/Mina keys
+     * are derived there).
+     */
+    getBalances(): Promise<WalletBalance[]>;
     /**
      * Resolves an ILP destination address to a peer ID.
      * Convention: destination "g.toon.peer1" → peerId "peer1" (last segment).
@@ -2110,6 +2149,29 @@ declare class OnChainChannelClient implements ConnectorChannelClient {
      * 4. Deposit initial funds if specified
      */
     openChannel(params: OpenChannelParams): Promise<OpenChannelResult>;
+    /**
+     * Deposit additional collateral into an already-open channel. `amount` is the
+     * DELTA to add (base units). Dispatches by the channel's cached chain context;
+     * `currentDeposit` is the channel's current locked total (tracked off-chain by
+     * the caller) — required for EVM, whose `setTotalDeposit` takes the new
+     * cumulative total, not a delta. Returns the new on-chain deposit total.
+     *
+     * Non-custodial: the client deposits its OWN funds and signs its OWN tx.
+     * EVM is live; Solana/Mina deposit extraction is a follow-up (PR B.1).
+     */
+    depositToChannel(channelId: string, amount: bigint, opts: {
+        currentDeposit: bigint;
+    }): Promise<{
+        txHash?: string;
+        depositTotal: bigint;
+    }>;
+    /**
+     * EVM deposit: approve the token-network for the delta if the allowance is
+     * short, then `setTotalDeposit(channelId, participant, current + delta)` —
+     * the contract takes the new cumulative total, so we add the delta to the
+     * caller-supplied current locked amount.
+     */
+    private depositEvm;
     /**
      * Opens a REAL on-chain Solana payment channel.
      *
@@ -2274,6 +2336,18 @@ declare class ChannelManager {
      * Gets the cumulative transferred amount for a tracked channel.
      */
     getCumulativeAmount(channelId: string): bigint;
+    /**
+     * Gets the on-chain deposit total (collateral locked at open / via deposits)
+     * for a tracked channel, or `0n` when none was captured. The available
+     * (spendable) balance is `depositTotal - cumulativeAmount`.
+     */
+    getDepositTotal(channelId: string): bigint;
+    /**
+     * Update the tracked on-chain deposit total after a successful deposit, so the
+     * available balance (`depositTotal - cumulativeAmount`) reflects the new
+     * collateral on the next read.
+     */
+    setDepositTotal(channelId: string, total: bigint): void;
     /**
      * Gets all tracked channel IDs.
      */

package/dist/index.js

@@ -1640,17 +1640,17 @@ function readDiscoveredIlpPeer(peer) {
 }
 function selectIlpTransport(peer, options = {}) {
   const needsDuplex = options.needsDuplex ?? false;
-  const http2 = peer.httpEndpoint?.trim() || void 0;
+  const http3 = peer.httpEndpoint?.trim() || void 0;
   const btp = peer.btpEndpoint?.trim() || void 0;
   const canUpgrade = peer.supportsUpgrade === true;
   if (needsDuplex) {
     if (btp) return { kind: "btp", btpEndpoint: btp };
-    if (http2 && canUpgrade) return { kind: "http-upgradable", httpEndpoint: http2 };
+    if (http3 && canUpgrade) return { kind: "http-upgradable", httpEndpoint: http3 };
     throw new Error(
       "Duplex transport required but peer exposes neither a btpEndpoint nor an upgradable httpEndpoint"
     );
   }
-  if (http2) return { kind: "http", httpEndpoint: http2, canUpgrade };
+  if (http3) return { kind: "http", httpEndpoint: http3, canUpgrade };
   if (btp) return { kind: "btp", btpEndpoint: btp };
   throw new Error("Peer exposes neither an httpEndpoint nor a btpEndpoint");
 }
@@ -2410,6 +2410,70 @@ var OnChainChannelClient = class {
     if (chainPrefix === "mina") return this.openMinaChannel(params);
     return this.openEvmChannel(params);
   }
+  /**
+   * Deposit additional collateral into an already-open channel. `amount` is the
+   * DELTA to add (base units). Dispatches by the channel's cached chain context;
+   * `currentDeposit` is the channel's current locked total (tracked off-chain by
+   * the caller) — required for EVM, whose `setTotalDeposit` takes the new
+   * cumulative total, not a delta. Returns the new on-chain deposit total.
+   *
+   * Non-custodial: the client deposits its OWN funds and signs its OWN tx.
+   * EVM is live; Solana/Mina deposit extraction is a follow-up (PR B.1).
+   */
+  async depositToChannel(channelId, amount, opts) {
+    if (amount <= 0n) throw new Error("Deposit amount must be positive.");
+    const ctx = this.channelContext.get(channelId);
+    if (!ctx) {
+      throw new Error(
+        `No on-chain context for channel "${channelId}" \u2014 it must be opened by this client first.`
+      );
+    }
+    const chainPrefix = ctx.chain.split(":")[0];
+    if (chainPrefix === "solana" || chainPrefix === "mina") {
+      throw new Error(
+        `Deposit on ${chainPrefix} is not yet supported (EVM only; follow-up PR adds it).`
+      );
+    }
+    return this.depositEvm(channelId, amount, opts.currentDeposit, ctx);
+  }
+  /**
+   * EVM deposit: approve the token-network for the delta if the allowance is
+   * short, then `setTotalDeposit(channelId, participant, current + delta)` —
+   * the contract takes the new cumulative total, so we add the delta to the
+   * caller-supplied current locked amount.
+   */
+  async depositEvm(channelId, amount, currentDeposit, ctx) {
+    const { publicClient, walletClient } = this.createClients(ctx.chain);
+    const tokenNetworkAddr = ctx.tokenNetworkAddress;
+    const myAddress = this.evmSigner.address;
+    const newTotal = currentDeposit + amount;
+    if (ctx.tokenAddress) {
+      const tokenAddr = ctx.tokenAddress;
+      const allowance = await publicClient.readContract({
+        address: tokenAddr,
+        abi: ERC20_ABI,
+        functionName: "allowance",
+        args: [myAddress, tokenNetworkAddr]
+      });
+      if (allowance < amount) {
+        const approveHash = await walletClient.writeContract({
+          address: tokenAddr,
+          abi: ERC20_ABI,
+          functionName: "approve",
+          args: [tokenNetworkAddr, maxUint256]
+        });
+        await publicClient.waitForTransactionReceipt({ hash: approveHash });
+      }
+    }
+    const depositHash = await walletClient.writeContract({
+      address: tokenNetworkAddr,
+      abi: TOKEN_NETWORK_ABI,
+      functionName: "setTotalDeposit",
+      args: [channelId, myAddress, newTotal]
+    });
+    await publicClient.waitForTransactionReceipt({ hash: depositHash });
+    return { txHash: depositHash, depositTotal: newTotal };
+  }
   /**
    * Opens a REAL on-chain Solana payment channel.
    *
@@ -2611,7 +2675,8 @@ var OnChainChannelClient = class {
     }
     this.channelContext.set(channelId, {
       chain,
-      tokenNetworkAddress: tokenNetwork
+      tokenNetworkAddress: tokenNetwork,
+      ...params.token ? { tokenAddress: params.token } : {}
     });
     if (deposit > 0n) {
       const depositHash = await walletClient.writeContract({
@@ -3489,6 +3554,30 @@ var ChannelManager = class {
     }
     return tracking.cumulativeAmount;
   }
+  /**
+   * Gets the on-chain deposit total (collateral locked at open / via deposits)
+   * for a tracked channel, or `0n` when none was captured. The available
+   * (spendable) balance is `depositTotal - cumulativeAmount`.
+   */
+  getDepositTotal(channelId) {
+    const tracking = this.channels.get(channelId);
+    if (!tracking) {
+      throw new Error(`Channel "${channelId}" is not being tracked.`);
+    }
+    return tracking.depositTotal ?? 0n;
+  }
+  /**
+   * Update the tracked on-chain deposit total after a successful deposit, so the
+   * available balance (`depositTotal - cumulativeAmount`) reflects the new
+   * collateral on the next read.
+   */
+  setDepositTotal(channelId, total) {
+    const tracking = this.channels.get(channelId);
+    if (!tracking) {
+      throw new Error(`Channel "${channelId}" is not being tracked.`);
+    }
+    tracking.depositTotal = total;
+  }
   /**
    * Gets all tracked channel IDs.
    */
@@ -3547,6 +3636,91 @@ var JsonFileChannelStore = class {
   }
 };
 
+// src/balance/WalletBalanceReader.ts
+import { createPublicClient as createPublicClient2, http as http2, defineChain as defineChain2 } from "viem";
+var ERC20_READ_ABI = [
+  { name: "balanceOf", type: "function", stateMutability: "view", inputs: [{ name: "account", type: "address" }], outputs: [{ type: "uint256" }] },
+  { name: "decimals", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "uint8" }] },
+  { name: "symbol", type: "function", stateMutability: "view", inputs: [], outputs: [{ type: "string" }] }
+];
+function parseEvmChainId(chainKey) {
+  const parts = chainKey.split(":");
+  const idStr = parts.length >= 3 ? parts[2] : parts[1];
+  const id = Number.parseInt(idStr ?? "", 10);
+  if (!Number.isFinite(id)) throw new Error(`Invalid EVM chain key "${chainKey}".`);
+  return id;
+}
+async function readEvmTokenBalance(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 token = opts.tokenAddress;
+  const owner = opts.owner;
+  const [amount, decimals, symbol] = await Promise.all([
+    client.readContract({ address: token, abi: ERC20_READ_ABI, functionName: "balanceOf", args: [owner] }),
+    client.readContract({ address: token, abi: ERC20_READ_ABI, functionName: "decimals" }).catch(() => void 0),
+    client.readContract({ address: token, abi: ERC20_READ_ABI, functionName: "symbol" }).catch(() => void 0)
+  ]);
+  const out = { chain: "evm", address: opts.owner, amount: amount.toString() };
+  if (typeof symbol === "string" && symbol) out.asset = symbol;
+  if (decimals !== void 0) out.assetScale = Number(decimals);
+  return out;
+}
+async function readSolanaTokenBalance(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: "getTokenAccountsByOwner",
+      params: [opts.owner, { mint: opts.mint }, { encoding: "jsonParsed", 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"}`);
+  let amount = 0n;
+  let decimals;
+  for (const acc of json.result?.value ?? []) {
+    const ta = acc.account?.data?.parsed?.info?.tokenAmount;
+    if (ta?.amount) amount += BigInt(ta.amount);
+    if (ta?.decimals !== void 0) decimals = ta.decimals;
+  }
+  const out = { chain: "solana", address: opts.owner, amount: amount.toString() };
+  if (decimals !== void 0) out.assetScale = decimals;
+  return out;
+}
+async function readMinaBalance(opts) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const query = "query($pk:String!){account(publicKey:$pk){balance{total}}}";
+  const res = await fetchImpl(opts.graphqlUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ query, variables: { pk: opts.owner } })
+  });
+  if (!res.ok) throw new Error(`Mina GraphQL request failed: HTTP ${res.status}`);
+  const json = await res.json();
+  if (json.errors && json.errors.length > 0) {
+    throw new Error(`Mina GraphQL error: ${json.errors[0]?.message ?? "unknown"}`);
+  }
+  return {
+    chain: "mina",
+    address: opts.owner,
+    amount: String(json.data?.account?.balance?.total ?? "0"),
+    asset: "MINA",
+    assetScale: 9
+  };
+}
+
 // src/blob-storage.ts
 import { buildBlobStorageRequest } from "@toon-protocol/core";
 var ARWEAVE_TX_ID_REGEX = /^[A-Za-z0-9_-]{43}$/;
@@ -3617,8 +3791,8 @@ async function requestBlobStorage(client, secretKey, params) {
   };
 }
 function extractArweaveTxId(base64Data) {
-  const http2 = parseFulfillHttp(base64Data);
-  if (!http2.isHttp) {
+  const http3 = parseFulfillHttp(base64Data);
+  if (!http3.isHttp) {
     const legacy = decodeUtf8(fromBase64(base64Data));
     if (!ARWEAVE_TX_ID_REGEX.test(legacy)) {
       throw new Error(
@@ -3627,18 +3801,18 @@ function extractArweaveTxId(base64Data) {
     }
     return legacy;
   }
-  if (http2.status < 200 || http2.status >= 300) {
-    const detail = http2.body ? ` - ${http2.body}` : "";
+  if (http3.status < 200 || http3.status >= 300) {
+    const detail = http3.body ? ` - ${http3.body}` : "";
     throw new Error(
-      `Blob upload failed: DVM returned HTTP ${http2.status} ${http2.statusText}`.trimEnd() + detail
+      `Blob upload failed: DVM returned HTTP ${http3.status} ${http3.statusText}`.trimEnd() + detail
     );
   }
   let parsed;
   try {
-    parsed = JSON.parse(http2.body);
+    parsed = JSON.parse(http3.body);
   } catch {
     throw new Error(
-      `Blob upload response body was not valid JSON: "${http2.body}"`
+      `Blob upload response body was not valid JSON: "${http3.body}"`
     );
   }
   const body = parsed;
@@ -3656,7 +3830,7 @@ function extractArweaveTxId(base64Data) {
     }
   }
   throw new Error(
-    `Blob upload response did not contain a valid Arweave tx ID: "${http2.body}"`
+    `Blob upload response did not contain a valid Arweave tx ID: "${http3.body}"`
   );
 }
 
@@ -3932,6 +4106,8 @@ var ToonClient = class {
    */
   minaPrivateKey;
   channelManager;
+  /** Concrete on-chain client, kept so deposit/withdraw can reach chain methods. */
+  onChainChannelClient;
   peerNegotiations = /* @__PURE__ */ new Map();
   /**
    * Creates a new ToonClient instance.
@@ -4125,6 +4301,7 @@ var ToonClient = class {
         }
       }
       if (this.channelManager && initialization.onChainChannelClient) {
+        this.onChainChannelClient = initialization.onChainChannelClient;
         this.channelManager.setChannelClient(
           initialization.onChainChannelClient
         );
@@ -4533,6 +4710,84 @@ var ToonClient = class {
     if (!this.channelManager) throw new Error("ChannelManager not initialized");
     return this.channelManager.getCumulativeAmount(channelId);
   }
+  /**
+   * Gets the on-chain deposit total (locked collateral) for a tracked channel.
+   * The available (spendable) balance is this minus the cumulative spent amount.
+   */
+  getChannelDepositTotal(channelId) {
+    if (!this.channelManager) throw new Error("ChannelManager not initialized");
+    return this.channelManager.getDepositTotal(channelId);
+  }
+  /**
+   * Deposit additional collateral into an open channel. `amount` is the delta to
+   * add (base units, decimal string or bigint). The daemon signs its own tx; no
+   * key material leaves the client. Reads the current tracked deposit, performs
+   * the on-chain deposit, updates the tracked total, and returns the new total.
+   * EVM is live; Solana/Mina deposit lands in a follow-up.
+   */
+  async depositToChannel(channelId, amount) {
+    if (!this.channelManager) throw new Error("ChannelManager not initialized");
+    if (!this.onChainChannelClient) {
+      throw new Error("On-chain channel client not configured (no chainRpcUrls).");
+    }
+    const delta = BigInt(amount);
+    if (delta <= 0n) throw new Error("Deposit amount must be positive.");
+    const currentDeposit = this.channelManager.getDepositTotal(channelId);
+    const result = await this.onChainChannelClient.depositToChannel(channelId, delta, {
+      currentDeposit
+    });
+    this.channelManager.setDepositTotal(channelId, result.depositTotal);
+    return {
+      channelId,
+      ...result.txHash ? { txHash: result.txHash } : {},
+      depositTotal: result.depositTotal.toString()
+    };
+  }
+  /**
+   * Read the on-chain settlement-token balance of this client's OWN wallet on
+   * each configured chain (EVM token, Solana SPL, native MINA). A free read — no
+   * signing, no payment. Best-effort per chain: a chain whose config is absent or
+   * whose RPC read fails is omitted rather than failing the whole result, so the
+   * wallet view degrades gracefully. Available after `start()` (Solana/Mina keys
+   * are derived there).
+   */
+  async getBalances() {
+    const out = [];
+    const evmAddress = this.getEvmAddress();
+    const rpcUrls = this.config.chainRpcUrls;
+    const tokens = this.config.preferredTokens;
+    if (evmAddress && rpcUrls && tokens) {
+      const chainKeys = this.config.supportedChains ?? Object.keys(rpcUrls);
+      const chainKey = chainKeys.find((c) => c.startsWith("evm") && rpcUrls[c] && tokens[c]);
+      const rpcUrl = chainKey ? rpcUrls[chainKey] : void 0;
+      const tokenAddress = chainKey ? tokens[chainKey] : void 0;
+      if (chainKey && rpcUrl && tokenAddress) {
+        try {
+          out.push(await readEvmTokenBalance({ rpcUrl, chainKey, tokenAddress, owner: evmAddress }));
+        } catch {
+        }
+      }
+    }
+    const solAddress = this.getSolanaAddress();
+    const sol = this.config.solanaChannel;
+    if (solAddress && sol?.rpcUrl && sol.tokenMint) {
+      try {
+        out.push(
+          await readSolanaTokenBalance({ rpcUrl: sol.rpcUrl, mint: sol.tokenMint, owner: solAddress })
+        );
+      } catch {
+      }
+    }
+    const minaAddress = this.getMinaAddress();
+    const mina = this.config.minaChannel;
+    if (minaAddress && mina?.graphqlUrl) {
+      try {
+        out.push(await readMinaBalance({ graphqlUrl: mina.graphqlUrl, owner: minaAddress }));
+      } catch {
+      }
+    }
+    return out;
+  }
   /**
    * Resolves an ILP destination address to a peer ID.
    * Convention: destination "g.toon.peer1" → peerId "peer1" (last segment).