Emulator Feature: Report gas used

convert/vm.go

@@ -35,10 +35,11 @@ func VMTransactionResultToEmulator(tp *fvm.TransactionProcedure) (*types.Transac
 	}
 
 	return &types.TransactionResult{
-		TransactionID: txID,
-		Error:         VMErrorToEmulator(tp.Err),
-		Logs:          tp.Logs,
-		Events:        sdkEvents,
+		TransactionID:   txID,
+		ComputationUsed: tp.ComputationUsed,
+		Error:           VMErrorToEmulator(tp.Err),
+		Logs:            tp.Logs,
+		Events:          sdkEvents,
 	}, nil
 }
 

convert/vm_test.go

@@ -0,0 +1,65 @@
+/*
+ * Flow Emulator
+ *
+ * Copyright 2019-2021 Dapper Labs, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package convert_test
+
+import (
+	"testing"
+
+	"github.com/onflow/flow-go-sdk/test"
+	"github.com/onflow/flow-go/fvm"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/onflow/flow-emulator/convert"
+	sdkConvert "github.com/onflow/flow-emulator/convert/sdk"
+	flowgo "github.com/onflow/flow-go/model/flow"
+)
+
+func TestVm(t *testing.T) {
+	t.Run("should be able to convert", func(t *testing.T) {
+		idGenerator := test.IdentifierGenerator()
+
+		eventGenerator := test.EventGenerator()
+		event1, err := sdkConvert.SDKEventToFlow(eventGenerator.New())
+		assert.NoError(t, err)
+
+		event2, err := sdkConvert.SDKEventToFlow(eventGenerator.New())
+		assert.NoError(t, err)
+
+		tp := &fvm.TransactionProcedure{
+			ID:              flowgo.Identifier(idGenerator.New()),
+			Logs:            []string{"TestLog1", "TestLog2"},
+			Events:          []flowgo.Event{event1, event2},
+			ComputationUsed: 5,
+			Err:             nil,
+		}
+
+		tr, err := convert.VMTransactionResultToEmulator(tp)
+		assert.NoError(t, err)
+
+		assert.Equal(t, tp.ID, flowgo.Identifier(tr.TransactionID))
+		assert.Equal(t, tp.Logs, tr.Logs)
+
+		flowEvents, err := sdkConvert.FlowEventsToSDK(tp.Events)
+		assert.NoError(t, err)
+		assert.Equal(t, flowEvents, tr.Events)
+
+		assert.Equal(t, tp.ComputationUsed, tr.ComputationUsed)
+		assert.Equal(t, tp.Err, tr.Error)
+	})
+}

server/backend/backend.go

@@ -583,10 +583,12 @@ func printTransactionResult(logger *logrus.Logger, result *types.TransactionResu
 	if result.Succeeded() {
 		logger.
 			WithField("txID", result.TransactionID.String()).
+			WithField("computationUsed", result.ComputationUsed).
 			Info("⭐  Transaction executed")
 	} else {
 		logger.
 			WithField("txID", result.TransactionID.String()).
+			WithField("computationUsed", result.ComputationUsed).
 			Warn("❗  Transaction reverted")
 	}
 

types/result.go

@@ -19,9 +19,9 @@
 package types
 
 import (
-	flowgo "github.com/onflow/flow-go/model/flow"
 	"github.com/onflow/cadence"
 	"github.com/onflow/flow-go-sdk"
+	flowgo "github.com/onflow/flow-go/model/flow"
 )
 
 type StorableTransactionResult struct {
@@ -33,10 +33,11 @@ type StorableTransactionResult struct {
 
 // A TransactionResult is the result of executing a transaction.
 type TransactionResult struct {
-	TransactionID flow.Identifier
-	Error         error
-	Logs          []string
-	Events        []flow.Event
+	TransactionID   flow.Identifier
+	ComputationUsed uint64
+	Error           error
+	Logs            []string
+	Events          []flow.Event
 }
 
 // Succeeded returns true if the transaction executed without errors.

types/result_test.go

@@ -0,0 +1,77 @@
+/*
+ * Flow Emulator
+ *
+ * Copyright 2019-2020 Dapper Labs, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package types_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/onflow/cadence"
+	"github.com/onflow/flow-go-sdk"
+	"github.com/onflow/flow-go-sdk/test"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/onflow/flow-emulator/types"
+)
+
+func TestResult(t *testing.T) {
+	t.Run("should return correct boolean", func(t *testing.T) {
+		idGenerator := test.IdentifierGenerator()
+
+		trSucceed := &types.TransactionResult{
+			TransactionID:   idGenerator.New(),
+			ComputationUsed: 20,
+			Error:           nil,
+			Logs:            []string{},
+			Events:          []flow.Event{},
+		}
+		assert.True(t, trSucceed.Succeeded())
+		assert.False(t, trSucceed.Reverted())
+
+		trReverted := &types.TransactionResult{
+			TransactionID:   idGenerator.New(),
+			ComputationUsed: 20,
+			Error:           errors.New("transaction execution error"),
+			Logs:            []string{},
+			Events:          []flow.Event{},
+		}
+		assert.True(t, trReverted.Reverted())
+		assert.False(t, trReverted.Succeeded())
+
+		srSucceed := &types.ScriptResult{
+			ScriptID: idGenerator.New(),
+			Value:    cadence.Value(cadence.NewInt(1)),
+			Error:    nil,
+			Logs:     []string{},
+			Events:   []flow.Event{},
+		}
+		assert.True(t, srSucceed.Succeeded())
+		assert.False(t, srSucceed.Reverted())
+
+		srReverted := &types.ScriptResult{
+			ScriptID: idGenerator.New(),
+			Value:    cadence.Value(cadence.NewInt(1)),
+			Error:    errors.New("transaction execution error"),
+			Logs:     []string{},
+			Events:   []flow.Event{},
+		}
+		assert.True(t, srReverted.Reverted())
+		assert.False(t, srReverted.Succeeded())
+	})
+}