Opcode: log

config/consensus.go

@@ -422,6 +422,10 @@ var MaxEvalDeltaAccounts int
 // in a StateDelta, used for decoding purposes.
 var MaxStateDeltaKeys int
 
+// MaxLogCalls is the highest allowable log messages that may appear in
+// any version, used for decoding purposes. Never decrease this value.
+const MaxLogCalls = 32
+
 // MaxLogicSigMaxSize is the largest logical signature appear in any of the supported
 // protocols, used for decoding purposes.
 var MaxLogicSigMaxSize int

daemon/algod/api/algod.oas2.json

@@ -1744,6 +1744,12 @@
           "items": {
             "$ref": "#/definitions/AccountStateDelta"
           }
+        },
+        "logs": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/LogItem"
+          }
         }
       }
     },
@@ -1910,6 +1916,24 @@
           "format": "int64"
         }
       }
+    },
+    "LogItem": {
+      "description": "Application Log",
+      "type": "object",
+      "required": [
+        "id",
+        "value"
+      ],
+      "properties": {
+        "id": {
+          "description": "unique application identifier",
+          "type": "integer"
+        },
+        "value": {
+          "description": " base64 encoded log message",
+          "type": "string"
+        }
+      }
     }
   },
   "parameters": {
@@ -2307,6 +2331,13 @@
             "description": "\\[gd\\] Global state key/value changes for the application being executed by this transaction.",
             "$ref": "#/definitions/StateDelta"
           },
+          "logs": {
+            "description": "\\[lg\\] Logs for the application being executed by this transaction.",
+            "type": "array",
+            "items": {
+              "$ref": "#/definitions/LogItem"
+            }
+          },
           "txn": {
             "description": "The raw signed transaction.",
             "type": "object",

daemon/algod/api/algod.oas3.yml

@@ -493,6 +493,13 @@
                   },
                   "type": "array"
                 },
+                "logs": {
+                  "description": "\\[lg\\] Logs for the application being executed by this transaction.",
+                  "items": {
+                    "$ref": "#/components/schemas/LogItem"
+                  },
+                  "type": "array"
+                },
                 "pool-error": {
                   "description": "Indicates that the transaction was kicked out of this node's transaction pool (and specifies why that happened).  An empty string indicates the transaction wasn't kicked out of this node's txpool due to an error.\n",
                   "type": "string"
@@ -1267,6 +1274,12 @@
               "$ref": "#/components/schemas/DryrunState"
             },
             "type": "array"
+          },
+          "logs": {
+            "items": {
+              "$ref": "#/components/schemas/LogItem"
+            },
+            "type": "array"
           }
         },
         "required": [
@@ -1327,6 +1340,24 @@
         ],
         "type": "object"
       },
+      "LogItem": {
+        "description": "Application Log",
+        "properties": {
+          "id": {
+            "description": "unique application identifier",
+            "type": "integer"
+          },
+          "value": {
+            "description": " base64 encoded log message",
+            "type": "string"
+          }
+        },
+        "required": [
+          "id",
+          "value"
+        ],
+        "type": "object"
+      },
       "StateDelta": {
         "description": "Application state delta.",
         "items": {
@@ -3340,6 +3371,13 @@
                       },
                       "type": "array"
                     },
+                    "logs": {
+                      "description": "\\[lg\\] Logs for the application being executed by this transaction.",
+                      "items": {
+                        "$ref": "#/components/schemas/LogItem"
+                      },
+                      "type": "array"
+                    },
                     "pool-error": {
                       "description": "Indicates that the transaction was kicked out of this node's transaction pool (and specifies why that happened).  An empty string indicates the transaction wasn't kicked out of this node's txpool due to an error.\n",
                       "type": "string"
@@ -3404,6 +3442,13 @@
                       },
                       "type": "array"
                     },
+                    "logs": {
+                      "description": "\\[lg\\] Logs for the application being executed by this transaction.",
+                      "items": {
+                        "$ref": "#/components/schemas/LogItem"
+                      },
+                      "type": "array"
+                    },
                     "pool-error": {
                       "description": "Indicates that the transaction was kicked out of this node's transaction pool (and specifies why that happened).  An empty string indicates the transaction wasn't kicked out of this node's txpool due to an error.\n",
                       "type": "string"

daemon/algod/api/client/restClient.go

@@ -434,8 +434,8 @@ func (client RestClient) PendingTransactionInformation(transactionID string) (re
 	return
 }
 
-// PendingTransactionInformationV2 gets information about a recently issued
-// transaction. See PendingTransactionInformation for more details.
+// PendingTransactionInformationV2 gets information about a recently issued transaction.
+// See PendingTransactionInformation for more details.
 func (client RestClient) PendingTransactionInformationV2(transactionID string) (response generatedV2.PendingTransactionResponse, err error) {
 	transactionID = stripTransaction(transactionID)
 	err = client.get(&response, fmt.Sprintf("/v2/transactions/pending/%s", transactionID), nil)

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

@@ -521,6 +521,13 @@ func doDryrunRequest(dr *DryrunRequest, response *generated.DryrunResponse) {
 					}
 					result.LocalDeltas = &localDeltas
 				}
+
+				var err3 error
+				result.Logs, err3 = DeltaLogToLog(delta.Logs, appIdx)
+				if err3 != nil {
+					messages = append(messages, err3.Error())
+				}
+
 				if pass {
 					messages = append(messages, "PASS")
 				} else {
@@ -563,6 +570,22 @@ func StateDeltaToStateDelta(sd basics.StateDelta) *generated.StateDelta {
 	return &gsd
 }
 
+// DeltaLogToLog EvalDelta.Logs to generated.LogItem
+func DeltaLogToLog(logs []basics.LogItem, appIdx basics.AppIndex) (*[]generated.LogItem, error) {
+	if len(logs) == 0 {
+		return nil, nil
+	}
+	encodedLogs := make([]generated.LogItem, 0, len(logs))
+	for _, log := range logs {
+		if log.ID != 0 {
+			return nil, fmt.Errorf("logging for a foreign app is not supported")
+		}
+		msg := base64.StdEncoding.EncodeToString([]byte(log.Message))
+		encodedLogs = append(encodedLogs, generated.LogItem{Id: uint64(appIdx), Value: msg})
+	}
+	return &encodedLogs, nil
+}
+
 // MergeAppParams merges values, existing in "base" take priority over new in "update"
 func MergeAppParams(base *basics.AppParams, update *basics.AppParams) {
 	if len(base.ApprovalProgram) == 0 && len(update.ApprovalProgram) > 0 {

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

@@ -346,7 +346,7 @@ func init() {
 
 	// legder requires proto string and proto params set
 	var proto config.ConsensusParams
-	proto.LogicSigVersion = 4
+	proto.LogicSigVersion = 5
 	proto.LogicSigMaxCost = 20000
 	proto.MaxAppProgramCost = 700
 	proto.MaxAppKeyLen = 64
@@ -1091,3 +1091,113 @@ int 1`)
 		logResponse(t, &response)
 	}
 }
+
+func TestDryrunLogs(t *testing.T) {
+	t.Parallel()
+
+	ops, err := logic.AssembleString(`
+#pragma version 5
+byte "A"
+loop:
+int 0
+dup2
+getbyte
+int 1
++
+dup
+int 97 //ascii code of last char
+<=
+bz end
+setbyte
+dup
+log
+b loop
+end:
+int 1
+return
+`)
+
+	require.NoError(t, err)
+	approval := ops.Program
+	ops, err = logic.AssembleString("int 1")
+	clst := ops.Program
+	ops, err = logic.AssembleString("#pragma version 5 \nint 1")
+	approv := ops.Program
+	require.NoError(t, err)
+
+	var appIdx basics.AppIndex = 1
+	creator := randomAddress()
+	sender := randomAddress()
+	dr := DryrunRequest{
+		Txns: []transactions.SignedTxn{
+			{
+				Txn: transactions.Transaction{
+					Header: transactions.Header{Sender: sender},
+					Type:   protocol.ApplicationCallTx,
+					ApplicationCallTxnFields: transactions.ApplicationCallTxnFields{
+						ApplicationID: appIdx,
+						OnCompletion:  transactions.OptInOC,
+					},
+				},
+			},
+			{
+				Txn: transactions.Transaction{
+					Header: transactions.Header{Sender: sender},
+					Type:   protocol.ApplicationCallTx,
+					ApplicationCallTxnFields: transactions.ApplicationCallTxnFields{
+						ApplicationID: appIdx + 1,
+						OnCompletion:  transactions.OptInOC,
+					},
+				},
+			},
+		},
+		Apps: []generated.Application{
+			{
+				Id: uint64(appIdx),
+				Params: generated.ApplicationParams{
+					Creator:           creator.String(),
+					ApprovalProgram:   approval,
+					ClearStateProgram: clst,
+					LocalStateSchema:  &generated.ApplicationStateSchema{NumByteSlice: 1},
+				},
+			},
+			{
+				Id: uint64(appIdx + 1),
+				Params: generated.ApplicationParams{
+					Creator:           creator.String(),
+					ApprovalProgram:   approv,
+					ClearStateProgram: clst,
+					LocalStateSchema:  &generated.ApplicationStateSchema{NumByteSlice: 1},
+				},
+			},
+		},
+		Accounts: []generated.Account{
+			{
+				Address: sender.String(),
+				Status:  "Online",
+				Amount:  10000000,
+			},
+		},
+	}
+	dr.ProtocolVersion = string(dryrunProtoVersion)
+
+	var response generated.DryrunResponse
+	doDryrunRequest(&dr, &response)
+	require.NoError(t, err)
+	checkAppCallPass(t, &response)
+	if t.Failed() {
+		logResponse(t, &response)
+	}
+	logs := *response.Txns[0].Logs
+	assert.Equal(t, 32, len(logs))
+	for i, m := range logs {
+		assert.Equal(t, base64.StdEncoding.EncodeToString([]byte(string(rune('B'+i)))), m.Value)
+	}
+	encoded := string(protocol.EncodeJSON(response.Txns[0]))
+	assert.Contains(t, encoded, "logs")
+
+	assert.Empty(t, response.Txns[1].Logs)
+	encoded = string(protocol.EncodeJSON(response.Txns[1]))
+	assert.NotContains(t, encoded, "logs")
+
+}