@gearbox-protocol/sdk 14.12.0-next.9 → 14.12.0-test.2

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

@@ -1,16 +1,18 @@
-import { iMellowClaimerAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import { iMellowClaimerAdapterAbi } from "../abi/adapters/index.js";
 import { iMellowClaimerAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iMellowClaimerAdapterAbi;
 const protocolAbi = iMellowClaimerAbi;
 class MellowClaimerAdapterContract extends AbstractAdapterContract {
   #allowedMultiVaults;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = decodeAbiParameters(
         [
@@ -36,6 +38,28 @@ class MellowClaimerAdapterContract extends AbstractAdapterContract {
       )
     };
   }
+  async 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;
+      // no-op:
+      // `multiAcceptAndClaim` is only emitted by the withdrawal
+      // compressor, and sdk now encodes the spent phantom token
+      // burn as a negative storeExpectedBalances delta. Resolving the phantom
+      // from calldata alone is impossible offline (the multiVault-to-phantom
+      // mapping is not serialized); the commented-out code recovered it via
+      // an RPC lookup.
+      case "multiAcceptAndClaim": {
+        break;
+      }
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 export {
   MellowClaimerAdapterContract

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

@@ -1,10 +1,10 @@
-import { mellowDvvAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import {
   decodeAbiParameters
 } from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import { mellowDvvAdapterAbi } from "../abi/adapters/index.js";
 import { iERC4626Abi } from "../abi/targetContractAbi.js";
 import { fnSigToName, swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
@@ -13,8 +13,8 @@ const protocolAbi = iERC4626Abi;
 class MellowDVVAdapterContract extends AbstractAdapterContract {
   #vault;
   #asset;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = decodeAbiParameters(
         [
@@ -54,19 +54,21 @@ class MellowDVVAdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
-  decodeDiffLeftovers(decoded, balances) {
+  async 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);
+        await super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -1,10 +1,11 @@
-import { iMellow4626VaultAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import {
-  decodeAbiParameters
+  decodeAbiParameters,
+  decodeFunctionData
 } from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import { iMellow4626VaultAdapterAbi } from "../abi/adapters/index.js";
 import { iERC4626Abi } from "../abi/targetContractAbi.js";
 import { fnSigToName, swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
@@ -14,8 +15,8 @@ class MellowERC4626VaultAdapterContract extends AbstractAdapterContract {
   #vault;
   #asset;
   #stakedPhantomToken;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const version = Number(args.baseParams.version);
       if (version <= 310) {
@@ -89,19 +90,57 @@ class MellowERC4626VaultAdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
-  decodeDiffLeftovers(decoded, balances) {
+  /**
+   * Plain `redeem` on a Mellow multivault is a delayed-withdrawal request:
+   * it is only emitted by the withdrawal compressor (the router uses
+   * `redeemDiff`), spends the multivault shares and mints the withdrawal
+   * phantom token for the illiquid part. Mellow request calls cannot carry
+   * an intent, so `extraData` is always undefined.
+   *
+   * The withdrawal phantom token is only serialized by v311 adapters;
+   * on other versions it cannot be resolved offline and the request is not
+   * reported.
+   */
+  parseDelayedWithdrawalRequest(calldata) {
+    if (!this.#stakedPhantomToken || !this.#asset) {
+      return void 0;
+    }
+    const decoded = decodeFunctionData({ abi: this.abi, data: calldata });
+    if (decoded.functionName !== "redeem") {
+      return void 0;
+    }
+    return {
+      phantomToken: this.#stakedPhantomToken,
+      claimToken: this.#asset,
+      extraData: void 0
+    };
+  }
+  async 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;
+      }
+      // no-op:
+      // the only in-bracket producer of plain `redeem` is the
+      // withdrawal compressor, and sdk now encodes the spent
+      // shares as a negative storeExpectedBalances delta. The router never
+      // emits plain `redeem` — its workers use `redeemDiff` only. If the
+      // router (or another assembler) ever starts emitting in-bracket plain
+      // `redeem` without the negative delta, this case must decrease `share`
+      // by `shares` again (see commented-out lines).
+      case "redeem": {
+        break;
       }
       default:
-        return super.decodeDiffLeftovers(decoded, balances);
+        await super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -1,18 +1,18 @@
-import { iMellowWrapperAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import {
   decodeAbiParameters
 } from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import { iMellowWrapperAdapterAbi } from "../abi/adapters/index.js";
 import { iMellowWrapperAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iMellowWrapperAdapterAbi;
 const protocolAbi = iMellowWrapperAbi;
 class MellowWrapperAdapterContract extends AbstractAdapterContract {
   #allowedVaults;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = decodeAbiParameters(
         [
@@ -36,15 +36,16 @@ class MellowWrapperAdapterContract extends AbstractAdapterContract {
       allowedVaults: this.#allowedVaults?.map((v) => this.labelAddress(v))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  async 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);
+        await super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -0,0 +1,154 @@
+import {
+  decodeAbiParameters,
+  decodeFunctionData,
+  isAddressEqual,
+  zeroAddress
+} from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import {
+  iMidasGatewayAdapterV311Abi,
+  iMidasGatewayV311Abi
+} from "../abi/adapters/index.js";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iMidasGatewayAdapterV311Abi;
+const protocolAbi = iMidasGatewayV311Abi;
+class MidasGatewayAdapterContract extends AbstractAdapterContract {
+  #gateway;
+  #mToken;
+  #quoteToken;
+  #phantomToken;
+  #referrerId;
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = decodeAbiParameters(
+        [
+          { type: "address", name: "creditManager" },
+          { type: "address", name: "targetContract" },
+          { type: "address", name: "gateway" },
+          { type: "address", name: "mToken" },
+          { type: "address", name: "quoteToken" },
+          { type: "address", name: "phantomToken" },
+          { type: "bytes32", name: "referrerId" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#gateway = decoded[2];
+      this.#mToken = decoded[3];
+      this.#quoteToken = decoded[4];
+      this.#phantomToken = decoded[5];
+      this.#referrerId = decoded[6];
+    }
+  }
+  get gateway() {
+    if (!this.#gateway) throw new MissingSerializedParamsError("gateway");
+    return this.#gateway;
+  }
+  get mToken() {
+    if (!this.#mToken) throw new MissingSerializedParamsError("mToken");
+    return this.#mToken;
+  }
+  get quoteToken() {
+    if (!this.#quoteToken) throw new MissingSerializedParamsError("quoteToken");
+    return this.#quoteToken;
+  }
+  /**
+   * Redemption phantom token; `zeroAddress` when the gateway was deployed
+   * without delayed withdrawals
+   */
+  get phantomToken() {
+    if (!this.#phantomToken)
+      throw new MissingSerializedParamsError("phantomToken");
+    return this.#phantomToken;
+  }
+  get referrerId() {
+    if (this.#referrerId === void 0)
+      throw new MissingSerializedParamsError("referrerId");
+    return this.#referrerId;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      gateway: this.#gateway ? this.labelAddress(this.#gateway) : void 0,
+      mToken: this.#mToken ? this.labelAddress(this.#mToken) : void 0,
+      quoteToken: this.#quoteToken ? this.labelAddress(this.#quoteToken) : void 0,
+      phantomToken: this.#phantomToken ? this.labelAddress(this.#phantomToken) : void 0,
+      referrerId: this.#referrerId
+    };
+  }
+  /**
+   * `redeemRequest` (the only request call the withdrawal compressor emits)
+   * spends the mToken and mints the redemption phantom token; the quote token
+   * is received when the redemption is claimed. The 2-arg overload carries
+   * the intent `extraData`.
+   */
+  parseDelayedWithdrawalRequest(calldata) {
+    const decoded = decodeFunctionData({ abi: this.abi, data: calldata });
+    if (decoded.functionName !== "redeemRequest") {
+      return void 0;
+    }
+    if (isAddressEqual(this.phantomToken, zeroAddress)) {
+      return void 0;
+    }
+    const [, extraData] = decoded.args;
+    return {
+      phantomToken: this.phantomToken,
+      claimToken: this.quoteToken,
+      extraData
+    };
+  }
+  /**
+   * `withdrawFromRedeemer(address redeemer, uint256 amount)` claims a matured
+   * redemption from a redeemer contract.
+   */
+  parseDelayedWithdrawalClaim(calldata) {
+    const decoded = decodeFunctionData({ abi: this.abi, data: calldata });
+    if (decoded.functionName !== "withdrawFromRedeemer") {
+      return void 0;
+    }
+    const [redeemer] = decoded.args;
+    return { redeemer };
+  }
+  async applyBalanceChanges(balances, decoded) {
+    switch (decoded.functionName) {
+      case "depositInstantDiff": {
+        const [leftoverAmount] = decoded.args;
+        this.setLeftover(balances, this.quoteToken, leftoverAmount);
+        break;
+      }
+      // instant redemption spends the mToken down to the leftover
+      case "redeemInstantDiff": {
+        const [leftoverAmount] = decoded.args;
+        this.setLeftover(balances, this.mToken, leftoverAmount);
+        break;
+      }
+      // delayed redemption also spends the mToken down to the leftover (the
+      // minted phantom token is accounted for elsewhere)
+      case "redeemRequestDiff": {
+        const [leftoverAmount] = decoded.args;
+        this.setLeftover(balances, this.mToken, leftoverAmount);
+        break;
+      }
+      // no-op:
+      // `redeemRequest` is only emitted by the withdrawal compressor,
+      // and sdk now encodes the spent mToken amount as a negative storeExpectedBalances delta
+      case "redeemRequest": {
+        break;
+      }
+      // no-op:
+      // `withdrawFromRedeemer` is only emitted by the withdrawal
+      // compressor, and `assembleClaimDelayedCalls` encodes the phantom token
+      // burn as a negative storeExpectedBalances delta
+      case "withdrawFromRedeemer": {
+        break;
+      }
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
+}
+export {
+  MidasGatewayAdapterContract
+};

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

@@ -1,20 +1,20 @@
-import { iMidasIssuanceVaultAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import {
   decodeAbiParameters
 } from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
-import { iMidasIssuanceVaultAbi } from "../abi/targetContractAbi.js";
+import { iMidasIssuanceVaultAdapterV310Abi } from "../abi/adapters/index.js";
+import { iMidasIssuanceVaultV310Abi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
-const abi = iMidasIssuanceVaultAdapterAbi;
-const protocolAbi = iMidasIssuanceVaultAbi;
+const abi = iMidasIssuanceVaultAdapterV310Abi;
+const protocolAbi = iMidasIssuanceVaultV310Abi;
 class MidasIssuanceVaultAdapterContract extends AbstractAdapterContract {
   #mToken;
   #referrerId;
   #allowedTokens;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = decodeAbiParameters(
         [
@@ -53,14 +53,15 @@ class MidasIssuanceVaultAdapterContract extends AbstractAdapterContract {
       allowedTokens: this.#allowedTokens?.map((t) => this.labelAddress(t))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  async 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);
+        await super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -1,22 +1,22 @@
-import {
-  iMidasRedemptionVaultAdapterAbi,
-  iMidasRedemptionVaultGatewayAbi
-} from "@gearbox-protocol/integrations-v3";
 import {
   decodeAbiParameters
 } from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import {
+  iMidasRedemptionVaultAdapterV310Abi,
+  iMidasRedemptionVaultGatewayV310Abi
+} from "../abi/adapters/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
-const abi = iMidasRedemptionVaultAdapterAbi;
-const protocolAbi = iMidasRedemptionVaultGatewayAbi;
+const abi = iMidasRedemptionVaultAdapterV310Abi;
+const protocolAbi = iMidasRedemptionVaultGatewayV310Abi;
 class MidasRedemptionVaultAdapterContract extends AbstractAdapterContract {
   #gateway;
   #mToken;
   #allowedTokens;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = decodeAbiParameters(
         [
@@ -61,16 +61,17 @@ class MidasRedemptionVaultAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  async 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);
+        await super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -1,10 +1,10 @@
-import { iPendleRouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import {
   decodeAbiParameters
 } from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import { iPendleRouterAdapterAbi } from "../abi/adapters/index.js";
 import { iPendleRouterAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 var PendleTokenType = /* @__PURE__ */ ((PendleTokenType2) => {
@@ -22,8 +22,8 @@ const abi = iPendleRouterAdapterAbi;
 const protocolAbi = iPendleRouterAbi;
 class PendleRouterAdapterContract extends AbstractAdapterContract {
   #allowedPairs;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const version = Number(args.baseParams.version);
       if (version === 310) {
@@ -96,27 +96,29 @@ class PendleRouterAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  async 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);
+        await super.applyBalanceChanges(balances, decoded);
     }
   }
   #mustFindPendleToken(market, type) {

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

@@ -4,17 +4,17 @@ import {
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import { iSecuritizeOnRampAdapterV310Abi } from "../abi/adapters/iSecuritizeOnRampAdapterV310.js";
 import { iBaseOnRampAbi } from "../abi/securitize/iBaseOnRamp.js";
 import { iSecuritizeOnRampAbi } from "../abi/securitize/iSecuritizeOnRamp.js";
-import { iSecuritizeOnRampAdapterAbi } from "../abi/securitize/iSecuritizeOnRampAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
-const abi = iSecuritizeOnRampAdapterAbi;
+const abi = iSecuritizeOnRampAdapterV310Abi;
 const protocolAbi = [...iSecuritizeOnRampAbi, ...iBaseOnRampAbi];
 class SecuritizeOnRampAdapterContract extends AbstractAdapterContract {
   #dsToken;
   #liquidityToken;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = decodeAbiParameters(
         [
@@ -45,15 +45,16 @@ class SecuritizeOnRampAdapterContract extends AbstractAdapterContract {
       liquidityToken: this.#liquidityToken ? this.labelAddress(this.#liquidityToken) : void 0
     };
   }
-  decodeDiffLeftovers(decoded, balances) {
+  async 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);
+        await super.applyBalanceChanges(balances, decoded);
     }
   }
 }