@gearbox-protocol/sdk 9.14.1 → 9.15.0

package/dist/esm/permissionless/utils/create2.js

@@ -0,0 +1,85 @@
+import { formatAbiItem } from "abitype";
+import {
+  getCreate2Address,
+  stringToHex
+} from "viem";
+const PUBLIC_CREATE2_FACTORY = "0x4e59b44847b379578588920ca78fbf26c0b4956c";
+function handleSalt(salt) {
+  if (salt.slice(0, 2) !== "0x" || salt.length !== 66) {
+    salt = stringToHex(salt, { size: 32 });
+  }
+  return salt;
+}
+async function deployUsingPublicCreate2(sponsor, bytecode, salt) {
+  const callData = `${handleSalt(salt)}${bytecode.replace("0x", "")}`;
+  const hash = await sponsor.sendTransaction({
+    to: PUBLIC_CREATE2_FACTORY,
+    data: callData,
+    account: sponsor.account,
+    chain: sponsor.chain
+  });
+  return hash;
+}
+async function getCreate2AddressPublicFactory(salt, bytecode) {
+  return getCreate2Address({
+    from: PUBLIC_CREATE2_FACTORY,
+    salt: handleSalt(salt),
+    bytecode
+  });
+}
+function createCreate2DeployRawTx(bytecode, salt) {
+  const callData = `${handleSalt(salt)}${bytecode.replace("0x", "")}`;
+  const deterministicDeployerAbi = [
+    {
+      payable: true,
+      stateMutability: "payable",
+      type: "fallback"
+    }
+  ];
+  const signature = formatAbiItem(deterministicDeployerAbi[0]);
+  const contractMethod = {
+    name: "fallback",
+    inputs: [],
+    payable: true
+  };
+  const rawTx = {
+    to: PUBLIC_CREATE2_FACTORY,
+    value: "0",
+    signature,
+    callData,
+    contractMethod,
+    contractInputsValues: {},
+    description: ""
+  };
+  return rawTx;
+}
+function getCreate2DeploymentAddress(bytecode, salt) {
+  return getCreate2Address({
+    from: PUBLIC_CREATE2_FACTORY,
+    salt: handleSalt(salt),
+    bytecode
+  });
+}
+async function checkCreate2Deployment(client, bytecode, salt) {
+  const address = getCreate2DeploymentAddress(bytecode, salt);
+  const code = await client.getCode({ address });
+  return code !== void 0;
+}
+async function checkCreate2DeploymentAddress(client, bytecode, salt) {
+  const address = getCreate2DeploymentAddress(bytecode, salt);
+  const code = await client.getCode({ address });
+  if (code !== void 0) {
+    return [true, address];
+  }
+  return [false, address];
+}
+export {
+  PUBLIC_CREATE2_FACTORY,
+  checkCreate2Deployment,
+  checkCreate2DeploymentAddress,
+  createCreate2DeployRawTx,
+  deployUsingPublicCreate2,
+  getCreate2AddressPublicFactory,
+  getCreate2DeploymentAddress,
+  handleSalt
+};

package/dist/esm/permissionless/utils/format.js

@@ -0,0 +1,67 @@
+import { json_parse } from "../../sdk/utils/index.js";
+function formatBytecodeSize(size) {
+  return `${(size / 1024).toFixed(2)} KB`;
+}
+function formatBytecodeVersion(version) {
+  if (version === 0) return "-";
+  const major = Math.floor(version / 100);
+  const minor = Math.floor(version % 100 / 10);
+  const patch = version % 10;
+  return `v${major}.${minor}.${patch}`;
+}
+function formatTimestamp(timestamp) {
+  return new Date(timestamp * 1e3).toLocaleString("en-GB", {
+    dateStyle: "short",
+    timeStyle: "short"
+  });
+}
+function shortenHash(hash, chars = 4) {
+  if (!hash) return "";
+  const start = hash.slice(0, chars + 2);
+  const end = hash.slice(-chars);
+  return `${start}...${end}`;
+}
+function convertPercent(percent) {
+  return Math.floor(percent * 100);
+}
+function significantTrunc(x) {
+  if (x === 0) return "0";
+  if (x >= 1) return x.toFixed(0);
+  const str = x.toPrecision(2);
+  if (str.includes("e")) {
+    const value = Number(str);
+    return value.toFixed(20).replace(/\.?0+$/, "");
+  }
+  return str.replace(/\.?0+$/, "");
+}
+function deepJsonParse(value) {
+  if (typeof value === "string") {
+    try {
+      const parsed = json_parse(value);
+      if (parsed === value) return value;
+      return deepJsonParse(parsed);
+    } catch {
+      return value;
+    }
+  }
+  if (Array.isArray(value)) {
+    return value.map(deepJsonParse);
+  }
+  if (typeof value === "object" && value !== null) {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = deepJsonParse(v);
+    }
+    return result;
+  }
+  return value;
+}
+export {
+  convertPercent,
+  deepJsonParse,
+  formatBytecodeSize,
+  formatBytecodeVersion,
+  formatTimestamp,
+  shortenHash,
+  significantTrunc
+};

package/dist/esm/permissionless/utils/governance/batch.js

@@ -0,0 +1,87 @@
+import { keccak256, toBytes } from "viem";
+function convertRawTxToSafeMultisigTx(tx) {
+  const { to, value, contractMethod, contractInputsValues } = tx;
+  return {
+    to,
+    value: `${value}`,
+    data: tx.callData,
+    contractMethod,
+    contractInputsValues: Object.entries(contractInputsValues).reduce(
+      (acc, [key, value2]) => {
+        acc[key] = typeof value2 === "object" ? JSON.stringify(
+          value2,
+          (_, v) => typeof v === "bigint" ? v.toString() : v
+        ) : `${value2}`;
+        return acc;
+      },
+      {}
+    )
+  };
+}
+function stringifyReplacer(_, value) {
+  return value === void 0 ? null : `${value}`;
+}
+function serializeJSONObject(json) {
+  if (Array.isArray(json)) {
+    return `[${json.map((el) => serializeJSONObject(el)).join(",")}]`;
+  }
+  if (typeof json === "object" && json !== null) {
+    let acc = "";
+    const keys = Object.keys(json).sort();
+    acc += `{${JSON.stringify(keys, stringifyReplacer)}`;
+    for (const key of keys) {
+      acc += `${serializeJSONObject(json[key])},`;
+    }
+    return `${acc}}`;
+  }
+  return `${JSON.stringify(json, stringifyReplacer)}`;
+}
+function calculateChecksum(multisigBatch) {
+  const serialized = serializeJSONObject({
+    ...multisigBatch,
+    meta: { ...multisigBatch.meta, name: null }
+  });
+  return keccak256(toBytes(serialized));
+}
+function getSafeBatch(args) {
+  const { chainId, safeAddress, name, txs: transactions } = args;
+  const batchInfo = {
+    version: "1.0",
+    chainId: `${chainId}`,
+    createdAt: Date.now(),
+    safeAddress,
+    meta: {
+      name,
+      description: name,
+      txBuilderVersion: "1.16.0",
+      createdFromSafeAddress: safeAddress,
+      createdFromOwnerAddress: ""
+    },
+    transactions
+  };
+  const batch = {
+    ...batchInfo,
+    meta: {
+      ...batchInfo.meta,
+      checksum: calculateChecksum(batchInfo)
+    }
+  };
+  return batch;
+}
+function getSafeBatches(args) {
+  const { batches, name } = args;
+  return batches.map((txs, index) => {
+    const batchName = `${name}-#${index}`;
+    return getSafeBatch({
+      ...args,
+      name: batchName,
+      txs
+    });
+  });
+}
+export {
+  calculateChecksum,
+  convertRawTxToSafeMultisigTx,
+  getSafeBatch,
+  getSafeBatches
+};

package/dist/esm/permissionless/utils/governance/index.js

@@ -0,0 +1,3 @@
+export * from "./batch";
+export * from "./timelock-txs";
+export * from "./types";

package/dist/esm/permissionless/utils/governance/timelock-txs.js

@@ -0,0 +1,20 @@
+import { governorAbi } from "../../../abi/governance/governor.js";
+import { createRawTx } from "../../../sdk/utils/index.js";
+import { convertRawTxToSafeMultisigTx } from "./batch";
+function convertQueueBatchToExecuteTx(queueBatch) {
+  const executionBatch = queueBatch.filter((tx) => tx.contractMethod.name === "queueTransaction").map((tx) => ({
+    ...tx.contractInputsValues,
+    value: BigInt(tx.contractInputsValues.value),
+    eta: BigInt(tx.contractInputsValues.eta)
+  }));
+  return convertRawTxToSafeMultisigTx(
+    createRawTx(queueBatch[0].to, {
+      functionName: "executeBatch",
+      args: [executionBatch],
+      abi: governorAbi
+    })
+  );
+}
+export {
+  convertQueueBatchToExecuteTx
+};

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

@@ -0,0 +1,9 @@
+export * from "./abi-decoder";
+export * from "./abi-encoder";
+export * from "./block-utils";
+export * from "./create2";
+export * from "./format";
+export * from "./governance";
+export * from "./literals";
+export * from "./price-update";
+export * from "./signature";

package/dist/esm/permissionless/utils/literals.js

@@ -0,0 +1,16 @@
+const CROSS_CHAIN_GOVERNANCE = "CROSS_CHAIN_GOVERNANCE";
+const BYTECODE_REPOSITORY = "BYTECODE_REPOSITORY";
+const INSTANCE_MANAGER = "INSTANCE_MANAGER";
+const TOKEN_COMPRESSOR = "GLOBAL::TOKEN_COMPRESSOR";
+const CROSS_CHAIN_MULTISIG = "CROSS_CHAIN_MULTISIG";
+const PRICE_FEED_STORE = "PRICE_FEED_STORE";
+const MARKET_CONFIGURATOR_FACTORY = "MARKET_CONFIGURATOR_FACTORY";
+export {
+  BYTECODE_REPOSITORY,
+  CROSS_CHAIN_GOVERNANCE,
+  CROSS_CHAIN_MULTISIG,
+  INSTANCE_MANAGER,
+  MARKET_CONFIGURATOR_FACTORY,
+  PRICE_FEED_STORE,
+  TOKEN_COMPRESSOR
+};

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

@@ -0,0 +1,65 @@
+import { AP_PRICE_FEED_COMPRESSOR } from "../../../sdk/constants/index.js";
+import { GearboxSDK } from "../../../sdk/index.js";
+import { AddressProviderContract } from "../../bindings";
+import { Addresses } from "../../deployment/addresses";
+import { deepJsonParse } from "../format";
+import { getUpdatablePriceFeeds } from "./get-updatable-feeds";
+function getCallTouchedPriceFeeds(parsedCall) {
+  const priceFeeds = [];
+  const deepParsedArgs = 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 AddressProviderContract(
+    Addresses.ADDRESS_PROVIDER,
+    client
+  );
+  const pfCompressor = await addressProvider.getAddressOrRevert(
+    AP_PRICE_FEED_COMPRESSOR,
+    310n
+  );
+  const sdk = await GearboxSDK.attach({
+    rpcURLs: [client.transport.url],
+    marketConfigurators: []
+  });
+  const touchedFeeds = parsedCalls.flatMap(
+    (call) => getCallTouchedPriceFeeds(call)
+  );
+  return (await getUpdatablePriceFeeds({
+    sdk,
+    client,
+    pfCompressor,
+    priceFeeds: touchedFeeds
+  })).map((feed) => feed.address);
+}
+export {
+  getCallTouchedPriceFeeds,
+  getCallsTouchedPriceFeeds,
+  getCallsTouchedUpdatablePriceFeeds
+};

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

@@ -0,0 +1,65 @@
+import {
+  decodeFunctionData,
+  multicall3Abi,
+  parseAbi
+} from "viem";
+import {
+  GearboxSDK
+} from "../../../sdk/index.js";
+import { createRawTx } from "../../../sdk/utils/index.js";
+import { PriceFeedStoreContract } from "../../bindings";
+import { Addresses } from "../../deployment/addresses";
+function getUpdateCalldata(tx) {
+  const data = decodeFunctionData({
+    abi: 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 PriceFeedStoreContract(
+    Addresses.PRICE_FEED_STORE,
+    client
+  );
+  const sdk = await 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 = createRawTx(multicall3Address, {
+      abi: 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);
+}
+export {
+  getPriceUpdateTx,
+  getUpdateCalldata
+};

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

@@ -0,0 +1,103 @@
+import {
+  multicall3Abi
+} from "viem";
+import { GearboxSDK } from "../../../sdk/index.js";
+import {
+  simulateMulticall
+} from "../../../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 simulateMulticall(client, {
+    contracts: [
+      {
+        address: multicall3Address,
+        // @ts-expect-error
+        abi: 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 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 }),
+    {}
+  );
+}
+export {
+  getPrices
+};

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

@@ -0,0 +1,31 @@
+import { getContract } from "viem";
+import { priceFeedCompressorAbi } from "../../../abi/compressors/priceFeedCompressor.js";
+import {
+  PythPriceFeed,
+  RedstonePriceFeedContract
+} from "../../../sdk/index.js";
+import { bytes32ToString } from "../../../sdk/utils/index.js";
+async function getUpdatablePriceFeeds(args) {
+  const { sdk, client, pfCompressor, priceFeeds } = args;
+  const priceFeedCompressor = getContract({
+    address: pfCompressor,
+    abi: priceFeedCompressorAbi,
+    client
+  });
+  const updatablePriceFeeds = (await priceFeedCompressor.read.loadPriceFeedTree([
+    priceFeeds
+  ])).filter(
+    (data) => ["PRICE_FEED::PYTH", "PRICE_FEED::REDSTONE"].includes(
+      bytes32ToString(data.baseParams.contractType)
+    )
+  ).map((data) => {
+    if (bytes32ToString(data.baseParams.contractType) === "PRICE_FEED::PYTH") {
+      return new PythPriceFeed(sdk, data);
+    }
+    return new RedstonePriceFeedContract(sdk, data);
+  });
+  return updatablePriceFeeds;
+}
+export {
+  getUpdatablePriceFeeds
+};

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

@@ -0,0 +1,4 @@
+export * from "./get-price-feeds";
+export * from "./get-price-update-tx";
+export * from "./get-prices";
+export * from "./get-updatable-feeds";

package/dist/esm/permissionless/utils/signature.js

@@ -0,0 +1,11 @@
+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)}`;
+}
+export {
+  normalizeSignature
+};