add access to resources created in the current group

cmd/goal/clerk.go

@@ -1095,7 +1095,7 @@ var dryrunCmd = &cobra.Command{
 			if uint64(txn.Lsig.Len()) > params.LogicSigMaxSize {
 				reportErrorf("program size too large: %d > %d", len(txn.Lsig.Logic), params.LogicSigMaxSize)
 			}
-			ep := &logic.EvalParams{Proto: &params, TxnGroup: txgroup}
+			ep := logic.NewEvalParams(txgroup, &params, nil)
 			err := logic.CheckSignature(i, ep)
 			if err != nil {
 				reportErrorf("program failed Check: %s", err)

cmd/tealdbg/debugger_test.go

@@ -100,11 +100,8 @@ func TestDebuggerSimple(t *testing.T) {
 	da := makeTestDbgAdapter(t)
 	debugger.AddAdapter(da)
 
-	ep := &logic.EvalParams{
-		Proto:    &proto,
-		Debugger: debugger,
-		TxnGroup: make([]transactions.SignedTxnWithAD, 1),
-	}
+	ep := logic.NewEvalParams(make([]transactions.SignedTxnWithAD, 1), &proto, nil)
+	ep.Debugger = debugger
 
 	source := `int 0
 int 1

cmd/tealdbg/local.go

@@ -205,17 +205,16 @@ const (
 
 // evaluation is a description of a single debugger run
 type evaluation struct {
-	program         []byte
-	source          string
-	offsetToLine    map[int]int
-	name            string
-	groupIndex      uint64
-	pastSideEffects []logic.EvalSideEffects
-	mode            modeType
-	aidx            basics.AppIndex
-	ba              apply.Balances
-	result          evalResult
-	states          AppState
+	program      []byte
+	source       string
+	offsetToLine map[int]int
+	name         string
+	groupIndex   uint64
+	mode         modeType
+	aidx         basics.AppIndex
+	ba           apply.Balances
+	result       evalResult
+	states       AppState
 }
 
 func (e *evaluation) eval(gi int, ep *logic.EvalParams) (pass bool, err error) {
@@ -341,17 +340,6 @@ func (r *LocalRunner) Setup(dp *DebugParams) (err error) {
 		dp.LatestTimestamp = int64(ddr.LatestTimestamp)
 	}
 
-	if dp.PastSideEffects == nil {
-		dp.PastSideEffects = logic.MakePastSideEffects(len(r.txnGroup))
-	} else if len(dp.PastSideEffects) != len(r.txnGroup) {
-		err = fmt.Errorf(
-			"invalid past side effects slice with length %d should match group length of %d txns",
-			len(dp.PastSideEffects),
-			len(r.txnGroup),
-		)
-		return
-	}
-
 	// if program(s) specified then run from it
 	if len(dp.ProgramBlobs) > 0 {
 		if len(r.txnGroup) == 1 && dp.GroupIndex != 0 {
@@ -389,7 +377,6 @@ func (r *LocalRunner) Setup(dp *DebugParams) (err error) {
 				}
 			}
 			r.runs[i].groupIndex = uint64(dp.GroupIndex)
-			r.runs[i].pastSideEffects = dp.PastSideEffects
 			r.runs[i].name = dp.ProgramNames[i]
 
 			var mode modeType
@@ -452,13 +439,12 @@ func (r *LocalRunner) Setup(dp *DebugParams) (err error) {
 						return
 					}
 					run := evaluation{
-						program:         stxn.Txn.ApprovalProgram,
-						groupIndex:      uint64(gi),
-						pastSideEffects: dp.PastSideEffects,
-						mode:            modeStateful,
-						aidx:            appIdx,
-						ba:              b,
-						states:          states,
+						program:    stxn.Txn.ApprovalProgram,
+						groupIndex: uint64(gi),
+						mode:       modeStateful,
+						aidx:       appIdx,
+						ba:         b,
+						states:     states,
 					}
 					r.runs = append(r.runs, run)
 				}
@@ -488,13 +474,12 @@ func (r *LocalRunner) Setup(dp *DebugParams) (err error) {
 								return
 							}
 							run := evaluation{
-								program:         program,
-								groupIndex:      uint64(gi),
-								pastSideEffects: dp.PastSideEffects,
-								mode:            modeStateful,
-								aidx:            appIdx,
-								ba:              b,
-								states:          states,
+								program:    program,
+								groupIndex: uint64(gi),
+								mode:       modeStateful,
+								aidx:       appIdx,
+								ba:         b,
+								states:     states,
 							}
 							r.runs = append(r.runs, run)
 							found = true
@@ -526,30 +511,9 @@ func (r *LocalRunner) RunAll() error {
 	txngroup := transactions.WrapSignedTxnsWithAD(r.txnGroup)
 	failed := 0
 	start := time.Now()
-	pooledApplicationBudget := uint64(0)
-	credit, _ := transactions.FeeCredit(txngroup, r.proto.MinTxnFee)
-	// ignore error since fees are not important for debugging in most cases
-
-	var pastSideEffects []logic.EvalSideEffects
-	for _, run := range r.runs {
-		if run.mode == modeStateful {
-			if r.proto.EnableAppCostPooling {
-				pooledApplicationBudget += uint64(r.proto.MaxAppProgramCost)
-			} else {
-				pooledApplicationBudget = uint64(r.proto.MaxAppProgramCost)
-			}
-			pastSideEffects = run.pastSideEffects
-		}
-	}
-	ep := &logic.EvalParams{
-		Proto:                   &r.proto,
-		Debugger:                r.debugger,
-		TxnGroup:                txngroup,
-		PastSideEffects:         pastSideEffects,
-		Specials:                &transactions.SpecialAddresses{},
-		FeeCredit:               &credit,
-		PooledApplicationBudget: &pooledApplicationBudget,
-	}
+
+	ep := logic.NewEvalParams(txngroup, &r.proto, &transactions.SpecialAddresses{})
+	ep.Debugger = r.debugger
 
 	var last error
 	for i := range r.runs {
@@ -576,27 +540,8 @@ func (r *LocalRunner) Run() (bool, error) {
 	}
 
 	txngroup := transactions.WrapSignedTxnsWithAD(r.txnGroup)
-	pooledApplicationBudget := uint64(0)
-	credit, _ := transactions.FeeCredit(txngroup, r.proto.MinTxnFee)
-	// ignore error since fees are not important for debugging in most cases
-
-	for _, run := range r.runs {
-		if run.mode == modeStateful {
-			if r.proto.EnableAppCostPooling {
-				pooledApplicationBudget += uint64(r.proto.MaxAppProgramCost)
-			} else {
-				pooledApplicationBudget = uint64(r.proto.MaxAppProgramCost)
-			}
-		}
-	}
-	ep := &logic.EvalParams{
-		Proto:                   &r.proto,
-		TxnGroup:                txngroup,
-		PastSideEffects:         r.runs[0].pastSideEffects, // Looks strange, but all runs have same pastSideEffects
-		Specials:                &transactions.SpecialAddresses{},
-		FeeCredit:               &credit,
-		PooledApplicationBudget: &pooledApplicationBudget,
-	}
+
+	ep := logic.NewEvalParams(txngroup, &r.proto, &transactions.SpecialAddresses{})
 
 	run := r.runs[0]
 	// Workaround for Go's nil/empty interfaces nil check after nil assignment, i.e.

cmd/tealdbg/localLedger_test.go

@@ -90,6 +90,7 @@ int 2
 	// make transaction group: app call + sample payment
 	txn := transactions.SignedTxn{
 		Txn: transactions.Transaction{
+			Type: protocol.ApplicationCallTx,
 			Header: transactions.Header{
 				Sender: addr,
 				Fee:    basics.MicroAlgos{Raw: 100},
@@ -109,11 +110,7 @@ int 2
 	a.NoError(err)
 
 	proto := config.Consensus[protocol.ConsensusCurrentVersion]
-	ep := &logic.EvalParams{
-		Proto:           &proto,
-		TxnGroup:        []transactions.SignedTxnWithAD{transactions.SignedTxnWithAD{SignedTxn: txn}},
-		PastSideEffects: logic.MakePastSideEffects(1),
-	}
+	ep := logic.NewEvalParams([]transactions.SignedTxnWithAD{{SignedTxn: txn}}, &proto, &transactions.SpecialAddresses{})
 	pass, delta, err := ba.StatefulEval(0, ep, appIdx, program)
 	a.NoError(err)
 	a.True(pass)

cmd/tealdbg/local_test.go

@@ -316,6 +316,7 @@ func TestDebugEnvironment(t *testing.T) {
 	// make transaction group: app call + sample payment
 	txn := transactions.SignedTxn{
 		Txn: transactions.Transaction{
+			Type: protocol.ApplicationCallTx,
 			Header: transactions.Header{
 				Sender: sender,
 				Fee:    basics.MicroAlgos{Raw: 1000},
@@ -523,7 +524,7 @@ func TestDebugFromPrograms(t *testing.T) {
 	partitiontest.PartitionTest(t)
 	a := require.New(t)
 
-	txnBlob := []byte("[" + strings.Join([]string{string(txnSample), txnSample}, ",") + "]")
+	txnBlob := []byte("[" + strings.Join([]string{txnSample, txnSample}, ",") + "]")
 
 	l := LocalRunner{}
 	dp := DebugParams{
@@ -602,7 +603,7 @@ func TestRunMode(t *testing.T) {
 	partitiontest.PartitionTest(t)
 	a := require.New(t)
 
-	txnBlob := []byte("[" + strings.Join([]string{string(txnSample), txnSample}, ",") + "]")
+	txnBlob := []byte("[" + strings.Join([]string{txnSample, txnSample}, ",") + "]")
 	l := LocalRunner{}
 
 	// check run mode auto on stateful code

cmd/tealdbg/server.go

@@ -25,7 +25,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/algorand/go-algorand/data/transactions/logic"
 	"github.com/algorand/websocket"
 	"github.com/gorilla/mux"
 )
@@ -73,7 +72,6 @@ type DebugParams struct {
 	Proto            string
 	TxnBlob          []byte
 	GroupIndex       int
-	PastSideEffects  []logic.EvalSideEffects
 	BalanceBlob      []byte
 	DdrBlob          []byte
 	IndexerURL       string

cmd/tealdbg/server_test.go

@@ -131,7 +131,7 @@ func TestServerRemote(t *testing.T) {
 
 func TestServerLocal(t *testing.T) {
 	partitiontest.PartitionTest(t)
-	txnBlob := []byte("[" + strings.Join([]string{string(txnSample), txnSample}, ",") + "]")
+	txnBlob := []byte("[" + strings.Join([]string{txnSample, txnSample}, ",") + "]")
 	dp := DebugParams{
 		ProgramNames: []string{"test"},
 		ProgramBlobs: [][]byte{{2, 0x20, 1, 1, 0x22}}, // version, intcb, int 1

daemon/algod/api/server/v2/dryrun.go

@@ -366,6 +366,10 @@ func doDryrunRequest(dr *DryrunRequest, response *generated.DryrunResponse) {
 		return
 	}
 	proto := config.Consensus[protocol.ConsensusVersion(dr.ProtocolVersion)]
+	txgroup := transactions.WrapSignedTxnsWithAD(dr.Txns)
+	specials := transactions.SpecialAddresses{}
+	ep := logic.NewEvalParams(txgroup, &proto, &specials)
+
 	origEnableAppCostPooling := proto.EnableAppCostPooling
 	// Enable EnableAppCostPooling so that dryrun
 	// 1) can determine cost 2) reports actual cost for large programs that fail
@@ -381,18 +385,10 @@ func doDryrunRequest(dr *DryrunRequest, response *generated.DryrunResponse) {
 			allowedBudget += uint64(proto.MaxAppProgramCost)
 		}
 	}
+	ep.PooledApplicationBudget = &pooledAppBudget
 
 	response.Txns = make([]generated.DryrunTxnResult, len(dr.Txns))
-	txgroup := transactions.WrapSignedTxnsWithAD(dr.Txns)
-	pse := logic.MakePastSideEffects(len(dr.Txns))
 	for ti, stxn := range dr.Txns {
-		ep := &logic.EvalParams{
-			Proto:                   &proto,
-			TxnGroup:                txgroup,
-			PastSideEffects:         pse,
-			PooledApplicationBudget: &pooledAppBudget,
-			Specials:                &transactions.SpecialAddresses{},
-		}
 		var result generated.DryrunTxnResult
 		if len(stxn.Lsig.Logic) > 0 {
 			var debug dryrunDebugReceiver

data/transactions/logic/blackbox_test.go

@@ -80,22 +80,14 @@ func TestNewAppEvalParams(t *testing.T) {
 	for i, param := range params {
 		for j, testCase := range cases {
 			t.Run(fmt.Sprintf("i=%d,j=%d", i, j), func(t *testing.T) {
-				ep := logic.NewAppEvalParams(testCase.group, &param, nil, 0)
-
-				// Ensure non app calls have a nil evaluator, and that non-nil
-				// evaluators point to the right transactions and values
-				if testCase.numAppCalls > 0 {
-					require.NotNil(t, ep)
-					require.NotNil(t, ep.PastSideEffects)
-					require.Equal(t, ep.TxnGroup, testCase.group)
-					require.Equal(t, *ep.Proto, param)
-					if reflect.DeepEqual(param, config.Consensus[protocol.ConsensusV29]) {
-						require.Nil(t, ep.PooledApplicationBudget)
-					} else if reflect.DeepEqual(param, config.Consensus[protocol.ConsensusFuture]) {
-						require.Equal(t, *ep.PooledApplicationBudget, uint64(param.MaxAppProgramCost*testCase.numAppCalls))
-					}
-				} else {
-					require.Nil(t, ep)
+				ep := logic.NewEvalParams(testCase.group, &param, nil)
+				require.NotNil(t, ep)
+				require.Equal(t, ep.TxnGroup, testCase.group)
+				require.Equal(t, *ep.Proto, param)
+				if reflect.DeepEqual(param, config.Consensus[protocol.ConsensusV29]) {
+					require.Nil(t, ep.PooledApplicationBudget)
+				} else if reflect.DeepEqual(param, config.Consensus[protocol.ConsensusFuture]) {
+					require.Equal(t, *ep.PooledApplicationBudget, uint64(param.MaxAppProgramCost*testCase.numAppCalls))
 				}
 			})
 		}

data/transactions/logic/debugger.go

@@ -105,6 +105,10 @@ func makeDebugState(cx *EvalContext) DebugState {
 
 	globals := make([]basics.TealValue, len(globalFieldSpecs))
 	for _, fs := range globalFieldSpecs {
+		// Don't try to grab app only fields when evaluating a signature
+		if (cx.runModeFlags&runModeSignature) != 0 && fs.mode == runModeApplication {
+			continue
+		}
 		sv, err := cx.globalFieldToValue(fs)
 		if err != nil {
 			sv = stackValue{Bytes: []byte(err.Error())}