MTCannon: Fix AssertEVMReverts to correctly construct data

cannon/mipsevm/multithreaded/state.go

@@ -231,7 +231,6 @@ func (s *State) EncodeThreadProof() []byte {
 	out := make([]byte, 0, THREAD_WITNESS_SIZE)
 	out = append(out, threadBytes[:]...)
 	out = append(out, otherThreadsWitness[:]...)
-
 	return out
 }
 

cannon/mipsevm/multithreaded/testutil/mutators.go

@@ -93,3 +93,7 @@ func (m *StateMutatorMultiThreaded) SetPreimageOffset(val uint32) {
 func (m *StateMutatorMultiThreaded) SetStep(val uint64) {
 	m.state.Step = val
 }
+
+func (m *StateMutatorMultiThreaded) SetRegisters(index uint32, val uint32) {
+	m.state.GetRegistersRef()[index] = val
+}

cannon/mipsevm/singlethreaded/testutil/state.go

@@ -79,3 +79,7 @@ func (m *StateMutatorSingleThreaded) SetPreimageOffset(val uint32) {
 func (m *StateMutatorSingleThreaded) SetStep(val uint64) {
 	m.state.Step = val
 }
+
+func (m *StateMutatorSingleThreaded) SetRegisters(index uint32, val uint32) {
+	m.state.GetRegistersRef()[index] = val
+}

cannon/mipsevm/tests/evm_common_test.go

@@ -499,24 +499,31 @@ func TestEVMFault(t *testing.T) {
 		name   string
 		nextPC uint32
 		insn   uint32
+		errMsg string
 	}{
-		{"illegal instruction", 0, 0xFF_FF_FF_FF},
-		{"branch in delay-slot", 8, 0x11_02_00_03},
-		{"jump in delay-slot", 8, 0x0c_00_00_0c},
+		{"illegal instruction", 0, 0xFF_FF_FF_FF, "invalid instruction"},
+		{"branch in delay-slot", 8, 0x11_02_00_03, "branch in delay slot"},
+		{"jump in delay-slot", 8, 0x0c_00_00_0c, "jump in delay slot"},
 	}
 
 	for _, v := range versions {
 		for _, tt := range cases {
 			testName := fmt.Sprintf("%v (%v)", tt.name, v.Name)
 			t.Run(testName, func(t *testing.T) {
-				goVm := v.VMFactory(nil, os.Stdout, os.Stderr, testutil.CreateLogger(), testutil.WithNextPC(tt.nextPC))
+				// set the return address ($ra) to jump into when test completes
+				goVm := v.VMFactory(nil, os.Stdout, os.Stderr, testutil.CreateLogger(), testutil.WithNextPC(tt.nextPC), testutil.WithRegisters(31, testutil.EndAddr))
+				proofData := v.ThreadProofEncoder(nil, os.Stdout, os.Stderr, testutil.CreateLogger(), testutil.WithNextPC(tt.nextPC), testutil.WithRegisters(31, testutil.EndAddr))
 				state := goVm.GetState()
 				state.GetMemory().SetMemory(0, tt.insn)
-				// set the return address ($ra) to jump into when test completes
-				state.GetRegistersRef()[31] = testutil.EndAddr
-
+				statePCs := []uint32{state.GetPC()}
+				// TODO: Hardcode here to achieve the expected result.
+				// Future improvements might involve having the Go VM indicate attempted memory accesses
+				// and caching this info to generate proofs for the solidity VM.
+				if tt.errMsg == "invalid instruction" {
+					statePCs = append(statePCs, 0xa7ef00cc)
+				}
 				require.Panics(t, func() { _, _ = goVm.Step(true) })
-				testutil.AssertEVMReverts(t, state, v.Contracts, tracer)
+				testutil.AssertEVMReverts(t, state, v.Contracts, tracer, statePCs, proofData, &tt.errMsg)
 			})
 		}
 	}

cannon/mipsevm/tests/evm_multithreaded_test.go

@@ -1179,10 +1179,14 @@ func TestEVM_UnsupportedSyscall(t *testing.T) {
 			// Setup basic getThreadId syscall instruction
 			state.Memory.SetMemory(state.GetPC(), syscallInsn)
 			state.GetRegistersRef()[2] = syscallNum
+			proofData := state.EncodeThreadProof()
 
+			statePCs := []uint32{state.GetPC()}
 			// Set up post-state expectations
 			require.Panics(t, func() { _, _ = goVm.Step(true) })
-			testutil.AssertEVMReverts(t, state, contracts, tracer)
+
+			errorMessage := "MIPS2: unimplemented syscall"
+			testutil.AssertEVMReverts(t, state, contracts, tracer, statePCs, proofData, &errorMessage)
 		})
 	}
 }

cannon/mipsevm/tests/helpers.go

@@ -50,31 +50,50 @@ func multiThreadElfVmFactory(t require.TestingT, elfFile string, po mipsevm.Prei
 	return fpvm
 }
 
+type ThreadProofEncoder func(po mipsevm.PreimageOracle, stdOut, stdErr io.Writer, log log.Logger, opts ...testutil.StateOption) []byte
+
+func singalThreadProofEncoder(po mipsevm.PreimageOracle, stdOut, stdErr io.Writer, log log.Logger, opts ...testutil.StateOption) []byte {
+	return nil
+}
+
+func multiThreadProofEncoder(po mipsevm.PreimageOracle, stdOut, stdErr io.Writer, log log.Logger, opts ...testutil.StateOption) []byte {
+	state := multithreaded.CreateEmptyState()
+	mutator := mttestutil.NewStateMutatorMultiThreaded(state)
+	for _, opt := range opts {
+		opt(mutator)
+	}
+	proofData := state.EncodeThreadProof()
+	return proofData
+}
+
 type VersionedVMTestCase struct {
-	Name         string
-	Contracts    *testutil.ContractMetadata
-	StateHashFn  mipsevm.HashFn
-	VMFactory    VMFactory
-	ElfVMFactory ElfVMFactory
+	Name               string
+	Contracts          *testutil.ContractMetadata
+	StateHashFn        mipsevm.HashFn
+	VMFactory          VMFactory
+	ElfVMFactory       ElfVMFactory
+	ThreadProofEncoder ThreadProofEncoder
 }
 
 func GetSingleThreadedTestCase(t require.TestingT) VersionedVMTestCase {
 	return VersionedVMTestCase{
-		Name:         "single-threaded",
-		Contracts:    testutil.TestContractsSetup(t, testutil.MipsSingleThreaded),
-		StateHashFn:  singlethreaded.GetStateHashFn(),
-		VMFactory:    singleThreadedVmFactory,
-		ElfVMFactory: singleThreadElfVmFactory,
+		Name:               "single-threaded",
+		Contracts:          testutil.TestContractsSetup(t, testutil.MipsSingleThreaded),
+		StateHashFn:        singlethreaded.GetStateHashFn(),
+		VMFactory:          singleThreadedVmFactory,
+		ElfVMFactory:       singleThreadElfVmFactory,
+		ThreadProofEncoder: singalThreadProofEncoder,
 	}
 }
 
 func GetMultiThreadedTestCase(t require.TestingT) VersionedVMTestCase {
 	return VersionedVMTestCase{
-		Name:         "multi-threaded",
-		Contracts:    testutil.TestContractsSetup(t, testutil.MipsMultithreaded),
-		StateHashFn:  multithreaded.GetStateHashFn(),
-		VMFactory:    multiThreadedVmFactory,
-		ElfVMFactory: multiThreadElfVmFactory,
+		Name:               "multi-threaded",
+		Contracts:          testutil.TestContractsSetup(t, testutil.MipsMultithreaded),
+		StateHashFn:        multithreaded.GetStateHashFn(),
+		VMFactory:          multiThreadedVmFactory,
+		ElfVMFactory:       multiThreadElfVmFactory,
+		ThreadProofEncoder: multiThreadProofEncoder,
 	}
 }
 

cannon/mipsevm/testutil/mips.go

@@ -8,6 +8,7 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/state"
@@ -181,21 +182,37 @@ func ValidateEVM(t *testing.T, stepWitness *mipsevm.StepWitness, step uint64, go
 }
 
 // AssertEVMReverts runs a single evm step from an FPVM prestate and asserts that the VM panics
-func AssertEVMReverts(t *testing.T, state mipsevm.FPVMState, contracts *ContractMetadata, tracer *tracing.Hooks) {
-	insnProof := state.GetMemory().MerkleProof(state.GetPC())
+func AssertEVMReverts(t *testing.T, state mipsevm.FPVMState, contracts *ContractMetadata, tracer *tracing.Hooks, statePCs []uint32, ProofData []byte, expectedReason *string) {
+	for _, pc := range statePCs {
+		proof := state.GetMemory().MerkleProof(pc)
+		ProofData = append(ProofData, proof[:]...)
+	}
 	encodedWitness, _ := state.EncodeWitness()
 	stepWitness := &mipsevm.StepWitness{
 		State:     encodedWitness,
-		ProofData: insnProof[:],
+		ProofData: ProofData,
 	}
 	input := EncodeStepInput(t, stepWitness, mipsevm.LocalContext{}, contracts.Artifacts.MIPS)
 	startingGas := uint64(30_000_000)
 
 	env, evmState := NewEVMEnv(contracts)
 	env.Config.Tracer = tracer
 	sender := common.Address{0x13, 0x37}
-	_, _, err := env.Call(vm.AccountRef(sender), contracts.Addresses.MIPS, input, startingGas, common.U2560)
+	ret, _, err := env.Call(vm.AccountRef(sender), contracts.Addresses.MIPS, input, startingGas, common.U2560)
 	require.EqualValues(t, err, vm.ErrExecutionReverted)
+
+	if expectedReason != nil {
+		reason := ""
+		if len(ret) > 4 { // 4 bytes for the error selector
+			unpacked, decodeErr := abi.UnpackRevert(ret)
+			if decodeErr == nil {
+				reason = unpacked
+			}
+		}
+
+		require.Equal(t, *expectedReason, reason, "Revert reason mismatch")
+	}
+
 	logs := evmState.Logs()
 	require.Equal(t, 0, len(logs))
 }

cannon/mipsevm/testutil/state.go

@@ -43,6 +43,7 @@ type StateMutator interface {
 	SetExited(val bool)
 	SetStep(val uint64)
 	SetLastHint(val hexutil.Bytes)
+	SetRegisters(index uint32, val uint32)
 	Randomize(randSeed int64)
 }
 
@@ -103,6 +104,12 @@ func WithRandomization(seed int64) StateOption {
 	}
 }
 
+func WithRegisters(index uint32, val uint32) StateOption {
+	return func(state StateMutator) {
+		state.SetRegisters(index, val)
+	}
+}
+
 func AlignPC(pc uint32) uint32 {
 	// Memory-align random pc and leave room for nextPC
 	pc = pc & 0xFF_FF_FF_FC // Align address