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

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

@@ -117,27 +117,29 @@ class PendleRouterAdapterContract extends import_AbstractAdapter.AbstractAdapter
       }))
     };
   }
-  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(
@@ -152,15 +154,11 @@ class PendleRouterAdapterContract extends import_AbstractAdapter.AbstractAdapter
           );
         }
         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/cjs/plugins/adapters/contracts/SecuritizeOnRampAdapterContract.js

@@ -64,15 +64,16 @@ class SecuritizeOnRampAdapterContract extends import_AbstractAdapter.AbstractAda
       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);
     }
   }
 }

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

@@ -72,28 +72,29 @@ class SecuritizeRedemptionGatewayAdapterContract extends import_AbstractAdapter.
       redemptionPhantomToken: this.#redemptionPhantomToken ? this.labelAddress(this.#redemptionPhantomToken) : void 0
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
-      // exact-input redemption: burns dsTokenAmount of the DS token in
-      // exchange for the redemption phantom token (which is credited by the
-      // storeExpectedBalances bracket delta, not here)
       case "redeem": {
         const [dsTokenAmount] = decoded.args;
-        const balance = balances.get(this.dsToken) ?? 0n;
-        return [
-          {
-            tokenIn: this.dsToken,
-            leftoverAmount: balance > dsTokenAmount ? balance - dsTokenAmount : 0n
-          }
-        ];
+        this.spendExact(balances, this.dsToken, dsTokenAmount);
+        break;
       }
       // diff-style redemption: spends the DS token down to the leftover
       case "redeemDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.dsToken, leftoverAmount }];
+        this.setLeftover(balances, this.dsToken, leftoverAmount);
+        break;
       }
+      // TODO:
+      // `claim(address[] redeemers)` (the claim call emitted by the
+      // withdrawal compressor) cannot be previewed offline: the redemption
+      // phantom token burn (the compressor's `withdrawalTokenSpent`, i.e.
+      // each redeemer's `getRedemptionAmount()`) lives in per-redeemer clone
+      // contracts and is not recoverable from calldata. For claimable
+      // redeemers it equals the stablecoin credit, but that value is not in
+      // calldata either.
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -100,21 +100,23 @@ class StakingRewardsAdapterContract extends import_AbstractAdapter.AbstractAdapt
       referral: this.#referral
     };
   }
-  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": {
         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/TraderJoeRouterAdapterContract.js

@@ -82,14 +82,15 @@ class TraderJoeRouterAdapterContract extends import_AbstractAdapter.AbstractAdap
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "swapDiffTokensForTokens": {
         const [leftoverAmount, , path] = decoded.args;
-        return [{ tokenIn: path.tokenPath[0], leftoverAmount }];
+        this.setLeftover(balances, path.tokenPath[0], leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -93,14 +93,15 @@ class UniswapV2AdapterContract extends import_AbstractAdapter.AbstractAdapterCon
   classifyLegacyOperation(_parsed, transfers) {
     return { operation: "UniswapSwap", ...(0, import_transferHelpers.swapFromTransfers)(transfers) };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "swapDiffTokensForTokens": {
         const [leftoverAmount, , path] = decoded.args;
-        return [{ tokenIn: path[0], leftoverAmount }];
+        this.setLeftover(balances, path[0], leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -71,24 +71,21 @@ class UniswapV3AdapterContract 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);
     }
   }
   stringifyFunctionParams(params) {

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

@@ -81,19 +81,19 @@ class UniswapV4AdapterContract extends import_AbstractAdapter.AbstractAdapterCon
   classifyLegacyOperation(_parsed, transfers) {
     return { operation: "UniswapSwap", ...(0, import_transferHelpers.swapFromTransfers)(transfers) };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "swapExactInputSingleDiff": {
         const [poolKey, zeroForOne, leftoverAmount] = decoded.args;
-        return [
-          {
-            tokenIn: zeroForOne ? poolKey.token0 : poolKey.token1,
-            leftoverAmount
-          }
-        ];
+        this.setLeftover(
+          balances,
+          zeroForOne ? poolKey.token0 : poolKey.token1,
+          leftoverAmount
+        );
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -70,18 +70,20 @@ class UpshiftVaultAdapterContract extends import_AbstractAdapter.AbstractAdapter
       stakedPhantomToken: this.#stakedPhantomToken ? this.labelAddress(this.#stakedPhantomToken) : void 0
     };
   }
-  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.vault, leftoverAmount }];
+        this.setLeftover(balances, this.vault, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -74,14 +74,15 @@ class VelodromeV2RouterAdapterContract extends import_AbstractAdapter.AbstractAd
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "swapDiffTokensForTokens": {
         const [leftoverAmount, , routes] = decoded.args;
-        return [{ tokenIn: routes[0].from, leftoverAmount }];
+        this.setLeftover(balances, routes[0].from, leftoverAmount);
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -65,19 +65,21 @@ class WstETHV1AdapterContract extends import_AbstractAdapter.AbstractAdapterCont
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
-  decodeDiffLeftovers(decoded, balances) {
+  applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "wrapDiff": {
         const [leftoverAmount] = decoded.args;
-        return [{ tokenIn: this.stETH, leftoverAmount }];
+        this.setLeftover(balances, this.stETH, leftoverAmount);
+        break;
       }
       // wstETH is the adapter's target contract
       case "unwrapDiff": {
         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/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);
     }
   }
 }

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