@toon-protocol/client 0.14.5 → 0.14.7

package/dist/index.d.ts

@@ -976,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.
@@ -1226,6 +1228,18 @@ declare class ToonClient {
      * 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
@@ -2135,6 +2149,36 @@ 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;
+    }>;
+    /**
+     * Solana deposit: fire the standalone `deposit` instruction against the channel
+     * vault. Incremental on-chain (the program adds `amount`), so the new total is
+     * the caller-tracked current plus the delta. Requires the funded payer token
+     * account (the funded ATA) from the Solana channel config.
+     */
+    private depositSolana;
+    /**
+     * 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.
      *
@@ -2305,6 +2349,12 @@ declare class ChannelManager {
      * (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

@@ -2035,29 +2035,44 @@ async function openSolanaChannel(params) {
   ]);
   let depositTxSignature;
   if (params.deposit && params.deposit.amount > 0n) {
-    const depositData = new Uint8Array(16);
-    depositData.set(IX_DEPOSIT, 0);
-    writeU64LE(depositData, 8, params.deposit.amount);
-    depositTxSignature = await buildAndSendTransaction(rpcUrl, payer, [
-      {
-        programId,
-        keys: [
-          { pubkey: payerPubkey, isSigner: true, isWritable: false },
-          {
-            pubkey: params.deposit.payerTokenAccount,
-            isSigner: false,
-            isWritable: true
-          },
-          { pubkey: vaultPDA, isSigner: false, isWritable: true },
-          { pubkey: channelPDA, isSigner: false, isWritable: true },
-          { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }
-        ],
-        data: depositData
-      }
-    ]);
+    ({ depositTxSignature } = await depositSolanaChannel({
+      rpcUrl,
+      programId,
+      channelPDA,
+      payerSeed,
+      payerPubkey,
+      payerTokenAccount: params.deposit.payerTokenAccount,
+      amount: params.deposit.amount
+    }));
   }
   return { channelPDA, opened: true, initTxSignature, depositTxSignature };
 }
+async function depositSolanaChannel(params) {
+  const { rpcUrl, programId, channelPDA, payerSeed, payerPubkey, payerTokenAccount, amount } = params;
+  if (amount <= 0n) throw new Error("Solana deposit amount must be positive.");
+  const payer = {
+    publicKey: padTo32(base58Decode(payerPubkey)),
+    privateKey: payerSeed
+  };
+  const { pda: vaultPDA } = deriveVaultPDA(channelPDA, programId);
+  const depositData = new Uint8Array(16);
+  depositData.set(IX_DEPOSIT, 0);
+  writeU64LE(depositData, 8, amount);
+  const depositTxSignature = await buildAndSendTransaction(rpcUrl, payer, [
+    {
+      programId,
+      keys: [
+        { pubkey: payerPubkey, isSigner: true, isWritable: false },
+        { pubkey: payerTokenAccount, isSigner: false, isWritable: true },
+        { pubkey: vaultPDA, isSigner: false, isWritable: true },
+        { pubkey: channelPDA, isSigner: false, isWritable: true },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }
+      ],
+      data: depositData
+    }
+  ]);
+  return { depositTxSignature };
+}
 
 // src/channel/mina-channel-open.ts
 import { hexToMinaBase58PrivateKey as hexToMinaBase58PrivateKey2 } from "@toon-protocol/core";
@@ -2410,6 +2425,101 @@ 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") {
+      return this.depositSolana(channelId, amount, opts.currentDeposit);
+    }
+    if (chainPrefix === "mina") {
+      throw new Error("Deposit on mina is not yet supported (EVM + Solana today; Mina follow-up).");
+    }
+    return this.depositEvm(channelId, amount, opts.currentDeposit, ctx);
+  }
+  /**
+   * Solana deposit: fire the standalone `deposit` instruction against the channel
+   * vault. Incremental on-chain (the program adds `amount`), so the new total is
+   * the caller-tracked current plus the delta. Requires the funded payer token
+   * account (the funded ATA) from the Solana channel config.
+   */
+  async depositSolana(channelId, amount, currentDeposit) {
+    if (!this.solanaConfig) {
+      throw new Error("Solana channel config not set \u2014 cannot deposit.");
+    }
+    const cfg = this.solanaConfig;
+    const payerTokenAccount = cfg.deposit?.payerTokenAccount;
+    if (!payerTokenAccount) {
+      throw new Error(
+        "Solana deposit requires solanaConfig.deposit.payerTokenAccount (the funded SPL token account)."
+      );
+    }
+    const payerSeed = cfg.keypair.slice(0, 32);
+    const payerPubkey = base58Encode2(new Uint8Array(ed255192.getPublicKey(payerSeed)));
+    const { depositTxSignature } = await depositSolanaChannel({
+      rpcUrl: cfg.rpcUrl,
+      programId: cfg.programId,
+      channelPDA: channelId,
+      payerSeed,
+      payerPubkey,
+      payerTokenAccount,
+      amount
+    });
+    return { txHash: depositTxSignature, depositTotal: currentDeposit + amount };
+  }
+  /**
+   * 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 +2721,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({
@@ -3501,6 +3612,18 @@ var ChannelManager = class {
     }
     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.
    */
@@ -4029,6 +4152,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.
@@ -4222,6 +4347,7 @@ var ToonClient = class {
         }
       }
       if (this.channelManager && initialization.onChainChannelClient) {
+        this.onChainChannelClient = initialization.onChainChannelClient;
         this.channelManager.setChannelClient(
           initialization.onChainChannelClient
         );
@@ -4638,6 +4764,31 @@ var ToonClient = class {
     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