Feature: CPI Events API

lang/attribute/event/src/lib.rs

@@ -81,6 +81,29 @@ pub fn emit(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     })
 }
 
+#[proc_macro]
+pub fn emit_cpi(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let tuple = parse_macro_input!(input as syn::ExprTuple);
+
+    let elems = tuple.elems;
+    if elems.len() != 2 {
+        panic!("Expected a tuple with exactly two elements.");
+    }
+
+    let first = &elems[0];
+    let second = &elems[1];
+
+    proc_macro::TokenStream::from(quote! {
+        let program_info: &anchor_lang::solana_program::account_info::AccountInfo = &#first;
+
+        let __disc: Vec<u8> = crate::event::EVENT_IX_TAG_LE.to_vec();
+        let __inner_data: &Vec<u8> = &anchor_lang::Event::data(&#second);
+        let __ix_data: Vec<u8> = __disc.iter().chain(__inner_data.iter()).cloned().collect();
+
+        anchor_lang::__private::_emit_cpi_invoke(__ix_data, program_info)?;
+    })
+}
+
 // 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/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;
@@ -47,7 +48,7 @@ pub use anchor_attribute_access_control::access_control;
 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};
+pub use anchor_attribute_event::{emit, emit_cpi, event};
 pub use anchor_attribute_program::program;
 pub use anchor_derive_accounts::Accounts;
 pub use anchor_derive_space::InitSpace;
@@ -292,8 +293,8 @@ pub mod prelude {
         accounts::interface_account::InterfaceAccount, accounts::program::Program,
         accounts::signer::Signer, accounts::system_account::SystemAccount,
         accounts::sysvar::Sysvar, accounts::unchecked_account::UncheckedAccount, constant,
-        context::Context, context::CpiContext, declare_id, emit, err, error, event, program,
-        require, require_eq, require_gt, require_gte, require_keys_eq, require_keys_neq,
+        context::Context, context::CpiContext, declare_id, emit, emit_cpi, err, error, event,
+        program, require, require_eq, require_gt, require_gte, require_keys_eq, require_keys_neq,
         require_neq, solana_program::bpf_loader_upgradeable::UpgradeableLoaderState, source,
         system_program::System, zero_copy, AccountDeserialize, AccountSerialize, Accounts,
         AccountsClose, AccountsExit, AnchorDeserialize, AnchorSerialize, Id, InitSpace, Key, Owner,
@@ -333,6 +334,8 @@ pub mod __private {
 
     pub use bytemuck;
 
+    use solana_program::account_info::AccountInfo;
+    use solana_program::instruction::{AccountMeta, Instruction};
     use solana_program::pubkey::Pubkey;
 
     // Used to calculate the maximum between two expressions.
@@ -358,6 +361,17 @@ pub mod __private {
             input.to_bytes()
         }
     }
+
+    #[doc(hidden)]
+    pub fn _emit_cpi_invoke(ix_data: Vec<u8>, program: &AccountInfo) -> anchor_lang::Result<()> {
+        let ix: Instruction = Instruction::new_with_bytes(
+            program.key.clone(),
+            ix_data.as_ref(),
+            vec![AccountMeta::new_readonly(*program.key, false)],
+        );
+        solana_program::program::invoke(&ix, &[program.clone()])?;
+        Ok(())
+    }
 }
 
 /// Ensures a condition is true, otherwise returns with the given error.

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

@@ -78,6 +78,18 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
                         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
+                   if cfg!(not(feature = "no-cpi-event")) {
+                        __private::__events::__event_dispatch(
+                            program_id,
+                            accounts,
+                            &ix_data,
+                        )
+                    } else {
+                        Err(anchor_lang::error::ErrorCode::IdlInstructionStub.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 {

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

@@ -23,6 +23,17 @@ pub mod events {
         });
         Ok(())
     }
+
+    pub fn test_event_cpi(ctx: Context<TestEventCpi>) -> Result<()> {
+        emit_cpi!((
+            &ctx.accounts.program.to_account_info(),
+            MyOtherEvent {
+                data: 7,
+                label: "cpi".to_string(),
+            },
+        ));
+        Ok(())
+    }
 }
 
 #[derive(Accounts)]
@@ -31,6 +42,12 @@ pub struct Initialize {}
 #[derive(Accounts)]
 pub struct TestEvent {}
 
+#[derive(Accounts)]
+pub struct TestEventCpi<'info> {
+    /// CHECK: this is the program itself
+    program: AccountInfo<'info>,
+}
+
 #[event]
 pub struct MyEvent {
     pub data: u64,

tests/events/tests/events.js

@@ -1,4 +1,5 @@
 const anchor = require("@coral-xyz/anchor");
+const { bs58, base64 } = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
 const { assert } = require("chai");
 
 describe("events", () => {
@@ -54,6 +55,34 @@ describe("events", () => {
     assert.strictEqual(eventTwo.data.toNumber(), 6);
     assert.strictEqual(eventTwo.label, "bye");
   });
+
+  it("Self-CPI events work", async () => {
+    await sleep(200);
+
+    let sendTx = await program.transaction.testEventCpi({
+      accounts: {
+        program: program.programId,
+      },
+    });
+
+    let provider = anchor.getProvider();
+    let connection = provider.connection;
+    let txid = await provider.sendAndConfirm(sendTx, [], {
+      commitment: "confirmed",
+    });
+
+    let tx = await connection.getTransaction(txid, { commitment: "confirmed" });
+
+    let cpiEventData = tx.meta.innerInstructions[0].instructions[0].data;
+    let ixData = bs58.decode(cpiEventData);
+    let eventData = ixData.slice(8);
+
+    let coder = new anchor.BorshEventCoder(program.idl);
+    let event = coder.decode(base64.encode(eventData)).data;
+
+    assert.strictEqual(event.data.toNumber(), 7);
+    assert.strictEqual(event.label, "cpi");
+  });
 });
 
 function sleep(ms) {