[FVM] reducing register touches

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

@@ -63,19 +63,12 @@ func extractExecutionState(
 	newState := ledger.State(targetHash)
 
 	if migrate {
-		storageUsedUpdateMigration := mgr.StorageUsedUpdateMigration{
-			Log:       log,
-			OutputDir: outputDir,
-		}
-
-		orderedMapMigration := mgr.OrderedMapMigration{
-			Log:       log,
-			OutputDir: dir,
+		accountStatusMigration := mgr.AccountStatusMigration{
+			Logger: log,
 		}
 
 		migrations = []ledger.Migration{
-			orderedMapMigration.Migrate,
-			storageUsedUpdateMigration.Migrate,
+			accountStatusMigration.Migrate,
 			mgr.PruneMigration,
 		}
 

cmd/util/ledger/migrations/account_status_migration.go

@@ -0,0 +1,49 @@
+package migrations
+
+import (
+	"encoding/hex"
+
+	"github.com/onflow/flow-go/fvm/state"
+	"github.com/onflow/flow-go/ledger"
+	"github.com/rs/zerolog"
+)
+
+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))
+}