@gearbox-protocol/sdk 9.14.1 → 9.15.1

package/dist/esm/permissionless/bindings/compressors/token-compressor.js

@@ -0,0 +1,89 @@
+import {
+  erc20Abi,
+  parseAbi
+} from "viem";
+import { tokenCompressorAbi } from "../../../abi/compressors/tokenCompressor.js";
+import { BaseContract } from "../base-contract.js";
+const abi = tokenCompressorAbi;
+class TokenCompressorContract extends BaseContract {
+  constructor(address, client) {
+    super(abi, address, client, "TokenCompressor");
+  }
+  async getTokenInfo(token) {
+    const result = await this.contract.read.getTokenInfo([token]);
+    return result;
+  }
+  // @dev workaround for mellow withdrawal phantom token symbol
+  async getMellowWithdrawalPhantomTokenInfo(tokens) {
+    const abi2 = parseAbi([
+      "function multiVault() public view returns (address)"
+    ]);
+    const contracts = tokens.map((token) => ({
+      address: token,
+      abi: abi2,
+      functionName: "multiVault",
+      args: []
+    }));
+    const results = await this.client.multicall({
+      contracts
+    });
+    const multivaultToToken = /* @__PURE__ */ new Map();
+    const multivaults = [];
+    for (let i = 0; i < results.length; i++) {
+      if (results[i].status === "success") {
+        const token = tokens[i];
+        const multivault = results[i].result;
+        multivaultToToken.set(multivault, token);
+        multivaults.push(multivault);
+      }
+    }
+    const resultsSymbols = await this.client.multicall({
+      contracts: multivaults.map((multiVault) => ({
+        address: multiVault,
+        abi: erc20Abi,
+        functionName: "symbol",
+        args: []
+      })),
+      allowFailure: true
+    });
+    const tokenToSymbol = /* @__PURE__ */ new Map();
+    for (let i = 0; i < resultsSymbols.length; i++) {
+      if (resultsSymbols[i].status === "success") {
+        const multivault = multivaults[i];
+        const token = multivaultToToken.get(multivault);
+        if (token) {
+          tokenToSymbol.set(token, resultsSymbols[i].result);
+        }
+      }
+    }
+    return Object.fromEntries(tokenToSymbol);
+  }
+  async getTokensInfo(tokens) {
+    const mellowPTInfo = await this.getMellowWithdrawalPhantomTokenInfo(tokens);
+    const results = await this.client.multicall({
+      contracts: tokens.map((token) => ({
+        address: this.address,
+        abi,
+        functionName: "getTokenInfo",
+        args: [token]
+      }))
+    });
+    const tokenInfos = results.map((result, index) => {
+      if (result.status === "failure") {
+        throw new Error(`Failed to get token info: ${result.error}`);
+      }
+      const token = tokens[index];
+      const multivaultSymbol = mellowPTInfo[token];
+      const tokenInfo = result.result;
+      const postfix = multivaultSymbol ? `[${multivaultSymbol}]` : "";
+      return {
+        ...tokenInfo,
+        symbol: `${tokenInfo.symbol} ${postfix}`
+      };
+    });
+    return tokenInfos;
+  }
+}
+export {
+  TokenCompressorContract
+};

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

@@ -0,0 +1,38 @@
+import {
+  hexToString
+} from "viem";
+import { withdrawalCompressorAbi } from "../../../abi/compressors/withdrawalCompressor.js";
+import { BaseContract } from "../base-contract.js";
+const abi = withdrawalCompressorAbi;
+class WithdrawalCompressorContract extends 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: hexToString(withdrawableType, {
+              size: 32
+            }),
+            compressorType: hexToString(compressorType, {
+              size: 32
+            })
+          }
+        };
+      }
+      default:
+        return void 0;
+    }
+  }
+}
+export {
+  WithdrawalCompressorContract
+};

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.js";
+import { normalizeSignature } from "../utils/index.js";
+import { CROSS_CHAIN_MULTISIG } from "../utils/literals.js";
+import { BaseContract } from "./base-contract.js";
+import { InstanceManagerContract } from "./instance-manager.js";
+import { MarketConfiguratorFactoryContract } from "./market-configurator-factory.js";
+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.js";
+import { decodeFunctionWithNamedArgs } from "../../utils/abi-decoder.js";
+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.js";
+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.js";
+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
+};