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

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

@@ -116,8 +116,10 @@ class AbstractAdapterContract extends import_sdk.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.
@@ -134,23 +136,43 @@ class AbstractAdapterContract extends import_sdk.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/cjs/plugins/adapters/contracts/AbstractCurveAdapter.js

@@ -28,23 +28,26 @@ class AbstractCurveAdapterContract extends import_AbstractAdapter.AbstractAdapte
   classifyLegacyOperation(parsed, transfers) {
     return (0, import_transferHelpers.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/cjs/plugins/adapters/contracts/BalancerV3RouterAdapterContract.js

@@ -93,23 +93,25 @@ class BalancerV3RouterAdapterContract extends import_AbstractAdapter.AbstractAda
       }))
     };
   }
-  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/cjs/plugins/adapters/contracts/BalancerV3WrapperAdapterContract.js

@@ -55,19 +55,21 @@ class BalancerV3WrapperAdapterContract extends import_AbstractAdapter.AbstractAd
       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/cjs/plugins/adapters/contracts/CamelotV3AdapterContract.js

@@ -68,24 +68,21 @@ class CamelotV3AdapterContract extends import_AbstractAdapter.AbstractAdapterCon
       }))
     };
   }
-  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/cjs/plugins/adapters/contracts/ConvexV1BaseRewardPoolAdapterContract.js

@@ -128,22 +128,24 @@ class ConvexV1BaseRewardPoolAdapterContract extends import_AbstractAdapter.Abstr
       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/cjs/plugins/adapters/contracts/ConvexV1BoosterAdapterContract.js

@@ -102,21 +102,23 @@ class ConvexV1BoosterAdapterContract extends import_AbstractAdapter.AbstractAdap
     }
     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/cjs/plugins/adapters/contracts/DaiUsdsAdapterContract.js

@@ -74,18 +74,20 @@ class DaiUsdsAdapterContract extends import_AbstractAdapter.AbstractAdapterContr
     }
     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/cjs/plugins/adapters/contracts/ERC4626AdapterContract.js

@@ -99,18 +99,27 @@ class ERC4626AdapterContract extends import_AbstractAdapter.AbstractAdapterContr
     }
     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/cjs/plugins/adapters/contracts/ERC4626ReferralAdapterContract.js

@@ -74,18 +74,20 @@ class ERC4626ReferralAdapterContract extends import_AbstractAdapter.AbstractAdap
     }
     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/cjs/plugins/adapters/contracts/FluidDexAdapterContract.js

@@ -62,19 +62,19 @@ class FluidDexAdapterContract extends import_AbstractAdapter.AbstractAdapterCont
       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/cjs/plugins/adapters/contracts/InfinifiGatewayAdapterContract.js

@@ -84,25 +84,28 @@ class InfinifiGatewayAdapterContract extends import_AbstractAdapter.AbstractAdap
       )
     };
   }
-  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/cjs/plugins/adapters/contracts/KelpLRTDepositPoolAdapterContract.js

@@ -54,14 +54,15 @@ class KelpLRTDepositPoolAdapterContract extends import_AbstractAdapter.AbstractA
       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/cjs/plugins/adapters/contracts/LidoV1AdapterContract.js

@@ -75,15 +75,16 @@ class LidoV1AdapterContract extends import_AbstractAdapter.AbstractAdapterContra
   classifyLegacyOperation(_parsed, transfers) {
     return { operation: "LidoSubmit", ...(0, import_transferHelpers.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/cjs/plugins/adapters/contracts/MellowClaimerAdapterContract.js

@@ -57,6 +57,35 @@ class MellowClaimerAdapterContract extends import_AbstractAdapter.AbstractAdapte
       )
     };
   }
+  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);
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -73,19 +73,21 @@ class MellowDVVAdapterContract extends import_AbstractAdapter.AbstractAdapterCon
     }
     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/cjs/plugins/adapters/contracts/MellowERC4626VaultAdapterContract.js

@@ -108,19 +108,26 @@ class MellowERC4626VaultAdapterContract extends import_AbstractAdapter.AbstractA
     }
     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/cjs/plugins/adapters/contracts/MellowWrapperAdapterContract.js

@@ -55,15 +55,16 @@ class MellowWrapperAdapterContract extends import_AbstractAdapter.AbstractAdapte
       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/cjs/plugins/adapters/contracts/MidasGatewayAdapterContract.js

@@ -97,21 +97,48 @@ class MidasGatewayAdapterContract extends import_AbstractAdapter.AbstractAdapter
       }))
     };
   }
-  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) => (0, import_viem.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/cjs/plugins/adapters/contracts/MidasIssuanceVaultAdapterContract.js

@@ -72,14 +72,15 @@ class MidasIssuanceVaultAdapterContract extends import_AbstractAdapter.AbstractA
       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/cjs/plugins/adapters/contracts/MidasRedemptionVaultAdapterContract.js

@@ -77,16 +77,17 @@ class MidasRedemptionVaultAdapterContract extends import_AbstractAdapter.Abstrac
       }))
     };
   }
-  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);
     }
   }
 }