Fix conflicts between scheduled callbacks and malleability

Author: tim-barry

engine/execution/computation/computer/computer.go

@@ -184,7 +184,10 @@ func NewBlockComputer(
 		return nil, fmt.Errorf("could not build system chunk transaction: %w", err)
 	}
 
-	processCallbackTxn := blueprints.ProcessCallbacksTransaction(vmCtx.Chain)
+	processCallbackTxn, err := blueprints.ProcessCallbacksTransaction(vmCtx.Chain)
+	if err != nil {
+		return nil, fmt.Errorf("failed to generate callbacks script: %w", err)
+	}
 
 	return &blockComputer{
 		vm:                    vm,
@@ -286,13 +289,8 @@ func (e *blockComputer) queueUserTransactions(
 			isSystemTransaction: false,
 		}
 
-<<<<<<< HEAD
 		for i, txnBody := range collection.Collection.Transactions {
-			requestQueue <- newTransactionRequest(
-=======
-		for i, txnBody := range collection.Transactions {
 			txQueue <- newTransactionRequest(
->>>>>>> master
 				collectionInfo,
 				collectionCtx,
 				collectionLogger,
@@ -444,17 +442,9 @@ func (e *blockComputer) executeUserTransactions(
 	rawCollections []*entity.CompleteCollection,
 	userTxCount int,
 ) {
-<<<<<<< HEAD
-	txQueue := make(chan TransactionRequest, userTxCount)
-
-	e.queueUserTransactions(
+	txQueue := e.queueUserTransactions(
 		block.BlockID(),
 		block.Block.ToHeader(),
-=======
-	txQueue := e.queueUserTransactions(
-		block.ID(),
-		block.Block.Header,
->>>>>>> master
 		rawCollections,
 		userTxCount,
 	)
@@ -578,21 +568,10 @@ func (e *blockComputer) executeProcessCallback(
 	blockSpan otelTrace.Span,
 	txnIndex uint32,
 	systemLogger zerolog.Logger,
-<<<<<<< HEAD
-) ([]*flow.TransactionBody, error) {
-	processTxn, err := blueprints.ProcessCallbacksTransaction(e.vmCtx.Chain)
-	if err != nil {
-		return nil, fmt.Errorf("failed to generate callbacks script: %w", err)
-	}
-
-	// add process callback transaction to the system collection info
-	// TODO(7749): fix illegal mutation
-	systemCollectionInfo.CompleteCollection.Collection.Transactions = append(systemCollectionInfo.CompleteCollection.Collection.Transactions, processTxn) //nolint:structwrite
-=======
 ) ([]*flow.TransactionBody, uint32, error) {
 	// add process callback transaction to the system collection info
-	systemCollectionInfo.CompleteCollection.Transactions = append(systemCollectionInfo.CompleteCollection.Transactions, e.processCallbackTxn)
->>>>>>> master
+	// TODO(7749): fix illegal mutation
+	systemCollectionInfo.CompleteCollection.Collection.Transactions = append(systemCollectionInfo.CompleteCollection.Collection.Transactions, e.processCallbackTxn) //nolint:structwrite
 
 	request := newTransactionRequest(
 		systemCollectionInfo,

fvm/blueprints/scheduled_callback.go

@@ -15,16 +15,11 @@ import (
 
 const callbackTransactionGasLimit = flow.DefaultMaxTransactionGasLimit
 
-<<<<<<< HEAD
 // ProcessCallbacksTransaction constructs a transaction for processing callbacks, for the given callback.
 // No errors are expected during normal operation.
 func ProcessCallbacksTransaction(chain flow.Chain) (*flow.TransactionBody, error) {
-	script := prepareScheduledContractTransaction(chain, processCallbacksTransaction)
-=======
-func ProcessCallbacksTransaction(chain flow.Chain) *flow.TransactionBody {
 	sc := systemcontracts.SystemContractsForChain(chain.ChainID())
 	script := templates.GenerateProcessCallbackScript(sc.AsTemplateEnv())
->>>>>>> master
 
 	return flow.NewTransactionBodyBuilder().
 		SetScript(script).
@@ -43,30 +38,20 @@ func ExecuteCallbacksTransactions(chainID flow.Chain, processEvents flow.EventsL
 			return nil, fmt.Errorf("failed to get callback args from event: %w", err)
 		}
 
-<<<<<<< HEAD
-		tx, err := executeCallbackTransaction(chainID, id, effort)
+		tx, err := executeCallbackTransaction(env, id, effort)
 		if err != nil {
 			return nil, fmt.Errorf("failed to construct execute callback transactions: %w", err)
 		}
-=======
-		tx := executeCallbackTransaction(env, id, effort)
->>>>>>> master
 		txs = append(txs, tx)
 	}
 
 	return txs, nil
 }
 
-<<<<<<< HEAD
-func executeCallbackTransaction(chain flow.Chain, id []byte, effort uint64) (*flow.TransactionBody, error) {
-	script := prepareScheduledContractTransaction(chain, executeCallbacksTransaction)
-	return flow.NewTransactionBodyBuilder().
-=======
-func executeCallbackTransaction(env templates.Environment, id []byte, effort uint64) *flow.TransactionBody {
+func executeCallbackTransaction(env templates.Environment, id []byte, effort uint64) (*flow.TransactionBody, error) {
 	script := templates.GenerateExecuteCallbackScript(env)
 
-	return flow.NewTransactionBody().
->>>>>>> master
+	return flow.NewTransactionBodyBuilder().
 		SetScript(script).
 		AddArgument(id).
 		SetComputeLimit(effort).

fvm/bootstrap.go

@@ -802,9 +802,13 @@ func (b *bootstrapExecutor) deployNFTStorefrontV2(deployTo flow.Address, env *te
 
 func (b *bootstrapExecutor) deployFlowCallbackScheduler(deployTo flow.Address, env *templates.Environment) {
 	contract := contracts.FlowCallbackScheduler(*env)
+	txBody, err := blueprints.DeployContractTransaction(deployTo, contract, "FlowCallbackScheduler").Build()
+	if err != nil {
+		panic(fmt.Sprintf("failed to create FlowCallbackScheduler deploy transaction: %s", err))
+	}
 	txError, err := b.invokeMetaTransaction(
 		b.ctx,
-		Transaction(blueprints.DeployContractTransaction(deployTo, contract, "FlowCallbackScheduler"), 0),
+		Transaction(txBody, 0),
 	)
 
 	panicOnMetaInvokeErrf("failed to deploy FlowCallbackScheduler contract: %s", txError, err)