feat(ctb): Cannon contracts VM tests

packages/contracts-bedrock/scripts/differential-testing/differential-testing.go

@@ -5,7 +5,9 @@ import (
 	"fmt"
 	"math/big"
 	"os"
+	"strconv"
 
+	"github.com/ethereum-optimism/optimism/cannon/mipsevm"
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/crossdomain"
 	"github.com/ethereum/go-ethereum/accounts/abi"
@@ -60,6 +62,15 @@ var (
 	proveWithdrawalInputsArgs = abi.Arguments{
 		{Name: "inputs", Type: proveWithdrawalInputs},
 	}
+
+	// cannonMemoryProof inputs tuple (bytes32, bytes)
+	cannonMemoryProof, _ = abi.NewType("tuple", "CannonMemoryProof", []abi.ArgumentMarshaling{
+		{Name: "memRoot", Type: "bytes32"},
+		{Name: "proof", Type: "bytes"},
+	})
+	cannonMemoryProofArgs = abi.Arguments{
+		{Name: "encodedCannonMemoryProof", Type: cannonMemoryProof},
+	}
 )
 
 func main() {
@@ -312,6 +323,39 @@ func main() {
 
 		// Print the output
 		fmt.Print(hexutil.Encode(packed[32:]))
+	case "cannonMemoryProof":
+		// <pc, insn, [memAddr, memValue]>
+		mem := mipsevm.NewMemory()
+		if len(args) != 3 && len(args) != 5 {
+			panic("Error: cannonMemoryProofWithProof requires 2 or 4 arguments")
+		}
+		pc, err := strconv.ParseUint(args[1], 10, 32)
+		checkErr(err, "Error decocding addr")
+		insn, err := strconv.ParseUint(args[2], 10, 32)
+		checkErr(err, "Error decocding insn")
+		mem.SetMemory(uint32(pc), uint32(insn))
+
+		var insnProof, memProof [896]byte
+		if len(args) == 5 {
+			memAddr, err := strconv.ParseUint(args[3], 10, 32)
+			checkErr(err, "Error decocding memAddr")
+			memValue, err := strconv.ParseUint(args[4], 10, 32)
+			checkErr(err, "Error decocding memValue")
+			mem.SetMemory(uint32(memAddr), uint32(memValue))
+			memProof = mem.MerkleProof(uint32(memAddr))
+		}
+		insnProof = mem.MerkleProof(uint32(pc))
+
+		output := struct {
+			MemRoot common.Hash
+			Proof   []byte
+		}{
+			MemRoot: mem.MerkleRoot(),
+			Proof:   append(insnProof[:], memProof[:]...),
+		}
+		packed, err := cannonMemoryProofArgs.Pack(&output)
+		checkErr(err, "Error encoding output")
+		fmt.Print(hexutil.Encode(packed[32:]))
 	default:
 		panic(fmt.Errorf("Unknown command: %s", args[0]))
 	}

packages/contracts-bedrock/test/CommonTest.t.sol

@@ -678,6 +678,46 @@ contract FFIInterface is Test {
 
         return abi.decode(vm.ffi(cmds), (bytes32, bytes, bytes, bytes[]));
     }
+
+    function getCannonMemoryProof(uint32 pc, uint32 insn)
+     external
+    returns (
+        bytes32,
+        bytes memory
+    ) {
+        string[] memory cmds = new string[](4);
+        cmds[0] = "scripts/differential-testing/differential-testing";
+        cmds[1] = "cannonMemoryProof";
+        cmds[2] = vm.toString(pc);
+        cmds[3] = vm.toString(insn);
+        bytes memory result = vm.ffi(cmds);
+        (
+            bytes32 memRoot,
+            bytes memory proof
+        ) = abi.decode(result, (bytes32, bytes));
+        return (memRoot, proof);
+    }
+
+    function getCannonMemoryProof(uint32 pc, uint32 insn, uint32 memAddr, uint32 memVal)
+     external
+    returns (
+        bytes32,
+        bytes memory
+    ) {
+        string[] memory cmds = new string[](6);
+        cmds[0] = "scripts/differential-testing/differential-testing";
+        cmds[1] = "cannonMemoryProof";
+        cmds[2] = vm.toString(pc);
+        cmds[3] = vm.toString(insn);
+        cmds[4] = vm.toString(memAddr);
+        cmds[5] = vm.toString(memVal);
+        bytes memory result = vm.ffi(cmds);
+        (
+            bytes32 memRoot,
+            bytes memory proof
+        ) = abi.decode(result, (bytes32, bytes));
+        return (memRoot, proof);
+    }
 }
 
 // Used for testing a future upgrade beyond the current implementations.