@0xsequence/catapult 1.1.0

package/src/lib/verification/sourcify.ts

@@ -0,0 +1,248 @@
+import { Network } from '../types/network'
+import { VerificationPlatform, VerificationRequest, VerificationResult } from './etherscan'
+
+export class SourcifyVerificationPlatform implements VerificationPlatform {
+  readonly name = 'sourcify'
+
+  supportsNetwork(network: Network): boolean {
+    // Sourcify supports most networks, but we can add specific logic here if needed
+    return !network.supports || network.supports.includes(this.name)
+  }
+
+  isConfigured(): boolean {
+    // Sourcify requires no configuration
+    return true
+  }
+
+  getConfigurationRequirements(): string {
+    return 'Sourcify requires no configuration'
+  }
+
+  async isContractAlreadyVerified(address: string, network: Network): Promise<boolean> {
+    try {
+      const response = await fetch(
+        `https://sourcify.dev/server/check-by-addresses?addresses=${address}&chainIds=${network.chainId}`,
+        {
+          method: 'GET',
+          signal: AbortSignal.timeout(15000), // 15 second timeout
+        }
+      )
+
+      if (!response.ok) {
+        return false
+      }
+
+      const data = await response.json()
+      
+      // Check if the contract is verified (perfect or partial match)
+      return Array.isArray(data) && data.some(item => 
+        item.address?.toLowerCase() === address.toLowerCase() &&
+        item.chainId === network.chainId.toString() &&
+        (item.status === 'perfect' || item.status === 'partial')
+      )
+    } catch (error) {
+      // If we can't determine the verification status, assume it's not verified
+      console.warn(`Failed to check Sourcify verification status for ${address}: ${error instanceof Error ? error.message : String(error)}`)
+      return false
+    }
+  }
+
+  async verifyContract(request: VerificationRequest): Promise<VerificationResult> {
+    const { contract, buildInfo, address, network } = request
+
+    // First check if it's already verified
+    const alreadyVerified = await this.isContractAlreadyVerified(address, network)
+    if (alreadyVerified) {
+      return {
+        success: true,
+        message: 'Contract was already verified on Sourcify (checked before attempting verification)',
+        isAlreadyVerified: true
+      }
+    }
+
+    try {
+      // Extract metadata and source files
+      const { metadata, sourceFiles } = await this.createVerificationData(contract, buildInfo)
+
+      // Use web standard FormData instead of node form-data package
+      const formData = new FormData()
+
+      formData.append('address', address)
+      formData.append('chain', network.chainId.toString())
+      
+      // Upload files individually to Sourcify
+      // First add the metadata.json
+      const metadataJson = JSON.stringify(metadata, null, 2)
+      const metadataBlob = new Blob([metadataJson], { type: 'application/json' })
+      formData.append('files', metadataBlob, 'metadata.json')
+      
+      // Add each source file individually
+      for (const [sourcePath, sourceContent] of sourceFiles) {
+        const sourceBlob = new Blob([sourceContent], { type: 'text/plain' })
+        formData.append('files', sourceBlob, sourcePath)
+      }
+
+      const response = await fetch('https://sourcify.dev/server/verify', {
+        method: 'POST',
+        body: formData,
+        signal: AbortSignal.timeout(60000), // 60 second timeout for verification
+      })
+
+      if (!response.ok) {
+        let responseText = ''
+        try {
+          responseText = await response.text()
+        } catch {
+          // ignore
+        }
+
+        // Treat partial verification conflicts as a non-error notice
+        if (response.status === 409) {
+          const lower = `${response.statusText} ${responseText}`.toLowerCase()
+          if (
+            lower.includes('already partially verified') ||
+            lower.includes('partial match') ||
+            lower.includes('partial')
+          ) {
+            return {
+              success: true,
+              message: 'Contract already partially verified on Sourcify (no further action needed)',
+              isAlreadyVerified: true
+            }
+          }
+        }
+
+        let errorDetails = `HTTP ${response.status}: ${response.statusText}`
+        if (responseText) {
+          errorDetails += ` - ${responseText}`
+        }
+        return {
+          success: false,
+          message: `Sourcify API request failed: ${errorDetails}`
+        }
+      }
+
+      const result = await response.json() as any
+      
+      // Check for different response formats
+      if (result.result && Array.isArray(result.result)) {
+        // Array response format - check if any items have perfect/partial status
+        const perfectMatch = result.result.find((item: any) => item.status === 'perfect')
+        const partialMatch = result.result.find((item: any) => item.status === 'partial')
+        
+        if (perfectMatch || partialMatch) {
+          const matchType = perfectMatch ? 'perfect' : 'partial'
+          return {
+            success: true,
+            message: `Contract verified successfully on Sourcify (${matchType} match)`
+          }
+        }
+        
+        return {
+          success: false,
+          message: 'Sourcify verification failed - no perfect or partial match found'
+        }
+      } else if (result.status) {
+        // Single object response format
+        if (result.status === 'perfect' || result.status === 'partial') {
+          return {
+            success: true,
+            message: `Contract verified successfully on Sourcify (status: ${result.status})`
+          }
+        } else if (result.status === 'error') {
+          return {
+            success: false,
+            message: result.message || 'Sourcify verification failed with unknown error'
+          }
+        } else {
+          return {
+            success: false,
+            message: `Sourcify verification failed with status: ${result.status}`
+          }
+        }
+      } else {
+        // Unknown response format
+        return {
+          success: false,
+          message: `Sourcify verification failed - unexpected response format: ${JSON.stringify(result)}`
+        }
+      }
+    } catch (error) {
+      return {
+        success: false,
+        message: `Sourcify verification failed: ${error instanceof Error ? error.message : String(error)}`
+      }
+    }
+  }
+
+  private async createVerificationData(contract: any, buildInfo: any): Promise<{
+    metadata: any,
+    sourceFiles: Array<[string, string]>
+  }> {
+    // Extract source files from the build info
+    const sourceFiles: Array<[string, string]> = []
+    for (const [sourcePath, sourceInfo] of Object.entries(buildInfo.input.sources) as [string, any][]) {
+      if (sourceInfo.content) {
+        sourceFiles.push([sourcePath, sourceInfo.content])
+      }
+    }
+
+    // Try to find metadata from the contract's artifact if available
+    let metadata = null
+    
+    // First, try to get metadata from the contract's artifact file  
+    try {
+      // Look for artifact file in contract sources (convert Set to Array)
+      const sources = Array.from(contract._sources) as string[]
+      const artifactPath = sources.find((source) => 
+        source.includes('/artifacts/') && source.endsWith('.json') && !source.includes('/build-info/')
+      )
+      
+      if (artifactPath) {
+        const fs = await import('fs/promises')
+        const artifactContent = await fs.readFile(artifactPath, 'utf-8')
+        const artifact = JSON.parse(artifactContent)
+        
+        // Use rawMetadata if available (it's a JSON string)
+        if (artifact.rawMetadata) {
+          metadata = JSON.parse(artifact.rawMetadata)
+        } else if (artifact.metadata) {
+          metadata = artifact.metadata
+        }
+      }
+    } catch (error) {
+      console.warn(`Failed to load artifact metadata: ${error instanceof Error ? error.message : String(error)}`)
+    }
+
+    // Fallback: look for metadata in the build info output
+    if (!metadata && buildInfo.output?.contracts?.[contract.sourceName]?.[contract.contractName]?.metadata) {
+      const metadataField = buildInfo.output.contracts[contract.sourceName][contract.contractName].metadata
+      metadata = typeof metadataField === 'string' ? JSON.parse(metadataField) : metadataField
+    }
+
+    // Last resort fallback: create basic metadata from the input
+    if (!metadata) {
+      metadata = {
+        compiler: {
+          version: buildInfo.solcLongVersion || buildInfo.solcVersion
+        },
+        language: buildInfo.input.language,
+        output: {
+          abi: buildInfo.output?.contracts?.[contract.sourceName]?.[contract.contractName]?.abi || [],
+          devdoc: { kind: 'dev', methods: {}, version: 1 },
+          userdoc: { kind: 'user', methods: {}, version: 1 }
+        },
+        settings: buildInfo.input.settings,
+        sources: buildInfo.input.sources,
+        version: 1
+      }
+    }
+
+    // Validation: ensure metadata has compilation target
+    if (!metadata?.settings?.compilationTarget) {
+      console.warn('Warning: Metadata missing compilation target')
+    }
+
+    return { metadata, sourceFiles }
+  }
+}

package/test_validation/artifacts/TestContract.json

@@ -0,0 +1,9 @@
+{
+  "abi": [],
+  "bytecode": {
+    "object": "0x608060405234801561001057600080fd5b50600160008190555050607c8061002760003960006000f3fe"
+  },
+  "deployedBytecode": {
+    "object": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c80638da5cb5b14610044575b36600b57005b600080fd5b61005c600480360381019061005791906100a1565b610062565b005b600080fd5b6000813590506100da81610099565b92915050565b600080fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b60006002820490506001821680610128576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161011f906101c4565b60405180910390fd5b5080910390565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600060405190508061014e82610131565b8091505090565b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b82818337600083901b82529050565b600060208284031215610178576101776100c7565b5b60006101868482850161007c565b91505092915050565b7f537472696e67206d757374206265206e6f6e2d656d7074790000000000000000600082015250565b60006101c560198361021f565b91506101d08261018f565b6020820190509190565b60006020820190508181036000830152610203816101bf565b9050919050565b600082825260208201905092915050565b5050565b565b005b00fea264697066735822122013e4c7c9dd8f5cc6c8b78b5e5b5e5e5e5e5e5e5e5e5e5e5e5e5e5e5e5e5e64736f6c634300081e0033"
+  }
+}

package/test_validation/jobs/test-missing.yaml

@@ -0,0 +1,16 @@
+name: "test-missing"
+version: "1.0.0"
+description: "Test job that references a non-existent contract"
+
+actions:
+  - name: "deploy-valid"
+    template: "sequence-universal-deployer-2"
+    arguments:
+      creationCode: "{{Contract(TestContract).creationCode}}"
+      salt: "0"
+      
+  - name: "deploy-missing"
+    template: "sequence-universal-deployer-2"
+    arguments:
+      creationCode: "{{Contract(NonExistentContract).creationCode}}"
+      salt: "0"

package/test_validation/networks.yaml

@@ -0,0 +1,3 @@
+- name: "Test Network"
+  chainId: 1337
+  rpcUrl: "http://localhost:8545"

package/tsconfig.json

@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "removeComments": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitThis": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "resolveJsonModule": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts"
+  ]
+}