@gearbox-protocol/sdk 9.14.1 → 9.15.1

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

@@ -0,0 +1,376 @@
+import {
+  encodeAbiParameters,
+  formatUnits,
+  hexToString,
+  recoverTypedDataAddress
+} from "viem";
+import { iPriceFeedStoreAbi } from "../../abi/310/iPriceFeedStore.js";
+import { json_stringify } from "../../sdk/utils/index.js";
+import { PRICE_FEED_STORE } from "../utils/index.js";
+import { BaseContract } from "./base-contract.js";
+import { priceFeedSetupParams } from "./pricefeeds/index.js";
+const abi = iPriceFeedStoreAbi;
+class PriceFeedStoreContract extends 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: 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: 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 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 = 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 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: 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: 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: json_stringify(calls) }
+        };
+      }
+      default:
+        return void 0;
+    }
+  }
+}
+export {
+  PriceFeedStoreContract
+};

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

@@ -0,0 +1,39 @@
+import { parseAbi } from "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: 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
+};
+export {
+  balancerStablePriceFeed
+};

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

@@ -0,0 +1,39 @@
+import { parseAbi } from "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: 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
+};
+export {
+  balancerWeightedPriceFeed
+};

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

@@ -0,0 +1,23 @@
+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
+};
+export {
+  boundedPriceFeed
+};

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

@@ -0,0 +1,19 @@
+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
+};
+export {
+  compositePriceFeed
+};

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

@@ -0,0 +1,18 @@
+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
+};
+export {
+  constantPriceFeed
+};

package/dist/esm/permissionless/bindings/pricefeeds/curve-crypto.js

@@ -0,0 +1,43 @@
+import { parseAbi } from "viem";
+const curveCryptoPriceFeed = {
+  contractType: "PRICE_FEED::CURVE_CRYPTO",
+  version: 310,
+  constructorParams: [
+    {
+      label: "priceStore",
+      type: { type: "owner" }
+    },
+    {
+      label: "lowerbound",
+      type: {
+        type: "lowerbound",
+        getter: async (values, publicClient) => {
+          const { pool } = values;
+          return await publicClient.readContract({
+            abi: parseAbi([
+              "function get_virtual_price() external view returns (uint256)"
+            ]),
+            address: pool,
+            functionName: "get_virtual_price"
+          });
+        }
+      }
+    },
+    {
+      label: "token",
+      type: { type: "address" }
+    },
+    {
+      label: "pool",
+      type: { type: "address" }
+    },
+    {
+      label: "underlyingPriceFeeds",
+      type: { type: "pricefeedParamsFixed", qty: 3, minNonZero: 2 }
+    }
+  ],
+  stalenessPeriod: false
+};
+export {
+  curveCryptoPriceFeed
+};

package/dist/esm/permissionless/bindings/pricefeeds/curve-stable.js

@@ -0,0 +1,43 @@
+import { parseAbi } from "viem";
+const curveStablePriceFeed = {
+  contractType: "PRICE_FEED::CURVE_STABLE",
+  version: 310,
+  constructorParams: [
+    {
+      label: "priceStore",
+      type: { type: "owner" }
+    },
+    {
+      label: "lowerbound",
+      type: {
+        type: "lowerbound",
+        getter: async (values, publicClient) => {
+          const { pool } = values;
+          return await publicClient.readContract({
+            abi: parseAbi([
+              "function get_virtual_price() external view returns (uint256)"
+            ]),
+            address: pool,
+            functionName: "get_virtual_price"
+          });
+        }
+      }
+    },
+    {
+      label: "token",
+      type: { type: "address" }
+    },
+    {
+      label: "pool",
+      type: { type: "address" }
+    },
+    {
+      label: "underlyingPriceFeeds",
+      type: { type: "pricefeedParamsFixed", qty: 4, minNonZero: 2 }
+    }
+  ],
+  stalenessPeriod: false
+};
+export {
+  curveStablePriceFeed
+};

package/dist/esm/permissionless/bindings/pricefeeds/curve-twap.js

@@ -0,0 +1,46 @@
+const curveTwapPriceFeed = {
+  contractType: "PRICE_FEED::CURVE_TWAP",
+  version: 310,
+  constructorParams: [
+    {
+      label: "lowerBound ($)",
+      type: { type: "int256", decimals: 8 },
+      defaultValue: "0"
+    },
+    {
+      label: "upperBound ($)",
+      type: { type: "int256", decimals: 8 },
+      defaultValue: "1"
+    },
+    {
+      label: "oneOverZero",
+      type: { type: "bool" },
+      displayOrder: 5,
+      defaultValue: false
+    },
+    {
+      label: "token",
+      type: { type: "address" },
+      displayOrder: 1
+    },
+    {
+      label: "pool",
+      type: { type: "address" },
+      displayOrder: 2
+    },
+    {
+      label: "underlyingPriceFeed",
+      type: { type: "pricefeedParamsFlattened" },
+      displayOrder: 3
+    },
+    {
+      label: "descriptionTicker",
+      type: { type: "string", maxLen: 32 },
+      displayOrder: 4
+    }
+  ],
+  stalenessPeriod: false
+};
+export {
+  curveTwapPriceFeed
+};

package/dist/esm/permissionless/bindings/pricefeeds/curve-usd.js

@@ -0,0 +1,26 @@
+const curveUsdPriceFeed = {
+  contractType: "PRICE_FEED::CURVE_USD",
+  version: 310,
+  constructorParams: [
+    {
+      label: "priceStore",
+      type: { type: "owner" }
+    },
+    {
+      label: "crvUSD",
+      type: { type: "address" }
+    },
+    {
+      label: "pool",
+      type: { type: "address" }
+    },
+    {
+      label: "underlyingPriceFeed",
+      type: { type: "pricefeedParamsFlattened" }
+    }
+  ],
+  stalenessPeriod: false
+};
+export {
+  curveUsdPriceFeed
+};