@gearbox-protocol/sdk 14.12.0-next.5 → 14.12.0-next.50

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

@@ -1,5 +1,8 @@
-import { ierc4626AdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters, zeroAddress } from "viem";
+import {
+  decodeAbiParameters,
+  zeroAddress
+} from "viem";
+import { ierc4626AdapterAbi } from "../../../abi/ierc4626Adapter.js";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
@@ -11,8 +14,8 @@ const protocolAbi = iERC4626Abi;
 class ERC4626AdapterContract 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 version = Number(args.baseParams.version);
       if (version <= 311) {
@@ -49,6 +52,14 @@ class ERC4626AdapterContract extends AbstractAdapterContract {
     if (!this.#asset) throw new MissingSerializedParamsError("asset");
     return this.#asset;
   }
+  /**
+   * Vault share token: the serialized `vault` when set; for v<=311 the
+   * serialized vault is zeroAddress and the adapter targets the vault
+   * directly, so the target contract is the share token.
+   */
+  get share() {
+    return this.#vault && this.#vault !== zeroAddress ? this.#vault : this.targetContract;
+  }
   stateHuman(raw) {
     return {
       ...super.stateHuman(raw),
@@ -70,6 +81,36 @@ class ERC4626AdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
+  async applyBalanceChanges(balances, decoded) {
+    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, this.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). Out-of-bracket RWA
+      // wrap/unwrap `redeem` goes through applyRWAWrapUnwrap, not here.
+      case "redeem": {
+        break;
+      }
+      // `withdraw`/`deposit`/`mint` stay unsupported: they are not emitted
+      // by the router (which uses diff variants) or the withdrawal compressor
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 export {
   ERC4626AdapterContract

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

@@ -1,8 +1,10 @@
-import { erc4626ReferralAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import { erc4626ReferralAdapterAbi } from "../abi/adapters/index.js";
 import { iERC4626ReferralAbi } from "../abi/targetContractAbi.js";
 import { fnSigToName, swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
@@ -11,8 +13,8 @@ const protocolAbi = iERC4626ReferralAbi;
 class ERC4626ReferralAdapterContract extends AbstractAdapterContract {
   #asset;
   #referral;
-  constructor(options, args) {
-    super(options, { ...args, abi, protocolAbi });
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi, protocolAbi });
     if (args.baseParams.serializedParams) {
       const decoded = decodeAbiParameters(
         [
@@ -53,6 +55,22 @@ class ERC4626ReferralAdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
+  async applyBalanceChanges(balances, decoded) {
+    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, this.targetContract, leftoverAmount);
+        break;
+      }
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 export {
   ERC4626ReferralAdapterContract

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

@@ -1,8 +1,10 @@
-import { iFluidDexAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import { iFluidDexAdapterAbi } from "../abi/adapters/index.js";
 import { iFluidDexAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iFluidDexAdapterAbi;
@@ -10,8 +12,8 @@ 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(
         [
@@ -41,6 +43,21 @@ class FluidDexAdapterContract extends AbstractAdapterContract {
       token1: this.#token1 ? this.labelAddress(this.#token1) : void 0
     };
   }
+  async applyBalanceChanges(balances, decoded) {
+    switch (decoded.functionName) {
+      case "swapInDiff": {
+        const [swap0to1, leftoverAmount] = decoded.args;
+        this.setLeftover(
+          balances,
+          swap0to1 ? this.token0 : this.token1,
+          leftoverAmount
+        );
+        break;
+      }
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 export {
   FluidDexAdapterContract

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

@@ -1,8 +1,10 @@
-import { iInfinifiGatewayAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
+import { iInfinifiGatewayAdapterAbi } from "../abi/adapters/index.js";
 import { iInfinifiGatewayAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iInfinifiGatewayAdapterAbi;
@@ -12,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(
         [
@@ -63,6 +65,30 @@ class InfinifiGatewayAdapterContract extends AbstractAdapterContract {
       )
     };
   }
+  async applyBalanceChanges(balances, decoded) {
+    switch (decoded.functionName) {
+      case "mintDiff": {
+        const [leftoverAmount] = decoded.args;
+        this.setLeftover(balances, this.usdc, leftoverAmount);
+        break;
+      }
+      // redeem, stake and lock all spend iUSD
+      case "redeemDiff":
+      case "stakeDiff":
+      case "createPositionDiff": {
+        const [leftoverAmount] = decoded.args;
+        this.setLeftover(balances, this.iusd, leftoverAmount);
+        break;
+      }
+      case "unstakeDiff": {
+        const [leftoverAmount] = decoded.args;
+        this.setLeftover(balances, this.siusd, leftoverAmount);
+        break;
+      }
+      default:
+        await super.applyBalanceChanges(balances, decoded);
+    }
+  }
 }
 export {
   InfinifiGatewayAdapterContract

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,18 +1,20 @@
 import {
-  iKelpLrtDepositPoolAdapterAbi,
-  iKelpLrtDepositPoolGatewayAbi
-} from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.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(
         [
@@ -36,6 +38,17 @@ class KelpLRTDepositPoolAdapterContract extends AbstractAdapterContract {
       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);
+    }
+  }
 }
 export {
   KelpLRTDepositPoolAdapterContract

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,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