@gearbox-protocol/sdk 9.14.1 → 9.15.0

package/dist/cjs/permissionless/bindings/factory/pool-factory.js

@@ -0,0 +1,69 @@
+"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 pool_factory_exports = {};
+__export(pool_factory_exports, {
+  PoolFactory: () => PoolFactory
+});
+module.exports = __toCommonJS(pool_factory_exports);
+var import_iPoolConfigureActions = require("../../../abi/310/configure/iPoolConfigureActions.js");
+var import_abstract_factory = require("./abstract-factory");
+const abi = import_iPoolConfigureActions.iPoolConfigureActionsAbi;
+class PoolFactory extends import_abstract_factory.AbstractFactory {
+  constructor() {
+    super(abi);
+  }
+  pause() {
+    return this.createCallData({
+      functionName: "pause"
+    });
+  }
+  unpause() {
+    return this.createCallData({
+      functionName: "unpause"
+    });
+  }
+  setCreditManagerDebtLimit(args) {
+    return this.createCallData({
+      functionName: "setCreditManagerDebtLimit",
+      args: [args.creditManager, args.limit]
+    });
+  }
+  setTokenLimit(args) {
+    return this.createCallData({
+      functionName: "setTokenLimit",
+      args: [args.token, args.limit]
+    });
+  }
+  setTokenQuotaIncreaseFee(params) {
+    return this.createCallData({
+      functionName: "setTokenQuotaIncreaseFee",
+      args: [params.token, params.fee]
+    });
+  }
+  setTotalDebtLimit(args) {
+    return this.createCallData({
+      functionName: "setTotalDebtLimit",
+      args: [args.limit]
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PoolFactory
+});

package/dist/cjs/permissionless/bindings/factory/price-oracle-factory.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 price_oracle_factory_exports = {};
+__export(price_oracle_factory_exports, {
+  PriceOracleFactory: () => PriceOracleFactory
+});
+module.exports = __toCommonJS(price_oracle_factory_exports);
+var import_iPriceOracleConfigureActions = require("../../../abi/310/configure/iPriceOracleConfigureActions.js");
+var import_abstract_factory = require("./abstract-factory");
+const abi = import_iPriceOracleConfigureActions.iPriceOracleConfigureActionsAbi;
+class PriceOracleFactory extends import_abstract_factory.AbstractFactory {
+  constructor() {
+    super(abi);
+  }
+  setPriceFeed(params) {
+    return this.createCallData({
+      functionName: "setPriceFeed",
+      args: [params.token, params.priceFeed]
+    });
+  }
+  setReservePriceFeed(params) {
+    return this.createCallData({
+      functionName: "setReservePriceFeed",
+      args: [params.token, params.priceFeed]
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PriceOracleFactory
+});

package/dist/cjs/permissionless/bindings/governance/batches-chain.js

@@ -0,0 +1,41 @@
+"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 batches_chain_exports = {};
+__export(batches_chain_exports, {
+  BatchesChainContract: () => BatchesChainContract
+});
+module.exports = __toCommonJS(batches_chain_exports);
+var import_batchesChain = require("../../../abi/governance/batchesChain.js");
+var import_base_contract = require("../base-contract");
+const abi = import_batchesChain.batchesChainAbi;
+class BatchesChainContract extends import_base_contract.BaseContract {
+  constructor(address, client) {
+    super(abi, address, client, "BatchesChain");
+  }
+  createBatchOrderingTx(prevHash) {
+    return this.createRawTx({
+      functionName: "revertIfQueued",
+      args: [prevHash]
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BatchesChainContract
+});

package/dist/cjs/permissionless/bindings/governance/governor.js

@@ -0,0 +1,243 @@
+"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 governor_exports = {};
+__export(governor_exports, {
+  GovernorContract: () => GovernorContract
+});
+module.exports = __toCommonJS(governor_exports);
+var import_viem = require("viem");
+var import_utils = require("viem/utils");
+var import_governor = require("../../../abi/governance/governor.js");
+var import_utils2 = require("../../../sdk/utils/index.js");
+var import_utils3 = require("../../utils");
+var import_base_contract = require("../base-contract");
+var import_market_configurator = require("../market-configurator");
+var import_treasury_splitter = require("../treasury-splitter");
+var import_batches_chain = require("./batches-chain");
+const abi = import_governor.governorAbi;
+class GovernorContract extends import_base_contract.BaseContract {
+  batchesChainContract;
+  constructor(address, client) {
+    super(abi, address, client, "Governor");
+    this.batchesChainContract = new import_batches_chain.BatchesChainContract(
+      "0x59b2fd348e4Ade84ffEfDaf5fcdDa7276c8C5041",
+      client
+    );
+  }
+  getTxHash(tx) {
+    if (tx.contractMethod.name !== "queueTransaction") {
+      throw new Error(
+        `Transaction is not a queueTransaction, method provided: ${tx.contractMethod.name}`
+      );
+    }
+    const { target, value, signature, data, eta } = tx.contractInputsValues;
+    return (0, import_viem.keccak256)(
+      (0, import_viem.encodeAbiParameters)(
+        [
+          { type: "address", name: "target" },
+          { type: "uint", name: "value" },
+          { type: "string", name: "signature" },
+          { type: "bytes", name: "data" },
+          { type: "uint", name: "eta" }
+        ],
+        [target, value, signature, data, eta]
+      )
+    );
+  }
+  async owner() {
+    const owner = await this.client.readContract({
+      address: this.address,
+      abi: import_governor.governorAbi,
+      functionName: "owner"
+    });
+    return owner;
+  }
+  createQueueTx(args) {
+    const { tx, eta } = args;
+    const signature = (0, import_utils.formatAbiItem)({
+      type: "function",
+      stateMutability: tx.contractMethod.payable ? "payable" : "nonpayable",
+      outputs: [],
+      ...tx.contractMethod
+    });
+    return this.createRawTx({
+      functionName: "queueTransaction",
+      args: [
+        tx.to,
+        0n,
+        signature,
+        "0x" + tx.callData.slice(10),
+        BigInt(eta)
+      ],
+      description: `QueueTransaction(${tx.description})`
+    });
+  }
+  createGovernorBatch(args) {
+    const { txs, eta, prevHash } = args;
+    const transactions = [];
+    const queueTxs = txs.map((tx) => this.createQueueTx({ tx, eta }));
+    transactions.push(
+      this.createRawTx({
+        functionName: "startBatch",
+        args: [BigInt(eta)],
+        description: `StartBatch(${eta})`
+      })
+    );
+    if (prevHash !== void 0) {
+      transactions.push(
+        this.createQueueTx({
+          tx: this.batchesChainContract.createBatchOrderingTx(prevHash),
+          eta
+        })
+      );
+    }
+    transactions.push(...queueTxs);
+    return transactions;
+  }
+  createGovernorBatches(args) {
+    const { batches, eta } = args;
+    const queueBatches = [];
+    let prevHash;
+    for (const txs of batches) {
+      queueBatches.push(this.createGovernorBatch({ txs, eta, prevHash }));
+      prevHash = this.getTxHash(this.createQueueTx({ tx: txs[0], eta }));
+    }
+    return queueBatches;
+  }
+  createExecuteBatchTx(args) {
+    const executionBatch = args.txs.filter((tx) => tx.contractMethod.name === "queueTransaction").map((tx) => ({
+      ...tx.contractInputsValues,
+      value: BigInt(tx.contractInputsValues.value),
+      eta: BigInt(tx.contractInputsValues.eta)
+    }));
+    return this.createRawTx({
+      functionName: "executeBatch",
+      args: [executionBatch],
+      description: `ExecuteBatch(${executionBatch.map(
+        (tx) => `{
+  target: ${tx.target},
+  value: ${tx.value.toString()},
+  signature: ${tx.signature},
+  data: ${tx.data.length > 40 ? `${tx.data.slice(0, 40)}...` : tx.data},
+},`
+      ).join("\n")})`
+    });
+  }
+  decodeFunctionData(target, calldata) {
+    switch (target.toLowerCase()) {
+      case this.address.toLowerCase(): {
+        return this.parseFunctionData(calldata);
+      }
+      case this.batchesChainContract.address.toLowerCase(): {
+        return this.batchesChainContract.parseFunctionData(calldata);
+      }
+      default: {
+        try {
+          let parsedData;
+          const marketConfigurator = new import_market_configurator.MarketConfiguratorContract(
+            target,
+            this.client
+          );
+          parsedData = marketConfigurator.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const treasurySplitter = new import_treasury_splitter.TreasurySplitterContract(
+            target,
+            this.client
+          );
+          parsedData = treasurySplitter.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+        } catch {
+          return void 0;
+        }
+      }
+    }
+  }
+  parseFunctionParams(params) {
+    const { functionName, args } = params;
+    switch (functionName) {
+      case "startBatch": {
+        const [eta] = args;
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            eta: (0, import_utils3.formatTimestamp)(Number(eta))
+          }
+        };
+      }
+      case "queueTransaction": {
+        const [target, value, signature, data, eta] = args;
+        const calldata = (0, import_viem.keccak256)((0, import_viem.toBytes)(signature)).slice(0, 10) + data.slice(2);
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            target,
+            value: (0, import_viem.formatEther)(value),
+            signature,
+            data: (0, import_utils2.json_stringify)(
+              this.decodeFunctionData(target, calldata)?.args ?? calldata
+            ),
+            eta: (0, import_utils3.formatTimestamp)(Number(eta))
+          }
+        };
+      }
+      case "executeBatch": {
+        const [txs] = args;
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            txs: (0, import_utils2.json_stringify)(
+              txs.map((tx) => {
+                const { target, value, signature, data, eta } = tx;
+                const calldata = (0, import_viem.keccak256)((0, import_viem.toBytes)(signature)).slice(0, 10) + data.slice(2);
+                return {
+                  target,
+                  value: (0, import_viem.formatEther)(value),
+                  signature,
+                  data: (0, import_utils2.json_stringify)(
+                    this.decodeFunctionData(target, calldata)?.args ?? calldata
+                  ),
+                  eta: (0, import_utils3.formatTimestamp)(Number(eta))
+                };
+              })
+            )
+          }
+        };
+      }
+      default:
+        return void 0;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GovernorContract
+});

package/dist/cjs/permissionless/bindings/governance/index.js

@@ -0,0 +1,26 @@
+"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 governance_exports = {};
+module.exports = __toCommonJS(governance_exports);
+__reExport(governance_exports, require("./governor"), module.exports);
+__reExport(governance_exports, require("./timelock"), module.exports);
+__reExport(governance_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./governor"),
+  ...require("./timelock"),
+  ...require("./types")
+});

package/dist/cjs/permissionless/bindings/governance/timelock.js

@@ -0,0 +1,104 @@
+"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 timelock_exports = {};
+__export(timelock_exports, {
+  TimeLockContract: () => TimeLockContract
+});
+module.exports = __toCommonJS(timelock_exports);
+var import_iTimeLock = require("../../../abi/governance/iTimeLock.js");
+var import_base_contract = require("../base-contract");
+class TimeLockContract extends import_base_contract.BaseContract {
+  constructor(address, client) {
+    super(import_iTimeLock.iTimeLockAbi, address, client, "TimeLock");
+  }
+  async admin() {
+    const admin = await this.client.readContract({
+      address: this.address,
+      abi: import_iTimeLock.iTimeLockAbi,
+      functionName: "admin"
+    });
+    return admin;
+  }
+  async getGracePeriod() {
+    return this.contract.read.GRACE_PERIOD();
+  }
+  async getQueuedAndExecutedTransactions(fromBlock, toBlock) {
+    const [executedEvents, queuedEvents, cancelledEvents] = await Promise.all([
+      this.getEvents("ExecuteTransaction", fromBlock, toBlock),
+      this.getEvents("QueueTransaction", fromBlock, toBlock),
+      this.getEvents("CancelTransaction", fromBlock, toBlock)
+    ]);
+    const toBlockTimestamp = await this.client.getBlock({ blockNumber: toBlock }).then((block) => block.timestamp);
+    const gracePeriod = await this.getGracePeriod();
+    const processedTxHashes = /* @__PURE__ */ new Set([
+      ...executedEvents.map((event) => event.args.txHash),
+      ...cancelledEvents.map((event) => event.args.txHash)
+    ]);
+    const queuedTxHashes = new Set(
+      queuedEvents.map((event) => event.args.txHash)
+    );
+    const remainingQueuedEvents = queuedEvents.filter((event) => {
+      const cancelledOrExecuted = processedTxHashes.has(event.args.txHash);
+      const expired = event.args.eta ? toBlockTimestamp > event.args.eta + gracePeriod : true;
+      return !cancelledOrExecuted && !expired;
+    });
+    const orphanedCanceledEvents = cancelledEvents.filter(
+      (event) => !queuedTxHashes.has(event.args.txHash)
+    );
+    return {
+      executed: executedEvents.map((event) => ({
+        txHash: event.args.txHash,
+        txParams: {
+          target: event.args.target,
+          value: event.args.value,
+          data: event.args.data,
+          signature: event.args.signature,
+          eta: event.args.eta
+        },
+        blockNumber: event.blockNumber
+      })),
+      queued: remainingQueuedEvents.map((event) => ({
+        txHash: event.args.txHash,
+        txParams: {
+          target: event.args.target,
+          value: event.args.value,
+          data: event.args.data,
+          signature: event.args.signature,
+          eta: event.args.eta
+        },
+        blockNumber: event.blockNumber
+      })),
+      canceled: orphanedCanceledEvents.map((event) => ({
+        txHash: event.args.txHash,
+        txParams: {
+          target: event.args.target,
+          value: event.args.value,
+          data: event.args.data,
+          signature: event.args.signature,
+          eta: event.args.eta
+        },
+        blockNumber: event.blockNumber
+      }))
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TimeLockContract
+});

package/dist/cjs/permissionless/bindings/governance/types.js

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/permissionless/bindings/index.js

@@ -0,0 +1,48 @@
+"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 bindings_exports = {};
+module.exports = __toCommonJS(bindings_exports);
+__reExport(bindings_exports, require("./address-provider"), module.exports);
+__reExport(bindings_exports, require("./base-contract"), module.exports);
+__reExport(bindings_exports, require("./bytecode-repository"), module.exports);
+__reExport(bindings_exports, require("./compressors"), module.exports);
+__reExport(bindings_exports, require("./cross-chain-multisig"), module.exports);
+__reExport(bindings_exports, require("./governance"), module.exports);
+__reExport(bindings_exports, require("./instance-manager"), module.exports);
+__reExport(bindings_exports, require("./market-configurator"), module.exports);
+__reExport(bindings_exports, require("./market-configurator-factory"), module.exports);
+__reExport(bindings_exports, require("./price-feed-store"), module.exports);
+__reExport(bindings_exports, require("./pricefeeds"), module.exports);
+__reExport(bindings_exports, require("./router"), module.exports);
+__reExport(bindings_exports, require("./treasury-splitter"), module.exports);
+__reExport(bindings_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./address-provider"),
+  ...require("./base-contract"),
+  ...require("./bytecode-repository"),
+  ...require("./compressors"),
+  ...require("./cross-chain-multisig"),
+  ...require("./governance"),
+  ...require("./instance-manager"),
+  ...require("./market-configurator"),
+  ...require("./market-configurator-factory"),
+  ...require("./price-feed-store"),
+  ...require("./pricefeeds"),
+  ...require("./router"),
+  ...require("./treasury-splitter"),
+  ...require("./types")
+});