interesting
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

core/vm/program: evm bytecode-building utility (#30725) 

In many cases, there is a need to create somewhat nontrivial bytecode. A
recent example is the verkle statetests, where we want a `CREATE2`- op
to create a contract, which can then be invoked, and when invoked does a
selfdestruct-to-self.

It is overkill to go full solidity, but it is also a bit tricky do
assemble this by concatenating bytes. This PR takes an approach that
has been used in in goevmlab for several years.

Using this utility, the case can be expressed as: 
```golang
	// Some runtime code
	runtime := program.New().Ops(vm.ADDRESS, vm.SELFDESTRUCT).Bytecode()
	// A constructor returning the runtime code
	initcode := program.New().ReturnData(runtime).Bytecode()
	// A factory invoking the constructor
	outer := program.New().Create2AndCall(initcode, nil).Bytecode()
```

We have a lot of places in the codebase where we concatenate bytes, cast
from `vm.OpCode` . By taking tihs approach instead, thos places can be made a
bit more maintainable/robust.
This commit is contained in:
Martin HS 2024-11-20 08:40:21 +01:00 committed by GitHub
parent aa63692129
commit 6d3d252a5e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
4 changed files with 834 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

430
core/vm/program/program.go Normal file
View File

@ -0,0 +1,430 @@
// Copyright 2024 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the goevmlab library. If not, see <http://www.gnu.org/licenses/>.
// package program is a utility to create EVM bytecode for testing, but _not_ for production. As such:
//
// - There are not package guarantees. We might iterate heavily on this package, and do backwards-incompatible changes without warning
// - There are no quality-guarantees. These utilities may produce evm-code that is non-functional. YMMV.
// - There are no stability-guarantees. The utility will `panic` if the inputs do not align / make sense.
package program
import (
"fmt"
"math/big"
"github.com/ethereum/go-ethereum/core/vm"
"github.com/holiman/uint256"
)
// Program is a simple bytecode container. It can be used to construct
// simple EVM programs. Errors during construction of a Program typically
// cause panics: so avoid using these programs in production settings or on
// untrusted input.
// This package is mainly meant to aid in testing. This is not a production
// -level "compiler".
type Program struct {
code []byte
}
// New creates a new Program
func New() *Program {
return &Program{
code: make([]byte, 0),
}
}
// add adds the op to the code.
func (p *Program) add(op byte) *Program {
p.code = append(p.code, op)
return p
}
// pushBig creates a PUSHX instruction and pushes the given val.
// - If the val is nil, it pushes zero
// - If the val is bigger than 32 bytes, it panics
func (p *Program) doPush(val *uint256.Int) {
if val == nil {
val = new(uint256.Int)
}
valBytes := val.Bytes()
if len(valBytes) == 0 {
valBytes = append(valBytes, 0)
}
bLen := len(valBytes)
p.add(byte(vm.PUSH1) - 1 + byte(bLen))
p.Append(valBytes)
}
// Append appends the given data to the code.
func (p *Program) Append(data []byte) *Program {
p.code = append(p.code, data...)
return p
}
// Bytes returns the Program bytecode. OBS: This is not a copy.
func (p *Program) Bytes() []byte {
return p.code
}
// SetBytes sets the Program bytecode. The combination of Bytes and SetBytes means
// that external callers can implement missing functionality:
//
// ...
// prog.Push(1)
// code := prog.Bytes()
// manipulate(code)
// prog.SetBytes(code)
func (p *Program) SetBytes(code []byte) {
p.code = code
}
// Hex returns the Program bytecode as a hex string.
func (p *Program) Hex() string {
return fmt.Sprintf("%02x", p.Bytes())
}
// Op appends the given opcode(s).
func (p *Program) Op(ops ...vm.OpCode) *Program {
for _, op := range ops {
p.add(byte(op))
}
return p
}
// Push creates a PUSHX instruction with the data provided. If zero is being pushed,
// PUSH0 will be avoided in favour of [PUSH1 0], to ensure backwards compatibility.
func (p *Program) Push(val any) *Program {
switch v := val.(type) {
case int:
p.doPush(new(uint256.Int).SetUint64(uint64(v)))
case uint64:
p.doPush(new(uint256.Int).SetUint64(v))
case uint32:
p.doPush(new(uint256.Int).SetUint64(uint64(v)))
case uint16:
p.doPush(new(uint256.Int).SetUint64(uint64(v)))
case *big.Int:
p.doPush(uint256.MustFromBig(v))
case *uint256.Int:
p.doPush(v)
case uint256.Int:
p.doPush(&v)
case []byte:
p.doPush(new(uint256.Int).SetBytes(v))
case byte:
p.doPush(new(uint256.Int).SetUint64(uint64(v)))
case interface{ Bytes() []byte }:
// Here, we jump through some hoops in order to avoid depending on
// go-ethereum types.Address and common.Hash, and instead use the
// interface. This works on both values and pointers!
p.doPush(new(uint256.Int).SetBytes(v.Bytes()))
case nil:
p.doPush(nil)
default:
panic(fmt.Sprintf("unsupported type %T", v))
}
return p
}
// Push0 implements PUSH0 (0x5f).
func (p *Program) Push0() *Program {
return p.Op(vm.PUSH0)
}
// ExtcodeCopy performs an extcodecopy invocation.
func (p *Program) ExtcodeCopy(address, memOffset, codeOffset, length any) *Program {
p.Push(length)
p.Push(codeOffset)
p.Push(memOffset)
p.Push(address)
return p.Op(vm.EXTCODECOPY)
}
// Call is a convenience function to make a call. If 'gas' is nil, the opcode GAS will
// be used to provide all gas.
func (p *Program) Call(gas *uint256.Int, address, value, inOffset, inSize, outOffset, outSize any) *Program {
if outOffset == outSize && inSize == outSize && inOffset == outSize && value == outSize {
p.Push(outSize).Op(vm.DUP1, vm.DUP1, vm.DUP1, vm.DUP1)
} else {
p.Push(outSize).Push(outOffset).Push(inSize).Push(inOffset).Push(value)
}
p.Push(address)
if gas == nil {
p.Op(vm.GAS)
} else {
p.doPush(gas)
}
return p.Op(vm.CALL)
}
// DelegateCall is a convenience function to make a delegatecall. If 'gas' is nil, the opcode GAS will
// be used to provide all gas.
func (p *Program) DelegateCall(gas *uint256.Int, address, inOffset, inSize, outOffset, outSize any) *Program {
if outOffset == outSize && inSize == outSize && inOffset == outSize {
p.Push(outSize).Op(vm.DUP1, vm.DUP1, vm.DUP1)
} else {
p.Push(outSize).Push(outOffset).Push(inSize).Push(inOffset)
}
p.Push(address)
if gas == nil {
p.Op(vm.GAS)
} else {
p.doPush(gas)
}
return p.Op(vm.DELEGATECALL)
}
// StaticCall is a convenience function to make a staticcall. If 'gas' is nil, the opcode GAS will
// be used to provide all gas.
func (p *Program) StaticCall(gas *uint256.Int, address, inOffset, inSize, outOffset, outSize any) *Program {
if outOffset == outSize && inSize == outSize && inOffset == outSize {
p.Push(outSize).Op(vm.DUP1, vm.DUP1, vm.DUP1)
} else {
p.Push(outSize).Push(outOffset).Push(inSize).Push(inOffset)
}
p.Push(address)
if gas == nil {
p.Op(vm.GAS)
} else {
p.doPush(gas)
}
return p.Op(vm.STATICCALL)
}
// StaticCall is a convenience function to make a callcode. If 'gas' is nil, the opcode GAS will
// be used to provide all gas.
func (p *Program) CallCode(gas *uint256.Int, address, value, inOffset, inSize, outOffset, outSize any) *Program {
if outOffset == outSize && inSize == outSize && inOffset == outSize {
p.Push(outSize).Op(vm.DUP1, vm.DUP1, vm.DUP1)
} else {
p.Push(outSize).Push(outOffset).Push(inSize).Push(inOffset)
}
p.Push(value)
p.Push(address)
if gas == nil {
p.Op(vm.GAS)
} else {
p.doPush(gas)
}
return p.Op(vm.CALLCODE)
}
// Label returns the PC (of the next instruction).
func (p *Program) Label() uint64 {
return uint64(len(p.code))
}
// Jumpdest adds a JUMPDEST op, and returns the PC of that instruction.
func (p *Program) Jumpdest() (*Program, uint64) {
here := p.Label()
p.Op(vm.JUMPDEST)
return p, here
}
// Jump pushes the destination and adds a JUMP.
func (p *Program) Jump(loc any) *Program {
p.Push(loc)
p.Op(vm.JUMP)
return p
}
// JumpIf implements JUMPI.
func (p *Program) JumpIf(loc any, condition any) *Program {
p.Push(condition)
p.Push(loc)
p.Op(vm.JUMPI)
return p
}
// Size returns the current size of the bytecode.
func (p *Program) Size() int {
return len(p.code)
}
// InputAddressToStack stores the input (calldata) to memory as address (20 bytes).
func (p *Program) InputAddressToStack(inputOffset uint32) *Program {
p.Push(inputOffset)
p.Op(vm.CALLDATALOAD) // Loads [n -> n + 32] of input data to stack top
mask, _ := big.NewInt(0).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16)
p.Push(mask) // turn into address
return p.Op(vm.AND)
}
// MStore stores the provided data (into the memory area starting at memStart).
func (p *Program) Mstore(data []byte, memStart uint32) *Program {
var idx = 0
// We need to store it in chunks of 32 bytes
for ; idx+32 <= len(data); idx += 32 {
chunk := data[idx : idx+32]
// push the value
p.Push(chunk)
// push the memory index
p.Push(uint32(idx) + memStart)
p.Op(vm.MSTORE)
}
// Remainders become stored using MSTORE8
for ; idx < len(data); idx++ {
b := data[idx]
// push the byte
p.Push(b)
p.Push(uint32(idx) + memStart)
p.Op(vm.MSTORE8)
}
return p
}
// MstoreSmall stores the provided data, which must be smaller than 32 bytes,
// into the memory area starting at memStart.
// The data will be LHS zero-added to align on 32 bytes.
// For example, providing data 0x1122, it will do a PUSH2:
// PUSH2 0x1122, resulting in
// stack: 0x0000000000000000000000000000000000000000000000000000000000001122
// followed by MSTORE(0,0)
// And thus, the resulting memory will be
// [ 0000000000000000000000000000000000000000000000000000000000001122 ]
func (p *Program) MstoreSmall(data []byte, memStart uint32) *Program {
if len(data) > 32 {
// For larger sizes, use Mstore instead.
panic("only <=32 byte data size supported")
}
if len(data) == 0 {
// Storing 0-length data smells of an error somewhere.
panic("data is zero length")
}
// push the value
p.Push(data)
// push the memory index
p.Push(memStart)
p.Op(vm.MSTORE)
return p
}
// MemToStorage copies the given memory area into SSTORE slots,
// It expects data to be aligned to 32 byte, and does not zero out
// remainders if some data is not
// I.e, if given a 1-byte area, it will still copy the full 32 bytes to storage.
func (p *Program) MemToStorage(memStart, memSize, startSlot int) *Program {
// We need to store it in chunks of 32 bytes
for idx := memStart; idx < (memStart + memSize); idx += 32 {
dataStart := idx
// Mload the chunk
p.Push(dataStart)
p.Op(vm.MLOAD)
// Value is now on stack,
p.Push(startSlot)
p.Op(vm.SSTORE)
startSlot++
}
return p
}
// ReturnViaCodeCopy utilises CODECOPY to place the given data in the bytecode of
// p, loads into memory (offset 0) and returns the code.
// This is a typical "constructor".
// Note: since all indexing is calculated immediately, the preceding bytecode
// must not be expanded or shortened.
func (p *Program) ReturnViaCodeCopy(data []byte) *Program {
p.Push(len(data))
// For convenience, we'll use PUSH2 for the offset. Then we know we can always
// fit, since code is limited to 0xc000
p.Op(vm.PUSH2)
offsetPos := p.Size() // Need to update this position later on
p.Append([]byte{0, 0}) // Offset of the code to be copied
p.Push(0) // Offset in memory (destination)
p.Op(vm.CODECOPY) // Copy from code[offset:offset+len] to memory[0:]
p.Return(0, len(data)) // Return memory[0:len]
offset := p.Size()
p.Append(data) // And add the data
// Now, go back and fix the offset
p.code[offsetPos] = byte(offset >> 8)
p.code[offsetPos+1] = byte(offset)
return p
}
// Sstore stores the given byte array to the given slot.
// OBS! Does not verify that the value indeed fits into 32 bytes.
// If it does not, it will panic later on via doPush.
func (p *Program) Sstore(slot any, value any) *Program {
p.Push(value)
p.Push(slot)
return p.Op(vm.SSTORE)
}
// Tstore stores the given byte array to the given t-slot.
// OBS! Does not verify that the value indeed fits into 32 bytes.
// If it does not, it will panic later on via doPush.
func (p *Program) Tstore(slot any, value any) *Program {
p.Push(value)
p.Push(slot)
return p.Op(vm.TSTORE)
}
// Return implements RETURN
func (p *Program) Return(offset, len int) *Program {
p.Push(len)
p.Push(offset)
return p.Op(vm.RETURN)
}
// ReturnData loads the given data into memory, and does a return with it
func (p *Program) ReturnData(data []byte) *Program {
p.Mstore(data, 0)
return p.Return(0, len(data))
}
// Create2 uses create2 to construct a contract with the given bytecode.
// This operation leaves either '0' or address on the stack.
func (p *Program) Create2(code []byte, salt any) *Program {
var (
value = 0
offset = 0
size = len(code)
)
// Load the code into mem
p.Mstore(code, 0)
// Create it
return p.Push(salt).
Push(size).
Push(offset).
Push(value).
Op(vm.CREATE2)
// On the stack now, is either
// - zero: in case of failure, OR
// - address: in case of success
}
// Create2ThenCall calls create2 with the given initcode and salt, and then calls
// into the created contract (or calls into zero, if the creation failed).
func (p *Program) Create2ThenCall(code []byte, salt any) *Program {
p.Create2(code, salt)
// If there happen to be a zero on the stack, it doesn't matter, we're
// not sending any value anyway
p.Push(0).Push(0) // mem out
p.Push(0).Push(0) // mem in
p.Push(0) // value
p.Op(vm.DUP6) // address
p.Op(vm.GAS)
p.Op(vm.CALL)
p.Op(vm.POP) // pop the retval
return p.Op(vm.POP) // pop the address
}
// Selfdestruct pushes beneficiary and invokes selfdestruct.
func (p *Program) Selfdestruct(beneficiary any) *Program {
p.Push(beneficiary)
return p.Op(vm.SELFDESTRUCT)
}

311
core/vm/program/program_test.go Normal file
View File

@ -0,0 +1,311 @@
// Copyright 2024 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the goevmlab library. If not, see <http://www.gnu.org/licenses/>.
package program
import (
"bytes"
"math/big"
"testing"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/vm"
"github.com/holiman/uint256"
)
func TestPush(t *testing.T) {
tests := []struct {
input interface{}
expected string
}{
// native ints
{0, "6000"},
{0xfff, "610fff"},
{nil, "6000"},
{uint8(1), "6001"},
{uint16(1), "6001"},
{uint32(1), "6001"},
{uint64(1), "6001"},
// bigints
{big.NewInt(0), "6000"},
{big.NewInt(1), "6001"},
{big.NewInt(0xfff), "610fff"},
// uint256
{uint256.NewInt(1), "6001"},
{uint256.Int{1, 0, 0, 0}, "6001"},
// Addresses
{common.HexToAddress("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"), "73deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"},
{&common.Address{}, "6000"},
}
for i, tc := range tests {
have := New().Push(tc.input).Hex()
if have != tc.expected {
t.Errorf("test %d: got %v expected %v", i, have, tc.expected)
}
}
}
func TestCall(t *testing.T) {
{ // Nil gas
have := New().Call(nil, common.HexToAddress("0x1337"), big.NewInt(1), 1, 2, 3, 4).Hex()
want := "600460036002600160016113375af1"
if have != want {
t.Errorf("have %v want %v", have, want)
}
}
{ // Non nil gas
have := New().Call(uint256.NewInt(0xffff), common.HexToAddress("0x1337"), big.NewInt(1), 1, 2, 3, 4).Hex()
want := "6004600360026001600161133761fffff1"
if have != want {
t.Errorf("have %v want %v", have, want)
}
}
}
func TestMstore(t *testing.T) {
{
have := New().Mstore(common.FromHex("0xaabb"), 0).Hex()
want := "60aa60005360bb600153"
if have != want {
t.Errorf("have %v want %v", have, want)
}
}
{ // store at offset
have := New().Mstore(common.FromHex("0xaabb"), 3).Hex()
want := "60aa60035360bb600453"
if have != want {
t.Errorf("have %v want %v", have, want)
}
}
{ // 34 bytes
data := common.FromHex("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" +
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" +
"FFFF")
have := New().Mstore(data, 0).Hex()
want := "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60005260ff60205360ff602153"
if have != want {
t.Errorf("have %v want %v", have, want)
}
}
}
func TestMemToStorage(t *testing.T) {
have := New().MemToStorage(0, 33, 1).Hex()
want := "600051600155602051600255"
if have != want {
t.Errorf("have %v want %v", have, want)
}
}
func TestSstore(t *testing.T) {
have := New().Sstore(0x1337, []byte("1234")).Hex()
want := "633132333461133755"
if have != want {
t.Errorf("have %v want %v", have, want)
}
}
func TestReturnData(t *testing.T) {
{
have := New().ReturnData([]byte{0xFF}).Hex()
want := "60ff60005360016000f3"
if have != want {
t.Errorf("have %v want %v", have, want)
}
}
{
// 32 bytes
data := common.FromHex("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
have := New().ReturnData(data).Hex()
want := "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60005260206000f3"
if have != want {
t.Errorf("have %v want %v", have, want)
}
}
{ // ReturnViaCodeCopy
data := common.FromHex("0x6001")
have := New().Append([]byte{0x5b, 0x5b, 0x5b}).ReturnViaCodeCopy(data).Hex()
want := "5b5b5b600261001060003960026000f36001"
if have != want {
t.Errorf("have %v want %v", have, want)
}
}
{ // ReturnViaCodeCopy larger code
data := common.FromHex("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60005260206000f3")
have := New().Append([]byte{0x5b, 0x5b, 0x5b}).ReturnViaCodeCopy(data).Hex()
want := "5b5b5b602961001060003960296000f37fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60005260206000f3"
if have != want {
t.Errorf("have %v want %v", have, want)
}
}
}
func TestCreateAndCall(t *testing.T) {
// A constructor that stores a slot
ctor := New().Sstore(0, big.NewInt(5))
// A runtime bytecode which reads the slot and returns
deployed := New()
deployed.Push(0).Op(vm.SLOAD) // [value] in stack
deployed.Push(0) // [value, 0]
deployed.Op(vm.MSTORE)
deployed.Return(0, 32)
// Pack them
ctor.ReturnData(deployed.Bytes())
// Verify constructor + runtime code
{
want := "6005600055606060005360006001536054600253606060035360006004536052600553606060065360206007536060600853600060095360f3600a53600b6000f3"
if got := ctor.Hex(); got != want {
t.Fatalf("1: got %v expected %v", got, want)
}
}
}
func TestCreate2Call(t *testing.T) {
// Some runtime code
runtime := New().Op(vm.ADDRESS, vm.SELFDESTRUCT).Bytes()
want := common.FromHex("0x30ff")
if !bytes.Equal(want, runtime) {
t.Fatalf("runtime code error\nwant: %x\nhave: %x\n", want, runtime)
}
// A constructor returning the runtime code
initcode := New().ReturnData(runtime).Bytes()
want = common.FromHex("603060005360ff60015360026000f3")
if !bytes.Equal(want, initcode) {
t.Fatalf("initcode error\nwant: %x\nhave: %x\n", want, initcode)
}
// A factory invoking the constructor
outer := New().Create2ThenCall(initcode, nil).Bytes()
want = common.FromHex("60606000536030600153606060025360006003536053600453606060055360ff6006536060600753600160085360536009536060600a536002600b536060600c536000600d5360f3600e536000600f60006000f560006000600060006000855af15050")
if !bytes.Equal(want, outer) {
t.Fatalf("factory error\nwant: %x\nhave: %x\n", want, outer)
}
}
func TestGenerator(t *testing.T) {
for i, tc := range []struct {
want []byte
haveFn func() []byte
}{
{ // CREATE
want: []byte{
// Store initcode in memory at 0x00 (5 bytes left-padded to 32 bytes)
byte(vm.PUSH5),
// Init code: PUSH1 0, PUSH1 0, RETURN (3 steps)
byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.RETURN),
byte(vm.PUSH1), 0,
byte(vm.MSTORE),
// length, offset, value
byte(vm.PUSH1), 5, byte(vm.PUSH1), 27, byte(vm.PUSH1), 0,
byte(vm.CREATE),
byte(vm.POP),
},
haveFn: func() []byte {
initcode := New().Return(0, 0).Bytes()
return New().MstoreSmall(initcode, 0).
Push(len(initcode)). // length
Push(32 - len(initcode)). // offset
Push(0). // value
Op(vm.CREATE).
Op(vm.POP).Bytes()
},
},
{ // CREATE2
want: []byte{
// Store initcode in memory at 0x00 (5 bytes left-padded to 32 bytes)
byte(vm.PUSH5),
// Init code: PUSH1 0, PUSH1 0, RETURN (3 steps)
byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.RETURN),
byte(vm.PUSH1), 0,
byte(vm.MSTORE),
// salt, length, offset, value
byte(vm.PUSH1), 1, byte(vm.PUSH1), 5, byte(vm.PUSH1), 27, byte(vm.PUSH1), 0,
byte(vm.CREATE2),
byte(vm.POP),
},
haveFn: func() []byte {
initcode := New().Return(0, 0).Bytes()
return New().MstoreSmall(initcode, 0).
Push(1). // salt
Push(len(initcode)). // length
Push(32 - len(initcode)). // offset
Push(0). // value
Op(vm.CREATE2).
Op(vm.POP).Bytes()
},
},
{ // CALL
want: []byte{
// outsize, outoffset, insize, inoffset
byte(vm.PUSH1), 0, byte(vm.DUP1), byte(vm.DUP1), byte(vm.DUP1),
byte(vm.DUP1), // value
byte(vm.PUSH1), 0xbb, //address
byte(vm.GAS), // gas
byte(vm.CALL),
byte(vm.POP),
},
haveFn: func() []byte {
return New().Call(nil, 0xbb, 0, 0, 0, 0, 0).Op(vm.POP).Bytes()
},
},
{ // CALLCODE
want: []byte{
// outsize, outoffset, insize, inoffset
byte(vm.PUSH1), 0, byte(vm.DUP1), byte(vm.DUP1), byte(vm.DUP1),
byte(vm.PUSH1), 0, // value
byte(vm.PUSH1), 0xcc, //address
byte(vm.GAS), // gas
byte(vm.CALLCODE),
byte(vm.POP),
},
haveFn: func() []byte {
return New().CallCode(nil, 0xcc, 0, 0, 0, 0, 0).Op(vm.POP).Bytes()
},
},
{ // STATICCALL
want: []byte{
// outsize, outoffset, insize, inoffset
byte(vm.PUSH1), 0, byte(vm.DUP1), byte(vm.DUP1), byte(vm.DUP1),
byte(vm.PUSH1), 0xdd, //address
byte(vm.GAS), // gas
byte(vm.STATICCALL),
byte(vm.POP),
},
haveFn: func() []byte {
return New().StaticCall(nil, 0xdd, 0, 0, 0, 0).Op(vm.POP).Bytes()
},
},
{ // DELEGATECALL
want: []byte{
// outsize, outoffset, insize, inoffset
byte(vm.PUSH1), 0, byte(vm.DUP1), byte(vm.DUP1), byte(vm.DUP1),
byte(vm.PUSH1), 0xee, //address
byte(vm.GAS), // gas
byte(vm.DELEGATECALL),
byte(vm.POP),
},
haveFn: func() []byte {
return New().DelegateCall(nil, 0xee, 0, 0, 0, 0).Op(vm.POP).Bytes()
},
},
} {
if have := tc.haveFn(); !bytes.Equal(have, tc.want) {
t.Fatalf("test %d error\nhave: %x\nwant: %x\n", i, have, tc.want)
}
}
}

30
core/vm/program/readme.md Normal file
View File

@ -0,0 +1,30 @@
### What is this
In many cases, we have a need to create somewhat nontrivial bytecode, for testing various
quirks related to state transition or evm execution.
For example, we want to have a `CREATE2`- op create a contract, which is then invoked, and when invoked does a selfdestruct-to-self.
It is overkill to go full solidity, but it is also a bit tricky do assemble this by concatenating bytes.
This utility takes an approach from [goevmlab](https://github.com/holiman/goevmlab/) where it has been used for several years,
a go-lang utility to assemble evm bytecode.
Using this utility, the case above can be expressed as:
```golang
// Some runtime code
runtime := program.New().Ops(vm.ADDRESS, vm.SELFDESTRUCT).Bytecode()
// A constructor returning the runtime code
initcode := program.New().ReturnData(runtime).Bytecode()
// A factory invoking the constructor
outer := program.New().Create2AndCall(initcode, nil).Bytecode()
```
### Warning
This package is a utility for testing, _not_ for production. As such:
- There are not package guarantees. We might iterate heavily on this package, and do backwards-incompatible changes without warning
- There are no quality-guarantees. These utilities may produce evm-code that is non-functional. YMMV.
- There are no stability-guarantees. The utility will `panic` if the inputs do not align / make sense.

252
core/vm/runtime/runtime_test.go
View File

@ -33,6 +33,7 @@ import (
"github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/state"
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/core/vm/program"
"github.com/ethereum/go-ethereum/eth/tracers" "github.com/ethereum/go-ethereum/eth/tracers"
"github.com/ethereum/go-ethereum/eth/tracers/logger" "github.com/ethereum/go-ethereum/eth/tracers/logger"
"github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/params"
@ -436,110 +437,46 @@ func benchmarkNonModifyingCode(gas uint64, code []byte, name string, tracerCode
// BenchmarkSimpleLoop test a pretty simple loop which loops until OOG // BenchmarkSimpleLoop test a pretty simple loop which loops until OOG
// 55 ms // 55 ms
func BenchmarkSimpleLoop(b *testing.B) { func BenchmarkSimpleLoop(b *testing.B) {
staticCallIdentity := []byte{ p, lbl := program.New().Jumpdest()
byte(vm.JUMPDEST), // [ count ] // Call identity, and pop return value
// push args for the call staticCallIdentity := p.
byte(vm.PUSH1), 0, // out size StaticCall(nil, 0x4, 0, 0, 0, 0).
byte(vm.DUP1), // out offset Op(vm.POP).Jump(lbl).Bytes() // pop return value and jump to label
byte(vm.DUP1), // out insize
byte(vm.DUP1), // in offset
byte(vm.PUSH1), 0x4, // address of identity
byte(vm.GAS), // gas
byte(vm.STATICCALL),
byte(vm.POP), // pop return value
byte(vm.PUSH1), 0, // jumpdestination
byte(vm.JUMP),
}
callIdentity := []byte{ p, lbl = program.New().Jumpdest()
byte(vm.JUMPDEST), // [ count ] callIdentity := p.
// push args for the call Call(nil, 0x4, 0, 0, 0, 0, 0).
byte(vm.PUSH1), 0, // out size Op(vm.POP).Jump(lbl).Bytes() // pop return value and jump to label
byte(vm.DUP1), // out offset
byte(vm.DUP1), // out insize
byte(vm.DUP1), // in offset
byte(vm.DUP1), // value
byte(vm.PUSH1), 0x4, // address of identity
byte(vm.GAS), // gas
byte(vm.CALL),
byte(vm.POP), // pop return value
byte(vm.PUSH1), 0, // jumpdestination
byte(vm.JUMP),
}
callInexistant := []byte{ p, lbl = program.New().Jumpdest()
byte(vm.JUMPDEST), // [ count ] callInexistant := p.
// push args for the call Call(nil, 0xff, 0, 0, 0, 0, 0).
byte(vm.PUSH1), 0, // out size Op(vm.POP).Jump(lbl).Bytes() // pop return value and jump to label
byte(vm.DUP1), // out offset
byte(vm.DUP1), // out insize
byte(vm.DUP1), // in offset
byte(vm.DUP1), // value
byte(vm.PUSH1), 0xff, // address of existing contract
byte(vm.GAS), // gas
byte(vm.CALL),
byte(vm.POP), // pop return value
byte(vm.PUSH1), 0, // jumpdestination
byte(vm.JUMP),
}
callEOA := []byte{ p, lbl = program.New().Jumpdest()
byte(vm.JUMPDEST), // [ count ] callEOA := p.
// push args for the call Call(nil, 0xE0, 0, 0, 0, 0, 0). // call addr of EOA
byte(vm.PUSH1), 0, // out size Op(vm.POP).Jump(lbl).Bytes() // pop return value and jump to label
byte(vm.DUP1), // out offset
byte(vm.DUP1), // out insize
byte(vm.DUP1), // in offset
byte(vm.DUP1), // value
byte(vm.PUSH1), 0xE0, // address of EOA
byte(vm.GAS), // gas
byte(vm.CALL),
byte(vm.POP), // pop return value
byte(vm.PUSH1), 0, // jumpdestination
byte(vm.JUMP),
}
loopingCode := []byte{ p, lbl = program.New().Jumpdest()
byte(vm.JUMPDEST), // [ count ] // Push as if we were making call, then pop it off again, and loop
// push args for the call loopingCode := p.Push(0).
byte(vm.PUSH1), 0, // out size Op(vm.DUP1, vm.DUP1, vm.DUP1).
byte(vm.DUP1), // out offset Push(0x4).
byte(vm.DUP1), // out insize Op(vm.GAS, vm.POP, vm.POP, vm.POP, vm.POP, vm.POP, vm.POP).
byte(vm.DUP1), // in offset Jump(lbl).Bytes()
byte(vm.PUSH1), 0x4, // address of identity
byte(vm.GAS), // gas
byte(vm.POP), byte(vm.POP), byte(vm.POP), byte(vm.POP), byte(vm.POP), byte(vm.POP), p, lbl = program.New().Jumpdest()
byte(vm.PUSH1), 0, // jumpdestination loopingCode2 := p.
byte(vm.JUMP), Push(0x01020304).Push(uint64(0x0102030405)).
} Op(vm.POP, vm.POP).
Op(vm.PUSH6).Append(make([]byte, 6)).Op(vm.JUMP). // Jumpdest zero expressed in 6 bytes
Jump(lbl).Bytes()
loopingCode2 := []byte{ p, lbl = program.New().Jumpdest()
byte(vm.JUMPDEST), // [ count ] callRevertingContractWithInput := p.
// push args for the call Call(nil, 0xee, 0, 0, 0x20, 0x0, 0x0).
byte(vm.PUSH4), 1, 2, 3, 4, Op(vm.POP).Jump(lbl).Bytes() // pop return value and jump to label
byte(vm.PUSH5), 1, 2, 3, 4, 5,
byte(vm.POP), byte(vm.POP),
byte(vm.PUSH6), 0, 0, 0, 0, 0, 0, // jumpdestination
byte(vm.JUMP),
}
callRevertingContractWithInput := []byte{
byte(vm.JUMPDEST), //
// push args for the call
byte(vm.PUSH1), 0, // out size
byte(vm.DUP1), // out offset
byte(vm.PUSH1), 0x20, // in size
byte(vm.PUSH1), 0x00, // in offset
byte(vm.PUSH1), 0x00, // value
byte(vm.PUSH1), 0xEE, // address of reverting contract
byte(vm.GAS), // gas
byte(vm.CALL),
byte(vm.POP), // pop return value
byte(vm.PUSH1), 0, // jumpdestination
byte(vm.JUMP),
}
//tracer := logger.NewJSONLogger(nil, os.Stdout) //tracer := logger.NewJSONLogger(nil, os.Stdout)
//Execute(loopingCode, nil, &Config{ //Execute(loopingCode, nil, &Config{
@ -778,104 +715,49 @@ func TestRuntimeJSTracer(t *testing.T) {
this.exits++; this.exits++;
this.gasUsed = res.getGasUsed(); this.gasUsed = res.getGasUsed();
}}`} }}`}
initcode := program.New().Return(0, 0).Bytes()
tests := []struct { tests := []struct {
code []byte code []byte
// One result per tracer // One result per tracer
results []string results []string
}{ }{
{ { // CREATE
// CREATE code: program.New().MstoreSmall(initcode, 0).
code: []byte{ Push(len(initcode)). // length
// Store initcode in memory at 0x00 (5 bytes left-padded to 32 bytes) Push(32 - len(initcode)). // offset
byte(vm.PUSH5), Push(0). // value
// Init code: PUSH1 0, PUSH1 0, RETURN (3 steps) Op(vm.CREATE).
byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.RETURN), Op(vm.POP).Bytes(),
byte(vm.PUSH1), 0,
byte(vm.MSTORE),
// length, offset, value
byte(vm.PUSH1), 5, byte(vm.PUSH1), 27, byte(vm.PUSH1), 0,
byte(vm.CREATE),
byte(vm.POP),
},
results: []string{`"1,1,952853,6,12"`, `"1,1,952853,6,0"`}, results: []string{`"1,1,952853,6,12"`, `"1,1,952853,6,0"`},
}, },
{ { // CREATE2
// CREATE2 code: program.New().MstoreSmall(initcode, 0).
code: []byte{ Push(1). // salt
// Store initcode in memory at 0x00 (5 bytes left-padded to 32 bytes) Push(len(initcode)). // length
byte(vm.PUSH5), Push(32 - len(initcode)). // offset
// Init code: PUSH1 0, PUSH1 0, RETURN (3 steps) Push(0). // value
byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.RETURN), Op(vm.CREATE2).
byte(vm.PUSH1), 0, Op(vm.POP).Bytes(),
byte(vm.MSTORE),
// salt, length, offset, value
byte(vm.PUSH1), 1, byte(vm.PUSH1), 5, byte(vm.PUSH1), 27, byte(vm.PUSH1), 0,
byte(vm.CREATE2),
byte(vm.POP),
},
results: []string{`"1,1,952844,6,13"`, `"1,1,952844,6,0"`}, results: []string{`"1,1,952844,6,13"`, `"1,1,952844,6,0"`},
}, },
{ { // CALL
// CALL code: program.New().Call(nil, 0xbb, 0, 0, 0, 0, 0).Op(vm.POP).Bytes(),
code: []byte{
// outsize, outoffset, insize, inoffset
byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.PUSH1), 0,
byte(vm.PUSH1), 0, // value
byte(vm.PUSH1), 0xbb, //address
byte(vm.GAS), // gas
byte(vm.CALL),
byte(vm.POP),
},
results: []string{`"1,1,981796,6,13"`, `"1,1,981796,6,0"`}, results: []string{`"1,1,981796,6,13"`, `"1,1,981796,6,0"`},
}, },
{ { // CALLCODE
// CALLCODE code: program.New().CallCode(nil, 0xcc, 0, 0, 0, 0, 0).Op(vm.POP).Bytes(),
code: []byte{
// outsize, outoffset, insize, inoffset
byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.PUSH1), 0,
byte(vm.PUSH1), 0, // value
byte(vm.PUSH1), 0xcc, //address
byte(vm.GAS), // gas
byte(vm.CALLCODE),
byte(vm.POP),
},
results: []string{`"1,1,981796,6,13"`, `"1,1,981796,6,0"`}, results: []string{`"1,1,981796,6,13"`, `"1,1,981796,6,0"`},
}, },
{ { // STATICCALL
// STATICCALL code: program.New().StaticCall(nil, 0xdd, 0, 0, 0, 0).Op(vm.POP).Bytes(),
code: []byte{
// outsize, outoffset, insize, inoffset
byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.PUSH1), 0,
byte(vm.PUSH1), 0xdd, //address
byte(vm.GAS), // gas
byte(vm.STATICCALL),
byte(vm.POP),
},
results: []string{`"1,1,981799,6,12"`, `"1,1,981799,6,0"`}, results: []string{`"1,1,981799,6,12"`, `"1,1,981799,6,0"`},
}, },
{ { // DELEGATECALL
// DELEGATECALL code: program.New().DelegateCall(nil, 0xee, 0, 0, 0, 0).Op(vm.POP).Bytes(),
code: []byte{
// outsize, outoffset, insize, inoffset
byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.PUSH1), 0,
byte(vm.PUSH1), 0xee, //address
byte(vm.GAS), // gas
byte(vm.DELEGATECALL),
byte(vm.POP),
},
results: []string{`"1,1,981799,6,12"`, `"1,1,981799,6,0"`}, results: []string{`"1,1,981799,6,12"`, `"1,1,981799,6,0"`},
}, },
{ { // CALL self-destructing contract
// CALL self-destructing contract code: program.New().Call(nil, 0xff, 0, 0, 0, 0, 0).Op(vm.POP).Bytes(),
code: []byte{
// outsize, outoffset, insize, inoffset
byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.PUSH1), 0, byte(vm.PUSH1), 0,
byte(vm.PUSH1), 0, // value
byte(vm.PUSH1), 0xff, //address
byte(vm.GAS), // gas
byte(vm.CALL),
byte(vm.POP),
},
results: []string{`"2,2,0,5003,12"`, `"2,2,0,5003,0"`}, results: []string{`"2,2,0,5003,12"`, `"2,2,0,5003,0"`},
}, },
} }
@ -958,16 +840,8 @@ func TestJSTracerCreateTx(t *testing.T) {
func BenchmarkTracerStepVsCallFrame(b *testing.B) { func BenchmarkTracerStepVsCallFrame(b *testing.B) {
// Simply pushes and pops some values in a loop // Simply pushes and pops some values in a loop
code := []byte{ p, lbl := program.New().Jumpdest()
byte(vm.JUMPDEST), code := p.Push(0).Push(0).Op(vm.POP, vm.POP).Jump(lbl).Bytes()
byte(vm.PUSH1), 0,
byte(vm.PUSH1), 0,
byte(vm.POP),
byte(vm.POP),
byte(vm.PUSH1), 0, // jumpdestination
byte(vm.JUMP),
}
stepTracer := ` stepTracer := `
{ {
step: function() {}, step: function() {},