remove a few copying subroutine

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

@@ -929,10 +929,10 @@ func (v2 *Handlers) RawTransaction(ctx echo.Context) error {
 
 // PreEncodedSimulateTxnResult mirrors model.SimulateTransactionResult
 type PreEncodedSimulateTxnResult struct {
-	Txn                    PreEncodedTxInfo                      `codec:"txn-result"`
-	AppBudgetConsumed      *uint64                               `codec:"app-budget-consumed,omitempty"`
-	LogicSigBudgetConsumed *uint64                               `codec:"logic-sig-budget-consumed,omitempty"`
-	TransactionTrace       *model.SimulationTransactionExecTrace `codec:"exec-trace,omitempty"`
+	Txn                    PreEncodedTxInfo             `codec:"txn-result"`
+	AppBudgetConsumed      *uint64                      `codec:"app-budget-consumed,omitempty"`
+	LogicSigBudgetConsumed *uint64                      `codec:"logic-sig-budget-consumed,omitempty"`
+	TransactionTrace       *simulation.TransactionTrace `codec:"exec-trace,omitempty"`
 }
 
 // PreEncodedSimulateTxnGroupResult mirrors model.SimulateTransactionGroupResult

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

@@ -117,6 +117,8 @@ func makeTagGraph(rootType reflect.Type, seen map[reflect.Type]*tagNode) *tagNod
 	case reflect.Ptr:
 		// Directly embed value type graph
 		node = makeTagGraph(rootType.Elem(), seen)
+		// the node in seen for rootType should be refreshed from calculation.
+		seen[rootType] = node
 	case reflect.Struct:
 		for i := 0; i < rootType.NumField(); i++ {
 			field := rootType.Field(i)
@@ -141,8 +143,8 @@ func makeTagGraph(rootType reflect.Type, seen map[reflect.Type]*tagNode) *tagNod
 				} else {
 					tagValue = field.Name
 				}
-				if len(tagValue) != 0 {
-					// ignore any empty tags
+				if len(tagValue) != 0 && tagValue != "-" {
+					// ignore any empty tags and skipping fields
 					node.addChild(tagValue, subgraph)
 				}
 			}

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

@@ -360,60 +360,12 @@ func ConvertInnerTxn(txn *transactions.SignedTxnWithAD) PreEncodedTxInfo {
 	return response
 }
 
-func convertProgramTrace(programTrace []simulation.OpcodeTraceUnit) *[]model.SimulationOpcodeTraceUnit {
-	if len(programTrace) == 0 {
-		return nil
-	}
-
-	modelProgramTrace := make([]model.SimulationOpcodeTraceUnit, len(programTrace))
-	for i := range programTrace {
-		var spawnedInnersPtr *[]uint64
-		if len(programTrace[i].SpawnedInners) > 0 {
-			spawnedInners := make([]uint64, len(programTrace[i].SpawnedInners))
-			for j, innerIndex := range programTrace[i].SpawnedInners {
-				spawnedInners[j] = uint64(innerIndex)
-			}
-			spawnedInnersPtr = &spawnedInners
-		}
-		modelProgramTrace[i] = model.SimulationOpcodeTraceUnit{
-			Pc:            programTrace[i].PC,
-			SpawnedInners: spawnedInnersPtr,
-		}
-	}
-
-	return &modelProgramTrace
-}
-
-func convertTxnTrace(txnTrace *simulation.TransactionTrace) *model.SimulationTransactionExecTrace {
-	if txnTrace == nil {
-		return nil
-	}
-
-	var execTraceModel model.SimulationTransactionExecTrace
-
-	execTraceModel.LogicSigTrace = convertProgramTrace(txnTrace.LogicSigTrace)
-	execTraceModel.ClearStateProgramTrace = convertProgramTrace(txnTrace.ClearStateProgramTrace)
-	execTraceModel.ApprovalProgramTrace = convertProgramTrace(txnTrace.ApprovalProgramTrace)
-
-	if len(txnTrace.InnerTraces) > 0 {
-		innerTrace := make([]model.SimulationTransactionExecTrace, len(txnTrace.InnerTraces))
-
-		for i := range txnTrace.InnerTraces {
-			innerTrace[i] = *convertTxnTrace(&txnTrace.InnerTraces[i])
-		}
-
-		execTraceModel.InnerTrace = &innerTrace
-	}
-
-	return &execTraceModel
-}
-
 func convertTxnResult(txnResult simulation.TxnResult) PreEncodedSimulateTxnResult {
 	return PreEncodedSimulateTxnResult{
 		Txn:                    ConvertInnerTxn(&txnResult.Txn),
 		AppBudgetConsumed:      numOrNil(txnResult.AppBudgetConsumed),
 		LogicSigBudgetConsumed: numOrNil(txnResult.LogicSigBudgetConsumed),
-		TransactionTrace:       convertTxnTrace(txnResult.Trace),
+		TransactionTrace:       txnResult.Trace,
 	}
 }
 

ledger/simulation/trace.go

@@ -177,36 +177,36 @@ func makeSimulationResult(lastRound basics.Round, request Request, developerAPI
 // OpcodeTraceUnit contains the trace effects of a single opcode evaluation
 type OpcodeTraceUnit struct {
 	// The PC of the opcode being evaluated
-	PC uint64
+	PC uint64 `codec:"pc"`
 
 	// SpawnedInners contains the indexes of traces for inner transactions spawned by this opcode,
 	// if any. These indexes refer to the InnerTraces array of the TransactionTrace object containing
 	// this OpcodeTraceUnit.
-	SpawnedInners []int
+	SpawnedInners []int `codec:"spawned-inners,omitempty"`
 
 	// Below are fields exposed with stack-change option activated
 	// Opcode line (source?)
-	TEALSource string
+	TEALSource string `codec:"-"`
 
 	// deleted elements from stack, help backwards debugging
-	Deleted []basics.TealValue
+	Deleted []basics.TealValue `codec:"-"`
 
 	// what has been added to stack
-	Added []basics.TealValue
+	Added []basics.TealValue `codec:"-"`
 }
 
 // TransactionTrace contains the trace effects of a single transaction evaluation (including its inners)
 type TransactionTrace struct {
 	// ApprovalProgramTrace stands for a slice of OpcodeTraceUnit over application call on approval program
-	ApprovalProgramTrace []OpcodeTraceUnit
+	ApprovalProgramTrace []OpcodeTraceUnit `codec:"approval-program-trace,omitempty"`
 	// ClearStateProgramTrace stands for a slice of OpcodeTraceUnit over application call on clear-state program
-	ClearStateProgramTrace []OpcodeTraceUnit
+	ClearStateProgramTrace []OpcodeTraceUnit `codec:"clear-state-program-trace,omitempty"`
 	// LogicSigTrace contains the trace for a logicsig evaluation, if the transaction is approved by a logicsig.
-	LogicSigTrace []OpcodeTraceUnit
+	LogicSigTrace []OpcodeTraceUnit `codec:"logic-sig-trace,omitempty"`
 	// programTraceRef points to one of ApprovalProgramTrace, ClearStateProgramTrace, and LogicSigTrace during simulation.
-	programTraceRef *[]OpcodeTraceUnit
+	programTraceRef *[]OpcodeTraceUnit `codec:"-"`
 	// InnerTraces contains the traces for inner transactions, if this transaction spawned any. This
 	// object only contains traces for inners that are immediate children of this transaction.
 	// Grandchild traces will be present inside the TransactionTrace of their parent.
-	InnerTraces []TransactionTrace
+	InnerTraces []TransactionTrace `codec:"inner-trace,omitempty"`
 }