clean up

Author: pgherveou

.gitignore

@@ -7,9 +7,10 @@ yarn-error.log*
 pnpm-debug.log*
 lerna-debug.log*
 
-abi/*
-pvm/*
-evm/*
+codegen/abi/*
+codegen/pvm/*
+codegen/evm/*
+*.sha256.txt
 
 node_modules
 dist

.prettierrc.json

@@ -9,7 +9,7 @@
         }
     },
     "tasks": {
-        "build": "deno run -P src/build-contracts.ts && deno fmt",
+        "build": "deno run -P src/build-contracts.ts",
         "test:evm": "deno task build && USE_REVIVE=evm START_REVIVE_DEV_NODE=true START_ETH_RPC=true deno test -P",
         "test:pvm": "deno task build && USE_REVIVE=pvm START_REVIVE_DEV_NODE=true START_ETH_RPC=true deno test -P",
         "test:geth": "START_GETH=true deno test -P",
@@ -19,14 +19,16 @@
         "include": ["src/all-tests.ts"]
     },
     "imports": {
+        "@std/cli": "jsr:@std/cli@^1.0.23",
         "viem": "npm:viem@^2.38.3",
         "viem/": "npm:/viem@^2.38.3/",
         "solc": "npm:solc@^0.8.30",
         "@parity/resolc": "npm:@parity/resolc@^0.4.1",
         "@std/assert": "jsr:@std/assert@^1.0.15",
         "@std/expect": "jsr:@std/expect@^1.0.17",
         "@std/testing": "jsr:@std/testing@^1.0.16",
-        "@std/path": "jsr:@std/path@^1.1.2"
+        "@std/path": "jsr:@std/path@^1.1.2",
+        "@std/log": "jsr:@std/log@^0.224"
     },
     "compilerOptions": {
         "strict": true

abi/.gitkeep codegen/abi/.gitkeepabi/.gitkeep renamed to codegen/abi/.gitkeep

@@ -1,23 +1,82 @@
 /// <reference path="./solc.d.ts" />
 
-import {
-    compile,
-    type SolcOutput,
-    tryResolveImport,
-    version,
-} from '@parity/resolc'
+import * as resolc from '@parity/resolc'
 import solc from 'solc'
 import { basename, join } from '@std/path'
+import * as log from '@std/log'
+import { parseArgs } from '@std/cli'
+
+type CompileInput = Parameters<typeof resolc.compile>[0]
+const LOG_LEVEL = (Deno.env.get('LOG_LEVEL')?.toUpperCase() ??
+    'INFO') as log.LevelName
+log.setup({
+    handlers: {
+        console: new log.ConsoleHandler(LOG_LEVEL),
+    },
+    loggers: {
+        default: {
+            level: LOG_LEVEL,
+            handlers: ['console'],
+        },
+    },
+})
+
+const logger = log.getLogger()
+const { filter, solcOnly, force } = parseArgs(Deno.args, {
+    string: ['filter'],
+    boolean: ['solcOnly', 'force'],
+})
+
+async function computeSha256(content: string): Promise<string> {
+    const encoder = new TextEncoder()
+    const data = encoder.encode(content)
+    const hashBuffer = await crypto.subtle.digest('SHA-256', data)
+    const hashArray = Array.from(new Uint8Array(hashBuffer))
+    return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
+}
 
-type CompileInput = Parameters<typeof compile>[0]
+function readCachedHash(hashFile: string): string | null {
+    try {
+        return Deno.readTextFileSync(hashFile).trim()
+    } catch {
+        return null
+    }
+}
 
-const args = Deno.args
-const filter = args.includes('-f') || args.includes('--filter')
-    ? args[args.indexOf('-f') + 1] || args[args.indexOf('--filter') + 1]
-    : undefined
-const solcOnly = args.includes('-s') || args.includes('--solcOnly')
+function writeCachedHash(hashFile: string, hash: string): void {
+    Deno.writeTextFileSync(hashFile, hash)
+}
 
-function evmCompile(sources: CompileInput) {
+let resolcVersion = ''
+async function pvmCompile(file: Deno.DirEntry, sources: CompileInput) {
+    if (resolcVersion === '') {
+        if (Deno.env.get('REVIVE_BIN') === undefined) {
+            resolcVersion = ` @parity/resolc: ${resolc.version().trim()}`
+        } else {
+            resolcVersion = new TextDecoder()
+                .decode(
+                    (
+                        await new Deno.Command('resolc', {
+                            args: ['--version'],
+                            stdout: 'piped',
+                        }).output()
+                    ).stdout,
+                )
+                .trim()
+        }
+    }
+    logger.info(`Compiling ${file.name} with revive ${resolcVersion}`)
+    return await resolc.compile(sources, {
+        bin: Deno.env.get('REVIVE_BIN'),
+    })
+}
+
+let solcVersion = ''
+function evmCompile(file: Deno.DirEntry, sources: CompileInput) {
+    if (solcVersion === '') {
+        solcVersion = solc.version()
+    }
+    logger.info(`Compile ${file.name} with solc ${solcVersion}`)
     const input = {
         language: 'Solidity',
         sources,
@@ -32,84 +91,87 @@ function evmCompile(sources: CompileInput) {
 
     return solc.compile(JSON.stringify(input), {
         import: (relativePath: string) => {
-            const source = Deno.readTextFileSync(tryResolveImport(relativePath))
+            const source = Deno.readTextFileSync(
+                resolc.tryResolveImport(relativePath),
+            )
             return { contents: source }
         },
     })
 }
 
-console.log('Compiling contracts...')
+logger.debug('Compiling contracts...')
 
 const currentDir = new URL('.', import.meta.url).pathname
 const rootDir = join(currentDir, '..')
 const contractsDir = join(rootDir, 'contracts')
-const abiDir = join(rootDir, 'abi')
-const pvmDir = join(rootDir, 'pvm')
-const evmDir = join(rootDir, 'evm')
+const codegenDir = join(rootDir, 'codegen')
+const abiDir = join(codegenDir, 'abi')
+const pvmDir = join(codegenDir, 'pvm')
+const evmDir = join(codegenDir, 'evm')
 
 const input = Array.from(Deno.readDirSync(contractsDir))
     .filter((f) => f.isFile && f.name.endsWith('.sol'))
     .filter((f) => !filter || f.name.includes(filter))
 
 for (const file of input) {
-    console.log(`🔨 Compiling ${file.name}...`)
     const name = basename(file.name)
+    const sourceFilePath = join(contractsDir, file.name)
+    const sourceContent = Deno.readTextFileSync(sourceFilePath)
+    const sourceHash = await computeSha256(sourceContent)
     const inputSources = {
         [name]: {
-            content: Deno.readTextFileSync(join(contractsDir, file.name)),
+            content: sourceContent,
         },
     }
 
-    if (!solcOnly) {
-        if (Deno.env.get('REVIVE_BIN') === undefined) {
-            console.log(`Compiling with revive @parity/resolc: ${version()}...`)
-        } else {
-            // add the result of resolc --version
-
-            const output = new TextDecoder().decode(
-                (
-                    await new Deno.Command('resolc', {
-                        args: ['--version'],
-                        stdout: 'piped',
-                    }).output()
-                ).stdout,
-            )
-            console.log(
-                `Compiling with revive (using ${
-                    Deno.env.get(
-                        'REVIVE_BIN',
-                    )
-                } - ${output})...`,
-            )
-        }
-        const reviveOut = await compile(inputSources, {
-            bin: Deno.env.get('REVIVE_BIN'),
-        })
+    // Create marker files to track if this source has been compiled
+    const pvmSourceMarkerFile = join(pvmDir, `.${name}.sha256.txt`)
+    const pvmSourceMarkerHash = readCachedHash(pvmSourceMarkerFile)
+    const needsPvmCompilation = !solcOnly &&
+        (force || pvmSourceMarkerHash !== sourceHash)
+
+    const evmSourceMarkerFile = join(evmDir, `.${name}.sha256.txt`)
+    const evmSourceMarkerHash = readCachedHash(evmSourceMarkerFile)
+    const needsEvmCompilation = force || evmSourceMarkerHash !== sourceHash
+
+    if (needsPvmCompilation) {
+        const reviveOut = await pvmCompile(file, inputSources)
 
         for (const contracts of Object.values(reviveOut.contracts)) {
             for (const [name, contract] of Object.entries(contracts)) {
                 if (contract?.evm?.bytecode?.object) {
-                    console.log(`📜 Add PVM contract ${name}`)
+                    const pvmFile = join(pvmDir, `${name}.polkavm`)
+                    logger.info(`📜 Add PVM contract ${name}`)
                     const bytecode = new Uint8Array(
                         contract.evm.bytecode.object
                             .match(/.{1,2}/g)!
                             .map((byte) => parseInt(byte, 16)),
                     )
-                    Deno.writeFileSync(
-                        join(pvmDir, `${name}.polkavm`),
-                        bytecode,
-                    )
+                    Deno.writeFileSync(pvmFile, bytecode)
                 }
             }
         }
+        writeCachedHash(pvmSourceMarkerFile, sourceHash)
+    } else if (!solcOnly) {
+        logger.debug(
+            `⏭️  Skipping PVM compilation for ${file.name} (unchanged)`,
+        )
+    }
+
+    if (!needsEvmCompilation) {
+        logger.debug(
+            `⏭️  Skipping EVM compilation for ${file.name} (unchanged)`,
+        )
+        continue
     }
 
-    console.log(`Compile with solc ${file.name}`)
-    const evmOut = JSON.parse(evmCompile(inputSources)) as SolcOutput
+    const evmOut = JSON.parse(
+        evmCompile(file, inputSources),
+    ) as resolc.SolcOutput
 
     if (evmOut.errors) {
         for (const error of evmOut.errors) {
-            console.error(error.formattedMessage)
+            logger.error(error.formattedMessage)
         }
 
         if (evmOut.errors.some((err) => err.severity !== 'warning')) {
@@ -119,21 +181,24 @@ for (const file of input) {
 
     for (const contracts of Object.values(evmOut.contracts)) {
         for (const [name, contract] of Object.entries(contracts)) {
-            console.log(`📜 Add EVM contract ${name}`)
+            const evmFile = join(evmDir, `${name}.bin`)
+            const abiFile = join(abiDir, `${name}.ts`)
 
             // Only write bytecode if it exists and is not empty
             if (contract.evm?.bytecode?.object) {
                 const bytecodeHex = contract.evm.bytecode.object
                 if (bytecodeHex.length > 0) {
+                    logger.info(`📜 Add EVM contract ${name}`)
                     const bytecode = new Uint8Array(
                         bytecodeHex
                             .match(/.{1,2}/g)!
                             .map((byte) => parseInt(byte, 16)),
                     )
-                    Deno.writeFileSync(join(evmDir, `${name}.bin`), bytecode)
+                    Deno.writeFileSync(evmFile, bytecode)
                 }
             }
 
+            logger.info(`📜 Add ABI ${name}`)
             const abi = contract.abi
             const abiName = `${name}Abi`
             const tsContent = `export const ${abiName} = ${
@@ -143,7 +208,14 @@ for (const file of input) {
                     2,
                 )
             } as const\n`
-            Deno.writeTextFileSync(join(abiDir, `${name}.ts`), tsContent)
+            Deno.writeTextFileSync(abiFile, tsContent)
         }
     }
+
+    // Mark that we've compiled this source file for EVM
+    writeCachedHash(evmSourceMarkerFile, sourceHash)
+
+    if (needsEvmCompilation || needsPvmCompilation) {
+        logger.info(`✅ Compiled ${file.name} successfully`)
+    }
 }