feat(v2): Accept Into<Address> in address = <expr>

Author: jamie-osec

lang-v2/derive/src/parse.rs

@@ -1334,8 +1334,14 @@ pub fn parse_field(
         };
         constraints.push(quote! {
             {
-                // Bind the expected address to a local for `address_eq`.
-                let __expected: anchor_lang_v2::Address = #addr;
+                // Accept any `T: Into<Address>` on the RHS — `Address`
+                // itself goes through the blanket `From<T> for T`,
+                // `&Address`, `[u8; 32]`, and any user-defined wrapper
+                // with an `Into<Address>` impl all flow through the
+                // same conversion. Still binds to a local first so
+                // `address_eq` sees a stable reference.
+                let __expected: anchor_lang_v2::Address =
+                    core::convert::Into::into(#addr);
                 if !anchor_lang_v2::address_eq(#field_name.account().address(), &__expected) {
                     return Err(#err);
                 }

tests-v2/programs/constraints/src/lib.rs

@@ -167,6 +167,22 @@ pub mod constraints {
     pub fn check_multiple_constraints(_ctx: &mut Context<CheckMultipleConstraints>) -> Result<()> {
         Ok(())
     }
+
+    /// `address = <expr>` accepting an `Into<Address>` RHS. The fixture
+    /// uses `[u8; 32]` (which has `From<[u8; 32]> for Address`) and a
+    /// helper returning `&Address` (`From<&Address> for Address`) — both
+    /// would have failed the prior `let __expected: Address = #expr`
+    /// type-ascription path.
+    #[discrim = 17]
+    pub fn check_address_into(_ctx: &mut Context<CheckAddressInto>) -> Result<()> {
+        Ok(())
+    }
+
+    /// Same but feeding `address` from a function returning `&Address`.
+    #[discrim = 18]
+    pub fn check_address_into_ref(_ctx: &mut Context<CheckAddressIntoRef>) -> Result<()> {
+        Ok(())
+    }
 }
 
 // -- Accounts structs --------------------------------------------------------
@@ -309,11 +325,36 @@ pub struct CheckSigner {
     pub user: UncheckedAccount,
 }
 
+/// `[u8; 32]` form of `PINNED_ADDRESS`. Used in the `Into<Address>` test
+/// fixture so the RHS goes through `From<[u8; 32]> for Address` rather
+/// than the trivial identity coercion.
+pub const PINNED_BYTES: [u8; 32] = PINNED_ADDRESS.to_bytes();
+
+/// Helper returning `&Address`. Exercises `From<&Address> for Address` on
+/// the constraint RHS — different impl from the `[u8; 32]` form.
+pub fn pinned_address_ref() -> &'static Address {
+    &PINNED_ADDRESS
+}
+
 // 16. Multiple `constraint`s on a single field, mixing both spellings.
 //
 // Order of evaluation matters: the first failing check is the one whose
 // error surfaces. The integration tests trip each entry in turn to
 // confirm that.
+// 17. address = <[u8; 32] expr> — RHS converts via `Into<Address>`.
+#[derive(Accounts)]
+pub struct CheckAddressInto {
+    #[account(address = PINNED_BYTES)]
+    pub pinned: UncheckedAccount,
+}
+
+// 18. address = <&Address expr> — RHS converts via `Into<Address>`.
+#[derive(Accounts)]
+pub struct CheckAddressIntoRef {
+    #[account(address = pinned_address_ref())]
+    pub pinned: UncheckedAccount,
+}
+
 #[derive(Accounts)]
 pub struct CheckMultipleConstraints {
     pub a: UncheckedAccount,

tests-v2/tests/constraints.rs

@@ -703,6 +703,66 @@ fn signer_on_unchecked_ok_when_signed() {
     .expect("signed");
 }
 
+// ---- 17/18. address = <Into<Address> expr> -------------------------------
+//
+// Asserts the constraint accepts any `Into<Address>` RHS, not just an
+// `Address` literal. Two fixtures cover the two non-trivial impls in
+// `solana-address`:
+//   - `From<[u8; 32]> for Address` — `address = SOME_BYTES`
+//   - `From<&Address>  for Address` — `address = some_fn_returning_ref()`
+
+#[test]
+fn address_into_from_byte_array_match_ok() {
+    let (mut svm, payer, _) = setup();
+    call(
+        &mut svm,
+        &payer,
+        17,
+        vec![AccountMeta::new_readonly(pinned_address(), false)],
+        &[],
+    )
+    .expect("address from [u8; 32]");
+}
+
+#[test]
+fn address_into_from_byte_array_mismatch_rejected() {
+    let (mut svm, payer, _) = setup();
+    let result = call_raw(
+        &mut svm,
+        &payer,
+        17,
+        vec![AccountMeta::new_readonly(Pubkey::new_unique(), false)],
+        &[],
+    );
+    assert_err_contains(&result, "InvalidAccountData");
+}
+
+#[test]
+fn address_into_from_ref_match_ok() {
+    let (mut svm, payer, _) = setup();
+    call(
+        &mut svm,
+        &payer,
+        18,
+        vec![AccountMeta::new_readonly(pinned_address(), false)],
+        &[],
+    )
+    .expect("address from &Address");
+}
+
+#[test]
+fn address_into_from_ref_mismatch_rejected() {
+    let (mut svm, payer, _) = setup();
+    let result = call_raw(
+        &mut svm,
+        &payer,
+        18,
+        vec![AccountMeta::new_readonly(Pubkey::new_unique(), false)],
+        &[],
+    );
+    assert_err_contains(&result, "InvalidAccountData");
+}
+
 // ---- 16. Multiple constraints on a single field --------------------------
 //
 // `CheckMultipleConstraints` carries three `constraint`s on its `c` field,