sae: Implement custom tx AsOp

vms/saevm/cchain/tx/BUILD.bazel

@@ -18,12 +18,18 @@ go_library(
     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",
     ],
 )
 
@@ -39,14 +45,19 @@ go_test(
         "//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/compatibility_test.go

@@ -5,13 +5,21 @@
 
 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"
 )
@@ -51,3 +59,96 @@
 		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]
+}

vms/saevm/cchain/tx/export.go

@@ -4,12 +4,22 @@
 package tx
 
 import (
+	"errors"
+	"fmt"
+
 	"github.com/ava-labs/libevm/common"
 
+	// Imported for [atomic.UnsignedExportTx.Burned] comment resolution.
+	_ "github.com/ava-labs/avalanchego/graft/coreth/plugin/evm/atomic"
+
 	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/utils/math"
 	"github.com/ava-labs/avalanchego/vms/components/avax"
+	"github.com/ava-labs/avalanchego/vms/saevm/hook"
 )
 
+var _ Unsigned = (*Export)(nil)
+
 // Export is the unsigned component of a transaction that transfers assets from
 // the C-Chain to either the P-Chain or the X-Chain. It modifies the C-Chain
 // state and produces UTXOs in the shared memory between the C-Chain and the
@@ -22,9 +32,6 @@ type Export struct {
 	ExportedOutputs  []*avax.TransferableOutput `serialize:"true" json:"exportedOutputs"`
 }
 
-// TODO(StephenButtolph): Remove this with its removal from the interface.
-func (*Export) isUnsigned() {}
-
 // Input identifies an account + nonce pair on the C-Chain that authorizes the
 // asset and quantity to deduct.
 //
@@ -36,3 +43,64 @@ type Input struct {
 	AssetID ids.ID         `serialize:"true" json:"assetID"`
 	Nonce   uint64         `serialize:"true" json:"nonce"`
 }
+
+// Like [atomic.UnsignedExportTx.Burned], burned will error if the sum of the
+// inputs exceeds MaxUint64, even if the total amount burned could be
+// represented as a uint64.
+//
+// Because the total supply of AVAX fits in a uint64, this doesn't matter in
+// practice and allows for easier fuzzing.
+func (e *Export) burned(assetID ids.ID) (uint64, error) {
+	var (
+		burned uint64
+		err    error
+	)
+	for _, in := range e.Ins {
+		if in.AssetID == assetID {
+			burned, err = math.Add(burned, in.Amount)
+			if err != nil {
+				return 0, err
+			}
+		}
+	}
+	for _, out := range e.ExportedOutputs {
+		if out.Asset.ID == assetID {
+			burned, err = math.Sub(burned, out.Out.Amount())
+			if err != nil {
+				return 0, err
+			}
+		}
+	}
+	return burned, nil
+}
+
+func (e *Export) numSigs() (uint64, error) {
+	return uint64(len(e.Ins)), nil
+}
+
+var errMultipleNonces = errors.New("multiple nonces for address")
+
+func (e *Export) asOp(avaxAssetID ids.ID) (op, error) {
+	burn := make(map[common.Address]hook.AccountDebit, len(e.Ins))
+	for _, in := range e.Ins {
+		debit, ok := burn[in.Address]
+		if ok && debit.Nonce != in.Nonce {
+			return op{}, fmt.Errorf("%w: address %s has nonces %d and %d", errMultipleNonces, in.Address, debit.Nonce, in.Nonce)
+		}
+
+		// Even if no AVAX is debited, non-AVAX inputs MUST increment the nonce.
+		if in.AssetID == avaxAssetID {
+			amount := scaleAVAX(in.Amount)
+			if _, overflow := debit.Amount.AddOverflow(&debit.Amount, &amount); overflow {
+				return op{}, fmt.Errorf("%w: for address %s", errOverflow, in.Address)
+			}
+		}
+
+		debit.Nonce = in.Nonce
+		debit.MinBalance = debit.Amount
+		burn[in.Address] = debit
+	}
+	return op{
+		burn: burn,
+	}, nil
+}

vms/saevm/cchain/tx/import.go

@@ -4,12 +4,23 @@
 package tx
 
 import (
+	"errors"
+	"fmt"
+
 	"github.com/ava-labs/libevm/common"
+	"github.com/holiman/uint256"
+
+	// Imported for [atomic.UnsignedImportTx.Burned] comment resolution.
+	_ "github.com/ava-labs/avalanchego/graft/coreth/plugin/evm/atomic"
 
 	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/utils/math"
 	"github.com/ava-labs/avalanchego/vms/components/avax"
+	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
 )
 
+var _ Unsigned = (*Import)(nil)
+
 // Import is the unsigned component of a transaction that transfers assets from
 // either the P-Chain or the X-Chain to the C-Chain. It consumes UTXOs in the
 // shared memory between the C-Chain and the source chain and increases balances
@@ -22,9 +33,6 @@ type Import struct {
 	Outs           []Output                  `serialize:"true" json:"outputs"`
 }
 
-// TODO(StephenButtolph): Remove this with its removal from the interface.
-func (*Import) isUnsigned() {}
-
 // Output specifies an account on the C-Chain whose balance of the specified
 // asset should be increased.
 //
@@ -35,3 +43,70 @@ type Output struct {
 	Amount  uint64         `serialize:"true" json:"amount"`
 	AssetID ids.ID         `serialize:"true" json:"assetID"`
 }
+
+// Like [atomic.UnsignedImportTx.Burned], burned will error if the sum of the
+// inputs exceeds MaxUint64, even if the total amount burned could be
+// represented as a uint64.
+//
+// Because the total supply of AVAX fits in a uint64, this doesn't matter in
+// practice and allows for easier fuzzing.
+func (i *Import) burned(assetID ids.ID) (uint64, error) {
+	var (
+		burned uint64
+		err    error
+	)
+	for _, in := range i.ImportedInputs {
+		if in.Asset.ID == assetID {
+			burned, err = math.Add(burned, in.In.Amount())
+			if err != nil {
+				return 0, err
+			}
+		}
+	}
+	for _, out := range i.Outs {
+		if out.AssetID == assetID {
+			burned, err = math.Sub(burned, out.Amount)
+			if err != nil {
+				return 0, err
+			}
+		}
+	}
+	return burned, nil
+}
+
+var errUnexpectedInputType = errors.New("unexpected input type")
+
+func (i *Import) numSigs() (uint64, error) {
+	var n uint64
+	for _, in := range i.ImportedInputs {
+		input, ok := in.In.(*secp256k1fx.TransferInput)
+		if !ok {
+			return 0, fmt.Errorf("%w: got %T ; want %T", errUnexpectedInputType, in.In, input)
+		}
+		n += uint64(len(input.SigIndices))
+	}
+	return n, nil
+}
+
+var errOverflow = errors.New("amount overflow")
+
+func (i *Import) asOp(avaxAssetID ids.ID) (op, error) {
+	mint := make(map[common.Address]uint256.Int, len(i.Outs))
+	for _, out := range i.Outs {
+		if out.AssetID != avaxAssetID {
+			continue
+		}
+
+		var (
+			total  = mint[out.Address]
+			amount = scaleAVAX(out.Amount)
+		)
+		if _, overflow := total.AddOverflow(&total, &amount); overflow {
+			return op{}, fmt.Errorf("%w: for address %s", errOverflow, out.Address)
+		}
+		mint[out.Address] = total
+	}
+	return op{
+		mint: mint,
+	}, nil
+}