feat: precompile Solidity testing in pure Go

.github/workflows/tests.yml

@@ -74,6 +74,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          submodules: true
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
@@ -92,6 +93,18 @@ jobs:
       - name: Hardhat Compile
         run: npx hardhat compile
         working-directory: ./contracts
+      - name: Install solc
+        shell: bash
+        run: sudo add-apt-repository ppa:ethereum/ethereum && sudo apt update && sudo apt install -y solc
+      - name: Install abigen
+        shell: bash
+        run: go install github.com/ava-labs/subnet-evm/cmd/abigen
+      - name: Generate abigen bindings
+        shell: bash
+        run: go generate ./contracts/... ./testing/...
+      - name: Confirm abigen bindings up to date
+        shell: bash
+        run: .github/workflows/check-clean-branch.sh
       - name: Install AvalancheGo Release
         shell: bash
         run: BASEDIR=/tmp/e2e-test AVALANCHEGO_BUILD_PATH=/tmp/e2e-test/avalanchego ./scripts/install_avalanchego_release.sh

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "testing/dstest/internal/ds-test"]
+	path = testing/dstest/internal/ds-test
+	url = https://github.com/dapphub/ds-test.git

contracts/contracts/Empty.sol

@@ -0,0 +1,5 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+/// @dev Noop contract that can be deployed by example / test contracts.
+contract Empty {}

contracts/contracts/ExampleDeployerList.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.24;
 
 import "@openzeppelin/contracts/access/Ownable.sol";
 import "./interfaces/IAllowList.sol";
+import {Empty} from "./Empty.sol";
 import "./AllowList.sol";
 
 address constant DEPLOYER_LIST = 0x0200000000000000000000000000000000000000;
@@ -14,9 +15,6 @@ contract ExampleDeployerList is AllowList {
   constructor() AllowList(DEPLOYER_LIST) {}
 
   function deployContract() public {
-    new Example();
+    new Empty();
   }
 }
-
-// This is an empty contract that can be used to test contract deployment
-contract Example {}

contracts/contracts/ExampleTxAllowList.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.24;
 
 import "./AllowList.sol";
+import {Empty} from "./Empty.sol";
 import "./interfaces/IAllowList.sol";
 
 // Precompiled Allow List Contract Address
@@ -13,8 +14,6 @@ contract ExampleTxAllowList is AllowList {
   constructor() AllowList(TX_ALLOW_LIST) {}
 
   function deployContract() public {
-    new Example();
+    new Empty();
   }
 }
-
-contract Example {}

contracts/contracts_test.go

@@ -0,0 +1,50 @@
+package contracts
+
+import (
+	"testing"
+
+	"github.com/ava-labs/subnet-evm/params"
+	"github.com/ava-labs/subnet-evm/testing/evmsim"
+)
+
+//go:generate sh -c "go run $(git rev-parse --show-toplevel)/scripts/abigen --solc.include-path=./node_modules --abigen.pkg=contracts contracts/**/*.sol > generated_test.go"
+
+func newEVMSim(tb testing.TB, genesis params.Precompiles) *evmsim.Backend {
+	tb.Helper()
+
+	cfg := &evmsim.Config{
+		GenesisPrecompiles: genesis,
+	}
+	return cfg.NewWithHexKeys(tb, keys())
+}
+
+// keys returns the hex-encoded private keys of the testing accounts; these
+// identically match the accounts used in the Hardhat config.
+func keys() []string {
+	return []string{
+		"0x56289e99c94b6912bfc12adc093c9b51124f0dc54ac7a766b2bc5ccf558d8027",
+		"0x7b4198529994b0dc604278c99d153cfd069d594753d471171a1d102a10438e07",
+		"0x15614556be13730e9e8d6eacc1603143e7b96987429df8726384c2ec4502ef6e",
+		"0x31b571bf6894a248831ff937bb49f7754509fe93bbd2517c9c73c4144c0e97dc",
+		"0x6934bef917e01692b789da754a0eae31a8536eb465e7bff752ea291dad88c675",
+		"0xe700bdbdbc279b808b1ec45f8c2370e4616d3a02c336e68d85d4668e08f53cff",
+		"0xbbc2865b76ba28016bc2255c7504d000e046ae01934b04c694592a6276988630",
+		"0xcdbfd34f687ced8c6968854f8a99ae47712c4f4183b78dcc4a903d1bfe8cbf60",
+		"0x86f78c5416151fe3546dece84fda4b4b1e36089f2dbc48496faf3a950f16157c",
+		"0x750839e9dbbd2a0910efe40f50b2f3b2f2f59f5580bb4b83bd8c1201cf9a010a",
+	}
+}
+
+// Convenience labels for using an account by name instead of number.
+const (
+	admin = iota
+	_
+	_
+	_
+	_
+	_
+	_
+	_
+	_
+	allowlistOther
+)

contracts/txallowlist_test.go

@@ -0,0 +1,81 @@
+package contracts
+
+import (
+	"context"
+	"testing"
+
+	"github.com/ava-labs/subnet-evm/core/types"
+	"github.com/ava-labs/subnet-evm/params"
+	"github.com/ava-labs/subnet-evm/testing/dstest"
+	"github.com/ava-labs/subnet-evm/testing/evmsim"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/subnet-evm/precompile/contracts/txallowlist"
+	_ "github.com/ava-labs/subnet-evm/precompile/registry"
+)
+
+func TestAllowList(t *testing.T) {
+	// This is a demonstration of a Go implementation of the Hardhat tests:
+	// https://github.com/ava-labs/subnet-evm/blob/dc1d78da/contracts/test/tx_allow_list.ts
+
+	ctx := context.Background()
+
+	sim := newEVMSim(t, params.Precompiles{
+		txallowlist.ConfigKey: txallowlist.NewConfig(
+			new(uint64),
+			[]common.Address{common.HexToAddress("0x8db97C7cEcE249c2b98bDC0226Cc4C2A57BF52FC")},
+			nil, nil,
+		),
+	})
+
+	allow := evmsim.Bind(t, sim, NewIAllowList, txallowlist.ContractAddress)
+	allowSess := &IAllowListSession{
+		Contract:     allow,
+		TransactOpts: *sim.From(admin),
+	}
+
+	sutAddr, sut := evmsim.Deploy(t, sim, admin, DeployExampleTxAllowListTest)
+	sutSess := &ExampleTxAllowListTestSession{
+		Contract:     sut,
+		TransactOpts: *sim.From(admin),
+	}
+	parser := dstest.New(sutAddr)
+
+	_, err := allowSess.SetAdmin(sutAddr)
+	require.NoErrorf(t, err, "%T.SetAdmin(%T address)", allow, sut)
+
+	_, err = sutSess.SetUp()
+	require.NoErrorf(t, err, "%T.SetUp()", sut)
+
+	// TODO: This table of steps is purely to demonstrate a *direct*
+	// reimplementation of the Hardhat tests in Go. I (arr4n) believe we should
+	// refactor the tests before a complete translation, primarily to reduce the
+	// number of calls that have to happen here. Also note that the original
+	// tests use a `beforeEach()` whereas the above preamble is equivalent to a
+	// `beforeAll()`.
+	for _, step := range []struct {
+		name string
+		fn   (func() (*types.Transaction, error))
+	}{
+		{"should add contract deployer as admin", sutSess.StepContractOwnerIsAdmin},
+		{"precompile should see admin address has admin role", sutSess.StepPrecompileHasDeployerAsAdmin},
+		{"precompile should see test address has no role", sutSess.StepNewAddressHasNoRole},
+	} {
+		t.Run(step.name, func(t *testing.T) {
+			tx, err := step.fn()
+			require.NoError(t, err, "running step")
+
+			// TODO(arr4n): DSTest can be used for general logging, so the
+			// following pattern is only valid when we don't use it as such.
+			// Failing assertions, however, set a private `failed` boolean,
+			// which we need to expose. Alternatively, they also hook into HEVM
+			// cheatcodes if they're implemented; having these would be useful
+			// for testing in general.
+			failures := parser.ParseTB(ctx, t, tx, sim)
+			if len(failures) > 0 {
+				t.Errorf("Assertion failed:\n%s", failures)
+			}
+		})
+	}
+}

scripts/abigen/abigen.go

@@ -0,0 +1,106 @@
+// The abigen command runs `solc | abigen` and writes the generated bindings to
+// stdout.
+package main
+
+import (
+	"bytes"
+	"context"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"regexp"
+)
+
+func main() {
+	var c config
+
+	flag.StringVar(&c.solc.version, "solc.version", "0.8.26", "Version of solc expected; the version used will be sourced from $PATH")
+	flag.StringVar(&c.solc.evmVersion, "solc.evm-version", "paris", "solc --evm-version flag")
+	flag.StringVar(&c.solc.basePath, "solc.base-path", "./", "solc --base-path flag")
+	flag.StringVar(&c.solc.includePath, "solc.include-path", "", "solc --include-path flag; only propagated if not empty")
+	flag.StringVar(&c.solc.output, "solc.output", "abi,bin", "solc --combined-json flag")
+	flag.StringVar(&c.abigen.pkg, "abigen.pkg", "", "abigen --pkg flag")
+
+	help := flag.Bool("help", false, "Print usage message")
+	flag.Parse()
+	if *help {
+		flag.Usage()
+		os.Exit(0)
+	}
+
+	if err := c.run(context.Background(), os.Stdout, os.Stderr); err != nil {
+		fmt.Fprint(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+type config struct {
+	solc struct {
+		version, evmVersion, basePath, includePath, output string
+	}
+	abigen struct {
+		pkg string
+	}
+}
+
+func (cfg *config) run(ctx context.Context, stdout, stderr io.Writer) error {
+	solcV := exec.CommandContext(ctx, "solc", "--version")
+	buf, err := solcV.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("solc --version: %v", err)
+	}
+	if !bytes.Contains(buf, []byte(cfg.solc.version)) {
+		fmt.Fprintf(stderr, "solc --version:\n%s", buf)
+		return fmt.Errorf("solc version mismatch; not %q", cfg.solc.version)
+	}
+
+	args := append(nonEmptyArgs(map[string]string{
+		"--evm-version":   cfg.solc.evmVersion,
+		"--base-path":     cfg.solc.basePath,
+		"--include-path":  cfg.solc.includePath,
+		"--combined-json": cfg.solc.output,
+	}), flag.Args()...)
+
+	solc := exec.CommandContext(ctx, "solc", args...)
+	// Although we could use io.Pipe(), it's much easier to reason about
+	// non-concurrent processes, and solc doesn't create huge outputs.
+	var solcOut bytes.Buffer
+	solc.Stdout = &solcOut
+	solc.Stderr = stderr
+	if err := solc.Run(); err != nil {
+		return fmt.Errorf("solc: %w", err)
+	}
+
+	abigen := exec.CommandContext(ctx, "abigen", nonEmptyArgs(map[string]string{
+		"--combined-json": "-", // stdin
+		"--pkg":           cfg.abigen.pkg,
+	})...)
+	abigen.Stdin = &solcOut
+	var abigenOut bytes.Buffer
+	abigen.Stdout = &abigenOut
+	abigen.Stderr = stderr
+	if err := abigen.Run(); err != nil {
+		return fmt.Errorf("abigen: %w", err)
+	}
+
+	re := regexp.MustCompile(`"github\.com/ethereum/go-ethereum/(accounts|core)/`)
+	_, err = stdout.Write(re.ReplaceAll(
+		abigenOut.Bytes(),
+		[]byte(`"github.com/ava-labs/subnet-evm/${1}/`)),
+	)
+	return err
+}
+
+// nonEmptyArgs returns a slice of arguments suitable for use with exec.Command.
+// Any empty values are skipped.
+func nonEmptyArgs(from map[string]string) []string {
+	var args []string
+	for k, v := range from {
+		if v != "" {
+			args = append(args, k, v)
+		}
+	}
+	return args
+}

testing/dstest/FakeTest.t.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.0;
+
+import {DSTest} from "ds-test/src/test.sol";
+
+contract FakeTest is DSTest {
+    event NotFromDSTest();
+
+    function logNonDSTest() external {
+        emit NotFromDSTest();
+    }
+
+    function logString(string memory s) external {
+        emit log(s);
+    }
+
+    function logNamedAddress(string memory name, address addr) external {
+        emit log_named_address(name, addr);
+    }
+}