Sync Stable Cadence feature branch

encoding/json/decode.go

@@ -303,7 +303,7 @@ func (d *Decoder) decodeAddress(valueJSON any) cadence.Address {
 	actualPrefix := v[:prefixLength]
 	if actualPrefix != addressPrefix {
 		panic(errors.NewDefaultUserError(
-			"invalid address prefix: expected `%s`, got `%s`",
+			"invalid address prefix: (shown as hex) expected %x, got %x", // hex encoding user input (actualPrefix) avoids invalid UTF-8.
 			addressPrefix,
 			actualPrefix,
 		))

encoding/json/encode.go

@@ -849,55 +849,55 @@ func prepareType(typ cadence.Type, results typePreparationResults) jsonValue {
 		return jsonNominalType{
 			Kind:         "Struct",
 			Type:         "",
-			TypeID:       typeId(typ.Location, typ.QualifiedIdentifier),
+			TypeID:       string(common.NewTypeIDFromQualifiedName(nil, typ.Location, typ.QualifiedIdentifier)),
 			Fields:       prepareFields(typ.Fields, results),
 			Initializers: prepareInitializers(typ.Initializers, results),
 		}
 	case *cadence.ResourceType:
 		return jsonNominalType{
 			Kind:         "Resource",
 			Type:         "",
-			TypeID:       typeId(typ.Location, typ.QualifiedIdentifier),
+			TypeID:       string(common.NewTypeIDFromQualifiedName(nil, typ.Location, typ.QualifiedIdentifier)),
 			Fields:       prepareFields(typ.Fields, results),
 			Initializers: prepareInitializers(typ.Initializers, results),
 		}
 	case *cadence.EventType:
 		return jsonNominalType{
 			Kind:         "Event",
 			Type:         "",
-			TypeID:       typeId(typ.Location, typ.QualifiedIdentifier),
+			TypeID:       string(common.NewTypeIDFromQualifiedName(nil, typ.Location, typ.QualifiedIdentifier)),
 			Fields:       prepareFields(typ.Fields, results),
 			Initializers: [][]jsonParameterType{prepareParameters(typ.Initializer, results)},
 		}
 	case *cadence.ContractType:
 		return jsonNominalType{
 			Kind:         "Contract",
 			Type:         "",
-			TypeID:       typeId(typ.Location, typ.QualifiedIdentifier),
+			TypeID:       string(common.NewTypeIDFromQualifiedName(nil, typ.Location, typ.QualifiedIdentifier)),
 			Fields:       prepareFields(typ.Fields, results),
 			Initializers: prepareInitializers(typ.Initializers, results),
 		}
 	case *cadence.StructInterfaceType:
 		return jsonNominalType{
 			Kind:         "StructInterface",
 			Type:         "",
-			TypeID:       typeId(typ.Location, typ.QualifiedIdentifier),
+			TypeID:       string(common.NewTypeIDFromQualifiedName(nil, typ.Location, typ.QualifiedIdentifier)),
 			Fields:       prepareFields(typ.Fields, results),
 			Initializers: prepareInitializers(typ.Initializers, results),
 		}
 	case *cadence.ResourceInterfaceType:
 		return jsonNominalType{
 			Kind:         "ResourceInterface",
 			Type:         "",
-			TypeID:       typeId(typ.Location, typ.QualifiedIdentifier),
+			TypeID:       string(common.NewTypeIDFromQualifiedName(nil, typ.Location, typ.QualifiedIdentifier)),
 			Fields:       prepareFields(typ.Fields, results),
 			Initializers: prepareInitializers(typ.Initializers, results),
 		}
 	case *cadence.ContractInterfaceType:
 		return jsonNominalType{
 			Kind:         "ContractInterface",
 			Type:         "",
-			TypeID:       typeId(typ.Location, typ.QualifiedIdentifier),
+			TypeID:       string(common.NewTypeIDFromQualifiedName(nil, typ.Location, typ.QualifiedIdentifier)),
 			Fields:       prepareFields(typ.Fields, results),
 			Initializers: prepareInitializers(typ.Initializers, results),
 		}
@@ -937,7 +937,7 @@ func prepareType(typ cadence.Type, results typePreparationResults) jsonValue {
 	case *cadence.EnumType:
 		return jsonNominalType{
 			Kind:         "Enum",
-			TypeID:       typeId(typ.Location, typ.QualifiedIdentifier),
+			TypeID:       string(common.NewTypeIDFromQualifiedName(nil, typ.Location, typ.QualifiedIdentifier)),
 			Fields:       prepareFields(typ.Fields, results),
 			Initializers: prepareInitializers(typ.Initializers, results),
 			Type:         prepareType(typ.RawType, results),
@@ -1030,11 +1030,3 @@ func encodeUFix64(v uint64) string {
 		fraction,
 	)
 }
-
-func typeId(location common.Location, identifier string) string {
-	if location == nil {
-		return identifier
-	}
-
-	return string(location.TypeID(nil, identifier))
-}

encoding/json/encoding_test.go

@@ -197,6 +197,16 @@ func TestEncodeAddress(t *testing.T) {
 	)
 }
 
+func TestDecodeInvalidAddress(t *testing.T) {
+
+	t.Parallel()
+
+	msg := `{"type":"Address","value":"000000000102030405"}`
+
+	_, err := json.Decode(nil, []byte(msg))
+	require.ErrorContains(t, err, "invalid address prefix: (shown as hex) expected 3078, got 3030")
+}
+
 func TestEncodeInt(t *testing.T) {
 
 	t.Parallel()

meetings/2023-08-15.md

@@ -0,0 +1,167 @@
+# Aug 14th, 2023
+
+## Ways to contribute
+
+* Participate in [FLIP (Flow Improvement Proposal) discussions](https://github.com/onflow/flips)
+* Contribute to Cadence implementation: ➡️[GitHub issues](https://github.com/onflow/cadence/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22Good+First+Issue%22)
+* Contribute Cadence tools: ➡️[GitHub issues](https://github.com/onflow/cadence-tools/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22Good+First+Issue%22)
+
+## FLIPs
+
+### Interface Conformance Improvements
+
+* FLIP: [https://github.com/onflow/flips/pull/83](https://github.com/onflow/flips/pull/83)
+* Status:
+    * FLIP approved and merged 🎉
+
+### Remove pub, pub(set) and priv
+
+* FLIP: [https://github.com/onflow/flips/pull/84](https://github.com/onflow/flips/pull/84)
+* Status:
+    * FLIP approved and merged 🎉
+
+### Emit events from function conditions, allow concrete events in interfaces
+
+* FLIP: [https://github.com/onflow/flips/pull/111](https://github.com/onflow/flips/pull/111)
+* Status:
+    * FLIP approved and merged 🎉
+
+### Remove restricted types, interface set types
+
+* FLIP: [https://github.com/onflow/flips/pull/85](https://github.com/onflow/flips/pull/85)
+* Status:
+    * FLIP approved and merged 🎉
+
+### Add Range type
+
+* FLIP: [https://github.com/onflow/flips/pull/96](https://github.com/onflow/flips/pull/96)
+* Status:
+    * FLIP approved and merged 🎉
+
+### External Mutability
+
+* Vision: [https://github.com/onflow/flips/pull/97](https://github.com/onflow/flips/pull/97)
+* FLIPs:
+    * **Change member access semantic**
+        * FLIP: [https://github.com/onflow/flips/pull/89](https://github.com/onflow/flips/pull/89)
+        * Status:
+            * FLIP approved and merged 🎉
+    * **Improve entitlement mappings**
+        * FLIP: [https://github.com/onflow/flips/pull/94](https://github.com/onflow/flips/pull/94)
+        * Status:
+            * FLIP approved and merged 🎉
+    * **Introduce built-in mutability entitlements**
+        * FLIP: [https://github.com/onflow/flips/pull/86](https://github.com/onflow/flips/pull/86)
+        * Status:
+            * Positive sentiment
+            * No new feedback in last few weeks
+            * Implementation and documentation ready
+            * Last conversation was about naming convention for entitlements
+        * Open problems:
+            * None
+        * Next steps:
+            * **Approved**
+
+### Account Type
+
+* FLIP: [https://github.com/onflow/flips/pull/92](https://github.com/onflow/flips/pull/92)
+* Status:
+    * Positive sentiment
+    * No new feedback in last few weeks
+    * Implementation ready
+* Open problems:
+    * None
+* Next steps:
+    * **Approved**
+
+### Remove nested type requirements
+
+* FLIP: [https://github.com/onflow/flips/pull/118](https://github.com/onflow/flips/pull/118)
+* Overview:
+    * Remove nested type requirements
+    * Allow declaration of events in interfaces as concrete types (used in core contracts)
+* Status:
+    * Positive sentiment
+    * No new feedback in last few weeks
+    * Implementation ready (2 PRs)
+* Open problems:
+    * None
+* Next steps:
+    * **Approved**
+
+### Random function
+
+* FLIP: [https://github.com/onflow/flips/pull/118](https://github.com/onflow/flips/pull/118)
+* Overview:
+    * Rename unsafeRandom to random, underlying implementation has been secured using Flow protocol native random beacon
+    * Update the interface to a safer and more convenient one (generalized types and a modulo parameter)
+    * Rollout: add random, deprecate unsafeRandom, finally remove in SC release
+* Status:
+    * Positive sentiment for random
+* Open problems:
+    * Behavior in scripts
+        * Should not panic
+        * Several options
+    * Naming:
+        * Potential for misuse by developers. Unsafe → safe renaming might be confusing
+        * Maybe addressed by commit-reveal scheme FLIP: [https://github.com/onflow/flips/pull/123](https://github.com/onflow/flips/pull/123)
+* Next steps:
+    * Determine script behavior, maybe propose in separate FLIP
+    * Schedule breakout session
+        * Deniz
+        * You? Leave a comment!
+* Feedback:
+    * Just switch unsafeRandom to safe random generator for now
+    * Different name/indicator to prevent misuse?
+        * Trigger developers to check documentation, see/use commit-reveal scheme design pattern to use returned safe random properly
+        * `random(iReadTheDocs: Bool)`
+    * Our bar is very high, other systems isn't
+
+### Commit-reveal scheme for non-reverted randomness
+
+* FLIP: [https://github.com/onflow/flips/pull/123](https://github.com/onflow/flips/pull/123)
+* Overview:
+    * Provide a safe pattern to address transaction abortion after a random is revealed
+    * Commit to block
+    * In the future, query history of past randoms
+    * Use past, committed seed for new random
+* Status:
+    * Positive sentiment
+    * Waiting for feedback
+* Open problems:
+    * None
+* Next steps:
+    * Gather more feedback
+
+### Remove custom destructors
+
+* FLIP:  [https://github.com/onflow/flips/pull/131](https://github.com/onflow/flips/pull/131)
+* Overview:
+    * Proposal to address inability for users to destroy resources they own
+    * One of the discussed options (others: try/catch, etc.)
+    * Originated from attachments feature (attachment might prevent destruction of whole resource)
+    * Remove destroy
+    * Allows users to always destroy resources
+* Status:
+    * New
+    * Very much an RFC!
+* Open problems:
+    * Philosophical question (sending to "burner account")
+    * Existing code / applications
+    * "Migration" path for use-cases like FT total supply
+* Next steps:
+    * Discuss
+    * Breakout session
+        * You? Leave a comment!
+    * Publish resource destruction options document, add to FLIP
+* Feedback:
+    * Provide details on impact on applications, e.g. core contracts like FT/NFT
+        * Chicken-and-egg problem: need more data on how feature is used, can then figure out if/what alternative is
+    * Even if exploit vector isn’t used today, it should be addressed/prevented
+    * If important use-case exists, also not worth it to remove
+    * Emitting events could maybe be allowed
+    * Given impact, reach out to more developers / gather more feedback
+
+## Related FLIPs / forum discussions
+
+* [https://forum.onflow.org/t/storage-fees-improvements-and-few-random-ideas-on-the-way/5104](https://forum.onflow.org/t/storage-fees-improvements-and-few-random-ideas-on-the-way/5104)

runtime/capabilitycontrollers_test.go

@@ -1898,6 +1898,43 @@ func TestRuntimeCapabilityControllers(t *testing.T) {
 
 		t.Parallel()
 
+		t.Run("capability", func(t *testing.T) {
+			t.Parallel()
+
+			err, _ := test(
+				// language=cadence
+				`
+                  import Test from 0x1
+
+                  transaction {
+                      prepare(signer: AuthAccount) {
+                          let storagePath = /storage/r
+                          let resourceID = 42
+
+						  // Arrange
+						  Test.createAndSaveR(id: resourceID, storagePath: storagePath)
+
+                          let issuedCap: Capability<&Test.R> =
+                              signer.capabilities.storage.issue<&Test.R>(storagePath)
+                          let controller1: &StorageCapabilityController =
+                              signer.capabilities.storage.getController(byCapabilityID: issuedCap.id)!
+                          let controller2: &StorageCapabilityController =
+                              signer.capabilities.storage.getController(byCapabilityID: issuedCap.id)!
+
+                          // Act
+                          let controller1Cap = controller1.capability
+                          let controller2Cap = controller2.capability
+
+                          // Assert
+                          assert(controller1Cap.borrow<&Test.R>() != nil)
+                          assert(controller2Cap.borrow<&Test.R>() != nil)
+                      }
+                  }
+                `,
+			)
+			require.NoError(t, err)
+		})
+
 		t.Run("tag", func(t *testing.T) {
 			t.Parallel()
 
@@ -2379,6 +2416,39 @@ func TestRuntimeCapabilityControllers(t *testing.T) {
 
 		t.Parallel()
 
+		t.Run("capability", func(t *testing.T) {
+			t.Parallel()
+
+			err, _ := test(
+				// language=cadence
+				`
+                  import Test from 0x1
+
+                  transaction {
+                      prepare(signer: AuthAccount) {
+
+						  // Arrange
+                          let issuedCap: Capability<&AuthAccount> =
+                              signer.capabilities.account.issue<&AuthAccount>()
+                          let controller1: &AccountCapabilityController =
+                              signer.capabilities.account.getController(byCapabilityID: issuedCap.id)!
+                          let controller2: &AccountCapabilityController =
+                              signer.capabilities.account.getController(byCapabilityID: issuedCap.id)!
+
+                          // Act
+                          let controller1Cap = controller1.capability
+                          let controller2Cap = controller2.capability
+
+                          // Assert
+                          assert(controller1Cap.borrow<&AuthAccount>() != nil)
+                          assert(controller2Cap.borrow<&AuthAccount>() != nil)
+                      }
+                  }
+                `,
+			)
+			require.NoError(t, err)
+		})
+
 		t.Run("tag", func(t *testing.T) {
 			t.Parallel()
 

runtime/cmd/cmd.go

@@ -241,11 +241,12 @@ func (*StandardLibraryHandler) ProgramLog(message string, locationRange interpre
 	return nil
 }
 
-func (h *StandardLibraryHandler) UnsafeRandom() (uint64, error) {
+func (h *StandardLibraryHandler) ReadRandom(p []byte) error {
 	if h.rand == nil {
 		h.rand = rand.New(rand.NewSource(time.Now().UnixNano()))
 	}
-	return h.rand.Uint64(), nil
+	h.rand.Read(p)
+	return nil
 }
 
 func (*StandardLibraryHandler) GetBlockAtHeight(_ uint64) (block stdlib.Block, exists bool, err error) {

runtime/convertTypes.go

@@ -547,19 +547,18 @@ func exportCapabilityType(
 }
 
 func importInterfaceType(memoryGauge common.MemoryGauge, t cadence.InterfaceType) interpreter.InterfaceStaticType {
-	return interpreter.NewInterfaceStaticType(
+	return interpreter.NewInterfaceStaticTypeComputeTypeID(
 		memoryGauge,
 		t.InterfaceTypeLocation(),
 		t.InterfaceTypeQualifiedIdentifier(),
 	)
 }
 
 func importCompositeType(memoryGauge common.MemoryGauge, t cadence.CompositeType) interpreter.CompositeStaticType {
-	return interpreter.NewCompositeStaticType(
+	return interpreter.NewCompositeStaticTypeComputeTypeID(
 		memoryGauge,
 		t.CompositeTypeLocation(),
 		t.CompositeTypeQualifiedIdentifier(),
-		"", // intentionally empty
 	)
 }