@gearbox-protocol/sdk 14.12.0-next.8 → 14.12.0-test.1

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

@@ -1,20 +1,19 @@
-import { iFluidDexAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import {
   decodeAbiParameters
 } from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import { iFluidDexAdapterAbi } from "../abi/adapters/index.js";
 import { iFluidDexAbi } from "../abi/targetContractAbi.js";
-import { clampToLeftover } from "../balanceChanges.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iFluidDexAdapterAbi;
 const protocolAbi = iFluidDexAbi;
 class FluidDexAdapterContract extends AbstractAdapterContract {
   #token0;
   #token1;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = decodeAbiParameters(
         [
@@ -44,18 +43,19 @@ class FluidDexAdapterContract extends AbstractAdapterContract {
       token1: this.#token1 ? this.labelAddress(this.#token1) : void 0
     };
   }
-  previewDecodedBalanceChanges(balances, decoded) {
+  async applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "swapInDiff": {
         const [swap0to1, leftoverAmount] = decoded.args;
-        return clampToLeftover(
+        this.setLeftover(
           balances,
           swap0to1 ? this.token0 : this.token1,
           leftoverAmount
         );
+        break;
       }
       default:
-        return super.previewDecodedBalanceChanges(balances, decoded);
+        await super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -1,12 +1,11 @@
-import { iInfinifiGatewayAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import {
   decodeAbiParameters
 } from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import { iInfinifiGatewayAdapterAbi } from "../abi/adapters/index.js";
 import { iInfinifiGatewayAbi } from "../abi/targetContractAbi.js";
-import { clampToLeftover } from "../balanceChanges.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iInfinifiGatewayAdapterAbi;
 const protocolAbi = iInfinifiGatewayAbi;
@@ -15,8 +14,8 @@ class InfinifiGatewayAdapterContract extends AbstractAdapterContract {
   #iusd;
   #siusd;
   #allowedLockedTokens;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = decodeAbiParameters(
         [
@@ -66,25 +65,28 @@ class InfinifiGatewayAdapterContract extends AbstractAdapterContract {
       )
     };
   }
-  previewDecodedBalanceChanges(balances, decoded) {
+  async applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "mintDiff": {
         const [leftoverAmount] = decoded.args;
-        return clampToLeftover(balances, 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 clampToLeftover(balances, this.iusd, leftoverAmount);
+        this.setLeftover(balances, this.iusd, leftoverAmount);
+        break;
       }
       case "unstakeDiff": {
         const [leftoverAmount] = decoded.args;
-        return clampToLeftover(balances, this.siusd, leftoverAmount);
+        this.setLeftover(balances, this.siusd, leftoverAmount);
+        break;
       }
       default:
-        return super.previewDecodedBalanceChanges(balances, decoded);
+        await super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -1,18 +1,18 @@
-import {
-  iInfinifiUnwindingGatewayAbi,
-  iInfinifiUnwindingGatewayAdapterAbi
-} from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import {
+  iInfinifiUnwindingGatewayAbi,
+  iInfinifiUnwindingGatewayAdapterAbi
+} from "../abi/adapters/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iInfinifiUnwindingGatewayAdapterAbi;
 const protocolAbi = iInfinifiUnwindingGatewayAbi;
 class InfinifiUnwindingGatewayAdapterContract extends AbstractAdapterContract {
   #allowedLockedTokens;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = decodeAbiParameters(
         [

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

@@ -1,21 +1,20 @@
-import {
-  iKelpLrtDepositPoolAdapterAbi,
-  iKelpLrtDepositPoolGatewayAbi
-} from "@gearbox-protocol/integrations-v3";
 import {
   decodeAbiParameters
 } from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
-import { clampToLeftover } from "../balanceChanges.js";
+import {
+  iKelpLrtDepositPoolAdapterAbi,
+  iKelpLrtDepositPoolGatewayAbi
+} from "../abi/adapters/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iKelpLrtDepositPoolAdapterAbi;
 const protocolAbi = iKelpLrtDepositPoolGatewayAbi;
 class KelpLRTDepositPoolAdapterContract extends AbstractAdapterContract {
   #allowedAssets;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = decodeAbiParameters(
         [
@@ -39,14 +38,15 @@ class KelpLRTDepositPoolAdapterContract extends AbstractAdapterContract {
       allowedAssets: this.#allowedAssets?.map((a) => this.labelAddress(a))
     };
   }
-  previewDecodedBalanceChanges(balances, decoded) {
+  async applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "depositAssetDiff": {
-        const [asset, leftoverAmount] = decoded.args;
-        return clampToLeftover(balances, asset, leftoverAmount);
+        const [tokenIn, leftoverAmount] = decoded.args;
+        this.setLeftover(balances, tokenIn, leftoverAmount);
+        break;
       }
       default:
-        return super.previewDecodedBalanceChanges(balances, decoded);
+        await super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -1,18 +1,18 @@
-import {
-  iKelpLrtWithdrawalManagerAdapterAbi,
-  iKelpLrtWithdrawalManagerGatewayAbi
-} from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import {
+  iKelpLrtWithdrawalManagerAdapterAbi,
+  iKelpLrtWithdrawalManagerGatewayAbi
+} from "../abi/adapters/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iKelpLrtWithdrawalManagerAdapterAbi;
 const protocolAbi = iKelpLrtWithdrawalManagerGatewayAbi;
 class KelpLRTWithdrawalManagerAdapterContract extends AbstractAdapterContract {
   #allowedTokensOut;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = decodeAbiParameters(
         [

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

@@ -1,12 +1,11 @@
-import { iLidoV1AdapterAbi } from "@gearbox-protocol/integrations-v3";
 import {
   decodeAbiParameters
 } from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import { iLidoV1AdapterAbi } from "../abi/adapters/index.js";
 import { lidoV1_WETHGatewayAbi } from "../abi/targetContractAbi.js";
-import { clampToLeftover } from "../balanceChanges.js";
 import { swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iLidoV1AdapterAbi;
@@ -15,8 +14,8 @@ class LidoV1AdapterContract extends AbstractAdapterContract {
   #stETH;
   #weth;
   #treasury;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = decodeAbiParameters(
         [
@@ -57,15 +56,16 @@ class LidoV1AdapterContract extends AbstractAdapterContract {
   classifyLegacyOperation(_parsed, transfers) {
     return { operation: "LidoSubmit", ...swapFromTransfers(transfers) };
   }
-  previewDecodedBalanceChanges(balances, decoded) {
+  async applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       // the adapter targets the WETH gateway, so WETH is spent
       case "submitDiff": {
         const [leftoverAmount] = decoded.args;
-        return clampToLeftover(balances, this.weth, leftoverAmount);
+        this.setLeftover(balances, this.weth, leftoverAmount);
+        break;
       }
       default:
-        return super.previewDecodedBalanceChanges(balances, decoded);
+        await super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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,12 +1,11 @@
-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 { clampToLeftover } from "../balanceChanges.js";
 import { fnSigToName, swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = mellowDvvAdapterAbi;
@@ -14,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(
         [
@@ -55,19 +54,21 @@ class MellowDVVAdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
-  previewDecodedBalanceChanges(balances, decoded) {
+  async applyBalanceChanges(balances, decoded) {
     const share = this.#vault ?? this.targetContract;
     switch (decoded.functionName) {
       case "depositDiff": {
         const [leftoverAmount] = decoded.args;
-        return clampToLeftover(balances, this.asset, leftoverAmount);
+        this.setLeftover(balances, this.asset, leftoverAmount);
+        break;
       }
       case "redeemDiff": {
         const [leftoverAmount] = decoded.args;
-        return clampToLeftover(balances, share, leftoverAmount);
+        this.setLeftover(balances, share, leftoverAmount);
+        break;
       }
       default:
-        return super.previewDecodedBalanceChanges(balances, decoded);
+        await super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -1,12 +1,12 @@
-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 { clampToLeftover } from "../balanceChanges.js";
 import { fnSigToName, swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iMellow4626VaultAdapterAbi;
@@ -15,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) {
@@ -90,19 +90,57 @@ class MellowERC4626VaultAdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
-  previewDecodedBalanceChanges(balances, decoded) {
+  /**
+   * 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 clampToLeftover(balances, this.asset, leftoverAmount);
+        this.setLeftover(balances, this.asset, leftoverAmount);
+        break;
       }
       case "redeemDiff": {
         const [leftoverAmount] = decoded.args;
-        return clampToLeftover(balances, 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.previewDecodedBalanceChanges(balances, decoded);
+        await super.applyBalanceChanges(balances, decoded);
     }
   }
 }

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

@@ -1,19 +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 { clampToLeftover } from "../balanceChanges.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(
         [
@@ -37,15 +36,16 @@ class MellowWrapperAdapterContract extends AbstractAdapterContract {
       allowedVaults: this.#allowedVaults?.map((v) => this.labelAddress(v))
     };
   }
-  previewDecodedBalanceChanges(balances, decoded) {
+  async applyBalanceChanges(balances, decoded) {
     switch (decoded.functionName) {
       case "depositDiff": {
         const weth = this.tokensMeta.mustFindBySymbol("WETH").addr;
         const [leftoverAmount] = decoded.args;
-        return clampToLeftover(balances, weth, leftoverAmount);
+        this.setLeftover(balances, weth, leftoverAmount);
+        break;
       }
       default:
-        return super.previewDecodedBalanceChanges(balances, decoded);
+        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
+};