@gearbox-protocol/sdk 14.12.0-next.4 → 14.12.0-next.41

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

@@ -21,16 +21,16 @@ __export(KelpLRTDepositPoolAdapterContract_exports, {
   KelpLRTDepositPoolAdapterContract: () => KelpLRTDepositPoolAdapterContract
 });
 module.exports = __toCommonJS(KelpLRTDepositPoolAdapterContract_exports);
-var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
 var import_sdk = require("../../../sdk/index.js");
+var import_adapters = require("../abi/adapters/index.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
-const abi = import_integrations_v3.iKelpLrtDepositPoolAdapterAbi;
-const protocolAbi = import_integrations_v3.iKelpLrtDepositPoolGatewayAbi;
+const abi = import_adapters.iKelpLrtDepositPoolAdapterAbi;
+const protocolAbi = import_adapters.iKelpLrtDepositPoolGatewayAbi;
 class KelpLRTDepositPoolAdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
   #allowedAssets;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = (0, import_viem.decodeAbiParameters)(
         [
@@ -54,6 +54,17 @@ class KelpLRTDepositPoolAdapterContract extends import_AbstractAdapter.AbstractA
       allowedAssets: this.#allowedAssets?.map((a) => this.labelAddress(a))
     };
   }
+  async applyBalanceChanges(balances, decoded) {
+    switch (decoded.functionName) {
+      case "depositAssetDiff": {
+        const [tokenIn, leftoverAmount] = decoded.args;
+        this.setLeftover(balances, tokenIn, leftoverAmount);
+        break;
+      }
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -21,16 +21,16 @@ __export(KelpLRTWithdrawalManagerAdapterContract_exports, {
   KelpLRTWithdrawalManagerAdapterContract: () => KelpLRTWithdrawalManagerAdapterContract
 });
 module.exports = __toCommonJS(KelpLRTWithdrawalManagerAdapterContract_exports);
-var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
 var import_sdk = require("../../../sdk/index.js");
+var import_adapters = require("../abi/adapters/index.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
-const abi = import_integrations_v3.iKelpLrtWithdrawalManagerAdapterAbi;
-const protocolAbi = import_integrations_v3.iKelpLrtWithdrawalManagerGatewayAbi;
+const abi = import_adapters.iKelpLrtWithdrawalManagerAdapterAbi;
+const protocolAbi = import_adapters.iKelpLrtWithdrawalManagerGatewayAbi;
 class KelpLRTWithdrawalManagerAdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
   #allowedTokensOut;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = (0, import_viem.decodeAbiParameters)(
         [

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

@@ -21,20 +21,20 @@ __export(LidoV1AdapterContract_exports, {
   LidoV1AdapterContract: () => LidoV1AdapterContract
 });
 module.exports = __toCommonJS(LidoV1AdapterContract_exports);
-var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
 var import_sdk = require("../../../sdk/index.js");
+var import_adapters = require("../abi/adapters/index.js");
 var import_targetContractAbi = require("../abi/targetContractAbi.js");
 var import_transferHelpers = require("../transferHelpers.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
-const abi = import_integrations_v3.iLidoV1AdapterAbi;
+const abi = import_adapters.iLidoV1AdapterAbi;
 const protocolAbi = import_targetContractAbi.lidoV1_WETHGatewayAbi;
 class LidoV1AdapterContract extends import_AbstractAdapter.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 = (0, import_viem.decodeAbiParameters)(
         [
@@ -75,6 +75,18 @@ class LidoV1AdapterContract extends import_AbstractAdapter.AbstractAdapterContra
   classifyLegacyOperation(_parsed, transfers) {
     return { operation: "LidoSubmit", ...(0, import_transferHelpers.swapFromTransfers)(transfers) };
   }
+  async applyBalanceChanges(balances, decoded) {
+    switch (decoded.functionName) {
+      // the adapter targets the WETH gateway, so WETH is spent
+      case "submitDiff": {
+        const [leftoverAmount] = decoded.args;
+        this.setLeftover(balances, this.weth, leftoverAmount);
+        break;
+      }
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -21,17 +21,17 @@ __export(MellowClaimerAdapterContract_exports, {
   MellowClaimerAdapterContract: () => MellowClaimerAdapterContract
 });
 module.exports = __toCommonJS(MellowClaimerAdapterContract_exports);
-var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
 var import_sdk = require("../../../sdk/index.js");
+var import_adapters = require("../abi/adapters/index.js");
 var import_targetContractAbi = require("../abi/targetContractAbi.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
-const abi = import_integrations_v3.iMellowClaimerAdapterAbi;
+const abi = import_adapters.iMellowClaimerAdapterAbi;
 const protocolAbi = import_targetContractAbi.iMellowClaimerAbi;
 class MellowClaimerAdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
   #allowedMultiVaults;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = (0, import_viem.decodeAbiParameters)(
         [
@@ -57,6 +57,28 @@ class MellowClaimerAdapterContract extends import_AbstractAdapter.AbstractAdapte
       )
     };
   }
+  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);
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -21,19 +21,19 @@ __export(MellowDVVAdapterContract_exports, {
   MellowDVVAdapterContract: () => MellowDVVAdapterContract
 });
 module.exports = __toCommonJS(MellowDVVAdapterContract_exports);
-var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
 var import_sdk = require("../../../sdk/index.js");
+var import_adapters = require("../abi/adapters/index.js");
 var import_targetContractAbi = require("../abi/targetContractAbi.js");
 var import_transferHelpers = require("../transferHelpers.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
-const abi = import_integrations_v3.mellowDvvAdapterAbi;
+const abi = import_adapters.mellowDvvAdapterAbi;
 const protocolAbi = import_targetContractAbi.iERC4626Abi;
 class MellowDVVAdapterContract extends import_AbstractAdapter.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 = (0, import_viem.decodeAbiParameters)(
         [
@@ -73,6 +73,23 @@ class MellowDVVAdapterContract extends import_AbstractAdapter.AbstractAdapterCon
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
+  async applyBalanceChanges(balances, decoded) {
+    const share = this.#vault ?? this.targetContract;
+    switch (decoded.functionName) {
+      case "depositDiff": {
+        const [leftoverAmount] = decoded.args;
+        this.setLeftover(balances, this.asset, leftoverAmount);
+        break;
+      }
+      case "redeemDiff": {
+        const [leftoverAmount] = decoded.args;
+        this.setLeftover(balances, share, leftoverAmount);
+        break;
+      }
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -21,20 +21,20 @@ __export(MellowERC4626VaultAdapterContract_exports, {
   MellowERC4626VaultAdapterContract: () => MellowERC4626VaultAdapterContract
 });
 module.exports = __toCommonJS(MellowERC4626VaultAdapterContract_exports);
-var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
 var import_sdk = require("../../../sdk/index.js");
+var import_adapters = require("../abi/adapters/index.js");
 var import_targetContractAbi = require("../abi/targetContractAbi.js");
 var import_transferHelpers = require("../transferHelpers.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
-const abi = import_integrations_v3.iMellow4626VaultAdapterAbi;
+const abi = import_adapters.iMellow4626VaultAdapterAbi;
 const protocolAbi = import_targetContractAbi.iERC4626Abi;
 class MellowERC4626VaultAdapterContract extends import_AbstractAdapter.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) {
@@ -108,6 +108,59 @@ class MellowERC4626VaultAdapterContract extends import_AbstractAdapter.AbstractA
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
+  /**
+   * 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 = (0, import_viem.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;
+        this.setLeftover(balances, this.asset, leftoverAmount);
+        break;
+      }
+      case "redeemDiff": {
+        const [leftoverAmount] = decoded.args;
+        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:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -21,17 +21,17 @@ __export(MellowWrapperAdapterContract_exports, {
   MellowWrapperAdapterContract: () => MellowWrapperAdapterContract
 });
 module.exports = __toCommonJS(MellowWrapperAdapterContract_exports);
-var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
 var import_sdk = require("../../../sdk/index.js");
+var import_adapters = require("../abi/adapters/index.js");
 var import_targetContractAbi = require("../abi/targetContractAbi.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
-const abi = import_integrations_v3.iMellowWrapperAdapterAbi;
+const abi = import_adapters.iMellowWrapperAdapterAbi;
 const protocolAbi = import_targetContractAbi.iMellowWrapperAbi;
 class MellowWrapperAdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
   #allowedVaults;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = (0, import_viem.decodeAbiParameters)(
         [
@@ -55,6 +55,18 @@ class MellowWrapperAdapterContract extends import_AbstractAdapter.AbstractAdapte
       allowedVaults: this.#allowedVaults?.map((v) => this.labelAddress(v))
     };
   }
+  async applyBalanceChanges(balances, decoded) {
+    switch (decoded.functionName) {
+      case "depositDiff": {
+        const weth = this.tokensMeta.mustFindBySymbol("WETH").addr;
+        const [leftoverAmount] = decoded.args;
+        this.setLeftover(balances, weth, leftoverAmount);
+        break;
+      }
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -0,0 +1,168 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MidasGatewayAdapterContract_exports = {};
+__export(MidasGatewayAdapterContract_exports, {
+  MidasGatewayAdapterContract: () => MidasGatewayAdapterContract
+});
+module.exports = __toCommonJS(MidasGatewayAdapterContract_exports);
+var import_viem = require("viem");
+var import_sdk = require("../../../sdk/index.js");
+var import_adapters = require("../abi/adapters/index.js");
+var import_AbstractAdapter = require("./AbstractAdapter.js");
+const abi = import_adapters.iMidasGatewayAdapterV311Abi;
+const protocolAbi = import_adapters.iMidasGatewayV311Abi;
+class MidasGatewayAdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
+  #gateway;
+  #mToken;
+  #quoteToken;
+  #phantomToken;
+  #referrerId;
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = (0, import_viem.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 import_sdk.MissingSerializedParamsError("gateway");
+    return this.#gateway;
+  }
+  get mToken() {
+    if (!this.#mToken) throw new import_sdk.MissingSerializedParamsError("mToken");
+    return this.#mToken;
+  }
+  get quoteToken() {
+    if (!this.#quoteToken) throw new import_sdk.MissingSerializedParamsError("quoteToken");
+    return this.#quoteToken;
+  }
+  /**
+   * Redemption phantom token; `zeroAddress` when the gateway was deployed
+   * without delayed withdrawals
+   */
+  get phantomToken() {
+    if (!this.#phantomToken)
+      throw new import_sdk.MissingSerializedParamsError("phantomToken");
+    return this.#phantomToken;
+  }
+  get referrerId() {
+    if (this.#referrerId === void 0)
+      throw new import_sdk.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 = (0, import_viem.decodeFunctionData)({ abi: this.abi, data: calldata });
+    if (decoded.functionName !== "redeemRequest") {
+      return void 0;
+    }
+    if ((0, import_viem.isAddressEqual)(this.phantomToken, import_viem.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 = (0, import_viem.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);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MidasGatewayAdapterContract
+});

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

@@ -21,19 +21,19 @@ __export(MidasIssuanceVaultAdapterContract_exports, {
   MidasIssuanceVaultAdapterContract: () => MidasIssuanceVaultAdapterContract
 });
 module.exports = __toCommonJS(MidasIssuanceVaultAdapterContract_exports);
-var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
 var import_sdk = require("../../../sdk/index.js");
+var import_adapters = require("../abi/adapters/index.js");
 var import_targetContractAbi = require("../abi/targetContractAbi.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
-const abi = import_integrations_v3.iMidasIssuanceVaultAdapterAbi;
-const protocolAbi = import_targetContractAbi.iMidasIssuanceVaultAbi;
+const abi = import_adapters.iMidasIssuanceVaultAdapterV310Abi;
+const protocolAbi = import_targetContractAbi.iMidasIssuanceVaultV310Abi;
 class MidasIssuanceVaultAdapterContract extends import_AbstractAdapter.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 = (0, import_viem.decodeAbiParameters)(
         [
@@ -72,6 +72,17 @@ class MidasIssuanceVaultAdapterContract extends import_AbstractAdapter.AbstractA
       allowedTokens: this.#allowedTokens?.map((t) => this.labelAddress(t))
     };
   }
+  async applyBalanceChanges(balances, decoded) {
+    switch (decoded.functionName) {
+      case "depositInstantDiff": {
+        const [tokenIn, leftoverAmount] = decoded.args;
+        this.setLeftover(balances, tokenIn, leftoverAmount);
+        break;
+      }
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -21,18 +21,18 @@ __export(MidasRedemptionVaultAdapterContract_exports, {
   MidasRedemptionVaultAdapterContract: () => MidasRedemptionVaultAdapterContract
 });
 module.exports = __toCommonJS(MidasRedemptionVaultAdapterContract_exports);
-var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
 var import_sdk = require("../../../sdk/index.js");
+var import_adapters = require("../abi/adapters/index.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
-const abi = import_integrations_v3.iMidasRedemptionVaultAdapterAbi;
-const protocolAbi = import_integrations_v3.iMidasRedemptionVaultGatewayAbi;
+const abi = import_adapters.iMidasRedemptionVaultAdapterV310Abi;
+const protocolAbi = import_adapters.iMidasRedemptionVaultGatewayV310Abi;
 class MidasRedemptionVaultAdapterContract extends import_AbstractAdapter.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 = (0, import_viem.decodeAbiParameters)(
         [
@@ -77,6 +77,19 @@ class MidasRedemptionVaultAdapterContract extends import_AbstractAdapter.Abstrac
       }))
     };
   }
+  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;
+        this.setLeftover(balances, this.mToken, leftoverAmount);
+        break;
+      }
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {