Rename valid field in public key to isValid

docs/language/accounts.mdx

@@ -167,7 +167,7 @@ struct AccountKey {
 struct PublicKey {
     let publicKey: [UInt8]
     let signatureAlgorithm: SignatureAlgorithm
-    let valid: Bool
+    let isValid: Bool
 
     /// Verifies a signature. Checks whether the signature was produced by signing
     /// the given tag and data, using this public key and the given hash algorithm

runtime/account_keys_test.go

@@ -271,7 +271,7 @@ var accountKeyA = &AccountKey{
 	PublicKey: &PublicKey{
 		PublicKey: []byte{1, 2, 3},
 		SignAlgo:  sema.SignatureAlgorithmECDSA_P256,
-		Valid:     false,
+		IsValid:   false,
 		Validated: true,
 	},
 	HashAlgo:  sema.HashAlgorithmSHA3_256,
@@ -284,7 +284,7 @@ var accountKeyB = &AccountKey{
 	PublicKey: &PublicKey{
 		PublicKey: []byte{4, 5, 6},
 		SignAlgo:  sema.SignatureAlgorithmECDSA_secp256k1,
-		Valid:     false,
+		IsValid:   false,
 		Validated: false,
 	},
 	HashAlgo:  sema.HashAlgorithmSHA3_256,
@@ -1049,7 +1049,7 @@ func TestPublicKey(t *testing.T) {
 		assert.Contains(t, err.Error(), "value of type `PublicKey` has no member `validate`")
 	})
 
-	t.Run("valid field", func(t *testing.T) {
+	t.Run("IsValid", func(t *testing.T) {
 		for _, validity := range []bool{true, false} {
 			script := `
 			pub fun main(): Bool {
@@ -1058,7 +1058,7 @@ func TestPublicKey(t *testing.T) {
 					signatureAlgorithm: SignatureAlgorithm.ECDSA_P256
 				)
 
-				return publicKey.valid
+				return publicKey.isValid
 			}
 		`
 			invoked := false
@@ -1080,7 +1080,7 @@ func TestPublicKey(t *testing.T) {
 		}
 	})
 
-	t.Run("valid - publicKey from host env", func(t *testing.T) {
+	t.Run("IsValid - publicKey from host env", func(t *testing.T) {
 
 		storage := newTestAccountKeyStorage()
 		storage.keys = append(storage.keys, accountKeyA, accountKeyB)
@@ -1091,7 +1091,7 @@ func TestPublicKey(t *testing.T) {
 					// Get a public key from host env
 					let acc = getAccount(0x02)
 					let publicKey = acc.keys.get(keyIndex: %d)!.publicKey
-					return publicKey.valid
+					return publicKey.isValid
 				}
 			`, index)
 
@@ -1110,11 +1110,11 @@ func TestPublicKey(t *testing.T) {
 			// If already validated, then the validation func shouldn't get re-invoked
 			assert.NotEqual(t, key.PublicKey.Validated, invoked)
 
-			// If validated, `isValid` should have the same value as `publicKey.Valid`.
+			// If validated, `isValid` should have the same value as `publicKey.IsValid`.
 			// Otherwise, it should give the value returned by the `validate()` func.
 			isValid := validateMethodReturnValue
 			if key.PublicKey.Validated {
-				isValid = key.PublicKey.Valid
+				isValid = key.PublicKey.IsValid
 			}
 
 			assert.Equal(t, cadence.Bool(isValid), value)

runtime/interpreter/value.go

@@ -8172,8 +8172,8 @@ func NewPublicKeyValue(
 		Functions:           functions,
 	}
 
-	// Validate the public key, and initialize 'valid' field.
-	publicKeyValue.Fields.Set(sema.PublicKeyValidField, validationFunction(publicKeyValue))
+	// Validate the public key, and initialize 'isValid' field.
+	publicKeyValue.Fields.Set(sema.PublicKeyIsValidField, validationFunction(publicKeyValue))
 
 	return publicKeyValue
 

runtime/runtime.go

@@ -2519,15 +2519,15 @@ func NewPublicKeyFromValue(publicKey *interpreter.CompositeValue) *PublicKey {
 
 	// `valid` and `validated` fields
 	var valid, validated bool
-	validField, validated := publicKey.Fields.Get(sema.PublicKeyValidField)
+	validField, validated := publicKey.Fields.Get(sema.PublicKeyIsValidField)
 	if validated {
 		valid = bool(validField.(interpreter.BoolValue))
 	}
 
 	return &PublicKey{
 		PublicKey: byteArray,
 		SignAlgo:  SignatureAlgorithm(signAlgoRawValue.ToInt()),
-		Valid:     valid,
+		IsValid:   valid,
 		Validated: validated,
 	}
 }
@@ -2572,7 +2572,7 @@ func newPublicKeyValidationFunction(
 	return func(publicKeyValue *interpreter.CompositeValue) interpreter.BoolValue {
 		// If the public key is already validated, avoid re-validating, and return the cached result.
 		if publicKey.Validated {
-			return interpreter.BoolValue(publicKey.Valid)
+			return interpreter.BoolValue(publicKey.IsValid)
 		}
 
 		return validatePublicKey(publicKeyValue, runtimeInterface)

runtime/sema/type.go

@@ -5478,7 +5478,7 @@ var AccountKeyType = func() *CompositeType {
 const PublicKeyTypeName = "PublicKey"
 const PublicKeyPublicKeyField = "publicKey"
 const PublicKeySignAlgoField = "signatureAlgorithm"
-const PublicKeyValidField = "valid"
+const PublicKeyIsValidField = "isValid"
 const PublicKeyVerifyFunction = "verify"
 
 const publicKeyKeyFieldDocString = `
@@ -5489,7 +5489,7 @@ const publicKeySignAlgoFieldDocString = `
 The signature algorithm to be used with the key
 `
 
-const publicKeyValidFieldDocString = `
+const publicKeyIsValidFieldDocString = `
 Flag indicating whether the key is valid
 `
 
@@ -5521,9 +5521,9 @@ var PublicKeyType = func() *CompositeType {
 		),
 		NewPublicConstantFieldMember(
 			publicKeyType,
-			PublicKeyValidField,
+			PublicKeyIsValidField,
 			BoolType,
-			publicKeyValidFieldDocString,
+			publicKeyIsValidFieldDocString,
 		),
 		NewPublicFunctionMember(
 			publicKeyType,

runtime/types.go

@@ -78,6 +78,6 @@ type AccountKey struct {
 type PublicKey struct {
 	PublicKey []byte
 	SignAlgo  SignatureAlgorithm
-	Valid     bool
+	IsValid   bool
 	Validated bool
 }