Update scheduled transaction usage (#873)

* remove uneeded methods

* remove duplicated test

* update usage of blueprints

---------

Co-authored-by: Jordan Ribbink <[email protected]>

Author: devbugging

emulator/blockchain.go

@@ -52,12 +52,14 @@ import (
 	"github.com/onflow/flow-go/access/validator"
 	"github.com/onflow/flow-go/engine"
 	"github.com/onflow/flow-go/fvm"
+	"github.com/onflow/flow-go/fvm/blueprints"
 	fvmcrypto "github.com/onflow/flow-go/fvm/crypto"
 	"github.com/onflow/flow-go/fvm/environment"
 	fvmerrors "github.com/onflow/flow-go/fvm/errors"
 	"github.com/onflow/flow-go/fvm/meter"
 	reusableRuntime "github.com/onflow/flow-go/fvm/runtime"
 	"github.com/onflow/flow-go/fvm/storage/snapshot"
+	"github.com/onflow/flow-go/fvm/systemcontracts"
 	accessmodel "github.com/onflow/flow-go/model/access"
 	flowgo "github.com/onflow/flow-go/model/flow"
 	"github.com/onflow/flow-go/module/metrics"
@@ -1908,57 +1910,60 @@ func (b *Blockchain) executeSystemChunkTransaction() error {
 func (b *Blockchain) executeScheduledTransactions(blockContext fvm.Context) ([]*types.TransactionResult, error) {
 	var results []*types.TransactionResult
 
-	serviceAddress := b.GetChain().ServiceAddress()
-	parentID := b.pendingBlock.parentID
 	// disable checks for signatures and keys since we are executing a system transaction
 	ctx := fvm.NewContextFromParent(
 		blockContext,
 		fvm.WithAuthorizationChecksEnabled(false),
 		fvm.WithSequenceNumberCheckAndIncrementEnabled(false),
+		fvm.WithTransactionFeesEnabled(false),
 	)
 
 	// process scheduled transactions out-of-band (do not alter collections)
-	processTx := processScheduledTransaction(serviceAddress, parentID)
+	processTx, err := blueprints.ProcessCallbacksTransaction(b.GetChain())
+	if err != nil {
+		return nil, err
+	}
+
 	executionSnapshot, output, err := b.vm.Run(
 		ctx,
-		fvm.Transaction(&processTx, uint32(len(b.pendingBlock.Transactions()))),
+		fvm.Transaction(processTx, uint32(len(b.pendingBlock.Transactions()))),
 		b.pendingBlock.ledgerState,
 	)
 	if err != nil {
-		return results, err
+		return nil, err
 	}
 	// record events and state changes
 	b.pendingBlock.events = append(b.pendingBlock.events, output.Events...)
 	if err := b.pendingBlock.ledgerState.Merge(executionSnapshot); err != nil {
-		return results, err
+		return nil, err
 	}
 
-	// filter to only process PendingExecution events
-	sdkEvents, err := convert.FlowEventsToSDK(output.Events)
+	executeTxs, err := blueprints.ExecuteCallbacksTransactions(b.GetChain(), output.Events)
 	if err != nil {
-		return results, err
+		return nil, err
 	}
-	pendingExecutionEvents := filterPendingExecutionEvents(sdkEvents, serviceAddress)
-	executeTxs, scheduledIDs, err := executeScheduledTransactions(pendingExecutionEvents, serviceAddress, parentID)
+
+	env := systemcontracts.SystemContractsForChain(b.GetChain().ChainID()).AsTemplateEnv()
+	scheduledIDs, err := parseScheduledIDs(env, output.Events)
 	if err != nil {
-		return results, err
+		return nil, err
 	}
 
 	// execute scheduled transactions out-of-band
 	for idx, tx := range executeTxs {
 		execSnapshot, execOutput, err := b.vm.Run(
 			ctx,
-			fvm.Transaction(&tx, uint32(len(b.pendingBlock.Transactions()))),
+			fvm.Transaction(tx, uint32(len(b.pendingBlock.Transactions()))),
 			b.pendingBlock.ledgerState,
 		)
 		if err != nil {
-			return results, err
+			return nil, err
 		}
 
 		// Print scheduled transaction result (labeled), including app-level scheduled tx id
 		schedResult, err := convert.VMTransactionResultToEmulator(tx.ID(), execOutput)
 		if err != nil {
-			return results, err
+			return nil, err
 		}
 		appScheduledID := ""
 		if idx < len(scheduledIDs) {
@@ -1968,7 +1973,7 @@ func (b *Blockchain) executeScheduledTransactions(blockContext fvm.Context) ([]*
 
 		b.pendingBlock.events = append(b.pendingBlock.events, execOutput.Events...)
 		if err := b.pendingBlock.ledgerState.Merge(execSnapshot); err != nil {
-			return results, err
+			return nil, err
 		}
 	}
 

emulator/scheduled_transactions.go

@@ -23,157 +23,48 @@ import (
 	"fmt"
 
 	"github.com/onflow/cadence"
-	"github.com/onflow/cadence/common"
-	jsoncdc "github.com/onflow/cadence/encoding/json"
+	"github.com/onflow/cadence/encoding/ccf"
 	"github.com/onflow/flow-core-contracts/lib/go/templates"
-	flowsdk "github.com/onflow/flow-go-sdk"
+	"github.com/onflow/flow-go/fvm/blueprints"
 	flowgo "github.com/onflow/flow-go/model/flow"
 )
 
-const (
-	contractName              = "FlowTransactionScheduler"
-	pendingExecutionEventName = "PendingExecution"
-)
-
-// filterPendingExecutionEvents filters events to only include PendingExecution events
-func filterPendingExecutionEvents(events []flowsdk.Event, serviceAddress flowgo.Address) []flowsdk.Event {
-	var filteredEvents []flowsdk.Event
+// parseScheduledIDs parses ID of the scheduled transactions from the events
+func parseScheduledIDs(env templates.Environment, events flowgo.EventsList) ([]string, error) {
+	const (
+		processedCallbackIDFieldName     = "id"
+		processedCallbackEffortFieldName = "executionEffort"
+	)
 
-	contractLocation := common.AddressLocation{
-		Address: common.Address(serviceAddress),
-		Name:    contractName,
-	}
-	expectedEventType := string(contractLocation.TypeID(nil, fmt.Sprintf("%s.%s", contractName, pendingExecutionEventName)))
+	ids := make([]string, 0)
 
 	for _, event := range events {
-		if event.Type == expectedEventType {
-			filteredEvents = append(filteredEvents, event)
+		if blueprints.PendingExecutionEventType(env) != event.Type {
+			continue
 		}
-	}
-
-	return filteredEvents
-}
-
-// todo: replace all the functions bellow with flow-go implementation once it's done
-// issue: https://github.com/onflow/flow-emulator/issues/829
-
-func processScheduledTransaction(
-	serviceAddress flowgo.Address,
-	parentID flowgo.Identifier,
-) flowgo.TransactionBody {
-	env := templates.Environment{
-		FlowTransactionSchedulerAddress: serviceAddress.HexWithPrefix(),
-	}
-
-	script := templates.GenerateProcessTransactionScript(env)
-
-	txBuilder := flowgo.NewTransactionBodyBuilder().
-		SetScript(script).
-		SetComputeLimit(defaultTransactionMaxGasLimit).
-		SetPayer(serviceAddress).
-		AddAuthorizer(serviceAddress).
-		SetReferenceBlockID(parentID)
-
-	tx, err := txBuilder.Build()
-	if err != nil {
-		panic(err)
-	}
-
-	return *tx
-}
-
-func executeScheduledTransactions(
-	pendingExecutionEvents []flowsdk.Event,
-	serviceAddress flowgo.Address,
-	parentID flowgo.Identifier,
-) (transactions []flowgo.TransactionBody, scheduledIDs []string, err error) {
-	transactions = make([]flowgo.TransactionBody, 0)
-	scheduledIDs = make([]string, 0)
-
-	env := templates.Environment{
-		FlowTransactionSchedulerAddress: serviceAddress.HexWithPrefix(),
-	}
-
-	script := templates.GenerateExecuteTransactionScript(env)
 
-	for _, e := range pendingExecutionEvents {
-		id, _, limit, _, err := parseSchedulerPendingExecutionEvent(e, serviceAddress)
+		eventData, err := ccf.Decode(nil, event.Payload)
 		if err != nil {
-			return nil, nil, err
+			return nil, fmt.Errorf("failed to decode event: %w", err)
 		}
 
-		txBuilder := flowgo.NewTransactionBodyBuilder().
-			SetScript(script).
-			AddArgument(id).
-			SetPayer(serviceAddress).
-			AddAuthorizer(serviceAddress).
-			SetReferenceBlockID(parentID).
-			SetComputeLimit(limit)
-
-		tx, err := txBuilder.Build()
-		if err != nil {
-			return nil, nil, err
+		cadenceEvent, ok := eventData.(cadence.Event)
+		if !ok {
+			return nil, fmt.Errorf("event data is not a cadence event")
 		}
 
-		transactions = append(transactions, *tx)
-		scheduledIDs = append(scheduledIDs, string(id))
-	}
-
-	return transactions, scheduledIDs, nil
-}
-
-// parseSchedulerPendingExecutionEvent parses flow event that is emitted during scheduler
-// marking the transaction as pending execution.
-// Returns:
-// - ID of the transaction encoded as bytes
-// - The priority of the transaction
-// - execution effort
-// - The address of the account that owns the transaction
-// - error in case the event type is not correct
-func parseSchedulerPendingExecutionEvent(event flowsdk.Event, serviceAddress flowgo.Address) ([]byte, uint8, uint64, cadence.Address, error) {
-	contractLocation := common.AddressLocation{
-		Address: common.Address(serviceAddress),
-		Name:    contractName,
-	}
-	transactionPendingExecutionEvent := contractLocation.TypeID(nil, fmt.Sprintf("%s.%s", contractName, pendingExecutionEventName))
-
-	const (
-		IDField        = "id"
-		priorityField  = "priority"
-		executionField = "executionEffort"
-		ownerField     = "transactionHandlerOwner"
-	)
-
-	if event.Type != string(transactionPendingExecutionEvent) {
-		return nil, 0, 0, cadence.BytesToAddress([]byte{}), fmt.Errorf("invalid event type, got: %s, expected: %s", event.Type, transactionPendingExecutionEvent)
-	}
-
-	id, ok := event.Value.SearchFieldByName(IDField).(cadence.UInt64)
-	if !ok {
-		return nil, 0, 0, cadence.BytesToAddress([]byte{}), fmt.Errorf("invalid ID value type: %v", id)
-	}
-
-	encodedID, err := jsoncdc.Encode(id)
-	if err != nil {
-		return nil, 0, 0, cadence.BytesToAddress([]byte{}), err
-	}
-
-	priorityRaw, ok := event.Value.SearchFieldByName(priorityField).(cadence.UInt8)
-	if !ok {
-		return nil, 0, 0, cadence.BytesToAddress([]byte{}), fmt.Errorf("invalid priority value type: %v", priorityRaw)
-	}
-	priority := uint8(priorityRaw)
+		idValue := cadence.SearchFieldByName(
+			cadenceEvent,
+			processedCallbackIDFieldName,
+		)
 
-	effortRaw, ok := event.Value.SearchFieldByName(executionField).(cadence.UInt64)
-	if !ok {
-		return nil, 0, 0, cadence.BytesToAddress([]byte{}), fmt.Errorf("invalid effort value type: %v", effortRaw)
-	}
-	executionEffort := uint64(effortRaw)
+		id, ok := idValue.(cadence.UInt64)
+		if !ok {
+			return nil, fmt.Errorf("id is not uint64")
+		}
 
-	owner, ok := event.Value.SearchFieldByName(ownerField).(cadence.Address)
-	if !ok {
-		return nil, 0, 0, cadence.BytesToAddress([]byte{}), fmt.Errorf("invalid owner value type: %v", owner)
+		ids = append(ids, fmt.Sprintf("%d", id))
 	}
 
-	return encodedID, priority, executionEffort, owner, nil
+	return ids, nil
 }