import { mkdirSync, readFileSync, writeFileSync } from 'node:fs' import path from 'node:path' import { glob } from 'glob' import { Box, Newline, Text } from 'ink' import { option } from 'pastel' import { useEffect, useState } from 'react' import zod from 'zod' import RawOutput from '../components/RawOutput.js' import { formatJsonFailure, formatJsonSuccess } from '../utils/output.js' // Add command description for help output export const description = 'Compile Solidity smart contracts to bytecode and ABI\nExample: tevm compile --json' export const options = zod.object({ watch: zod .boolean() .default(false) .describe( option({ description: 'Watch for changes', alias: 'w', }), ), optimize: zod .boolean() .default(true) .describe( option({ description: 'Enable optimizations', defaultValueDescription: 'true', }), ), target: zod .enum(['es2015', 'es2020', 'esnext']) .default('es2020') .describe( option({ description: 'Compilation target', defaultValueDescription: 'es2020', }), ), }) type Props = { options: zod.infer } type CompileState = { status: 'compiling' | 'done' | 'error' artifacts: string[] errors: string[] } export default function Compile({ options }: Props) { const [state, setState] = useState({ status: 'compiling', artifacts: [], errors: [] }) useEffect(() => { const compileContracts = async (): Promise => { try { const cwd = process.cwd() const files = glob.sync('src/**/*.sol', { cwd, nodir: true }) if (files.length === 0) { setState({ status: 'error', artifacts: [], errors: ['No Solidity files found under src/**/*.sol'] }) return } const sources = Object.fromEntries( files.map((file) => [ file, { content: readFileSync(path.join(cwd, file), 'utf8'), }, ]), ) const input = { language: 'Solidity', sources, settings: { optimizer: { enabled: options.optimize, runs: 200, }, outputSelection: { '*': { '*': ['abi', 'evm.bytecode', 'evm.deployedBytecode'], }, }, }, } const solc = (await import('solc')).default const output = JSON.parse(solc.compile(JSON.stringify(input))) const errors = (output.errors ?? []) .filter((error: { severity?: string }) => error.severity === 'error') .map( (error: { formattedMessage?: string; message?: string }) => error.formattedMessage ?? error.message ?? String(error), ) if (errors.length > 0) { setState({ status: 'error', artifacts: [], errors }) return } const artifactsDir = path.join(cwd, 'artifacts') const artifacts: string[] = [] mkdirSync(artifactsDir, { recursive: true }) for (const [sourceName, contracts] of Object.entries(output.contracts ?? {}) as Array< [string, Record] >) { for (const [contractName, contract] of Object.entries(contracts)) { const artifactPath = path.join(artifactsDir, `${contractName}.json`) const bytecode = contract.evm?.bytecode?.object ? `0x${contract.evm.bytecode.object}` : '0x' const deployedBytecode = contract.evm?.deployedBytecode?.object ? `0x${contract.evm.deployedBytecode.object}` : '0x' writeFileSync( artifactPath, `${JSON.stringify( { contractName, sourceName, abi: contract.abi ?? [], bytecode, deployedBytecode, }, null, 2, )} `, ) artifacts.push(path.relative(cwd, artifactPath)) } } setState({ status: 'done', artifacts, errors: [] }) } catch (error) { setState({ status: 'error', artifacts: [], errors: [error instanceof Error ? error.message : String(error)], }) } } void compileContracts() if (!options.watch) { return } const interval = setInterval(() => void compileContracts(), 1000) return () => clearInterval(interval) }, [options.optimize, options.watch]) if (state.status === 'compiling') { return Compiling Solidity contracts... } if (state.status === 'error') { if (process.env['TEVM_JSON'] === 'true') { return } return ( Compilation failed: {state.errors.map((error, index) => ( - {error} ))} ) } if (process.env['TEVM_JSON'] === 'true') { return } return ( Compiled {state.artifacts.length} artifacts: {state.artifacts.map((artifact) => ( - {artifact} ))} {options.watch && Watching for changes...} ) }