@gearbox-protocol/sdk 14.12.0-next.23 → 14.12.0-next.25

package/dist/esm/plugins/adapters/contracts/BalancerV3WrapperAdapterContract.js

@@ -34,19 +34,21 @@ class BalancerV3WrapperAdapterContract extends AbstractAdapterContract {
       balancerPoolToken: this.#balancerPoolToken ? this.labelAddress(this.#balancerPoolToken) : void 0
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       // mint spends the pool token, burn spends the wrapper (target contract)
       case "mintDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.balancerPoolToken, leftoverAmount }];
+        this.setLeftover(balances, this.balancerPoolToken, leftoverAmount);
+        break;
       }
       case "burnDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.targetContract, leftoverAmount }];
+        this.setLeftover(balances, this.targetContract, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/CamelotV3AdapterContract.js

@@ -47,24 +47,21 @@ class CamelotV3AdapterContract extends AbstractAdapterContract {
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "exactDiffInputSingle": {
         const [params] = decoded.args;
-        return [
-          {
-            tokenIn: params.tokenIn,
-            leftoverAmount: params.leftoverAmount
-          }
-        ];
+        this.setLeftover(balances, params.tokenIn, params.leftoverAmount);
+        break;
       }
       case "exactDiffInput": {
         const [params] = decoded.args;
         const tokenIn = `0x${params.path.replace("0x", "").slice(0, 40)}`;
-        return [{ tokenIn, leftoverAmount: params.leftoverAmount }];
+        this.setLeftover(balances, tokenIn, params.leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/ConvexV1BaseRewardPoolAdapterContract.js

@@ -116,22 +116,24 @@ class ConvexV1BaseRewardPoolAdapterContract extends AbstractAdapterContract {
       withdrawAmount: swap.toAmount
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "stakeDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.stakingToken, leftoverAmount }];
+        this.setLeftover(balances, this.stakingToken, leftoverAmount);
+        break;
       }
       case "withdrawDiff":
       case "withdrawDiffAndUnwrap": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.stakedPhantomToken, leftoverAmount }];
+        this.setLeftover(balances, this.stakedPhantomToken, leftoverAmount);
+        break;
       }
       // no accrued rewards on a freshly opened account
       case "getReward":
-        return [];
+        break;
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/ConvexV1BoosterAdapterContract.js

@@ -83,21 +83,23 @@ class ConvexV1BoosterAdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       // deposit spends the curve LP token, withdraw spends the convex token
       case "depositDiff": {
         const [pid, leftoverAmount] = decoded.args;
         const pool = this.#mustFindPool(Number(pid));
-        return [{ tokenIn: pool.curveToken, leftoverAmount }];
+        this.setLeftover(balances, pool.curveToken, leftoverAmount);
+        break;
       }
       case "withdrawDiff": {
         const [pid, leftoverAmount] = decoded.args;
         const pool = this.#mustFindPool(Number(pid));
-        return [{ tokenIn: pool.convexToken, leftoverAmount }];
+        this.setLeftover(balances, pool.convexToken, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
   #mustFindPool(pid) {

package/dist/esm/plugins/adapters/contracts/DaiUsdsAdapterContract.js

@@ -55,18 +55,20 @@ class DaiUsdsAdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "daiToUsdsDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.dai, leftoverAmount }];
+        this.setLeftover(balances, this.dai, leftoverAmount);
+        break;
       }
       case "usdsToDaiDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.usds, leftoverAmount }];
+        this.setLeftover(balances, this.usds, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/ERC4626AdapterContract.js

@@ -81,18 +81,27 @@ class ERC4626AdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "depositDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.asset, leftoverAmount }];
+        this.setLeftover(balances, this.asset, leftoverAmount);
+        break;
       }
       case "redeemDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.share, leftoverAmount }];
+        this.setLeftover(balances, this.share, leftoverAmount);
+        break;
       }
+      case "redeem": {
+        const [shares] = decoded.args;
+        this.spendExact(balances, this.share, shares);
+        break;
+      }
+      // `withdraw`/`deposit`/`mint` stay unsupported: they are not emitted
+      // by the router (which uses diff variants) or the withdrawal compressor
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/ERC4626ReferralAdapterContract.js

@@ -55,18 +55,20 @@ class ERC4626ReferralAdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "depositDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.asset, leftoverAmount }];
+        this.setLeftover(balances, this.asset, leftoverAmount);
+        break;
       }
       case "redeemDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.targetContract, leftoverAmount }];
+        this.setLeftover(balances, this.targetContract, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/FluidDexAdapterContract.js

@@ -43,19 +43,19 @@ class FluidDexAdapterContract extends AbstractAdapterContract {
       token1: this.#token1 ? this.labelAddress(this.#token1) : void 0
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "swapInDiff": {
         const [swap0to1, leftoverAmount] = decoded.args;
-        return [
-          {
-            tokenIn: swap0to1 ? this.token0 : this.token1,
-            leftoverAmount
-          }
-        ];
+        this.setLeftover(
+          balances,
+          swap0to1 ? this.token0 : this.token1,
+          leftoverAmount
+        );
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/InfinifiGatewayAdapterContract.js

@@ -65,25 +65,28 @@ class InfinifiGatewayAdapterContract extends AbstractAdapterContract {
       )
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "mintDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.usdc, leftoverAmount }];
+        this.setLeftover(balances, this.usdc, leftoverAmount);
+        break;
       }
       // redeem, stake and lock all spend iUSD
       case "redeemDiff":
       case "stakeDiff":
       case "createPositionDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.iusd, leftoverAmount }];
+        this.setLeftover(balances, this.iusd, leftoverAmount);
+        break;
       }
       case "unstakeDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.siusd, leftoverAmount }];
+        this.setLeftover(balances, this.siusd, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/KelpLRTDepositPoolAdapterContract.js

@@ -38,14 +38,15 @@ class KelpLRTDepositPoolAdapterContract extends AbstractAdapterContract {
       allowedAssets: this.#allowedAssets?.map((a) => this.labelAddress(a))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "depositAssetDiff": {
         const [tokenIn, leftoverAmount] = decoded.args;
-        return [{ tokenIn, leftoverAmount }];
+        this.setLeftover(balances, tokenIn, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/LidoV1AdapterContract.js

@@ -56,15 +56,16 @@ class LidoV1AdapterContract extends AbstractAdapterContract {
   classifyLegacyOperation(_parsed, transfers) {
     return { operation: "LidoSubmit", ...swapFromTransfers(transfers) };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       // the adapter targets the WETH gateway, so WETH is spent
       case "submitDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.weth, leftoverAmount }];
+        this.setLeftover(balances, this.weth, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/MellowClaimerAdapterContract.js

@@ -1,4 +1,6 @@
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
@@ -36,6 +38,35 @@ class MellowClaimerAdapterContract extends AbstractAdapterContract {
       )
     };
   }
+  applyBalanceChanges(balances, decoded) {
+    switch (decoded.functionName) {
+      // pure "accept" of transferred pending assets, coupled with a Mellow
+      // withdrawal request: it moves no ERC-20s, and the withdrawal phantom
+      // token effect is credited by the storeExpectedBalances bracket delta
+      // built from the compressor's outputs
+      case "multiAccept":
+        break;
+      case "withdrawPhantomToken": {
+        const [token, amount] = decoded.args;
+        this.spendExact(balances, token, amount);
+        break;
+      }
+      // TODO:
+      // `multiAcceptAndClaim` (the claim call emitted by the withdrawal
+      // compressor) cannot be previewed offline: the burn amount IS in
+      // calldata (`maxAssets` == the compressor's `withdrawalTokenSpent`),
+      // but the withdrawal phantom token to debit cannot be resolved from
+      // the `multiVault` argument. The on-chain adapter only serializes
+      // (creditManager, targetContract, allowedMultiVaults) and drops its
+      // `phantomTokenToMultiVault` mapping (unlike Midas/Kelp adapters,
+      // which serialize aligned token/phantom arrays). Resolving it would
+      // require DelayedWithdrawalPlugin state (WithdrawableAsset maps
+      // multiVault -> withdrawalPhantomToken) or a contract-side
+      // `serialize()` fix.
+      default:
+        super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 export {
   MellowClaimerAdapterContract

package/dist/esm/plugins/adapters/contracts/MellowDVVAdapterContract.js

@@ -54,19 +54,21 @@ class MellowDVVAdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     const share = this.#vault ?? this.targetContract;
     switch (decoded.functionName) {
       case "depositDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.asset, leftoverAmount }];
+        this.setLeftover(balances, this.asset, leftoverAmount);
+        break;
       }
       case "redeemDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: share, leftoverAmount }];
+        this.setLeftover(balances, share, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/MellowERC4626VaultAdapterContract.js

@@ -89,19 +89,26 @@ class MellowERC4626VaultAdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     const share = this.#vault ?? this.targetContract;
     switch (decoded.functionName) {
       case "depositDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.asset, leftoverAmount }];
+        this.setLeftover(balances, this.asset, leftoverAmount);
+        break;
       }
       case "redeemDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: share, leftoverAmount }];
+        this.setLeftover(balances, share, leftoverAmount);
+        break;
+      }
+      case "redeem": {
+        const [shares] = decoded.args;
+        this.spendExact(balances, share, shares);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/MellowWrapperAdapterContract.js

@@ -36,15 +36,16 @@ class MellowWrapperAdapterContract extends AbstractAdapterContract {
       allowedVaults: this.#allowedVaults?.map((v) => this.labelAddress(v))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "depositDiff": {
         const weth = this.tokensMeta.mustFindBySymbol("WETH").addr;
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: weth, leftoverAmount }];
+        this.setLeftover(balances, weth, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/MidasGatewayAdapterContract.js

@@ -1,5 +1,6 @@
 import {
-  decodeAbiParameters
+  decodeAbiParameters,
+  isAddressEqual
 } from "viem";
 import {
   MissingSerializedParamsError
@@ -81,21 +82,48 @@ class MidasGatewayAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "depositInstantDiff": {
         const [tokenIn, leftoverAmount] = decoded.args;
-        return [{ tokenIn, leftoverAmount }];
+        this.setLeftover(balances, tokenIn, leftoverAmount);
+        break;
       }
       // redemptions spend the mToken down to the leftover, tokenOut arg is
       // the received token
       case "redeemInstantDiff":
       case "redeemRequestDiff": {
         const [, leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.mToken, leftoverAmount }];
+        this.setLeftover(balances, this.mToken, leftoverAmount);
+        break;
+      }
+      // exact-input redemption request emitted in-bracket by the withdrawal
+      // compressor
+      case "redeemRequest": {
+        const [, amountMTokenIn] = decoded.args;
+        this.spendExact(balances, this.mToken, amountMTokenIn);
+        break;
+      }
+      // claim call emitted by the withdrawal compressor
+      case "withdrawFromRedeemer": {
+        const [, tokenOut, amount] = decoded.args;
+        const phantomToken = this.allowedOutputTokens.find(
+          (t) => isAddressEqual(t.token, tokenOut)
+        )?.phantomToken;
+        if (!phantomToken) {
+          super.applyBalanceChanges(balances, decoded);
+          break;
+        }
+        this.spendExact(balances, phantomToken, amount);
+        break;
+      }
+      case "withdrawPhantomToken": {
+        const [token, amount] = decoded.args;
+        this.spendExact(balances, token, amount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/MidasIssuanceVaultAdapterContract.js

@@ -53,14 +53,15 @@ class MidasIssuanceVaultAdapterContract extends AbstractAdapterContract {
       allowedTokens: this.#allowedTokens?.map((t) => this.labelAddress(t))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "depositInstantDiff": {
         const [tokenIn, leftoverAmount] = decoded.args;
-        return [{ tokenIn, leftoverAmount }];
+        this.setLeftover(balances, tokenIn, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/MidasRedemptionVaultAdapterContract.js

@@ -61,16 +61,17 @@ class MidasRedemptionVaultAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       // redemption spends the mToken down to the leftover, tokenOut arg is
       // the received token
       case "redeemInstantDiff": {
         const [, leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.mToken, leftoverAmount }];
+        this.setLeftover(balances, this.mToken, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

package/dist/esm/plugins/adapters/contracts/PendleRouterAdapterContract.js

@@ -96,27 +96,29 @@ class PendleRouterAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "swapDiffTokenForPt":
       case "addLiquiditySingleTokenDiff": {
         const [, , , diffInput] = decoded.args;
-        return [
-          {
-            tokenIn: diffInput.tokenIn,
-            leftoverAmount: diffInput.leftoverTokenIn
-          }
-        ];
+        this.setLeftover(
+          balances,
+          diffInput.tokenIn,
+          diffInput.leftoverTokenIn
+        );
+        break;
       }
       case "swapDiffPtForToken": {
         const [market, leftoverPt] = decoded.args;
         const pt = this.#mustFindPendleToken(market, 0 /* PT */);
-        return [{ tokenIn: pt, leftoverAmount: leftoverPt }];
+        this.setLeftover(balances, pt, leftoverPt);
+        break;
       }
       case "removeLiquiditySingleTokenDiff": {
         const [market, leftoverLp] = decoded.args;
         const lp = this.#mustFindPendleToken(market, 1 /* LP */);
-        return [{ tokenIn: lp, leftoverAmount: leftoverLp }];
+        this.setLeftover(balances, lp, leftoverLp);
+        break;
       }
       case "redeemDiffPyToToken": {
         const candidates = this.allowedPairs.filter(
@@ -131,15 +133,11 @@ class PendleRouterAdapterContract extends AbstractAdapterContract {
           );
         }
         const [, leftoverPt] = decoded.args;
-        return [
-          {
-            tokenIn: candidates[0].pendleToken,
-            leftoverAmount: leftoverPt
-          }
-        ];
+        this.setLeftover(balances, candidates[0].pendleToken, leftoverPt);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
   #mustFindPendleToken(market, type) {

package/dist/esm/plugins/adapters/contracts/SecuritizeOnRampAdapterContract.js

@@ -45,15 +45,16 @@ class SecuritizeOnRampAdapterContract extends AbstractAdapterContract {
       liquidityToken: this.#liquidityToken ? this.labelAddress(this.#liquidityToken) : void 0
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       // swaps the liquidity token into dsToken
       case "swapDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.liquidityToken, leftoverAmount }];
+        this.setLeftover(balances, this.liquidityToken, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }