sae: Implement Tx.TransferNonAVAX

go.work.sum

@@ -572,6 +572,7 @@ github.com/gookit/color v1.5.4/go.mod h1:pZJOeOS8DM43rXbp4AZo1n9zCU2qjpcRko0b6/Q
 github.com/gopherjs/gopherjs v1.17.2 h1:fQnZVsXk8uxXIStYb0N4bGk7jeyTalG/wsZjQ25dO0g=
 github.com/gorilla/css v1.0.0/go.mod h1:Dn721qIggHpt4+EFCcTLTU/vk5ySda2ReITrtgBl60c=
 github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7 h1:pdN6V1QBWetyv/0+wjACpqVH+eVULgEjkurDLq3goeM=
 github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
@@ -719,6 +720,7 @@ github.com/mitchellh/iochan v1.0.0 h1:C+X3KsSTLFVBr/tK1eYN/vs4rJcvsiLU338UhYPJWe
 github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY=
 github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU=
 github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU=
+github.com/moby/spdystream v0.2.0/go.mod h1:f7i0iNDQJ059oMTcWxx8MA/zKFIuD/lY+0GqbN2Wy8c=
 github.com/moul/http2curl v1.0.0 h1:dRMWoAtb+ePxMlLkrCbAqh4TlPHXvoGUSQ323/9Zahs=
 github.com/mozilla/tls-observatory v0.0.0-20210609171429-7bc42856d2e5/go.mod h1:FUqVoUPHSEdDR0MnFM3Dh8AU0pZHLXUD127SAJGER/s=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=

vms/saevm/cchain/tx/BUILD.bazel

@@ -16,14 +16,22 @@ go_library(
     ],
     importpath = "github.com/ava-labs/avalanchego/vms/saevm/cchain/tx",
     deps = [
+        "//chains/atomic",
         "//codec",
         "//codec/linearcodec",
+        "//graft/coreth/core/extstate",
+        "//graft/coreth/plugin/evm/atomic",
+        "//graft/coreth/plugin/evm/upgrade/ap5",
         "//ids",
         "//utils/hashing",
+        "//utils/math",
         "//utils/wrappers",
         "//vms/components/avax",
+        "//vms/components/gas",
+        "//vms/saevm/hook",
         "//vms/secp256k1fx",
         "@com_github_ava_labs_libevm//common",
+        "@com_github_holiman_uint256//:uint256",
     ],
 )
 
@@ -36,17 +44,28 @@ go_test(
     data = glob(["testdata/**"]),
     embed = [":tx"],
     deps = [
+        "//chains/atomic",
+        "//graft/coreth/core/extstate",
         "//graft/coreth/plugin/evm/atomic",
         "//graft/coreth/plugin/evm/atomic/vm",
+        "//graft/coreth/plugin/evm/customtypes",
         "//ids",
+        "//snow",
+        "//utils/math",
         "//vms/components/avax",
+        "//vms/components/gas",
         "//vms/components/verify",
         "//vms/saevm/cchain/tx/txtest",
         "//vms/saevm/cmputils",
+        "//vms/saevm/hook",
         "//vms/secp256k1fx",
         "@com_github_ava_labs_libevm//common",
+        "@com_github_ava_labs_libevm//core/rawdb",
+        "@com_github_ava_labs_libevm//core/state",
+        "@com_github_ava_labs_libevm//core/types",
         "@com_github_google_go_cmp//cmp",
         "@com_github_google_go_cmp//cmp/cmpopts",
+        "@com_github_holiman_uint256//:uint256",
         "@com_github_stretchr_testify//assert",
         "@com_github_stretchr_testify//require",
     ],

vms/saevm/cchain/tx/compatibility_test.go

@@ -5,21 +5,40 @@
 
 import (
 	"encoding/json"
+	"math"
+	"math/big"
 	"testing"
 
+	"github.com/ava-labs/libevm/common"
 	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+	"github.com/holiman/uint256"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/ava-labs/avalanchego/graft/coreth/core/extstate"
+	"github.com/ava-labs/avalanchego/graft/coreth/plugin/evm/atomic"
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/snow"
+	"github.com/ava-labs/avalanchego/vms/components/gas"
 	"github.com/ava-labs/avalanchego/vms/saevm/cchain/tx/txtest"
+	"github.com/ava-labs/avalanchego/vms/saevm/cmputils"
+	"github.com/ava-labs/avalanchego/vms/saevm/hook"
 
 	. "github.com/ava-labs/avalanchego/vms/saevm/cchain/tx"
 )
 
-// fuzz seeds f with [NewTxs] and fuzzes the test.
+// fuzz seeds f with [NewTxs], specifies simple alphabets used to bias the
+// fuzzer, and fuzzes the test.
 func fuzz(f *testing.F, ff func(t *testing.T, tx *Tx)) {
 	fuzzer := &txtest.F{
 		F: f,
+		Addresses: []common.Address{
+			{1},
+		},
+		AssetIDs: []ids.ID{
+			AVAXAssetID,
+		},
 	}
 	for _, tx := range NewTxs {
 		fuzzer.Add(tx)
@@ -51,3 +70,165 @@
 		assert.JSONEq(t, string(want), string(got))
 	})
 }
+
+func FuzzAsOpCompatibility(f *testing.F) {
+	fuzz(f, func(t *testing.T, newTx *Tx) {
+		got, err := newTx.AsOp(AVAXAssetID)
+		if err != nil {
+			t.Skip("invalid tx")
+		}
+
+		oldTx := ToOldTx(t, newTx)
+		gasUsed, err := oldTx.UnsignedAtomicTx.GasUsed(true)
+		require.NoErrorf(t, err, "%T.GasUsed(true)", oldTx.UnsignedAtomicTx)
+
+		gasPrice, err := atomic.EffectiveGasPrice(oldTx.UnsignedAtomicTx, AVAXAssetID, true)
+		require.NoErrorf(t, err, "atomic.EffectiveGasPrice(%T, avaxAssetID, true)", oldTx)
+
+		state := newAsOpStateDB()
+		if export, ok := oldTx.UnsignedAtomicTx.(*atomic.UnsignedExportTx); ok {
+			for _, in := range export.Ins {
+				state.initialNonces[in.Address] = in.Nonce
+			}
+		}
+
+		ctx := &snow.Context{AVAXAssetID: AVAXAssetID}
+		require.NoErrorf(t, oldTx.UnsignedAtomicTx.EVMStateTransfer(ctx, state), "%T.EVMStateTransfer()", oldTx.UnsignedAtomicTx)
+
+		want := hook.Op{
+			ID:        oldTx.ID(),
+			Gas:       gas.Gas(gasUsed),
+			GasFeeCap: gasPrice,
+			Burn:      state.op.Burn,
+			Mint:      state.op.Mint,
+		}
+		if diff := cmp.Diff(want, got, cmpopts.EquateEmpty()); diff != "" {
+			t.Errorf("%T.AsOp() diff (-want +got):\n%s", newTx, diff)
+		}
+	})
+}
+
+// asOpStateDB is an in-memory [atomic.StateDB] for [FuzzAsOpCompatibility]. It
+// constructs a [hook.Op] from [atomic.UnsignedAtomicTx.EVMStateTransfer].
+type asOpStateDB struct {
+	initialNonces map[common.Address]uint64
+	op            hook.Op
+}
+
+func newAsOpStateDB() *asOpStateDB {
+	return &asOpStateDB{
+		initialNonces: make(map[common.Address]uint64),
+		op: hook.Op{
+			Burn: make(map[common.Address]hook.AccountDebit),
+			Mint: make(map[common.Address]uint256.Int),
+		},
+	}
+}
+
+func (s *asOpStateDB) AddBalance(addr common.Address, amount *uint256.Int) {
+	b := s.op.Mint[addr]
+	b.Add(&b, amount)
+	s.op.Mint[addr] = b
+}
+
+func (s *asOpStateDB) SubBalance(addr common.Address, amount *uint256.Int) {
+	d := s.op.Burn[addr]
+	d.Amount.Add(&d.Amount, amount)
+	d.MinBalance = d.Amount
+	s.op.Burn[addr] = d
+}
+
+func (*asOpStateDB) GetBalance(common.Address) *uint256.Int {
+	return largeUint256()
+}
+
+func (*asOpStateDB) AddBalanceMultiCoin(common.Address, common.Hash, *big.Int) {}
+
+func (*asOpStateDB) SubBalanceMultiCoin(common.Address, common.Hash, *big.Int) {}
+
+func (*asOpStateDB) GetBalanceMultiCoin(common.Address, common.Hash) *big.Int {
+	return largeBigInt()
+}
+
+func (s *asOpStateDB) SetNonce(addr common.Address, nonce uint64) {
+	d := s.op.Burn[addr]
+	// The op specifies what nonce is being consumed, not the next nonce. So we
+	// need to subtract 1.
+	d.Nonce = nonce - 1
+	s.op.Burn[addr] = d
+}
+
+func (s *asOpStateDB) GetNonce(addr common.Address) uint64 {
+	return s.initialNonces[addr]
+}
+
+func FuzzAtomicRequestsCompatibility(f *testing.F) {
+	fuzz(f, func(t *testing.T, newTx *Tx) {
+		oldTx := ToOldTx(t, newTx)
+		wantChainID, wantRequests, err := oldTx.UnsignedAtomicTx.AtomicOps()
+		require.NoErrorf(t, err, "%T.AtomicOps()", oldTx.UnsignedAtomicTx)
+
+		gotChainID, gotRequests, err := newTx.AtomicRequests()
+		require.NoErrorf(t, err, "%T.AtomicRequests()", newTx)
+		assert.Equal(t, wantChainID, gotChainID, "chainID")
+		assert.Equal(t, wantRequests, gotRequests, "requests")
+	})
+}
+
+func FuzzTransferNonAVAXCompatibility(f *testing.F) {
+	fuzz(f, func(t *testing.T, newTx *Tx) {
+		op, err := newTx.AsOp(AVAXAssetID)
+		if err != nil {
+			t.Skip("invalid tx")
+		}
+
+		oldState := NewEmptyStateDB(t)
+		newState := NewEmptyStateDB(t)
+		states := []*extstate.StateDB{oldState, newState}
+
+		if tx, ok := newTx.Unsigned.(*Export); ok {
+			for _, in := range tx.Ins {
+				// Coreth silently overflows the nonce, whereas SAE will leave
+				// the nonce unmodified. This difference doesn't matter on live
+				// networks.
+				if in.Nonce == math.MaxUint64 {
+					t.Skip("nonce overflow")
+				}
+
+				for _, state := range states {
+					state.AddBalance(in.Address, largeUint256())
+					state.SetNonce(in.Address, in.Nonce)
+					state.AddBalanceMultiCoin(in.Address, common.Hash(in.AssetID), largeBigInt())
+				}
+			}
+		}
+
+		var (
+			oldTx = ToOldTx(t, newTx)
+			ctx   = &snow.Context{AVAXAssetID: AVAXAssetID}
+		)
+		require.NoError(t, oldTx.UnsignedAtomicTx.EVMStateTransfer(ctx, oldState))
+		require.NoError(t, newTx.TransferNonAVAX(AVAXAssetID, newState))
+		require.NoError(t, op.ApplyTo(newState.StateDB))
+
+		// We must manually finalize the trie structures before comparison.
+		// Otherwise, comparing the state DBs wouldn't include the changes.
+		for _, state := range states {
+			state.Finalise(true)
+			state.IntermediateRoot(true)
+		}
+
+		opts := []cmp.Option{
+			cmpopts.IgnoreUnexported(extstate.StateDB{}),
+			cmputils.StateDBs(),
+		}
+		if diff := cmp.Diff(oldState, newState, opts...); diff != "" {
+			t.Errorf("%T.TransferNonAVAX() diff (-want +got):\n%s", newTx, diff)
+		}
+	})
+}
+
+// largeUint256 and largeBigInt return a balance large enough to never underflow
+// but small enough to never overflow during test arithmetic.
+func largeUint256() *uint256.Int { return new(uint256.Int).Lsh(uint256.NewInt(1), 128) }
+func largeBigInt() *big.Int      { return new(big.Int).Lsh(big.NewInt(1), 128) }