@gearbox-protocol/sdk 9.14.1 → 9.15.1

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

@@ -0,0 +1,771 @@
+"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_exports = {};
+__export(market_configurator_exports, {
+  MarketConfiguratorContract: () => MarketConfiguratorContract
+});
+module.exports = __toCommonJS(market_configurator_exports);
+var import_viem = require("viem");
+var import_creditSuiteParams = require("../../abi/310/configure/creditSuiteParams.js");
+var import_generated = require("../../abi/310/generated.js");
+var import_utils = require("../../sdk/utils/index.js");
+var import_plugins = require("../plugins/index.js");
+var import_create2 = require("../utils/create2.js");
+var import_utils2 = require("../utils/index.js");
+var import_credit_factory = require("./factory/credit-factory.js");
+var import_pool_factory = require("./factory/pool-factory.js");
+var import_price_oracle_factory = require("./factory/price-oracle-factory.js");
+var import_index = require("./index.js");
+const abi = import_generated.iMarketConfiguratorV310Abi;
+class MarketConfiguratorContract extends import_index.BaseContract {
+  creditFactory;
+  poolFactory;
+  priceOracleFactory;
+  constructor(address, client) {
+    super(abi, address, client, "MarketConfigurator");
+    this.creditFactory = new import_credit_factory.CreditFactory();
+    this.poolFactory = new import_pool_factory.PoolFactory();
+    this.priceOracleFactory = new import_price_oracle_factory.PriceOracleFactory();
+  }
+  async getAddressProvider() {
+    const addressProvider = await this.contract.read.addressProvider();
+    return new import_index.AddressProviderContract(addressProvider, this.client);
+  }
+  //
+  // MARKET CONFIG
+  //
+  async previewCreateMarket(params) {
+    return this.contract.read.previewCreateMarket([
+      BigInt(params.minorVersion),
+      params.underlying,
+      params.name,
+      params.symbol
+    ]);
+  }
+  async createMarket(params) {
+    const pool = await this.contract.read.previewCreateMarket([
+      BigInt(params.minorVersion),
+      params.underlying,
+      params.name,
+      params.symbol
+    ]);
+    const tx = this.createRawTx({
+      functionName: "createMarket",
+      args: [
+        BigInt(params.minorVersion),
+        params.underlying,
+        params.name,
+        params.symbol,
+        params.interestRateModelParams,
+        params.rateKeeperParams,
+        params.lossPolicyParams,
+        params.underlyingPriceFeed
+      ]
+    });
+    return {
+      tx,
+      pool
+    };
+  }
+  addAsset(pool, args) {
+    return this.createRawTx({
+      functionName: "addToken",
+      args: [pool, args.token, args.priceFeed]
+    });
+  }
+  //
+  // PRICE ORACLE CONFIG
+  //
+  configurePriceOracle(pool, config) {
+    return this.createRawTx({
+      functionName: "configurePriceOracle",
+      args: [pool, config]
+    });
+  }
+  setPriceFeed(pool, params) {
+    return this.configurePriceOracle(
+      pool,
+      this.priceOracleFactory.setPriceFeed(params)
+    );
+  }
+  setReservePriceFeed(pool, params) {
+    return this.configurePriceOracle(
+      pool,
+      this.priceOracleFactory.setReservePriceFeed(params)
+    );
+  }
+  //
+  // POOL CONFIG
+  //
+  configurePool(pool, calldata) {
+    return this.createRawTx({
+      functionName: "configurePool",
+      args: [pool, calldata]
+    });
+  }
+  setTokenLimit(pool, params) {
+    return this.configurePool(pool, this.poolFactory.setTokenLimit(params));
+  }
+  setTokenQuotaIncreaseFee(pool, params) {
+    return this.configurePool(
+      pool,
+      this.poolFactory.setTokenQuotaIncreaseFee(params)
+    );
+  }
+  setTotalDebtLimit(pool, params) {
+    return this.configurePool(pool, this.poolFactory.setTotalDebtLimit(params));
+  }
+  setCreditManagerDebtLimit(pool, args) {
+    return this.configurePool(
+      pool,
+      this.poolFactory.setCreditManagerDebtLimit(args)
+    );
+  }
+  /// INTEREST RATE MODEL CONFIG
+  updateInterestRateModel(pool, args) {
+    return this.createRawTx({
+      functionName: "updateInterestRateModel",
+      args: [pool, args.deployParams]
+    });
+  }
+  //
+  // CREDIT MANAGER CONFIG
+  //
+  async createCreditSuite(marketInfo, args) {
+    const addressProvider = await this.contract.read.addressProvider();
+    const creditSuiteParams = (0, import_viem.encodeAbiParameters)(
+      [
+        {
+          type: "tuple",
+          components: [
+            { type: "uint8", name: "maxEnabledTokens" },
+            { type: "uint16", name: "feeInterest" },
+            { type: "uint16", name: "feeLiquidation" },
+            { type: "uint16", name: "liquidationPremium" },
+            { type: "uint16", name: "feeLiquidationExpired" },
+            { type: "uint16", name: "liquidationPremiumExpired" },
+            { type: "uint128", name: "minDebt" },
+            { type: "uint128", name: "maxDebt" },
+            { type: "string", name: "name" },
+            {
+              type: "tuple",
+              name: "accountFactoryParams",
+              components: [
+                {
+                  type: "bytes32",
+                  name: "postfix"
+                },
+                {
+                  type: "bytes32",
+                  name: "salt"
+                },
+                {
+                  type: "bytes",
+                  name: "constructorParams"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          type: "tuple",
+          name: "creditFacadeParams",
+          components: [
+            { type: "address", name: "degenNFT" },
+            { type: "bool", name: "isExpirable" },
+            { type: "bool", name: "migrateBotList" }
+          ]
+        }
+      ],
+      [
+        {
+          maxEnabledTokens: args.params.maxEnabledTokens,
+          feeInterest: (0, import_utils2.convertPercent)(args.params.feeInterest),
+          feeLiquidation: (0, import_utils2.convertPercent)(args.params.feeLiquidation),
+          liquidationPremium: (0, import_utils2.convertPercent)(args.params.feeLiquidationPremium),
+          feeLiquidationExpired: (0, import_utils2.convertPercent)(
+            args.params.feeLiquidationExpired
+          ),
+          liquidationPremiumExpired: (0, import_utils2.convertPercent)(
+            args.params.feeLiquidationPremiumExpired
+          ),
+          minDebt: args.params.minDebt,
+          maxDebt: args.params.maxDebt,
+          name: args.params.name,
+          accountFactoryParams: {
+            postfix: (0, import_viem.stringToHex)(args.params.accountFactoryType, { size: 32 }),
+            salt: args.params.accountFactorySalt ? (0, import_create2.handleSalt)(args.params.accountFactorySalt) : (0, import_create2.handleSalt)(
+              (0, import_viem.keccak256)((0, import_viem.toBytes)(marketInfo.name + args.params.name))
+            ),
+            constructorParams: (0, import_viem.encodeAbiParameters)(
+              [{ type: "address" }],
+              [addressProvider]
+            )
+          }
+        },
+        {
+          degenNFT: args.params.whitelistPolicy,
+          isExpirable: args.params.isExpired,
+          migrateBotList: false
+        }
+      ]
+    );
+    const creditManagerAddress = await this.contract.read.previewCreateCreditSuite([
+      BigInt(marketInfo.minorVersion),
+      BigInt(args.params.minorVersion),
+      marketInfo.underlyingAsset,
+      marketInfo.name,
+      marketInfo.symbol,
+      creditSuiteParams
+    ]);
+    const tx = this.createRawTx({
+      functionName: "createCreditSuite",
+      args: [
+        BigInt(args.params.minorVersion),
+        marketInfo.pool,
+        creditSuiteParams
+      ]
+    });
+    return {
+      tx,
+      creditManager: creditManagerAddress
+    };
+  }
+  configureCreditManager(creditManager, calldata) {
+    return this.createRawTx({
+      functionName: "configureCreditSuite",
+      args: [creditManager, calldata]
+    });
+  }
+  configureAdapterFor(creditManager, targetContract, data) {
+    return this.configureCreditManager(
+      creditManager,
+      this.creditFactory.configureAdapterFor(targetContract, data)
+    );
+  }
+  addCollateralToken(creditManager, args) {
+    return this.configureCreditManager(
+      creditManager,
+      this.creditFactory.addCollateralToken(args)
+    );
+  }
+  setFees(params) {
+    return this.configureCreditManager(
+      params.creditManager,
+      this.creditFactory.setFees(params)
+    );
+  }
+  rampLiquidationThreshold(creditManager, args) {
+    return this.configureCreditManager(
+      creditManager,
+      this.creditFactory.rampLiquidationThreshold(args)
+    );
+  }
+  forbidToken(params) {
+    return this.configureCreditManager(
+      params.creditManager,
+      this.creditFactory.forbidToken(params.token)
+    );
+  }
+  allowToken(params) {
+    return this.configureCreditManager(
+      params.creditManager,
+      this.creditFactory.allowToken(params.token)
+    );
+  }
+  setExpirationDate(params) {
+    return this.configureCreditManager(
+      params.creditManager,
+      this.creditFactory.setExpirationDate(params)
+    );
+  }
+  pauseCreditManager(params) {
+    return this.configureCreditManager(
+      params.creditManager,
+      this.creditFactory.pause()
+    );
+  }
+  unpauseCreditManager(params) {
+    return this.configureCreditManager(
+      params.creditManager,
+      this.creditFactory.unpause()
+    );
+  }
+  forbidAdapter(params) {
+    return this.configureCreditManager(
+      params.creditManager,
+      this.creditFactory.forbidAdapter(params.target)
+    );
+  }
+  //
+  // RATE KEEPER CONFIG
+  //
+  async updateRateKeeper(pool, args) {
+    return this.createRawTx({
+      functionName: "updateRateKeeper",
+      args: [pool, args.deployParams]
+    });
+  }
+  configureRateKeeper(pool, calldata) {
+    return this.createRawTx({
+      functionName: "configureRateKeeper",
+      args: [pool, calldata]
+    });
+  }
+  //
+  // LOSS POLICY CONFIG
+  //
+  configureLossPolicy(pool, calldata) {
+    return this.createRawTx({
+      functionName: "configureLossPolicy",
+      args: [pool, calldata]
+    });
+  }
+  updateLossPolicy(pool, deployParams) {
+    return this.createRawTx({
+      functionName: "updateLossPolicy",
+      args: [pool, deployParams]
+    });
+  }
+  enableLossPolicy(pool) {
+    return this.createRawTx({
+      functionName: "configureLossPolicy",
+      args: [
+        pool,
+        (0, import_viem.encodeFunctionData)({
+          abi: (0, import_viem.parseAbi)(["function enable() external"]),
+          functionName: "enable"
+        })
+      ]
+    });
+  }
+  disableLossPolicy(pool) {
+    return this.createRawTx({
+      functionName: "configureLossPolicy",
+      args: [
+        pool,
+        (0, import_viem.encodeFunctionData)({
+          abi: (0, import_viem.parseAbi)(["function disable() external"]),
+          functionName: "disable"
+        })
+      ]
+    });
+  }
+  //
+  // ROLES
+  //
+  async treasury() {
+    return await this.contract.read.treasury();
+  }
+  async admins() {
+    const [admin, emergencyAdmin, treasury, acl] = await Promise.all([
+      this.contract.read.admin(),
+      this.contract.read.emergencyAdmin(),
+      this.contract.read.treasury(),
+      this.contract.read.acl()
+    ]);
+    const results = await this.client.multicall({
+      allowFailure: false,
+      contracts: [
+        {
+          address: acl,
+          abi: (0, import_viem.parseAbi)([
+            "function getRoleHolders(bytes32) view returns (address[])"
+          ]),
+          functionName: "getRoleHolders",
+          args: [(0, import_viem.stringToHex)("PAUSABLE_ADMIN", { size: 32 })]
+        },
+        {
+          address: acl,
+          abi: (0, import_viem.parseAbi)([
+            "function getRoleHolders(bytes32) view returns (address[])"
+          ]),
+          functionName: "getRoleHolders",
+          args: [(0, import_viem.stringToHex)("UNPAUSABLE_ADMIN", { size: 32 })]
+        }
+      ]
+    });
+    return {
+      admin,
+      emergencyAdmin,
+      treasury,
+      pausableAdmins: [...results[0]],
+      unpausableAdmins: [...results[1]]
+    };
+  }
+  async multipause() {
+    const acl = await this.contract.read.acl();
+    const pausableAdmins = await this.client.readContract({
+      address: acl,
+      abi: (0, import_viem.parseAbi)([
+        "function getRoleHolders(bytes32) view returns (address[])"
+      ]),
+      functionName: "getRoleHolders",
+      args: [(0, import_viem.stringToHex)("PAUSABLE_ADMIN", { size: 32 })]
+    });
+    try {
+      const result = await this.client.multicall({
+        allowFailure: true,
+        contracts: pausableAdmins.map((admin) => ({
+          address: admin,
+          abi: (0, import_viem.parseAbi)(["function contractType() view returns (bytes32)"]),
+          functionName: "contractType"
+        }))
+      });
+      const pause = result.map((r, i) => ({
+        ...r,
+        address: pausableAdmins[i]
+      })).find(({ status, result: result2 }) => {
+        try {
+          return status === "success" && (0, import_viem.hexToString)(result2, { size: 32 }) === "MULTI_PAUSE";
+        } catch {
+          return false;
+        }
+      });
+      return pause?.address;
+    } catch {
+      return void 0;
+    }
+  }
+  grantRole(role, address) {
+    return this.createRawTx({
+      functionName: "grantRole",
+      args: [(0, import_viem.stringToHex)(role, { size: 32 }), address]
+    });
+  }
+  //
+  // SYNC
+  //
+  async syncSetEmergencyAdmin(fromBlock, toBlock) {
+    const events = await this.getEvents(
+      "SetEmergencyAdmin",
+      fromBlock,
+      toBlock
+    );
+    return (events || []).map((event) => ({
+      emergencyAdmin: event.args.newEmergencyAdmin,
+      atBlock: Number(event.blockNumber)
+    })).filter((event) => event.emergencyAdmin !== void 0);
+  }
+  async syncMarkets({
+    fromBlock,
+    toBlock
+  }) {
+    const events = await this.getEvents("CreateMarket", fromBlock, toBlock);
+    const _chainId = await this.client.getChainId();
+    const markets = [];
+    for (const event of events) {
+      const pool = event.args.pool;
+      const [underlyingAsset, name, symbol] = await Promise.all([
+        this.client.readContract({
+          address: pool,
+          abi: import_viem.erc4626Abi,
+          functionName: "asset"
+        }),
+        this.client.readContract({
+          address: pool,
+          abi: import_viem.erc20Abi,
+          functionName: "name"
+        }),
+        this.client.readContract({
+          address: pool,
+          abi: import_viem.erc20Abi,
+          functionName: "symbol"
+        })
+      ]);
+      markets.push({
+        address: pool,
+        underlyingAsset,
+        name,
+        symbol,
+        isDeployed: true
+      });
+    }
+    return markets;
+  }
+  parseFunctionParams(params) {
+    const { functionName, args } = params;
+    switch (functionName) {
+      case "createMarket": {
+        const [
+          minorVersion,
+          underlying,
+          name,
+          symbol,
+          interestRateModelParams,
+          rateKeeperParams,
+          lossPolicyParams,
+          underlyingPriceFeed
+        ] = args;
+        const irmParsedPostfix = (0, import_viem.hexToString)(
+          interestRateModelParams.postfix
+        ).replace(/\0/g, "");
+        const irmParsedParams = (0, import_plugins.parseIrmDeployParams)(
+          irmParsedPostfix,
+          Number(minorVersion),
+          interestRateModelParams.constructorParams
+        );
+        const rateKeeperParsedPostfix = (0, import_viem.hexToString)(
+          rateKeeperParams.postfix
+        ).replace(/\0/g, "");
+        const rateKeeperParsedParams = (0, import_plugins.parseRateKeeperDeployParams)(
+          rateKeeperParsedPostfix,
+          Number(minorVersion),
+          rateKeeperParams.constructorParams
+        );
+        const lossPolicyParsedPostfix = (0, import_viem.hexToString)(
+          lossPolicyParams.postfix
+        ).replace(/\0/g, "");
+        const lossPolicyParsedParams = (0, import_plugins.parseLossPolicyDeployParams)(
+          lossPolicyParsedPostfix,
+          Number(minorVersion),
+          lossPolicyParams.constructorParams
+        );
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            minorVersion: minorVersion.toString(),
+            underlying,
+            name,
+            symbol,
+            interestRateModelParams: (0, import_utils.json_stringify)({
+              postfix: irmParsedPostfix,
+              salt: interestRateModelParams.salt,
+              constructorParams: irmParsedParams
+            }),
+            rateKeeperParams: (0, import_utils.json_stringify)({
+              postfix: rateKeeperParsedPostfix,
+              salt: rateKeeperParams.salt,
+              constructorParams: rateKeeperParsedParams
+            }),
+            lossPolicyParams: (0, import_utils.json_stringify)({
+              postfix: lossPolicyParsedPostfix,
+              salt: lossPolicyParams.salt,
+              constructorParams: lossPolicyParsedParams
+            }),
+            underlyingPriceFeed
+          }
+        };
+      }
+      case "createCreditSuite": {
+        const [minorVersion, pool, creditSuiteParams] = args;
+        const decoded = (0, import_viem.decodeAbiParameters)(
+          [import_creditSuiteParams.creditManagerParamsAbi, import_creditSuiteParams.creditFacadeParamsAbi],
+          creditSuiteParams
+        );
+        const accountFactoryParams = decoded[0].accountFactoryParams;
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            minorVersion: minorVersion.toString(),
+            pool,
+            creditSuiteParams: (0, import_utils.json_stringify)({
+              ...decoded[0],
+              minDebt: decoded[0].minDebt.toString(),
+              maxDebt: decoded[0].maxDebt.toString(),
+              accountFactoryParams: {
+                postfix: (0, import_viem.hexToString)(accountFactoryParams.postfix).replace(
+                  /\0/g,
+                  ""
+                ),
+                salt: accountFactoryParams.salt,
+                // TODO: tmp solution, move AccountFactory decoding to plugins
+                constructorParams: {
+                  addressProvider: (0, import_viem.decodeAbiParameters)(
+                    [{ type: "address" }],
+                    accountFactoryParams.constructorParams
+                  )[0]
+                }
+              }
+            })
+          }
+        };
+      }
+      case "configurePriceOracle": {
+        const [pool, config] = args;
+        const decoded = this.priceOracleFactory.decodeConfig(config);
+        if (decoded) {
+          return {
+            chainId: 0,
+            target: this.address,
+            label: this.name,
+            functionName,
+            args: {
+              pool,
+              data: (0, import_utils.json_stringify)(decoded)
+            }
+          };
+        }
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            pool,
+            config
+          }
+        };
+      }
+      case "configurePool": {
+        const [pool, calldata] = args;
+        const decoded = this.poolFactory.decodeConfig(calldata);
+        if (decoded) {
+          return {
+            chainId: 0,
+            target: this.address,
+            label: this.name,
+            functionName,
+            args: {
+              pool,
+              data: (0, import_utils.json_stringify)(decoded)
+            }
+          };
+        }
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            pool,
+            calldata
+          }
+        };
+      }
+      case "configureCreditSuite": {
+        const [creditManager, calldata] = args;
+        const decoded = this.creditFactory.decodeConfig(calldata);
+        if (decoded) {
+          return {
+            chainId: 0,
+            target: this.address,
+            label: this.name,
+            functionName,
+            args: {
+              creditManager,
+              data: (0, import_utils.json_stringify)(decoded)
+            }
+          };
+        }
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            creditManager,
+            calldata
+          }
+        };
+      }
+      case "updateInterestRateModel": {
+        const [pool, deployParams] = args;
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            pool,
+            deployParams: (0, import_utils.json_stringify)(deployParams)
+          }
+        };
+      }
+      case "updateRateKeeper": {
+        const [pool, deployParams] = args;
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            pool,
+            deployParams: (0, import_utils.json_stringify)(deployParams)
+          }
+        };
+      }
+      case "updateLossPolicy": {
+        const [pool, deployParams] = args;
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            pool,
+            deployParams: (0, import_utils.json_stringify)(deployParams)
+          }
+        };
+      }
+      case "grantRole": {
+        const [role, address] = args;
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            address,
+            role: (0, import_viem.hexToString)(role, { size: 32 })
+          }
+        };
+      }
+      default:
+        return void 0;
+    }
+  }
+  //
+  // EMERGENCY CONFIG
+  //
+  emergencyConfigurePool(pool, calldata) {
+    return this.createRawTx({
+      functionName: "emergencyConfigurePool",
+      args: [pool, calldata]
+    });
+  }
+  emergencyConfigureCreditSuite(creditManager, calldata) {
+    return this.createRawTx({
+      functionName: "emergencyConfigureCreditSuite",
+      args: [creditManager, calldata]
+    });
+  }
+  emergencyConfigurePriceOracle(pool, calldata) {
+    return this.createRawTx({
+      functionName: "emergencyConfigurePriceOracle",
+      args: [pool, calldata]
+    });
+  }
+  emergencyConfigureLossPolicy(pool, calldata) {
+    return this.createRawTx({
+      functionName: "emergencyConfigureLossPolicy",
+      args: [pool, calldata]
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MarketConfiguratorContract
+});