idl: Exclude external accounts (solana-foundation#4197)

Author: acheroncrypto

CHANGELOG.md

@@ -37,6 +37,7 @@ The minor version will be incremented upon a breaking change and the patch versi
 - lang: Rename `utils` module of `declare_program!` to `parsers` ([#4151](https://github.com/solana-foundation/anchor/pull/4151)).
 - lang: Remove the `interface-instructions` feature and the `#[interface]` attribute ([#4156](https://github.com/solana-foundation/anchor/pull/4156)).
 - cli: Remove the `login` command ([#4182](https://github.com/solana-foundation/anchor/pull/4182)).
+- idl: Exclude external accounts ([#4197](https://github.com/solana-foundation/anchor/pull/4197)).
 
 ## [0.32.1] - 2025-10-09
 

lang/syn/src/idl/accounts.rs

@@ -43,7 +43,7 @@ pub fn gen_idl_build_impl_accounts_struct(accounts: &AccountsStruct) -> TokenStr
                     (quote! { None }, quote! { None }, quote! { vec![] })
                 };
 
-                let acc_type_path = match &acc.ty {
+                let defined = match &acc.ty {
                     Ty::Account(ty)
                     // Skip `UpgradeableLoaderState` type for now until `bincode` serialization
                     // is supported.
@@ -57,11 +57,21 @@ pub fn gen_idl_build_impl_accounts_struct(accounts: &AccountsStruct) -> TokenStr
                             .to_string()
                             .contains("UpgradeableLoaderState") =>
                     {
-                        Some(&ty.account_type_path)
+                        let defined = &ty.account_type_path;
+                        Some((defined, quote! { <#defined>::owner() == crate::ID }))
                     }
-                    Ty::LazyAccount(ty) => Some(&ty.account_type_path),
-                    Ty::AccountLoader(ty) => Some(&ty.account_type_path),
-                    Ty::InterfaceAccount(ty) => Some(&ty.account_type_path),
+                    Ty::LazyAccount(ty) => {
+                        let defined = &ty.account_type_path;
+                        Some((defined, quote! { <#defined>::owner() == crate::ID }))
+                    },
+                    Ty::AccountLoader(ty) => {
+                        let defined = &ty.account_type_path;
+                        Some((defined, quote! { <#defined>::owner() == crate::ID }))
+                    },
+                    Ty::InterfaceAccount(ty) => {
+                        let defined = &ty.account_type_path;
+                        Some((defined, quote! { <#defined>::owners().contains(&crate::ID) }))
+                    },
                     _ => None,
                 };
 
@@ -78,7 +88,7 @@ pub fn gen_idl_build_impl_accounts_struct(accounts: &AccountsStruct) -> TokenStr
                             relations: #relations,
                         })
                     },
-                    acc_type_path,
+                    defined,
                 )
             }
             AccountField::CompositeField(comp_f) => {
@@ -116,7 +126,10 @@ pub fn gen_idl_build_impl_accounts_struct(accounts: &AccountsStruct) -> TokenStr
             }
         })
         .unzip::<_, _, Vec<_>, Vec<_>>();
-    let defined = defined.into_iter().flatten().collect::<Vec<_>>();
+    let (defined, is_owner) = defined
+        .into_iter()
+        .flatten()
+        .unzip::<_, _, Vec<_>, Vec<_>>();
 
     quote! {
         impl #impl_generics #ident #ty_generics #where_clause {
@@ -126,11 +139,14 @@ pub fn gen_idl_build_impl_accounts_struct(accounts: &AccountsStruct) -> TokenStr
             ) -> Vec<#idl::IdlInstructionAccountItem> {
                 #(
                     if let Some(ty) = <#defined>::create_type() {
-                        let account = #idl::IdlAccount {
-                            name: ty.name.clone(),
-                            discriminator: <#defined>::DISCRIMINATOR.into(),
-                        };
-                        accounts.insert(account.name.clone(), account);
+                        if #is_owner {
+                            let account = #idl::IdlAccount {
+                                name: ty.name.clone(),
+                                discriminator: <#defined>::DISCRIMINATOR.into(),
+                            };
+                            accounts.insert(account.name.clone(), account);
+                        }
+
                         types.insert(ty.name.clone(), ty);
                         <#defined>::insert_types(types);
                     }

tests/idl/idls/idl.json

@@ -596,6 +596,9 @@
             }
           ]
         },
+        {
+          "name": "external"
+        },
         {
           "name": "token_account"
         },
@@ -1356,6 +1359,13 @@
         ]
       }
     },
+    {
+      "name": "MyAccount",
+      "type": {
+        "kind": "struct",
+        "fields": []
+      }
+    },
     {
       "name": "MyStruct",
       "type": {

tests/idl/programs/external/src/lib.rs

@@ -6,11 +6,19 @@ declare_id!("Externa1111111111111111111111111111111111111");
 pub mod external {
     use super::*;
 
-    pub fn initialize(_ctx: Context<Initialize>) -> Result<()> {
+    pub fn test_compilation(_ctx: Context<TestCompilation>) -> Result<()> {
         Ok(())
     }
 }
 
+#[derive(Accounts)]
+pub struct TestCompilation<'info> {
+    account: Account<'info, MyAccount>,
+}
+
+#[account]
+pub struct MyAccount {}
+
 #[derive(AnchorSerialize, AnchorDeserialize, Clone)]
 pub struct MyStruct {
     some_field: u8,
@@ -22,10 +30,3 @@ pub enum MyEnum {
     Named { name: String },
     Tuple(String),
 }
-
-pub struct NonBorshStruct {
-    pub data: i32,
-}
-
-#[derive(Accounts)]
-pub struct Initialize {}

tests/idl/programs/idl/src/lib.rs

@@ -541,6 +541,8 @@ pub struct TestCompilation<'info> {
 
     composite: Composite<'info>,
 
+    external: Account<'info, external::MyAccount>,
+
     token_account: Account<'info, token::TokenAccount>,
     mint_account: Account<'info, token::Mint>,
     token_interface_account: InterfaceAccount<'info, token_interface::TokenAccount>,

tests/idl/tests/idl.ts

@@ -2,6 +2,7 @@ import * as anchor from "@anchor-lang/core";
 import BN from "bn.js";
 import { assert } from "chai";
 
+import type { External } from "../target/types/external";
 import type { Idl } from "../target/types/idl";
 
 describe("IDL", () => {
@@ -547,7 +548,7 @@ describe("IDL", () => {
         program.idl.accounts.find((acc) => acc.name === "zcAccount")
       );
       const zcAccount = program.idl.types.find((ty) => ty.name === "zcAccount");
-      if (!zcAccount) throw new Error("Zero copy accout not found");
+      if (!zcAccount) throw new Error("`zcAccount` not found");
 
       assert.strictEqual(zcAccount.serialization, "bytemuck");
       assert.deepEqual(zcAccount.repr, { kind: "c" });
@@ -560,13 +561,28 @@ describe("IDL", () => {
       const zcUnsafeAccount = program.idl.types.find(
         (ty) => ty.name === "zcUnsafeAccount"
       );
-      if (!zcUnsafeAccount)
-        throw new Error("Unsafe zero copy accout not found");
+      if (!zcUnsafeAccount) throw new Error("`zcUnsafeAccount` not found");
 
       assert.strictEqual(zcUnsafeAccount.serialization, "bytemuckunsafe");
       assert.deepEqual(zcUnsafeAccount.repr, { kind: "rust", packed: true });
     });
 
+    it("Does not include external accounts", () => {
+      const external: anchor.Program<External> = anchor.workspace.external;
+      assert.isDefined(
+        external.idl.accounts.find((acc) => acc.name === "myAccount")
+      );
+      assert.isDefined(
+        external.idl.types.find((ty) => ty.name === "myAccount")
+      );
+
+      assert.isUndefined(
+        // @ts-expect-error
+        program.idl.accounts.find((acc) => acc.name === "myAccount")
+      );
+      assert.isDefined(program.idl.types.find((ty) => ty.name === "myAccount"));
+    });
+
     it("Includes constants marked with `#[constant]`", () => {
       const checkDefined = (
         cb: (constant: typeof program["idl"]["constants"][number]) => boolean