@gearbox-protocol/sdk 9.14.1 → 9.15.1

package/dist/esm/permissionless/bindings/base-contract.js

@@ -0,0 +1,151 @@
+import {
+  getContract
+} from "viem";
+import { createRawTx } from "../../sdk/utils/index.js";
+import { decodeFunctionWithNamedArgs } from "../utils/abi-decoder.js";
+class BaseContract {
+  abi;
+  address;
+  name;
+  static register = {};
+  contract;
+  client;
+  constructor(abi, address, client, name) {
+    this.abi = abi;
+    this.client = client;
+    this.address = address.toLowerCase();
+    this.name = name;
+    this.contract = getContract({
+      address,
+      abi,
+      client
+    });
+    BaseContract.register[this.address] = this;
+  }
+  static parseCall(call) {
+    const parsedCall = BaseContract.parse(call.target, call.callData);
+    return {
+      ...parsedCall,
+      chainId: call.chainId
+    };
+  }
+  static parse(address, calldata) {
+    const contract = BaseContract.register[address.toLowerCase()];
+    if (contract) {
+      return contract.parseFunctionData(calldata);
+    } else {
+      return {
+        chainId: 0,
+        target: address,
+        label: "Unknown contract",
+        functionName: `Unknown function: ${calldata}`,
+        args: {}
+      };
+    }
+  }
+  parseFunctionData(calldata) {
+    const decodedWithNames = decodeFunctionWithNamedArgs(this.abi, calldata);
+    if (!decodedWithNames) {
+      return {
+        chainId: 0,
+        target: this.address,
+        label: this.name,
+        functionName: `Unknown function: ${calldata}`,
+        args: {}
+      };
+    }
+    const specParsed = this.parseFunctionParams(
+      decodedWithNames.originalDecoded
+    );
+    if (specParsed) {
+      return specParsed;
+    }
+    return this.wrapParseCall(
+      decodedWithNames.originalDecoded,
+      decodedWithNames.args
+    );
+  }
+  wrapParseCall(params, parsedParams) {
+    return {
+      chainId: 0,
+      target: this.address,
+      label: this.name,
+      functionName: params.functionName,
+      args: parsedParams
+    };
+  }
+  parseFunctionParams(_params) {
+    return void 0;
+  }
+  createRawTx(parameters) {
+    const { description: argsDescription } = parameters;
+    const tx = createRawTx(
+      this.address,
+      {
+        abi: this.abi,
+        ...parameters
+      },
+      argsDescription
+    );
+    tx.description = parameters.description || argsDescription || this.stringifyParsedCall(this.parseFunctionData(tx.callData));
+    return tx;
+  }
+  stringifyParsedCall(parsedCall) {
+    const argsStr = Object.entries(parsedCall.args).map(([key, value]) => `${key}: ${value}`).join(", ");
+    return `${parsedCall.label}.${parsedCall.functionName}(${argsStr})`;
+  }
+  async getEvents(eventName, fromBlock, toBlock, args, chunkSize) {
+    if (chunkSize) {
+      const chunkSizeBigint = BigInt(chunkSize);
+      const getEventPromises = [];
+      for (let i = fromBlock; i < toBlock; i += chunkSizeBigint) {
+        getEventPromises.push(
+          this.client.getContractEvents({
+            address: this.address,
+            fromBlock: i,
+            toBlock: i + chunkSizeBigint,
+            abi: this.abi,
+            eventName,
+            args
+          })
+        );
+      }
+      const events = (await Promise.all(getEventPromises)).flat();
+      return events;
+    }
+    try {
+      const events = await this.client.getContractEvents({
+        address: this.address,
+        fromBlock,
+        toBlock,
+        abi: this.abi,
+        eventName,
+        args
+      });
+      return events;
+    } catch (e) {
+      const blockRangeErrors = [
+        "query exceeds max block",
+        "range is too large",
+        "eth_getLogs is limited to",
+        "Unable to perform request",
+        "Block range limit exceeded"
+      ];
+      if (e instanceof Error && blockRangeErrors.some((errorText) => e.message.includes(errorText))) {
+        const middle = (fromBlock + toBlock) / 2n;
+        const [firstHalfEvents, secondHalfEvents] = await Promise.all([
+          this.getEvents(eventName, fromBlock, middle, args),
+          this.getEvents(eventName, middle + 1n, toBlock, args)
+        ]);
+        return [...firstHalfEvents, ...secondHalfEvents];
+      }
+      throw e;
+    }
+  }
+  getContract() {
+    return this.contract;
+  }
+}
+export {
+  BaseContract
+};

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/index.js";
+import { BYTECODE_REPOSITORY } from "../utils/literals.js";
+import { BaseContract } from "./base-contract.js";
+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.js";
+export * from "./withdrawal-compressor.js";