Capability controllers migration

migrations/account_storage.go

@@ -37,18 +37,18 @@ func NewAccountStorage(storage *runtime.Storage, address common.Address) Account
 	}
 }
 
+type ValueConverter func(
+	addressPath interpreter.AddressPath,
+	value interpreter.Value,
+) interpreter.Value
+
 // 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,
+	valueConverter ValueConverter,
 ) {
 	for _, domain := range domains {
 		storageMap := i.storage.GetStorageMap(i.address, domain.Identifier(), false)
@@ -69,9 +69,19 @@ func (i *AccountStorage) ForEachValue(
 		for _, key := range keys {
 			storageKey := interpreter.StringStorageMapKey(key)
 
+			path := interpreter.PathValue{
+				Identifier: key,
+				Domain:     domain,
+			}
+
+			addressPath := interpreter.AddressPath{
+				Address: i.address,
+				Path:    path,
+			}
+
 			value := storageMap.ReadValue(nil, storageKey)
 
-			newValue := valueConverter(value, i.address, domain, key)
+			newValue := valueConverter(addressPath, value)
 			if newValue == nil {
 				continue
 			}

migrations/account_type/migration.go

@@ -39,25 +39,26 @@ func (AccountTypeMigration) Name() string {
 
 // Migrate migrates `AuthAccount` and `PublicAccount` types inside `TypeValue`s,
 // to the account reference type (&Account).
-func (AccountTypeMigration) Migrate(value interpreter.Value) (newValue interpreter.Value) {
+func (AccountTypeMigration) Migrate(
+	_ interpreter.AddressPath,
+	value interpreter.Value,
+	_ *interpreter.Interpreter,
+) interpreter.Value {
 	switch value := value.(type) {
 	case interpreter.TypeValue:
 		convertedType := maybeConvertAccountType(value.Type)
-		if convertedType == nil {
-			return
+		if convertedType != nil {
+			return interpreter.NewTypeValue(nil, convertedType)
 		}
-		return interpreter.NewTypeValue(nil, convertedType)
 
 	case *interpreter.CapabilityValue:
 		convertedBorrowType := maybeConvertAccountType(value.BorrowType)
-		if convertedBorrowType == nil {
-			return
+		if convertedBorrowType != nil {
+			return interpreter.NewUnmeteredCapabilityValue(value.ID, value.Address, convertedBorrowType)
 		}
-		return interpreter.NewUnmeteredCapabilityValue(value.ID, value.Address, convertedBorrowType)
-
-	default:
-		return nil
 	}
+
+	return nil
 }
 
 func maybeConvertAccountType(staticType interpreter.StaticType) interpreter.StaticType {

migrations/account_type/migration_test.go

@@ -19,9 +19,9 @@
 package account_type
 
 import (
-	"fmt"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/onflow/atree"
@@ -37,34 +37,20 @@ import (
 var _ migrations.Reporter = &testReporter{}
 
 type testReporter struct {
-	migratedPaths map[common.Address]map[common.PathDomain]map[string]struct{}
+	migratedPaths map[interpreter.AddressPath]struct{}
 }
 
 func newTestReporter() *testReporter {
 	return &testReporter{
-		migratedPaths: map[common.Address]map[common.PathDomain]map[string]struct{}{},
+		migratedPaths: map[interpreter.AddressPath]struct{}{},
 	}
 }
 
 func (t *testReporter) Report(
-	address common.Address,
-	domain common.PathDomain,
-	identifier string,
+	addressPath interpreter.AddressPath,
 	_ string,
 ) {
-	migratedPathsInAddress, ok := t.migratedPaths[address]
-	if !ok {
-		migratedPathsInAddress = make(map[common.PathDomain]map[string]struct{})
-		t.migratedPaths[address] = migratedPathsInAddress
-	}
-
-	migratedPathsInDomain, ok := migratedPathsInAddress[domain]
-	if !ok {
-		migratedPathsInDomain = make(map[string]struct{})
-		migratedPathsInAddress[domain] = migratedPathsInDomain
-	}
-
-	migratedPathsInDomain[identifier] = struct{}{}
+	t.migratedPaths[addressPath] = struct{}{}
 }
 
 func TestTypeValueMigration(t *testing.T) {
@@ -356,22 +342,23 @@ func TestTypeValueMigration(t *testing.T) {
 		NewAccountTypeMigration(),
 	)
 
-	// Check reported migrated paths
-
-	migratedPathsInDomain := reporter.migratedPaths[account][pathDomain]
-	for path, test := range testCases {
-		t.Run(fmt.Sprintf("reported_%s", path), func(t *testing.T) {
-			test := test
-			path := path
+	migration.Commit()
 
-			t.Parallel()
+	// Check reported migrated paths
+	for identifier, test := range testCases {
+		addressPath := interpreter.AddressPath{
+			Address: account,
+			Path: interpreter.PathValue{
+				Domain:     pathDomain,
+				Identifier: identifier,
+			},
+		}
 
-			if test.expectedType == nil {
-				require.NotContains(t, migratedPathsInDomain, path)
-			} else {
-				require.Contains(t, migratedPathsInDomain, path)
-			}
-		})
+		if test.expectedType == nil {
+			assert.NotContains(t, reporter.migratedPaths, addressPath)
+		} else {
+			assert.Contains(t, reporter.migratedPaths, addressPath)
+		}
 	}
 
 	// Assert the migrated values.
@@ -665,6 +652,8 @@ func TestNestedTypeValueMigration(t *testing.T) {
 		NewAccountTypeMigration(),
 	)
 
+	migration.Commit()
+
 	// Assert: Traverse through the storage and see if the values are updated now.
 
 	storageMap := storage.GetStorageMap(account, pathDomain.Identifier(), false)
@@ -776,6 +765,8 @@ func TestValuesWithStaticTypeMigration(t *testing.T) {
 		NewAccountTypeMigration(),
 	)
 
+	migration.Commit()
+
 	// Assert: Traverse through the storage and see if the values are updated now.
 
 	storageMap := storage.GetStorageMap(account, pathDomain.Identifier(), false)

migrations/capcons/capabilitymigration.go

@@ -0,0 +1,116 @@
+/*
+ * 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 capcons
+
+import (
+	"github.com/onflow/cadence/migrations"
+	"github.com/onflow/cadence/runtime/common"
+	"github.com/onflow/cadence/runtime/errors"
+	"github.com/onflow/cadence/runtime/interpreter"
+	"github.com/onflow/cadence/runtime/sema"
+)
+
+type CapabilityMigrationReporter interface {
+	MigratedPathCapability(
+		accountAddress common.Address,
+		addressPath interpreter.AddressPath,
+		borrowType *interpreter.ReferenceStaticType,
+	)
+	MissingCapabilityID(
+		accountAddress common.Address,
+		addressPath interpreter.AddressPath,
+	)
+}
+
+// CapabilityMigration migrates all path capabilities to ID capabilities,
+// using the path to ID capability controller mapping generated by LinkMigration.
+type CapabilityMigration struct {
+	CapabilityIDs map[interpreter.AddressPath]interpreter.UInt64Value
+	Reporter      CapabilityMigrationReporter
+}
+
+var _ migrations.Migration = &CapabilityMigration{}
+
+func (*CapabilityMigration) Name() string {
+	return "CapabilityMigration"
+}
+
+var fullyEntitledAccountReferenceStaticType = interpreter.ConvertSemaReferenceTypeToStaticReferenceType(
+	nil,
+	sema.FullyEntitledAccountReferenceType,
+)
+
+// Migrate migrates a path capability to an ID capability in the given value.
+// If a value is returned, the value must be updated with the replacement in the parent.
+// If nil is returned, the value was not updated and no operation has to be performed.
+func (m *CapabilityMigration) Migrate(
+	addressPath interpreter.AddressPath,
+	value interpreter.Value,
+	_ *interpreter.Interpreter,
+) interpreter.Value {
+	reporter := m.Reporter
+
+	switch value := value.(type) {
+	case *interpreter.PathCapabilityValue: //nolint:staticcheck
+
+		// Migrate the path capability to an ID capability
+
+		oldCapability := value
+
+		capabilityAddressPath := oldCapability.AddressPath()
+		capabilityID, ok := m.CapabilityIDs[capabilityAddressPath]
+		if !ok {
+			if reporter != nil {
+				reporter.MissingCapabilityID(
+					addressPath.Address,
+					capabilityAddressPath,
+				)
+			}
+			break
+		}
+
+		newBorrowType, ok := oldCapability.BorrowType.(*interpreter.ReferenceStaticType)
+		if !ok {
+			panic(errors.NewUnreachableError())
+		}
+
+		// Convert the old AuthAccount type to the new fully-entitled Account type
+		if newBorrowType.ReferencedType == interpreter.PrimitiveStaticTypeAuthAccount { //nolint:staticcheck
+			newBorrowType = fullyEntitledAccountReferenceStaticType
+		}
+
+		newCapability := interpreter.NewUnmeteredCapabilityValue(
+			capabilityID,
+			oldCapability.Address,
+			newBorrowType,
+		)
+
+		if reporter != nil {
+			reporter.MigratedPathCapability(
+				addressPath.Address,
+				capabilityAddressPath,
+				newBorrowType,
+			)
+		}
+
+		return newCapability
+	}
+
+	return nil
+}

migrations/capcons/error.go

@@ -0,0 +1,55 @@
+/*
+ * 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 capcons
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/onflow/cadence/runtime/common"
+	"github.com/onflow/cadence/runtime/errors"
+	"github.com/onflow/cadence/runtime/interpreter"
+)
+
+// CyclicLinkError
+type CyclicLinkError struct {
+	Paths   []interpreter.PathValue
+	Address common.Address
+}
+
+var _ errors.UserError = CyclicLinkError{}
+
+func (CyclicLinkError) IsUserError() {}
+
+func (e CyclicLinkError) Error() string {
+	var builder strings.Builder
+	for i, path := range e.Paths {
+		if i > 0 {
+			builder.WriteString(" -> ")
+		}
+		builder.WriteString(path.String())
+	}
+	paths := builder.String()
+
+	return fmt.Sprintf(
+		"cyclic link in account %s: %s",
+		e.Address.ShortHexWithPrefix(),
+		paths,
+	)
+}