go-ethereum/core/vm/evm.libevm_test.go
Arran Schlosberg 35926db4d6
feat: temporary extras (#234)
## Why this should be merged

Registration of extras requires runtime enforcement of payload types. In
production, only a single set of types can be registered and any
attempts at re-registration will panic (by design). Although this makes
production usage safe, it doesn't allow downstream consumers (e.g. data
indexers) to use extras from different chains (e.g. `coreth` _and_
`subnet-evm`) at the same time.

## How this works

1. The `libevm/register.AtMostOnce` type can now be overridden
temporarily.
2. `params`, `core/types`, `core/vm`, and `state` packages introduce
`WithTempRegisteredExtras()` functions.
3. `libevm/temporary.WithRegisteredExtras()` provides "atomic" override
of all extras.

In all cases, the scope of the override is limited to the life of a
single function call.

## How this was tested

Relative to numbered list above:

1. Unit test of new and existing functionality.
2. Integration tests of both packages, demonstrating both payload and
behavioural override.
2025-10-02 17:42:26 +01:00

105 lines
3.2 KiB
Go

// Copyright 2024-2025 the libevm authors.
//
// The libevm additions to go-ethereum are free software: you can redistribute
// them and/or modify them 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.
//
// The libevm additions are distributed in the hope that they 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 go-ethereum library. If not, see
// <http://www.gnu.org/licenses/>.
package vm
import (
"math/big"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/ava-labs/libevm/params"
)
type evmArgOverrider struct {
newEVMchainID int64
gotResetChainID *big.Int
resetTxContextTo TxContext
resetStateDBTo StateDB
}
func (o *evmArgOverrider) OverrideNewEVMArgs(args *NewEVMArgs) *NewEVMArgs {
args.ChainConfig = &params.ChainConfig{ChainID: big.NewInt(o.newEVMchainID)}
return args
}
func (o *evmArgOverrider) OverrideEVMResetArgs(r params.Rules, _ *EVMResetArgs) *EVMResetArgs {
o.gotResetChainID = r.ChainID
return &EVMResetArgs{
TxContext: o.resetTxContextTo,
StateDB: o.resetStateDBTo,
}
}
func (o *evmArgOverrider) register(t *testing.T) {
t.Helper()
TestOnlyClearRegisteredHooks()
RegisterHooks(o)
t.Cleanup(TestOnlyClearRegisteredHooks)
}
func TestOverrideNewEVMArgs(t *testing.T) {
// The overrideNewEVMArgs function accepts and returns all arguments to
// NewEVM(), in order. Here we lock in our assumption of that order. If this
// breaks then all functionality overriding the args MUST be updated.
var _ func(BlockContext, TxContext, StateDB, *params.ChainConfig, Config) *EVM = NewEVM
const chainID = 13579
hooks := evmArgOverrider{newEVMchainID: chainID}
hooks.register(t)
assertChainID := func(t *testing.T, want int64) {
t.Helper()
evm := NewEVM(BlockContext{}, TxContext{}, nil, nil, Config{})
got := evm.ChainConfig().ChainID
require.Equalf(t, big.NewInt(want), got, "%T.ChainConfig().ChainID set by NewEVM() hook", evm)
}
assertChainID(t, chainID)
t.Run("WithTempRegisteredHooks", func(t *testing.T) {
override := evmArgOverrider{newEVMchainID: 24680}
WithTempRegisteredHooks(&override, func() {
assertChainID(t, override.newEVMchainID)
})
t.Run("after", func(t *testing.T) {
assertChainID(t, chainID)
})
})
}
func TestOverrideEVMResetArgs(t *testing.T) {
// Equivalent to rationale for TestOverrideNewEVMArgs above.
var _ func(TxContext, StateDB) = (*EVM)(nil).Reset
const (
chainID = 0xc0ffee
gasPrice = 1357924680
)
hooks := &evmArgOverrider{
newEVMchainID: chainID,
resetTxContextTo: TxContext{
GasPrice: big.NewInt(gasPrice),
},
}
hooks.register(t)
evm := NewEVM(BlockContext{}, TxContext{}, nil, nil, Config{})
evm.Reset(TxContext{}, nil)
assert.Equalf(t, big.NewInt(chainID), hooks.gotResetChainID, "%T.ChainID passed to Reset() hook", params.Rules{})
assert.Equalf(t, big.NewInt(gasPrice), evm.GasPrice, "%T.GasPrice set by Reset() hook", evm)
}