.github/workflows/checks.yml

@@ -29,6 +29,9 @@ jobs:
                   restore-keys: |
                       ${{ runner.os }}-yarn-
 
+            - name: update-resolc
+              run: yarn update-resolc
+
             - name: Install
               run: yarn install --immutable
 

.github/workflows/npm-release.yml

@@ -23,6 +23,9 @@ jobs:
             - name: Install
               run: yarn install --immutable
 
+            - name: update-resolc
+              run: yarn update-resolc
+
             - name: Build
               run: yarn build
 
@@ -37,7 +40,7 @@ jobs:
                   name: package
                   path: 'parity-revive-*.tgz'
 
-            - uses: octokit/request-action@v2.3.0
+            - uses: octokit/request-action@bbedc70b1981e610d89f1f8de88311a1fc02fb83
               with:
                   route: POST /repos/paritytech/npm_publish_automation/actions/workflows/publish.yml/dispatches
                   ref: main

.gitignore

@@ -1,4 +1,6 @@
 # Based on https://raw.githubusercontent.com/github/gitignore/main/Node.gitignore
+src/resolc/resolc.js
+src/resolc/resolc.wasm
 
 # Logs
 

eslint.config.mjs

@@ -1,12 +1,11 @@
-import globals from "globals";
-import pluginJs from "@eslint/js";
-import tseslint from "typescript-eslint";
-
+import globals from 'globals'
+import pluginJs from '@eslint/js'
+import tseslint from 'typescript-eslint'
 
 /** @type {import('eslint').Linter.Config[]} */
 export default [
-  {files: ["**/*.{js,mjs,cjs,ts}"]},
-  {languageOptions: { globals: globals.browser }},
-  pluginJs.configs.recommended,
-  ...tseslint.configs.recommended,
-];
+    { files: ['**/*.{mjs,ts}'] },
+    { languageOptions: { globals: globals.browser } },
+    pluginJs.configs.recommended,
+    ...tseslint.configs.recommended,
+]

package.json

@@ -17,8 +17,9 @@
         "dist"
     ],
     "scripts": {
-        "build": "tsc",
-        "lint": "npx eslint 'src/**/*.{cjs,js,ts}' && npx prettier --check '**/*.{ts,json,yml,md}'",
+        "update-resolc": "node ./scripts/update-resolc.js",
+        "build": "tsc && cp src/resolc/** dist/resolc",
+        "lint": "npx eslint 'src/**/*.{cjs,ts}' && npx prettier --check '**/*.{ts,json,yml,md}'",
         "lint:fix": "npx prettier --write '**/*.{ts,json,yml,md}'",
         "test": "npm run build && node ./dist/index.test.js"
     },

scripts/update-resolc.js

@@ -0,0 +1,50 @@
+const fs = require('fs')
+
+async function main() {
+    const headers = { 'content-type': 'application/json' }
+
+    let asset_url = ''
+    try {
+        const response = await fetch(
+            'https://api.github.com/repos/paritytech/revive/releases/latest',
+            { headers }
+        )
+
+        const json = await response.json()
+        console.log(`Using release ${json.name}`)
+
+        asset_url = json.assets_url
+    } catch (error) {
+        console.error(`Failed to get asset_url: ${error}`)
+        process.exit(1)
+    }
+
+    let assets = []
+    try {
+        const response = await fetch(asset_url)
+        assets = await response.json()
+    } catch (error) {
+        console.error(`Failed to get download_url: ${error}`)
+        process.exit(1)
+    }
+
+    try {
+        for (const assetName of ['resolc.wasm', 'resolc.js']) {
+            const asset = assets.find((asset) => asset.name == assetName)
+            const response = await fetch(asset.browser_download_url, {
+                headers: {
+                    'content-type': 'application/octet-stream',
+                },
+            })
+            const data = await response.arrayBuffer()
+
+            fs.writeFileSync(`src/resolc/${assetName}`, Buffer.from(data))
+            console.log(`src/resolc/${assetName} updated`)
+        }
+    } catch (error) {
+        console.error(`Failed to download wasm: ${error}`)
+        process.exit(1)
+    }
+}
+
+main()

src/index.test.ts

@@ -3,19 +3,36 @@ import { readFileSync } from 'node:fs'
 import assert from 'node:assert'
 import { compile, tryResolveImport } from '.'
 import { resolve } from 'node:path'
+import { execSync } from 'node:child_process'
 
-test('check Ok output', async () => {
-    const contract = 'contracts/1_Storage.sol'
-    const sources = {
-        [contract]: {
-            content: readFileSync('fixtures/storage.sol', 'utf8'),
-        },
+function isResolcInPath() {
+    try {
+        execSync('resolc --version', { stdio: 'ignore' })
+        return true
+    } catch {
+        return false
     }
+}
 
-    const out = await compile(sources)
-    assert(out.contracts[contract].Storage.abi != null)
-    assert(out.contracts[contract].Storage.evm.bytecode != null)
-})
+const compileOptions = [{}]
+if (isResolcInPath()) {
+    compileOptions.push({ bin: 'resolc' })
+}
+
+for (const options of compileOptions) {
+    test(`check Ok output with option ${JSON.stringify(options)}`, async () => {
+        const contract = 'fixtures/token.sol'
+        const sources = {
+            [contract]: {
+                content: readFileSync('fixtures/storage.sol', 'utf8'),
+            },
+        }
+
+        const out = await compile(sources, options)
+        assert(out.contracts[contract].Storage.abi != null)
+        assert(out.contracts[contract].Storage.evm.bytecode != null)
+    })
+}
 
 test('check Err output', async () => {
     const contract = 'contracts/1_Storage.sol'

src/index.ts

@@ -1,4 +1,6 @@
 import solc from 'solc'
+import { spawn } from 'child_process'
+import { resolc } from './resolc'
 import path from 'path'
 import { existsSync, readFileSync } from 'fs'
 
@@ -22,7 +24,7 @@ type SolcError = {
     type: string
 }
 
-type SolcOutput = {
+export type SolcOutput = {
     contracts: {
         [contractPath: string]: {
             [contractName: string]: {
@@ -84,42 +86,28 @@ export function resolveInputs(sources: SolcInput): SolcInput {
     )
 }
 
-export async function compile(sources: SolcInput): Promise<SolcOutput> {
-    // compile with solc to resolve all the imports
-    sources = resolveInputs(sources)
-
-    const body = {
-        cmd: '--standard-json',
-        input: JSON.stringify({
-            language: 'Solidity',
-            sources,
-            settings: {
-                optimizer: { enabled: true, runs: 200 },
-                outputSelection: {
-                    '*': {
-                        '*': ['abi'],
-                    },
+export async function compile(
+    sources: SolcInput,
+    option: { bin?: string } = {}
+): Promise<SolcOutput> {
+    const input = JSON.stringify({
+        language: 'Solidity',
+        sources: resolveInputs(sources),
+        settings: {
+            optimizer: { enabled: true, runs: 200 },
+            outputSelection: {
+                '*': {
+                    '*': ['abi'],
                 },
             },
-        }),
-    }
-
-    const BACKENDROOT_URL =
-        process.env.REMIX_BACKEND ?? 'https://remix-backend.polkadot.io'
-    const response = await fetch(`${BACKENDROOT_URL}/resolc`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
         },
-        body: JSON.stringify(body),
     })
 
-    if (!response.ok) {
-        const text = await response.text().catch(() => '')
-        throw new Error(`${response.statusText}: ${text}`)
+    if (option.bin) {
+        return compileWithBin(input, option.bin)
     }
 
-    return (await response.json()) as SolcOutput
+    return resolc(input)
 }
 
 /**
@@ -175,3 +163,35 @@ export function tryResolveImport(importPath: string) {
         throw new Error(`Resolved path ${resolvedPath} does not exist.`)
     }
 }
+function compileWithBin(input: string, bin: string): PromiseLike<SolcOutput> {
+    return new Promise((resolve, reject) => {
+        const process = spawn(bin, ['--standard-json'])
+
+        let output = ''
+        let error = ''
+
+        process.stdin.write(input)
+        process.stdin.end()
+
+        process.stdout.on('data', (data) => {
+            output += data.toString()
+        })
+
+        process.stderr.on('data', (data) => {
+            error += data.toString()
+        })
+
+        process.on('close', (code) => {
+            if (code === 0) {
+                try {
+                    const result: SolcOutput = JSON.parse(output)
+                    resolve(result)
+                } catch {
+                    reject(new Error(`Failed to parse output`))
+                }
+            } else {
+                reject(new Error(`Process exited with code ${code}: ${error}`))
+            }
+        })
+    })
+}

src/resolc.ts

@@ -0,0 +1,11 @@
+import soljson from 'solc/soljson'
+import Resolc from './resolc/resolc'
+import type { SolcOutput } from '.'
+
+export function resolc(input: string): SolcOutput {
+    const m = Resolc() as any // eslint-disable-line @typescript-eslint/no-explicit-any
+    m.soljson = soljson
+    m.writeToStdin(input)
+    m.callMain(['--standard-json'])
+    return JSON.parse(m.readFromStdout()) as SolcOutput
+}

src/solc.d.ts

@@ -1,3 +1,5 @@
+declare module 'solc/soljson' {}
+
 declare module 'solc' {
     // Basic types for input/output handling
     export interface CompileInput {