Merge pull request #43 from ethereum-optimism/tip/contract-bindings

rvgo: Generate contract bindings

Author: ImTei

rvgo/Makefile

@@ -32,3 +32,20 @@ lint-check:
 lint-fix:
 	golangci-lint run --fix
 .PHONY: lint-fix
+
+build-bindgen:
+	cd ../rvsol/lib/optimism/op-bindings && \
+	go build -o ./bin/op-bindings ./cmd/. && \
+	cp ./bin/op-bindings ../../../../rvgo/
+.PHONY: build-bindgen
+
+bindgen-generate-local:
+	./op-bindings \
+		generate \
+		--metadata-out ./bindings \
+		--bindings-package bindings \
+		--contracts-list ../rvsol/artifacts.json \
+		--log.level info \
+		local \
+		--forge-artifacts ../rvsol/out
+.PHONY: bindgen-generate-local

rvgo/bindings/preimageoracle.go

@@ -0,0 +1,128 @@
+package bindings
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/ethereum-optimism/superchain-registry/superchain"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/solc"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+// layouts represents the set of storage layouts. It is populated in an init function.
+var layouts = make(map[string]*solc.StorageLayout)
+
+// deployedBytecodes represents the set of deployed bytecodes. It is populated
+// in an init function.
+var deployedBytecodes = make(map[string]string)
+
+var initBytecodes = make(map[string]string)
+var deploymentSalts = make(map[string]string)
+var deployers = make(map[string]string)
+
+// immutableReferences represents the set of immutable references. It is populated
+// in an init function.
+var immutableReferences = make(map[string]bool)
+
+// Create2DeployerCodeHash represents the codehash of the Create2Deployer contract.
+var Create2DeployerCodeHash = common.HexToHash("0xb0550b5b431e30d38000efb7107aaa0ade03d48a7198a140edda9d27134468b2")
+
+func init() {
+	code, err := superchain.LoadContractBytecode(superchain.Hash(Create2DeployerCodeHash))
+	if err != nil {
+		panic(err)
+	}
+	deployedBytecodes["Create2Deployer"] = common.Bytes2Hex(code)
+}
+
+// GetStorageLayout returns the storage layout of a contract by name.
+func GetStorageLayout(name string) (*solc.StorageLayout, error) {
+	layout := layouts[name]
+	if layout == nil {
+		return nil, fmt.Errorf("%s: storage layout not found", name)
+	}
+	return layout, nil
+}
+
+// GetDeployedBytecode returns the deployed bytecode of a contract by name.
+func GetDeployedBytecode(name string) ([]byte, error) {
+	bc := deployedBytecodes[name]
+	if bc == "" {
+		return nil, fmt.Errorf("%s: deployed bytecode not found", name)
+	}
+
+	if !isHex(bc) {
+		return nil, fmt.Errorf("%s: invalid deployed bytecode", name)
+	}
+
+	return common.FromHex(bc), nil
+}
+
+// HasImmutableReferences returns the immutable references of a contract by name.
+func HasImmutableReferences(name string) (bool, error) {
+	has, ok := immutableReferences[name]
+	if !ok {
+		return false, fmt.Errorf("%s: immutable reference not found", name)
+	}
+	return has, nil
+}
+
+func GetInitBytecode(name string) ([]byte, error) {
+	bc := initBytecodes[name]
+	if bc == "" {
+		return nil, fmt.Errorf("%s: init bytecode not found", name)
+	}
+
+	if !isHex(bc) {
+		return nil, fmt.Errorf("%s: invalid init bytecode", name)
+	}
+
+	return common.FromHex(bc), nil
+}
+
+func GetDeployerAddress(name string) ([]byte, error) {
+	addr := deployers[name]
+	if addr == "" {
+		return nil, fmt.Errorf("%s: deployer address not found", name)
+	}
+
+	if !common.IsHexAddress(addr) {
+		return nil, fmt.Errorf("%s: invalid deployer address", name)
+	}
+
+	return common.FromHex(addr), nil
+}
+
+func GetDeploymentSalt(name string) ([]byte, error) {
+	salt := deploymentSalts[name]
+	if salt == "" {
+		return nil, fmt.Errorf("%s: deployment salt not found", name)
+	}
+
+	if !isHex(salt) {
+		return nil, fmt.Errorf("%s: invalid deployment salt", name)
+	}
+
+	return common.FromHex(salt), nil
+}
+
+// isHexCharacter returns bool of c being a valid hexadecimal.
+func isHexCharacter(c byte) bool {
+	return ('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')
+}
+
+// isHex validates whether each byte is valid hexadecimal string.
+func isHex(str string) bool {
+	if len(str)%2 != 0 {
+		return false
+	}
+	str = strings.TrimPrefix(str, "0x")
+
+	for _, c := range []byte(str) {
+		if !isHexCharacter(c) {
+			return false
+		}
+	}
+	return true
+}

rvgo/bindings/preimageoracle_more.go

@@ -1,10 +1,11 @@
 package fast
 
 import (
-	"encoding/binary"
 	"errors"
 	"fmt"
+	"math/big"
 
+	"github.com/ethereum-optimism/asterisc/rvgo/bindings"
 	preimage "github.com/ethereum-optimism/optimism/op-preimage"
 	"github.com/ethereum/go-ethereum/common"
 )
@@ -22,34 +23,16 @@ type StepWitness struct {
 	PreimageOffset uint64
 }
 
-func uint64ToBytes32(v uint64) []byte {
-	var out [32]byte
-	binary.BigEndian.PutUint64(out[32-8:], v)
-	return out[:]
-}
-
-func (wit *StepWitness) EncodeStepInput(localContext LocalContext) []byte {
-	abiStatePadding := (32 - (uint64(len(wit.State)) % 32)) % 32
-	abiProofPadding := (32 - (uint64(len(wit.MemProof)) % 32)) % 32
-
-	var input []byte
-	input = append(input, StepBytes4...)
-	// state data offset in bytes
-	input = append(input, uint64ToBytes32(32*3)...)
-	// proof data offset in bytes
-	input = append(input, uint64ToBytes32(32*3+32+uint64(len(wit.State))+abiStatePadding)...)
-	// local context in bytes
-	input = append(input, common.Hash(localContext).Bytes()...)
-
-	// state data length in bytes
-	input = append(input, uint64ToBytes32(uint64(len(wit.State)))...)
-	input = append(input, wit.State[:]...)
-	input = append(input, make([]byte, abiStatePadding)...)
-	// proof data length in bytes
-	input = append(input, uint64ToBytes32(uint64(len(wit.MemProof)))...)
-	input = append(input, wit.MemProof[:]...)
-	input = append(input, make([]byte, abiProofPadding)...)
-	return input
+func (wit *StepWitness) EncodeStepInput(localContext LocalContext) ([]byte, error) {
+	abi, err := bindings.RISCVMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+	input, err := abi.Pack("step", wit.State, wit.MemProof, localContext)
+	if err != nil {
+		return nil, err
+	}
+	return input, nil
 }
 
 func (wit *StepWitness) HasPreimage() bool {
@@ -61,32 +44,38 @@ func (wit *StepWitness) EncodePreimageOracleInput(localContext LocalContext) ([]
 		return nil, errors.New("cannot encode pre-image oracle input, witness has no pre-image to proof")
 	}
 
+	preimageAbi, err := bindings.PreimageOracleMetaData.GetAbi()
+	if err != nil {
+		return nil, err
+	}
+
 	switch preimage.KeyType(wit.PreimageKey[0]) {
 	case preimage.LocalKeyType:
 		if len(wit.PreimageValue) > 32+8 {
 			return nil, fmt.Errorf("local pre-image exceeds maximum size of 32 bytes with key 0x%x", wit.PreimageKey)
 		}
-		var input []byte
-		input = append(input, LoadLocalDataBytes4...)
-		input = append(input, wit.PreimageKey[:]...)
-		input = append(input, common.Hash(localContext).Bytes()...)
-
 		preimagePart := wit.PreimageValue[8:]
 		var tmp [32]byte
 		copy(tmp[:], preimagePart)
-		input = append(input, tmp[:]...)
-		input = append(input, uint64ToBytes32(uint64(len(wit.PreimageValue)-8))...)
-		input = append(input, uint64ToBytes32(wit.PreimageOffset)...)
-		// Note: we can pad calldata to 32 byte multiple, but don't strictly have to
+		input, err := preimageAbi.Pack("loadLocalData",
+			new(big.Int).SetBytes(wit.PreimageKey[1:]),
+			localContext,
+			tmp,
+			new(big.Int).SetUint64(uint64(len(preimagePart))),
+			new(big.Int).SetUint64(uint64(wit.PreimageOffset)),
+		)
+		if err != nil {
+			return nil, err
+		}
 		return input, nil
 	case preimage.Keccak256KeyType:
-		var input []byte
-		input = append(input, LoadKeccak256PreimagePartBytes4...)
-		input = append(input, uint64ToBytes32(wit.PreimageOffset)...)
-		input = append(input, uint64ToBytes32(32+32)...) // partOffset, calldata offset
-		input = append(input, uint64ToBytes32(uint64(len(wit.PreimageValue))-8)...)
-		input = append(input, wit.PreimageValue[8:]...)
-		// Note: we can pad calldata to 32 byte multiple, but don't strictly have to
+		input, err := preimageAbi.Pack(
+			"loadKeccak256PreimagePart",
+			new(big.Int).SetUint64(uint64(wit.PreimageOffset)),
+			wit.PreimageValue[8:])
+		if err != nil {
+			return nil, err
+		}
 		return input, nil
 	default:
 		return nil, fmt.Errorf("unsupported pre-image type %d, cannot prepare preimage with key %x offset %d for oracle",

rvgo/bindings/registry.go

@@ -156,7 +156,8 @@ func stepEVM(t *testing.T, env *vm.EVM, wit *fast.StepWitness, addrs *Addresses,
 		require.NoError(t, err, "evm must not fail (ret: %x, gas: %d)", ret, startingGas-leftOverGas)
 	}
 
-	input := wit.EncodeStepInput(fast.LocalContext{})
+	input, err := wit.EncodeStepInput(fast.LocalContext{})
+	require.NoError(t, err)
 
 	ret, leftOverGas, err := env.Call(vm.AccountRef(addrs.Sender), addrs.RISCV, input, startingGas, big.NewInt(0))
 	if revertCode != nil {

rvgo/bindings/riscv.go

@@ -38,7 +38,9 @@ func runEVM(t *testing.T, contracts *Contracts, addrs *Addresses, stepWitness *f
 }
 
 func runSlow(t *testing.T, stepWitness *fast.StepWitness, fastPost fast.StateWitness, po slow.PreimageOracle, expectedErr interface{}) {
-	slowPostHash, err := slow.Step(stepWitness.EncodeStepInput(fast.LocalContext{}), po)
+	input, err := stepWitness.EncodeStepInput(fast.LocalContext{})
+	require.NoError(t, err)
+	slowPostHash, err := slow.Step(input, po)
 	if expectedErr != nil {
 		require.ErrorAs(t, err, expectedErr)
 	} else {