Feature: CPI Events API

lang/Cargo.toml

@@ -13,6 +13,7 @@ allow-missing-optionals = ["anchor-derive-accounts/allow-missing-optionals"]
 init-if-needed = ["anchor-derive-accounts/init-if-needed"]
 derive = []
 default = []
+cpi-events = ["anchor-attribute-event/cpi-events"]
 anchor-debug = [
     "anchor-attribute-access-control/anchor-debug",
     "anchor-attribute-account/anchor-debug",

lang/attribute/event/Cargo.toml

@@ -13,6 +13,7 @@ proc-macro = true
 
 [features]
 anchor-debug = ["anchor-syn/anchor-debug"]
+cpi-events = ["anchor-syn/cpi-events"]
 
 [dependencies]
 proc-macro2 = "1.0"

lang/attribute/event/src/lib.rs

@@ -1,5 +1,6 @@
 extern crate proc_macro;
 
+use anchor_syn::parser::accounts::add_event_cpi_accounts;
 use quote::quote;
 use syn::parse_macro_input;
 
@@ -81,6 +82,92 @@ pub fn emit(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     })
 }
 
+/// Logs an event that can be subscribed to by clients. More stable than `emit!` because
+/// RPCs are less likely to truncate CPI information than program logs. Generated code for this feature
+/// can be disabled by adding `no-cpi-events` to the `defaults = []` section of your program's Cargo.toml.
+///
+/// Uses a [`invoke_signed`](https://docs.rs/solana-program/latest/solana_program/program/fn.invoke_signed.html)
+/// syscall to store data in the ledger, which results in data being stored in the transaction metadata.
+///
+/// This also requires the usage of an additional PDA, derived from &[b"__event_authority"], to guarantee that
+/// the self-CPI is truly being invoked by the same program. Requiring this PDA to be a signer during `invoke_signed` syscall
+/// ensures that the program is the one doing the logging.
+///
+/// # Example
+///
+/// ```rust,ignore
+/// use anchor_lang::prelude::*;
+///
+/// // handler function inside #[program]
+/// pub fn do_something(ctx: Context<DoSomething>) -> Result<()> {
+///     emit_cpi!(
+///         ctx.accounts.program.to_account_info(),
+///         ctx.accounts.event_authority.clone(),
+///         *ctx.bumps.get("event_authority").unwrap(),
+///         MyEvent {
+///             data: 5,
+///             label: [1,2,3,4,5],
+///         }
+///     );
+///     Ok(())
+/// }
+///
+/// #[derive(Accounts)]
+/// pub struct DoSomething<'info> {
+///     /// CHECK: this account is needed to guarantee that your program is the one doing the logging
+///     #[account(seeds=[b"__event_authority"], bump)]
+///     pub event_authority: AccountInfo<'info>,
+///     pub program: Program<'info, crate::program::MyProgramName>,
+/// }
+///
+/// #[event]
+/// pub struct MyEvent {
+///     pub data: u64,
+///     pub label: [u8; 5],
+/// }
+/// ```
+#[proc_macro]
+pub fn emit_cpi(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let event_struct = parse_macro_input!(input as syn::Expr);
+
+    proc_macro::TokenStream::from(quote! {
+        let __event_authority_info = ctx.accounts.event_authority.to_account_info();
+        let __event_authority_bump = *ctx.bumps.get("event_authority").unwrap();
+        let __program_info = ctx.accounts.program.to_account_info();
+
+        let __disc = crate::event::EVENT_IX_TAG_LE;
+        let __inner_data: Vec<u8> = anchor_lang::Event::data(&#event_struct);
+        let __ix_data: Vec<u8> = __disc.into_iter().chain(__inner_data.into_iter()).collect();
+
+        let __ix = anchor_lang::solana_program::instruction::Instruction::new_with_bytes(
+            *__program_info.key,
+            &__ix_data,
+            vec![
+                anchor_lang::solana_program::instruction::AccountMeta::new_readonly(
+                    *__event_authority_info.key,
+                    true,
+                ),
+            ],
+        );
+        anchor_lang::solana_program::program::invoke_signed(
+            &__ix,
+            &[__program_info, __event_authority_info],
+            &[&[b"__event_authority", &[__event_authority_bump]]],
+        )
+        .map_err(anchor_lang::error::Error::from)?;
+    })
+}
+
+#[proc_macro_attribute]
+pub fn event_cpi(
+    _attr: proc_macro::TokenStream,
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let accounts_struct = parse_macro_input!(input as syn::ItemStruct);
+    let accounts_struct = add_event_cpi_accounts(&accounts_struct).unwrap();
+    proc_macro::TokenStream::from(quote! {#accounts_struct})
+}
+
 // EventIndex is a marker macro. It functionally does nothing other than
 // allow one to mark fields with the `#[index]` inert attribute, which is
 // used to add metadata to IDLs.

lang/src/error.rs

@@ -44,6 +44,11 @@ pub enum ErrorCode {
     #[msg("IDL account must be empty in order to resize, try closing first")]
     IdlAccountNotEmpty,
 
+    // Event instructions
+    /// 1500 - The program was compiled without event instructions
+    #[msg("The program was compiled without event instructions")]
+    EventInstructionStub = 1500,
+
     // Constraints
     /// 2000 - A mut constraint was violated
     #[msg("A mut constraint was violated")]

lang/src/event.rs

@@ -0,0 +1,3 @@
+// Sha256(anchor:event)[..8]
+pub const EVENT_IX_TAG: u64 = 0x1d9acb512ea545e4;
+pub const EVENT_IX_TAG_LE: [u8; 8] = EVENT_IX_TAG.to_le_bytes();

lang/src/lib.rs

@@ -37,6 +37,7 @@ mod bpf_writer;
 mod common;
 pub mod context;
 pub mod error;
+pub mod event;
 #[doc(hidden)]
 pub mod idl;
 pub mod system_program;
@@ -48,6 +49,8 @@ pub use anchor_attribute_account::{account, declare_id, zero_copy};
 pub use anchor_attribute_constant::constant;
 pub use anchor_attribute_error::*;
 pub use anchor_attribute_event::{emit, event};
+#[cfg(not(feature = "no-cpi-events"))]
+pub use anchor_attribute_event::{emit_cpi, event_cpi};
 pub use anchor_attribute_program::program;
 pub use anchor_derive_accounts::Accounts;
 pub use anchor_derive_space::InitSpace;
@@ -299,6 +302,8 @@ pub mod prelude {
         AccountsClose, AccountsExit, AnchorDeserialize, AnchorSerialize, Id, InitSpace, Key, Owner,
         ProgramData, Result, Space, ToAccountInfo, ToAccountInfos, ToAccountMetas,
     };
+    #[cfg(not(feature = "no-cpi-events"))]
+    pub use super::{emit_cpi, event_cpi};
     pub use anchor_attribute_error::*;
     pub use borsh;
     pub use error::*;

lang/syn/Cargo.toml

@@ -16,6 +16,7 @@ hash = []
 default = []
 anchor-debug = []
 seeds = []
+cpi-events = []
 
 [dependencies]
 proc-macro2 = { version = "1.0", features=["span-locations"]}

lang/syn/src/codegen/program/dispatch.rs

@@ -67,17 +67,38 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
                 #(#global_dispatch_arms)*
                 anchor_lang::idl::IDL_IX_TAG_LE => {
                     // If the method identifier is the IDL tag, then execute an IDL
-                    // instruction, injected into all Anchor programs.
-                    if cfg!(not(feature = "no-idl")) {
+                    // instruction, injected into all Anchor programs unless they have
+                    // no-idl enabled
+                    #[cfg(not(feature = "no-idl"))]
+                    {
                         __private::__idl::__idl_dispatch(
                             program_id,
                             accounts,
                             &ix_data,
                         )
-                    } else {
+                    }
+                    #[cfg(feature = "no-idl")]
+                    {
                         Err(anchor_lang::error::ErrorCode::IdlInstructionStub.into())
                     }
                 }
+                anchor_lang::event::EVENT_IX_TAG_LE => {
+                   // If the method identifier is the event tag, then execute an event cpi
+                   // against the noop instruction injected into all Anchor programs unless they have
+                   // no-cpi-events enabled.
+                    #[cfg(not(feature = "no-cpi-events"))]
+                    {
+                        __private::__events::__event_dispatch(
+                            program_id,
+                            accounts,
+                            &ix_data,
+                        )
+                    }
+                    #[cfg(feature = "no-cpi-events")]
+                    {
+                        Err(anchor_lang::error::ErrorCode::EventInstructionStub.into())
+                    }
+                }
                 _ => {
                     #fallback_fn
                 }

lang/syn/src/codegen/program/handlers.rs

@@ -91,6 +91,16 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
         }
     };
 
+    let non_inlined_event: proc_macro2::TokenStream = {
+        quote! {
+            #[inline(never)]
+            #[cfg(not(feature = "no-cpi-events"))]
+            pub fn __event_dispatch(program_id: &Pubkey, accounts: &[AccountInfo], event_data: &[u8]) -> anchor_lang::Result<()> {
+                Ok(())
+            }
+        }
+    };
+
     let non_inlined_handlers: Vec<proc_macro2::TokenStream> = program
         .ixs
         .iter()
@@ -173,7 +183,12 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
                 #idl_accounts_and_functions
             }
 
+            /// __idl mod defines handler for self-cpi based event logging
+            pub mod __events {
+                use super::*;
 
+                #non_inlined_event
+            }
 
             /// __global mod defines wrapped handlers for global instructions.
             pub mod __global {

lang/syn/src/parser/accounts/mod.rs

@@ -9,8 +9,8 @@ use syn::Path;
 
 pub mod constraints;
 
-pub fn parse(strct: &syn::ItemStruct) -> ParseResult<AccountsStruct> {
-    let instruction_api: Option<Punctuated<Expr, Comma>> = strct
+pub fn parse(accounts_struct: &syn::ItemStruct) -> ParseResult<AccountsStruct> {
+    let instruction_api: Option<Punctuated<Expr, Comma>> = accounts_struct
         .attrs
         .iter()
         .find(|a| {
@@ -20,23 +20,91 @@ pub fn parse(strct: &syn::ItemStruct) -> ParseResult<AccountsStruct> {
         })
         .map(|ix_attr| ix_attr.parse_args_with(Punctuated::<Expr, Comma>::parse_terminated))
         .transpose()?;
-    let fields = match &strct.fields {
+
+    let is_event_cpi = accounts_struct
+        .attrs
+        .iter()
+        .filter_map(|attr| attr.path.get_ident())
+        .find(|ident| *ident == "event_cpi")
+        .is_some();
+    let accounts_struct = if is_event_cpi {
+        add_event_cpi_accounts(accounts_struct)?
+    } else {
+        accounts_struct.clone()
+    };
+
+    let fields = match &accounts_struct.fields {
         syn::Fields::Named(fields) => fields
             .named
             .iter()
             .map(parse_account_field)
             .collect::<ParseResult<Vec<AccountField>>>()?,
         _ => {
             return Err(ParseError::new_spanned(
-                &strct.fields,
+                &accounts_struct.fields,
                 "fields must be named",
             ))
         }
     };
 
     constraints_cross_checks(&fields)?;
 
-    Ok(AccountsStruct::new(strct.clone(), fields, instruction_api))
+    Ok(AccountsStruct::new(
+        accounts_struct,
+        fields,
+        instruction_api,
+    ))
+}
+
+/// Add necessary event CPI accounts to the given accounts struct.
+pub fn add_event_cpi_accounts(accounts_struct: &syn::ItemStruct) -> ParseResult<syn::ItemStruct> {
+    let syn::ItemStruct {
+        attrs,
+        vis,
+        struct_token,
+        ident,
+        generics,
+        fields,
+        ..
+    } = accounts_struct;
+
+    let attrs = if attrs.is_empty() {
+        quote! {}
+    } else {
+        quote! { #(#attrs)* }
+    };
+
+    let fields = fields.into_iter().collect::<Vec<_>>();
+    let fields = if fields.is_empty() {
+        quote! {}
+    } else {
+        quote! { #(#fields)*, }
+    };
+
+    let info_lifetime = generics
+        .lifetimes()
+        .next()
+        .map(|lifetime| quote! {#lifetime})
+        .unwrap_or(quote! {'info});
+    let generics = generics
+        .lt_token
+        .map(|_| quote! {#generics})
+        .unwrap_or(quote! {<'info>});
+
+    let accounts_struct = quote! {
+        #attrs
+        #vis #struct_token #ident #generics {
+            #fields
+
+            /// CHECK: Only the event authority can call the CPI event
+            #[account(seeds = [b"__event_authority"], bump)]
+            pub event_authority: AccountInfo<#info_lifetime>,
+            /// CHECK: The program itself
+            #[account(address = crate::ID)]
+            pub program: AccountInfo<#info_lifetime>,
+        }
+    };
+    syn::parse2(accounts_struct)
 }
 
 fn constraints_cross_checks(fields: &[AccountField]) -> ParseResult<()> {

tests/events/Anchor.toml

@@ -1,3 +1,6 @@
+[features]
+seeds = false
+
 [provider]
 cluster = "localnet"
 wallet = "~/.config/solana/id.json"

tests/events/programs/events/Cargo.toml

@@ -14,6 +14,7 @@ no-entrypoint = []
 no-idl = []
 cpi = ["no-entrypoint"]
 default = []
+no-cpi-events = []
 
 [dependencies]
 anchor-lang = { path = "../../../../lang" }

tests/events/programs/events/src/lib.rs

@@ -23,6 +23,14 @@ pub mod events {
         });
         Ok(())
     }
+
+    pub fn test_event_cpi(ctx: Context<TestEventCpi>) -> Result<()> {
+        emit_cpi!(MyOtherEvent {
+            data: 7,
+            label: "cpi".to_string(),
+        });
+        Ok(())
+    }
 }
 
 #[derive(Accounts)]
@@ -31,6 +39,10 @@ pub struct Initialize {}
 #[derive(Accounts)]
 pub struct TestEvent {}
 
+#[event_cpi]
+#[derive(Accounts)]
+pub struct TestEventCpi {}
+
 #[event]
 pub struct MyEvent {
     pub data: u64,