@gearbox-protocol/sdk 9.14.1 → 9.15.1

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

@@ -0,0 +1,244 @@
+"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 instance_manager_exports = {};
+__export(instance_manager_exports, {
+  InstanceManagerContract: () => InstanceManagerContract
+});
+module.exports = __toCommonJS(instance_manager_exports);
+var import_viem = require("viem");
+var import_instanceManager = require("../../abi/310/instanceManager.js");
+var import_camelotV3Worker = require("../../abi/router/camelotV3Worker.js");
+var import_erc4626Worker = require("../../abi/router/erc4626Worker.js");
+var import_gearboxRouter = require("../../abi/router/gearboxRouter.js");
+var import_pendleRouterWorker = require("../../abi/router/pendleRouterWorker.js");
+var import_uniswapV3Worker = require("../../abi/router/uniswapV3Worker.js");
+var import_utils = require("../../sdk/utils/index.js");
+var import_addresses = require("../deployment/addresses.js");
+var import_base_contract = require("./base-contract.js");
+var import_compressors = require("./compressors/index.js");
+var import_price_feed_store = require("./price-feed-store.js");
+var import_router = require("./router/index.js");
+const abi = import_instanceManager.instanceManagerAbi;
+class InstanceManagerContract extends import_base_contract.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 import_addresses.Addresses.PRICE_FEED_STORE.toLowerCase(): {
+        const priceFeedStore = new import_price_feed_store.PriceFeedStoreContract(target, this.client);
+        return priceFeedStore.parseFunctionData(calldata);
+      }
+      default: {
+        try {
+          let parsedData;
+          const router = new import_base_contract.BaseContract(
+            import_gearboxRouter.gearboxRouterAbi,
+            target,
+            this.client,
+            "GearboxRouter"
+          );
+          parsedData = router.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const routingManager = new import_router.RoutingManagerContract(
+            target,
+            this.client
+          );
+          parsedData = routingManager.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const camelotV3Worker = new import_base_contract.BaseContract(
+            import_camelotV3Worker.camelotV3WorkerAbi,
+            target,
+            this.client,
+            "CamelotV3Worker"
+          );
+          parsedData = camelotV3Worker.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const erc4626Worker = new import_base_contract.BaseContract(
+            import_erc4626Worker.erc4626WorkerAbi,
+            target,
+            this.client,
+            "ERC4626Worker"
+          );
+          parsedData = erc4626Worker.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const pendleRouterWorker = new import_base_contract.BaseContract(
+            import_pendleRouterWorker.pendleRouterWorkerAbi,
+            target,
+            this.client,
+            "PendleRouterWorker"
+          );
+          parsedData = pendleRouterWorker.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const uniswapV3Worker = new import_base_contract.BaseContract(
+            import_uniswapV3Worker.uniswapV3WorkerAbi,
+            target,
+            this.client,
+            "UniswapV3Worker"
+          );
+          parsedData = uniswapV3Worker.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+          const withdrawalCompressor = new import_compressors.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 = import_base_contract.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: (0, import_utils.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: (0, import_viem.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: [(0, import_viem.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: [(0, import_viem.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: [(0, import_viem.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})`
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InstanceManagerContract
+});

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

@@ -0,0 +1,75 @@
+"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 market_configurator_factory_exports = {};
+__export(market_configurator_factory_exports, {
+  MarketConfiguratorFactoryContract: () => MarketConfiguratorFactoryContract
+});
+module.exports = __toCommonJS(market_configurator_factory_exports);
+var import_iMarketConfiguratorFactory = require("../../abi/310/iMarketConfiguratorFactory.js");
+var import_base_contract = require("./base-contract.js");
+const abi = import_iMarketConfiguratorFactory.iMarketConfiguratorFactoryAbi;
+class MarketConfiguratorFactoryContract extends import_base_contract.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)
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MarketConfiguratorFactoryContract
+});