Chore: Eliminate BlockEvaluator.Transaction

cmd/algoh/blockstats_test.go

@@ -77,7 +77,7 @@ func TestEventWithDetails(t *testing.T) {
 
 	// Create blocks with some senders in the payload.
 	makeStxnWithAddr := func(addr basics.Address) transactions.SignedTxnInBlock {
-		return transactions.SignedTxnInBlock{SignedTxnWithAD: transactions.SignedTxnWithAD{SignedTxn: transactions.SignedTxn{Txn: transactions.Transaction{Header: transactions.Header{Sender: addr}}}}}
+		return transactions.SignedTxnInBlock{SignedTxnWithAD: transactions.SignedTxn{Txn: transactions.Transaction{Header: transactions.Header{Sender: addr}}}.WithAD()}
 	}
 	addr := basics.Address{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
 	otherAddr := basics.Address{0x7, 0xda, 0xcb, 0x4b, 0x6d, 0x9e, 0xd1, 0x41, 0xb1, 0x75, 0x76, 0xbd, 0x45, 0x9a, 0xe6, 0x42, 0x1d, 0x48, 0x6d, 0xa3, 0xd4, 0xef, 0x22, 0x47, 0xc4, 0x9, 0xa3, 0x96, 0xb8, 0x2e, 0xa2, 0x21}

daemon/algod/api/server/v2/test/handlers_test.go

@@ -1261,17 +1261,12 @@ int 1`,
 								FailedAt:          expectedFailedAt,
 								Txns: []v2.PreEncodedSimulateTxnResult{
 									{
-										Txn: makePendingTxnResponse(t, transactions.SignedTxnWithAD{
-											SignedTxn: stxns[0],
-											// expect no ApplyData info
-										}),
+										// expect no ApplyData info
+										Txn:               makePendingTxnResponse(t, stxns[0].WithAD()),
 										AppBudgetConsumed: txnAppBudgetUsed[0],
 									},
 									{
-										Txn: makePendingTxnResponse(t, transactions.SignedTxnWithAD{
-											SignedTxn: stxns[1],
-											ApplyData: scenario.ExpectedSimulationAD,
-										}),
+										Txn:               makePendingTxnResponse(t, stxns[1].WithAD(scenario.ExpectedSimulationAD)),
 										AppBudgetConsumed: txnAppBudgetUsed[1],
 									},
 								},
@@ -1997,7 +1992,7 @@ func addStateProof(blk bookkeeping.Block) bookkeeping.Block {
 			},
 		},
 	}
-	txnib := transactions.SignedTxnInBlock{SignedTxnWithAD: transactions.SignedTxnWithAD{SignedTxn: tx}}
+	txnib := transactions.SignedTxnInBlock{SignedTxnWithAD: tx.WithAD()}
 	blk.Payset = append(blk.Payset, txnib)
 
 	updatedStateProofTracking := bookkeeping.StateProofTrackingData{
@@ -2316,13 +2311,13 @@ func TestDeltasForTxnGroup(t *testing.T) {
 	blk2 := bookkeeping.BlockHeader{Round: 2}
 	delta1 := ledgercore.StateDelta{Hdr: &blk1}
 	delta2 := ledgercore.StateDelta{Hdr: &blk2, KvMods: map[string]ledgercore.KvValueDelta{"bx1": {Data: []byte("foobar")}}}
-	txn1 := transactions.SignedTxnWithAD{SignedTxn: transactions.SignedTxn{Txn: transactions.Transaction{Type: protocol.PaymentTx}}}
+	txn1 := transactions.SignedTxn{Txn: transactions.Transaction{Type: protocol.PaymentTx}}.WithAD()
 	groupID1, err := crypto.DigestFromString(crypto.Hash([]byte("hello")).String())
 	require.NoError(t, err)
-	txn2 := transactions.SignedTxnWithAD{SignedTxn: transactions.SignedTxn{Txn: transactions.Transaction{
+	txn2 := transactions.SignedTxn{Txn: transactions.Transaction{
 		Type:   protocol.AssetTransferTx,
 		Header: transactions.Header{Group: groupID1}},
-	}}
+	}.WithAD()
 
 	tracer := eval.MakeTxnGroupDeltaTracer(2)
 	handlers := v2.Handlers{

data/bookkeeping/encoding_test.go

@@ -54,9 +54,7 @@ func TestBlockWithTxnEncoding(t *testing.T) {
 	var b Block
 	b.Payset = []transactions.SignedTxnInBlock{
 		{
-			SignedTxnWithAD: transactions.SignedTxnWithAD{
-				SignedTxn: sigtxn,
-			},
+			SignedTxnWithAD: sigtxn.WithAD(),
 		},
 	}
 	enc := protocol.Encode(&b)

data/ledger_test.go

@@ -190,9 +190,7 @@ func TestLedgerCirculation(t *testing.T) {
 		tx.Type = protocol.PaymentTx
 		signedTx := tx.Sign(srcAccountKey)
 		blk.Payset = transactions.Payset{transactions.SignedTxnInBlock{
-			SignedTxnWithAD: transactions.SignedTxnWithAD{
-				SignedTxn: signedTx,
-			},
+			SignedTxnWithAD: signedTx.WithAD(),
 		}}
 		require.NoError(t, l.AddBlock(blk, agreement.Certificate{}))
 		l.WaitForCommit(rnd)

data/pools/transactionPool.go

@@ -109,8 +109,7 @@ type BlockEvaluator interface {
 	TestTransactionGroup(txgroup []transactions.SignedTxn) error
 	Round() basics.Round
 	PaySetSize() int
-	TransactionGroup(txads []transactions.SignedTxnWithAD) error
-	Transaction(txn transactions.SignedTxn, ad transactions.ApplyData) error
+	TransactionGroup(txads ...transactions.SignedTxnWithAD) error
 	GenerateBlock(addrs []basics.Address) (*ledgercore.UnfinishedBlock, error)
 	ResetTxnBytes()
 }
@@ -616,7 +615,7 @@ func (pool *TransactionPool) addToPendingBlockEvaluatorOnce(txgroup []transactio
 		transactionGroupStartsTime = time.Now()
 	}
 
-	err := pool.pendingBlockEvaluator.TransactionGroup(txgroupad)
+	err := pool.pendingBlockEvaluator.TransactionGroup(txgroupad...)
 
 	if recomputing {
 		if !pool.assemblyResults.assemblyCompletedOrAbandoned {

data/pools/transactionPool_test.go

@@ -565,7 +565,7 @@ func TestRememberForget(t *testing.T) {
 				tx.Note[1] = byte(j)
 				signedTx := tx.Sign(secrets[i])
 				transactionPool.RememberOne(signedTx)
-				err := eval.Transaction(signedTx, transactions.ApplyData{})
+				err := eval.TransactionGroup(signedTx.WithAD())
 				require.NoError(t, err)
 			}
 		}
@@ -733,7 +733,7 @@ func TestFixOverflowOnNewBlock(t *testing.T) {
 	signedTx := tx.Sign(secrets[0])
 
 	blockEval := newBlockEvaluator(t, mockLedger)
-	err := blockEval.Transaction(signedTx, transactions.ApplyData{})
+	err := blockEval.TransactionGroup(signedTx.WithAD())
 	require.NoError(t, err)
 
 	// simulate this transaction was applied
@@ -1272,7 +1272,7 @@ func BenchmarkTransactionPoolSteadyState(b *testing.B) {
 		eval := newBlockEvaluator(b, l)
 		for len(ledgerTxnQueue) > 0 {
 			stx := ledgerTxnQueue[0]
-			err := eval.Transaction(stx, transactions.ApplyData{})
+			err := eval.TransactionGroup(stx.WithAD())
 			if err == ledgercore.ErrNoSpace {
 				break
 			}
@@ -1522,7 +1522,7 @@ func TestStateProofLogging(t *testing.T) {
 	eval, err := mockLedger.StartEvaluator(b.BlockHeader, 0, 1000000, nil)
 	require.NoError(t, err)
 
-	err = eval.Transaction(stxn, transactions.ApplyData{})
+	err = eval.TransactionGroup(stxn.WithAD())
 	require.NoError(t, err)
 
 	err = transactionPool.RememberOne(stxn)

data/transactions/logic/blackbox_test.go

@@ -43,13 +43,13 @@ func TestNewAppEvalParams(t *testing.T) {
 		Sender:   basics.Address{1, 2, 3, 4},
 		Receiver: basics.Address{4, 3, 2, 1},
 		Amount:   100,
-	}.SignedTxnWithAD()
+	}.SignedTxn().WithAD()
 
 	appcall1 := txntest.Txn{
 		Type:          protocol.ApplicationCallTx,
 		Sender:        basics.Address{1, 2, 3, 4},
 		ApplicationID: basics.AppIndex(1),
-	}.SignedTxnWithAD()
+	}.SignedTxn().WithAD()
 
 	appcall2 := appcall1
 	appcall2.Txn.ApplicationID = basics.AppIndex(2)

data/transactions/logic/eval.go

@@ -2986,12 +2986,12 @@ func TxnFieldToTealValue(txn *transactions.Transaction, groupIndex int, field Tx
 		return basics.TealValue{}, fmt.Errorf("negative groupIndex %d", groupIndex)
 	}
 	var cx EvalContext
-	stxnad := &transactions.SignedTxnWithAD{SignedTxn: transactions.SignedTxn{Txn: *txn}}
+	stxnad := transactions.SignedTxn{Txn: *txn}.WithAD()
 	fs, ok := txnFieldSpecByField(field)
 	if !ok {
 		return basics.TealValue{}, fmt.Errorf("invalid field %s", field)
 	}
-	sv, err := cx.txnFieldToStack(stxnad, &fs, arrayFieldIdx, groupIndex, inner)
+	sv, err := cx.txnFieldToStack(&stxnad, &fs, arrayFieldIdx, groupIndex, inner)
 	return sv.ToTealValue(), err
 }
 

data/transactions/payset_test.go

@@ -27,9 +27,7 @@ func generatePayset(txnCount, acctCount int) Payset {
 	stxnb := make([]SignedTxnInBlock, txnCount)
 	for i, stxn := range generateSignedTxns(txnCount, acctCount) {
 		stxnb[i] = SignedTxnInBlock{
-			SignedTxnWithAD: SignedTxnWithAD{
-				SignedTxn: stxn,
-			},
+			SignedTxnWithAD: stxn.WithAD(),
 		}
 	}
 	return Payset(stxnb)

data/transactions/signedtxn.go

@@ -62,6 +62,18 @@ func (s SignedTxn) ID() Txid {
 	return s.Txn.ID()
 }
 
+// WithAD returns a SignedTxnWithAD with an (optional) ApplyData.
+func (s SignedTxn) WithAD(ad ...ApplyData) SignedTxnWithAD {
+	switch len(ad) {
+	case 0:
+		return SignedTxnWithAD{SignedTxn: s}
+	case 1:
+		return SignedTxnWithAD{SignedTxn: s, ApplyData: ad[0]}
+	default:
+		panic("WithAD called incorrectly")
+	}
+}
+
 // ID on SignedTxnInBlock should never be called, because the ID depends
 // on the block from which this transaction will be decoded.  By having
 // a different return value from SignedTxn.ID(), we will catch errors at

data/txntest/txn.go

@@ -320,13 +320,6 @@ func (tx Txn) SignedTxn() transactions.SignedTxn {
 	return transactions.SignedTxn{Txn: tx.Txn()}
 }
 
-// SignedTxnWithAD produces unsigned, transactions.SignedTxnWithAD
-// from the fields in this Txn.  This seemingly pointless operation
-// exists, again, for convenience when driving tests.
-func (tx Txn) SignedTxnWithAD() transactions.SignedTxnWithAD {
-	return transactions.SignedTxnWithAD{SignedTxn: tx.SignedTxn()}
-}
-
 // Group turns a list of Txns into a slice of SignedTxns with
 // GroupIDs set properly to make them a transaction group. The input
 // Txns are modified with the calculated GroupID.

ledger/archival_test.go

@@ -655,11 +655,9 @@ func TestArchivalCreatables(t *testing.T) {
 
 func makeSignedTxnInBlock(tx transactions.Transaction) transactions.SignedTxnInBlock {
 	return transactions.SignedTxnInBlock{
-		SignedTxnWithAD: transactions.SignedTxnWithAD{
-			SignedTxn: transactions.SignedTxn{
+		SignedTxnWithAD: transactions.SignedTxn{
 				Txn: tx,
-			},
-		},
+			}.WithAD(),
 		HasGenesisID: true,
 	}
 }

ledger/eval/eval.go

@@ -932,7 +932,7 @@ func (eval *BlockEvaluator) TestTransactionGroup(txgroup []transactions.SignedTx
 
 	var group transactions.TxGroup
 	for gi, txn := range txgroup {
-		err := eval.TestTransaction(txn)
+		err := eval.testTransaction(txn)
 		if err != nil {
 			return err
 		}
@@ -973,10 +973,10 @@ func (eval *BlockEvaluator) TestTransactionGroup(txgroup []transactions.SignedTx
 	return nil
 }
 
-// TestTransaction performs basic duplicate detection and well-formedness checks
+// testTransaction performs basic duplicate detection and well-formedness checks
 // on a single transaction, but does not actually add the transaction to the block
 // evaluator, or modify the block evaluator state in any other visible way.
-func (eval *BlockEvaluator) TestTransaction(txn transactions.SignedTxn) error {
+func (eval *BlockEvaluator) testTransaction(txn transactions.SignedTxn) error {
 	// Transaction valid (not expired)?
 	err := eval.block.Alive(txn.Txn.Header)
 	if err != nil {
@@ -999,22 +999,10 @@ func (eval *BlockEvaluator) TestTransaction(txn transactions.SignedTxn) error {
 	return nil
 }
 
-// Transaction tentatively adds a new transaction as part of this block evaluation.
-// If the transaction cannot be added to the block without violating some constraints,
-// an error is returned and the block evaluator state is unchanged.
-func (eval *BlockEvaluator) Transaction(txn transactions.SignedTxn, ad transactions.ApplyData) error {
-	return eval.TransactionGroup([]transactions.SignedTxnWithAD{
-		{
-			SignedTxn: txn,
-			ApplyData: ad,
-		},
-	})
-}
-
 // TransactionGroup tentatively adds a new transaction group as part of this block evaluation.
 // If the transaction group cannot be added to the block without violating some constraints,
 // an error is returned and the block evaluator state is unchanged.
-func (eval *BlockEvaluator) TransactionGroup(txgroup []transactions.SignedTxnWithAD) (err error) {
+func (eval *BlockEvaluator) TransactionGroup(txgroup ...transactions.SignedTxnWithAD) (err error) {
 	// Nothing to do if there are no transactions.
 	if len(txgroup) == 0 {
 		return nil
@@ -2168,7 +2156,7 @@ transactionGroupLoop:
 					}
 				}
 			}
-			err = eval.TransactionGroup(txgroup.TxnGroup)
+			err = eval.TransactionGroup(txgroup.TxnGroup...)
 			if err != nil {
 				return ledgercore.StateDelta{}, err
 			}

ledger/eval/eval_test.go

@@ -165,7 +165,7 @@ ok:
 	if err != nil {
 		return eval, addrs[0], err
 	}
-	err = eval.TransactionGroup(g)
+	err = eval.TransactionGroup(g...)
 	return eval, addrs[0], err
 }
 
@@ -221,12 +221,12 @@ func TestPrivateTransactionGroup(t *testing.T) {
 
 	var txgroup []transactions.SignedTxnWithAD
 	eval := BlockEvaluator{}
-	err := eval.TransactionGroup(txgroup)
+	err := eval.TransactionGroup(txgroup...)
 	require.NoError(t, err) // nothing to do, no problem
 
 	eval.proto = config.Consensus[protocol.ConsensusCurrentVersion]
 	txgroup = make([]transactions.SignedTxnWithAD, eval.proto.MaxTxGroupSize+1)
-	err = eval.TransactionGroup(txgroup)
+	err = eval.TransactionGroup(txgroup...)
 	require.ErrorContains(t, err, "group size")
 }
 
@@ -399,7 +399,7 @@ int 1`,
 
 			require.Len(t, eval.block.Payset, 0)
 
-			err = eval.TransactionGroup(txgroup)
+			err = eval.TransactionGroup(txgroup...)
 			switch testCase.firstTxnBehavior {
 			case "approve":
 				if len(scenario.ExpectedError) != 0 {
@@ -666,7 +666,7 @@ func testnetFixupExecution(t *testing.T, headerRound basics.Round, poolBonus uin
 		},
 	}
 	st := txn.Sign(keys[0])
-	err = eval.Transaction(st, transactions.ApplyData{})
+	err = eval.TransactionGroup(st.WithAD())
 	require.NoError(t, err)
 
 	poolOld, err := eval.workaroundOverspentRewards(rewardPoolBalance, headerRound)
@@ -1420,12 +1420,11 @@ func TestAbsenteeChecks(t *testing.T) {
 		return pay(i, addrs[i]).Sign(keys[i])
 	}
 
-	require.NoError(t, blkEval.Transaction(selfpay(0), transactions.ApplyData{}))
-	require.NoError(t, blkEval.Transaction(selfpay(1), transactions.ApplyData{}))
-	require.NoError(t, blkEval.Transaction(selfpay(2), transactions.ApplyData{}))
+	require.NoError(t, blkEval.TransactionGroup(selfpay(0).WithAD()))
+	require.NoError(t, blkEval.TransactionGroup(selfpay(1).WithAD()))
+	require.NoError(t, blkEval.TransactionGroup(selfpay(2).WithAD()))
 	for i := 0; i < 32; i++ {
-		require.NoError(t, blkEval.Transaction(pay(0, basics.Address{byte(i << 3), 0xaa}).Sign(keys[0]),
-			transactions.ApplyData{}))
+		require.NoError(t, blkEval.TransactionGroup(pay(0, basics.Address{byte(i << 3), 0xaa}).Sign(keys[0]).WithAD()))
 	}
 
 	// Make sure we validate our block as well

ledger/eval/evalindexer.go

@@ -33,7 +33,7 @@ func (eval *BlockEvaluator) ProcessBlockForIndexer(block *bookkeeping.Block) (le
 	}
 
 	for _, group := range paysetgroups {
-		err = eval.TransactionGroup(group)
+		err = eval.TransactionGroup(group...)
 		if err != nil {
 			return ledgercore.StateDelta{}, []transactions.SignedTxnInBlock{},
 				fmt.Errorf("ProcessBlockForIndexer() err: %w", err)

ledger/eval/prefetcher/prefetcher_alignment_test.go

@@ -331,7 +331,7 @@ func runEval(t *testing.T, l *prefetcherAlignmentTestLedger, txn transactions.Tr
 	eval, err := eval.StartEvaluator(l, block.BlockHeader, eval.EvaluatorOptions{})
 	require.NoError(t, err)
 
-	err = eval.TransactionGroup(makeGroupFromTxn(txn))
+	err = eval.TransactionGroup(makeGroupFromTxn(txn)...)
 	require.NoError(t, err)
 }
 

ledger/eval/txntracer_test.go

@@ -212,7 +212,7 @@ int 1`
 
 			require.Len(t, eval.block.Payset, 0)
 
-			err = eval.TransactionGroup(txgroup)
+			err = eval.TransactionGroup(txgroup...)
 			require.NoError(t, err)
 			require.Len(t, eval.block.Payset, 4)
 
@@ -226,10 +226,7 @@ int 1`
 				Fee:         minFee,
 				GenesisHash: genHash,
 			}
-			secondTxGroup := transactions.WrapSignedTxnsWithAD([]transactions.SignedTxn{
-				secondPayTxn.Txn().Sign(keys[2]),
-			})
-			err = eval.TransactionGroup(secondTxGroup)
+			err = eval.TransactionGroup(secondPayTxn.Txn().Sign(keys[2]).WithAD())
 			require.NoError(t, err)
 
 			// Calculate expected balances dynamically based on proto.MinTxnFee