Simplify tx verification

vms/avm/unique_tx.go

@@ -8,8 +8,6 @@ import (
 	"errors"
 	"fmt"
 
-	"go.uber.org/zap"
-
 	"github.com/ava-labs/avalanchego/cache"
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/snow/choices"
@@ -23,9 +21,8 @@ var (
 	_ snowstorm.Tx            = (*UniqueTx)(nil)
 	_ cache.Evictable[ids.ID] = (*UniqueTx)(nil)
 
-	errMissingUTXO = errors.New("missing utxo")
-	errUnknownTx   = errors.New("transaction is unknown")
-	errRejectedTx  = errors.New("transaction is rejected")
+	errTxNotProcessing  = errors.New("transaction is not processing")
+	errUnexpectedReject = errors.New("attempting to reject transaction")
 )
 
 // UniqueTx provides a de-duplication service for txs. This only provides a
@@ -40,8 +37,7 @@ type UniqueTx struct {
 type TxCachedState struct {
 	*txs.Tx
 
-	unique, verifiedTx, verifiedState bool
-	validity                          error
+	unique bool
 
 	deps []snowstorm.Tx
 
@@ -118,7 +114,7 @@ func (tx *UniqueTx) Key() ids.ID {
 // Accept is called when the transaction was finalized as accepted by consensus
 func (tx *UniqueTx) Accept(context.Context) error {
 	if s := tx.Status(); s != choices.Processing {
-		return fmt.Errorf("transaction has invalid status: %s", s)
+		return fmt.Errorf("%w: %s", errTxNotProcessing, s)
 	}
 
 	if err := tx.vm.onAccept(tx.Tx); err != nil {
@@ -157,27 +153,8 @@ func (tx *UniqueTx) Accept(context.Context) error {
 	return tx.vm.metrics.MarkTxAccepted(tx.Tx)
 }
 
-// Reject is called when the transaction was finalized as rejected by consensus
-func (tx *UniqueTx) Reject(context.Context) error {
-	tx.setStatus(choices.Rejected)
-
-	txID := tx.ID()
-	tx.vm.ctx.Log.Debug("rejecting tx",
-		zap.Stringer("txID", txID),
-	)
-
-	if err := tx.vm.state.Commit(); err != nil {
-		tx.vm.ctx.Log.Error("failed to commit reject",
-			zap.Stringer("txID", tx.txID),
-			zap.Error(err),
-		)
-		return err
-	}
-
-	tx.vm.walletService.decided(txID)
-
-	tx.deps = nil // Needed to prevent a memory leak
-	return nil
+func (*UniqueTx) Reject(context.Context) error {
+	return errUnexpectedReject
 }
 
 // Status returns the current status of this transaction
@@ -228,59 +205,11 @@ func (tx *UniqueTx) Bytes() []byte {
 	return tx.Tx.Bytes()
 }
 
-func (tx *UniqueTx) verifyWithoutCacheWrites() error {
-	switch status := tx.Status(); status {
-	case choices.Unknown:
-		return errUnknownTx
-	case choices.Accepted:
-		return nil
-	case choices.Rejected:
-		return errRejectedTx
-	default:
-		return tx.SemanticVerify()
-	}
-}
-
 // Verify the validity of this transaction
 func (tx *UniqueTx) Verify(context.Context) error {
-	if err := tx.verifyWithoutCacheWrites(); err != nil {
-		return err
-	}
-
-	tx.verifiedState = true
-	return nil
-}
-
-// SyntacticVerify verifies that this transaction is well formed
-func (tx *UniqueTx) SyntacticVerify() error {
-	tx.refresh()
-
-	if tx.Tx == nil {
-		return errUnknownTx
-	}
-
-	if tx.verifiedTx {
-		return tx.validity
-	}
-
-	tx.verifiedTx = true
-	tx.validity = tx.Tx.Unsigned.Visit(&executor.SyntacticVerifier{
-		Backend: tx.vm.txBackend,
-		Tx:      tx.Tx,
-	})
-	return tx.validity
-}
-
-// SemanticVerify the validity of this transaction
-func (tx *UniqueTx) SemanticVerify() error {
-	if err := tx.SyntacticVerify(); err != nil {
-		return err
-	}
-
-	if tx.validity != nil || tx.verifiedState {
-		return tx.validity
+	if s := tx.Status(); s != choices.Processing {
+		return fmt.Errorf("%w: %s", errTxNotProcessing, s)
 	}
-
 	return tx.Unsigned.Visit(&executor.SemanticVerifier{
 		Backend: tx.vm.txBackend,
 		State:   tx.vm.state,

vms/avm/vm.go

@@ -460,16 +460,21 @@ func (vm *VM) ParseTx(_ context.Context, bytes []byte) (snowstorm.Tx, error) {
 		return nil, err
 	}
 
+	err = rawTx.Unsigned.Visit(&txexecutor.SyntacticVerifier{
+		Backend: vm.txBackend,
+		Tx:      rawTx,
+	})
+	if err != nil {
+		return nil, err
+	}
+
 	tx := &UniqueTx{
 		TxCachedState: &TxCachedState{
 			Tx: rawTx,
 		},
 		vm:   vm,
 		txID: rawTx.ID(),
 	}
-	if err := tx.SyntacticVerify(); err != nil {
-		return nil, err
-	}
 
 	if tx.Status() == choices.Unknown {
 		vm.state.AddTx(tx.Tx)

vms/avm/wallet_service.go

@@ -4,6 +4,7 @@
 package avm
 
 import (
+	"errors"
 	"fmt"
 	"net/http"
 
@@ -22,6 +23,8 @@ import (
 	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
 )
 
+var errMissingUTXO = errors.New("missing utxo")
+
 type WalletService struct {
 	vm         *VM
 	pendingTxs linkedhashmap.LinkedHashmap[ids.ID, *txs.Tx]