simulate: fix signers

ledger/simulation/simulation_eval_test.go

@@ -8896,3 +8896,74 @@ func TestUnnamedResourcesCrossProductLimits(t *testing.T) {
 		})
 	}
 }
+
+func TestFixAuthAddr(t *testing.T) {
+	partitiontest.PartitionTest(t)
+	t.Parallel()
+
+	env := simulationtesting.PrepareSimulatorTest(t)
+	defer env.Close()
+
+	sender := env.Accounts[0]
+	other := env.Accounts[1]
+
+	appID := env.CreateApp(sender.Addr, simulationtesting.AppParams{
+		ApprovalProgram: `#pragma version 9
+txn ApplicationID
+bz end
+
+itxn_begin
+int pay
+itxn_field TypeEnum
+txn ApplicationArgs 0
+itxn_field Sender
+txn ApplicationArgs 0
+sha512_256 // essentially a random account
+itxn_field RekeyTo
+itxn_submit
+
+end:
+int 1
+`,
+		ClearStateProgram: "#pragma version 9\nint 1",
+	})
+	env.TransferAlgos(sender.Addr, appID.Address(), 1_000_000)
+
+	pay0 := env.TxnInfo.NewTxn(txntest.Txn{
+		Type:     protocol.PaymentTx,
+		Sender:   sender.Addr,
+		Receiver: sender.Addr,
+		RekeyTo:  other.Addr,
+	})
+	pay1 := env.TxnInfo.NewTxn(txntest.Txn{
+		Type:     protocol.PaymentTx,
+		Sender:   sender.Addr,
+		Receiver: sender.Addr,
+		RekeyTo:  appID.Address(),
+	})
+	appCall := env.TxnInfo.NewTxn(txntest.Txn{
+		Type:            protocol.ApplicationCallTx,
+		Sender:          other.Addr,
+		ApplicationID:   appID,
+		ApplicationArgs: [][]byte{sender.Addr[:]},
+	})
+	pay2 := env.TxnInfo.NewTxn(txntest.Txn{
+		Type:     protocol.PaymentTx,
+		Sender:   sender.Addr,
+		Receiver: sender.Addr,
+	})
+
+	txgroup := txntest.Group(&pay0, &pay1, &appCall, &pay2)
+
+	request := simulation.Request{
+		TxnGroups:            [][]transactions.SignedTxn{txgroup},
+		AllowEmptySignatures: true,
+	}
+
+	result, err := simulation.MakeSimulator(env.Ledger, false).Simulate(request)
+	require.NoError(t, err)
+
+	require.Empty(t, result.TxnGroups[0].FailureMessage)
+
+	// TODO: make sure output txn has the correct auth addr?
+}

ledger/simulation/simulator.go

@@ -142,7 +142,7 @@
 // check verifies that the transaction is well-formed and has valid or missing signatures.
 // An invalid transaction group error is returned if the transaction is not well-formed or there are invalid signatures.
 // To make things easier, we support submitting unsigned transactions and will respond whether signatures are missing.
-func (s Simulator) check(hdr bookkeeping.BlockHeader, txgroup []transactions.SignedTxn, tracer logic.EvalTracer, overrides ResultEvalOverrides) error {
+func (s Simulator) check(hdr bookkeeping.BlockHeader, txgroup []transactions.SignedTxnWithAD, tracer logic.EvalTracer, overrides ResultEvalOverrides) error {
 	proxySignerSecrets, err := crypto.SecretKeyToSignatureSecrets(proxySigner)
 	if err != nil {
 		return err
@@ -158,7 +158,8 @@
 	// denoting that a LogicSig's delegation signature is omitted, e.g. by setting all the bits of
 	// the signature.
 	txnsToVerify := make([]transactions.SignedTxn, len(txgroup))
-	for i, stxn := range txgroup {
+	for i, stxnad := range txgroup {
+		stxn := stxnad.SignedTxn
 		if stxn.Txn.Type == protocol.StateProofTx {
 			return errors.New("cannot simulate StateProof transactions")
 		}
@@ -181,16 +182,14 @@
 	return err
 }
 
-func (s Simulator) evaluate(hdr bookkeeping.BlockHeader, stxns []transactions.SignedTxn, tracer logic.EvalTracer) (*ledgercore.ValidatedBlock, error) {
+func (s Simulator) evaluate(hdr bookkeeping.BlockHeader, group []transactions.SignedTxnWithAD, tracer logic.EvalTracer) (*ledgercore.ValidatedBlock, error) {
 	// s.ledger has 'StartEvaluator' because *data.Ledger is embedded in the simulatorLedger
 	// and data.Ledger embeds *ledger.Ledger
-	eval, err := s.ledger.StartEvaluator(hdr, len(stxns), 0, tracer)
+	eval, err := s.ledger.StartEvaluator(hdr, len(group), 0, tracer)
 	if err != nil {
 		return nil, err
 	}
 
-	group := transactions.WrapSignedTxnsWithAD(stxns)
-
 	err = eval.TransactionGroup(group)
 	if err != nil {
 		return nil, EvalFailureError{SimulatorError{err}}
@@ -205,14 +204,41 @@
 	return vb, nil
 }
 
-func (s Simulator) simulateWithTracer(txgroup []transactions.SignedTxn, tracer logic.EvalTracer, overrides ResultEvalOverrides) (*ledgercore.ValidatedBlock, error) {
+func (s Simulator) simulateWithTracer(txgroup []transactions.SignedTxnWithAD, tracer logic.EvalTracer, overrides ResultEvalOverrides) (*ledgercore.ValidatedBlock, error) {
 	prevBlockHdr, err := s.ledger.BlockHdr(s.ledger.start)
 	if err != nil {
 		return nil, err
 	}
 	nextBlock := bookkeeping.MakeBlock(prevBlockHdr)
 	hdr := nextBlock.BlockHeader
 
+	fixAuthAddr := true
+	if fixAuthAddr {
+		// Map of rekeys for senders in the group
+		staticRekeys := make(map[basics.Address]basics.Address)
+
+		for i := range txgroup {
+			sender := txgroup[i].SignedTxn.Txn.Sender
+
+			if authAddr, ok := staticRekeys[sender]; ok {
+				// If there is a static rekey for the sender set the auth addr to that address
+				txgroup[i].SignedTxn.AuthAddr = authAddr
+			} else {
+				// Otherwise lookup the sender's account and set the txn auth addr to the account's auth addr
+				data, _, _, err := s.ledger.LookupAccount(s.ledger.start, sender)
+				if err != nil {
+					return nil, err
+				}
+				txgroup[i].SignedTxn.AuthAddr = data.AuthAddr
+			}
+
+			if txgroup[i].SignedTxn.Txn.RekeyTo != (basics.Address{}) {
+				staticRekeys[sender] = txgroup[i].SignedTxn.Txn.RekeyTo
+			}
+		}
+
+	}
+
 	// check that the transaction is well-formed and mark whether signatures are missing
 	err = s.check(hdr, txgroup, tracer, overrides)
 	if err != nil {
@@ -243,11 +269,6 @@
 		s.ledger.start = s.ledger.Ledger.Latest()
 	}
 
-	simulatorTracer, err := makeEvalTracer(s.ledger.start, simulateRequest, s.developerAPI)
-	if err != nil {
-		return Result{}, err
-	}
-
 	if len(simulateRequest.TxnGroups) != 1 {
 		return Result{}, InvalidRequestError{
 			SimulatorError{
@@ -256,7 +277,14 @@
 		}
 	}
 
-	block, err := s.simulateWithTracer(simulateRequest.TxnGroups[0], simulatorTracer, simulatorTracer.result.EvalOverrides)
+	group := transactions.WrapSignedTxnsWithAD(simulateRequest.TxnGroups[0])
+
+	simulatorTracer, err := makeEvalTracer(s.ledger.start, group, simulateRequest, s.developerAPI)
+	if err != nil {
+		return Result{}, err
+	}
+
+	block, err := s.simulateWithTracer(group, simulatorTracer, simulatorTracer.result.EvalOverrides)
 	if err != nil {
 		var verifyError *verify.TxGroupError
 		switch {

ledger/simulation/simulator_test.go

@@ -142,7 +142,7 @@ int 1`,
 
 	mockTracer := &mocktracer.Tracer{}
 	s.ledger.start = s.ledger.Ledger.Latest() // Set starting round for simulation
-	block, err := s.simulateWithTracer(txgroup, mockTracer, ResultEvalOverrides{})
+	block, err := s.simulateWithTracer(transactions.WrapSignedTxnsWithAD(txgroup), mockTracer, ResultEvalOverrides{})
 	require.NoError(t, err)
 
 	evalBlock := block.Block()

ledger/simulation/tracer.go

@@ -98,14 +98,16 @@ type evalTracer struct {
 	// scratchSlots are the scratch slots changed on current opcode (currently either `store` or `stores`).
 	// NOTE: this field scratchSlots is used only for scratch change exposure.
 	scratchSlots []uint64
+
+	groups [][]transactions.SignedTxnWithAD
 }
 
-func makeEvalTracer(lastRound basics.Round, request Request, developerAPI bool) (*evalTracer, error) {
+func makeEvalTracer(lastRound basics.Round, group []transactions.SignedTxnWithAD, request Request, developerAPI bool) (*evalTracer, error) {
 	result, err := makeSimulationResult(lastRound, request, developerAPI)
 	if err != nil {
 		return nil, err
 	}
-	return &evalTracer{result: &result}, nil
+	return &evalTracer{result: &result, groups: [][]transactions.SignedTxnWithAD{group}}, nil
 }
 
 // handleError is responsible for setting the failedAt field properly.
@@ -512,4 +514,42 @@ func (tracer *evalTracer) AfterProgram(cx *logic.EvalContext, pass bool, evalErr
 	} else {
 		tracer.handleError(evalError)
 	}
+
+	fixAuthAddrs := true
+
+	// Since an app could rekey multiple accounts, we need to go over the
+	// rest of the txngroup and make sure all the auth addrs are correct
+	if fixAuthAddrs {
+		knownAuthAddrs := make(map[basics.Address]basics.Address)
+		// iterate over all txns in the group after this one
+		for i := groupIndex + 1; i < len(cx.TxnGroup); i++ {
+			stxn := &tracer.groups[0][i]
+			sender := stxn.Txn.Sender
+
+			// Check if we already know the auth addr
+			if authAddr, ok := knownAuthAddrs[sender]; ok {
+				stxn.AuthAddr = authAddr
+			} else {
+				// Get the auth addr from the ledger
+				data, err := cx.Ledger.AccountData(sender)
+				if err != nil {
+					panic(err)
+				}
+
+				// set the txn auth addr
+				stxn.AuthAddr = data.AuthAddr
+				knownAuthAddrs[sender] = data.AuthAddr
+			}
+
+			// If this is an appl, we can break since we know AfterProgram will be called afterwards
+			if stxn.Txn.Type == protocol.ApplicationCallTx {
+				break
+			}
+
+			// If this is a rekey, save the auth addr for the sender
+			if stxn.Txn.RekeyTo != (basics.Address{}) {
+				knownAuthAddrs[sender] = stxn.Txn.RekeyTo
+			}
+		}
+	}
 }