@gearbox-protocol/sdk 9.14.1 → 9.15.1

package/dist/cjs/permissionless/bindings/price-feed-store.js

@@ -0,0 +1,395 @@
+"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 price_feed_store_exports = {};
+__export(price_feed_store_exports, {
+  PriceFeedStoreContract: () => PriceFeedStoreContract
+});
+module.exports = __toCommonJS(price_feed_store_exports);
+var import_viem = require("viem");
+var import_iPriceFeedStore = require("../../abi/310/iPriceFeedStore.js");
+var import_utils = require("../../sdk/utils/index.js");
+var import_utils2 = require("../utils/index.js");
+var import_base_contract = require("./base-contract.js");
+var import_pricefeeds = require("./pricefeeds/index.js");
+const abi = import_iPriceFeedStore.iPriceFeedStoreAbi;
+class PriceFeedStoreContract extends import_base_contract.BaseContract {
+  chainId;
+  constructor(address, client, chainId = 1) {
+    super(abi, address, client, "PriceFeedStore");
+    this.chainId = chainId;
+  }
+  async getZeroPriceFeed() {
+    const result = await this.contract.read.zeroPriceFeed();
+    return result;
+  }
+  async getAllowedPriceFeeds(fromBlock, toBlock) {
+    const events = await this.getEvents("AllowPriceFeed", fromBlock, toBlock);
+    return events.map((e) => ({
+      token: e.args.token,
+      priceFeed: e.args.priceFeed
+    }));
+  }
+  async getTokenPriceFeedsMap() {
+    const tokenPriceFeedsMap = await this.contract.read.getTokenPriceFeedsMap();
+    return tokenPriceFeedsMap;
+  }
+  async getAddPriceFeedEvents(fromBlock, toBlock) {
+    const events = await this.getEvents("AddPriceFeed", fromBlock, toBlock);
+    const result = [];
+    for (const e of events) {
+      result.push({
+        priceFeed: e.args.priceFeed,
+        stalenessPeriod: Number(e.args.stalenessPeriod)
+      });
+    }
+    return result;
+  }
+  async getNewPriceFeeds(fromBlock, toBlock) {
+    const events = await this.getAddPriceFeedEvents(fromBlock, toBlock);
+    const priceFeedInfo = await Promise.all(
+      events.map((event) => this.contract.read.priceFeedInfo([event.priceFeed]))
+    );
+    return priceFeedInfo.map((info, index) => ({
+      address: events[index].priceFeed,
+      contractType: (0, import_viem.hexToString)(info.priceFeedType, { size: 32 }),
+      version: Number(info.version),
+      deployedBy: this.address,
+      stalenessPeriod: info.stalenessPeriod,
+      name: info.name,
+      isInStore: true,
+      parameters: {}
+    }));
+  }
+  async getStalenessPeriodUpdates(fromBlock, toBlock) {
+    const events = await this.getEvents(
+      "SetStalenessPeriod",
+      fromBlock,
+      toBlock
+    );
+    return events.map((e) => ({
+      priceFeed: e.args.priceFeed,
+      stalenessPeriod: Number(e.args.stalenessPeriod)
+    }));
+  }
+  async getOwner() {
+    const result = await this.contract.read.owner();
+    return result;
+  }
+  async getPriceFeeds(token) {
+    const result = await this.contract.read.getPriceFeeds([token]);
+    return result;
+  }
+  async getStalenessPeriod(priceFeed) {
+    const result = await this.contract.read.getStalenessPeriod([priceFeed]);
+    return result;
+  }
+  async isAllowedPriceFeed(token, priceFeed) {
+    const result = await this.contract.read.isAllowedPriceFeed([
+      token,
+      priceFeed
+    ]);
+    return result;
+  }
+  computeEIP712ExternalPriceFeedDigest(priceFeed, name, stalenessPeriod, chainId) {
+    return {
+      domain: this.getEIP712Domain(chainId),
+      types: {
+        ExternalPriceFeed: [
+          { name: "priceFeed", type: "address" },
+          { name: "name", type: "string" },
+          { name: "stalenessPeriod", type: "uint256" }
+        ]
+      },
+      primaryType: "ExternalPriceFeed",
+      message: {
+        priceFeed: priceFeed.toLowerCase(),
+        name,
+        stalenessPeriod: BigInt(stalenessPeriod)
+      }
+    };
+  }
+  getEIP712Domain(chainId) {
+    return {
+      name: import_utils2.PRICE_FEED_STORE,
+      version: "310",
+      chainId: chainId ?? this.chainId,
+      verifyingContract: this.address
+    };
+  }
+  async recoverExternalPriceFeedSigner(priceFeed, name, stalenessPeriod, signature, chainId) {
+    const digest = this.computeEIP712ExternalPriceFeedDigest(
+      priceFeed,
+      name,
+      stalenessPeriod,
+      chainId
+    );
+    return await (0, import_viem.recoverTypedDataAddress)({
+      ...digest,
+      signature
+    });
+  }
+  async getKnownTokens() {
+    const result = await this.contract.read.getKnownTokens();
+    return result;
+  }
+  async getKnownPriceFeeds() {
+    const result = await this.contract.read.getKnownPriceFeeds();
+    return result;
+  }
+  async isKnownPriceFeed(priceFeed) {
+    const result = await this.contract.read.isKnownPriceFeed([priceFeed]);
+    return result;
+  }
+  async encodeConstructorParams(contractType, version, data) {
+    const types = [];
+    const values = [];
+    let flattenedAddresses = [];
+    let flattenedPeriods = [];
+    const params = import_pricefeeds.priceFeedSetupParams.find(
+      (p) => p.contractType === contractType && p.version === version
+    )?.constructorParams;
+    if (!params) {
+      throw new Error("Params not found");
+    }
+    for (let i = 0; i < params.length; i++) {
+      const param = params[i];
+      if (param.type.type === "pricefeedParamsFlattened") {
+        const p = data[param.label];
+        flattenedAddresses.push(p.address);
+        flattenedPeriods.push(BigInt(p.stalenessPeriod));
+        if (i + 1 < params.length && params[i + 1].type.type === "pricefeedParamsFlattened") {
+          continue;
+        }
+        if (flattenedAddresses.length > 0) {
+          for (const addr of flattenedAddresses) {
+            types.push({ type: "address" });
+            values.push(addr);
+          }
+          for (const period of flattenedPeriods) {
+            types.push({ type: "uint32" });
+            values.push(period);
+          }
+          flattenedAddresses = [];
+          flattenedPeriods = [];
+        }
+        continue;
+      }
+      switch (param.type.type) {
+        case "address":
+        case "bytes32":
+        case "string":
+          types.push({ type: param.type.type });
+          values.push(data[param.label]);
+          break;
+        case "uint256":
+        case "int256":
+        case "uint32":
+          types.push({ type: param.type.type });
+          values.push(BigInt(data[param.label]));
+          break;
+        case "uint8":
+          types.push({ type: param.type.type });
+          values.push(Number(data[param.label]));
+          break;
+        case "bool":
+          types.push({ type: param.type.type });
+          values.push(data[param.label]);
+          break;
+        case "owner":
+          types.push({ type: "address" });
+          values.push(this.address);
+          break;
+        case "pricefeedParamsFixed":
+        case "pricefeedParamsVariable": {
+          const structType = param.type.type === "pricefeedParamsFixed" ? `tuple[${param.type.qty}]` : `tuple[]`;
+          const structData = Array.from(
+            {
+              length: param.type.qty
+            },
+            (_, i2) => {
+              const key = `${param.label}-${i2}`;
+              const priceFeedParams = data[key];
+              if (!priceFeedParams) {
+                if (param.type.type === "pricefeedParamsFixed") {
+                  throw new Error(`${key} not found`);
+                } else {
+                  return void 0;
+                }
+              }
+              return [
+                priceFeedParams.address,
+                BigInt(priceFeedParams.stalenessPeriod)
+              ];
+            }
+          ).filter((d) => !!d);
+          types.push({
+            type: structType,
+            components: [{ type: "address" }, { type: "uint256" }]
+          });
+          values.push(structData);
+          break;
+        }
+        case "addressArrayFixed": {
+          const arrayData = Array.from(
+            {
+              length: param.type.qty
+            },
+            (_, i2) => {
+              const key = `${param.label}-${i2}`;
+              const address = data[key];
+              if (!address) {
+                throw new Error(`${key} not found`);
+              }
+              return address;
+            }
+          ).filter((d) => !!d);
+          types.push({
+            type: `address[${param.type.qty}]`
+          });
+          values.push(arrayData);
+          break;
+        }
+        case "lowerbound": {
+          const lowerbound = await param.type.getter(data, this.client);
+          types.push({ type: "uint256" });
+          values.push(lowerbound * 99n / 100n);
+          break;
+        }
+      }
+    }
+    return (0, import_viem.encodeAbiParameters)(types, values);
+  }
+  updatePricesTx(updates) {
+    return this.createRawTx({
+      functionName: "updatePrices",
+      args: [updates]
+    });
+  }
+  addPriceFeedTx(priceFeed, stalenessPeriod, name) {
+    return this.createRawTx({
+      functionName: "addPriceFeed",
+      args: [priceFeed, stalenessPeriod, name]
+    });
+  }
+  removePriceFeedTx(priceFeed) {
+    return this.createRawTx({
+      functionName: "removePriceFeed",
+      args: [priceFeed]
+    });
+  }
+  allowPriceFeedTx(token, priceFeed) {
+    return this.createRawTx({
+      functionName: "allowPriceFeed",
+      args: [token, priceFeed]
+    });
+  }
+  setStalenessPeriodTx(priceFeed, stalenessPeriod) {
+    return this.createRawTx({
+      functionName: "setStalenessPeriod",
+      args: [priceFeed, stalenessPeriod]
+    });
+  }
+  updatePrices(updates) {
+    return this.createRawTx({
+      functionName: "updatePrices",
+      args: [updates]
+    });
+  }
+  configurePriceFeeds(priceFeeds) {
+    return this.createRawTx({
+      functionName: "configurePriceFeeds",
+      args: [priceFeeds]
+    });
+  }
+  async getPriceFeedsInfo(priceFeeds) {
+    if (priceFeeds.length === 0) {
+      return [];
+    }
+    const multicallCalls = priceFeeds.map((priceFeed) => ({
+      address: this.address,
+      abi: this.abi,
+      functionName: "priceFeedInfo",
+      args: [priceFeed]
+    }));
+    const results = await this.client.multicall({
+      contracts: multicallCalls
+    });
+    return results.map((result, index) => {
+      if (result.status === "failure") {
+        throw new Error(
+          `Failed to get price feed info for ${priceFeeds[index]}: ${result.error}`
+        );
+      }
+      const info = result.result;
+      return {
+        address: priceFeeds[index],
+        contractType: (0, import_viem.hexToString)(info.priceFeedType, { size: 32 }),
+        version: Number(info.version),
+        deployedBy: this.address,
+        stalenessPeriod: Number(info.stalenessPeriod),
+        name: info.name,
+        isInStore: true,
+        parameters: {}
+      };
+    });
+  }
+  parseFunctionParams(params) {
+    switch (params.functionName) {
+      case "configurePriceFeeds": {
+        const [priceFeedCalls] = params.args;
+        const calls = [];
+        for (const priceFeedCall of priceFeedCalls) {
+          const selector = priceFeedCall.callData.slice(0, 10).toLowerCase();
+          if (selector === "0xbc489a65") {
+            calls.push({
+              target: priceFeedCall.target,
+              functionName: "setLimiter",
+              args: {
+                lowerBound: (0, import_viem.formatUnits)(
+                  BigInt(`0x${priceFeedCall.callData.slice(10)}`),
+                  18
+                  // TODO: use decimals returned by getScale()
+                )
+                // uint256 formatted with 18 decimals
+              }
+            });
+          } else {
+            calls.push({
+              target: priceFeedCall.target,
+              callData: priceFeedCall.callData
+            });
+          }
+        }
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName: params.functionName,
+          args: { calls: (0, import_utils.json_stringify)(calls) }
+        };
+      }
+      default:
+        return void 0;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PriceFeedStoreContract
+});

package/dist/cjs/permissionless/bindings/pricefeeds/balancer-stable.js

@@ -0,0 +1,63 @@
+"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 balancer_stable_exports = {};
+__export(balancer_stable_exports, {
+  balancerStablePriceFeed: () => balancerStablePriceFeed
+});
+module.exports = __toCommonJS(balancer_stable_exports);
+var import_viem = require("viem");
+const balancerStablePriceFeed = {
+  contractType: "PRICE_FEED::BALANCER_STABLE",
+  version: 310,
+  constructorParams: [
+    {
+      label: "priceStore",
+      type: { type: "owner" }
+    },
+    {
+      label: "lowerbound",
+      type: {
+        type: "lowerbound",
+        getter: async (values, publicClient) => {
+          const { balancerPool } = values;
+          return await publicClient.readContract({
+            abi: (0, import_viem.parseAbi)([
+              "function getRate() external view returns (uint256)"
+            ]),
+            address: balancerPool,
+            functionName: "getRate"
+          });
+        }
+      }
+    },
+    {
+      label: "balancerPool",
+      type: { type: "address" }
+    },
+    {
+      label: "underlyingPriceFeeds",
+      type: { type: "pricefeedParamsFixed", qty: 5, minNonZero: 2 }
+    }
+  ],
+  stalenessPeriod: false
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  balancerStablePriceFeed
+});

package/dist/cjs/permissionless/bindings/pricefeeds/balancer-weighted.js

@@ -0,0 +1,63 @@
+"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 balancer_weighted_exports = {};
+__export(balancer_weighted_exports, {
+  balancerWeightedPriceFeed: () => balancerWeightedPriceFeed
+});
+module.exports = __toCommonJS(balancer_weighted_exports);
+var import_viem = require("viem");
+const balancerWeightedPriceFeed = {
+  contractType: "PRICE_FEED::BALANCER_WEIGHTED",
+  version: 310,
+  constructorParams: [
+    {
+      label: "priceStore",
+      type: { type: "owner" }
+    },
+    {
+      label: "lowerbound",
+      type: {
+        type: "lowerbound",
+        getter: async (values, publicClient) => {
+          const { balancerPool } = values;
+          return await publicClient.readContract({
+            abi: (0, import_viem.parseAbi)([
+              "function getRate() external view returns (uint256)"
+            ]),
+            address: balancerPool,
+            functionName: "getRate"
+          });
+        }
+      }
+    },
+    {
+      label: "balancerPool",
+      type: { type: "address" }
+    },
+    {
+      label: "underlyingPriceFeeds",
+      type: { type: "pricefeedParamsVariable", qty: 8, minNonZero: 2 }
+    }
+  ],
+  stalenessPeriod: false
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  balancerWeightedPriceFeed
+});

package/dist/cjs/permissionless/bindings/pricefeeds/bounded.js

@@ -0,0 +1,47 @@
+"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 bounded_exports = {};
+__export(bounded_exports, {
+  boundedPriceFeed: () => boundedPriceFeed
+});
+module.exports = __toCommonJS(bounded_exports);
+const boundedPriceFeed = {
+  contractType: "PRICE_FEED::BOUNDED",
+  version: 310,
+  constructorParams: [
+    {
+      label: "underlyingPriceFeed",
+      type: { type: "pricefeedParamsFlattened" }
+    },
+    {
+      label: "upperBound ($)",
+      type: { type: "int256", decimals: 8 }
+    },
+    {
+      label: "descriptionTicker",
+      type: { type: "string", maxLen: 32 },
+      displayOrder: 1
+    }
+  ],
+  stalenessPeriod: false
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  boundedPriceFeed
+});

package/dist/cjs/permissionless/bindings/pricefeeds/composite.js

@@ -0,0 +1,43 @@
+"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 composite_exports = {};
+__export(composite_exports, {
+  compositePriceFeed: () => compositePriceFeed
+});
+module.exports = __toCommonJS(composite_exports);
+const compositePriceFeed = {
+  contractType: "PRICE_FEED::COMPOSITE",
+  version: 310,
+  constructorParams: [
+    {
+      label: "underlyingPriceFeed",
+      type: { type: "pricefeedParamsFixed", qty: 2 }
+    },
+    {
+      label: "descriptionTicker",
+      type: { type: "string", maxLen: 32 },
+      displayOrder: 1
+    }
+  ],
+  stalenessPeriod: false
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compositePriceFeed
+});

package/dist/cjs/permissionless/bindings/pricefeeds/constant.js

@@ -0,0 +1,42 @@
+"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 constant_exports = {};
+__export(constant_exports, {
+  constantPriceFeed: () => constantPriceFeed
+});
+module.exports = __toCommonJS(constant_exports);
+const constantPriceFeed = {
+  contractType: "PRICE_FEED::CONSTANT",
+  version: 310,
+  constructorParams: [
+    {
+      label: "price ($)",
+      type: { type: "int256", decimals: 8 }
+    },
+    {
+      label: "descriptionTicker",
+      type: { type: "string", maxLen: 32 }
+    }
+  ],
+  stalenessPeriod: false
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  constantPriceFeed
+});