link libraries

Author: jialinli98

ethereum/tests/src/solidityVerifier.ts

@@ -17,14 +17,93 @@ export interface FoundryArtefact {
   abi: Abi;
   bytecode: {
     object: Hex;
+    linkReferences?: Record<string, Record<string, Array<{ start: number; length: number }>>>;
   };
 }
 
+// Cache deployed libraries to avoid redeploying
+const deployedLibraries = new Map<string, Address>();
+
+async function deployLibrary(libraryName: string, libraryPath: string): Promise<Address> {
+  // Check if already deployed
+  const cacheKey = `${libraryPath}:${libraryName}`;
+  if (deployedLibraries.has(cacheKey)) {
+    return deployedLibraries.get(cacheKey)!;
+  }
+
+  // Import and deploy the library
+  const libraryArtifact = await import(`../../contracts/out/${libraryPath}/${libraryName}.json`, {
+    with: { type: 'json' }
+  });
+
+  const hash = await client.deployContract({
+    abi: libraryArtifact.default.abi,
+    account,
+    bytecode: libraryArtifact.default.bytecode.object as Hex,
+    chain: client.chain
+  });
+
+  const receipt = await client.waitForTransactionReceipt({ hash });
+  assert(receipt.status === 'success', 'Library deployment failed');
+  assert(!!receipt.contractAddress, 'Library address should not be empty');
+
+  deployedLibraries.set(cacheKey, receipt.contractAddress);
+  return receipt.contractAddress;
+}
+
+function linkLibraries(
+  bytecode: Hex,
+  linkReferences: Record<string, Record<string, Array<{ start: number; length: number }>>>,
+  libraryAddresses: Map<string, Address>
+): Hex {
+  let linkedBytecode = bytecode;
+
+  for (const [filePath, libraries] of Object.entries(linkReferences)) {
+    for (const [libraryName, references] of Object.entries(libraries)) {
+      const libraryAddress = libraryAddresses.get(`${filePath}:${libraryName}`);
+      assert(!!libraryAddress, `Library ${libraryName} not deployed`);
+
+      const addressHex = libraryAddress.slice(2).toLowerCase();
+
+      // Replace all occurrences of the library placeholder
+      for (const ref of references) {
+        // Each reference has a start position (in bytes, so multiply by 2 for hex string)
+        // Add 2 to skip '0x' prefix
+        const startPos = ref.start * 2 + 2;
+        const endPos = startPos + ref.length * 2;
+
+        linkedBytecode = (linkedBytecode.slice(0, startPos) + addressHex + linkedBytecode.slice(endPos)) as Hex;
+      }
+    }
+  }
+
+  return linkedBytecode;
+}
+
 export async function deploySolidityProofVerifier(artefact: FoundryArtefact): Promise<SolidityProofVerifier> {
+  let bytecode = artefact.bytecode.object;
+
+  // Deploy and link libraries if needed
+  if (artefact.bytecode.linkReferences && Object.keys(artefact.bytecode.linkReferences).length > 0) {
+    const libraryAddresses = new Map<string, Address>();
+
+    for (const [filePath, libraries] of Object.entries(artefact.bytecode.linkReferences)) {
+      for (const libraryName of Object.keys(libraries)) {
+        const address = await deployLibrary(
+          libraryName,
+          filePath.replace('src/generated-verifier/', '').replace('.sol', '.sol')
+        );
+        libraryAddresses.set(`${filePath}:${libraryName}`, address);
+      }
+    }
+
+    bytecode = linkLibraries(bytecode, artefact.bytecode.linkReferences, libraryAddresses);
+  }
+
   const hash = await client.deployContract({
     abi: artefact.abi,
     account,
-    bytecode: artefact.bytecode.object,
+    bytecode,
     chain: client.chain
   });