Verification flow verification classes

packages/lib-sourcify/src/Compilation/AbstractCompilation.ts

@@ -3,6 +3,7 @@
   CompilationTarget,
   CompiledContractCborAuxdata,
   Metadata,
+  LinkReferences,
 } from './CompilationTypes';
 import {
   ImmutableReferences,
@@ -17,7 +18,7 @@
   VyperOutput,
   VyperOutputContract,
 } from './VyperTypes';
-import { logInfo, logSilly, logWarn } from '../lib/logger';
+import { logInfo, logSilly, logWarn } from '../logger';
 
 export abstract class AbstractCompilation {
   /**
@@ -28,14 +29,14 @@
   abstract compilationTarget: CompilationTarget;
   abstract jsonInput: SolidityJsonInput | VyperJsonInput;
 
-  metadata?: Metadata;
+  protected _metadata?: Metadata;
   compilerOutput?: SolidityOutput | VyperOutput;
 
   abstract auxdataStyle: AuxdataStyle;
 
   /** Marks the positions of the CborAuxdata parts in the bytecode */
-  creationBytecodeCborAuxdata?: CompiledContractCborAuxdata;
-  runtimeBytecodeCborAuxdata?: CompiledContractCborAuxdata;
+  protected _creationBytecodeCborAuxdata?: CompiledContractCborAuxdata;
+  protected _runtimeBytecodeCborAuxdata?: CompiledContractCborAuxdata;
 
   /**
    * Recompiles the contract with the specified compiler settings
@@ -73,7 +74,7 @@
     }
 
     // We call getCompilationTarget() before logging because it can throw an error
-    const compilationTarget = this.getCompilationTarget();
+    const compilationTarget = this.compilationTargetContract;
 
     const compilationEndTime = Date.now();
     const compilationDuration = compilationEndTime - compilationStartTime;
@@ -89,7 +90,9 @@
     return compilationTarget;
   }
 
-  getCompilationTarget(): SolidityOutputContract | VyperOutputContract {
+  get compilationTargetContract():
+    | SolidityOutputContract
+    | VyperOutputContract {
     if (!this.compilerOutput) {
       logWarn('Compiler output is undefined');
       throw new Error('Compiler output is undefined');
@@ -110,20 +113,36 @@
     ];
   }
 
-  getCreationBytecode() {
-    return `0x${this.getCompilationTarget().evm.bytecode.object}`;
+  get creationBytecode() {
+    return `0x${this.compilationTargetContract.evm.bytecode.object}`;
   }
 
-  getRuntimeBytecode() {
-    return `0x${this.getCompilationTarget().evm.deployedBytecode.object}`;
+  get runtimeBytecode() {
+    return `0x${this.compilationTargetContract.evm.deployedBytecode.object}`;
   }
 
-  getMetadata(): Metadata {
-    if (!this.metadata) {
+  get metadata() {
+    if (!this._metadata) {
       throw new Error('Metadata is not set');
     }
-    return this.metadata;
+    return this._metadata;
   }
 
-  abstract getImmutableReferences(): ImmutableReferences;
+  abstract get immutableReferences(): ImmutableReferences;
+  abstract get runtimeLinkReferences(): LinkReferences;
+  abstract get creationLinkReferences(): LinkReferences;
+
+  get creationBytecodeCborAuxdata(): CompiledContractCborAuxdata {
+    if (!this._creationBytecodeCborAuxdata) {
+      throw new Error('Creation bytecode cbor auxdata is not set');
+    }
+    return this._creationBytecodeCborAuxdata;
+  }
+
+  get runtimeBytecodeCborAuxdata(): CompiledContractCborAuxdata {
+    if (!this._runtimeBytecodeCborAuxdata) {
+      throw new Error('Runtime bytecode cbor auxdata is not set');
+    }
+    return this._runtimeBytecodeCborAuxdata;
+  }
 }

packages/lib-sourcify/src/Compilation/SolidityCompilation.ts

@@ -7,7 +7,7 @@ import {
   SolidityOutput,
   SolidityOutputContract,
 } from './SolidityTypes';
-import { CompilationTarget } from './CompilationTypes';
+import { CompilationTarget, LinkReferences } from './CompilationTypes';
 import {
   findAuxdataPositions,
   findAuxdatasInLegacyAssembly,
@@ -22,7 +22,6 @@ export class SolidityCompilation extends AbstractCompilation {
   declare compileAndReturnCompilationTarget: (
     forceEmscripten: boolean,
   ) => Promise<SolidityOutputContract>;
-  declare getCompilationTarget: () => SolidityOutputContract;
 
   // Specify the auxdata style, used for extracting the auxdata from the compiler output
   readonly auxdataStyle: AuxdataStyle.SOLIDITY = AuxdataStyle.SOLIDITY;
@@ -58,6 +57,7 @@ export class SolidityCompilation extends AbstractCompilation {
         ],
       },
     };
+    delete this.jsonInput.settings.compilationTarget;
   }
 
   /** Generates an edited contract with a space at the end of each source file to create a different source file hash and consequently a different metadata hash.
@@ -91,31 +91,32 @@ export class SolidityCompilation extends AbstractCompilation {
   public async generateCborAuxdataPositions(forceEmscripten = false) {
     // Auxdata array extracted from the compiler's `legacyAssembly` field
     const auxdatasFromCompilerOutput = findAuxdatasInLegacyAssembly(
-      this.getCompilationTarget().evm.legacyAssembly,
+      (this.compilationTargetContract as SolidityOutputContract).evm
+        .legacyAssembly,
     );
 
     // Case: there is not auxadata
     if (auxdatasFromCompilerOutput.length === 0) {
-      this.creationBytecodeCborAuxdata = {};
-      this.runtimeBytecodeCborAuxdata = {};
+      this._creationBytecodeCborAuxdata = {};
+      this._runtimeBytecodeCborAuxdata = {};
       return true;
     }
 
-    // Case: there is only one auxdata, no need to recompile
+    // Case: there is only one auxdata, no need to recompile if we find both runtime and creation auxdata at the end of the bytecode (creation auxdata can be in a different place)
     if (auxdatasFromCompilerOutput.length === 1) {
       // Extract the auxdata from the end of the recompiled runtime bytecode
       const [, runtimeAuxdataCbor, runtimeCborLengthHex] = splitAuxdata(
-        this.getRuntimeBytecode(),
+        this.runtimeBytecode,
         this.auxdataStyle,
       );
 
       const auxdataFromRawRuntimeBytecode = `${runtimeAuxdataCbor}${runtimeCborLengthHex}`;
 
       // we divide by 2 because we store the length in bytes (without 0x)
-      this.runtimeBytecodeCborAuxdata = {
+      this._runtimeBytecodeCborAuxdata = {
         '1': {
           offset:
-            this.getRuntimeBytecode().substring(2).length / 2 -
+            this.runtimeBytecode.substring(2).length / 2 -
             parseInt(runtimeCborLengthHex, 16) -
             2, // bytecode has 2 bytes of cbor length prefix at the end
           value: `0x${auxdataFromRawRuntimeBytecode}`,
@@ -124,18 +125,18 @@ export class SolidityCompilation extends AbstractCompilation {
 
       // Try to extract the auxdata from the end of the recompiled creation bytecode
       const [, creationAuxdataCbor, creationCborLengthHex] = splitAuxdata(
-        this.getCreationBytecode(),
+        this.creationBytecode,
         this.auxdataStyle,
       );
 
       // If we can find the auxdata at the end of the bytecode return; otherwise continue with `generateEditedContract`
       if (creationAuxdataCbor) {
         const auxdataFromRawCreationBytecode = `${creationAuxdataCbor}${creationCborLengthHex}`;
         // we divide by 2 because we store the length in bytes (without 0x)
-        this.creationBytecodeCborAuxdata = {
+        this._creationBytecodeCborAuxdata = {
           '1': {
             offset:
-              this.getCreationBytecode().substring(2).length / 2 -
+              this.creationBytecode.substring(2).length / 2 -
               parseInt(creationCborLengthHex, 16) -
               2, // bytecode has 2 bytes of cbor length prefix at the end
             value: `0x${auxdataFromRawCreationBytecode}`,
@@ -145,7 +146,7 @@ export class SolidityCompilation extends AbstractCompilation {
       }
     }
 
-    // Case: multiple auxdatas or failing creation auxdata,
+    // Case: multiple auxdatas or creation auxdata not found at the end of the bytecode,
     // we need to recompile with a slightly edited file to check the differences
     const editedContractCompilerOutput = await this.generateEditedContract({
       version: this.compilerVersion,
@@ -160,19 +161,19 @@ export class SolidityCompilation extends AbstractCompilation {
     const editedContractAuxdatasFromCompilerOutput =
       findAuxdatasInLegacyAssembly(editedContract.evm.legacyAssembly);
 
-    // Potentially we already found runtimeBytecodeCborAuxdata in the case of failing creation auxdata
+    // Potentially we already found runtimeBytecodeCborAuxdata in the case of creation auxdata not found at the end of the bytecode
     // so no need to call `findAuxdataPositions`
-    if (this.runtimeBytecodeCborAuxdata === undefined) {
-      this.runtimeBytecodeCborAuxdata = findAuxdataPositions(
-        this.getRuntimeBytecode(),
+    if (this._runtimeBytecodeCborAuxdata === undefined) {
+      this._runtimeBytecodeCborAuxdata = findAuxdataPositions(
+        this.runtimeBytecode,
         `0x${editedContract.evm.deployedBytecode.object}`,
         auxdatasFromCompilerOutput,
         editedContractAuxdatasFromCompilerOutput,
       );
     }
 
-    this.creationBytecodeCborAuxdata = findAuxdataPositions(
-      this.getCreationBytecode(),
+    this._creationBytecodeCborAuxdata = findAuxdataPositions(
+      this.creationBytecode,
       `0x${editedContract.evm.bytecode.object}`,
       auxdatasFromCompilerOutput,
       editedContractAuxdatasFromCompilerOutput,
@@ -184,11 +185,24 @@ export class SolidityCompilation extends AbstractCompilation {
   public async compile(forceEmscripten = false) {
     const contract =
       await this.compileAndReturnCompilationTarget(forceEmscripten);
-    this.metadata = JSON.parse(contract.metadata.trim());
+    this._metadata = JSON.parse(contract.metadata.trim());
   }
 
-  getImmutableReferences(): ImmutableReferences {
-    const compilationTarget = this.getCompilationTarget();
+  get immutableReferences(): ImmutableReferences {
+    const compilationTarget = this
+      .compilationTargetContract as SolidityOutputContract;
     return compilationTarget.evm.deployedBytecode.immutableReferences || {};
   }
+
+  get runtimeLinkReferences(): LinkReferences {
+    const compilationTarget = this
+      .compilationTargetContract as SolidityOutputContract;
+    return compilationTarget.evm.deployedBytecode.linkReferences || {};
+  }
+
+  get creationLinkReferences(): LinkReferences {
+    const compilationTarget = this
+      .compilationTargetContract as SolidityOutputContract;
+    return compilationTarget.evm.bytecode.linkReferences || {};
+  }
 }

packages/lib-sourcify/src/Compilation/SolidityTypes.ts

@@ -78,7 +78,7 @@
   timeout?: number;
 }
 
-interface Settings {
+export interface Settings {
   stopAfter?: string;
   remappings?: string[];
   optimizer?: Optimizer;

packages/lib-sourcify/src/Compilation/VyperCompilation.ts

@@ -1,4 +1,4 @@
-import { logWarn } from '../lib/logger';
+import { logWarn } from '../logger';
 import { AbstractCompilation } from './AbstractCompilation';
 import { id as keccak256str } from 'ethers';
 import {
@@ -16,6 +16,7 @@ import {
 import {
   CompilationTarget,
   CompiledContractCborAuxdata,
+  LinkReferences,
 } from './CompilationTypes';
 import { ImmutableReferences } from './SolidityTypes';
 
@@ -43,7 +44,7 @@ export class VyperCompilation extends AbstractCompilation {
    * compatibility reasons e.g. in the legacy Sourcify API that always assumes a metadata.json
    */
   generateMetadata() {
-    const contract = this.getCompilationTarget();
+    const contract = this.compilationTargetContract;
     const outputMetadata = {
       abi: contract.abi,
       devdoc: contract.devdoc,
@@ -61,7 +62,7 @@ export class VyperCompilation extends AbstractCompilation {
       {},
     );
 
-    this.metadata = {
+    this._metadata = {
       compiler: { version: this.compilerVersion },
       language: 'Vyper',
       output: outputMetadata,
@@ -129,33 +130,43 @@ export class VyperCompilation extends AbstractCompilation {
     this.initVyperJsonInput();
   }
 
-  getImmutableReferences(): ImmutableReferences {
+  get immutableReferences(): ImmutableReferences {
     let immutableReferences = {};
     if (gte(this.compilerVersionCompatibleWithSemver, '0.3.10')) {
       try {
         const { immutableSize } = decode(
-          this.getCreationBytecode(),
+          this.creationBytecode,
           this.auxdataStyle,
         );
         if (immutableSize) {
           immutableReferences = {
             '0': [
               {
                 length: immutableSize,
-                start: this.getRuntimeBytecode().substring(2).length / 2,
+                start: this.runtimeBytecode.substring(2).length / 2,
               },
             ],
           };
         }
       } catch (e) {
         logWarn('Cannot decode vyper contract bytecode', {
-          creationBytecode: this.getCreationBytecode(),
+          creationBytecode: this.creationBytecode,
         });
       }
     }
     return immutableReferences;
   }
 
+  get runtimeLinkReferences(): LinkReferences {
+    // Vyper doesn't support libraries
+    return {};
+  }
+
+  get creationLinkReferences(): LinkReferences {
+    // Vyper doesn't support libraries
+    return {};
+  }
+
   public async compile() {
     await this.compileAndReturnCompilationTarget(false);
     this.generateMetadata();
@@ -167,7 +178,7 @@ export class VyperCompilation extends AbstractCompilation {
   public async generateCborAuxdataPositions() {
     try {
       const [, runtimeAuxdataCbor, runtimeCborLengthHex] = splitAuxdata(
-        this.getRuntimeBytecode(),
+        this.runtimeBytecode,
         this.auxdataStyle,
       );
 
@@ -176,20 +187,22 @@ export class VyperCompilation extends AbstractCompilation {
         this.auxdataStyle === AuxdataStyle.VYPER_LT_0_3_10 ||
         this.auxdataStyle === AuxdataStyle.VYPER_LT_0_3_5
       ) {
-        this.runtimeBytecodeCborAuxdata = this.tryGenerateCborAuxdataPosition(
-          this.getRuntimeBytecode(),
+        this._runtimeBytecodeCborAuxdata = this.tryGenerateCborAuxdataPosition(
+          this.runtimeBytecode,
           runtimeAuxdataCbor,
           runtimeCborLengthHex,
         );
+      } else {
+        this._runtimeBytecodeCborAuxdata = {};
       }
 
       const [, creationAuxdataCbor, creationCborLengthHex] = splitAuxdata(
-        this.getCreationBytecode(),
+        this.creationBytecode,
         this.auxdataStyle,
       );
 
-      this.creationBytecodeCborAuxdata = this.tryGenerateCborAuxdataPosition(
-        this.getCreationBytecode(),
+      this._creationBytecodeCborAuxdata = this.tryGenerateCborAuxdataPosition(
+        this.creationBytecode,
         creationAuxdataCbor,
         creationCborLengthHex,
       );
@@ -231,10 +244,10 @@ export class VyperCompilation extends AbstractCompilation {
   }
 
   // Override the bytecodes' getter methods to not duplicate the 0x prefix
-  getCreationBytecode() {
-    return this.getCompilationTarget().evm.bytecode.object;
+  get creationBytecode() {
+    return this.compilationTargetContract.evm.bytecode.object;
   }
-  getRuntimeBytecode() {
-    return this.getCompilationTarget().evm.deployedBytecode.object;
+  get runtimeBytecode() {
+    return this.compilationTargetContract.evm.deployedBytecode.object;
   }
 }

packages/lib-sourcify/src/lib/SourcifyChain.ts → packages/lib-sourcify/src/SourcifyChain.ts

@@ -12,7 +12,7 @@ import {
   FetchContractCreationTxMethods,
   SourcifyChainExtension,
   TraceSupportedRPC,
-} from './types';
+} from './lib/types';
 import { logDebug, logError, logInfo, logWarn } from './logger';
 
 const RPC_TIMEOUT = process.env.RPC_TIMEOUT