Atomic VM Refactor

.github/workflows/ci.yml

@@ -133,7 +133,7 @@ jobs:
         with:
           go-version-file: "go.mod"
       - name: Run e2e tests
-        uses: ava-labs/avalanchego/.github/actions/run-monitored-tmpnet-cmd@d8bfb84e85957e16c6e5bab105f61e29485f369c
+        uses: ava-labs/avalanchego/.github/actions/run-monitored-tmpnet-cmd@c7351c1ea9ad15f6a65614f158c06ddbb0f722a7
         with:
           run: ./scripts/tests.e2e.sh
           prometheus_username: ${{ secrets.PROMETHEUS_ID || '' }}

consensus/dummy/consensus.go

@@ -59,6 +59,7 @@ type (
 		block *types.Block,
 		parent *types.Header,
 		statedb *state.StateDB,
+		config *params.ChainConfig,
 	) (
 		blockFeeContribution *big.Int,
 		extDataGasUsed *big.Int,
@@ -371,7 +372,7 @@ func (eng *DummyEngine) Finalize(chain consensus.ChainHeaderReader, block *types
 		err                          error
 	)
 	if eng.cb.OnExtraStateChange != nil {
-		contribution, extDataGasUsed, err = eng.cb.OnExtraStateChange(block, parent, state)
+		contribution, extDataGasUsed, err = eng.cb.OnExtraStateChange(block, parent, state, chain.Config())
 		if err != nil {
 			return err
 		}

core/test_blockchain.go

@@ -24,7 +24,7 @@ import (
 )
 
 var TestCallbacks = dummy.ConsensusCallbacks{
-	OnExtraStateChange: func(block *types.Block, _ *types.Header, sdb *state.StateDB) (*big.Int, *big.Int, error) {
+	OnExtraStateChange: func(block *types.Block, _ *types.Header, sdb *state.StateDB, _ *params.ChainConfig) (*big.Int, *big.Int, error) {
 		sdb.AddBalanceMultiCoin(common.HexToAddress("0xdeadbeef"), common.HexToHash("0xdeadbeef"), big.NewInt(block.Number().Int64()))
 		return nil, nil, nil
 	},

eth/gasprice/gasprice_test.go

@@ -133,7 +133,7 @@ func newTestBackend(t *testing.T, config *params.ChainConfig, numBlocks int, ext
 		OnFinalizeAndAssemble: func(*types.Header, *types.Header, *state.StateDB, []*types.Transaction) ([]byte, *big.Int, *big.Int, error) {
 			return nil, common.Big0, extDataGasUsage, nil
 		},
-		OnExtraStateChange: func(*types.Block, *types.Header, *state.StateDB) (*big.Int, *big.Int, error) {
+		OnExtraStateChange: func(*types.Block, *types.Header, *state.StateDB, *params.ChainConfig) (*big.Int, *big.Int, error) {
 			return common.Big0, extDataGasUsage, nil
 		},
 	})

go.mod

@@ -4,7 +4,7 @@ go 1.23.6
 
 require (
 	github.com/VictoriaMetrics/fastcache v1.12.1
-	github.com/ava-labs/avalanchego v1.13.1-rc.0.0.20250421193253-d8bfb84e8595
+	github.com/ava-labs/avalanchego v1.13.1-rc.0.0.20250419152035-c7351c1ea9ad
 	github.com/ava-labs/libevm v1.13.14-0.2.0.release
 	github.com/davecgh/go-spew v1.1.1
 	github.com/deckarep/golang-set/v2 v2.1.0

go.sum

@@ -58,8 +58,8 @@ github.com/ajg/form v1.5.1/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY
 github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8=
 github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
-github.com/ava-labs/avalanchego v1.13.1-rc.0.0.20250421193253-d8bfb84e8595 h1:sazRMIAL0gAJGyhZCkO8zPTVFufwuxPHQoPfmP6qLko=
-github.com/ava-labs/avalanchego v1.13.1-rc.0.0.20250421193253-d8bfb84e8595/go.mod h1:6cFD9bIDPn9aDPzTvAjBndeqURKA1C9c4aEeIcvS0Ms=
+github.com/ava-labs/avalanchego v1.13.1-rc.0.0.20250419152035-c7351c1ea9ad h1:+Ff14700/W+AGkhew8XfHVb1MVHT5KHj5OyioTRvkDo=
+github.com/ava-labs/avalanchego v1.13.1-rc.0.0.20250419152035-c7351c1ea9ad/go.mod h1:9/YOzCqY75s5ku5sbYRwWpI7igbYVdrnkI5XDxZcFtA=
 github.com/ava-labs/libevm v1.13.14-0.2.0.release h1:uKGCc5/ceeBbfAPRVtBUxbQt50WzB2pEDb8Uy93ePgQ=
 github.com/ava-labs/libevm v1.13.14-0.2.0.release/go.mod h1:+Iol+sVQ1KyoBsHf3veyrBmHCXr3xXRWq6ZXkgVfNLU=
 github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g=

plugin/evm/api.go

@@ -5,40 +5,12 @@ package evm
 
 import (
 	"context"
-	"errors"
-	"fmt"
 	"math/big"
-	"net/http"
 
-	"github.com/ava-labs/avalanchego/api"
-	"github.com/ava-labs/avalanchego/ids"
-	"github.com/ava-labs/avalanchego/utils/formatting"
-	"github.com/ava-labs/avalanchego/utils/json"
-	"github.com/ava-labs/avalanchego/utils/set"
-	"github.com/ava-labs/coreth/plugin/evm/atomic"
-	"github.com/ava-labs/coreth/plugin/evm/client"
-	"github.com/ava-labs/coreth/plugin/evm/upgrade/ap3"
 	"github.com/ava-labs/libevm/common"
 	"github.com/ava-labs/libevm/log"
 )
 
-// test constants
-const (
-	GenesisTestAddr = "0x751a0b96e1042bee789452ecb20253fba40dbe85"
-	GenesisTestKey  = "0xabd71b35d559563fea757f0f5edbde286fb8c043105b15abb7cd57189306d7d1"
-
-	// Max number of addresses that can be passed in as argument to GetUTXOs
-	maxGetUTXOsAddrs = 1024
-)
-
-var (
-	errNoAddresses   = errors.New("no addresses provided")
-	errNoSourceChain = errors.New("no source chain provided")
-	errNilTxID       = errors.New("nil transaction ID")
-
-	initialBaseFee = big.NewInt(ap3.InitialBaseFee)
-)
-
 // SnowmanAPI introduces snowman specific functionality to the evm
 type SnowmanAPI struct{ vm *VM }
 
@@ -65,202 +37,3 @@ func (api *SnowmanAPI) IssueBlock(ctx context.Context) error {
 	api.vm.builder.signalTxsReady()
 	return nil
 }
-
-// AvaxAPI offers Avalanche network related API methods
-type AvaxAPI struct{ vm *VM }
-
-type VersionReply struct {
-	Version string `json:"version"`
-}
-
-// ClientVersion returns the version of the VM running
-func (service *AvaxAPI) Version(r *http.Request, _ *struct{}, reply *VersionReply) error {
-	reply.Version = Version
-	return nil
-}
-
-// GetUTXOs gets all utxos for passed in addresses
-func (service *AvaxAPI) GetUTXOs(r *http.Request, args *api.GetUTXOsArgs, reply *api.GetUTXOsReply) error {
-	log.Info("EVM: GetUTXOs called", "Addresses", args.Addresses)
-
-	if len(args.Addresses) == 0 {
-		return errNoAddresses
-	}
-	if len(args.Addresses) > maxGetUTXOsAddrs {
-		return fmt.Errorf("number of addresses given, %d, exceeds maximum, %d", len(args.Addresses), maxGetUTXOsAddrs)
-	}
-
-	if args.SourceChain == "" {
-		return errNoSourceChain
-	}
-
-	chainID, err := service.vm.ctx.BCLookup.Lookup(args.SourceChain)
-	if err != nil {
-		return fmt.Errorf("problem parsing source chainID %q: %w", args.SourceChain, err)
-	}
-	sourceChain := chainID
-
-	addrSet := set.Set[ids.ShortID]{}
-	for _, addrStr := range args.Addresses {
-		addr, err := service.vm.ParseServiceAddress(addrStr)
-		if err != nil {
-			return fmt.Errorf("couldn't parse address %q: %w", addrStr, err)
-		}
-		addrSet.Add(addr)
-	}
-
-	startAddr := ids.ShortEmpty
-	startUTXO := ids.Empty
-	if args.StartIndex.Address != "" || args.StartIndex.UTXO != "" {
-		startAddr, err = service.vm.ParseServiceAddress(args.StartIndex.Address)
-		if err != nil {
-			return fmt.Errorf("couldn't parse start index address %q: %w", args.StartIndex.Address, err)
-		}
-		startUTXO, err = ids.FromString(args.StartIndex.UTXO)
-		if err != nil {
-			return fmt.Errorf("couldn't parse start index utxo: %w", err)
-		}
-	}
-
-	service.vm.ctx.Lock.Lock()
-	defer service.vm.ctx.Lock.Unlock()
-
-	utxos, endAddr, endUTXOID, err := service.vm.GetAtomicUTXOs(
-		sourceChain,
-		addrSet,
-		startAddr,
-		startUTXO,
-		int(args.Limit),
-	)
-	if err != nil {
-		return fmt.Errorf("problem retrieving UTXOs: %w", err)
-	}
-
-	reply.UTXOs = make([]string, len(utxos))
-	for i, utxo := range utxos {
-		b, err := atomic.Codec.Marshal(atomic.CodecVersion, utxo)
-		if err != nil {
-			return fmt.Errorf("problem marshalling UTXO: %w", err)
-		}
-		str, err := formatting.Encode(args.Encoding, b)
-		if err != nil {
-			return fmt.Errorf("problem encoding utxo: %w", err)
-		}
-		reply.UTXOs[i] = str
-	}
-
-	endAddress, err := service.vm.FormatLocalAddress(endAddr)
-	if err != nil {
-		return fmt.Errorf("problem formatting address: %w", err)
-	}
-
-	reply.EndIndex.Address = endAddress
-	reply.EndIndex.UTXO = endUTXOID.String()
-	reply.NumFetched = json.Uint64(len(utxos))
-	reply.Encoding = args.Encoding
-	return nil
-}
-
-func (service *AvaxAPI) IssueTx(r *http.Request, args *api.FormattedTx, response *api.JSONTxID) error {
-	log.Info("EVM: IssueTx called")
-
-	txBytes, err := formatting.Decode(args.Encoding, args.Tx)
-	if err != nil {
-		return fmt.Errorf("problem decoding transaction: %w", err)
-	}
-
-	tx := &atomic.Tx{}
-	if _, err := atomic.Codec.Unmarshal(txBytes, tx); err != nil {
-		return fmt.Errorf("problem parsing transaction: %w", err)
-	}
-	if err := tx.Sign(atomic.Codec, nil); err != nil {
-		return fmt.Errorf("problem initializing transaction: %w", err)
-	}
-
-	response.TxID = tx.ID()
-
-	service.vm.ctx.Lock.Lock()
-	defer service.vm.ctx.Lock.Unlock()
-
-	if err := service.vm.mempool.AddLocalTx(tx); err != nil {
-		return err
-	}
-	service.vm.atomicTxPushGossiper.Add(&atomic.GossipAtomicTx{Tx: tx})
-	return nil
-}
-
-// GetAtomicTxStatus returns the status of the specified transaction
-func (service *AvaxAPI) GetAtomicTxStatus(r *http.Request, args *api.JSONTxID, reply *client.GetAtomicTxStatusReply) error {
-	log.Info("EVM: GetAtomicTxStatus called", "txID", args.TxID)
-
-	if args.TxID == ids.Empty {
-		return errNilTxID
-	}
-
-	service.vm.ctx.Lock.Lock()
-	defer service.vm.ctx.Lock.Unlock()
-
-	_, status, height, _ := service.vm.getAtomicTx(args.TxID)
-
-	reply.Status = status
-	if status == atomic.Accepted {
-		// Since chain state updates run asynchronously with VM block acceptance,
-		// avoid returning [Accepted] until the chain state reaches the block
-		// containing the atomic tx.
-		lastAccepted := service.vm.blockChain.LastAcceptedBlock()
-		if height > lastAccepted.NumberU64() {
-			reply.Status = atomic.Processing
-			return nil
-		}
-
-		jsonHeight := json.Uint64(height)
-		reply.BlockHeight = &jsonHeight
-	}
-	return nil
-}
-
-type FormattedTx struct {
-	api.FormattedTx
-	BlockHeight *json.Uint64 `json:"blockHeight,omitempty"`
-}
-
-// GetAtomicTx returns the specified transaction
-func (service *AvaxAPI) GetAtomicTx(r *http.Request, args *api.GetTxArgs, reply *FormattedTx) error {
-	log.Info("EVM: GetAtomicTx called", "txID", args.TxID)
-
-	if args.TxID == ids.Empty {
-		return errNilTxID
-	}
-
-	service.vm.ctx.Lock.Lock()
-	defer service.vm.ctx.Lock.Unlock()
-
-	tx, status, height, err := service.vm.getAtomicTx(args.TxID)
-	if err != nil {
-		return err
-	}
-
-	if status == atomic.Unknown {
-		return fmt.Errorf("could not find tx %s", args.TxID)
-	}
-
-	txBytes, err := formatting.Encode(args.Encoding, tx.SignedBytes())
-	if err != nil {
-		return err
-	}
-	reply.Tx = txBytes
-	reply.Encoding = args.Encoding
-	if status == atomic.Accepted {
-		// Since chain state updates run asynchronously with VM block acceptance,
-		// avoid returning [Accepted] until the chain state reaches the block
-		// containing the atomic tx.
-		lastAccepted := service.vm.blockChain.LastAcceptedBlock()
-		if height > lastAccepted.NumberU64() {
-			return nil
-		}
-
-		jsonHeight := json.Uint64(height)
-		reply.BlockHeight = &jsonHeight
-	}
-	return nil
-}

plugin/evm/atomic/atomictest/shared_memories.go

@@ -0,0 +1,79 @@
+package atomictest
+
+import (
+	"testing"
+
+	"github.com/ava-labs/avalanchego/chains/atomic"
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/stretchr/testify/assert"
+)
+
+type SharedMemories struct {
+	ThisChain   atomic.SharedMemory
+	PeerChain   atomic.SharedMemory
+	thisChainID ids.ID
+	peerChainID ids.ID
+}
+
+func (s *SharedMemories) AddItemsToBeRemovedToPeerChain(ops map[ids.ID]*atomic.Requests) error {
+	for _, reqs := range ops {
+		puts := make(map[ids.ID]*atomic.Requests)
+		puts[s.thisChainID] = &atomic.Requests{}
+		for _, key := range reqs.RemoveRequests {
+			val := []byte{0x1}
+			puts[s.thisChainID].PutRequests = append(puts[s.thisChainID].PutRequests, &atomic.Element{Key: key, Value: val})
+		}
+		if err := s.PeerChain.Apply(puts); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *SharedMemories) AssertOpsApplied(t *testing.T, ops map[ids.ID]*atomic.Requests) {
+	t.Helper()
+	for _, reqs := range ops {
+		// should be able to get put requests
+		for _, elem := range reqs.PutRequests {
+			val, err := s.PeerChain.Get(s.thisChainID, [][]byte{elem.Key})
+			if err != nil {
+				t.Fatalf("error finding puts in peerChainMemory: %s", err)
+			}
+			assert.Equal(t, elem.Value, val[0])
+		}
+
+		// should not be able to get remove requests
+		for _, key := range reqs.RemoveRequests {
+			_, err := s.ThisChain.Get(s.peerChainID, [][]byte{key})
+			assert.EqualError(t, err, "not found")
+		}
+	}
+}
+
+func (s *SharedMemories) AssertOpsNotApplied(t *testing.T, ops map[ids.ID]*atomic.Requests) {
+	t.Helper()
+	for _, reqs := range ops {
+		// should not be able to get put requests
+		for _, elem := range reqs.PutRequests {
+			_, err := s.PeerChain.Get(s.thisChainID, [][]byte{elem.Key})
+			assert.EqualError(t, err, "not found")
+		}
+
+		// should be able to get remove requests (these were previously added as puts on peerChain)
+		for _, key := range reqs.RemoveRequests {
+			val, err := s.ThisChain.Get(s.peerChainID, [][]byte{key})
+			assert.NoError(t, err)
+			assert.Equal(t, []byte{0x1}, val[0])
+		}
+	}
+}
+
+// TODO: once tests are moved to atomic package, unexport this function
+func NewSharedMemories(atomicMemory *atomic.Memory, thisChainID, peerChainID ids.ID) *SharedMemories {
+	return &SharedMemories{
+		ThisChain:   atomicMemory.NewSharedMemory(thisChainID),
+		PeerChain:   atomicMemory.NewSharedMemory(peerChainID),
+		thisChainID: thisChainID,
+		peerChainID: peerChainID,
+	}
+}