Add address field to capabilities

runtime/interpreter/value.go

@@ -7070,6 +7070,9 @@ func (v CapabilityValue) GetMember(inter *Interpreter, _ func() LocationRange, n
 		}
 		return inter.capabilityCheckFunction(v.Address, v.Path, borrowType)
 
+
+	case "address":
+		return v.Address
 	}
 
 	return nil

runtime/sema/type.go

@@ -6527,6 +6527,10 @@ const capabilityTypeCheckFunctionDocString = `
 Returns true if the capability currently targets an object that satisfies the given type, i.e. could be borrowed using the given type
 `
 
+const addressTypeCheckFunctionDocString = `
+Returns the address for a capability
+`
+
 func (t *CapabilityType) GetMembers() map[string]MemberResolver {
 	return withBuiltinMembers(t, map[string]MemberResolver{
 		"borrow": {
@@ -6551,6 +6555,17 @@ func (t *CapabilityType) GetMembers() map[string]MemberResolver {
 				)
 			},
 		},
+		"address": {
+			Kind: common.DeclarationKindField,
+			Resolve: func(identifier string, _ ast.Range, _ func(error)) *Member {
+				return NewPublicConstantFieldMember(
+					t,
+					identifier,
+					&AddressType{},
+					addressTypeCheckFunctionDocString,
+				)
+			},
+		},
 	})
 }
 

runtime/tests/checker/capability_test.go

@@ -434,3 +434,20 @@ func TestCheckCapability_check(t *testing.T) {
 		})
 	})
 }
+
+func TestCheckCapability_address(t *testing.T) {
+
+	t.Parallel()
+	t.Run("check address", func(t *testing.T) {
+		checker, err := ParseAndCheckWithPanic(t,
+			`		  			
+				let capability: Capability = panic("")
+				let addr = capability.address
+			`,
+		)
+		require.NoError(t, err)
+
+		addrType := RequireGlobalValue(t, checker.Elaboration, "addr")
+		require.Equal(t, &sema.AddressType{}, addrType)
+	})
+}

runtime/tests/interpreter/capability_test.go

@@ -657,3 +657,52 @@ func TestInterpretCapability_check(t *testing.T) {
 		})
 	})
 }
+
+func TestInterpretCapability_address(t *testing.T) {
+
+	t.Parallel()
+
+	t.Run("check address", func(t *testing.T) {
+
+		t.Parallel()
+
+		inter, _ := testAccount(
+			t,
+			true,
+			`
+				fun single(): Address {
+					return account.getCapability(/public/single).address
+				}
+
+				fun double(): Address {
+					return account.getCapability(/public/double).address
+				}
+
+				fun nonExistent() : Address {
+					return account.getCapability(/public/nonExistent).address
+				}				
+			`,
+		)
+
+		t.Run("single", func(t *testing.T) {
+			value, err := inter.Invoke("single")
+			require.NoError(t, err)
+
+			require.IsType(t, interpreter.AddressValue{}, value)
+		})
+
+		t.Run("double", func(t *testing.T) {
+			value, err := inter.Invoke("double")
+			require.NoError(t, err)
+
+			require.IsType(t, interpreter.AddressValue{}, value)
+		})
+
+		t.Run("nonExistent", func(t *testing.T) {
+			value, err := inter.Invoke("nonExistent")
+			require.NoError(t, err)
+
+			require.IsType(t, interpreter.AddressValue{}, value)
+		})
+	})
+}