@gearbox-protocol/sdk 14.12.0-next.3 → 14.12.0-next.30

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,155 @@
+"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;
+  #referrerId;
+  #allowedInputTokens;
+  #allowedOutputTokens;
+  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: "bytes32", name: "referrerId" },
+          { type: "address[]", name: "allowedInputTokens" },
+          { type: "address[]", name: "allowedOutputTokens" },
+          { type: "address[]", name: "allowedPhantomTokens" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#gateway = decoded[2];
+      this.#mToken = decoded[3];
+      this.#referrerId = decoded[4];
+      this.#allowedInputTokens = [...decoded[5]];
+      this.#allowedOutputTokens = decoded[6].map((token, index) => ({
+        token,
+        phantomToken: decoded[7][index]
+      }));
+    }
+  }
+  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 referrerId() {
+    if (this.#referrerId === void 0)
+      throw new import_sdk.MissingSerializedParamsError("referrerId");
+    return this.#referrerId;
+  }
+  get allowedInputTokens() {
+    if (!this.#allowedInputTokens)
+      throw new import_sdk.MissingSerializedParamsError("allowedInputTokens");
+    return this.#allowedInputTokens;
+  }
+  get allowedOutputTokens() {
+    if (!this.#allowedOutputTokens)
+      throw new import_sdk.MissingSerializedParamsError("allowedOutputTokens");
+    return this.#allowedOutputTokens;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      gateway: this.#gateway ? this.labelAddress(this.#gateway) : void 0,
+      mToken: this.#mToken ? this.labelAddress(this.#mToken) : void 0,
+      referrerId: this.#referrerId,
+      allowedInputTokens: this.#allowedInputTokens?.map(
+        (t) => this.labelAddress(t)
+      ),
+      allowedOutputTokens: this.#allowedOutputTokens?.map((t) => ({
+        token: this.labelAddress(t.token),
+        phantomToken: this.labelAddress(t.phantomToken)
+      }))
+    };
+  }
+  /**
+   * `redeemRequest` (the only request call the withdrawal compressor emits)
+   * spends the mToken and mints the phantom token of the requested
+   * `tokenOut`, which is received when the redemption is claimed. The 3-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;
+    }
+    const [tokenOut, , extraData] = decoded.args;
+    const phantomToken = this.allowedOutputTokens.find(
+      (t) => (0, import_viem.isAddressEqual)(t.token, tokenOut)
+    )?.phantomToken;
+    if (!phantomToken) {
+      return void 0;
+    }
+    return { phantomToken, claimToken: tokenOut, extraData };
+  }
+  async applyBalanceChanges(balances, decoded) {
+    switch (decoded.functionName) {
+      case "depositInstantDiff": {
+        const [tokenIn, leftoverAmount] = decoded.args;
+        this.setLeftover(balances, tokenIn, leftoverAmount);
+        break;
+      }
+      // instant 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;
+      }
+      // 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 = {

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

@@ -23,9 +23,9 @@ __export(PendleRouterAdapterContract_exports, {
   PendleTokenType: () => PendleTokenType
 });
 module.exports = __toCommonJS(PendleRouterAdapterContract_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");
 var PendleTokenType = /* @__PURE__ */ ((PendleTokenType2) => {
@@ -39,12 +39,12 @@ var PendlePairStatus = /* @__PURE__ */ ((PendlePairStatus2) => {
   PendlePairStatus2[PendlePairStatus2["EXIT_ONLY"] = 2] = "EXIT_ONLY";
   return PendlePairStatus2;
 })(PendlePairStatus || {});
-const abi = import_integrations_v3.iPendleRouterAdapterAbi;
+const abi = import_adapters.iPendleRouterAdapterAbi;
 const protocolAbi = import_targetContractAbi.iPendleRouterAbi;
 class PendleRouterAdapterContract extends import_AbstractAdapter.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) {
@@ -117,6 +117,62 @@ class PendleRouterAdapterContract extends import_AbstractAdapter.AbstractAdapter
       }))
     };
   }
+  async applyBalanceChanges(balances, decoded) {
+    switch (decoded.functionName) {
+      case "swapDiffTokenForPt":
+      case "addLiquiditySingleTokenDiff": {
+        const [, , , diffInput] = decoded.args;
+        this.setLeftover(
+          balances,
+          diffInput.tokenIn,
+          diffInput.leftoverTokenIn
+        );
+        break;
+      }
+      case "swapDiffPtForToken": {
+        const [market, leftoverPt] = decoded.args;
+        const pt = this.#mustFindPendleToken(market, 0 /* PT */);
+        this.setLeftover(balances, pt, leftoverPt);
+        break;
+      }
+      case "removeLiquiditySingleTokenDiff": {
+        const [market, leftoverLp] = decoded.args;
+        const lp = this.#mustFindPendleToken(market, 1 /* LP */);
+        this.setLeftover(balances, lp, leftoverLp);
+        break;
+      }
+      case "redeemDiffPyToToken": {
+        const candidates = this.allowedPairs.filter(
+          (p) => (p.pendleTokenType === void 0 || p.pendleTokenType === 0 /* PT */) && (balances.get(p.pendleToken) ?? 0n) > 1n
+        );
+        const ptTokens = new Set(
+          candidates.map((p) => p.pendleToken.toLowerCase())
+        );
+        if (ptTokens.size !== 1) {
+          throw new Error(
+            `cannot recover PT token for redeemDiffPyToToken on pendle adapter at ${this.address}: ${ptTokens.size} candidates`
+          );
+        }
+        const [, leftoverPt] = decoded.args;
+        this.setLeftover(balances, candidates[0].pendleToken, leftoverPt);
+        break;
+      }
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
+  #mustFindPendleToken(market, type) {
+    const marketLC = market.toLowerCase();
+    const pair = this.allowedPairs.find(
+      (p) => p.market.toLowerCase() === marketLC && (p.pendleTokenType === void 0 || p.pendleTokenType === type)
+    );
+    if (!pair) {
+      throw new Error(
+        `pendle pair for market ${market} not found on adapter at ${this.address}`
+      );
+    }
+    return pair.pendleToken;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -23,17 +23,17 @@ __export(SecuritizeOnRampAdapterContract_exports, {
 module.exports = __toCommonJS(SecuritizeOnRampAdapterContract_exports);
 var import_viem = require("viem");
 var import_sdk = require("../../../sdk/index.js");
+var import_iSecuritizeOnRampAdapterV310 = require("../abi/adapters/iSecuritizeOnRampAdapterV310.js");
 var import_iBaseOnRamp = require("../abi/securitize/iBaseOnRamp.js");
 var import_iSecuritizeOnRamp = require("../abi/securitize/iSecuritizeOnRamp.js");
-var import_iSecuritizeOnRampAdapter = require("../abi/securitize/iSecuritizeOnRampAdapter.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
-const abi = import_iSecuritizeOnRampAdapter.iSecuritizeOnRampAdapterAbi;
+const abi = import_iSecuritizeOnRampAdapterV310.iSecuritizeOnRampAdapterV310Abi;
 const protocolAbi = [...import_iSecuritizeOnRamp.iSecuritizeOnRampAbi, ...import_iBaseOnRamp.iBaseOnRampAbi];
 class SecuritizeOnRampAdapterContract extends import_AbstractAdapter.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 = (0, import_viem.decodeAbiParameters)(
         [
@@ -64,6 +64,18 @@ class SecuritizeOnRampAdapterContract extends import_AbstractAdapter.AbstractAda
       liquidityToken: this.#liquidityToken ? this.labelAddress(this.#liquidityToken) : void 0
     };
   }
+  async applyBalanceChanges(balances, decoded) {
+    switch (decoded.functionName) {
+      // swaps the liquidity token into dsToken
+      case "swapDiff": {
+        const [leftoverAmount] = decoded.args;
+        this.setLeftover(balances, this.liquidityToken, leftoverAmount);
+        break;
+      }
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {