@gearbox-protocol/sdk 9.14.1 → 9.15.0

package/dist/esm/permissionless/bindings/bytecode-repository.js

@@ -0,0 +1,508 @@
+import {
+  hashStruct,
+  hexToString,
+  parseEventLogs,
+  recoverTypedDataAddress,
+  stringToHex
+} from "viem";
+import { iBytecodeRepositoryAbi } from "../../abi/310/iBytecodeRepository.js";
+import { normalizeSignature } from "../utils";
+import { BYTECODE_REPOSITORY } from "../utils/literals";
+import { BaseContract } from "./base-contract";
+const abi = iBytecodeRepositoryAbi;
+class BytecodeRepositoryContract extends BaseContract {
+  constructor(address, client) {
+    super(abi, address, client, "BytecodeRepository");
+  }
+  async getBytecodeByHash(hash) {
+    return await this.contract.read.getBytecode([hash]);
+  }
+  async getAuditReports(hash) {
+    return await this.contract.read.getAuditReports([hash]);
+  }
+  async getPublicDomains() {
+    return await this.contract.read.getPublicDomains();
+  }
+  async isBytecodeUploaded(hash) {
+    return await this.contract.read.isBytecodeUploaded([hash]);
+  }
+  async isBytecodeAudited(hash) {
+    return await this.contract.read.isBytecodeAudited([hash]);
+  }
+  async getLatestVersion(type_) {
+    return await this.contract.read.getLatestVersion([
+      stringToHex(type_, { size: 32 })
+    ]);
+  }
+  async isPublicDomain(domain) {
+    return await this.contract.read.isPublicDomain([
+      stringToHex(domain, { size: 32 })
+    ]);
+  }
+  // // Write functions
+  // async uploadBytecode(bytecode: Bytecode) {
+  //   return await this.contract.write.uploadBytecode([bytecode]);
+  // }
+  async getUploadBytecodeEvents(fromBlock, toBlock, chunkSize) {
+    const events = await this.getEvents(
+      "UploadBytecode",
+      fromBlock,
+      toBlock,
+      void 0,
+      chunkSize
+    );
+    return events.map((e) => ({
+      bytecodeHash: e.args.bytecodeHash,
+      author: e.args.author,
+      version: Number(e.args.version),
+      contractType: e.args.contractType,
+      source: e.args.source,
+      initCode: "0x",
+      size: 0,
+      transactionHash: e.transactionHash,
+      blockNumber: Number(e.blockNumber)
+    }));
+  }
+  async getAddAuditorEvents(fromBlock, toBlock) {
+    const events = await this.getEvents("AddAuditor", fromBlock, toBlock);
+    const result = [];
+    for (const e of events) {
+      result.push({
+        address: e.args.auditor,
+        name: e.args.name,
+        removed: false,
+        removedAt: null,
+        addedAt: Number(e.blockNumber)
+      });
+    }
+    return result;
+  }
+  async getDeployContractEvents(fromBlock, toBlock) {
+    const events = await this.getEvents("DeployContract", fromBlock, toBlock);
+    const result = [];
+    for (const e of events) {
+      result.push({
+        address: e.args.contractAddress,
+        chainId: 1,
+        // BigInt(this.client.chain!.id!),
+        txHash: e.transactionHash,
+        blockNumber: Number(e.blockNumber),
+        bytecodeHash: e.args.bytecodeHash
+      });
+    }
+    return result;
+  }
+  async getAuditBytecodeEvents(fromBlock, toBlock) {
+    try {
+      const events = await this.getEvents("AuditBytecode", fromBlock, toBlock);
+      const result = [];
+      for (const e of events) {
+        result.push({
+          bytecodeHash: e.args.bytecodeHash,
+          auditor: e.args.auditor,
+          reportUrl: e.args.reportUrl,
+          signature: e.args.signature,
+          transactionHash: e.transactionHash,
+          blockNumber: Number(e.blockNumber)
+        });
+      }
+      return result;
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("query exceeds max block")) {
+        const middle = (fromBlock + toBlock) / 2n;
+        return [
+          ...await this.getAuditBytecodeEvents(fromBlock, middle),
+          ...await this.getAuditBytecodeEvents(middle + 1n, toBlock)
+        ];
+      }
+      throw e;
+    }
+  }
+  async getAllowPublicContractEvents(fromBlock, toBlock) {
+    const code = await this.client.getCode({ address: this.address });
+    if (code === void 0 || code === "0x") {
+      return [];
+    }
+    const publicDomains = await this.contract.read.getPublicDomains();
+    const publicDomainsString = publicDomains.map(
+      (domain) => hexToString(domain, { size: 32 })
+    );
+    const events = await this.getAllowContractEvents(fromBlock, toBlock);
+    return events.filter((e) => {
+      const contractTypeString = hexToString(e.contractType, { size: 32 });
+      return publicDomainsString.includes(
+        this.extractDomain(contractTypeString)
+      );
+    });
+  }
+  async getAllowContractEvents(fromBlock, toBlock) {
+    try {
+      const events = await this.getEvents("AllowContract", fromBlock, toBlock);
+      const result = [];
+      for (const e of events) {
+        result.push({
+          bytecodeHash: e.args.bytecodeHash,
+          contractType: e.args.contractType,
+          version: e.args.version,
+          transactionHash: e.transactionHash,
+          blockNumber: Number(e.blockNumber)
+        });
+      }
+      return result;
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("query exceeds max block")) {
+        const middle = (fromBlock + toBlock) / 2n;
+        return [
+          ...await this.getAllowContractEvents(fromBlock, middle),
+          ...await this.getAllowContractEvents(middle + 1n, toBlock)
+        ];
+      }
+      throw e;
+    }
+  }
+  async getUploadUpdates(fromBlock, toBlock) {
+    const events = await this.getUploadBytecodeEvents(fromBlock, toBlock);
+    const initCodes = await Promise.all(
+      events.map((event) => this.getBytecodeByHash(event.bytecodeHash))
+    );
+    events.forEach((event, index) => {
+      event.initCode = initCodes[index].initCode;
+      event.size = initCodes[index].initCode.length;
+    });
+    return events;
+  }
+  parseFunctionParams(params) {
+    switch (params.functionName) {
+      case "allowSystemContract": {
+        const [bytecodeHash] = params.args;
+        return this.wrapParseCall(params, {
+          bytecodeHash
+        });
+      }
+      case "addAuditor": {
+        const [auditor, name] = params.args;
+        return this.wrapParseCall(params, {
+          auditor,
+          name
+        });
+      }
+      case "removeAuditor": {
+        const [auditor] = params.args;
+        return this.wrapParseCall(params, {
+          auditor
+        });
+      }
+      case "addPublicDomain": {
+        const [domain] = params.args;
+        return this.wrapParseCall(params, {
+          domain: hexToString(domain, { size: 32 })
+        });
+      }
+      case "removePublicContractType": {
+        const [contractType] = params.args;
+        return this.wrapParseCall(params, {
+          contractType: hexToString(contractType, { size: 32 })
+        });
+      }
+      case "forbidInitCode": {
+        const [bytecodeHash] = params.args;
+        return this.wrapParseCall(params, {
+          bytecodeHash
+        });
+      }
+      case "setTokenSpecificPostfix": {
+        const [token, postfix] = params.args;
+        return this.wrapParseCall(params, {
+          token,
+          postfix: hexToString(postfix, { size: 32 })
+        });
+      }
+      case "uploadBytecode": {
+        const [uploadData] = params.args;
+        return this.wrapParseCall(params, {
+          contractType: hexToString(uploadData.contractType, { size: 32 }),
+          version: uploadData.version.toString(),
+          initCode: uploadData.initCode,
+          author: uploadData.author,
+          source: uploadData.source,
+          authorSignature: uploadData.authorSignature
+        });
+      }
+      case "submitAuditReport": {
+        const [bytecodeHash, { auditor, reportUrl, signature }] = params.args;
+        return this.wrapParseCall(params, {
+          bytecodeHash,
+          auditor,
+          reportUrl,
+          signature
+        });
+      }
+      // TODO: add all functions here!
+      // case "deployContract": {
+      //   const [contractType, version, encodedParams, salt, owner] = params.args;
+      //   return this.wrapParseCall(params, {
+      //     contractType: hexToString(contractType, { size: 32 }),
+      //     version: version.toString(),
+      //     encodedParams,
+      //     salt,
+      //     owner,
+      //   });
+      // }
+      // case "setContractTypeVersion": {
+      //   const [contractType, version] = params.args;
+      //   return this.wrapParseCall(params, {
+      //     contractType: hexToString(contractType, { size: 32 }),
+      //     version: version.toString(),
+      //   });
+      // }
+      default:
+        return void 0;
+    }
+  }
+  async signBytecodeHash(bytecodeHash, auditor, reportUrl, signature, sponsor) {
+    return await this.contract.write.submitAuditReport(
+      [bytecodeHash, { auditor, reportUrl, signature }],
+      {
+        account: sponsor.account,
+        chain: sponsor.chain
+      }
+    );
+  }
+  signBytecodeHashTx(bytecodeHash, auditor, reportUrl, signature) {
+    const normalizedSignature = normalizeSignature(signature);
+    return this.createRawTx({
+      functionName: "submitAuditReport",
+      args: [
+        bytecodeHash,
+        { auditor, reportUrl, signature: normalizedSignature }
+      ]
+    });
+  }
+  async recoverAuditorSignature(bytecodeHash, auditor, reportUrl, signature) {
+    const digest = this.computeEIP712AuditorDigest(
+      bytecodeHash,
+      auditor,
+      reportUrl
+    );
+    return await recoverTypedDataAddress({
+      ...digest,
+      signature
+    });
+  }
+  async recoverAuthorSignature(contractType, version, initCode, author, source, signature) {
+    const digest = this.computeEIP712AuthorDigest({
+      contractType: stringToHex(contractType, { size: 32 }),
+      version: BigInt(version),
+      initCode,
+      author,
+      source
+    });
+    return await recoverTypedDataAddress({
+      ...digest,
+      signature
+    });
+  }
+  // computeEIP712AuditorDigest(bytecodeHash: Hex, reportUrl: string) {
+  //   return {
+  //     domain: this.getEIP712Domain(),
+  //     types: {
+  //       SignBytecodeHash: [
+  //         { name: "bytecodeHash", type: "bytes32" },
+  //         { name: "reportUrl", type: "string" },
+  //       ],
+  //     },
+  //     primaryType: "SignBytecodeHash",
+  //     message: {
+  //       bytecodeHash,
+  //       reportUrl,
+  //     },
+  //   } as const;
+  // }
+  computeEIP712AuditorDigest(bytecodeHash, auditor, reportUrl) {
+    return {
+      domain: this.getEIP712Domain(),
+      types: {
+        AuditReport: [
+          { name: "bytecodeHash", type: "bytes32" },
+          { name: "auditor", type: "address" },
+          { name: "reportUrl", type: "string" }
+        ]
+      },
+      primaryType: "AuditReport",
+      message: {
+        bytecodeHash,
+        auditor,
+        reportUrl
+      }
+    };
+  }
+  computeEIP712AuthorDigest(args) {
+    return {
+      domain: this.getEIP712Domain(),
+      ...BytecodeRepositoryContract.getBytecodeHashTypes(),
+      message: args
+    };
+  }
+  getEIP712Domain() {
+    return {
+      name: BYTECODE_REPOSITORY,
+      version: "310",
+      chainId: 1,
+      verifyingContract: this.address
+    };
+  }
+  computeBytecodeHash(args) {
+    return hashStruct({
+      data: args,
+      ...BytecodeRepositoryContract.getBytecodeHashTypes()
+    });
+  }
+  static getBytecodeHashTypes() {
+    return {
+      primaryType: "Bytecode",
+      types: {
+        Bytecode: [
+          { name: "contractType", type: "bytes32" },
+          { name: "version", type: "uint256" },
+          { name: "initCode", type: "bytes" },
+          { name: "author", type: "address" },
+          { name: "source", type: "string" }
+        ]
+      }
+    };
+  }
+  async computeBytecodeHashContract(args) {
+    return await this.contract.read.computeBytecodeHash([
+      { ...args, authorSignature: "0x" }
+    ]);
+  }
+  async getAuditors() {
+    return [...await this.contract.read.getAuditors()];
+  }
+  isAuditor(auditor) {
+    return this.contract.read.isAuditor([auditor]);
+  }
+  extractDeployDataEvent(logs) {
+    const events = parseEventLogs({
+      logs: logs.filter(
+        (log) => log.address.toLowerCase() === this.address.toLowerCase()
+      ),
+      abi
+    });
+    const deployEvents = events.filter(
+      (event) => event.eventName === "DeployContract"
+    );
+    if (deployEvents.length !== 1) {
+      throw new Error("Invalid deploy event");
+    }
+    return {
+      address: deployEvents[0].args.contractAddress,
+      bytecodeHash: deployEvents[0].args.bytecodeHash,
+      contractType: deployEvents[0].args.contractType,
+      version: Number(deployEvents[0].args.version)
+    };
+  }
+  async computeAddress(args) {
+    return await this.contract.read.computeAddress([
+      stringToHex(args.contractType, { size: 32 }),
+      BigInt(args.version),
+      args.encodedParams,
+      args.salt,
+      args.owner
+    ]);
+  }
+  async isAlreadyDeployedAddress(args) {
+    const address = await this.computeAddress(args);
+    const code = await this.client.getCode({ address });
+    return [code !== void 0, address];
+  }
+  async isAlreadyDeployed(args) {
+    return (await this.isAlreadyDeployedAddress(args))[0];
+  }
+  async uploadBytecode(uploadByteCode, sponsor) {
+    const normalizedSignature = normalizeSignature(
+      uploadByteCode.authorSignature
+    );
+    return await this.contract.write.uploadBytecode(
+      [{ ...uploadByteCode, authorSignature: normalizedSignature }],
+      {
+        account: sponsor.account,
+        chain: sponsor.chain
+        // gas: 35_000_000n,
+      }
+    );
+  }
+  addAuditorTx(args) {
+    const { name, address } = args;
+    return this.createRawTx({
+      functionName: "addAuditor",
+      args: [address, name],
+      description: `BytecodeRepository.addAuditor(${name})`
+    });
+  }
+  addPublicDomainTx(args) {
+    const { domain } = args;
+    const domainHex = stringToHex(domain, { size: 32 });
+    return this.createRawTx({
+      functionName: "addPublicDomain",
+      args: [domainHex],
+      description: `BytecodeRepository.addPublicDomain(${domain})`
+    });
+  }
+  allowPublicContractTx(args) {
+    const { bytecodeHash } = args;
+    return this.createRawTx({
+      functionName: "allowPublicContract",
+      args: [bytecodeHash],
+      description: `BytecodeRepository.allowPublicContract(${bytecodeHash})`
+    });
+  }
+  allowSystemContractTx(args) {
+    const { bytecodeHash } = args;
+    return this.createRawTx({
+      functionName: "allowSystemContract",
+      args: [bytecodeHash],
+      description: `BytecodeRepository.allowSystemContract(${bytecodeHash})`
+    });
+  }
+  setTokenSpecificPostfixTx(args) {
+    const { token, postfix } = args;
+    const postfixHex = stringToHex(postfix, { size: 32 });
+    return this.createRawTx({
+      functionName: "setTokenSpecificPostfix",
+      args: [token, postfixHex],
+      description: `BytecodeRepository.setTokenSpecificPostfix(${token}, ${postfix})`
+    });
+  }
+  uploadBytecodeRawTx(uploadByteCode) {
+    return this.createRawTx({
+      functionName: "uploadBytecode",
+      args: [uploadByteCode]
+    });
+  }
+  extractDomain(contractType) {
+    const separatorIndex = contractType.indexOf("::");
+    if (separatorIndex === -1) return contractType;
+    return contractType.slice(0, separatorIndex);
+  }
+  async allowPublicContract(bytecodeHash, sponsor) {
+    return await this.contract.write.allowPublicContract([bytecodeHash], {
+      account: sponsor.account,
+      chain: sponsor.chain
+    });
+  }
+  deployTx(args) {
+    return this.createRawTx({
+      functionName: "deploy",
+      args: [
+        stringToHex(args.contractType, { size: 32 }),
+        args.version,
+        args.encodedParams,
+        args.salt
+      ]
+    });
+  }
+}
+export {
+  BytecodeRepositoryContract
+};

package/dist/esm/permissionless/bindings/compressors/index.js

@@ -0,0 +1,2 @@
+export * from "./token-compressor";
+export * from "./withdrawal-compressor";

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";
+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";
+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
+};