Entitlements Migration

migrations/account_storage.go

@@ -0,0 +1,87 @@
+/*
+ * Cadence - The resource-oriented smart contract programming language
+ *
+ * Copyright Dapper Labs, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package migrations
+
+import (
+	"github.com/onflow/cadence/runtime"
+	"github.com/onflow/cadence/runtime/common"
+	"github.com/onflow/cadence/runtime/interpreter"
+)
+
+type AccountStorage struct {
+	storage *runtime.Storage
+	address common.Address
+}
+
+// NewAccountStorage constructs an `AccountStorage` for a given account.
+func NewAccountStorage(storage *runtime.Storage, address common.Address) AccountStorage {
+	return AccountStorage{
+		storage: storage,
+		address: address,
+	}
+}
+
+// ForEachValue iterates over the values in the account.
+// The `valueConverter takes a function to be applied to each value.
+// It returns the converted, if a new value was created during conversion.
+func (i *AccountStorage) ForEachValue(
+	inter *interpreter.Interpreter,
+	domains []common.PathDomain,
+	valueConverter func(
+		value interpreter.Value,
+		address common.Address,
+		domain common.PathDomain,
+		key string,
+	) interpreter.Value,
+) {
+	for _, domain := range domains {
+		storageMap := i.storage.GetStorageMap(i.address, domain.Identifier(), false)
+		if storageMap == nil || storageMap.Count() == 0 {
+			continue
+		}
+
+		iterator := storageMap.Iterator(inter)
+
+		// Read the keys first, so the iteration wouldn't be affected
+		// by the modification of the storage values.
+		var keys []string
+		for key, _ := iterator.Next(); key != nil; key, _ = iterator.Next() {
+			identifier := string(key.(interpreter.StringAtreeValue))
+			keys = append(keys, identifier)
+		}
+
+		for _, key := range keys {
+			storageKey := interpreter.StringStorageMapKey(key)
+
+			value := storageMap.ReadValue(nil, storageKey)
+
+			newValue := valueConverter(value, i.address, domain, key)
+			if newValue == nil {
+				continue
+			}
+
+			// If the converter returns a new value, then replace the existing value with the new one.
+			storageMap.SetValue(
+				inter,
+				storageKey,
+				newValue,
+			)
+		}
+	}
+}

migrations/account_type/dummy_static_type.go

@@ -0,0 +1,49 @@
+/*
+ * Cadence - The resource-oriented smart contract programming language
+ *
+ * Copyright Dapper Labs, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package account_type
+
+import (
+	"github.com/onflow/cadence/runtime/common"
+	"github.com/onflow/cadence/runtime/interpreter"
+)
+
+// dummyStaticType is just a wrapper for `interpreter.PrimitiveStaticType`
+// with an overridden `ID` function.
+// This is only for testing the migration, so that a type-value with a deprecated primitive type
+// (e.g: `PrimitiveStaticTypePublicAccount`) is insertable as a dictionary key (to populate the storage).
+// i.e: To make hashing function works, which requires `ID()` method.
+// Currently, this is not possible, since the `ID` function of `interpreter.PrimitiveStaticType`
+// of deprecated types no longer work, as it relies on the `sema.Type`,
+// but the corresponding `sema.Type` for the deprecated primitive types are no longer available.
+type dummyStaticType struct {
+	interpreter.PrimitiveStaticType
+}
+
+func (t dummyStaticType) ID() common.TypeID {
+	return common.TypeID(t.String())
+}
+
+func (t dummyStaticType) Equal(other interpreter.StaticType) bool {
+	otherDummyType, ok := other.(dummyStaticType)
+	if !ok {
+		return false
+	}
+
+	return t == otherDummyType
+}

migrations/account_type/migration.go

@@ -0,0 +1,192 @@
+/*
+ * Cadence - The resource-oriented smart contract programming language
+ *
+ * Copyright Dapper Labs, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package account_type
+
+import (
+	"github.com/onflow/cadence/migrations"
+	"github.com/onflow/cadence/runtime/common"
+	"github.com/onflow/cadence/runtime/interpreter"
+	"github.com/onflow/cadence/runtime/sema"
+)
+
+type AccountTypeMigration struct{}
+
+var _ migrations.Migration = AccountTypeMigration{}
+
+func NewAccountTypeMigration() AccountTypeMigration {
+	return AccountTypeMigration{}
+}
+
+func (AccountTypeMigration) Name() string {
+	return "AccountTypeMigration"
+}
+
+// Migrate migrates `AuthAccount` and `PublicAccount` types inside `TypeValue`s,
+// to the account reference type (&Account).
+func (AccountTypeMigration) Migrate(value interpreter.Value) (newValue interpreter.Value) {
+	if typeValue, ok := value.(*interpreter.TypeValue); ok {
+		convertedType := maybeConvertAccountType(typeValue.Type)
+		if convertedType == nil {
+			return
+		}
+
+		return interpreter.NewTypeValue(nil, convertedType)
+	}
+
+	return nil
+}
+
+func maybeConvertAccountType(staticType interpreter.StaticType) interpreter.StaticType {
+	switch staticType := staticType.(type) {
+	case *interpreter.ConstantSizedStaticType:
+		convertedType := maybeConvertAccountType(staticType.Type)
+		if convertedType != nil {
+			return interpreter.NewConstantSizedStaticType(nil, convertedType, staticType.Size)
+		}
+
+	case *interpreter.VariableSizedStaticType:
+		convertedType := maybeConvertAccountType(staticType.Type)
+		if convertedType != nil {
+			return interpreter.NewVariableSizedStaticType(nil, convertedType)
+		}
+
+	case *interpreter.DictionaryStaticType:
+		convertedKeyType := maybeConvertAccountType(staticType.KeyType)
+		convertedValueType := maybeConvertAccountType(staticType.ValueType)
+		if convertedKeyType != nil && convertedValueType != nil {
+			return interpreter.NewDictionaryStaticType(nil, convertedKeyType, convertedValueType)
+		}
+		if convertedKeyType != nil {
+			return interpreter.NewDictionaryStaticType(nil, convertedKeyType, staticType.ValueType)
+		}
+		if convertedValueType != nil {
+			return interpreter.NewDictionaryStaticType(nil, staticType.KeyType, convertedValueType)
+		}
+
+	case *interpreter.CapabilityStaticType:
+		convertedBorrowType := maybeConvertAccountType(staticType.BorrowType)
+		if convertedBorrowType != nil {
+			return interpreter.NewCapabilityStaticType(nil, convertedBorrowType)
+		}
+
+	case *interpreter.IntersectionStaticType:
+		// Nothing to do. Inner types can only be interfaces.
+
+	case *interpreter.OptionalStaticType:
+		convertedInnerType := maybeConvertAccountType(staticType.Type)
+		if convertedInnerType != nil {
+			return interpreter.NewOptionalStaticType(nil, convertedInnerType)
+		}
+
+	case *interpreter.ReferenceStaticType:
+		// TODO: Reference of references must not be allowed?
+		convertedReferencedType := maybeConvertAccountType(staticType.ReferencedType)
+		if convertedReferencedType != nil {
+			switch convertedReferencedType {
+
+			// If the converted type is already an account reference, then return as-is.
+			// i.e: Do not create reference to a reference.
+			case authAccountReferenceType,
+				unauthorizedAccountReferenceType:
+				return convertedReferencedType
+
+			default:
+				return interpreter.NewReferenceStaticType(nil, staticType.Authorization, convertedReferencedType)
+			}
+		}
+
+	case interpreter.FunctionStaticType:
+		// Non-storable
+
+	case *interpreter.CompositeStaticType,
+		*interpreter.InterfaceStaticType:
+		// Nothing to do
+
+	case dummyStaticType:
+		// This is for testing the migration.
+		// i.e: wrapper was only to make it possible to use as a dictionary-key.
+		// Ignore the wrapper, and continue with the inner type.
+		return maybeConvertAccountType(staticType.PrimitiveStaticType)
+
+	default:
+		// Is it safe to do so?
+		switch staticType {
+		case interpreter.PrimitiveStaticTypePublicAccount: //nolint:staticcheck
+			return unauthorizedAccountReferenceType
+		case interpreter.PrimitiveStaticTypeAuthAccount: //nolint:staticcheck
+			return authAccountReferenceType
+
+		case interpreter.PrimitiveStaticTypeAuthAccountCapabilities, //nolint:staticcheck
+			interpreter.PrimitiveStaticTypePublicAccountCapabilities: //nolint:staticcheck
+			return interpreter.PrimitiveStaticTypeAccount_Capabilities
+
+		case interpreter.PrimitiveStaticTypeAuthAccountAccountCapabilities: //nolint:staticcheck
+			return interpreter.PrimitiveStaticTypeAccount_AccountCapabilities
+
+		case interpreter.PrimitiveStaticTypeAuthAccountStorageCapabilities: //nolint:staticcheck
+			return interpreter.PrimitiveStaticTypeAccount_StorageCapabilities
+
+		case interpreter.PrimitiveStaticTypeAuthAccountContracts, //nolint:staticcheck
+			interpreter.PrimitiveStaticTypePublicAccountContracts: //nolint:staticcheck
+			return interpreter.PrimitiveStaticTypeAccount_Contracts
+
+		case interpreter.PrimitiveStaticTypeAuthAccountKeys, //nolint:staticcheck
+			interpreter.PrimitiveStaticTypePublicAccountKeys: //nolint:staticcheck
+			return interpreter.PrimitiveStaticTypeAccount_Keys
+
+		case interpreter.PrimitiveStaticTypeAuthAccountInbox: //nolint:staticcheck
+			return interpreter.PrimitiveStaticTypeAccount_Inbox
+
+		case interpreter.PrimitiveStaticTypeAccountKey: //nolint:staticcheck
+			return interpreter.AccountKeyStaticType
+		}
+	}
+
+	return nil
+}
+
+var authAccountEntitlements = []common.TypeID{
+	sema.StorageType.ID(),
+	sema.ContractsType.ID(),
+	sema.KeysType.ID(),
+	sema.InboxType.ID(),
+	sema.CapabilitiesType.ID(),
+}
+
+var authAccountReferenceType = func() *interpreter.ReferenceStaticType {
+	auth := interpreter.NewEntitlementSetAuthorization(
+		nil,
+		func() []common.TypeID {
+			return authAccountEntitlements
+		},
+		len(authAccountEntitlements),
+		sema.Conjunction,
+	)
+	return interpreter.NewReferenceStaticType(
+		nil,
+		auth,
+		interpreter.PrimitiveStaticTypeAccount,
+	)
+}()
+
+var unauthorizedAccountReferenceType = interpreter.NewReferenceStaticType(
+	nil,
+	interpreter.UnauthorizedAccess,
+	interpreter.PrimitiveStaticTypeAccount,
+)