@gearbox-protocol/sdk 9.14.0 → 9.15.0

package/dist/cjs/permissionless/utils/price-update/get-price-feeds.js

@@ -0,0 +1,91 @@
+"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 get_price_feeds_exports = {};
+__export(get_price_feeds_exports, {
+  getCallTouchedPriceFeeds: () => getCallTouchedPriceFeeds,
+  getCallsTouchedPriceFeeds: () => getCallsTouchedPriceFeeds,
+  getCallsTouchedUpdatablePriceFeeds: () => getCallsTouchedUpdatablePriceFeeds
+});
+module.exports = __toCommonJS(get_price_feeds_exports);
+var import_constants = require("../../../sdk/constants/index.js");
+var import_sdk = require("../../../sdk/index.js");
+var import_bindings = require("../../bindings");
+var import_addresses = require("../../deployment/addresses");
+var import_format = require("../format");
+var import_get_updatable_feeds = require("./get-updatable-feeds");
+function getCallTouchedPriceFeeds(parsedCall) {
+  const priceFeeds = [];
+  const deepParsedArgs = (0, import_format.deepJsonParse)(parsedCall.args);
+  function searchForPriceFeeds(obj) {
+    if (obj === null || obj === void 0) {
+      return;
+    }
+    if (Array.isArray(obj)) {
+      obj.forEach((item) => {
+        searchForPriceFeeds(item);
+      });
+      return;
+    }
+    if (typeof obj === "object") {
+      for (const [key, value] of Object.entries(obj)) {
+        if (key === "priceFeed" || key === "underlyingPriceFeed") {
+          priceFeeds.push(value);
+        }
+        searchForPriceFeeds(value);
+      }
+    }
+  }
+  searchForPriceFeeds(deepParsedArgs);
+  return priceFeeds;
+}
+function getCallsTouchedPriceFeeds(parsedCalls) {
+  return parsedCalls.flatMap((call) => getCallTouchedPriceFeeds(call));
+}
+async function getCallsTouchedUpdatablePriceFeeds({
+  parsedCalls,
+  client
+}) {
+  const addressProvider = new import_bindings.AddressProviderContract(
+    import_addresses.Addresses.ADDRESS_PROVIDER,
+    client
+  );
+  const pfCompressor = await addressProvider.getAddressOrRevert(
+    import_constants.AP_PRICE_FEED_COMPRESSOR,
+    310n
+  );
+  const sdk = await import_sdk.GearboxSDK.attach({
+    rpcURLs: [client.transport.url],
+    marketConfigurators: []
+  });
+  const touchedFeeds = parsedCalls.flatMap(
+    (call) => getCallTouchedPriceFeeds(call)
+  );
+  return (await (0, import_get_updatable_feeds.getUpdatablePriceFeeds)({
+    sdk,
+    client,
+    pfCompressor,
+    priceFeeds: touchedFeeds
+  })).map((feed) => feed.address);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCallTouchedPriceFeeds,
+  getCallsTouchedPriceFeeds,
+  getCallsTouchedUpdatablePriceFeeds
+});

package/dist/cjs/permissionless/utils/price-update/get-price-update-tx.js

@@ -0,0 +1,84 @@
+"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 get_price_update_tx_exports = {};
+__export(get_price_update_tx_exports, {
+  getPriceUpdateTx: () => getPriceUpdateTx,
+  getUpdateCalldata: () => getUpdateCalldata
+});
+module.exports = __toCommonJS(get_price_update_tx_exports);
+var import_viem = require("viem");
+var import_sdk = require("../../../sdk/index.js");
+var import_utils = require("../../../sdk/utils/index.js");
+var import_bindings = require("../../bindings");
+var import_addresses = require("../../deployment/addresses");
+function getUpdateCalldata(tx) {
+  const data = (0, import_viem.decodeFunctionData)({
+    abi: (0, import_viem.parseAbi)(["function updatePrice(bytes calldata data) external"]),
+    data: tx.raw.callData
+  });
+  return {
+    priceFeed: tx.raw.to,
+    data: data.args[0]
+  };
+}
+async function getPriceUpdateTx({
+  client,
+  priceFeeds,
+  useMulticall3 = false
+}) {
+  const pfStore = new import_bindings.PriceFeedStoreContract(
+    import_addresses.Addresses.PRICE_FEED_STORE,
+    client
+  );
+  const sdk = await import_sdk.GearboxSDK.attach({
+    rpcURLs: [client.transport.url],
+    marketConfigurators: []
+  });
+  const updateTxs = await sdk.priceFeeds.generateExternalPriceFeedsUpdateTxs(priceFeeds);
+  if (useMulticall3) {
+    const multicallCalls = updateTxs.txs.map((tx) => ({
+      target: tx.raw.to,
+      allowFailure: false,
+      callData: tx.raw.callData
+    }));
+    if (multicallCalls.length === 0) {
+      return void 0;
+    }
+    const multicall3Address = client.chain?.contracts?.multicall3?.address;
+    if (!multicall3Address) {
+      throw new Error("Multicall3 address not found");
+    }
+    const multicallTx = (0, import_utils.createRawTx)(multicall3Address, {
+      abi: import_viem.multicall3Abi,
+      functionName: "aggregate3",
+      args: [multicallCalls]
+    });
+    return multicallTx;
+  }
+  const priceUpdates = updateTxs.txs.map((tx) => getUpdateCalldata(tx));
+  if (priceUpdates.length === 0) {
+    return void 0;
+  }
+  return pfStore.updatePrices(priceUpdates);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPriceUpdateTx,
+  getUpdateCalldata
+});

package/dist/cjs/permissionless/utils/price-update/get-prices.js

@@ -0,0 +1,123 @@
+"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 get_prices_exports = {};
+__export(get_prices_exports, {
+  getPrices: () => getPrices
+});
+module.exports = __toCommonJS(get_prices_exports);
+var import_viem = require("viem");
+var import_sdk = require("../../../sdk/index.js");
+var import_viem2 = require("../../../sdk/utils/viem/index.js");
+const latestRoundDataAbi = [
+  {
+    inputs: [],
+    name: "latestRoundData",
+    outputs: [
+      { name: "roundId", type: "uint80" },
+      { name: "answer", type: "int256" },
+      { name: "startedAt", type: "uint256" },
+      { name: "updatedAt", type: "uint256" },
+      { name: "answeredInRound", type: "uint80" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+function getLatestRoundDataCall(priceFeed) {
+  return {
+    address: priceFeed,
+    abi: latestRoundDataAbi,
+    functionName: "latestRoundData",
+    args: []
+  };
+}
+async function getPricesChunk({
+  client,
+  priceFeeds,
+  sdk
+}) {
+  const updateCall = priceFeeds.map(
+    (priceFeed) => getLatestRoundDataCall(priceFeed)
+  );
+  const updateTxs = await sdk.priceFeeds.generateExternalPriceFeedsUpdateTxs(priceFeeds);
+  const multicallCalls = updateTxs.txs.map((tx) => ({
+    target: tx.raw.to,
+    allowFailure: true,
+    callData: tx.raw.callData
+  }));
+  const multicall3Address = client.chain?.contracts?.multicall3?.address;
+  if (!multicall3Address) {
+    throw new Error("Multicall3 address not found");
+  }
+  const multicallResult = await (0, import_viem2.simulateMulticall)(client, {
+    contracts: [
+      {
+        address: multicall3Address,
+        // @ts-expect-error
+        abi: import_viem.multicall3Abi,
+        // @ts-expect-error
+        functionName: "aggregate3",
+        args: [multicallCalls]
+      },
+      ...updateCall
+    ],
+    allowFailure: true
+  });
+  const prices = multicallResult.results.slice(1).map((result) => {
+    if (result.status === "failure") {
+      return null;
+    }
+    return result.result[1];
+  });
+  const priceEntries = priceFeeds.map(
+    (priceFeed, index) => [
+      priceFeed,
+      prices[index] ?? null
+    ]
+  );
+  return Object.fromEntries(priceEntries);
+}
+async function getPrices({
+  client,
+  priceFeeds,
+  chunkSize = 10
+}) {
+  const sdk = await import_sdk.GearboxSDK.attach({
+    rpcURLs: [client.transport.url],
+    marketConfigurators: [],
+    redstone: {
+      ignoreMissingFeeds: true
+    }
+  });
+  const chunks = [];
+  for (let i = 0; i < priceFeeds.length; i += chunkSize) {
+    chunks.push(priceFeeds.slice(i, i + chunkSize));
+  }
+  const results = await Promise.all(
+    chunks.map((chunk) => getPricesChunk({ client, priceFeeds: chunk, sdk }))
+  );
+  return results.reduce(
+    (acc, result) => ({ ...acc, ...result }),
+    {}
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPrices
+});

package/dist/cjs/permissionless/utils/price-update/get-updatable-feeds.js

@@ -0,0 +1,52 @@
+"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 get_updatable_feeds_exports = {};
+__export(get_updatable_feeds_exports, {
+  getUpdatablePriceFeeds: () => getUpdatablePriceFeeds
+});
+module.exports = __toCommonJS(get_updatable_feeds_exports);
+var import_viem = require("viem");
+var import_priceFeedCompressor = require("../../../abi/compressors/priceFeedCompressor.js");
+var import_sdk = require("../../../sdk/index.js");
+var import_utils = require("../../../sdk/utils/index.js");
+async function getUpdatablePriceFeeds(args) {
+  const { sdk, client, pfCompressor, priceFeeds } = args;
+  const priceFeedCompressor = (0, import_viem.getContract)({
+    address: pfCompressor,
+    abi: import_priceFeedCompressor.priceFeedCompressorAbi,
+    client
+  });
+  const updatablePriceFeeds = (await priceFeedCompressor.read.loadPriceFeedTree([
+    priceFeeds
+  ])).filter(
+    (data) => ["PRICE_FEED::PYTH", "PRICE_FEED::REDSTONE"].includes(
+      (0, import_utils.bytes32ToString)(data.baseParams.contractType)
+    )
+  ).map((data) => {
+    if ((0, import_utils.bytes32ToString)(data.baseParams.contractType) === "PRICE_FEED::PYTH") {
+      return new import_sdk.PythPriceFeed(sdk, data);
+    }
+    return new import_sdk.RedstonePriceFeedContract(sdk, data);
+  });
+  return updatablePriceFeeds;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getUpdatablePriceFeeds
+});

package/dist/cjs/permissionless/utils/price-update/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var price_update_exports = {};
+module.exports = __toCommonJS(price_update_exports);
+__reExport(price_update_exports, require("./get-price-feeds"), module.exports);
+__reExport(price_update_exports, require("./get-price-update-tx"), module.exports);
+__reExport(price_update_exports, require("./get-prices"), module.exports);
+__reExport(price_update_exports, require("./get-updatable-feeds"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./get-price-feeds"),
+  ...require("./get-price-update-tx"),
+  ...require("./get-prices"),
+  ...require("./get-updatable-feeds")
+});

package/dist/cjs/permissionless/utils/signature.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 signature_exports = {};
+__export(signature_exports, {
+  normalizeSignature: () => normalizeSignature
+});
+module.exports = __toCommonJS(signature_exports);
+function normalizeSignature(signature) {
+  const sig = signature.startsWith("0x") ? signature.slice(2) : signature;
+  let v = parseInt(sig.slice(128, 130), 16);
+  if (v === 0 || v === 1) {
+    v += 27;
+  }
+  return `0x${sig.slice(0, 128)}${v.toString(16)}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizeSignature
+});

package/dist/cjs/sdk/GearboxSDK.js

@@ -458,7 +458,11 @@ class GearboxSDK {
       this.#currentBlock = blockNumber;
       this.#timestamp = timestamp;
       await this.marketRegister.syncState(ignoreUpdateablePrices);
-      await this.#hooks.triggerHooks("syncState", { blockNumber, timestamp });
+      await this.#hooks.triggerHooks("syncState", {
+        blockNumber,
+        timestamp,
+        ignoreUpdateablePrices
+      });
       const pluginsList = import_utils.TypedObjectUtils.entries(this.plugins);
       const pluginResponse = await Promise.allSettled(
         pluginsList.map(([name, plugin]) => {

package/dist/esm/permissionless/bindings/address-provider.js

@@ -0,0 +1,27 @@
+import { stringToHex } from "viem";
+import { iAddressProviderV310Abi } from "../../abi/310/generated.js";
+import { BaseContract } from "./base-contract";
+const abi = iAddressProviderV310Abi;
+class AddressProviderContract extends BaseContract {
+  constructor(address, client) {
+    super(abi, address, client, "AddressProvider");
+  }
+  async getAddressOrRevert(key, version = 0n) {
+    return await this.contract.read.getAddressOrRevert([
+      stringToHex(key, { size: 32 }),
+      version
+    ]);
+  }
+  async getLatestVersionAddress(key) {
+    const version = await this.getLatestVersion(key);
+    return await this.getAddressOrRevert(key, version);
+  }
+  async getLatestVersion(key) {
+    return await this.contract.read.getLatestVersion([
+      stringToHex(key, { size: 32 })
+    ]);
+  }
+}
+export {
+  AddressProviderContract
+};

package/dist/esm/permissionless/bindings/base-contract.js

@@ -0,0 +1,151 @@
+import {
+  getContract
+} from "viem";
+import { createRawTx } from "../../sdk/utils/index.js";
+import { decodeFunctionWithNamedArgs } from "../utils/abi-decoder";
+class BaseContract {
+  abi;
+  address;
+  name;
+  static register = {};
+  contract;
+  client;
+  constructor(abi, address, client, name) {
+    this.abi = abi;
+    this.client = client;
+    this.address = address.toLowerCase();
+    this.name = name;
+    this.contract = getContract({
+      address,
+      abi,
+      client
+    });
+    BaseContract.register[this.address] = this;
+  }
+  static parseCall(call) {
+    const parsedCall = BaseContract.parse(call.target, call.callData);
+    return {
+      ...parsedCall,
+      chainId: call.chainId
+    };
+  }
+  static parse(address, calldata) {
+    const contract = BaseContract.register[address.toLowerCase()];
+    if (contract) {
+      return contract.parseFunctionData(calldata);
+    } else {
+      return {
+        chainId: 0,
+        target: address,
+        label: "Unknown contract",
+        functionName: `Unknown function: ${calldata}`,
+        args: {}
+      };
+    }
+  }
+  parseFunctionData(calldata) {
+    const decodedWithNames = decodeFunctionWithNamedArgs(this.abi, calldata);
+    if (!decodedWithNames) {
+      return {
+        chainId: 0,
+        target: this.address,
+        label: this.name,
+        functionName: `Unknown function: ${calldata}`,
+        args: {}
+      };
+    }
+    const specParsed = this.parseFunctionParams(
+      decodedWithNames.originalDecoded
+    );
+    if (specParsed) {
+      return specParsed;
+    }
+    return this.wrapParseCall(
+      decodedWithNames.originalDecoded,
+      decodedWithNames.args
+    );
+  }
+  wrapParseCall(params, parsedParams) {
+    return {
+      chainId: 0,
+      target: this.address,
+      label: this.name,
+      functionName: params.functionName,
+      args: parsedParams
+    };
+  }
+  parseFunctionParams(params) {
+    return void 0;
+  }
+  createRawTx(parameters) {
+    const { description: argsDescription } = parameters;
+    const tx = createRawTx(
+      this.address,
+      {
+        abi: this.abi,
+        ...parameters
+      },
+      argsDescription
+    );
+    tx.description = parameters.description || argsDescription || this.stringifyParsedCall(this.parseFunctionData(tx.callData));
+    return tx;
+  }
+  stringifyParsedCall(parsedCall) {
+    const argsStr = Object.entries(parsedCall.args).map(([key, value]) => `${key}: ${value}`).join(", ");
+    return `${parsedCall.label}.${parsedCall.functionName}(${argsStr})`;
+  }
+  async getEvents(eventName, fromBlock, toBlock, args, chunkSize) {
+    if (chunkSize) {
+      const chunkSizeBigint = BigInt(chunkSize);
+      const getEventPromises = [];
+      for (let i = fromBlock; i < toBlock; i += chunkSizeBigint) {
+        getEventPromises.push(
+          this.client.getContractEvents({
+            address: this.address,
+            fromBlock: i,
+            toBlock: i + chunkSizeBigint,
+            abi: this.abi,
+            eventName,
+            args
+          })
+        );
+      }
+      const events = (await Promise.all(getEventPromises)).flat();
+      return events;
+    }
+    try {
+      const events = await this.client.getContractEvents({
+        address: this.address,
+        fromBlock,
+        toBlock,
+        abi: this.abi,
+        eventName,
+        args
+      });
+      return events;
+    } catch (e) {
+      const blockRangeErrors = [
+        "query exceeds max block",
+        "range is too large",
+        "eth_getLogs is limited to",
+        "Unable to perform request",
+        "Block range limit exceeded"
+      ];
+      if (e instanceof Error && blockRangeErrors.some((errorText) => e.message.includes(errorText))) {
+        const middle = (fromBlock + toBlock) / 2n;
+        const [firstHalfEvents, secondHalfEvents] = await Promise.all([
+          this.getEvents(eventName, fromBlock, middle, args),
+          this.getEvents(eventName, middle + 1n, toBlock, args)
+        ]);
+        return [...firstHalfEvents, ...secondHalfEvents];
+      }
+      throw e;
+    }
+  }
+  getContract() {
+    return this.contract;
+  }
+}
+export {
+  BaseContract
+};