6d3d252a5e
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.
312 lines
9.1 KiB
Go
312 lines
9.1 KiB
Go
// 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)
|
|
}
|
|
}
|
|
}
|