@gearbox-protocol/sdk 9.14.1 → 9.15.0

package/dist/esm/permissionless/chains/archive-transport.js

@@ -0,0 +1,250 @@
+import { http } from "viem";
+class ArchiveTransport {
+  config;
+  primaryTransport;
+  archiveTransport;
+  cachedTransport;
+  constructor(config) {
+    this.config = {
+      retryCount: 3,
+      retryDelay: 150,
+      timeout: 1e4,
+      enableLogging: false,
+      ...config
+    };
+    this.primaryTransport = http(this.config.primaryRpcUrl, {
+      retryCount: this.config.retryCount,
+      retryDelay: this.config.retryDelay,
+      timeout: this.config.timeout
+    });
+    this.archiveTransport = http(this.config.archiveRpcUrl, {
+      retryCount: this.config.retryCount,
+      retryDelay: this.config.retryDelay,
+      timeout: this.config.timeout
+    });
+  }
+  /**
+   * Get the configured transport instance
+   */
+  getTransport() {
+    if (this.cachedTransport) {
+      return this.cachedTransport;
+    }
+    const transport = ({
+      chain,
+      retryCount: transportRetryCount,
+      timeout: transportTimeout
+    }) => {
+      const primaryClient = this.primaryTransport({
+        chain,
+        retryCount: transportRetryCount,
+        timeout: transportTimeout
+      });
+      const archiveClient = this.archiveTransport({
+        chain,
+        retryCount: transportRetryCount,
+        timeout: transportTimeout
+      });
+      return {
+        config: {
+          key: "archive-class",
+          name: "Archive Transport Class",
+          request: primaryClient.config.request,
+          retryCount: transportRetryCount ?? this.config.retryCount,
+          retryDelay: this.config.retryDelay,
+          timeout: transportTimeout ?? this.config.timeout,
+          type: "archive"
+        },
+        request: async (args) => {
+          const { method, params } = args;
+          if (method !== "eth_getLogs") {
+            return await primaryClient.request({ method, params });
+          }
+          try {
+            return await this.handleGetLogsRequest(
+              method,
+              params,
+              primaryClient,
+              archiveClient
+            );
+          } catch (error) {
+            this.log(
+              "Archive transport error, falling back to primary RPC:",
+              error
+            );
+            return await primaryClient.request({ method, params });
+          }
+        },
+        value: primaryClient.value
+      };
+    };
+    this.cachedTransport = transport;
+    return this.cachedTransport;
+  }
+  /**
+   * Handle eth_getLogs requests with intelligent routing
+   */
+  async handleGetLogsRequest(method, params, primaryClient, archiveClient) {
+    const latestBlockHex = await primaryClient.request({
+      method: "eth_blockNumber",
+      params: []
+    });
+    const latestBlock = parseInt(latestBlockHex, 16);
+    const thresholdBlock = latestBlock - this.config.blockThreshold;
+    const logsParams = params;
+    const filter = logsParams[0] || {};
+    const { fromBlock, toBlock } = this.parseBlockNumbers(filter, latestBlock);
+    const allRecent = fromBlock >= thresholdBlock;
+    const allHistorical = toBlock < thresholdBlock;
+    const spansBoth = fromBlock < thresholdBlock && toBlock >= thresholdBlock;
+    if (allRecent) {
+      this.log(`Primary RPC: blocks [${fromBlock}-${toBlock}]`);
+      return await primaryClient.request({
+        method,
+        params
+      });
+    } else if (allHistorical) {
+      this.log(`Archive RPC: blocks [${fromBlock}-${toBlock}]`);
+      return await archiveClient.request({ method, params });
+    } else if (spansBoth) {
+      return await this.handleSplitRequest(
+        method,
+        filter,
+        fromBlock,
+        toBlock,
+        thresholdBlock,
+        primaryClient,
+        archiveClient
+      );
+    } else {
+      return await primaryClient.request({
+        method,
+        params
+      });
+    }
+  }
+  /**
+   * Handle split requests that span both historical and recent blocks
+   */
+  async handleSplitRequest(method, filter, fromBlock, toBlock, thresholdBlock, primaryClient, archiveClient) {
+    this.log(
+      `Splitting request: historical [${fromBlock}-${thresholdBlock - 1}] + recent [${thresholdBlock}-${toBlock}]`
+    );
+    const historicalFilter = {
+      ...filter,
+      fromBlock: `0x${fromBlock.toString(16)}`,
+      toBlock: `0x${(thresholdBlock - 1).toString(16)}`
+    };
+    const recentFilter = {
+      ...filter,
+      fromBlock: `0x${thresholdBlock.toString(16)}`,
+      toBlock: `0x${toBlock.toString(16)}`
+    };
+    try {
+      const [historicalResult, recentResult] = await Promise.all([
+        archiveClient.request({ method, params: [historicalFilter] }),
+        primaryClient.request({ method, params: [recentFilter] })
+      ]);
+      const historicalLogs = historicalResult;
+      const recentLogs = recentResult;
+      const mergedLogs = [...historicalLogs, ...recentLogs];
+      mergedLogs.sort((a, b) => {
+        const blockA = parseInt(a.blockNumber, 16);
+        const blockB = parseInt(b.blockNumber, 16);
+        if (blockA !== blockB) {
+          return blockA - blockB;
+        }
+        const logIndexA = parseInt(a.logIndex || "0x0", 16);
+        const logIndexB = parseInt(b.logIndex || "0x0", 16);
+        return logIndexA - logIndexB;
+      });
+      this.log(
+        `Merged ${historicalLogs.length} historical + ${recentLogs.length} recent = ${mergedLogs.length} total logs`
+      );
+      return mergedLogs;
+    } catch (error) {
+      this.log("Split request failed, falling back to archive RPC:", error);
+      return await archiveClient.request({
+        method,
+        params: [filter]
+      });
+    }
+  }
+  /**
+   * Parse block numbers from filter parameters
+   */
+  parseBlockNumbers(filter, latestBlock) {
+    let fromBlock;
+    let toBlock;
+    if (filter.fromBlock !== void 0) {
+      if (filter.fromBlock === "latest" || filter.fromBlock === "pending") {
+        fromBlock = latestBlock;
+      } else if (filter.fromBlock === "earliest") {
+        fromBlock = 0;
+      } else if (typeof filter.fromBlock === "string") {
+        fromBlock = parseInt(filter.fromBlock, 16);
+      } else {
+        fromBlock = filter.fromBlock;
+      }
+    }
+    if (filter.toBlock !== void 0) {
+      if (filter.toBlock === "latest" || filter.toBlock === "pending") {
+        toBlock = latestBlock;
+      } else if (filter.toBlock === "earliest") {
+        toBlock = 0;
+      } else if (typeof filter.toBlock === "string") {
+        toBlock = parseInt(filter.toBlock, 16);
+      } else {
+        toBlock = filter.toBlock;
+      }
+    }
+    return {
+      fromBlock: fromBlock ?? 0,
+      toBlock: toBlock ?? latestBlock
+    };
+  }
+  /**
+   * Log messages if logging is enabled
+   */
+  log(message, ...args) {
+    if (this.config.enableLogging) {
+      console.log(`[ArchiveTransport] ${message}`, ...args);
+    }
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration (will invalidate cached transport)
+   */
+  updateConfig(updates) {
+    this.config = { ...this.config, ...updates };
+    this.cachedTransport = void 0;
+    if (updates.primaryRpcUrl) {
+      this.primaryTransport = http(this.config.primaryRpcUrl, {
+        retryCount: this.config.retryCount,
+        retryDelay: this.config.retryDelay,
+        timeout: this.config.timeout
+      });
+    }
+    if (updates.archiveRpcUrl) {
+      this.archiveTransport = http(this.config.archiveRpcUrl, {
+        retryCount: this.config.retryCount,
+        retryDelay: this.config.retryDelay,
+        timeout: this.config.timeout
+      });
+    }
+  }
+  /**
+   * Enable or disable logging
+   */
+  setLogging(enabled) {
+    this.config.enableLogging = enabled;
+  }
+}
+export {
+  ArchiveTransport
+};

package/dist/esm/permissionless/core/index.js

@@ -0,0 +1,6 @@
+export * from "./auditor";
+export * from "./bytecode";
+export * from "./pricefeed";
+export * from "./pricefeed-builder";
+export * from "./proposal";
+export * from "./raw-tx";

package/dist/esm/permissionless/core/raw-tx.js

@@ -0,0 +1,14 @@
+import { createRawTx } from "../../sdk/utils/index.js";
+function createCallData(_abi, parameters) {
+  const tx = createRawTx(
+    "0x0000000000000000000000000000000000000000",
+    {
+      abi: _abi,
+      ...parameters
+    }
+  );
+  return tx.callData;
+}
+export {
+  createCallData
+};

package/dist/esm/permissionless/deployment/addresses.js

@@ -0,0 +1,11 @@
+var Addresses = /* @__PURE__ */ ((Addresses2) => {
+  Addresses2["ADDRESS_PROVIDER"] = "0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38";
+  Addresses2["ZERO_PRICE_FEED"] = "0x5dC92eC92cd5423EF95aEbe8Ac96619BCc9ffC88";
+  Addresses2["PRICE_FEED_STORE"] = "0x74A868AC479EE145029bB80827BB77F7B7c441cB";
+  Addresses2["IO_PROXY"] = "0xBcD875f0D62B9AA22481c81975F9AE1753Fc559A";
+  Addresses2["INSTANCE_MANAGER"] = "0x77777777144339Bdc3aCceE992D8d4D31734CB2e";
+  return Addresses2;
+})(Addresses || {});
+export {
+  Addresses
+};

package/dist/esm/permissionless/deployment/mainnet.js

@@ -0,0 +1,27 @@
+const MAINNET_CCM_CONSTRUCTOR_PARAMS = {
+  signers: [
+    "0xFd660518dC1b52d9F67FAcd42bbBA962B06b8E54",
+    "0x8cC8c75013D561Ad81D7d08591836Fc78585aE34",
+    "0xb9b7Db94D57fe25907620eAae42b9780176CceeA",
+    "0x66a3c94814dc3a37C9d61f1a977ea3730c621426",
+    "0x869ad60cDeF31Ae01959288Ff77D51bcB9F09E41",
+    "0xA0BaCE512E2904ccFDD24AB56feea6621ce14613",
+    "0x0Cec743b8CE4Ef8802cAc0e5df18a180ed8402A7",
+    "0x198c4D019BefE68415351E2C0F9b05585cfAAa5b",
+    "0x225C529a6a84AE9E45F97B6692E387791c3Ee8E8",
+    "0xb195a8CF4898E6DDc92e435cb118E9842456A45A",
+    "0xf33Ea4EE285B5DAC9a6163d8939699d59a7199BA",
+    "0xb647055A9915bF9c8021a684E175A353525b9890"
+  ],
+  threshold: 6,
+  dao: "0xA7D5DDc1b8557914F158076b228AA91eF613f1D5"
+};
+const MAINNET_DEPLOYMENT_CCM_SALT = "0x5e732654dc26892d02b6ae236f4a14577a726514abee949c570d011bcbcbcaac";
+const MAINNET_DEPLOYMENT_IM_SALT = "0x528da0da2d7789d36e2cbb0bd2bebf3f7d136e9c6c4e036fd56f7fd71ec5eb87";
+const MAINNET_DEPLOYMENT_BLOCK = 22358827;
+export {
+  MAINNET_CCM_CONSTRUCTOR_PARAMS,
+  MAINNET_DEPLOYMENT_BLOCK,
+  MAINNET_DEPLOYMENT_CCM_SALT,
+  MAINNET_DEPLOYMENT_IM_SALT
+};

package/dist/esm/permissionless/index.js

@@ -0,0 +1,6 @@
+export * from "./bindings";
+export * from "./chains/archive-transport";
+export * from "./core";
+export * from "./deployment/addresses";
+export * from "./deployment/mainnet";
+export * from "./utils";

package/dist/esm/permissionless/package.json

@@ -0,0 +1 @@
+{"type": "module","sideEffects":false}

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

@@ -0,0 +1,20 @@
+import {
+  getIrmDeployParamsAbi,
+  parseIrmDeployParams
+} from "./irm/constructor-params-abi";
+import {
+  getLossPolicyDeployParamsAbi,
+  parseLossPolicyDeployParams
+} from "./loss-policies/constructor-params-abi";
+import {
+  getRateKeeperDeployParamsAbi,
+  parseRateKeeperDeployParams
+} from "./rate-keepers/constructor-params-abi";
+export {
+  getIrmDeployParamsAbi,
+  getLossPolicyDeployParamsAbi,
+  getRateKeeperDeployParamsAbi,
+  parseIrmDeployParams,
+  parseLossPolicyDeployParams,
+  parseRateKeeperDeployParams
+};

package/dist/esm/permissionless/plugins/irm/constructor-params-abi.js

@@ -0,0 +1,52 @@
+import { decodeAbiParameters } from "viem";
+const LINEAR_IRM_ABI = [
+  { type: "uint256", name: "U_1" },
+  { type: "uint256", name: "U_2" },
+  { type: "uint256", name: "R_base" },
+  { type: "uint256", name: "R_slope1" },
+  { type: "uint256", name: "R_slope2" },
+  { type: "uint256", name: "R_slope3" },
+  { type: "bool", name: "isBorrowingMoreU2Forbidden" }
+];
+const irmDeployParamsAbiMapping = {
+  // Linear IRM - [U_1, U_2, R_base, R_slope1, R_slope2, R_slope3, isBorrowingMoreU2Forbidden]
+  LINEAR: {
+    "310": LINEAR_IRM_ABI
+  }
+};
+function getIrmDeployParamsAbi(irmType, version = 310) {
+  const versionedMapping = irmDeployParamsAbiMapping[irmType];
+  return versionedMapping?.[version.toString()] ?? null;
+}
+function parseIrmDeployParams(irmPostfix, version, data) {
+  const cleanIrmPostfix = irmPostfix.replace(/\0/g, "").trim();
+  if (!hasIrmDeployParamsAbi(cleanIrmPostfix)) return null;
+  const irmType = cleanIrmPostfix;
+  const abi = getIrmDeployParamsAbi(irmType, version);
+  if (!abi) return null;
+  try {
+    const decoded = decodeAbiParameters(abi, data);
+    const result = {};
+    abi.forEach((param, index) => {
+      result[param.name] = String(decoded[index]);
+    });
+    return result;
+  } catch (error) {
+    console.error(`Failed to parse IRM deploy params for ${irmType}:`, error);
+    return null;
+  }
+}
+function hasIrmDeployParamsAbi(irmType) {
+  return irmType in irmDeployParamsAbiMapping;
+}
+function getSupportedIrmTypes() {
+  return Object.keys(irmDeployParamsAbiMapping);
+}
+export {
+  LINEAR_IRM_ABI,
+  getIrmDeployParamsAbi,
+  getSupportedIrmTypes,
+  hasIrmDeployParamsAbi,
+  irmDeployParamsAbiMapping,
+  parseIrmDeployParams
+};

package/dist/esm/permissionless/plugins/loss-policies/constructor-params-abi.js

@@ -0,0 +1,50 @@
+import { decodeAbiParameters } from "viem";
+const ALIAS_LOSS_POLICY_ABI = [
+  { type: "address", name: "pool" },
+  { type: "address", name: "addressProvider" }
+];
+const lossPolicyDeployParamsAbiMapping = {
+  // Alias Loss Policy - [pool, addressProvider]
+  ALIASED: {
+    "310": ALIAS_LOSS_POLICY_ABI
+  }
+};
+function getLossPolicyDeployParamsAbi(lossPolicyType, version = 310) {
+  const versionedMapping = lossPolicyDeployParamsAbiMapping[lossPolicyType];
+  return versionedMapping?.[version.toString()] ?? null;
+}
+function parseLossPolicyDeployParams(lossPolicyPostfix, version, data) {
+  const cleanLossPolicyPostfix = lossPolicyPostfix.replace(/\0/g, "").trim();
+  if (!hasLossPolicyDeployParamsAbi(cleanLossPolicyPostfix)) return null;
+  const lossPolicyType = cleanLossPolicyPostfix;
+  const abi = getLossPolicyDeployParamsAbi(lossPolicyType, version);
+  if (!abi) return null;
+  try {
+    const decoded = decodeAbiParameters(abi, data);
+    const result = {};
+    abi.forEach((param, index) => {
+      result[param.name] = String(decoded[index]);
+    });
+    return result;
+  } catch (error) {
+    console.error(
+      `Failed to parse loss policy deploy params for ${lossPolicyType}:`,
+      error
+    );
+    return null;
+  }
+}
+function hasLossPolicyDeployParamsAbi(lossPolicyType) {
+  return lossPolicyType in lossPolicyDeployParamsAbiMapping;
+}
+function getSupportedLossPolicyTypes() {
+  return Object.keys(lossPolicyDeployParamsAbiMapping);
+}
+export {
+  ALIAS_LOSS_POLICY_ABI,
+  getLossPolicyDeployParamsAbi,
+  getSupportedLossPolicyTypes,
+  hasLossPolicyDeployParamsAbi,
+  lossPolicyDeployParamsAbiMapping,
+  parseLossPolicyDeployParams
+};

package/dist/esm/permissionless/plugins/rate-keepers/constructor-params-abi.js

@@ -0,0 +1,59 @@
+import { decodeAbiParameters } from "viem";
+const TUMBLER_RATE_KEEPER_ABI = [
+  { type: "address", name: "pool" },
+  { type: "uint256", name: "epochSeconds" }
+];
+const GAUGE_RATE_KEEPER_ABI = [
+  { type: "address", name: "pool" },
+  { type: "address", name: "gearStakingAddress" }
+];
+const rateKeeperDeployParamsAbiMapping = {
+  // Tumbler Rate Keeper - [pool, epochSeconds]
+  TUMBLER: {
+    "310": TUMBLER_RATE_KEEPER_ABI
+  },
+  // Gauge Rate Keeper - [pool, gearStakingAddress]
+  GAUGE: {
+    "310": GAUGE_RATE_KEEPER_ABI
+  }
+};
+function getRateKeeperDeployParamsAbi(rateKeeperType, version = 310) {
+  const versionedMapping = rateKeeperDeployParamsAbiMapping[rateKeeperType];
+  return versionedMapping?.[version.toString()] ?? null;
+}
+function parseRateKeeperDeployParams(rateKeeperPostfix, version, data) {
+  const cleanRateKeeperPostfix = rateKeeperPostfix.replace(/\0/g, "").trim();
+  if (!hasRateKeeperDeployParamsAbi(cleanRateKeeperPostfix)) return null;
+  const rateKeeperType = cleanRateKeeperPostfix;
+  const abi = getRateKeeperDeployParamsAbi(rateKeeperType, version);
+  if (!abi) return null;
+  try {
+    const decoded = decodeAbiParameters(abi, data);
+    const result = {};
+    abi.forEach((param, index) => {
+      result[param.name] = String(decoded[index]);
+    });
+    return result;
+  } catch (error) {
+    console.error(
+      `Failed to parse rate keeper deploy params for ${rateKeeperType}:`,
+      error
+    );
+    return null;
+  }
+}
+function hasRateKeeperDeployParamsAbi(rateKeeperType) {
+  return rateKeeperType in rateKeeperDeployParamsAbiMapping;
+}
+function getSupportedRateKeeperTypes() {
+  return Object.keys(rateKeeperDeployParamsAbiMapping);
+}
+export {
+  GAUGE_RATE_KEEPER_ABI,
+  TUMBLER_RATE_KEEPER_ABI,
+  getRateKeeperDeployParamsAbi,
+  getSupportedRateKeeperTypes,
+  hasRateKeeperDeployParamsAbi,
+  parseRateKeeperDeployParams,
+  rateKeeperDeployParamsAbiMapping
+};

package/dist/esm/permissionless/utils/abi-decoder.js

@@ -0,0 +1,50 @@
+import {
+  decodeFunctionData
+} from "viem";
+import { json_stringify } from "../../sdk/utils/index.js";
+function decodeFunctionWithNamedArgs(abi, calldata) {
+  try {
+    const decoded = decodeFunctionData({
+      abi,
+      data: calldata
+    });
+    const abiItem = abi.find(
+      (item) => item?.name === decoded.functionName && item?.type === "function"
+    );
+    if (!abiItem) {
+      return {
+        functionName: decoded.functionName,
+        args: {},
+        originalDecoded: decoded
+      };
+    }
+    const namedArgs = {};
+    if (Array.isArray(decoded.args)) {
+      decoded.args.forEach((value, i) => {
+        const input = abiItem.inputs?.[i];
+        if (input?.name) {
+          namedArgs[input.name] = input.type.startsWith("tuple") ? json_stringify(value) : String(value);
+        }
+      });
+    } else {
+      Object.entries(decoded.args || {}).forEach(([key, value]) => {
+        const index = parseInt(key);
+        if (!isNaN(index) && abiItem.inputs?.[index]?.name) {
+          namedArgs[abiItem.inputs[index].name] = String(value);
+        } else {
+          namedArgs[key] = String(value);
+        }
+      });
+    }
+    return {
+      functionName: decoded.functionName,
+      args: namedArgs,
+      originalDecoded: decoded
+    };
+  } catch {
+    return null;
+  }
+}
+export {
+  decodeFunctionWithNamedArgs
+};

package/dist/esm/permissionless/utils/abi-encoder.js

@@ -0,0 +1,65 @@
+import { encodeAbiParameters } from "viem";
+function encodeFunctionParams(params) {
+  const types = [];
+  const values = [];
+  for (const { type, value } of params) {
+    switch (type) {
+      case "address":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "bytes32":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "string":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "uint256":
+      case "int256":
+      case "uint32":
+        types.push({ type });
+        values.push(BigInt(value));
+        break;
+      case "uint8":
+        types.push({ type });
+        values.push(Number(value));
+        break;
+      case "bool":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "address[]":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "bytes32[]":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "string[]":
+        types.push({ type });
+        values.push(value);
+        break;
+      case "uint256[]":
+      case "int256[]":
+      case "uint32[]":
+        types.push({ type });
+        values.push(value.map((v) => BigInt(v)));
+        break;
+      case "uint8[]":
+        types.push({ type });
+        values.push(value.map((v) => Number(v)));
+        break;
+      case "bool[]":
+        types.push({ type });
+        values.push(value);
+        break;
+    }
+  }
+  return encodeAbiParameters(types, values);
+}
+export {
+  encodeFunctionParams
+};

package/dist/esm/permissionless/utils/block-utils.js

@@ -0,0 +1,31 @@
+async function getBlockNumberByTimestamp(client, targetTimestamp) {
+  const latestBlock = await client.getBlock({ blockTag: "latest" });
+  const latestBlockNumber = Number(latestBlock.number);
+  const latestTimestamp = Number(latestBlock.timestamp);
+  if (targetTimestamp >= latestTimestamp) {
+    return latestBlockNumber;
+  }
+  let left = 0;
+  let right = latestBlockNumber;
+  let closestBlock = latestBlockNumber;
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    const block = await client.getBlock({
+      blockNumber: BigInt(mid)
+    });
+    const blockTimestamp = Number(block.timestamp);
+    if (blockTimestamp === targetTimestamp) {
+      return mid;
+    }
+    if (blockTimestamp < targetTimestamp) {
+      left = mid + 1;
+    } else {
+      right = mid - 1;
+      closestBlock = mid;
+    }
+  }
+  return closestBlock;
+}
+export {
+  getBlockNumberByTimestamp
+};