sae: Implement custom tx AsOp

.github/CODEOWNERS

@@ -10,3 +10,4 @@
 /graft/evm @ava-labs/platform-evm
 /graft/subnet-evm @ava-labs/platform-evm
 /vms/saevm @ARR4N @StephenButtolph
+/vms/saevm/cchain @StephenButtolph

graft/coreth/BUILD.bazel

@@ -19,6 +19,7 @@ package_group(
         "//tests/reexecute/c",
         "//tests/reexecute/chaos",
         "//vms/evm/emulate",
+        "//vms/saevm/cchain/...",
         "//wallet/chain/c",
         "//wallet/subnet/primary",
     ],

ids/short.go

@@ -40,6 +40,16 @@ func ShortFromString(idStr string) (ShortID, error) {
 	return ToShortID(bytes)
 }
 
+// ShortFromStringOrPanic is the same as ShortFromString, but will panic on
+// error.
+func ShortFromStringOrPanic(idStr string) ShortID {
+	id, err := ShortFromString(idStr)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
 // ShortFromPrefixedString returns a ShortID assuming the cb58 format is
 // prefixed
 func ShortFromPrefixedString(idStr, prefix string) (ShortID, error) {

vms/saevm/cchain/BUILD.bazel

@@ -0,0 +1,11 @@
+# gazelle:default_visibility //vms/saevm/cchain:__subpackages__,//vms/saevm/cchain:external_consumers
+
+package(default_visibility = [
+    "//vms/saevm/cchain:__subpackages__",
+    "//vms/saevm/cchain:external_consumers",
+])
+
+package_group(
+    name = "external_consumers",
+    packages = [],
+)

vms/saevm/cchain/tx/BUILD.bazel

@@ -0,0 +1,64 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+load("//.bazel:defs.bzl", "go_test")
+
+package(default_visibility = [
+    "//vms/saevm/cchain:__subpackages__",
+    "//vms/saevm/cchain:external_consumers",
+])
+
+go_library(
+    name = "tx",
+    srcs = [
+        "codec.go",
+        "export.go",
+        "import.go",
+        "tx.go",
+    ],
+    importpath = "github.com/ava-labs/avalanchego/vms/saevm/cchain/tx",
+    deps = [
+        "//codec",
+        "//codec/linearcodec",
+        "//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",
+    ],
+)
+
+go_test(
+    name = "tx_test",
+    srcs = [
+        "compatibility_test.go",
+        "tx_test.go",
+    ],
+    data = glob(["testdata/**"]),
+    embed = [":tx"],
+    deps = [
+        "//graft/coreth/plugin/evm/atomic",
+        "//graft/coreth/plugin/evm/atomic/vm",
+        "//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_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/codec.go

@@ -0,0 +1,75 @@
+// Copyright (C) 2019, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package tx
+
+import (
+	"errors"
+
+	"github.com/ava-labs/avalanchego/codec"
+	"github.com/ava-labs/avalanchego/codec/linearcodec"
+	"github.com/ava-labs/avalanchego/utils/wrappers"
+	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
+)
+
+const codecVersion uint16 = 0
+
+var c codec.Manager
+
+func init() {
+	c = codec.NewDefaultManager()
+
+	// Registration order impacts the typeID included in the canonical format.
+	// We skip registrations in specific locations so that UTXOs in shared
+	// memory share the same serialized format as on the P-Chain and X-Chain.
+	var (
+		lc   = linearcodec.NewDefault()
+		errs = wrappers.Errs{}
+	)
+	errs.Add(
+		lc.RegisterType(&Import{}),
+		lc.RegisterType(&Export{}),
+	)
+	lc.SkipRegistrations(3)
+	errs.Add(
+		lc.RegisterType(&secp256k1fx.TransferInput{}),
+	)
+	lc.SkipRegistrations(1)
+	errs.Add(
+		lc.RegisterType(&secp256k1fx.TransferOutput{}),
+	)
+	lc.SkipRegistrations(1)
+	errs.Add(
+		lc.RegisterType(&secp256k1fx.Credential{}),
+		c.RegisterCodec(codecVersion, lc),
+	)
+	if errs.Errored() {
+		panic(errs.Err)
+	}
+}
+
+// MarshalSlice returns the canonical binary format of a slice of transactions.
+func MarshalSlice(txs []*Tx) ([]byte, error) {
+	if len(txs) == 0 {
+		return nil, nil
+	}
+	return c.Marshal(codecVersion, txs)
+}
+
+var errInefficientSlicePacking = errors.New("inefficient slice packing: empty slices should be packed as nil")
+
+// ParseSlice deserializes a slice of [Tx] from its canonical binary format.
+func ParseSlice(b []byte) ([]*Tx, error) {
+	if len(b) == 0 {
+		return nil, nil
+	}
+
+	var txs []*Tx
+	if _, err := c.Unmarshal(b, &txs); err != nil {
+		return nil, err
+	}
+	if len(txs) == 0 {
+		return nil, errInefficientSlicePacking
+	}
+	return txs, nil
+}

vms/saevm/cchain/tx/compatibility_test.go

@@ -0,0 +1,154 @@
+// Copyright (C) 2019, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package tx_test
+
+import (
+	"encoding/json"
+	"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/plugin/evm/atomic"
+	"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/hook"
+
+	. "github.com/ava-labs/avalanchego/vms/saevm/cchain/tx"
+)
+
+// fuzz seeds f with [NewTxs] and fuzzes the test.
+func fuzz(f *testing.F, ff func(t *testing.T, tx *Tx)) {
+	fuzzer := &txtest.F{
+		F: f,
+	}
+	for _, tx := range NewTxs {
+		fuzzer.Add(tx)
+	}
+	fuzzer.Fuzz(ff)
+}
+
+func FuzzParseRoundTrip(f *testing.F) {
+	fuzz(f, func(t *testing.T, want *Tx) {
+		bytes, err := want.Bytes()
+		require.NoErrorf(t, err, "%T.Bytes()", want)
+
+		got, err := Parse(bytes)
+		require.NoError(t, err, "Parse()")
+		if diff := cmp.Diff(want, got, CmpOpt()); diff != "" {
+			t.Errorf("Parse() diff (-want +got):\n%s", diff)
+		}
+	})
+}
+
+func FuzzJSONCompatibility(f *testing.F) {
+	fuzz(f, func(t *testing.T, newTx *Tx) {
+		oldTx := ToOldTx(t, newTx)
+		want, err := json.Marshal(oldTx)
+		require.NoErrorf(t, err, "json.Marshal(%T)", oldTx)
+
+		got, err := json.Marshal(newTx)
+		require.NoErrorf(t, err, "json.Marshal(%T)", newTx)
+		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 {
+	// Large enough to never underflow, but small enough to never overflow.
+	return new(uint256.Int).Lsh(uint256.NewInt(1), 128)
+}
+
+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 {
+	// Large enough to never underflow, but small enough to never overflow.
+	return new(big.Int).Lsh(big.NewInt(1), 128)
+}
+
+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]
+}