Merge pull request #7493 from devbugging/gregor/callbacks/02-blueprint-implementation

[Scheduled Callbacks] Blueprints and transaction scripts

Author: joshuahannan

fvm/blueprints/scheduled_callback.go

@@ -0,0 +1,133 @@
+package blueprints
+
+import (
+	_ "embed"
+	"fmt"
+	"strings"
+
+	"github.com/onflow/cadence"
+	"github.com/onflow/cadence/encoding/ccf"
+
+	"github.com/onflow/flow-go/model/flow"
+)
+
+// processScheduledCallbacksTransaction calls scheduled callback contract
+// and process new callbacks that should be executed.
+//
+//go:embed scripts/processScheduledCallbacksTransaction.cdc
+var processCallbacksTransaction string
+
+// executeCallbacksTransaction calls scheduled callback contract
+// to execute the provided callback by ID.
+//
+//go:embed scripts/executeScheduledCallbackTransaction.cdc
+var executeCallbacksTransaction string
+
+const (
+	placeholderScheduledContract     = "import \"CallbackScheduler\""
+	processedCallbackIDFieldName     = "ID"
+	processedCallbackEffortFieldName = "executionEffort"
+	processedEventTypeTemplate       = "A.%v.CallbackScheduler.CallbackProcessed"
+)
+
+func ProcessCallbacksTransaction(chain flow.Chain, maxEffortLeft uint64) (*flow.TransactionBody, error) {
+	script := prepareScheduledContractTransaction(chain, processCallbacksTransaction)
+	effort, err := ccf.Encode(cadence.UInt64(maxEffortLeft))
+	if err != nil {
+		return nil, fmt.Errorf("failed to encode max effort left: %w", err)
+	}
+
+	tx := flow.NewTransactionBody().
+		SetScript(script).
+		AddArgument(effort).
+		SetComputeLimit(flow.DefaultMaxTransactionGasLimit)
+
+	return tx, nil
+}
+
+func ExecuteCallbacksTransactions(chainID flow.Chain, processEvents flow.EventsList) ([]*flow.TransactionBody, error) {
+	txs := make([]*flow.TransactionBody, 0, len(processEvents))
+
+	for _, event := range processEvents {
+		id, effort, err := callbackArgsFromEvent(event)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get callback args from event: %w", err)
+		}
+
+		tx := executeCallbackTransaction(chainID, id, effort)
+		txs = append(txs, tx)
+	}
+
+	return txs, nil
+}
+
+func executeCallbackTransaction(chain flow.Chain, id []byte, effort uint64) *flow.TransactionBody {
+	script := prepareScheduledContractTransaction(chain, executeCallbacksTransaction)
+	return flow.NewTransactionBody().
+		SetScript(script).
+		AddArgument(id).
+		SetComputeLimit(effort)
+}
+
+// callbackArgsFromEvent decodes the event payload and returns the callback ID and effort.
+//
+// The event for processed callback event is emitted by the process callback transaction from
+// callback scheduler contract and has the following signature:
+// event CallbackProcessed(ID: UInt64, executionEffort: UInt64)
+func callbackArgsFromEvent(event flow.Event) ([]byte, uint64, error) {
+	scheduledContractAddress := "0x0000000000000000" // todo use contract addr
+	if string(event.Type) != fmt.Sprintf(processedEventTypeTemplate, scheduledContractAddress) {
+		return nil, 0, fmt.Errorf("wrong event type is passed")
+	}
+
+	eventData, err := ccf.Decode(nil, event.Payload)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to decode event: %w", err)
+	}
+
+	cadenceEvent, ok := eventData.(cadence.Event)
+	if !ok {
+		return nil, 0, fmt.Errorf("event data is not a cadence event")
+	}
+
+	idValue := cadence.SearchFieldByName(
+		cadenceEvent,
+		processedCallbackIDFieldName,
+	)
+
+	effortValue := cadence.SearchFieldByName(
+		cadenceEvent,
+		processedCallbackEffortFieldName,
+	)
+
+	id, ok := idValue.(cadence.UInt64)
+	if !ok {
+		return nil, 0, fmt.Errorf("id is not uint64")
+	}
+
+	effort, ok := effortValue.(cadence.UInt64)
+	if !ok {
+		return nil, 0, fmt.Errorf("effort is not uint64")
+	}
+
+	encodedID, err := ccf.Encode(id)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to encode id: %w", err)
+	}
+
+	return encodedID, uint64(effort), nil
+}
+
+func prepareScheduledContractTransaction(_ flow.Chain, txScript string) []byte {
+	// todo use this instead of palceholder address
+	// _ = systemcontracts.SystemContractsForChain(chain.ChainID())
+	scheduledContractAddress := "0x0000000000000000"
+
+	code := strings.ReplaceAll(
+		txScript,
+		placeholderScheduledContract,
+		fmt.Sprintf("%s from %s", placeholderScheduledContract, scheduledContractAddress),
+	)
+
+	return []byte(code)
+}

fvm/blueprints/scheduled_callback_test.go

@@ -0,0 +1,191 @@
+package blueprints_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/onflow/cadence"
+	cadenceCommon "github.com/onflow/cadence/common"
+	"github.com/onflow/cadence/encoding/ccf"
+
+	"github.com/onflow/flow-go/fvm/blueprints"
+	"github.com/onflow/flow-go/model/flow"
+	"github.com/onflow/flow-go/utils/unittest"
+)
+
+func TestProcessCallbacksTransaction(t *testing.T) {
+	t.Parallel()
+
+	chain := flow.Mainnet.Chain()
+	const effortLeft = 100
+	tx, err := blueprints.ProcessCallbacksTransaction(chain, effortLeft)
+	require.NoError(t, err)
+
+	assert.NotNil(t, tx)
+	assert.NotEmpty(t, tx.Script)
+	assert.Equal(t, uint64(flow.DefaultMaxTransactionGasLimit), tx.GasLimit)
+	encodedEffort, err := ccf.Encode(cadence.UInt64(effortLeft))
+	require.NoError(t, err)
+	assert.Equal(t, encodedEffort, tx.Arguments[0])
+}
+
+func TestExecuteCallbacksTransactions(t *testing.T) {
+	t.Parallel()
+
+	chain := flow.Mainnet.Chain()
+
+	tests := []struct {
+		name         string
+		events       []flow.Event
+		expectedTxs  int
+		expectError  bool
+		errorMessage string
+	}{
+		{
+			name:        "no events",
+			events:      []flow.Event{},
+			expectedTxs: 0,
+			expectError: false,
+		},
+		{
+			name:        "single valid event",
+			events:      []flow.Event{createValidCallbackEvent(t, 1, 100)},
+			expectedTxs: 1,
+			expectError: false,
+		},
+		{
+			name: "multiple valid events",
+			events: []flow.Event{
+				createValidCallbackEvent(t, 1, 100),
+				createValidCallbackEvent(t, 2, 200),
+				createValidCallbackEvent(t, 3, 300),
+			},
+			expectedTxs: 3,
+			expectError: false,
+		},
+		{
+			name:         "invalid event type",
+			events:       []flow.Event{createInvalidTypeEvent()},
+			expectedTxs:  0,
+			expectError:  true,
+			errorMessage: "failed to get callback args from event",
+		},
+		{
+			name:         "invalid event payload",
+			events:       []flow.Event{createInvalidPayloadEvent()},
+			expectedTxs:  0,
+			expectError:  true,
+			errorMessage: "failed to get callback args from event",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			txs, err := blueprints.ExecuteCallbacksTransactions(chain, tt.events)
+
+			if tt.expectError {
+				assert.Error(t, err)
+				assert.Contains(t, err.Error(), tt.errorMessage)
+				assert.Nil(t, txs)
+				return
+			}
+
+			assert.NoError(t, err)
+			assert.Len(t, txs, tt.expectedTxs)
+
+			for i, tx := range txs {
+				assert.NotNil(t, tx)
+				assert.NotEmpty(t, tx.Script)
+				expectedEffort := uint64(100 * (i + 1)) // Events created with efforts 100, 200, 300
+				assert.Equal(t, expectedEffort, tx.GasLimit)
+				assert.Len(t, tx.Arguments, 1)
+				assert.NotEmpty(t, tx.Arguments[0])
+
+				t.Logf("Transaction %d: ID arg length: %d, GasLimit: %d",
+					i, len(tx.Arguments[0]), tx.GasLimit)
+			}
+		})
+	}
+}
+
+func TestExecuteCallbackTransaction(t *testing.T) {
+	t.Parallel()
+
+	chain := flow.Mainnet.Chain()
+
+	const id = 123
+	const effort = 456
+	event := createValidCallbackEvent(t, id, effort)
+	txs, err := blueprints.ExecuteCallbacksTransactions(chain, []flow.Event{event})
+
+	require.NoError(t, err)
+	require.Len(t, txs, 1)
+
+	tx := txs[0]
+	assert.NotNil(t, tx)
+	assert.NotEmpty(t, tx.Script)
+	assert.Equal(t, uint64(effort), tx.GasLimit)
+	assert.Len(t, tx.Arguments, 1)
+
+	expectedEncodedID, err := ccf.Encode(cadence.NewUInt64(id))
+	require.NoError(t, err)
+	assert.Equal(t, tx.Arguments[0], expectedEncodedID)
+
+	assert.Equal(t, tx.GasLimit, uint64(effort))
+}
+
+func createValidCallbackEvent(t *testing.T, id uint64, effort uint64) flow.Event {
+	// todo use proper location
+	contractAddress := flow.HexToAddress("0x0000000000000000")
+	location := cadenceCommon.NewAddressLocation(nil, cadenceCommon.Address(contractAddress), "CallbackScheduler")
+
+	eventType := cadence.NewEventType(
+		location,
+		"CallbackProcessed",
+		[]cadence.Field{
+			{Identifier: "ID", Type: cadence.UInt64Type},
+			{Identifier: "executionEffort", Type: cadence.UInt64Type},
+		},
+		nil,
+	)
+
+	event := cadence.NewEvent(
+		[]cadence.Value{
+			cadence.NewUInt64(id),
+			cadence.NewUInt64(effort),
+		},
+	).WithType(eventType)
+
+	payload, err := ccf.Encode(event)
+	require.NoError(t, err)
+
+	return flow.Event{
+		Type:             flow.EventType("A.0x0000000000000000.CallbackScheduler.CallbackProcessed"),
+		TransactionID:    unittest.IdentifierFixture(),
+		TransactionIndex: 0,
+		EventIndex:       0,
+		Payload:          payload,
+	}
+}
+
+func createInvalidTypeEvent() flow.Event {
+	return flow.Event{
+		Type:             flow.EventType("A.0x0000000000000000.SomeContract.WrongEvent"),
+		TransactionID:    unittest.IdentifierFixture(),
+		TransactionIndex: 0,
+		EventIndex:       0,
+		Payload:          []byte("invalid"),
+	}
+}
+
+func createInvalidPayloadEvent() flow.Event {
+	return flow.Event{
+		Type:             flow.EventType("A.0x0000000000000000.CallbackScheduler.CallbackProcessed"),
+		TransactionID:    unittest.IdentifierFixture(),
+		TransactionIndex: 0,
+		EventIndex:       0,
+		Payload:          []byte("not valid ccf"),
+	}
+}

fvm/blueprints/scripts/executeScheduledCallbackTransaction.cdc

@@ -0,0 +1,7 @@
+import "CallbackScheduler"
+
+transaction(callbackID: UInt64) {
+    execute {
+        CallbackScheduler.executeCallback(ID: callbackID)
+    }
+}

fvm/blueprints/scripts/processScheduledCallbacksTransaction.cdc

@@ -0,0 +1,7 @@
+import "CallbackScheduler"
+
+transaction(maxEffortLeft: UInt64) {
+    execute {
+        CallbackScheduler.process(maxEffortLeft: effortLimit)
+    }
+}