@gearbox-protocol/sdk 9.14.1 → 9.15.0

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

@@ -0,0 +1,336 @@
+import {
+  parseAbi,
+  parseEventLogs,
+  recoverTypedDataAddress,
+  zeroAddress
+} from "viem";
+import { crossChainMultisigAbi } from "../../abi/310/crossChainMultisig.js";
+import { json_stringify } from "../../sdk/utils/index.js";
+import { Addresses } from "../deployment/addresses";
+import { normalizeSignature } from "../utils";
+import { CROSS_CHAIN_MULTISIG } from "../utils/literals";
+import { BaseContract } from "./base-contract";
+import { InstanceManagerContract } from "./instance-manager";
+import { MarketConfiguratorFactoryContract } from "./market-configurator-factory";
+const abi = crossChainMultisigAbi;
+class CrossChainMultisigContract extends 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 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) => BaseContract.parseCall(c)),
+      signatures
+    };
+  }
+  computeEIP712digest(name, batchHash, prevHash) {
+    return {
+      domain: {
+        name: 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: 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 = 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) => 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 Addresses.INSTANCE_MANAGER.toLowerCase(): {
+        const instanceManager = new InstanceManagerContract(
+          target,
+          this.client
+        );
+        return instanceManager.parseFunctionData(calldata);
+      }
+      default: {
+        try {
+          let parsedData;
+          const marketConfiguratorFactory = new 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: 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 = 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 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 = zeroAddress;
+    parseEventLogs({
+      abi: 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
+    };
+  }
+}
+export {
+  CrossChainMultisigContract
+};

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

@@ -0,0 +1,28 @@
+import { createCallData } from "../../core/raw-tx";
+import { decodeFunctionWithNamedArgs } from "../../utils/abi-decoder";
+class AbstractFactory {
+  abi;
+  constructor(abi) {
+    this.abi = abi;
+  }
+  createCallData(parameters) {
+    const callData = 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 = decodeFunctionWithNamedArgs(this.abi, calldata);
+    if (!decoded) return null;
+    return {
+      functionName: decoded.functionName,
+      args: decoded.args
+    };
+  }
+}
+export {
+  AbstractFactory
+};

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

@@ -0,0 +1,177 @@
+import { decodeFunctionData, hexToString } from "viem";
+import { iCreditConfigureActionsAbi } from "../../../abi/310/configure/iCreditConfigureActions.js";
+import {
+  adapterConstructorAbi,
+  parseAdapterAction,
+  parseAdapterDeployParams
+} from "../../../plugins/adapters/index.js";
+import { AbstractFactory } from "./abstract-factory";
+const abi = iCreditConfigureActionsAbi;
+class CreditFactory extends 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(
+        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 parseAdapterDeployParams(adapterPostfix, version, data);
+      } catch {
+        const v = getMaxVerBelowN(adapterPostfix, version);
+        if (v) return parseAdapterParams(adapterPostfix, v, data);
+        else return null;
+      }
+    }
+    try {
+      const decoded = decodeFunctionData({
+        abi: this.abi,
+        data: calldata
+      });
+      if (decoded.functionName === "allowAdapter") {
+        const deployParams = decoded.args[0];
+        const adapterType = hexToString(deployParams.postfix, {
+          size: 32
+        });
+        const latest = Math.max(
+          ...Object.keys(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 = parseAdapterAction(data);
+        if (!adapterAction) {
+          return super.decodeConfig(calldata);
+        }
+        return {
+          functionName: "configureAdapterFor",
+          args: {
+            targetContract,
+            adapterAction: JSON.stringify(adapterAction)
+          }
+        };
+      }
+      return super.decodeConfig(calldata);
+    } catch {
+      return null;
+    }
+  }
+}
+export {
+  CreditFactory
+};

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

@@ -0,0 +1,45 @@
+import { iPoolConfigureActionsAbi } from "../../../abi/310/configure/iPoolConfigureActions.js";
+import { AbstractFactory } from "./abstract-factory";
+const abi = iPoolConfigureActionsAbi;
+class PoolFactory extends 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]
+    });
+  }
+}
+export {
+  PoolFactory
+};

package/dist/esm/permissionless/bindings/factory/price-oracle-factory.js

@@ -0,0 +1,23 @@
+import { iPriceOracleConfigureActionsAbi } from "../../../abi/310/configure/iPriceOracleConfigureActions.js";
+import { AbstractFactory } from "./abstract-factory";
+const abi = iPriceOracleConfigureActionsAbi;
+class PriceOracleFactory extends 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]
+    });
+  }
+}
+export {
+  PriceOracleFactory
+};

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

@@ -0,0 +1,17 @@
+import { batchesChainAbi } from "../../../abi/governance/batchesChain.js";
+import { BaseContract } from "../base-contract";
+const abi = batchesChainAbi;
+class BatchesChainContract extends BaseContract {
+  constructor(address, client) {
+    super(abi, address, client, "BatchesChain");
+  }
+  createBatchOrderingTx(prevHash) {
+    return this.createRawTx({
+      functionName: "revertIfQueued",
+      args: [prevHash]
+    });
+  }
+}
+export {
+  BatchesChainContract
+};