@gearbox-protocol/sdk 14.12.0-next.22 → 14.12.0-next.24

package/dist/cjs/preview/preview/previewAdjustCreditAccount.js

@@ -23,6 +23,8 @@ __export(previewAdjustCreditAccount_exports, {
 module.exports = __toCommonJS(previewAdjustCreditAccount_exports);
 var import_sdk = require("../../sdk/index.js");
 var import_applyInnerOperations = require("./applyInnerOperations.js");
+var import_applyQuotaChanges = require("./applyQuotaChanges.js");
+var import_types = require("./types.js");
 var import_unwrapNativeCollateral = require("./unwrapNativeCollateral.js");
 async function previewAdjustCreditAccount(input, operation, options) {
   const { sdk, value = 0n } = input;
@@ -53,22 +55,30 @@ async function previewAdjustCreditAccount(input, operation, options) {
   state.balances = initialBalances.clone();
   state.debt = ca.debt;
   state.totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
-  (0, import_applyInnerOperations.applyInnerOperations)(sdk, operation.multicall, state);
-  const collateralAdded = (0, import_unwrapNativeCollateral.unwrapNativeCollateral)(
+  let error = (0, import_applyInnerOperations.applyInnerOperations)(sdk, operation.multicall, state);
+  const { assets: collateralAdded, error: unwrapError } = (0, import_unwrapNativeCollateral.unwrapNativeCollateral)(
     state.collateralAdded.toAssets(),
     value,
     sdk.addressProvider.getAddress(import_sdk.AP_WETH_TOKEN, import_sdk.NO_VERSION)
   );
-  const { quotas, quotasChange } = (0, import_applyInnerOperations.applyQuotaChanges)(
+  error ??= unwrapError;
+  const { quotas, quotasChange } = (0, import_applyQuotaChanges.applyQuotaChanges)(
     initialQuotas,
     state.quotaChanges
   );
   const assets = state.balances.toAssets(1n);
   const assetsChange = state.balances.difference(initialBalances).toAssets(1n);
-  const totalValue = assets.reduce(
-    (acc, { token, balance }) => acc + market.priceOracle.convert(token, market.underlying, balance),
-    0n
-  );
+  const totalValue = assets.reduce((acc, { token, balance }) => {
+    try {
+      return acc + market.priceOracle.convert(token, market.underlying, balance);
+    } catch {
+      error ??= {
+        code: import_types.ERROR_UNPRICEABLE_TOKEN,
+        message: `cannot price token ${token}`
+      };
+      return acc;
+    }
+  }, 0n);
   return {
     operation: "AdjustCreditAccount",
     creditManager: operation.creditManager,
@@ -81,7 +91,8 @@ async function previewAdjustCreditAccount(input, operation, options) {
     quotas,
     quotasChange,
     assets,
-    assetsChange
+    assetsChange,
+    error
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/preview/preview/previewCloseOrRepayCreditAccount.js

@@ -38,23 +38,31 @@ async function previewCloseCreditAccount(input, operation, permanent, options) {
   const market = sdk.marketRegister.findByCreditManager(
     operation.creditManager
   );
-  const { state } = await replayMulticall(sdk, operation, options);
+  const { state, error } = await replayMulticall(sdk, operation, options);
   return {
     operation: "CloseCreditAccount",
     permanent,
     creditManager: operation.creditManager,
     creditAccount: operation.creditAccount,
-    receivedAmount: state.collateralWithdrawn.getOrZero(market.underlying)
+    // On a malformed multicall the withdrawn amount depends on best-effort
+    // replayed balances and may be unreliable
+    receivedAmount: state.collateralWithdrawn.getOrZero(market.underlying),
+    error
   };
 }
 async function previewRepayCreditAccount(input, operation, permanent, options) {
   const { sdk, value = 0n } = input;
-  const { ca, state } = await replayMulticall(sdk, operation, options);
-  const collateralAdded = (0, import_unwrapNativeCollateral.unwrapNativeCollateral)(
+  const {
+    ca,
+    state,
+    error: replayError
+  } = await replayMulticall(sdk, operation, options);
+  const { assets: collateralAdded, error: unwrapError } = (0, import_unwrapNativeCollateral.unwrapNativeCollateral)(
     state.collateralAdded.toAssets(),
     value,
     sdk.addressProvider.getAddress(import_sdk.AP_WETH_TOKEN, import_sdk.NO_VERSION)
   );
+  const error = replayError ?? unwrapError;
   const initialTotalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
   return {
     operation: "RepayCreditAccount",
@@ -63,7 +71,10 @@ async function previewRepayCreditAccount(input, operation, permanent, options) {
     creditAccount: operation.creditAccount,
     collateralAdded,
     debtRepaid: initialTotalDebt - state.totalDebt,
-    collateralWithdrawn: state.collateralWithdrawn.toAssets()
+    // On a malformed multicall the MAX_UINT256 withdrawal sentinel resolves
+    // against best-effort replayed balances and may be unreliable
+    collateralWithdrawn: state.collateralWithdrawn.toAssets(),
+    error
   };
 }
 async function replayMulticall(sdk, operation, options) {
@@ -85,8 +96,8 @@ async function replayMulticall(sdk, operation, options) {
   }
   state.debt = ca.debt;
   state.totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
-  (0, import_applyInnerOperations.applyInnerOperations)(sdk, operation.multicall, state);
-  return { ca, state };
+  const error = (0, import_applyInnerOperations.applyInnerOperations)(sdk, operation.multicall, state);
+  return { ca, state, error };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/preview/preview/previewOpenCreditAccount.js

@@ -23,6 +23,7 @@ __export(previewOpenCreditAccount_exports, {
 module.exports = __toCommonJS(previewOpenCreditAccount_exports);
 var import_sdk = require("../../sdk/index.js");
 var import_applyInnerOperations = require("./applyInnerOperations.js");
+var import_types = require("./types.js");
 var import_unwrapNativeCollateral = require("./unwrapNativeCollateral.js");
 function previewOpenCreditAccount(input, operation) {
   const { sdk, value = 0n } = input;
@@ -30,15 +31,25 @@ function previewOpenCreditAccount(input, operation) {
     operation.creditManager
   );
   const state = (0, import_applyInnerOperations.makeInnerOperationsState)();
-  (0, import_applyInnerOperations.applyInnerOperations)(sdk, operation.multicall, state);
-  const collateralValue = state.collateralAdded.sum(
-    (token, balance) => market.priceOracle.convert(token, market.underlying, balance)
-  );
-  const collateral = (0, import_unwrapNativeCollateral.unwrapNativeCollateral)(
+  let error = (0, import_applyInnerOperations.applyInnerOperations)(sdk, operation.multicall, state);
+  let priceError;
+  const collateralValue = state.collateralAdded.sum((token, balance) => {
+    try {
+      return market.priceOracle.convert(token, market.underlying, balance);
+    } catch {
+      priceError ??= {
+        code: import_types.ERROR_UNPRICEABLE_TOKEN,
+        message: `cannot price token ${token}`
+      };
+      return 0n;
+    }
+  });
+  const { assets: collateral, error: unwrapError } = (0, import_unwrapNativeCollateral.unwrapNativeCollateral)(
     state.collateralAdded.toAssets(),
     value,
     sdk.addressProvider.getAddress(import_sdk.AP_WETH_TOKEN, import_sdk.NO_VERSION)
   );
+  error ??= unwrapError ?? priceError;
   const assets = state.balances.toAssets(1n);
   return {
     operation: operation.operation,
@@ -49,7 +60,8 @@ function previewOpenCreditAccount(input, operation) {
     debt: state.debt,
     // On opening, initial quotas are zero, so the raw changes are the quotas.
     quotas: state.quotaChanges,
-    assets
+    assets,
+    error
   };
 }
 function inferTargetAsset(multicall, balances) {

package/dist/cjs/preview/preview/types.js

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -13,4 +17,30 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var types_exports = {};
+__export(types_exports, {
+  ERROR_ADAPTER_CALL_OUTSIDE_BRACKET: () => ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
+  ERROR_INVALID_TRANSACTION_VALUE: () => ERROR_INVALID_TRANSACTION_VALUE,
+  ERROR_MALFORMED_BRACKET: () => ERROR_MALFORMED_BRACKET,
+  ERROR_NON_ADAPTER_CALL_IN_BRACKET: () => ERROR_NON_ADAPTER_CALL_IN_BRACKET,
+  ERROR_UNPREVIEWABLE_ADAPTER_CALL: () => ERROR_UNPREVIEWABLE_ADAPTER_CALL,
+  ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP: () => ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP,
+  ERROR_UNPRICEABLE_TOKEN: () => ERROR_UNPRICEABLE_TOKEN
+});
 module.exports = __toCommonJS(types_exports);
+const ERROR_MALFORMED_BRACKET = 1001;
+const ERROR_ADAPTER_CALL_OUTSIDE_BRACKET = 1002;
+const ERROR_NON_ADAPTER_CALL_IN_BRACKET = 1003;
+const ERROR_UNPREVIEWABLE_ADAPTER_CALL = 1004;
+const ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP = 1005;
+const ERROR_INVALID_TRANSACTION_VALUE = 1006;
+const ERROR_UNPRICEABLE_TOKEN = 2001;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
+  ERROR_INVALID_TRANSACTION_VALUE,
+  ERROR_MALFORMED_BRACKET,
+  ERROR_NON_ADAPTER_CALL_IN_BRACKET,
+  ERROR_UNPREVIEWABLE_ADAPTER_CALL,
+  ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP,
+  ERROR_UNPRICEABLE_TOKEN
+});

package/dist/cjs/preview/preview/unwrapNativeCollateral.js

@@ -22,22 +22,28 @@ __export(unwrapNativeCollateral_exports, {
 });
 module.exports = __toCommonJS(unwrapNativeCollateral_exports);
 var import_sdk = require("../../sdk/index.js");
-var import_errors = require("./errors.js");
+var import_types = require("./types.js");
 function unwrapNativeCollateral(collateral, nativeAmount, wethToken) {
   if (nativeAmount === 0n) {
-    return collateral;
+    return { assets: collateral };
   }
   const balances = new import_sdk.AssetsMap(collateral);
   const wethBalance = balances.get(wethToken) ?? 0n;
   if (wethBalance < nativeAmount) {
-    throw new import_errors.InvalidTransactionValueError(nativeAmount, wethBalance);
+    return {
+      assets: collateral,
+      error: {
+        code: import_types.ERROR_INVALID_TRANSACTION_VALUE,
+        message: `transaction value ${nativeAmount} exceeds WETH collateral ${wethBalance}`
+      }
+    };
   }
   balances.upsert(
     wethToken,
     wethBalance === nativeAmount ? void 0 : wethBalance - nativeAmount
   );
   balances.inc(import_sdk.NATIVE_ADDRESS, nativeAmount);
-  return balances.toAssets();
+  return { assets: balances.toAssets() };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/sdk/OnchainSDK.js

@@ -538,13 +538,10 @@ class OnchainSDK extends import_base.ChainContractsRegister {
   /**
    * Lazily returns a withdrawal compressor contract for the current chain.
    *
-   * @param version - Desired compressor version; when omitted, the latest
-   *   version supported on the current chain is used.
-   * @throws If no withdrawal compressor of the given version is supported
-   *   on the current chain.
+   * @throws If no withdrawal compressor is supported on the current chain.
    **/
-  withdrawalCompressor(version) {
-    return (0, import_accounts.createWithdrawalCompressor)(this, version);
+  get withdrawalCompressor() {
+    return (0, import_accounts.createWithdrawalCompressor)(this);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/sdk/accounts/CreditAccountsServiceV310.js

@@ -786,8 +786,7 @@ class CreditAccountsServiceV310 extends import_base.SDKConstruct {
     token,
     intent
   }) {
-    const compressor = this.sdk.withdrawalCompressor();
-    return compressor.getWithdrawalRequestResult(
+    return this.sdk.withdrawalCompressor.getWithdrawalRequestResult(
       creditAccount,
       token,
       amount,
@@ -800,8 +799,7 @@ class CreditAccountsServiceV310 extends import_base.SDKConstruct {
   async getPendingWithdrawals({
     creditAccount
   }) {
-    const compressor = this.sdk.withdrawalCompressor();
-    const { claimable, pending } = await compressor.getCurrentWithdrawals(creditAccount);
+    const { claimable, pending } = await this.sdk.withdrawalCompressor.getCurrentWithdrawals(creditAccount);
     return {
       claimableNow: claimable,
       pending

package/dist/cjs/sdk/accounts/withdrawal-compressor/AbstractWithdrawalCompressorContract.js

@@ -107,7 +107,7 @@ class AbstractWithdrawalCompressorContract extends import_base.BaseContract {
       claimable: claimable.map(
         (w) => toClaimableWithdrawal(w, creditManager, this.version >= 313)
       ),
-      pending: pending.map(toPendingWithdrawal).sort((a, b) => a.claimableAt < b.claimableAt ? -1 : 1)
+      pending: pending.map((w) => toPendingWithdrawal(w, creditManager, this.version >= 313)).sort((a, b) => a.claimableAt < b.claimableAt ? -1 : 1)
     };
   }
   /**
@@ -127,8 +127,8 @@ class AbstractWithdrawalCompressorContract extends import_base.BaseContract {
     return {
       token: resp.token,
       amountIn: resp.amountIn,
-      outputs: resp.outputs.map(toWithdrawalOutput),
-      requestCalls: resp.requestCalls.map(toMultiCall),
+      outputs: [...resp.outputs],
+      requestCalls: [...resp.requestCalls],
       claimableAt: resp.claimableAt
     };
   }
@@ -180,21 +180,8 @@ class AbstractWithdrawalCompressorContract extends import_base.BaseContract {
     ]);
   }
 }
-function toWithdrawalOutput(o) {
-  return { token: o.token, isDelayed: o.isDelayed, amount: o.amount };
-}
-function toMultiCall(c) {
-  return { target: c.target, callData: c.callData };
-}
 function toWithdrawableAsset(a, creditManager) {
-  return {
-    creditManager,
-    token: a.token,
-    withdrawalPhantomToken: a.withdrawalPhantomToken,
-    underlying: a.underlying,
-    withdrawalLength: a.withdrawalLength,
-    maxWithdrawals: a.maxWithdrawals
-  };
+  return { creditManager, ...a };
 }
 function toClaimableWithdrawal(w, creditManager, decodeIntent) {
   let intent;
@@ -205,17 +192,22 @@ function toClaimableWithdrawal(w, creditManager, decodeIntent) {
     token: w.token,
     withdrawalPhantomToken: w.withdrawalPhantomToken,
     withdrawalTokenSpent: w.withdrawalTokenSpent,
-    outputs: w.outputs.map(toWithdrawalOutput),
-    claimCalls: w.claimCalls.map(toMultiCall),
+    outputs: [...w.outputs],
+    claimCalls: [...w.claimCalls],
     intent
   };
 }
-function toPendingWithdrawal(w) {
+function toPendingWithdrawal(w, creditManager, decodeIntent) {
+  let intent;
+  if (decodeIntent && w.extraData && w.extraData !== "0x") {
+    intent = { ...(0, import_intent_codec.decodeDelayedIntent)(w.extraData), creditManager };
+  }
   return {
     token: w.token,
     withdrawalPhantomToken: w.withdrawalPhantomToken,
-    expectedOutputs: w.expectedOutputs.map(toWithdrawalOutput),
-    claimableAt: w.claimableAt
+    expectedOutputs: [...w.expectedOutputs],
+    claimableAt: w.claimableAt,
+    intent
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/sdk/accounts/withdrawal-compressor/addresses.js

@@ -23,28 +23,16 @@ __export(addresses_exports, {
 module.exports = __toCommonJS(addresses_exports);
 const WITHDRAWAL_COMPRESSORS = {
   Mainnet: {
-    310: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023",
-    313: "0x9605D59E40963ADce8a6895Aa3Fa497320Ef3F3b"
+    address: "0x83e5AaC6590Cf9c6Dd323851a0D66fEc2Bc4F5A3",
+    version: 313
   },
   Monad: {
-    310: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023"
+    address: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023",
+    version: 310
   }
 };
-function getWithdrawalCompressorAddress(network, version) {
-  const deployments = WITHDRAWAL_COMPRESSORS[network];
-  if (!deployments) {
-    return void 0;
-  }
-  if (version !== void 0) {
-    const address2 = deployments[version];
-    return address2 ? { address: address2, version } : void 0;
-  }
-  const latest = Object.keys(deployments).map(Number).sort((a, b) => b - a)[0];
-  if (latest === void 0) {
-    return void 0;
-  }
-  const address = deployments[latest];
-  return address ? { address, version: latest } : void 0;
+function getWithdrawalCompressorAddress(network) {
+  return WITHDRAWAL_COMPRESSORS[network];
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/sdk/accounts/withdrawal-compressor/createWithdrawalCompressor.js

@@ -25,12 +25,10 @@ var import_addresses = require("./addresses.js");
 var import_WithdrawalCompressorV310Contract = require("./WithdrawalCompressorV310Contract.js");
 var import_WithdrawalCompressorV311Contract = require("./WithdrawalCompressorV311Contract.js");
 var import_WithdrawalCompressorV313Contract = require("./WithdrawalCompressorV313Contract.js");
-function createWithdrawalCompressor(sdk, version) {
-  const location = (0, import_addresses.getWithdrawalCompressorAddress)(sdk.networkType, version);
+function createWithdrawalCompressor(sdk) {
+  const location = (0, import_addresses.getWithdrawalCompressorAddress)(sdk.networkType);
   if (!location) {
-    throw new Error(
-      `no withdrawal compressor${version ? ` v${version}` : ""} on ${sdk.networkType}`
-    );
+    throw new Error(`no withdrawal compressor on ${sdk.networkType}`);
   }
   const cached = sdk.getContract(
     location.address

package/dist/esm/abi/IWithdrawalCompressorV313.js

@@ -72,7 +72,8 @@ const iWithdrawalCompressorV313Abi = [
               { name: "amount", type: "uint256", internalType: "uint256" }
             ]
           },
-          { name: "claimableAt", type: "uint256", internalType: "uint256" }
+          { name: "claimableAt", type: "uint256", internalType: "uint256" },
+          { name: "extraData", type: "bytes", internalType: "bytes" }
         ]
       }
     ],

package/dist/esm/abi/compressors/withdrawalCompressor.js

@@ -94,7 +94,8 @@ const withdrawalCompressorAbi = [
               { name: "amount", type: "uint256", internalType: "uint256" }
             ]
           },
-          { name: "claimableAt", type: "uint256", internalType: "uint256" }
+          { name: "claimableAt", type: "uint256", internalType: "uint256" },
+          { name: "extraData", type: "bytes", internalType: "bytes" }
         ]
       }
     ],

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

@@ -104,8 +104,10 @@ class AbstractAdapterContract extends BaseContract {
     }
   }
   /**
-   * Applies the balance changes implied by a router-generated diff-style
-   * adapter call to a map of credit-account token balances.
+   * Applies the balance changes implied by an adapter call to a map of
+   * credit-account token balances. Handles both router-generated diff-style
+   * calls and exact-input calls (e.g. those emitted by the withdrawal
+   * compressor).
    *
    * @param balances - Token balances before the call. Mutated in place.
    * @param calldata - Raw ABI-encoded adapter calldata.
@@ -122,23 +124,43 @@ class AbstractAdapterContract extends BaseContract {
         { cause: e }
       );
     }
-    const leftovers = this.decodeDiffLeftovers(decoded, balances);
-    for (const { tokenIn, leftoverAmount } of leftovers) {
-      balances.upsert(tokenIn, leftoverAmount);
-    }
+    this.applyBalanceChanges(balances, decoded);
   }
   /**
-   * Resolves which tokens the diff-style call spends down to which leftovers.
+   * Applies the balance changes of a decoded adapter call to the running
+   * balances, mutating them in place. Overrides should express changes via
+   * {@link setLeftover} (diff-style calls) and {@link spendExact}
+   * (exact-input calls), and should resolve all tokens/amounts before the
+   * first write so a throw never leaves balances partially mutated.
    *
+   * @param _balances - Token balances before the call. Mutated in place.
    * @param decoded - The viem-decoded adapter call
-   * @param _balances - Token balances before the call
    * @throws When the adapter (or the specific function) has no balance-changes support
    */
-  decodeDiffLeftovers(decoded, _balances) {
+  applyBalanceChanges(_balances, decoded) {
     throw new Error(
       `previewBalanceChanges is not supported for ${decoded.functionName} on ${this.contractType} adapter at ${this.address}`
     );
   }
+  /**
+   * Diff-call semantics of a diff-style adapter call: the call spends the
+   * consumed token down to the exact `leftoverAmount` encoded in its
+   * calldata, so the post-call balance of `tokenIn` is `leftoverAmount`
+   * regardless of the actual amount spent.
+   */
+  setLeftover(balances, tokenIn, leftoverAmount) {
+    balances.upsert(tokenIn, leftoverAmount);
+  }
+  /**
+   * Exact-input call semantics: spends exactly `amount` of `tokenIn` from
+   * the running balance, clamping at zero. Used for non-diff adapter calls
+   * (e.g. those generated by the withdrawal compressor) whose spent amount
+   * is present in calldata.
+   */
+  spendExact(balances, tokenIn, amount) {
+    const balance = balances.getOrZero(tokenIn);
+    balances.upsert(tokenIn, balance > amount ? balance - amount : 0n);
+  }
   /**
    * Classifies an adapter call into a {@link LegacyAdapterOperation} using the
    * parsed call and credit-account transfer deltas.

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

@@ -5,23 +5,26 @@ class AbstractCurveAdapterContract extends AbstractAdapterContract {
   classifyLegacyOperation(parsed, transfers) {
     return classifyCurveOperation(parsed.functionName, transfers) ?? super.classifyLegacyOperation(parsed, transfers);
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     const { functionName, args } = decoded;
     switch (functionName) {
       case "exchange_diff": {
         const [i, , leftoverAmount] = args;
-        return [{ tokenIn: this.curveCoin(i), leftoverAmount }];
+        this.setLeftover(balances, this.curveCoin(i), leftoverAmount);
+        break;
       }
       case "add_diff_liquidity_one_coin": {
         const [leftoverAmount, i] = args;
-        return [{ tokenIn: this.curveCoin(i), leftoverAmount }];
+        this.setLeftover(balances, this.curveCoin(i), leftoverAmount);
+        break;
       }
       case "remove_diff_liquidity_one_coin": {
         const [leftoverAmount] = args;
-        return [{ tokenIn: this.lpToken, leftoverAmount }];
+        this.setLeftover(balances, this.lpToken, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
   /**

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

@@ -71,23 +71,25 @@ class BalancerV3RouterAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "swapSingleTokenDiffIn": {
         const [, tokenIn, , leftoverAmount] = decoded.args;
-        return [{ tokenIn, leftoverAmount }];
+        this.setLeftover(balances, tokenIn, leftoverAmount);
+        break;
       }
       // BPT (pool token) is spent down to the leftover
       case "removeLiquiditySingleTokenDiff": {
         const [pool, leftoverAmount] = decoded.args;
-        return [{ tokenIn: pool, leftoverAmount }];
+        this.setLeftover(balances, pool, leftoverAmount);
+        break;
       }
       case "addLiquidityUnbalancedDiff":
         throw new Error(
           `previewBalanceChanges cannot resolve pool tokens for addLiquidityUnbalancedDiff on ${this.contractType} adapter at ${this.address}`
         );
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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);
     }
   }
 }