Standardize P-Chain tx visitor order

vms/platformvm/block/builder/builder.go

@@ -516,32 +516,29 @@ func executeTx(
 		return false, err
 	}
 
-	executor := &txexecutor.StandardTxExecutor{
-		Backend:       backend,
-		State:         txDiff,
-		FeeCalculator: feeCalculator,
-		Tx:            tx,
-	}
-
-	err = tx.Unsigned.Visit(executor)
+	txInputs, _, _, err := txexecutor.StandardTx(
+		backend,
+		feeCalculator,
+		tx,
+		txDiff,
+	)
 	if err != nil {
 		txID := tx.ID()
 		mempool.MarkDropped(txID, err)
 		return false, nil
 	}
 
-	if inputs.Overlaps(executor.Inputs) {
+	if inputs.Overlaps(txInputs) {
 		txID := tx.ID()
 		mempool.MarkDropped(txID, blockexecutor.ErrConflictingBlockTxs)
 		return false, nil
 	}
-	err = manager.VerifyUniqueInputs(parentID, executor.Inputs)
-	if err != nil {
+	if err := manager.VerifyUniqueInputs(parentID, txInputs); err != nil {
 		txID := tx.ID()
 		mempool.MarkDropped(txID, err)
 		return false, nil
 	}
-	inputs.Union(executor.Inputs)
+	inputs.Union(txInputs)
 
 	txDiff.AddTx(tx, status.Committed)
 	return true, txDiff.Apply(stateDiff)

vms/platformvm/block/builder/helpers_test.go

@@ -247,13 +247,13 @@ func addSubnet(t *testing.T, env *environment) {
 	require.NoError(err)
 
 	feeCalculator := state.PickFeeCalculator(env.config, stateDiff)
-	executor := txexecutor.StandardTxExecutor{
-		Backend:       &env.backend,
-		State:         stateDiff,
-		FeeCalculator: feeCalculator,
-		Tx:            testSubnet1,
-	}
-	require.NoError(testSubnet1.Unsigned.Visit(&executor))
+	_, _, _, err = txexecutor.StandardTx(
+		&env.backend,
+		feeCalculator,
+		testSubnet1,
+		stateDiff,
+	)
+	require.NoError(err)
 
 	stateDiff.AddTx(testSubnet1, status.Committed)
 	require.NoError(stateDiff.Apply(env.state))

vms/platformvm/block/executor/helpers_test.go

@@ -253,13 +253,13 @@ func addSubnet(t testing.TB, env *environment) {
 	require.NoError(err)
 
 	feeCalculator := state.PickFeeCalculator(env.config, stateDiff)
-	executor := executor.StandardTxExecutor{
-		Backend:       env.backend,
-		State:         stateDiff,
-		FeeCalculator: feeCalculator,
-		Tx:            testSubnet1,
-	}
-	require.NoError(testSubnet1.Unsigned.Visit(&executor))
+	_, _, _, err = executor.StandardTx(
+		env.backend,
+		feeCalculator,
+		testSubnet1,
+		stateDiff,
+	)
+	require.NoError(err)
 
 	stateDiff.AddTx(testSubnet1, status.Committed)
 	require.NoError(stateDiff.Apply(env.state))

vms/platformvm/block/executor/manager.go

@@ -142,12 +142,13 @@ func (m *manager) VerifyTx(tx *txs.Tx) error {
 	}
 
 	feeCalculator := state.PickFeeCalculator(m.txExecutorBackend.Config, stateDiff)
-	return tx.Unsigned.Visit(&executor.StandardTxExecutor{
-		Backend:       m.txExecutorBackend,
-		State:         stateDiff,
-		FeeCalculator: feeCalculator,
-		Tx:            tx,
-	})
+	_, _, _, err = executor.StandardTx(
+		m.txExecutorBackend,
+		feeCalculator,
+		tx,
+		stateDiff,
+	)
+	return err
 }
 
 func (m *manager) VerifyUniqueInputs(blkID ids.ID, inputs set.Set[ids.ID]) error {

vms/platformvm/block/executor/verifier.go

@@ -230,23 +230,22 @@ func (v *verifier) ApricotAtomicBlock(b *block.ApricotAtomicBlock) error {
 	}
 
 	feeCalculator := state.NewStaticFeeCalculator(v.txExecutorBackend.Config, currentTimestamp)
-	atomicExecutor := executor.AtomicTxExecutor{
-		Backend:       v.txExecutorBackend,
-		FeeCalculator: feeCalculator,
-		ParentID:      parentID,
-		StateVersions: v,
-		Tx:            b.Tx,
-	}
-
-	if err := b.Tx.Unsigned.Visit(&atomicExecutor); err != nil {
+	onAcceptState, atomicInputs, atomicRequests, err := executor.AtomicTx(
+		v.txExecutorBackend,
+		feeCalculator,
+		parentID,
+		v,
+		b.Tx,
+	)
+	if err != nil {
 		txID := b.Tx.ID()
 		v.MarkDropped(txID, err) // cache tx as dropped
-		return fmt.Errorf("tx %s failed semantic verification: %w", txID, err)
+		return err
 	}
 
-	atomicExecutor.OnAccept.AddTx(b.Tx, status.Committed)
+	onAcceptState.AddTx(b.Tx, status.Committed)
 
-	if err := v.verifyUniqueInputs(parentID, atomicExecutor.Inputs); err != nil {
+	if err := v.verifyUniqueInputs(parentID, atomicInputs); err != nil {
 		return err
 	}
 
@@ -256,11 +255,11 @@ func (v *verifier) ApricotAtomicBlock(b *block.ApricotAtomicBlock) error {
 	v.blkIDToState[blkID] = &blockState{
 		statelessBlock: b,
 
-		onAcceptState: atomicExecutor.OnAccept,
+		onAcceptState: onAcceptState,
 
-		inputs:          atomicExecutor.Inputs,
-		timestamp:       atomicExecutor.OnAccept.GetTimestamp(),
-		atomicRequests:  atomicExecutor.AtomicRequests,
+		inputs:          atomicInputs,
+		timestamp:       onAcceptState.GetTimestamp(),
+		atomicRequests:  atomicRequests,
 		verifiedHeights: set.Of(v.pChainHeight),
 	}
 	return nil
@@ -395,15 +394,14 @@ func (v *verifier) proposalBlock(
 	atomicRequests map[ids.ID]*atomic.Requests,
 	onAcceptFunc func(),
 ) error {
-	txExecutor := executor.ProposalTxExecutor{
-		OnCommitState: onCommitState,
-		OnAbortState:  onAbortState,
-		Backend:       v.txExecutorBackend,
-		FeeCalculator: feeCalculator,
-		Tx:            tx,
-	}
-
-	if err := tx.Unsigned.Visit(&txExecutor); err != nil {
+	err := executor.ProposalTx(
+		v.txExecutorBackend,
+		feeCalculator,
+		tx,
+		onCommitState,
+		onAbortState,
+	)
+	if err != nil {
 		txID := tx.ID()
 		v.MarkDropped(txID, err) // cache tx as dropped
 		return err
@@ -519,30 +517,30 @@ func (v *verifier) processStandardTxs(txs []*txs.Tx, feeCalculator txfee.Calcula
 		atomicRequests = make(map[ids.ID]*atomic.Requests)
 	)
 	for _, tx := range txs {
-		txExecutor := executor.StandardTxExecutor{
-			Backend:       v.txExecutorBackend,
-			State:         diff,
-			FeeCalculator: feeCalculator,
-			Tx:            tx,
-		}
-		if err := tx.Unsigned.Visit(&txExecutor); err != nil {
+		txInputs, txAtomicRequests, onAccept, err := executor.StandardTx(
+			v.txExecutorBackend,
+			feeCalculator,
+			tx,
+			diff,
+		)
+		if err != nil {
 			txID := tx.ID()
 			v.MarkDropped(txID, err) // cache tx as dropped
 			return nil, nil, nil, err
 		}
 		// ensure it doesn't overlap with current input batch
-		if inputs.Overlaps(txExecutor.Inputs) {
+		if inputs.Overlaps(txInputs) {
 			return nil, nil, nil, ErrConflictingBlockTxs
 		}
 		// Add UTXOs to batch
-		inputs.Union(txExecutor.Inputs)
+		inputs.Union(txInputs)
 
 		diff.AddTx(tx, status.Committed)
-		if txExecutor.OnAccept != nil {
-			funcs = append(funcs, txExecutor.OnAccept)
+		if onAccept != nil {
+			funcs = append(funcs, onAccept)
 		}
 
-		for chainID, txRequests := range txExecutor.AtomicRequests {
+		for chainID, txRequests := range txAtomicRequests {
 			// Add/merge in the atomic requests represented by [tx]
 			chainRequests, exists := atomicRequests[chainID]
 			if !exists {

vms/platformvm/metrics/tx_metrics.go

@@ -132,16 +132,16 @@ func (m *txMetrics) TransferSubnetOwnershipTx(*txs.TransferSubnetOwnershipTx) er
 	return nil
 }
 
-func (m *txMetrics) ConvertSubnetTx(*txs.ConvertSubnetTx) error {
+func (m *txMetrics) BaseTx(*txs.BaseTx) error {
 	m.numTxs.With(prometheus.Labels{
-		txLabel: "convert_subnet",
+		txLabel: "base",
 	}).Inc()
 	return nil
 }
 
-func (m *txMetrics) BaseTx(*txs.BaseTx) error {
+func (m *txMetrics) ConvertSubnetTx(*txs.ConvertSubnetTx) error {
 	m.numTxs.With(prometheus.Labels{
-		txLabel: "base",
+		txLabel: "convert_subnet",
 	}).Inc()
 	return nil
 }