Replace script config for fixing missing constructor args transformations (#2282)

* Add configuration for replacing contracts with missing constructorArguments transformation

* Fix README path for configuration file in massive-replace script usage instructions

* Fix transaction hash assignment in replaceContract and fix error message in replaceCreationInformation

* Await all promises to settle in massive-replace-script before running next batch

* Add support for storing failed contracts in massive replace script

Author: manuelwedler

services/database/.env.template

@@ -26,4 +26,5 @@ DBMATE_SCHEMA_FILE=./sourcify-database.sql
 # Database configuration uses the POSTGRES_ variables above
 # API configuration
 API_BASE_URL=https://staging.sourcify.dev/server
-API_AUTH_TOKEN=token_here
+API_AUTH_TOKEN=token_here
+STORE_FAILED_CONTRACT_IDS=false

services/database/massive-replace-script/README.md

@@ -66,7 +66,7 @@ module.exports = {
 
 ```bash
 cd services/database
-CONFIG_FILE_PATH=./massive-replace-script/config-replace-creation-information.js npm run massive-replace
+CONFIG_FILE_PATH=./config-replace-creation-information.js npm run massive-replace
 ```
 
 ## How It Works

services/database/massive-replace-script/config-constructor-arguments-transformation.js

@@ -0,0 +1,42 @@
+// Configuration for fixing missing constructorArguments transformation
+// This configuration targets contracts where creation code exists but creation_match is null/false
+// and the recompiled creation code matches the onchain creation code
+// Related to: https://github.com/ethereum/sourcify/issues/2086
+
+module.exports = {
+  query: async (sourcePool, sourcifySchema, currentVerifiedContract, n) => {
+    return await sourcePool.query(
+      `
+      SELECT 
+          cd.chain_id,
+          cd.address,
+          sm.id as verified_contract_id
+      FROM ${sourcifySchema}.verified_contracts vc
+      JOIN ${sourcifySchema}.contract_deployments cd ON vc.deployment_id = cd.id
+      JOIN ${sourcifySchema}.contracts c ON cd.contract_id = c.id
+      JOIN ${sourcifySchema}.code creation_code ON c.creation_code_hash = creation_code.code_hash
+      JOIN ${sourcifySchema}.compiled_contracts cc ON vc.compilation_id = cc.id
+      JOIN ${sourcifySchema}.code recompiled_creation_code ON cc.creation_code_hash = recompiled_creation_code.code_hash
+      INNER JOIN ${sourcifySchema}.sourcify_matches sm ON sm.verified_contract_id = vc.id
+      WHERE c.creation_code_hash IS NOT NULL 
+          AND position(substring(recompiled_creation_code.code for 200) in creation_code.code) != 0
+          AND (vc.creation_match is null or vc.creation_match = false)
+          AND sm.id >= $1
+      ORDER BY sm.id ASC
+      LIMIT $2
+    `,
+      [currentVerifiedContract, n],
+    );
+  },
+  buildRequestBody: (contract) => {
+    return {
+      chainId: contract.chain_id.toString(),
+      address: `0x${contract.address.toString("hex")}`,
+      forceCompilation: false,
+      forceRPCRequest: false,
+      customReplaceMethod: "replace-creation-information",
+    };
+  },
+  description:
+    "Fixes missing constructorArguments transformation for contracts where creation code exists but creation_match is null/false. See https://github.com/ethereum/sourcify/issues/2086",
+};

services/database/massive-replace-script/massive-replace-script.ts

@@ -34,6 +34,35 @@ if (fs.existsSync(COUNTER_FILE)) {
   );
 }
 
+// Optional failed contracts storage
+const STORE_FAILED_CONTRACT_IDS =
+  process.env.STORE_FAILED_CONTRACT_IDS === "true";
+const FAILED_CONTRACTS_FILE = path.join(
+  CURRENT_VERIFIED_CONTRACT_PATH,
+  "FAILED_CONTRACTS",
+);
+
+function storeFailedContract(contract: any, error: any): void {
+  if (!STORE_FAILED_CONTRACT_IDS) return;
+
+  const address = `0x${contract.address.toString("hex")}`;
+  const failedContractInfo = {
+    timestamp: new Date().toISOString(),
+    verifiedContractId: contract.verified_contract_id,
+    chainId: contract.chain_id,
+    address: address,
+    error: error.message || error.toString(),
+  };
+
+  const logEntry = JSON.stringify(failedContractInfo) + "\n";
+
+  try {
+    fs.appendFileSync(FAILED_CONTRACTS_FILE, logEntry, "utf8");
+  } catch (writeError) {
+    console.error("Error writing to failed contracts file:", writeError);
+  }
+}
+
 const N = 5; // Number of contracts to process at a time
 
 const POSTGRES_SCHEMA = process.env.POSTGRES_SCHEMA || "public";
@@ -109,7 +138,7 @@ async function processContract(
   const address = `0x${contract.address.toString("hex")}`;
   try {
     console.log(
-      `Processing contract: chainId=${contract.chain_id}, address=0x${address}, verifiedContractId=${contract.verified_contract_id || contract.id}`,
+      `Processing contract: chainId=${contract.chain_id}, address=${address}, verifiedContractId=${contract.verified_contract_id}`,
     );
 
     const requestBody = config.buildRequestBody(contract);
@@ -121,6 +150,7 @@ async function processContract(
       `❌ Failed to process contract ${address} at chain ${contract.chain_id}:`,
       error,
     );
+    storeFailedContract(contract, error);
     throw error;
   }
 }
@@ -132,6 +162,10 @@ async function processContract(
     `Using configuration: ${config.description || "Custom replacement"}`,
   );
 
+  if (STORE_FAILED_CONTRACT_IDS) {
+    console.log(`Failed contracts will be stored in: ${FAILED_CONTRACTS_FILE}`);
+  }
+
   // Connect to source DB using a Pool
   const sourcePool = new Pool(SOURCE_DB_CONFIG);
   sourcePool.on("error", (err) => {
@@ -160,21 +194,20 @@ async function processContract(
 
       let secondToWait = 2;
       // Process the batch in parallel
-      try {
-        const processingPromises = verifiedContracts.map((contract) =>
-          processContract(contract, config),
-        );
-        await Promise.all(processingPromises);
-      } catch (batchError) {
-        secondToWait = 5; // Increase wait time on error
-        console.error("Error processing batch:", batchError);
+      const processingPromises = verifiedContracts.map((contract) =>
+        processContract(contract, config),
+      );
+      const results = await Promise.allSettled(processingPromises);
+      for (const result of results) {
+        if (result.status === "rejected") {
+          secondToWait = 5; // Increase wait time on error
+        }
       }
 
       // Update the counter file only after the batch successfully completes
 
       const lastProcessedId =
-        verifiedContracts[verifiedContracts.length - 1].verified_contract_id ||
-        verifiedContracts[verifiedContracts.length - 1].id;
+        verifiedContracts[verifiedContracts.length - 1].verified_contract_id;
       CURRENT_VERIFIED_CONTRACT = parseInt(lastProcessedId) + 1;
 
       // Use async write to avoid blocking

services/server/src/server/apiv1/verification/private/stateless/customReplaceMethods.ts

@@ -21,7 +21,7 @@ export const replaceCreationInformation: CustomReplaceMethod = async (
   await sourcifyDatabaseService.withTransaction(async (poolClient) => {
     if (!databaseColumns.onchainCreationCode) {
       throw new Error(
-        "Creation match is null, cannot replace creation information",
+        "No onchain creation code, cannot replace creation information",
       );
     }
     // Get existing verified contract to find deployment_id

services/server/src/server/apiv1/verification/private/stateless/private.stateless.handlers.ts

@@ -266,7 +266,7 @@ export async function replaceContract(
       const transactionHashFromDatabase = (sourcifyChain as SourcifyChainMock)
         .contractDeployment?.transaction_hash;
       if (transactionHashFromDatabase) {
-        transactionHash = `0x${transactionHashFromDatabase}`;
+        transactionHash = transactionHashFromDatabase;
       }
     } else {
       // Use the chainRepository to get the sourcifyChain object and fetch the contract's information from the RPC