@owney/sdk 0.7.26-beta.7 → 0.7.26-beta.8

package/dist/index.cjs

@@ -5199,6 +5199,64 @@ var OwneySDK = class {
    * the deposit's own check is the authority and refusing to even attempt
    * would strand funds we might have been able to move.
    */
+  /** ERC20 balance of the connected wallet, read through the wallet's own node. */
+  async readTokenBalance(chainId, token) {
+    const state = this.requireState();
+    return readErc20Balance(
+      (0, import_viem9.createPublicClient)({
+        chain: swapChain(chainId),
+        transport: (0, import_viem9.custom)(this.requireConnectedProvider())
+      }),
+      token,
+      state.walletAddress
+    );
+  }
+  /** How much of `token` the wallet has already approved Permit2 to move. */
+  async readTokenPermit2Allowance(chainId, token) {
+    const state = this.requireState();
+    return readPermit2Allowance(
+      (0, import_viem9.createPublicClient)({
+        chain: swapChain(chainId),
+        transport: (0, import_viem9.custom)(this.requireConnectedProvider())
+      }),
+      token,
+      state.walletAddress
+    );
+  }
+  /**
+   * How much of a landed swap to actually deposit.
+   *
+   * The swap reports what ARRIVED, and the deposit used to be handed that
+   * figure directly. It is the entire arrival, so there is no slack: anything
+   * that spends the target asset between the two fails the deposit outright.
+   *
+   * Something does. A first WETH deposit needs a one-time Permit2 approval,
+   * and that approval is a transaction. A wallet holding no native gas token -
+   * the normal state of someone who just swapped everything INTO WETH - pays
+   * for it out of the WETH. The deposit then asked for ~2e12 wei more than was
+   * left and refused with DEPOSIT_INSUFFICIENT_BALANCE, under a wrapper saying
+   * the funds were safe but unadded (ROUT-242).
+   *
+   * So the approval happens here, before the amount is settled, and the amount
+   * comes from a read taken after it. Two things this deliberately is not:
+   *
+   * - It is not a balance sweep. `received` is a DELTA over the pre-swap
+   *   balance, so a wallet already holding WETH reads far above it; depositing
+   *   the balance would move funds the user never offered. The arrival is the
+   *   ceiling and the balance is only ever allowed to lower it.
+   * - It does not touch USDC, which moves on signed typed data and so spends
+   *   nothing of the user's in between, nor a paymaster-configured client,
+   *   where the sponsor covers the transfer and Permit2 never applies.
+   */
+  async settleSwapDepositAmount(chainId, token, symbol, received) {
+    if (symbol !== "WETH" || this.paymasterServiceUrl) {
+      return received.toString();
+    }
+    const allowance = await this.readTokenPermit2Allowance(chainId, token);
+    if (allowance < received) await this.approvePermit2();
+    const balance = await this.readTokenBalance(chainId, token);
+    return (balance < received ? balance : received).toString();
+  }
   async walletSeesBalance(chainId, token, amount) {
     const provider = this.requireConnectedProvider();
     const state = this.requireState();
@@ -5427,7 +5485,7 @@ var OwneySDK = class {
    */
   async getWalletBalances(chainIds) {
     const state = this.requireState();
-    const chains = chainIds ?? SUPPORTED_CHAIN_IDS;
+    const chains = chainIds ?? SWAP_CHAIN_IDS;
     const failedChainIds = [];
     const results = await Promise.all(
       chains.map(async (chainId) => {
@@ -5533,12 +5591,18 @@ var OwneySDK = class {
         quote.dst.address,
         BigInt(swap.received)
       );
+      const amount = await this.settleSwapDepositAmount(
+        quote.dst.chainId,
+        quote.dst.address,
+        options.to.symbol,
+        BigInt(swap.received)
+      );
       const deposit = await this.deposit({
-        amount: swap.received,
+        amount,
         asset: options.to.symbol,
         ...options.agentId ? { agentId: options.agentId } : {}
       });
-      return { swap, deposit };
+      return { swap, deposit, deposited: amount };
     } catch (error) {
       const pending = {
         id: `${quote.dst.chainId}-${options.to.symbol}-${Date.now()}`,

package/dist/index.d.cts

@@ -1129,6 +1129,36 @@ declare class OwneySDK {
      * the deposit's own check is the authority and refusing to even attempt
      * would strand funds we might have been able to move.
      */
+    /** ERC20 balance of the connected wallet, read through the wallet's own node. */
+    private readTokenBalance;
+    /** How much of `token` the wallet has already approved Permit2 to move. */
+    private readTokenPermit2Allowance;
+    /**
+     * How much of a landed swap to actually deposit.
+     *
+     * The swap reports what ARRIVED, and the deposit used to be handed that
+     * figure directly. It is the entire arrival, so there is no slack: anything
+     * that spends the target asset between the two fails the deposit outright.
+     *
+     * Something does. A first WETH deposit needs a one-time Permit2 approval,
+     * and that approval is a transaction. A wallet holding no native gas token -
+     * the normal state of someone who just swapped everything INTO WETH - pays
+     * for it out of the WETH. The deposit then asked for ~2e12 wei more than was
+     * left and refused with DEPOSIT_INSUFFICIENT_BALANCE, under a wrapper saying
+     * the funds were safe but unadded (ROUT-242).
+     *
+     * So the approval happens here, before the amount is settled, and the amount
+     * comes from a read taken after it. Two things this deliberately is not:
+     *
+     * - It is not a balance sweep. `received` is a DELTA over the pre-swap
+     *   balance, so a wallet already holding WETH reads far above it; depositing
+     *   the balance would move funds the user never offered. The arrival is the
+     *   ceiling and the balance is only ever allowed to lower it.
+     * - It does not touch USDC, which moves on signed typed data and so spends
+     *   nothing of the user's in between, nor a paymaster-configured client,
+     *   where the sponsor covers the transfer and Permit2 never applies.
+     */
+    private settleSwapDepositAmount;
     private walletSeesBalance;
     /**
      * Runs a quoted swap. A named seam rather than an inline `executeSwap` call
@@ -1328,6 +1358,12 @@ declare class OwneySDK {
             txHash?: string;
         };
         deposit: OwneyDepositResult | OwneyMultiDepositResult;
+        /**
+         * What was actually deposited, which is not always what the swap
+         * delivered - see `settleSwapDepositAmount`. Callers seeding a headline
+         * want this one; `swap.received` stays what it says it is.
+         */
+        deposited: string;
     }>;
     /**
      * Withdraw from an agent and swap the proceeds into whatever the user wants

package/dist/index.d.ts

@@ -1129,6 +1129,36 @@ declare class OwneySDK {
      * the deposit's own check is the authority and refusing to even attempt
      * would strand funds we might have been able to move.
      */
+    /** ERC20 balance of the connected wallet, read through the wallet's own node. */
+    private readTokenBalance;
+    /** How much of `token` the wallet has already approved Permit2 to move. */
+    private readTokenPermit2Allowance;
+    /**
+     * How much of a landed swap to actually deposit.
+     *
+     * The swap reports what ARRIVED, and the deposit used to be handed that
+     * figure directly. It is the entire arrival, so there is no slack: anything
+     * that spends the target asset between the two fails the deposit outright.
+     *
+     * Something does. A first WETH deposit needs a one-time Permit2 approval,
+     * and that approval is a transaction. A wallet holding no native gas token -
+     * the normal state of someone who just swapped everything INTO WETH - pays
+     * for it out of the WETH. The deposit then asked for ~2e12 wei more than was
+     * left and refused with DEPOSIT_INSUFFICIENT_BALANCE, under a wrapper saying
+     * the funds were safe but unadded (ROUT-242).
+     *
+     * So the approval happens here, before the amount is settled, and the amount
+     * comes from a read taken after it. Two things this deliberately is not:
+     *
+     * - It is not a balance sweep. `received` is a DELTA over the pre-swap
+     *   balance, so a wallet already holding WETH reads far above it; depositing
+     *   the balance would move funds the user never offered. The arrival is the
+     *   ceiling and the balance is only ever allowed to lower it.
+     * - It does not touch USDC, which moves on signed typed data and so spends
+     *   nothing of the user's in between, nor a paymaster-configured client,
+     *   where the sponsor covers the transfer and Permit2 never applies.
+     */
+    private settleSwapDepositAmount;
     private walletSeesBalance;
     /**
      * Runs a quoted swap. A named seam rather than an inline `executeSwap` call
@@ -1328,6 +1358,12 @@ declare class OwneySDK {
             txHash?: string;
         };
         deposit: OwneyDepositResult | OwneyMultiDepositResult;
+        /**
+         * What was actually deposited, which is not always what the swap
+         * delivered - see `settleSwapDepositAmount`. Callers seeding a headline
+         * want this one; `swap.received` stays what it says it is.
+         */
+        deposited: string;
     }>;
     /**
      * Withdraw from an agent and swap the proceeds into whatever the user wants

package/dist/index.js

@@ -5180,6 +5180,64 @@ var OwneySDK = class {
    * the deposit's own check is the authority and refusing to even attempt
    * would strand funds we might have been able to move.
    */
+  /** ERC20 balance of the connected wallet, read through the wallet's own node. */
+  async readTokenBalance(chainId, token) {
+    const state = this.requireState();
+    return readErc20Balance(
+      createPublicClient2({
+        chain: swapChain(chainId),
+        transport: custom(this.requireConnectedProvider())
+      }),
+      token,
+      state.walletAddress
+    );
+  }
+  /** How much of `token` the wallet has already approved Permit2 to move. */
+  async readTokenPermit2Allowance(chainId, token) {
+    const state = this.requireState();
+    return readPermit2Allowance(
+      createPublicClient2({
+        chain: swapChain(chainId),
+        transport: custom(this.requireConnectedProvider())
+      }),
+      token,
+      state.walletAddress
+    );
+  }
+  /**
+   * How much of a landed swap to actually deposit.
+   *
+   * The swap reports what ARRIVED, and the deposit used to be handed that
+   * figure directly. It is the entire arrival, so there is no slack: anything
+   * that spends the target asset between the two fails the deposit outright.
+   *
+   * Something does. A first WETH deposit needs a one-time Permit2 approval,
+   * and that approval is a transaction. A wallet holding no native gas token -
+   * the normal state of someone who just swapped everything INTO WETH - pays
+   * for it out of the WETH. The deposit then asked for ~2e12 wei more than was
+   * left and refused with DEPOSIT_INSUFFICIENT_BALANCE, under a wrapper saying
+   * the funds were safe but unadded (ROUT-242).
+   *
+   * So the approval happens here, before the amount is settled, and the amount
+   * comes from a read taken after it. Two things this deliberately is not:
+   *
+   * - It is not a balance sweep. `received` is a DELTA over the pre-swap
+   *   balance, so a wallet already holding WETH reads far above it; depositing
+   *   the balance would move funds the user never offered. The arrival is the
+   *   ceiling and the balance is only ever allowed to lower it.
+   * - It does not touch USDC, which moves on signed typed data and so spends
+   *   nothing of the user's in between, nor a paymaster-configured client,
+   *   where the sponsor covers the transfer and Permit2 never applies.
+   */
+  async settleSwapDepositAmount(chainId, token, symbol, received) {
+    if (symbol !== "WETH" || this.paymasterServiceUrl) {
+      return received.toString();
+    }
+    const allowance = await this.readTokenPermit2Allowance(chainId, token);
+    if (allowance < received) await this.approvePermit2();
+    const balance = await this.readTokenBalance(chainId, token);
+    return (balance < received ? balance : received).toString();
+  }
   async walletSeesBalance(chainId, token, amount) {
     const provider = this.requireConnectedProvider();
     const state = this.requireState();
@@ -5408,7 +5466,7 @@ var OwneySDK = class {
    */
   async getWalletBalances(chainIds) {
     const state = this.requireState();
-    const chains = chainIds ?? SUPPORTED_CHAIN_IDS;
+    const chains = chainIds ?? SWAP_CHAIN_IDS;
     const failedChainIds = [];
     const results = await Promise.all(
       chains.map(async (chainId) => {
@@ -5514,12 +5572,18 @@ var OwneySDK = class {
         quote.dst.address,
         BigInt(swap.received)
       );
+      const amount = await this.settleSwapDepositAmount(
+        quote.dst.chainId,
+        quote.dst.address,
+        options.to.symbol,
+        BigInt(swap.received)
+      );
       const deposit = await this.deposit({
-        amount: swap.received,
+        amount,
         asset: options.to.symbol,
         ...options.agentId ? { agentId: options.agentId } : {}
       });
-      return { swap, deposit };
+      return { swap, deposit, deposited: amount };
     } catch (error) {
       const pending = {
         id: `${quote.dst.chainId}-${options.to.symbol}-${Date.now()}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owney/sdk",
-  "version": "0.7.26-beta.7",
+  "version": "0.7.26-beta.8",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",