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

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

@@ -1,8 +1,10 @@
-import { iLidoV1AdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+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 { swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
@@ -12,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(
         [
@@ -54,6 +56,18 @@ class LidoV1AdapterContract extends AbstractAdapterContract {
   classifyLegacyOperation(_parsed, transfers) {
     return { operation: "LidoSubmit", ...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);
+    }
+  }
 }
 export {
   LidoV1AdapterContract

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,8 +1,10 @@
-import { mellowDvvAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+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";
@@ -11,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(
         [
@@ -52,6 +54,23 @@ class MellowDVVAdapterContract extends AbstractAdapterContract {
     }
     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);
+    }
+  }
 }
 export {
   MellowDVVAdapterContract

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

@@ -1,8 +1,11 @@
-import { iMellow4626VaultAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  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";
@@ -12,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) {
@@ -87,6 +90,59 @@ class MellowERC4626VaultAdapterContract extends AbstractAdapterContract {
     }
     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 = 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);
+    }
+  }
 }
 export {
   MellowERC4626VaultAdapterContract

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

@@ -1,16 +1,18 @@
-import { iMellowWrapperAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+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(
         [
@@ -34,6 +36,18 @@ class MellowWrapperAdapterContract extends AbstractAdapterContract {
       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);
+    }
+  }
 }
 export {
   MellowWrapperAdapterContract

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,18 +1,20 @@
-import { iMidasIssuanceVaultAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+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(
         [
@@ -51,6 +53,17 @@ class MidasIssuanceVaultAdapterContract extends AbstractAdapterContract {
       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);
+    }
+  }
 }
 export {
   MidasIssuanceVaultAdapterContract

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

@@ -1,20 +1,22 @@
 import {
-  iMidasRedemptionVaultAdapterAbi,
-  iMidasRedemptionVaultGatewayAbi
-} from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+  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(
         [
@@ -59,6 +61,19 @@ class MidasRedemptionVaultAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
+  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);
+    }
+  }
 }
 export {
   MidasRedemptionVaultAdapterContract

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

@@ -1,8 +1,10 @@
-import { iPendleRouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+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) => {
@@ -20,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) {
@@ -94,6 +96,62 @@ class PendleRouterAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
+  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;
+  }
 }
 export {
   PendlePairStatus,

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

@@ -1,18 +1,20 @@
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 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(
         [
@@ -43,6 +45,18 @@ class SecuritizeOnRampAdapterContract extends AbstractAdapterContract {
       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);
+    }
+  }
 }
 export {
   SecuritizeOnRampAdapterContract