@gearbox-protocol/sdk 9.14.1 → 9.15.0

package/dist/cjs/permissionless/bindings/compressors/withdrawal-compressor.js

@@ -0,0 +1,60 @@
+"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 withdrawal_compressor_exports = {};
+__export(withdrawal_compressor_exports, {
+  WithdrawalCompressorContract: () => WithdrawalCompressorContract
+});
+module.exports = __toCommonJS(withdrawal_compressor_exports);
+var import_viem = require("viem");
+var import_withdrawalCompressor = require("../../../abi/compressors/withdrawalCompressor.js");
+var import_base_contract = require("../base-contract");
+const abi = import_withdrawalCompressor.withdrawalCompressorAbi;
+class WithdrawalCompressorContract extends import_base_contract.BaseContract {
+  constructor(address, client) {
+    super(abi, address, client, "RoutingManager");
+  }
+  parseFunctionParams(params) {
+    const { functionName, args } = params;
+    switch (functionName) {
+      case "setWithdrawableTypeToCompressorType": {
+        const [withdrawableType, compressorType] = args;
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            withdrawableType: (0, import_viem.hexToString)(withdrawableType, {
+              size: 32
+            }),
+            compressorType: (0, import_viem.hexToString)(compressorType, {
+              size: 32
+            })
+          }
+        };
+      }
+      default:
+        return void 0;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WithdrawalCompressorContract
+});

package/dist/cjs/permissionless/bindings/cross-chain-multisig.js

@@ -0,0 +1,355 @@
+"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 cross_chain_multisig_exports = {};
+__export(cross_chain_multisig_exports, {
+  CrossChainMultisigContract: () => CrossChainMultisigContract
+});
+module.exports = __toCommonJS(cross_chain_multisig_exports);
+var import_viem = require("viem");
+var import_crossChainMultisig = require("../../abi/310/crossChainMultisig.js");
+var import_utils = require("../../sdk/utils/index.js");
+var import_addresses = require("../deployment/addresses");
+var import_utils2 = require("../utils");
+var import_literals = require("../utils/literals");
+var import_base_contract = require("./base-contract");
+var import_instance_manager = require("./instance-manager");
+var import_market_configurator_factory = require("./market-configurator-factory");
+const abi = import_crossChainMultisig.crossChainMultisigAbi;
+class CrossChainMultisigContract extends import_base_contract.BaseContract {
+  constructor(address, client) {
+    super(abi, address, client, "CrossChainMultisig");
+  }
+  async getExecutedBatches(fromBlock, toBlock) {
+    const events = await this.getEvents("ExecuteBatch", fromBlock, toBlock);
+    const batches = await Promise.all(
+      events.map(async (event) => {
+        return this.getBatchData({
+          proposalHash: event.args.batchHash,
+          blockNumber: Number(event.blockNumber),
+          transactionHash: event.transactionHash
+        });
+      })
+    );
+    return batches;
+  }
+  async getCurrentBatches() {
+    const hashes = await this.contract.read.getCurrentBatchHashes();
+    return await Promise.all(
+      hashes.map(async (hash) => this.getBatchData({ proposalHash: hash }))
+    );
+  }
+  async getBatchData(args) {
+    const { proposalHash, blockNumber, transactionHash, timestamp } = args;
+    const proposal = await this.contract.read.getBatch([args.proposalHash]);
+    const signatures = [];
+    for (const sig of proposal.signatures) {
+      const recoveredSigner = await (0, import_viem.recoverTypedDataAddress)({
+        ...this.computeEIP712digest(
+          proposal.name,
+          proposalHash,
+          proposal.prevHash
+        ),
+        signature: sig
+      });
+      signatures.push({
+        signer: recoveredSigner,
+        signature: sig
+      });
+    }
+    const calls = proposal.calls.map((c) => ({
+      chainId: Number(c.chainId),
+      target: c.target,
+      callData: c.callData
+    }));
+    return {
+      ...proposal,
+      calls,
+      timestamp,
+      transactionHash,
+      blockNumber,
+      hash: proposalHash,
+      parsedCalls: calls.map((c) => import_base_contract.BaseContract.parseCall(c)),
+      signatures
+    };
+  }
+  computeEIP712digest(name, batchHash, prevHash) {
+    return {
+      domain: {
+        name: import_literals.CROSS_CHAIN_MULTISIG,
+        version: "310",
+        chainId: 1,
+        verifyingContract: this.address
+      },
+      types: {
+        CompactBatch: [
+          { name: "name", type: "string" },
+          { name: "batchHash", type: "bytes32" },
+          { name: "prevHash", type: "bytes32" }
+        ]
+      },
+      primaryType: "CompactBatch",
+      message: {
+        name,
+        batchHash,
+        prevHash
+      }
+    };
+  }
+  computeRecoveryDigest(chainId, startingBatchHash) {
+    return {
+      domain: {
+        name: import_literals.CROSS_CHAIN_MULTISIG,
+        version: "310",
+        chainId: 1,
+        verifyingContract: this.address
+      },
+      types: {
+        RecoveryMode: [
+          { name: "chainId", type: "uint256" },
+          { name: "startingBatchHash", type: "bytes32" }
+        ]
+      },
+      primaryType: "RecoveryMode",
+      message: {
+        chainId: BigInt(chainId),
+        startingBatchHash
+      }
+    };
+  }
+  // signCompactBatchTypeData(name: string, batchHash: Hex, prevHash: Hex) {
+  //   const typedData = this.computeEIP712digest(name, batchHash, prevHash);
+  //   return {
+  //     domain: typedData.domain,
+  //     types: typedData.types,
+  //     primaryType: typedData.primaryType,
+  //     message: typedData.message,
+  //   };
+  // }
+  async signBatch(batchHash, signature, sponsor) {
+    const normalizedSignature = (0, import_utils2.normalizeSignature)(signature);
+    const hash = await this.contract.write.signBatch(
+      [batchHash, normalizedSignature],
+      {
+        account: sponsor.account,
+        chain: sponsor.chain
+      }
+    );
+    return hash;
+  }
+  async enableRecovery(recovery, sponsor) {
+    const signatures = recovery.signatures.map(
+      (s) => (0, import_utils2.normalizeSignature)(s.signature)
+    );
+    return await this.contract.write.enableRecoveryMode(
+      [
+        {
+          chainId: BigInt(recovery.chainId),
+          startingBatchHash: recovery.startingBatchHash,
+          signatures
+        }
+      ],
+      {
+        account: sponsor.account,
+        chain: sponsor.chain
+      }
+    );
+  }
+  async getConfirmationThreshold() {
+    return await this.contract.read.confirmationThreshold();
+  }
+  async getSigners() {
+    return [...await this.contract.read.getSigners()];
+  }
+  decodeFunctionData(target, calldata) {
+    switch (target.toLowerCase()) {
+      case this.address.toLowerCase(): {
+        return this.parseFunctionData(calldata);
+      }
+      case import_addresses.Addresses.INSTANCE_MANAGER.toLowerCase(): {
+        const instanceManager = new import_instance_manager.InstanceManagerContract(
+          target,
+          this.client
+        );
+        return instanceManager.parseFunctionData(calldata);
+      }
+      default: {
+        try {
+          let parsedData;
+          const marketConfiguratorFactory = new import_market_configurator_factory.MarketConfiguratorFactoryContract(target, this.client);
+          parsedData = marketConfiguratorFactory.parseFunctionData(calldata);
+          if (!parsedData.functionName.startsWith("Unknown function")) {
+            return parsedData;
+          }
+        } catch {
+          return void 0;
+        }
+      }
+    }
+  }
+  parseFunctionParams(params) {
+    switch (params.functionName) {
+      case "addSigner": {
+        const [signer] = params.args;
+        return this.wrapParseCall(params, {
+          signer
+        });
+      }
+      case "removeSigner": {
+        const [signer] = params.args;
+        return this.wrapParseCall(params, {
+          signer
+        });
+      }
+      case "setConfirmationThreshold": {
+        const [threshold] = params.args;
+        return this.wrapParseCall(params, {
+          threshold: threshold.toString()
+        });
+      }
+      case "submitBatch": {
+        const [name, calls, prevHash] = params.args;
+        return this.wrapParseCall(params, {
+          name,
+          calls: (0, import_utils.json_stringify)(
+            calls.map(({ chainId, target, callData }) => ({
+              ...this.decodeFunctionData(target, callData),
+              chainId: Number(chainId),
+              target
+            }))
+          ),
+          prevHash
+        });
+      }
+      default:
+        return void 0;
+    }
+  }
+  async validateProposalSignature(proposalHash, signature) {
+    const normalizedSignature = (0, import_utils2.normalizeSignature)(signature);
+    const proposal = await this.getBatchData({ proposalHash });
+    const currentPrevHash = await this.contract.read.lastBatchHash();
+    if (proposal.prevHash !== currentPrevHash) {
+      return { success: false, error: "Proposal is not the latest" };
+    }
+    const signer = await this.getSignerFromSignature(
+      proposal.name,
+      proposalHash,
+      proposal.prevHash,
+      normalizedSignature
+    );
+    console.log("signer", signer);
+    const signers = await this.getSigners();
+    if (!signers.map((s) => s.toLowerCase()).includes(signer.toLowerCase())) {
+      return { success: false, error: "Signer is not a valid signer" };
+    }
+    const threshold = await this.getConfirmationThreshold();
+    if (proposal.signatures.length >= threshold) {
+      return { success: false, error: "Proposal has enough signatures" };
+    }
+    return { success: true };
+  }
+  async getSignerFromSignature(proposalName, proposalHash, prevHash, signature) {
+    return await (0, import_viem.recoverTypedDataAddress)({
+      ...this.computeEIP712digest(proposalName, proposalHash, prevHash),
+      signature
+    });
+  }
+  async executeProposal(signedProposal, sponsor) {
+    return await this.contract.write.executeBatch([signedProposal], {
+      account: sponsor.account,
+      chain: sponsor.chain
+    });
+  }
+  wrapSubmitBatch(args) {
+    const { proposal, prevHash } = args;
+    return this.createRawTx({
+      functionName: "submitBatch",
+      args: [proposal.name, proposal.calls, prevHash],
+      description: `CrossChainMultisig.submitBatch(${proposal.name})`
+    });
+  }
+  executeProposalTx(signedProposal) {
+    return this.createRawTx({
+      functionName: "executeBatch",
+      args: [signedProposal]
+    });
+  }
+  async submitBatch(proposal, sponsor) {
+    const prevHash = await this.getLastBatchHash();
+    return await this.contract.write.submitBatch(
+      [proposal.name, proposal.calls, prevHash],
+      {
+        account: sponsor.account,
+        chain: sponsor.chain
+      }
+    );
+  }
+  async getLastBatchHash() {
+    return await this.contract.read.lastBatchHash();
+  }
+  async computeBatchHash(args) {
+    const { proposal, prevHash } = args;
+    return await this.contract.read.computeBatchHash([
+      proposal.name,
+      proposal.calls,
+      prevHash
+    ]);
+  }
+  async getConstructorParams() {
+    const latestBlock = await this.client.getBlockNumber();
+    const result = await this.getEvents(
+      "SetConfirmationThreshold",
+      0n,
+      latestBlock
+    );
+    const event = result[0];
+    const threshold = event.args.newConfirmationThreshold;
+    const receipt = await this.client.getTransactionReceipt({
+      hash: event.transactionHash
+    });
+    const signers = [];
+    let dao = import_viem.zeroAddress;
+    (0, import_viem.parseEventLogs)({
+      abi: (0, import_viem.parseAbi)([
+        "event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)",
+        "event AddSigner(address indexed signer)"
+      ]),
+      logs: receipt.logs
+    }).forEach((p) => {
+      if (p.eventName === "AddSigner") {
+        signers.push(p.args.signer);
+      }
+      if (p.eventName === "OwnershipTransferred") {
+        dao = p.args.newOwner;
+      }
+    });
+    console.log("signers", signers);
+    console.log("threshold", threshold);
+    console.log("dao", dao);
+    return {
+      signers,
+      threshold,
+      dao
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CrossChainMultisigContract
+});

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

@@ -0,0 +1,52 @@
+"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 abstract_factory_exports = {};
+__export(abstract_factory_exports, {
+  AbstractFactory: () => AbstractFactory
+});
+module.exports = __toCommonJS(abstract_factory_exports);
+var import_raw_tx = require("../../core/raw-tx");
+var import_abi_decoder = require("../../utils/abi-decoder");
+class AbstractFactory {
+  abi;
+  constructor(abi) {
+    this.abi = abi;
+  }
+  createCallData(parameters) {
+    const callData = (0, import_raw_tx.createCallData)(this.abi, parameters);
+    return callData;
+  }
+  /**
+   * Decodes configuration calldata using the ABI
+   * @param calldata - The encoded function call data
+   * @returns Decoded function name and arguments, or null if decoding fails
+   */
+  decodeConfig(calldata) {
+    const decoded = (0, import_abi_decoder.decodeFunctionWithNamedArgs)(this.abi, calldata);
+    if (!decoded) return null;
+    return {
+      functionName: decoded.functionName,
+      args: decoded.args
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbstractFactory
+});

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

@@ -0,0 +1,197 @@
+"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 credit_factory_exports = {};
+__export(credit_factory_exports, {
+  CreditFactory: () => CreditFactory
+});
+module.exports = __toCommonJS(credit_factory_exports);
+var import_viem = require("viem");
+var import_iCreditConfigureActions = require("../../../abi/310/configure/iCreditConfigureActions.js");
+var import_adapters = require("../../../plugins/adapters/index.js");
+var import_abstract_factory = require("./abstract-factory");
+const abi = import_iCreditConfigureActions.iCreditConfigureActionsAbi;
+class CreditFactory extends import_abstract_factory.AbstractFactory {
+  constructor() {
+    super(abi);
+  }
+  pause() {
+    return this.createCallData({
+      functionName: "pause"
+    });
+  }
+  unpause() {
+    return this.createCallData({
+      functionName: "unpause"
+    });
+  }
+  addCollateralToken(args) {
+    return this.createCallData({
+      functionName: "addCollateralToken",
+      args: [args.token, args.liquidationThreshold]
+    });
+  }
+  allowAdapter(deployParams) {
+    return this.createCallData({
+      functionName: "allowAdapter",
+      args: [deployParams]
+    });
+  }
+  allowToken(token) {
+    return this.createCallData({
+      functionName: "allowToken",
+      args: [token]
+    });
+  }
+  forbidToken(token) {
+    return this.createCallData({
+      functionName: "forbidToken",
+      args: [token]
+    });
+  }
+  configureAdapterFor(targetContract, data) {
+    return this.createCallData({
+      functionName: "configureAdapterFor",
+      args: [targetContract, data]
+    });
+  }
+  forbidAdapter(adapter) {
+    return this.createCallData({
+      functionName: "forbidAdapter",
+      args: [adapter]
+    });
+  }
+  rampLiquidationThreshold(args) {
+    return this.createCallData({
+      functionName: "rampLiquidationThreshold",
+      args: [
+        args.token,
+        args.liquidationThresholdFinal,
+        args.rampStart,
+        args.rampDuration
+      ]
+    });
+  }
+  setExpirationDate(params) {
+    return this.createCallData({
+      functionName: "setExpirationDate",
+      args: [params.expirationDate]
+    });
+  }
+  setFees(params) {
+    return this.createCallData({
+      functionName: "setFees",
+      args: [
+        params.params.feeLiquidation,
+        params.params.feeLiquidationPremium,
+        params.params.feeLiquidationExpired,
+        params.params.feeLiquidationPremiumExpired
+      ]
+    });
+  }
+  setMaxDebtPerBlockMultiplier(newMaxDebtLimitPerBlockMultiplier) {
+    return this.createCallData({
+      functionName: "setMaxDebtPerBlockMultiplier",
+      args: [newMaxDebtLimitPerBlockMultiplier]
+    });
+  }
+  upgradeCreditConfigurator() {
+    return this.createCallData({
+      functionName: "upgradeCreditConfigurator"
+    });
+  }
+  upgradeCreditFacade(params) {
+    return this.createCallData({
+      functionName: "upgradeCreditFacade",
+      args: [params]
+    });
+  }
+  decodeConfig(calldata) {
+    function getMaxVerBelowN(adapterPostfix, n) {
+      const keys = Object.keys(
+        import_adapters.adapterConstructorAbi[adapterPostfix]
+      ).map(Number).filter((k) => k < n);
+      if (keys.length === 0) return void 0;
+      return Math.max(...keys);
+    }
+    function parseAdapterParams(adapterPostfix, version, data) {
+      if (version < 310) return null;
+      try {
+        return (0, import_adapters.parseAdapterDeployParams)(adapterPostfix, version, data);
+      } catch {
+        const v = getMaxVerBelowN(adapterPostfix, version);
+        if (v) return parseAdapterParams(adapterPostfix, v, data);
+        else return null;
+      }
+    }
+    try {
+      const decoded = (0, import_viem.decodeFunctionData)({
+        abi: this.abi,
+        data: calldata
+      });
+      if (decoded.functionName === "allowAdapter") {
+        const deployParams = decoded.args[0];
+        const adapterType = (0, import_viem.hexToString)(deployParams.postfix, {
+          size: 32
+        });
+        const latest = Math.max(
+          ...Object.keys(import_adapters.adapterConstructorAbi[adapterType]).map(
+            Number
+          )
+        );
+        const constructorArgs = parseAdapterParams(
+          adapterType,
+          latest,
+          deployParams.constructorParams
+        );
+        if (!constructorArgs) {
+          return super.decodeConfig(calldata);
+        }
+        return {
+          functionName: "allowAdapter",
+          args: {
+            adapterType,
+            salt: deployParams.salt,
+            constructorArgs: JSON.stringify(constructorArgs)
+          }
+        };
+      }
+      if (decoded.functionName === "configureAdapterFor") {
+        const [targetContract, data] = decoded.args;
+        const adapterAction = (0, import_adapters.parseAdapterAction)(data);
+        if (!adapterAction) {
+          return super.decodeConfig(calldata);
+        }
+        return {
+          functionName: "configureAdapterFor",
+          args: {
+            targetContract,
+            adapterAction: JSON.stringify(adapterAction)
+          }
+        };
+      }
+      return super.decodeConfig(calldata);
+    } catch {
+      return null;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreditFactory
+});