[FVM] reducing register touches

cmd/util/cmd/execution-state-extract/execution_state_extract.go

@@ -67,7 +67,12 @@ func extractExecutionState(
 			OutputDir: outputDir,
 		}
 
+		accountStatusMigration := mgr.AccountStatusMigration{
+			Logger: log,
+		}
+
 		migrations = []ledger.Migration{
+			accountStatusMigration.Migrate,
 			storageUsedUpdateMigration.Migrate,
 			mgr.PruneMigration,
 		}

cmd/util/ledger/migrations/account_status_migration.go

@@ -0,0 +1,50 @@
+package migrations
+
+import (
+	"encoding/hex"
+
+	"github.com/rs/zerolog"
+
+	"github.com/onflow/flow-go/fvm/state"
+	"github.com/onflow/flow-go/ledger"
+)
+
+const (
+	KeyExists        = "exists"
+	KeyAccountFrozen = "frozen"
+)
+
+// AccountStatusMigration migrates previous registers under
+// key of Exists which were used for checking existance of accounts.
+// the new register AccountStatus also captures frozen and all future states
+// of the accounts. Frozen state is used when an account is set
+// by the network governance for furture investigation and prevents operations on the account until
+// furthure investigation by the community.
+// This migration assumes no account has been frozen until now, and would warn if
+// find any account with frozen flags.
+type AccountStatusMigration struct {
+	Logger zerolog.Logger
+}
+
+func (as *AccountStatusMigration) Migrate(payload []ledger.Payload) ([]ledger.Payload, error) {
+	newPayloads := make([]ledger.Payload, 0, len(payload))
+	for _, p := range payload {
+		owner := p.Key.KeyParts[0].Value
+		controller := p.Key.KeyParts[1].Value
+		key := p.Key.KeyParts[2].Value
+		if len(controller) == 0 && string(key) == KeyExists {
+			newPayload := p.DeepCopy()
+			newPayload.Key.KeyParts[2].Value = []byte(state.KeyAccountStatus)
+			newPayload.Value = state.NewAccountStatus().ToBytes()
+			newPayloads = append(newPayloads, *newPayload)
+			continue
+		}
+		if len(controller) == 0 && string(key) == KeyAccountFrozen {
+			as.Logger.Warn().Msgf("frozen account found: %s", hex.EncodeToString(owner))
+			continue
+		}
+		// else just append and continue
+		newPayloads = append(newPayloads, p)
+	}
+	return newPayloads, nil
+}

cmd/util/ledger/migrations/account_status_migration_test.go

@@ -0,0 +1,55 @@
+package migrations
+
+import (
+	"testing"
+
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/require"
+
+	"github.com/onflow/flow-go-sdk"
+
+	state "github.com/onflow/flow-go/fvm/state"
+	"github.com/onflow/flow-go/ledger"
+	"github.com/onflow/flow-go/ledger/common/utils"
+)
+
+func createAccountPayloadKey(a flow.Address, key string) ledger.Key {
+	return ledger.Key{
+		KeyParts: []ledger.KeyPart{
+			ledger.NewKeyPart(0, a.Bytes()),
+			ledger.NewKeyPart(1, []byte("")),
+			ledger.NewKeyPart(2, []byte(key)),
+		},
+	}
+}
+
+func TestAccountStatusMigration(t *testing.T) {
+	mig := AccountStatusMigration{
+		Logger: zerolog.Logger{},
+	}
+
+	address1 := flow.HexToAddress("0x1")
+	address2 := flow.HexToAddress("0x2")
+
+	payloads := []ledger.Payload{
+		{Key: createAccountPayloadKey(address1, state.KeyStorageUsed), Value: utils.Uint64ToBinary(1)},
+		{Key: createAccountPayloadKey(address1, "other registers"), Value: utils.Uint64ToBinary(2)},
+		{Key: createAccountPayloadKey(address2, "other registers2"), Value: utils.Uint64ToBinary(3)},
+		{Key: createAccountPayloadKey(address1, KeyExists), Value: []byte{1}},
+		{Key: createAccountPayloadKey(address1, KeyAccountFrozen), Value: []byte{1}},
+	}
+
+	newPayloads, err := mig.Migrate(payloads)
+	require.NoError(t, err)
+	require.Equal(t, 4, len(newPayloads)) // no more frozen register
+
+	require.True(t, newPayloads[0].Equals(&payloads[0]))
+	require.True(t, newPayloads[1].Equals(&payloads[1]))
+	require.True(t, newPayloads[2].Equals(&payloads[2]))
+
+	expectedPayload := &ledger.Payload{
+		Key:   createAccountPayloadKey(address1, state.KeyAccountStatus),
+		Value: state.NewAccountStatus().ToBytes(),
+	}
+	require.True(t, newPayloads[3].Equals(expectedPayload))
+}

cmd/util/ledger/migrations/storage_used_update_migration_test.go

@@ -25,7 +25,7 @@ func TestStorageUsedUpdateMigrationMigration(t *testing.T) {
 
 	t.Run("fix storage used", func(t *testing.T) {
 		payload := []ledger.Payload{
-			{Key: createAccountPayloadKey(address1, state2.KeyExists), Value: []byte{1}},
+			{Key: createAccountPayloadKey(address1, state2.KeyAccountStatus), Value: []byte{1}},
 			{Key: createAccountPayloadKey(address1, state2.KeyStorageUsed), Value: utils.Uint64ToBinary(1)},
 		}
 		migratedPayload, err := mig.Migrate(payload)
@@ -35,12 +35,12 @@ func TestStorageUsedUpdateMigrationMigration(t *testing.T) {
 		require.NoError(t, err)
 
 		require.Equal(t, len(migratedPayload), len(payload))
-		require.Equal(t, uint64(55), migratedSize)
+		require.Equal(t, uint64(52), migratedSize)
 	})
 
 	t.Run("fix storage used if used to high", func(t *testing.T) {
 		payload := []ledger.Payload{
-			{Key: createAccountPayloadKey(address1, state2.KeyExists), Value: []byte{1}},
+			{Key: createAccountPayloadKey(address1, state2.KeyAccountStatus), Value: []byte{1}},
 			{Key: createAccountPayloadKey(address1, state2.KeyStorageUsed), Value: utils.Uint64ToBinary(10000)},
 		}
 		migratedPayload, err := mig.Migrate(payload)
@@ -50,12 +50,12 @@ func TestStorageUsedUpdateMigrationMigration(t *testing.T) {
 		require.NoError(t, err)
 
 		require.Equal(t, len(migratedPayload), len(payload))
-		require.Equal(t, uint64(55), migratedSize)
+		require.Equal(t, uint64(52), migratedSize)
 	})
 
 	t.Run("do not fix storage used if storage used ok", func(t *testing.T) {
 		payload := []ledger.Payload{
-			{Key: createAccountPayloadKey(address1, state2.KeyExists), Value: []byte{1}},
+			{Key: createAccountPayloadKey(address1, state2.KeyAccountStatus), Value: []byte{1}},
 			{Key: createAccountPayloadKey(address1, state2.KeyStorageUsed), Value: utils.Uint64ToBinary(55)},
 		}
 		migratedPayload, err := mig.Migrate(payload)
@@ -65,12 +65,12 @@ func TestStorageUsedUpdateMigrationMigration(t *testing.T) {
 		require.NoError(t, err)
 
 		require.Equal(t, len(migratedPayload), len(payload))
-		require.Equal(t, uint64(55), migratedSize)
+		require.Equal(t, uint64(52), migratedSize)
 	})
 
 	t.Run("error is storage used does not exist", func(t *testing.T) {
 		payload := []ledger.Payload{
-			{Key: createAccountPayloadKey(address1, state2.KeyExists), Value: []byte{1}},
+			{Key: createAccountPayloadKey(address1, state2.KeyAccountStatus), Value: []byte{1}},
 		}
 		_, err := mig.Migrate(payload)
 		require.Error(t, err)

engine/execution/computation/computer/computer_test.go

@@ -367,8 +367,9 @@ func TestBlockExecutor_ExecuteBlock(t *testing.T) {
 
 		execCtx := fvm.NewContext(zerolog.Nop())
 
+		address := common.Address{0x1}
 		contractLocation := common.AddressLocation{
-			Address: common.Address{0x1},
+			Address: address,
 			Name:    "Test",
 		}
 
@@ -407,6 +408,9 @@ func TestBlockExecutor_ExecuteBlock(t *testing.T) {
 			return nil, nil
 		})
 
+		err = view.Set(string(address.Bytes()), "", state.KeyAccountStatus, []byte{1})
+		require.NoError(t, err)
+
 		result, err := exe.ExecuteBlock(context.Background(), block, view, programs.NewEmptyPrograms())
 		assert.NoError(t, err)
 		assert.Len(t, result.StateSnapshots, collectionCount+1) // +1 system chunk
@@ -423,8 +427,10 @@ func TestBlockExecutor_ExecuteBlock(t *testing.T) {
 			),
 		)
 
+		address := common.Address{0x1}
+
 		contractLocation := common.AddressLocation{
-			Address: common.Address{0x1},
+			Address: address,
 			Name:    "Test",
 		}
 
@@ -477,6 +483,9 @@ func TestBlockExecutor_ExecuteBlock(t *testing.T) {
 			return nil, nil
 		})
 
+		err = view.Set(string(address.Bytes()), "", state.KeyAccountStatus, []byte{1})
+		require.NoError(t, err)
+
 		result, err := exe.ExecuteBlock(context.Background(), block, view, programs.NewEmptyPrograms())
 		require.NoError(t, err)
 		assert.Len(t, result.StateSnapshots, collectionCount+1) // +1 system chunk
@@ -594,7 +603,7 @@ func (f *FixedAddressGenerator) AddressCount() uint64 {
 	panic("not implemented")
 }
 
-func Test_FreezeAccountChecksAreIncluded(t *testing.T) {
+func Test_AccountStatusRegistersAreIncluded(t *testing.T) {
 
 	address := flow.HexToAddress("1234")
 	fag := &FixedAddressGenerator{Address: address}
@@ -633,11 +642,11 @@ func Test_FreezeAccountChecksAreIncluded(t *testing.T) {
 
 	registerTouches := view.Interactions().RegisterTouches()
 
-	// make sure check for frozen account has been registered
+	// make sure check for account status has been registered
 	id := flow.RegisterID{
 		Owner:      string(address.Bytes()),
 		Controller: "",
-		Key:        state.KeyAccountFrozen,
+		Key:        state.KeyAccountStatus,
 	}
 
 	require.Contains(t, registerTouches, id.String())

engine/execution/computation/execution_verification_test.go

@@ -160,7 +160,7 @@ func Test_ExecutionMatchesVerification(t *testing.T) {
 		err = testutil.SignTransaction(addKeyTx, accountAddress, accountPrivKey, 0)
 		require.NoError(t, err)
 
-		minimumStorage, err := cadence.NewUFix64("0.00008164")
+		minimumStorage, err := cadence.NewUFix64("0.00008171")
 		require.NoError(t, err)
 
 		cr := executeBlockAndVerify(t, [][]*flow.TransactionBody{

engine/execution/computation/programs_test.go

@@ -2,7 +2,9 @@ package computation
 
 import (
 	"context"
+	"fmt"
 	"testing"
+	"time"
 
 	"github.com/onflow/cadence"
 	jsoncdc "github.com/onflow/cadence/encoding/json"
@@ -146,6 +148,18 @@ func TestPrograms_TestContractUpdates(t *testing.T) {
 	hasValidEventValue(t, returnedComputationResult.Events[0][4], 2)
 }
 
+type blockProvider struct {
+	blocks map[uint64]*flow.Block
+}
+
+func (b blockProvider) ByHeightFrom(height uint64, _ *flow.Header) (*flow.Header, error) {
+	block, has := b.blocks[height]
+	if has {
+		return block.Header, nil
+	}
+	return nil, fmt.Errorf("block for height (%d) is not available", height)
+}
+
 // TestPrograms_TestBlockForks tests the functionality of
 // programsCache under contract deployment and contract updates on
 // different block forks
@@ -161,11 +175,14 @@ func TestPrograms_TestContractUpdates(t *testing.T) {
 //         -> Block121 (emit event - version should be 2)
 //             -> Block1211 (emit event - version should be 2)
 func TestPrograms_TestBlockForks(t *testing.T) {
-	// setup
+	block := unittest.BlockFixture()
 	rt := fvm.NewInterpreterRuntime()
-	chain := flow.Mainnet.Chain()
+	chain := flow.Emulator.Chain()
 	vm := fvm.NewVirtualMachine(rt)
-	execCtx := fvm.NewContext(zerolog.Nop(), fvm.WithChain(chain))
+	execCtx := fvm.NewContext(zerolog.Nop(),
+		fvm.WithBlockHeader(block.Header),
+		fvm.WithBlocks(blockProvider{map[uint64]*flow.Block{0: &block}}),
+		fvm.WithChain(chain))
 
 	privateKeys, err := testutil.GenerateAccountPrivateKeys(1)
 	require.NoError(t, err)
@@ -389,8 +406,9 @@ func createTestBlockAndRun(t *testing.T, engine *Manager, parentBlock *flow.Bloc
 
 	block := &flow.Block{
 		Header: &flow.Header{
-			ParentID: parentBlock.ID(),
-			View:     parentBlock.Header.Height + 1,
+			ParentID:  parentBlock.ID(),
+			View:      parentBlock.Header.Height + 1,
+			Timestamp: time.Now(),
 		},
 		Payload: &flow.Payload{
 			Guarantees: []*flow.CollectionGuarantee{&guarantee},
@@ -409,6 +427,11 @@ func createTestBlockAndRun(t *testing.T, engine *Manager, parentBlock *flow.Bloc
 	}
 	returnedComputationResult, err := engine.ComputeBlock(context.Background(), executableBlock, view)
 	require.NoError(t, err)
+
+	for _, txResult := range returnedComputationResult.TransactionResults {
+		require.Empty(t, txResult.ErrorMessage)
+	}
+
 	return block, returnedComputationResult
 }
 

engine/execution/state/bootstrap/bootstrap_test.go

@@ -47,7 +47,7 @@ func TestBootstrapLedger(t *testing.T) {
 }
 
 func TestBootstrapLedger_ZeroTokenSupply(t *testing.T) {
-	expectedStateCommitmentBytes, _ := hex.DecodeString("cae2f2d6c53582503dad30dba8a8bba098ff8654d19b820a49e1961c1f459a41")
+	expectedStateCommitmentBytes, _ := hex.DecodeString("09a41556866f7756a6a348e4fbf0c585b8f43870dfab30e98abdbb5635c0416b")
 	expectedStateCommitment, err := flow.ToStateCommitment(expectedStateCommitmentBytes)
 	require.NoError(t, err)
 

fvm/accounts_test.go

@@ -1284,7 +1284,7 @@ func TestAccountBalanceFields(t *testing.T) {
 
 				assert.NoError(t, err)
 				assert.NoError(t, script.Err)
-				assert.Equal(t, cadence.UFix64(9999_2520), script.Value)
+				assert.Equal(t, cadence.UFix64(9999_2550), script.Value)
 			}),
 	)
 

fvm/context.go

@@ -35,7 +35,7 @@ type Context struct {
 	CadenceLoggingEnabled         bool
 	EventCollectionEnabled        bool
 	ServiceEventCollectionEnabled bool
-	AccountFreezeAvailable        bool
+	AccountFreezeEnabled          bool
 	ExtensiveTracing              bool
 	TransactionProcessors         []TransactionProcessor
 	ScriptProcessors              []ScriptProcessor
@@ -89,13 +89,11 @@ func defaultContext(logger zerolog.Logger) Context {
 		CadenceLoggingEnabled:         false,
 		EventCollectionEnabled:        true,
 		ServiceEventCollectionEnabled: false,
-		AccountFreezeAvailable:        false,
+		AccountFreezeEnabled:          true,
 		ExtensiveTracing:              false,
 		TransactionProcessors: []TransactionProcessor{
-			NewTransactionAccountFrozenChecker(),
-			NewTransactionSignatureVerifier(AccountKeyWeightThreshold),
+			NewTransactionVerifier(AccountKeyWeightThreshold),
 			NewTransactionSequenceNumberChecker(),
-			NewTransactionAccountFrozenEnabler(),
 			NewTransactionInvoker(logger),
 		},
 		ScriptProcessors: []ScriptProcessor{
@@ -185,12 +183,12 @@ func WithBlockHeader(header *flow.Header) Option {
 	}
 }
 
-// WithAccountFreezeAvailable sets availability of account freeze function for a virtual machine context.
+// WithAccountFreezeEnabled enable/disable of account freeze functionality for a virtual machine context.
 //
 // With this option set to true, a setAccountFreeze function will be enabled for transactions processed by the VM
-func WithAccountFreezeAvailable(accountFreezeAvailable bool) Option {
+func WithAccountFreezeEnabled(accountFreezeEnabled bool) Option {
 	return func(ctx Context) Context {
-		ctx.AccountFreezeAvailable = accountFreezeAvailable
+		ctx.AccountFreezeEnabled = accountFreezeEnabled
 		return ctx
 	}
 }

fvm/fvm_blockcontext_test.go

@@ -1102,8 +1102,6 @@ func TestBlockContext_ExecuteTransaction_InteractionLimitReached(t *testing.T) {
 	t.Run("Using to much interaction fails but does not panic", newVMTest().withBootstrapProcedureOptions(bootstrapOptions...).
 		withContextOptions(
 			fvm.WithTransactionProcessors(
-				fvm.NewTransactionAccountFrozenChecker(),
-				fvm.NewTransactionAccountFrozenEnabler(),
 				fvm.NewTransactionInvoker(zerolog.Nop()),
 			),
 		).