@gearbox-protocol/sdk 13.2.0-next.1 → 13.2.0

package/dist/cjs/sdk/pools/AbstractPoolService.js

@@ -0,0 +1,137 @@
+"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 AbstractPoolService_exports = {};
+__export(AbstractPoolService_exports, {
+  AbstractPoolService: () => AbstractPoolService
+});
+module.exports = __toCommonJS(AbstractPoolService_exports);
+var import_generated = require("../../abi/310/generated.js");
+var import_iERC20ZapperDeposits = require("../../abi/iERC20ZapperDeposits.js");
+var import_iETHZapperDeposits = require("../../abi/iETHZapperDeposits.js");
+var import_iZapper = require("../../abi/iZapper.js");
+var import_base = require("../base/index.js");
+class AbstractPoolService extends import_base.SDKConstruct {
+  #version;
+  constructor(sdk, version) {
+    super(sdk);
+    this.#version = version;
+    this.logger?.debug(`Created PoolService with version: ${this.#version}`);
+  }
+  addLiquidity({
+    collateral,
+    pool,
+    account,
+    zapper,
+    permit,
+    nativeTokenAddress,
+    referralCode = 0n,
+    migrate
+  }) {
+    if (zapper?.tokenIn === nativeTokenAddress) {
+      return [
+        {
+          target: zapper.zapper,
+          abi: import_iETHZapperDeposits.iethZapperDepositsAbi,
+          functionName: "depositWithReferral",
+          args: [account, referralCode],
+          value: collateral.balance
+        }
+      ];
+    } else if (zapper) {
+      return permit ? [
+        {
+          target: zapper.zapper,
+          abi: import_iERC20ZapperDeposits.ierc20ZapperDepositsAbi,
+          functionName: "depositWithReferralAndPermit",
+          args: [
+            collateral.balance,
+            account,
+            referralCode,
+            permit.deadline,
+            permit.v,
+            permit.r,
+            permit.s
+          ]
+        }
+      ] : [
+        {
+          target: zapper.zapper,
+          abi: import_iERC20ZapperDeposits.ierc20ZapperDepositsAbi,
+          functionName: "depositWithReferral",
+          args: [collateral.balance, account, referralCode]
+        }
+      ];
+    } else {
+      if (migrate) throw Error("No zapper for migration");
+      return [
+        {
+          target: pool,
+          abi: import_generated.iPoolV310Abi,
+          functionName: "depositWithReferral",
+          args: [collateral.balance, account, referralCode]
+        }
+      ];
+    }
+  }
+  removeLiquidity({
+    pool,
+    amount,
+    account,
+    zapper,
+    permit
+  }) {
+    if (zapper) {
+      return permit ? [
+        {
+          target: zapper.zapper,
+          abi: import_iZapper.iZapperAbi,
+          functionName: "redeemWithPermit",
+          args: [
+            amount,
+            account,
+            permit.deadline,
+            permit.v,
+            permit.r,
+            permit.s
+          ]
+        }
+      ] : [
+        {
+          target: zapper.zapper,
+          abi: import_iZapper.iZapperAbi,
+          functionName: "redeem",
+          args: [amount, account]
+        }
+      ];
+    } else {
+      return [
+        {
+          target: pool,
+          abi: import_generated.iPoolV310Abi,
+          functionName: "redeem",
+          args: [amount, account, account]
+        }
+      ];
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbstractPoolService
+});

package/dist/cjs/{abi/iStateSerializer.js → sdk/pools/PoolServiceV310.js}

@@ -16,21 +16,15 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var iStateSerializer_exports = {};
-__export(iStateSerializer_exports, {
-  iStateSerializerAbi: () => iStateSerializerAbi
+var PoolServiceV310_exports = {};
+__export(PoolServiceV310_exports, {
+  PoolServiceV310: () => PoolServiceV310
 });
-module.exports = __toCommonJS(iStateSerializer_exports);
-const iStateSerializerAbi = [
-  {
-    type: "function",
-    inputs: [],
-    name: "serialize",
-    outputs: [{ name: "serializedData", internalType: "bytes", type: "bytes" }],
-    stateMutability: "view"
-  }
-];
+module.exports = __toCommonJS(PoolServiceV310_exports);
+var import_AbstractPoolService = require("./AbstractPoolService.js");
+class PoolServiceV310 extends import_AbstractPoolService.AbstractPoolService {
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  iStateSerializerAbi
+  PoolServiceV310
 });

package/dist/cjs/sdk/pools/createPoolService.js

@@ -0,0 +1,35 @@
+"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 createPoolService_exports = {};
+__export(createPoolService_exports, {
+  createPoolService: () => createPoolService
+});
+module.exports = __toCommonJS(createPoolService_exports);
+var import_constants = require("../constants/index.js");
+var import_PoolServiceV310 = require("./PoolServiceV310.js");
+function createPoolService(sdk, version) {
+  if ((0, import_constants.isV310)(version)) {
+    return new import_PoolServiceV310.PoolServiceV310(sdk, version);
+  }
+  throw new Error(`Unsupported Pool Service version ${version}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPoolService
+});

package/dist/cjs/sdk/pools/index.js

@@ -15,10 +15,12 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var pools_exports = {};
 module.exports = __toCommonJS(pools_exports);
-__reExport(pools_exports, require("./PoolService.js"), module.exports);
+__reExport(pools_exports, require("./AbstractPoolService.js"), module.exports);
+__reExport(pools_exports, require("./createPoolService.js"), module.exports);
 __reExport(pools_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./PoolService.js"),
+  ...require("./AbstractPoolService.js"),
+  ...require("./createPoolService.js"),
   ...require("./types.js")
 });

package/dist/cjs/sdk/utils/AddressMap.js

@@ -37,7 +37,7 @@ class AddressMap {
     this.#name = name;
   }
   /**
-   * Adds or overwrites value, undefined removes value
+   * Adds or updates value, undefined removes value
    * @param address
    * @param value
    */

package/dist/cjs/sdk/utils/viem/sendRawTx.js

@@ -18,7 +18,6 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var sendRawTx_exports = {};
 __export(sendRawTx_exports, {
-  estimateRawTxGas: () => estimateRawTxGas,
   sendRawTx: () => sendRawTx
 });
 module.exports = __toCommonJS(sendRawTx_exports);
@@ -37,22 +36,7 @@ async function sendRawTx(client, params) {
     value: BigInt(tx.value)
   });
 }
-async function estimateRawTxGas(client, params) {
-  const { tx, ...rest } = params;
-  return (0, import_utils.getAction)(
-    client,
-    import_actions.estimateGas,
-    "estimateGas"
-  )({
-    ...rest,
-    account: params.account,
-    data: tx.callData,
-    to: tx.to,
-    value: BigInt(tx.value)
-  });
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  estimateRawTxGas,
   sendRawTx
 });

package/dist/esm/dev/AccountOpener.js

@@ -6,7 +6,7 @@ import {
   parseEventLogs
 } from "viem";
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
-import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
+import { iCreditFacadeV310Abi, iPoolV310Abi } from "../abi/310/generated.js";
 import { ierc20Abi } from "../abi/iERC20.js";
 import {
   ADDRESS_0X0,
@@ -15,7 +15,6 @@ import {
   childLogger,
   MAX_UINT256,
   PERCENTAGE_FACTOR,
-  PoolService,
   SDKConstruct,
   sendRawTx
 } from "../sdk/index.js";
@@ -44,7 +43,6 @@ class AccountOpener extends SDKConstruct {
   #minDebtMultiplier;
   #allowMint;
   #leverageDelta;
-  #poolService;
   constructor(service, options_ = {}) {
     super(service.sdk);
     const {
@@ -70,7 +68,6 @@ class AccountOpener extends SDKConstruct {
     this.#poolDepositMultiplier = BigInt(poolDepositMultiplier);
     this.#minDebtMultiplier = BigInt(minDebtMultiplier);
     this.#leverageDelta = BigInt(leverageDelta);
-    this.#poolService = new PoolService(service.sdk);
     this.#logger?.info(
       {
         borrower: privateKeyToAccount(this.borrowerKey).address,
@@ -108,10 +105,6 @@ class AccountOpener extends SDKConstruct {
       },
       "opening credit accounts"
     );
-    await Promise.all([
-      this.sdk.tokensMeta.loadTokenData(),
-      this.sdk.marketRegister.loadZappers()
-    ]);
     let deposits = [];
     if (depositIntoPools) {
       try {
@@ -463,34 +456,9 @@ class AccountOpener extends SDKConstruct {
       this.#logger?.debug(
         `depositor balance in underlying: ${this.sdk.tokensMeta.formatBN(pool.underlying, allowance, { symbol: true })}`
       );
-      const tokensOut = this.#poolService.getDepositTokensOut(
-        address,
-        underlying
-      );
-      this.#logger?.debug(
-        { tokensOut: tokensOut.map((t) => this.labelAddress(t)) },
-        "deposit tokens out"
-      );
-      if (tokensOut.length === 0) {
-        throw new Error(`no tokens out found for pool ${poolName}`);
-      }
-      const tokenOut = tokensOut[0];
-      const metadata = this.#poolService.getDepositMetadata(
-        address,
-        underlying,
-        tokenOut
-      );
-      this.logger?.debug(
-        {
-          underlying: this.labelAddress(underlying),
-          tokenOut: this.labelAddress(tokenOut),
-          ...metadata
-        },
-        "pool deposit metadata"
-      );
       txHash = await this.#anvil.writeContract({
         account: depositor,
-        address: metadata.approveTarget,
+        address: underlying,
         abi: ierc20Abi,
         functionName: "approve",
         args: [address, allowance],
@@ -507,21 +475,12 @@ class AccountOpener extends SDKConstruct {
       this.#logger?.debug(
         `depositor approved underlying for pool ${poolName}: ${txHash}`
       );
-      const depositCall = this.#poolService.addLiquidity({
-        collateral: { token: underlying, balance: amount },
-        pool: address,
-        wallet: depositor.address,
-        meta: metadata
-      });
-      if (!depositCall) {
-        throw new Error(`no deposit call could be created for ${poolName}`);
-      }
       txHash = await this.#anvil.writeContract({
         account: depositor,
-        address: depositCall.target,
-        abi: depositCall.abi,
-        functionName: depositCall.functionName,
-        args: depositCall.args,
+        address,
+        abi: iPoolV310Abi,
+        functionName: "deposit",
+        args: [amount, depositor.address],
         chain: this.#anvil.chain
       });
       receipt = await this.#anvil.waitForTransactionReceipt({ hash: txHash });

package/dist/esm/dev/index.js

@@ -9,6 +9,11 @@ export * from "./EthCallSpy.js";
 export * from "./isOutOfSyncError.js";
 export * from "./isRateLimitError.js";
 export * from "./isTransientError.js";
+import {
+  isRangeError,
+  LogSplitterTransportOptions,
+  logSplitterTransport
+} from "./logSplitterTransport.js";
 export * from "./ltUtils.js";
 export * from "./migrateFaucet.js";
 export * from "./mint/index.js";
@@ -18,3 +23,8 @@ export * from "./replaceStorage.js";
 export * from "./resilientTransport.js";
 export * from "./transports.js";
 export * from "./types.js";
+export {
+  LogSplitterTransportOptions as GetLogsTransportOptions,
+  isRangeError,
+  logSplitterTransport
+};

package/dist/esm/dev/isTransientError.js

@@ -34,7 +34,11 @@ const TRANSIENT_PATTERNS = [
   // EIP-1474 ResourceUnavailableRpcError (code -32002): node is syncing or the
   // requested resource is temporarily unavailable.
   // Matches both the RPC message and viem's shortMessage "Requested resource not available."
-  /resource unavailable|requested resource not available/i
+  /resource unavailable|requested resource not available/i,
+  // sometimes happens on DRPC: "GRPC Context cancellation"
+  /context cancel/i,
+  // DRPC error: Can't route your request to suitable provider, if you specified certain providers revise the list
+  /suitable provider/i
 ];
 function isTransientError(e) {
   if (e instanceof BaseError) {

package/dist/esm/dev/logSplitterTransport.js

@@ -0,0 +1,131 @@
+import {
+  HttpRequestError,
+  hexToNumber,
+  InvalidParamsRpcError,
+  numberToHex
+} from "viem";
+function isFixedBlockRange(filter) {
+  if (filter.blockHash != null) return false;
+  return isHexBlockNumber(filter.fromBlock) && isHexBlockNumber(filter.toBlock);
+}
+function isHexBlockNumber(value) {
+  return typeof value === "string" && value.startsWith("0x");
+}
+const RANGE_ERROR_PATTERNS = [
+  /block range/i,
+  /too many results/i,
+  /response size/i,
+  /result window/i,
+  /exceeds allowed/i,
+  /cannot request logs over more than/i,
+  /eth_getLogs is limited to/i,
+  /eth_getLogs requests with up to/i,
+  /range is too large/i,
+  /exceeded max allowed range/i
+];
+function isRangeError(error) {
+  const msg = errorMessage(error);
+  return RANGE_ERROR_PATTERNS.some((re) => re.test(msg));
+}
+const GENERIC_BLOCKS_RE = /(\d+)\s*block/i;
+const ALCHEMY_RANGE_RE = /this block range should work: \[(0x[0-9a-fA-F]+),\s*(0x[0-9a-fA-F]+)\]/;
+function parsePageSizeHint(error) {
+  const alchemy = tryAlchemyHint(error);
+  if (alchemy != null) return alchemy;
+  const msg = errorMessage(error);
+  const m = msg.match(GENERIC_BLOCKS_RE);
+  return m ? Number(m[1]) : null;
+}
+function tryAlchemyHint(error) {
+  if (!(error instanceof HttpRequestError)) return void 0;
+  try {
+    const parsed = JSON.parse(error.details);
+    if (typeof parsed.message !== "string") return void 0;
+    const match = parsed.message.match(ALCHEMY_RANGE_RE);
+    if (!match) return void 0;
+    const from = hexToNumber(match[1]);
+    const to = hexToNumber(match[2]);
+    return to - from + 1;
+  } catch {
+    return void 0;
+  }
+}
+function errorMessage(error) {
+  if (error instanceof Error) {
+    const details = error.details;
+    return details ? `${error.message} ${details}` : error.message;
+  }
+  return String(error);
+}
+async function fetchLogsWithPagination(callRpc, from, to, options) {
+  if (from > to) {
+    throw new InvalidParamsRpcError(
+      new Error(`Invalid parameters: from (${from}) > to (${to})`)
+    );
+  }
+  const { softLimit, hardLimit } = options ?? {};
+  let pageSize = hardLimit ?? to - from + 1;
+  const results = [];
+  let cursor = from;
+  while (cursor <= to) {
+    const chunkEnd = Math.min(to, cursor + pageSize - 1);
+    try {
+      const logs = await callRpc(cursor, chunkEnd);
+      results.push(...logs);
+      cursor = chunkEnd + 1;
+    } catch (error) {
+      if (!isRangeError(error)) {
+        throw error;
+      }
+      if (cursor === chunkEnd) {
+        throw error;
+      }
+      const hint = parsePageSizeHint(error);
+      if (hint) {
+        pageSize = hint;
+      } else {
+        const half = Math.max(1, Math.floor((chunkEnd - cursor + 1) / 2));
+        pageSize = softLimit ? Math.min(softLimit, half) : half;
+      }
+    }
+  }
+  return results;
+}
+function logSplitterTransport(transport, logOptions) {
+  return (opts) => {
+    const base = transport(opts);
+    const rpcRequest = base.request;
+    const request = (async (args) => {
+      const { method, params } = args;
+      if (method !== "eth_getLogs") {
+        return rpcRequest(args);
+      }
+      const filter = params?.[0] ?? {};
+      if (!isFixedBlockRange(filter)) {
+        return rpcRequest(args);
+      }
+      const from = hexToNumber(filter.fromBlock);
+      const to = hexToNumber(filter.toBlock);
+      const callRpc = async (f, t) => {
+        const paginatedFilter = {
+          ...filter,
+          fromBlock: numberToHex(f),
+          toBlock: numberToHex(t)
+        };
+        return rpcRequest({
+          method: "eth_getLogs",
+          params: [paginatedFilter]
+        });
+      };
+      return fetchLogsWithPagination(callRpc, from, to, logOptions);
+    });
+    return { ...base, request };
+  };
+}
+export {
+  fetchLogsWithPagination,
+  isFixedBlockRange,
+  isRangeError,
+  logSplitterTransport,
+  parsePageSizeHint
+};

package/dist/esm/plugins/zappers/ZappersPlugin.js

@@ -0,0 +1,126 @@
+import { peripheryCompressorAbi } from "../../abi/compressors/peripheryCompressor.js";
+import {
+  AddressMap,
+  AP_PERIPHERY_COMPRESSOR,
+  BasePlugin,
+  hexEq,
+  VERSION_RANGE_310
+} from "../../sdk/index.js";
+class ZappersPlugin extends BasePlugin {
+  #zappers;
+  #extraZappers;
+  constructor(extraZappers = [], loadOnAttach = false) {
+    super(loadOnAttach);
+    this.#extraZappers = this.#addExtraZappers(extraZappers);
+  }
+  async load(force) {
+    if (!force && this.loaded) {
+      return this.state;
+    }
+    const [pcAddr] = this.sdk.addressProvider.mustGetLatest(
+      AP_PERIPHERY_COMPRESSOR,
+      VERSION_RANGE_310
+    );
+    this.sdk.logger?.debug(
+      `loading zappers with periphery compressor ${pcAddr}`
+    );
+    const markets = this.sdk.marketRegister.markets;
+    const resp = await this.client.multicall({
+      contracts: markets.map(
+        (m) => ({
+          abi: peripheryCompressorAbi,
+          address: pcAddr,
+          functionName: "getZappers",
+          args: [m.configurator.address, m.pool.pool.address]
+        })
+      ),
+      allowFailure: true,
+      batchSize: 0,
+      blockNumber: this.sdk.currentBlock
+    });
+    this.#zappers = new AddressMap(void 0, "zappers");
+    for (let i = 0; i < resp.length; i++) {
+      const { status, result, error } = resp[i];
+      const marketConfigurator = markets[i].configurator.address;
+      const pool = markets[i].pool.pool.address;
+      if (status === "success") {
+        this.#zappers.upsert(
+          pool,
+          result.map((z) => ({ ...z, pool }))
+        );
+      } else {
+        this.sdk.logger?.error(
+          `failed to load zapper for market configurator ${this.labelAddress(
+            marketConfigurator
+          )} and pool ${this.labelAddress(pool)}: ${error}`
+        );
+      }
+    }
+    this.#loadZapperTokens();
+    return this.state;
+  }
+  #addExtraZappers(extraZappers) {
+    const zappers = new AddressMap();
+    for (const z of extraZappers) {
+      const existing = zappers?.get(z.pool);
+      if (existing) {
+        const hasZapper = existing.some(
+          (zz) => hexEq(zz.baseParams.addr, z.baseParams.addr)
+        );
+        if (!hasZapper) {
+          existing.push(z);
+        }
+      } else {
+        zappers?.upsert(z.pool, [z]);
+      }
+    }
+    return zappers;
+  }
+  get extraZappers() {
+    if (!this.#extraZappers) {
+      console.error("extra zappers not attached");
+      return new AddressMap();
+    }
+    return this.#extraZappers;
+  }
+  get zappers() {
+    if (!this.#zappers) {
+      throw new Error("zappers plugin not attached");
+    }
+    return this.#zappers;
+  }
+  get loaded() {
+    return !!this.#zappers;
+  }
+  stateHuman(_) {
+    return this.zappers.values().flatMap(
+      (l) => l.flatMap((z) => ({
+        address: z.baseParams.addr,
+        contractType: z.baseParams.contractType,
+        version: Number(z.baseParams.version),
+        tokenIn: this.labelAddress(z.tokenIn.addr),
+        tokenOut: this.labelAddress(z.tokenOut.addr)
+      }))
+    );
+  }
+  get state() {
+    return {
+      zappers: this.zappers.asRecord()
+    };
+  }
+  hydrate(state) {
+    this.#zappers = new AddressMap(Object.entries(state.zappers), "zappers");
+    this.#loadZapperTokens();
+  }
+  #loadZapperTokens() {
+    const zappersTokens = this.zappers.values().flatMap((l) => l.flatMap((z) => [z.tokenIn, z.tokenOut]));
+    const extraZappersTokens = this.extraZappers.values().flatMap((l) => l.flatMap((z) => [z.tokenIn, z.tokenOut]));
+    for (const t of [...zappersTokens, ...extraZappersTokens]) {
+      this.sdk.tokensMeta.upsert(t.addr, t);
+      this.sdk.setAddressLabel(t.addr, t.symbol);
+    }
+  }
+}
+export {
+  ZappersPlugin
+};