feat: add zksync EraVM source verification and Abstract chain

packages/bytecode-utils/src/lib/bytecode.ts

@@ -1,24 +1,27 @@
-import { getBytes, hexlify } from 'ethers';
-import bs58 from 'bs58';
+import { getBytes } from 'ethers';
 import * as CBOR from 'cbor-x';
 import semver from 'semver';
 
+import {
+  AuxdataStyle,
+  decodeSolidityCborObject,
+  ensureHexPrefix,
+  splitCborAuxdata,
+  validateBytecode,
+  type SolidityDecodedObject,
+} from './cbor';
+import { decodeEraVmAuxdata, splitEraVmAuxdata } from './eravm';
+
+// Re-export the public CBOR API so it stays available from the package root.
+export { AuxdataStyle, isCborEncoded } from './cbor';
+export type { SolidityDecodedObject } from './cbor';
+export { eraBytecodeHash } from './eravm';
+
 type CBOR = {
   bytes: string;
   length: number;
 };
 
-export type SolidityDecodedObject = {
-  // Known CBOR fields that are defined in the spec
-  ipfs?: string;
-  solcVersion?: string;
-  experimental?: boolean;
-  bzzr0?: string;
-  bzzr1?: string;
-  // Any other CBOR field that is not explicitly defined above. This is a catch-all for future extensions.
-  [key: string]: string | Uint8Array | undefined | boolean;
-};
-
 export type VyperDecodedObject = {
   integrity?: string;
   runtimeSize?: number;
@@ -27,15 +30,6 @@ export type VyperDecodedObject = {
   vyperVersion: string;
 };
 
-export enum AuxdataStyle {
-  SOLIDITY = 'solidity',
-  VYPER = 'vyper',
-  VYPER_LT_0_3_10 = 'vyper_lt_0_3_10',
-  VYPER_LT_0_3_5 = 'vyper_lt_0_3_5',
-  VYPER_LT_0_3_4 = 'vyper_lt_0_3_4',
-  FE = 'fe',
-}
-
 export const getVyperAuxdataStyle = (
   compilerVersion: string,
 ):
@@ -94,7 +88,7 @@ export const getAuxdataStyle = (
 export const decode = <T extends AuxdataStyle>(
   bytecode: string,
   auxdataStyle: T,
-): T extends AuxdataStyle.SOLIDITY
+): T extends AuxdataStyle.SOLIDITY | AuxdataStyle.ZKSYNC
   ? SolidityDecodedObject
   : VyperDecodedObject => {
   if (bytecode.length === 0) {
@@ -154,41 +148,9 @@ export const decode = <T extends AuxdataStyle>(
       vyperVersion: cborDecodedObject.vyper.join('.'),
     } as any;
   } else if (auxdataStyle === AuxdataStyle.SOLIDITY) {
-    // cbor decode the object and get a json
-    const cborDecodedObject = CBOR.decode(getBytes(`0x${auxdata}`));
-
-    const result: SolidityDecodedObject = {};
-    // Decode all the parameters from the json
-    Object.keys(cborDecodedObject).forEach((key: string) => {
-      switch (key) {
-        case 'ipfs': {
-          const ipfsCID = bs58.encode(cborDecodedObject.ipfs);
-          result.ipfs = ipfsCID;
-          break;
-        }
-        case 'solc': {
-          // nightly builds are string encoded
-          if (typeof cborDecodedObject.solc === 'string') {
-            result.solcVersion = cborDecodedObject.solc;
-          } else {
-            result.solcVersion = cborDecodedObject.solc.join('.');
-          }
-          break;
-        }
-        case 'experimental': {
-          result.experimental = cborDecodedObject.experimental;
-          break;
-        }
-        case 'bzzr0':
-        case 'bzzr1':
-        default: {
-          result[key] = hexlify(cborDecodedObject[key]);
-          break;
-        }
-      }
-    });
-
-    return result as any;
+    return decodeSolidityCborObject(auxdata) as any;
+  } else if (auxdataStyle === AuxdataStyle.ZKSYNC) {
+    return decodeEraVmAuxdata(auxdata) as any;
   } else {
     throw Error('Invalid auxdata style');
   }
@@ -217,188 +179,9 @@ export const splitAuxdata = (
     return [bytecode];
   }
 
-  const bytesLength = 4;
-  const cborBytesLength = getCborBytesLength(
-    bytecode,
-    auxdataStyle,
-    bytesLength,
-  );
-
-  if (
-    isCborLengthInvalid(auxdataStyle, bytecode, cborBytesLength, bytesLength)
-  ) {
-    return [bytecode];
-  }
-
-  const auxdata = extractAuxdata(
-    bytecode,
-    auxdataStyle,
-    cborBytesLength,
-    bytesLength,
-  );
-  const executionBytecode = extractExecutionBytecode(
-    bytecode,
-    auxdataStyle,
-    cborBytesLength,
-    bytesLength,
-  );
-
-  if (isCborEncoded(auxdata)) {
-    const cborLengthHex = getCborLengthHex(bytecode, auxdataStyle, bytesLength);
-    return [executionBytecode, auxdata, cborLengthHex];
+  if (auxdataStyle === AuxdataStyle.ZKSYNC) {
+    return splitEraVmAuxdata(bytecode);
   }
 
-  return [bytecode];
-};
-
-/**
- * Validates that the bytecode is not empty.
- *
- * @param bytecode - The bytecode string to validate
- */
-const validateBytecode = (bytecode: string) => {
-  if (bytecode.length === 0) {
-    throw Error('Bytecode cannot be null');
-  }
-};
-
-/**
- * Ensures the bytecode string starts with '0x'.
- *
- * @param bytecode - The bytecode string
- * @returns The bytecode string with '0x' prefix
- */
-const ensureHexPrefix = (bytecode: string): string => {
-  return bytecode.startsWith('0x') ? bytecode : `0x${bytecode}`;
-};
-
-/**
- * Determines the length of the CBOR auxdata in bytes.
- *
- * @param bytecode - The complete bytecode string
- * @param auxdataStyle - The style of auxdata
- * @param bytesLength - The length of bytes used to encode the CBOR length
- * @returns An object containing the CBOR bytes length and a flag for legacy Vyper
- */
-const getCborBytesLength = (
-  bytecode: string,
-  auxdataStyle: AuxdataStyle,
-  bytesLength: number,
-): number => {
-  if (auxdataStyle === AuxdataStyle.VYPER_LT_0_3_5) {
-    return 22; // For Vyper 0.3.4, the CBOR length is fixed because it contains only the version
-  }
-  const cborLengthHex = bytecode.slice(-bytesLength);
-  return parseInt(cborLengthHex, 16) * 2;
-};
-
-/**
- * Checks if the CBOR length is invalid based on the bytecode length.
- *
- * @param auxdataStyle - The auxdata style (Solidity or Vyper)
- * @param bytecode - The complete bytecode string
- * @param cborBytesLength - The length of CBOR auxdata in bytes
- * @param bytesLength - The length of bytes used to encode the CBOR length
- * @returns True if the CBOR length is invalid, otherwise false
- */
-const isCborLengthInvalid = (
-  auxdataStyle: AuxdataStyle,
-  bytecode: string,
-  cborBytesLength: number,
-  bytesLength: number,
-): boolean => {
-  if (auxdataStyle === AuxdataStyle.VYPER) {
-    // Vyper includes the trailing length bytes in cborBytesLength,
-    // so we only subtract cborBytesLength (no separate bytesLength).
-    return bytecode.length - cborBytesLength <= 0;
-  }
-  return bytecode.length - bytesLength - cborBytesLength <= 0;
-};
-
-/**
- * Extracts the auxdata from the bytecode based on the auxdata style.
- *
- * @param bytecode - The complete bytecode string
- * @param auxdataStyle - The style of auxdata
- * @param cborBytesLength - The length of CBOR auxdata in bytes
- * @param bytesLength - The length of bytes used to encode the CBOR length
- * @returns The extracted auxdata as a hex string
- */
-const extractAuxdata = (
-  bytecode: string,
-  auxdataStyle: AuxdataStyle,
-  cborBytesLength: number,
-  bytesLength: number,
-): string => {
-  switch (auxdataStyle) {
-    case AuxdataStyle.VYPER_LT_0_3_10:
-    case AuxdataStyle.SOLIDITY:
-      return bytecode.substring(
-        bytecode.length - bytesLength - cborBytesLength,
-        bytecode.length - bytesLength,
-      );
-    case AuxdataStyle.VYPER:
-      return bytecode.substring(
-        bytecode.length - cborBytesLength,
-        bytecode.length - bytesLength,
-      );
-    case AuxdataStyle.VYPER_LT_0_3_5:
-      return bytecode.substring(bytecode.length - 22, bytecode.length);
-    default:
-      throw Error('Unsupported auxdata style');
-  }
-};
-
-/**
- * Extracts the execution bytecode from the complete bytecode string.
- *
- * @param bytecode - The complete bytecode string
- * @param cborBytesLength - The length of CBOR auxdata in bytes
- * @param bytesLength - The length of bytes used to encode the CBOR length
- * @returns The execution bytecode as a hex string
- */
-const extractExecutionBytecode = (
-  bytecode: string,
-  auxdataStyle: AuxdataStyle,
-  cborBytesLength: number,
-  bytesLength: number,
-): string => {
-  if (auxdataStyle === AuxdataStyle.VYPER) {
-    // Vyper includes the trailing length bytes in cborBytesLength,
-    // so we only subtract cborBytesLength to avoid double-counting.
-    return bytecode.substring(0, bytecode.length - cborBytesLength);
-  }
-  return bytecode.substring(0, bytecode.length - bytesLength - cborBytesLength);
-};
-
-/**
- * Attempts to decode the auxdata to verify if it's CBOR-encoded.
- *
- * @param auxdata - The auxdata string to decode
- * @returns True if auxdata is CBOR-encoded, otherwise false
- */
-export const isCborEncoded = (auxdata: string): boolean => {
-  try {
-    CBOR.decode(getBytes(`0x${auxdata}`));
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-/**
- * Retrieves the CBOR length from the bytecode based on the auxdata style.
- *
- * @param bytecode - The complete bytecode string
- * @param auxdataStyle - The style of auxdata
- * @param bytesLength - The length of bytes used to encode the CBOR length
- * @returns The CBOR length as a hex string
- */
-const getCborLengthHex = (
-  bytecode: string,
-  auxdataStyle: AuxdataStyle,
-  bytesLength: number,
-): string => {
-  if (auxdataStyle === AuxdataStyle.VYPER_LT_0_3_5) return '';
-  return bytecode.slice(-bytesLength);
+  return splitCborAuxdata(bytecode, auxdataStyle);
 };