Seperate atomic pkg base

core/genesis.go

@@ -259,11 +259,6 @@ func (g *Genesis) toBlock(db ethdb.Database, triedb *triedb.Database) *types.Blo
 		for key, value := range account.Storage {
 			statedb.SetState(addr, key, value)
 		}
-		if account.MCBalance != nil {
-			for coinID, value := range account.MCBalance {
-				statedb.AddBalanceMultiCoin(addr, coinID, value)
-			}
-		}
 	}
 	root := statedb.IntermediateRoot(false)
 	head.Root = root

core/state/dump.go

@@ -64,11 +64,9 @@ type DumpAccount struct {
 	Root        hexutil.Bytes          `json:"root"`
 	CodeHash    hexutil.Bytes          `json:"codeHash"`
 	Code        hexutil.Bytes          `json:"code,omitempty"`
-	IsMultiCoin bool                   `json:"isMultiCoin"`
 	Storage     map[common.Hash]string `json:"storage,omitempty"`
 	Address     *common.Address        `json:"address,omitempty"` // Address only present in iterative (line-by-line) mode
 	AddressHash hexutil.Bytes          `json:"key,omitempty"`     // If we don't have address, we can output the key
-
 }
 
 // Dump represents the full dump in a collected format, as one large map.
@@ -107,7 +105,6 @@ func (d iterativeDump) OnAccount(addr *common.Address, account DumpAccount) {
 		Nonce:       account.Nonce,
 		Root:        account.Root,
 		CodeHash:    account.CodeHash,
-		IsMultiCoin: account.IsMultiCoin,
 		Code:        account.Code,
 		Storage:     account.Storage,
 		AddressHash: account.AddressHash,
@@ -156,7 +153,6 @@ func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey []
 				Nonce:       data.Nonce,
 				Root:        data.Root[:],
 				CodeHash:    data.CodeHash,
-				IsMultiCoin: data.IsMultiCoin,
 				AddressHash: it.Key,
 			}
 			address   *common.Address

core/state/state_test.go

@@ -81,7 +81,6 @@ func TestDump(t *testing.T) {
             "nonce": 0,
             "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
             "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
-            "isMultiCoin": false,
             "address": "0x0000000000000000000000000000000000000001",
             "key": "0x1468288056310c82aa4c01a7e12a10f8111a0560e72b700555479031b86c357d"
         },
@@ -90,7 +89,6 @@ func TestDump(t *testing.T) {
             "nonce": 0,
             "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
             "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
-            "isMultiCoin": false,
             "address": "0x0000000000000000000000000000000000000002",
             "key": "0xd52688a8f926c816ca1e079067caba944f158e764817b83fc43594370ca9cf62"
         },
@@ -100,7 +98,6 @@ func TestDump(t *testing.T) {
             "root": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
             "codeHash": "0x87874902497a5bb968da31a2998d8f22e949d1ef6214bcdedd8bae24cca4b9e3",
             "code": "0x03030303030303",
-            "isMultiCoin": false,
             "address": "0x0000000000000000000000000000000000000102",
             "key": "0xa17eacbc25cda025e81db9c5c62868822c73ce097cee2a63e33a2e41268358a1"
         }
@@ -138,10 +135,10 @@ func TestIterativeDump(t *testing.T) {
 	// check that DumpToCollector contains the state objects that are in trie
 	got := b.String()
 	want := `{"root":"0x0ffca661efa3b7504ac015083994c94fd7d0d24db60354c717c936afcced762a"}
-{"balance":"22","nonce":0,"root":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","codeHash":"0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470","isMultiCoin":false,"address":"0x0000000000000000000000000000000000000001","key":"0x1468288056310c82aa4c01a7e12a10f8111a0560e72b700555479031b86c357d"}
-{"balance":"1337","nonce":0,"root":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","codeHash":"0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470","isMultiCoin":false,"address":"0x0000000000000000000000000000000000000000","key":"0x5380c7b7ae81a58eb98d9c78de4a1fd7fd9535fc953ed2be602daaa41767312a"}
-{"balance":"0","nonce":0,"root":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","codeHash":"0x87874902497a5bb968da31a2998d8f22e949d1ef6214bcdedd8bae24cca4b9e3","code":"0x03030303030303","isMultiCoin":false,"address":"0x0000000000000000000000000000000000000102","key":"0xa17eacbc25cda025e81db9c5c62868822c73ce097cee2a63e33a2e41268358a1"}
-{"balance":"44","nonce":0,"root":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","codeHash":"0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470","isMultiCoin":false,"address":"0x0000000000000000000000000000000000000002","key":"0xd52688a8f926c816ca1e079067caba944f158e764817b83fc43594370ca9cf62"}
+{"balance":"22","nonce":0,"root":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","codeHash":"0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470","address":"0x0000000000000000000000000000000000000001","key":"0x1468288056310c82aa4c01a7e12a10f8111a0560e72b700555479031b86c357d"}
+{"balance":"1337","nonce":0,"root":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","codeHash":"0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470","address":"0x0000000000000000000000000000000000000000","key":"0x5380c7b7ae81a58eb98d9c78de4a1fd7fd9535fc953ed2be602daaa41767312a"}
+{"balance":"0","nonce":0,"root":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","codeHash":"0x87874902497a5bb968da31a2998d8f22e949d1ef6214bcdedd8bae24cca4b9e3","code":"0x03030303030303","address":"0x0000000000000000000000000000000000000102","key":"0xa17eacbc25cda025e81db9c5c62868822c73ce097cee2a63e33a2e41268358a1"}
+{"balance":"44","nonce":0,"root":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","codeHash":"0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470","address":"0x0000000000000000000000000000000000000002","key":"0xd52688a8f926c816ca1e079067caba944f158e764817b83fc43594370ca9cf62"}
 `
 	if got != want {
 		t.Errorf("DumpToCollector mismatch:\ngot: %s\nwant: %s\n", got, want)
@@ -152,7 +149,7 @@ func TestNull(t *testing.T) {
 	s := newStateEnv()
 	address := common.HexToAddress("0x823140710bf13990e4500136726d8b55")
 	s.state.CreateAccount(address)
-	//value := common.FromHex("0x823140710bf13990e4500136726d8b55")
+	// value := common.FromHex("0x823140710bf13990e4500136726d8b55")
 	var value common.Hash
 
 	s.state.SetState(address, common.Hash{}, value)

core/types/account.go

@@ -87,14 +87,11 @@ func (ga *GenesisAlloc) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-type GenesisMultiCoinBalance map[common.Hash]*big.Int
-
 // GenesisAccount is an account in the state of the genesis block.
 type GenesisAccount struct {
 	Code       []byte                      `json:"code,omitempty"`
 	Storage    map[common.Hash]common.Hash `json:"storage,omitempty"`
 	Balance    *big.Int                    `json:"balance" gencodec:"required"`
-	MCBalance  GenesisMultiCoinBalance     `json:"mcbalance,omitempty"`
 	Nonce      uint64                      `json:"nonce,omitempty"`
 	PrivateKey []byte                      `json:"secretKey,omitempty"` // for tests
 }

peer/network.go

@@ -228,6 +228,7 @@ func (n *network) AppRequest(ctx context.Context, nodeID ids.NodeID, requestID u
 
 	log.Debug("received AppRequest from node", "nodeID", nodeID, "requestID", requestID, "requestLen", len(request))
 
+	// TODO: investigate if we can move all these network logic to new SDK handlers
 	var req message.Request
 	if _, err := n.codec.Unmarshal(request, &req); err != nil {
 		log.Debug("forwarding AppRequest to SDK network", "nodeID", nodeID, "requestID", requestID, "requestLen", len(request), "err", err)

plugin/evm/api.go

@@ -17,7 +17,6 @@ import (
 	"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/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 )
@@ -35,8 +34,6 @@ 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

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,
+	}
+}

plugin/evm/atomic/test_tx.go → plugin/evm/atomic/atomictest/tx.go

@@ -1,7 +1,7 @@
 // (c) 2020-2021, Ava Labs, Inc. All rights reserved.
 // See the file LICENSE for licensing terms.
 
-package atomic
+package atomictest
 
 import (
 	"math/big"
@@ -17,8 +17,11 @@ import (
 	"github.com/ava-labs/avalanchego/utils/set"
 	"github.com/ava-labs/avalanchego/utils/wrappers"
 	"github.com/ava-labs/coreth/params"
+	"github.com/ava-labs/coreth/plugin/evm/atomic"
 )
 
+const testCodecVersion = 0
+
 var TestTxCodec codec.Manager
 
 func init() {
@@ -28,7 +31,7 @@ func init() {
 	errs := wrappers.Errs{}
 	errs.Add(
 		c.RegisterType(&TestUnsignedTx{}),
-		TestTxCodec.RegisterCodec(CodecVersion, c),
+		TestTxCodec.RegisterCodec(testCodecVersion, c),
 	)
 
 	if errs.Errored() {
@@ -50,7 +53,7 @@ type TestUnsignedTx struct {
 	EVMStateTransferV           error
 }
 
-var _ UnsignedAtomicTx = &TestUnsignedTx{}
+var _ atomic.UnsignedAtomicTx = &TestUnsignedTx{}
 
 // GasUsed implements the UnsignedAtomicTx interface
 func (t *TestUnsignedTx) GasUsed(fixedFee bool) (uint64, error) { return t.GasUsedV, nil }
@@ -82,19 +85,19 @@ func (t *TestUnsignedTx) SignedBytes() []byte { return t.SignedBytesV }
 func (t *TestUnsignedTx) InputUTXOs() set.Set[ids.ID] { return t.InputUTXOsV }
 
 // SemanticVerify implements the UnsignedAtomicTx interface
-func (t *TestUnsignedTx) SemanticVerify(backend *Backend, stx *Tx, parent AtomicBlockContext, baseFee *big.Int) error {
+func (t *TestUnsignedTx) SemanticVerify(backend *atomic.VerifierBackend, stx *atomic.Tx, parent atomic.AtomicBlockContext, baseFee *big.Int) error {
 	return t.SemanticVerifyV
 }
 
 // EVMStateTransfer implements the UnsignedAtomicTx interface
-func (t *TestUnsignedTx) EVMStateTransfer(ctx *snow.Context, state StateDB) error {
+func (t *TestUnsignedTx) EVMStateTransfer(ctx *snow.Context, state atomic.StateDB) error {
 	return t.EVMStateTransferV
 }
 
 var TestBlockchainID = ids.GenerateTestID()
 
-func GenerateTestImportTxWithGas(gasUsed uint64, burned uint64) *Tx {
-	return &Tx{
+func GenerateTestImportTxWithGas(gasUsed uint64, burned uint64) *atomic.Tx {
+	return &atomic.Tx{
 		UnsignedAtomicTx: &TestUnsignedTx{
 			IDV:                         ids.GenerateTestID(),
 			GasUsedV:                    gasUsed,
@@ -110,8 +113,8 @@ func GenerateTestImportTxWithGas(gasUsed uint64, burned uint64) *Tx {
 	}
 }
 
-func GenerateTestImportTx() *Tx {
-	return &Tx{
+func GenerateTestImportTx() *atomic.Tx {
+	return &atomic.Tx{
 		UnsignedAtomicTx: &TestUnsignedTx{
 			IDV:                         ids.GenerateTestID(),
 			AcceptRequestsBlockchainIDV: TestBlockchainID,
@@ -125,8 +128,8 @@ func GenerateTestImportTx() *Tx {
 	}
 }
 
-func GenerateTestExportTx() *Tx {
-	return &Tx{
+func GenerateTestExportTx() *atomic.Tx {
+	return &atomic.Tx{
 		UnsignedAtomicTx: &TestUnsignedTx{
 			IDV:                         ids.GenerateTestID(),
 			AcceptRequestsBlockchainIDV: TestBlockchainID,
@@ -146,7 +149,7 @@ func GenerateTestExportTx() *Tx {
 	}
 }
 
-func NewTestTx() *Tx {
+func NewTestTx() *atomic.Tx {
 	txType := rand.Intn(2)
 	switch txType {
 	case 0:
@@ -158,8 +161,8 @@ func NewTestTx() *Tx {
 	}
 }
 
-func NewTestTxs(numTxs int) []*Tx {
-	txs := make([]*Tx, 0, numTxs)
+func NewTestTxs(numTxs int) []*atomic.Tx {
+	txs := make([]*atomic.Tx, 0, numTxs)
 	for i := 0; i < numTxs; i++ {
 		txs = append(txs, NewTestTx())
 	}

plugin/evm/atomic/atomictest/utils.go

@@ -0,0 +1,18 @@
+// (c) 2019-2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package atomictest
+
+import (
+	avalancheatomic "github.com/ava-labs/avalanchego/chains/atomic"
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/coreth/plugin/evm/atomic"
+)
+
+func ConvertToAtomicOps(tx *atomic.Tx) (map[ids.ID]*avalancheatomic.Requests, error) {
+	id, reqs, err := tx.AtomicOps()
+	if err != nil {
+		return nil, err
+	}
+	return map[ids.ID]*avalancheatomic.Requests{id: reqs}, nil
+}