@gearbox-protocol/sdk 9.14.1 → 9.15.0

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

@@ -0,0 +1,224 @@
+import {
+  encodeAbiParameters,
+  formatEther,
+  keccak256,
+  toBytes
+} from "viem";
+import { formatAbiItem } from "viem/utils";
+import { governorAbi } from "../../../abi/governance/governor.js";
+import { json_stringify } from "../../../sdk/utils/index.js";
+import { formatTimestamp } from "../../utils";
+import { BaseContract } from "../base-contract";
+import { MarketConfiguratorContract } from "../market-configurator";
+import { TreasurySplitterContract } from "../treasury-splitter";
+import { BatchesChainContract } from "./batches-chain";
+const abi = governorAbi;
+class GovernorContract extends BaseContract {
+  batchesChainContract;
+  constructor(address, client) {
+    super(abi, address, client, "Governor");
+    this.batchesChainContract = new 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 keccak256(
+      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: governorAbi,
+      functionName: "owner"
+    });
+    return owner;
+  }
+  createQueueTx(args) {
+    const { tx, eta } = args;
+    const signature = 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 MarketConfiguratorContract(
+            target,
+            this.client
+          );
+          parsedData = marketConfigurator.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const treasurySplitter = new 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: formatTimestamp(Number(eta))
+          }
+        };
+      }
+      case "queueTransaction": {
+        const [target, value, signature, data, eta] = args;
+        const calldata = keccak256(toBytes(signature)).slice(0, 10) + data.slice(2);
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            target,
+            value: formatEther(value),
+            signature,
+            data: json_stringify(
+              this.decodeFunctionData(target, calldata)?.args ?? calldata
+            ),
+            eta: formatTimestamp(Number(eta))
+          }
+        };
+      }
+      case "executeBatch": {
+        const [txs] = args;
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            txs: json_stringify(
+              txs.map((tx) => {
+                const { target, value, signature, data, eta } = tx;
+                const calldata = keccak256(toBytes(signature)).slice(0, 10) + data.slice(2);
+                return {
+                  target,
+                  value: formatEther(value),
+                  signature,
+                  data: json_stringify(
+                    this.decodeFunctionData(target, calldata)?.args ?? calldata
+                  ),
+                  eta: formatTimestamp(Number(eta))
+                };
+              })
+            )
+          }
+        };
+      }
+      default:
+        return void 0;
+    }
+  }
+}
+export {
+  GovernorContract
+};

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

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

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

@@ -0,0 +1,80 @@
+import { iTimeLockAbi } from "../../../abi/governance/iTimeLock.js";
+import { BaseContract } from "../base-contract";
+class TimeLockContract extends BaseContract {
+  constructor(address, client) {
+    super(iTimeLockAbi, address, client, "TimeLock");
+  }
+  async admin() {
+    const admin = await this.client.readContract({
+      address: this.address,
+      abi: 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
+      }))
+    };
+  }
+}
+export {
+  TimeLockContract
+};

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

@@ -0,0 +1,14 @@
+export * from "./address-provider";
+export * from "./base-contract";
+export * from "./bytecode-repository";
+export * from "./compressors";
+export * from "./cross-chain-multisig";
+export * from "./governance";
+export * from "./instance-manager";
+export * from "./market-configurator";
+export * from "./market-configurator-factory";
+export * from "./price-feed-store";
+export * from "./pricefeeds";
+export * from "./router";
+export * from "./treasury-splitter";
+export * from "./types";

package/dist/esm/permissionless/bindings/instance-manager.js

@@ -0,0 +1,223 @@
+import {
+  hexToString,
+  stringToHex
+} from "viem";
+import { instanceManagerAbi } from "../../abi/310/instanceManager.js";
+import { camelotV3WorkerAbi } from "../../abi/router/camelotV3Worker.js";
+import { erc4626WorkerAbi } from "../../abi/router/erc4626Worker.js";
+import { gearboxRouterAbi } from "../../abi/router/gearboxRouter.js";
+import { pendleRouterWorkerAbi } from "../../abi/router/pendleRouterWorker.js";
+import { uniswapV3WorkerAbi } from "../../abi/router/uniswapV3Worker.js";
+import { json_stringify } from "../../sdk/utils/index.js";
+import { Addresses } from "../deployment/addresses";
+import { BaseContract } from "./base-contract";
+import { WithdrawalCompressorContract } from "./compressors";
+import { PriceFeedStoreContract } from "./price-feed-store";
+import { RoutingManagerContract } from "./router";
+const abi = instanceManagerAbi;
+class InstanceManagerContract extends BaseContract {
+  constructor(address, client) {
+    super(abi, address, client, "InstanceManager");
+  }
+  // TODO:
+  decodeFunctionData(target, calldata) {
+    switch (target.toLowerCase()) {
+      case this.address.toLowerCase(): {
+        return this.parseFunctionData(calldata);
+      }
+      case Addresses.PRICE_FEED_STORE.toLowerCase(): {
+        const priceFeedStore = new PriceFeedStoreContract(target, this.client);
+        return priceFeedStore.parseFunctionData(calldata);
+      }
+      default: {
+        try {
+          let parsedData;
+          const router = new BaseContract(
+            gearboxRouterAbi,
+            target,
+            this.client,
+            "GearboxRouter"
+          );
+          parsedData = router.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const routingManager = new RoutingManagerContract(
+            target,
+            this.client
+          );
+          parsedData = routingManager.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const camelotV3Worker = new BaseContract(
+            camelotV3WorkerAbi,
+            target,
+            this.client,
+            "CamelotV3Worker"
+          );
+          parsedData = camelotV3Worker.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const erc4626Worker = new BaseContract(
+            erc4626WorkerAbi,
+            target,
+            this.client,
+            "ERC4626Worker"
+          );
+          parsedData = erc4626Worker.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const pendleRouterWorker = new BaseContract(
+            pendleRouterWorkerAbi,
+            target,
+            this.client,
+            "PendleRouterWorker"
+          );
+          parsedData = pendleRouterWorker.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const uniswapV3Worker = new BaseContract(
+            uniswapV3WorkerAbi,
+            target,
+            this.client,
+            "UniswapV3Worker"
+          );
+          parsedData = uniswapV3Worker.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const withdrawalCompressor = new WithdrawalCompressorContract(
+            target,
+            this.client
+          );
+          parsedData = withdrawalCompressor.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+        } catch {
+          return void 0;
+        }
+      }
+    }
+  }
+  // TODO:
+  parseFunctionParams(params) {
+    switch (params.functionName) {
+      case "configureGlobal": {
+        const [target, data] = params.args;
+        const nestedCall = BaseContract.parse(target, data);
+        return {
+          ...nestedCall,
+          label: `${nestedCall.label} via instanceManager`,
+          target: this.address
+        };
+      }
+      case "configureLocal": {
+        const [target, data] = params.args;
+        const decoded = this.decodeFunctionData(target, data);
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName: params.functionName,
+          args: decoded ? {
+            target,
+            functionName: decoded.functionName,
+            args: json_stringify(decoded.args)
+          } : {
+            target,
+            data
+          }
+        };
+      }
+      case "activate": {
+        const [instanceOwner, treasury, weth, gear] = params.args;
+        return this.wrapParseCall(params, {
+          instanceOwner,
+          treasury,
+          weth,
+          gear
+        });
+      }
+      case "deploySystemContract": {
+        const [contractType, version, saveVersion] = params.args;
+        return this.wrapParseCall(params, {
+          contractType: hexToString(contractType, { size: 32 }),
+          version: version.toString(),
+          saveVersion: saveVersion ? "true" : "false"
+        });
+      }
+      case "setGlobalAddress": {
+        const [key, address, saveVersion] = params.args;
+        return this.wrapParseCall(params, {
+          key,
+          address,
+          saveVersion: saveVersion ? "true" : "false"
+        });
+      }
+      default:
+        return void 0;
+    }
+  }
+  async isActivated() {
+    const result = await this.contract.read.isActivated();
+    return result;
+  }
+  async getOwner() {
+    const result = await this.contract.read.owner();
+    return result;
+  }
+  wrapConfigureGlobal(rawTx) {
+    return this.createRawTx({
+      functionName: "configureGlobal",
+      args: [rawTx.to, rawTx.callData],
+      description: rawTx.description ? `InstanceManager.configureGlobal(${rawTx.description})` : void 0
+    });
+  }
+  wrapConfigureLocal(rawTx) {
+    return this.createRawTx({
+      functionName: "configureLocal",
+      args: [rawTx.to, rawTx.callData],
+      description: rawTx.description ? `InstanceManager.configureLocal(${rawTx.description})` : void 0
+    });
+  }
+  setLocalAddress(args) {
+    const { key, address, saveVersion } = args;
+    return this.createRawTx({
+      functionName: "setLocalAddress",
+      args: [stringToHex(key, { size: 32 }), address, saveVersion],
+      description: `InstanceManager.setLocalAddress(key: ${key}, addr: ${address}, saveVersion: ${saveVersion})`
+    });
+  }
+  setGlobalAddress(args) {
+    const { key, address, saveVersion } = args;
+    return this.createRawTx({
+      functionName: "setGlobalAddress",
+      args: [stringToHex(key, { size: 32 }), address, saveVersion],
+      description: `InstanceManager.setGlobalAddress(key: ${key}, addr: ${address}, saveVersion: ${saveVersion})`
+    });
+  }
+  deploySystemContractTx(args) {
+    const { name, version, saveVersion } = args;
+    return this.createRawTx({
+      functionName: "deploySystemContract",
+      args: [stringToHex(name, { size: 32 }), version, saveVersion],
+      description: `InstanceManager.deploySystemContract(${name})`
+    });
+  }
+  activateTx(args) {
+    const { instanceOwner, treasury, weth, gear } = args;
+    return this.createRawTx({
+      functionName: "activate",
+      args: [instanceOwner, treasury, weth, gear],
+      description: `InstanceManager.activate(instanceOwner: ${instanceOwner}, treasury: ${treasury}, weth: ${weth}, gear: ${gear})`
+    });
+  }
+}
+export {
+  InstanceManagerContract
+};

package/dist/esm/permissionless/bindings/market-configurator-factory.js

@@ -0,0 +1,51 @@
+import { iMarketConfiguratorFactoryAbi } from "../../abi/310/iMarketConfiguratorFactory.js";
+import { BaseContract } from "./base-contract";
+const abi = iMarketConfiguratorFactoryAbi;
+class MarketConfiguratorFactoryContract extends BaseContract {
+  constructor(address, client) {
+    super(abi, address, client, "MarketConfiguratorFactory");
+  }
+  createMarketConfiguratorTx(args) {
+    return this.createRawTx({
+      functionName: "createMarketConfigurator",
+      args: [
+        args.emergencyAdmin,
+        args.adminFeeTreasury,
+        args.curatorName,
+        args.deployGovernor
+      ]
+    });
+  }
+  async getMarketConfigurators() {
+    return [...await this.contract.read.getMarketConfigurators()];
+  }
+  async getShutdownMarketConfigurators() {
+    return [...await this.contract.read.getShutdownMarketConfigurators()];
+  }
+  async syncMarketConfigurators(fromBlock, toBlock) {
+    const createEvents = await this.getEvents(
+      "CreateMarketConfigurator",
+      fromBlock,
+      toBlock
+    );
+    const shutdownEvents = await this.getEvents(
+      "ShutdownMarketConfigurator",
+      fromBlock,
+      toBlock
+    );
+    return {
+      newMarketConfigurators: (createEvents || []).map((event) => ({
+        address: event.args.marketConfigurator,
+        name: event.args.name,
+        atBlock: Number(event.blockNumber)
+      })).filter((marketConfigurator) => marketConfigurator.address !== void 0),
+      shutdownMarketConfigurators: (shutdownEvents || []).map((event) => ({
+        address: event.args.marketConfigurator,
+        atBlock: Number(event.blockNumber)
+      })).filter((marketConfigurator) => marketConfigurator.address !== void 0)
+    };
+  }
+}
+export {
+  MarketConfiguratorFactoryContract
+};