@gearbox-protocol/sdk 13.0.0-next.9 → 13.0.1

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

@@ -1,36 +1,65 @@
-import { iUniswapV4AdapterAbi } from "@gearbox-protocol/integrations-v3";
+import {
+  iUniswapV4AdapterAbi,
+  iUniswapV4GatewayAbi
+} from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import { MissingSerializedParamsError } from "../../../sdk/index.js";
+import { swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iUniswapV4AdapterAbi;
+const protocolAbi = iUniswapV4GatewayAbi;
 class UniswapV4AdapterContract extends AbstractAdapterContract {
-  supportedPoolKeys;
+  #supportedPoolKeys;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        {
-          type: "tuple[]",
-          name: "supportedPools",
-          components: [
-            { type: "address", name: "token0" },
-            { type: "address", name: "token1" },
-            { type: "uint24", name: "fee" },
-            { type: "int24", name: "tickSpacing" },
-            { type: "address", name: "hooks" }
-          ]
-        }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.supportedPoolKeys = decoded[2].map((pool) => ({
-      token0: pool.token0,
-      token1: pool.token1,
-      fee: pool.fee,
-      tickSpacing: pool.tickSpacing,
-      hooks: pool.hooks
-    }));
+    super(options, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = decodeAbiParameters(
+        [
+          { type: "address", name: "creditManager" },
+          { type: "address", name: "targetContract" },
+          {
+            type: "tuple[]",
+            name: "supportedPools",
+            components: [
+              { type: "address", name: "token0" },
+              { type: "address", name: "token1" },
+              { type: "uint24", name: "fee" },
+              { type: "int24", name: "tickSpacing" },
+              { type: "address", name: "hooks" }
+            ]
+          }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#supportedPoolKeys = decoded[2].map((pool) => ({
+        token0: pool.token0,
+        token1: pool.token1,
+        fee: pool.fee,
+        tickSpacing: pool.tickSpacing,
+        hooks: pool.hooks
+      }));
+    }
+  }
+  get supportedPoolKeys() {
+    if (!this.#supportedPoolKeys)
+      throw new MissingSerializedParamsError("supportedPoolKeys");
+    return this.#supportedPoolKeys;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      supportedPoolKeys: this.#supportedPoolKeys?.map((p) => ({
+        token0: this.labelAddress(p.token0),
+        token1: this.labelAddress(p.token1),
+        fee: p.fee,
+        tickSpacing: p.tickSpacing,
+        hooks: this.labelAddress(p.hooks)
+      }))
+    };
+  }
+  /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L81-L91 */
+  classifyLegacyOperation(_parsed, transfers) {
+    return { operation: "UniswapSwap", ...swapFromTransfers(transfers) };
   }
 }
 export {

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

@@ -1,26 +1,56 @@
-import { iUpshiftVaultAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import {
+  iUpshiftVaultAdapterAbi,
+  iUpshiftVaultGatewayAbi
+} from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iUpshiftVaultAdapterAbi;
+const protocolAbi = iUpshiftVaultGatewayAbi;
 class UpshiftVaultAdapterContract extends AbstractAdapterContract {
-  vault;
-  asset;
-  stakedPhantomToken;
+  #vault;
+  #asset;
+  #stakedPhantomToken;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "vault" },
-        { type: "address", name: "asset" },
-        { type: "address", name: "stakedPhantomToken" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.vault = decoded[2];
-    this.asset = decoded[3];
-    this.stakedPhantomToken = decoded[4];
+    super(options, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = decodeAbiParameters(
+        [
+          { type: "address", name: "creditManager" },
+          { type: "address", name: "targetContract" },
+          { type: "address", name: "vault" },
+          { type: "address", name: "asset" },
+          { type: "address", name: "stakedPhantomToken" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#vault = decoded[2];
+      this.#asset = decoded[3];
+      this.#stakedPhantomToken = decoded[4];
+    }
+  }
+  get vault() {
+    if (!this.#vault) throw new MissingSerializedParamsError("vault");
+    return this.#vault;
+  }
+  get asset() {
+    if (!this.#asset) throw new MissingSerializedParamsError("asset");
+    return this.#asset;
+  }
+  get stakedPhantomToken() {
+    if (!this.#stakedPhantomToken)
+      throw new MissingSerializedParamsError("stakedPhantomToken");
+    return this.#stakedPhantomToken;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      vault: this.#vault ? this.labelAddress(this.#vault) : void 0,
+      asset: this.#asset ? this.labelAddress(this.#asset) : void 0,
+      stakedPhantomToken: this.#stakedPhantomToken ? this.labelAddress(this.#stakedPhantomToken) : void 0
+    };
   }
 }
 export {

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

@@ -1,34 +1,55 @@
 import { iVelodromeV2RouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import { MissingSerializedParamsError } from "../../../sdk/index.js";
+import { iVelodromeV2RouterAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iVelodromeV2RouterAdapterAbi;
+const protocolAbi = iVelodromeV2RouterAbi;
 class VelodromeV2RouterAdapterContract extends AbstractAdapterContract {
-  supportedPools;
+  #supportedPools;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        {
-          type: "tuple[]",
-          name: "supportedPools",
-          components: [
-            { type: "address", name: "token0" },
-            { type: "address", name: "token1" },
-            { type: "bool", name: "stable" },
-            { type: "address", name: "factory" }
-          ]
-        }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.supportedPools = decoded[2].map((pool) => ({
-      token0: pool.token0,
-      token1: pool.token1,
-      stable: pool.stable,
-      factory: pool.factory
-    }));
+    super(options, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = decodeAbiParameters(
+        [
+          { type: "address", name: "creditManager" },
+          { type: "address", name: "targetContract" },
+          {
+            type: "tuple[]",
+            name: "supportedPools",
+            components: [
+              { type: "address", name: "token0" },
+              { type: "address", name: "token1" },
+              { type: "bool", name: "stable" },
+              { type: "address", name: "factory" }
+            ]
+          }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#supportedPools = decoded[2].map((pool) => ({
+        token0: pool.token0,
+        token1: pool.token1,
+        stable: pool.stable,
+        factory: pool.factory
+      }));
+    }
+  }
+  get supportedPools() {
+    if (!this.#supportedPools)
+      throw new MissingSerializedParamsError("supportedPools");
+    return this.#supportedPools;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      supportedPools: this.#supportedPools?.map((p) => ({
+        token0: this.labelAddress(p.token0),
+        token1: this.labelAddress(p.token1),
+        stable: p.stable,
+        factory: this.labelAddress(p.factory)
+      }))
+    };
   }
 }
 export {

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

@@ -1,20 +1,48 @@
 import { iwstEthv1AdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iwstETHAbi } from "../abi/targetContractAbi.js";
+import { swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iwstEthv1AdapterAbi;
+const protocolAbi = iwstETHAbi;
 class WstETHV1AdapterContract extends AbstractAdapterContract {
-  stETH;
+  #stETH;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "stETH" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.stETH = decoded[2];
+    super(options, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = decodeAbiParameters(
+        [
+          { type: "address", name: "creditManager" },
+          { type: "address", name: "targetContract" },
+          { type: "address", name: "stETH" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#stETH = decoded[2];
+    }
+  }
+  get stETH() {
+    if (!this.#stETH) throw new MissingSerializedParamsError("stETH");
+    return this.#stETH;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      stETH: this.#stETH ? this.labelAddress(this.#stETH) : void 0
+    };
+  }
+  /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L264-L275 */
+  classifyLegacyOperation(parsed, transfers) {
+    if (parsed.functionName.startsWith("wrap")) {
+      return { operation: "WstETHWrap", ...swapFromTransfers(transfers) };
+    }
+    if (parsed.functionName.startsWith("unwrap")) {
+      return { operation: "WstETHUnwrap", ...swapFromTransfers(transfers) };
+    }
+    return super.classifyLegacyOperation(parsed, transfers);
   }
 }
 export {

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

@@ -1,5 +1,5 @@
 export * from "./AbstractAdapter.js";
-export * from "./BalancerV2VaultAdapterContract.js";
+export * from "./AccountMigratorAdapterContract.js";
 export * from "./BalancerV3RouterAdapterContract.js";
 export * from "./BalancerV3WrapperAdapterContract.js";
 export * from "./CamelotV3AdapterContract.js";
@@ -12,34 +12,30 @@ export * from "./CurveV1AdapterDeposit.js";
 export * from "./CurveV1AdapterStETHContract.js";
 export * from "./CurveV1StableNGAdapterContract.js";
 export * from "./DaiUsdsAdapterContract.js";
-export * from "./EqualizerRouterAdapterContract.js";
 export * from "./ERC4626AdapterContract.js";
 export * from "./ERC4626ReferralAdapterContract.js";
 export * from "./FluidDexAdapterContract.js";
 export * from "./InfinifiGatewayAdapterContract.js";
+export * from "./InfinifiGatewayAdapterContract.js";
+export * from "./InfinifiUnwindingGatewayAdapterContract.js";
 export * from "./InfinifiUnwindingGatewayAdapterContract.js";
-export * from "./InfraredVaultAdapterContract.js";
 export * from "./KelpLRTDepositPoolAdapterContract.js";
 export * from "./KelpLRTWithdrawalManagerAdapterContract.js";
-export * from "./KodiakIslandGatewayAdapterContract.js";
 export * from "./LidoV1AdapterContract.js";
 export * from "./MellowClaimerAdapterContract.js";
 export * from "./MellowDepositQueueAdapterContract.js";
 export * from "./MellowDVVAdapterContract.js";
 export * from "./MellowERC4626VaultAdapterContract.js";
 export * from "./MellowRedeemQueueAdapterContract.js";
-export * from "./MellowVaultAdapterContract.js";
 export * from "./MellowWrapperAdapterContract.js";
 export * from "./MidasIssuanceVaultAdapterContract.js";
 export * from "./MidasRedemptionVaultAdapterContract.js";
 export * from "./PendleRouterAdapterContract.js";
 export * from "./StakingRewardsAdapterContract.js";
 export * from "./TraderJoeRouterAdapterContract.js";
-export * from "./types.js";
 export * from "./UniswapV2AdapterContract.js";
 export * from "./UniswapV3AdapterContract.js";
 export * from "./UniswapV4AdapterContract.js";
 export * from "./UpshiftVaultAdapterContract.js";
 export * from "./VelodromeV2AdapterContract.js";
 export * from "./WstETHV1AdapterContract.js";
-export * from "./YearnV2AdapterContract.js";

package/dist/esm/plugins/adapters/createAdapter.js

@@ -0,0 +1,140 @@
+import { isHex } from "viem";
+import { bytes32ToString } from "../../sdk/index.js";
+import {
+  AbstractAdapterContract,
+  AccountMigratorAdapterContract,
+  BalancerV3RouterAdapterContract,
+  BalancerV3WrapperAdapterContract,
+  CamelotV3AdapterContract,
+  ConvexV1BaseRewardPoolAdapterContract,
+  ConvexV1BoosterAdapterContract,
+  Curve2AssetsAdapterContract,
+  Curve3AssetsAdapterContract,
+  Curve4AssetsAdapterContract,
+  CurveV1AdapterDeposit,
+  CurveV1AdapterStETHContract,
+  CurveV1StableNGAdapterContract,
+  DaiUsdsAdapterContract,
+  ERC4626AdapterContract,
+  ERC4626ReferralAdapterContract,
+  FluidDexAdapterContract,
+  InfinifiGatewayAdapterContract,
+  InfinifiUnwindingGatewayAdapterContract,
+  KelpLRTDepositPoolAdapterContract,
+  KelpLRTWithdrawalManagerAdapterContract,
+  LidoV1AdapterContract,
+  MellowClaimerAdapterContract,
+  MellowDepositQueueAdapterContract,
+  MellowDVVAdapterContract,
+  MellowERC4626VaultAdapterContract,
+  MellowRedeemQueueAdapterContract,
+  MellowWrapperAdapterContract,
+  MidasIssuanceVaultAdapterContract,
+  MidasRedemptionVaultAdapterContract,
+  PendleRouterAdapterContract,
+  StakingRewardsAdapterContract,
+  TraderJoeRouterAdapterContract,
+  UniswapV2AdapterContract,
+  UniswapV3AdapterContract,
+  UpshiftVaultAdapterContract,
+  VelodromeV2RouterAdapterContract,
+  WstETHV1AdapterContract
+} from "./contracts/index.js";
+import { UniswapV4AdapterContract } from "./contracts/UniswapV4AdapterContract.js";
+function createAdapter(options, data, strict) {
+  const contractType = data.baseParams.contractType;
+  const adapterType = isHex(contractType) ? bytes32ToString(contractType) : contractType;
+  switch (adapterType) {
+    case "ADAPTER::ACCOUNT_MIGRATOR":
+      return new AccountMigratorAdapterContract(options, data);
+    case "ADAPTER::BALANCER_V3_ROUTER":
+      return new BalancerV3RouterAdapterContract(options, data);
+    case "ADAPTER::BALANCER_V3_WRAPPER":
+      return new BalancerV3WrapperAdapterContract(options, data);
+    case "ADAPTER::CAMELOT_V3_ROUTER":
+      return new CamelotV3AdapterContract(options, data);
+    case "ADAPTER::CURVE_STABLE_NG":
+      return new CurveV1StableNGAdapterContract(options, data);
+    case "ADAPTER::CURVE_V1_2ASSETS":
+      return new Curve2AssetsAdapterContract(options, data);
+    case "ADAPTER::CURVE_V1_3ASSETS":
+      return new Curve3AssetsAdapterContract(options, data);
+    case "ADAPTER::CURVE_V1_4ASSETS":
+      return new Curve4AssetsAdapterContract(options, data);
+    case "ADAPTER::CURVE_V1_STECRV_POOL":
+      return new CurveV1AdapterStETHContract(options, data);
+    case "ADAPTER::CURVE_V1_WRAPPER":
+      return new CurveV1AdapterDeposit(options, data);
+    case "ADAPTER::CVX_V1_BASE_REWARD_POOL":
+      return new ConvexV1BaseRewardPoolAdapterContract(options, data);
+    case "ADAPTER::CVX_V1_BOOSTER":
+      return new ConvexV1BoosterAdapterContract(options, data);
+    case "ADAPTER::DAI_USDS_EXCHANGE":
+      return new DaiUsdsAdapterContract(options, data);
+    case "ADAPTER::ERC4626_VAULT":
+      return new ERC4626AdapterContract(options, data);
+    case "ADAPTER::ERC4626_VAULT_REFERRAL":
+      return new ERC4626ReferralAdapterContract(options, data);
+    case "ADAPTER::FLUID_DEX":
+      return new FluidDexAdapterContract(options, data);
+    case "ADAPTER::INFINIFI_GATEWAY":
+      return new InfinifiGatewayAdapterContract(options, data);
+    case "ADAPTER::INFINIFI_UNWINDING":
+      return new InfinifiUnwindingGatewayAdapterContract(options, data);
+    case "ADAPTER::KELP_DEPOSIT_POOL":
+      return new KelpLRTDepositPoolAdapterContract(options, data);
+    case "ADAPTER::KELP_WITHDRAWAL":
+      return new KelpLRTWithdrawalManagerAdapterContract(options, data);
+    case "ADAPTER::LIDO_V1":
+      return new LidoV1AdapterContract(options, data);
+    case "ADAPTER::LIDO_WSTETH_V1":
+      return new WstETHV1AdapterContract(options, data);
+    case "ADAPTER::MELLOW_CLAIMER":
+      return new MellowClaimerAdapterContract(options, data);
+    case "ADAPTER::MELLOW_DVV":
+      return new MellowDVVAdapterContract(options, data);
+    case "ADAPTER::MELLOW_ERC4626_VAULT":
+      return new MellowERC4626VaultAdapterContract(options, data);
+    case "ADAPTER::MELLOW_WRAPPER":
+      return new MellowWrapperAdapterContract(options, data);
+    case "ADAPTER::MELLOW_DEPOSIT_QUEUE_QUEUE":
+      return new MellowDepositQueueAdapterContract(options, data);
+    case "ADAPTER::MELLOW_REDEEM_QUEUE_QUEUE":
+      return new MellowRedeemQueueAdapterContract(options, data);
+    case "ADAPTER::MIDAS_ISSUANCE_VAULT":
+      return new MidasIssuanceVaultAdapterContract(options, data);
+    case "ADAPTER::MIDAS_REDEMPTION_VAULT":
+      return new MidasRedemptionVaultAdapterContract(options, data);
+    case "ADAPTER::PENDLE_ROUTER":
+      return new PendleRouterAdapterContract(options, data);
+    case "ADAPTER::STAKING_REWARDS":
+      return new StakingRewardsAdapterContract(options, data);
+    case "ADAPTER::TRADERJOE_ROUTER":
+      return new TraderJoeRouterAdapterContract(options, data);
+    case "ADAPTER::UNISWAP_V2_ROUTER":
+      return new UniswapV2AdapterContract(options, data);
+    case "ADAPTER::UNISWAP_V3_ROUTER":
+      return new UniswapV3AdapterContract(options, data);
+    case "ADAPTER::UNISWAP_V4_GATEWAY":
+      return new UniswapV4AdapterContract(options, data);
+    case "ADAPTER::UPSHIFT_VAULT":
+      return new UpshiftVaultAdapterContract(options, data);
+    case "ADAPTER::VELODROME_V2_ROUTER":
+      return new VelodromeV2RouterAdapterContract(options, data);
+    default: {
+      if (strict) {
+        throw new Error(
+          `Adapter type ${adapterType} not supported for adapter at ${data.baseParams.addr}`
+        );
+      }
+      return new AbstractAdapterContract(options, {
+        ...data,
+        abi: [],
+        protocolAbi: []
+      });
+    }
+  }
+}
+export {
+  createAdapter
+};

package/dist/esm/plugins/adapters/index.js

@@ -1,4 +1,7 @@
 export * from "./AdaptersPlugin.js";
 export * from "./abi/index.js";
 export * from "./contracts/index.js";
+export * from "./createAdapter.js";
+export * from "./legacyAdapterOperations.js";
+export * from "./transferHelpers.js";
 export * from "./types.js";

package/dist/esm/plugins/adapters/transferHelpers.js

@@ -0,0 +1,95 @@
+import { isAddressEqual, zeroAddress } from "viem";
+function toNetTransfers(transfers, creditAccount) {
+  const result = {};
+  for (const { token, amount, from, to } of transfers) {
+    if (isAddressEqual(from, creditAccount)) {
+      result[token] = (result[token] ?? 0n) - amount;
+    }
+    if (isAddressEqual(to, creditAccount)) {
+      result[token] = (result[token] ?? 0n) + amount;
+    }
+  }
+  return result;
+}
+function fnSigToName(signature) {
+  const i = signature.indexOf("(");
+  return i >= 0 ? signature.slice(0, i) : signature;
+}
+function parsePosNegAmount(transfers) {
+  const pos = [];
+  const neg = [];
+  for (const [token, amount] of Object.entries(transfers)) {
+    if (amount < 0n) {
+      neg.push({ token, amount: (-amount).toString() });
+    } else if (amount > 0n) {
+      pos.push({ token, amount: amount.toString() });
+    }
+  }
+  return { pos, neg };
+}
+function swapFromTransfers(transfers) {
+  const { pos, neg } = parsePosNegAmount(transfers);
+  return {
+    from: neg[0]?.token ?? zeroAddress,
+    fromAmount: neg[0]?.amount ?? "0",
+    to: pos[0]?.token ?? zeroAddress,
+    toAmount: pos[0]?.amount ?? "0"
+  };
+}
+function rewardsFromTransfers(transfers) {
+  return parsePosNegAmount(transfers).pos;
+}
+function allTransfersAsTokenAmounts(transfers) {
+  return Object.entries(transfers).map(([token, amount]) => ({
+    token,
+    amount: (amount < 0n ? -amount : amount).toString()
+  }));
+}
+function curveAddLiquidityFromTransfers(transfers) {
+  const { pos, neg } = parsePosNegAmount(transfers);
+  return {
+    operation: "CurveAddLiquidity",
+    addedLiquidity: neg,
+    lpToken: pos[0]?.token ?? zeroAddress,
+    lpAmount: pos[0]?.amount ?? "0"
+  };
+}
+function curveRemoveLiquidityFromTransfers(transfers) {
+  const { pos, neg } = parsePosNegAmount(transfers);
+  return {
+    operation: "CurveRemoveLiquidity",
+    tokenReceived: pos,
+    lpToken: neg[0]?.token ?? zeroAddress,
+    lpAmount: neg[0]?.amount ?? "0"
+  };
+}
+function classifyCurveOperation(functionName, transfers) {
+  const fn = fnSigToName(functionName);
+  if (fn.startsWith("exchange")) {
+    return { operation: "CurveExchange", ...swapFromTransfers(transfers) };
+  }
+  if (fn.includes("remove") && fn.includes("liquidity_one_coin")) {
+    return {
+      operation: "CurveRemoveLiquidityOneCoin",
+      ...swapFromTransfers(transfers)
+    };
+  }
+  if (fn === "add_liquidity" || fn === "add_liquidity_one_coin") {
+    return curveAddLiquidityFromTransfers(transfers);
+  }
+  if (fn.includes("remove") && fn.includes("liquidity")) {
+    return curveRemoveLiquidityFromTransfers(transfers);
+  }
+  return void 0;
+}
+export {
+  allTransfersAsTokenAmounts,
+  classifyCurveOperation,
+  curveAddLiquidityFromTransfers,
+  curveRemoveLiquidityFromTransfers,
+  fnSigToName,
+  parsePosNegAmount,
+  rewardsFromTransfers,
+  swapFromTransfers,
+  toNetTransfers
+};

package/dist/esm/plugins/bots/PartialLiquidationBotV310Contract.js

@@ -1,8 +1,5 @@
 import { decodeAbiParameters, stringToHex } from "viem";
-import {
-  BaseContract,
-  formatPercentage
-} from "../../sdk/index.js";
+import { BaseContract, percentFmt } from "../../sdk/index.js";
 import { iPartialLiquidationBotV310Abi } from "./abi/index.js";
 import { BOT_PARAMS_ABI } from "./types.js";
 const abi = iPartialLiquidationBotV310Abi;
@@ -32,10 +29,10 @@ class PartialLiquidationBotV310Contract extends BaseContract {
     return {
       ...super.stateHuman(raw),
       treasury: this.treasury,
-      minHealthFactor: formatPercentage(this.minHealthFactor),
-      maxHealthFactor: formatPercentage(this.maxHealthFactor),
-      premiumScaleFactor: formatPercentage(this.premiumScaleFactor),
-      feeScaleFactor: formatPercentage(this.feeScaleFactor)
+      minHealthFactor: percentFmt(this.minHealthFactor, raw),
+      maxHealthFactor: percentFmt(this.maxHealthFactor, raw),
+      premiumScaleFactor: percentFmt(this.premiumScaleFactor, raw),
+      feeScaleFactor: percentFmt(this.feeScaleFactor, raw)
     };
   }
   get state() {

package/dist/esm/plugins/bots/abi/index.js

@@ -1,2 +1 @@
-export * from "./iPartialLiquidationBotV300.js";
 export * from "./iPartialLiquidationBotV310.js";

package/dist/esm/plugins/degen-distributors/DegenDistributorsPlugin.js

@@ -20,7 +20,8 @@ class DegenDistributorsPlugin extends BasePlugin {
     const distributors = await MarketConfiguratorContract.getPeripheryContractBatch(
       Object.values(configurators),
       this.sdk.client,
-      "DEGEN_DISTRIBUTOR"
+      "DEGEN_DISTRIBUTOR",
+      this.sdk.currentBlock
     );
     const distributorByConfigurator = configurators.reduce((acc, cfg, index) => {
       const cfgLC = cfg.address.toLowerCase();

package/dist/esm/plugins/pools-history/Pools7DAgoPlugin.js

@@ -3,7 +3,6 @@ import {
   AddressMap,
   AP_MARKET_COMPRESSOR,
   BasePlugin,
-  BigIntMath,
   BLOCKS_PER_WEEK_BY_NETWORK,
   VERSION_RANGE_310
 } from "../../sdk/index.js";
@@ -33,7 +32,7 @@ class Pools7DAgoPlugin extends BasePlugin {
           args: [m.pool.pool.address]
         })
       ),
-      blockNumber: BigIntMath.max(0n, targetBlock),
+      blockNumber: targetBlock > 0n ? targetBlock : void 0,
       batchSize: 0
     });
     this.#pools7DAgo = new AddressMap(void 0, MAP_LABEL);