@layerzerolabs/oapp-solana-contracts 1.2.11

package/src/lz_receive_types_v2.rs

@@ -0,0 +1,147 @@
+use crate::{
+    common::{AccountMetaRef, AddressLocator},
+    COMPOSED_MESSAGE_HASH_SEED, ENDPOINT_SEED, EVENT_SEED, NONCE_SEED, OAPP_SEED,
+    PAYLOAD_HASH_SEED,
+};
+use anchor_lang::{prelude::*, solana_program::system_program::ID as SYSTEM_ID};
+use solana_keccak_hasher::hash;
+
+/// Version identifier returned by `lz_receive_types_info` for the V2 flow.
+pub const LZ_RECEIVE_TYPES_VERSION: u8 = 2;
+
+/// Payload returned from `lz_receive_types_info` when the version is V2.
+///
+/// The executor uses these accounts to construct the follow-up
+/// `lz_receive_types_v2` call.
+#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug)]
+pub struct LzReceiveTypesV2Accounts {
+    pub accounts: Vec<Pubkey>,
+}
+
+/// Output of the lz_receive_types_v2 instruction.
+///
+/// This structure enables the multi-instruction execution model where OApps can
+/// define multiple instructions to be executed atomically by the Executor.
+/// The Executor constructs a single transaction containing all returned instructions.
+#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
+pub struct LzReceiveTypesV2Result {
+    /// The version of context account
+    pub context_version: u8,
+    /// ALTs required for this execution context
+    /// Used by the Executor to resolve AltIndex references in AccountMetaRef
+    /// Enables efficient account list compression for complex transactions
+    pub alts: Vec<Pubkey>,
+    /// The complete list of instructions required for LzReceive execution
+    /// MUST include exactly one LzReceive instruction
+    /// MAY include additional Standard instructions for preprocessing/postprocessing
+    /// Instructions are executed in the order returned
+    pub instructions: Vec<Instruction>,
+}
+
+/// The list of instructions that can be executed in the LzReceive transaction.
+///
+/// V2's multi-instruction model enables complex patterns such as:
+/// - Preprocessing steps before lz_receive (e.g., account initialization)
+/// - Postprocessing steps after lz_receive (e.g., verification, cleanup)
+/// - ABA messaging patterns with additional LayerZero sends
+/// - Conditional execution flows based on message content
+#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
+pub enum Instruction {
+    /// The main LzReceive instruction (exactly one required per transaction)
+    /// This instruction processes the incoming cross-chain message
+    LzReceive {
+        /// Account list for the lz_receive instruction
+        /// Uses AddressLocator for flexible address resolution
+        accounts: Vec<AccountMetaRef>,
+    },
+    /// Arbitrary custom instruction for preprocessing/postprocessing
+    /// Enables OApps to implement complex execution flows
+    Standard {
+        /// Target program ID for the custom instruction        
+        program_id: Pubkey,
+        /// Account list for the custom instruction
+        /// Uses same AddressLocator system as LzReceive
+        accounts: Vec<AccountMetaRef>,
+        /// Instruction data payload
+        /// Raw bytes containing the instruction's parameters
+        data: Vec<u8>,
+    },
+}
+
+/// V2 version of get_accounts_for_clear that returns AccountMetaRef
+pub fn get_accounts_for_clear(
+    endpoint_program: Pubkey,
+    receiver: &Pubkey,
+    src_eid: u32,
+    sender: &[u8; 32],
+    nonce: u64,
+) -> Vec<AccountMetaRef> {
+    let (nonce_account, _) = Pubkey::find_program_address(
+        &[NONCE_SEED, &receiver.to_bytes(), &src_eid.to_be_bytes(), sender],
+        &endpoint_program,
+    );
+
+    let (payload_hash_account, _) = Pubkey::find_program_address(
+        &[
+            PAYLOAD_HASH_SEED,
+            &receiver.to_bytes(),
+            &src_eid.to_be_bytes(),
+            sender,
+            &nonce.to_be_bytes(),
+        ],
+        &endpoint_program,
+    );
+
+    let (oapp_registry_account, _) =
+        Pubkey::find_program_address(&[OAPP_SEED, &receiver.to_bytes()], &endpoint_program);
+    let (event_authority_account, _) =
+        Pubkey::find_program_address(&[EVENT_SEED], &endpoint_program);
+    let (endpoint_settings_account, _) =
+        Pubkey::find_program_address(&[ENDPOINT_SEED], &endpoint_program);
+
+    vec![
+        AccountMetaRef { pubkey: endpoint_program.into(), is_writable: false },
+        AccountMetaRef { pubkey: (*receiver).into(), is_writable: false },
+        AccountMetaRef { pubkey: oapp_registry_account.into(), is_writable: false },
+        AccountMetaRef { pubkey: nonce_account.into(), is_writable: false },
+        AccountMetaRef { pubkey: payload_hash_account.into(), is_writable: true },
+        AccountMetaRef { pubkey: endpoint_settings_account.into(), is_writable: true },
+        AccountMetaRef { pubkey: event_authority_account.into(), is_writable: false },
+        AccountMetaRef { pubkey: endpoint_program.into(), is_writable: false },
+    ]
+}
+
+/// V2 version of get_accounts_for_send_compose that returns AccountMetaRef
+pub fn get_accounts_for_send_compose(
+    endpoint_program: Pubkey,
+    from: &Pubkey,
+    to: &Pubkey,
+    guid: &[u8; 32],
+    index: u16,
+    composed_message: &[u8],
+) -> Vec<AccountMetaRef> {
+    let (composed_message_account, _) = Pubkey::find_program_address(
+        &[
+            COMPOSED_MESSAGE_HASH_SEED,
+            &from.to_bytes(),
+            &to.to_bytes(),
+            &guid[..],
+            &index.to_be_bytes(),
+            &hash(composed_message).to_bytes(),
+        ],
+        &endpoint_program,
+    );
+
+    let (event_authority_account, _) =
+        Pubkey::find_program_address(&[EVENT_SEED], &endpoint_program);
+
+    vec![
+        AccountMetaRef { pubkey: endpoint_program.into(), is_writable: false },
+        AccountMetaRef { pubkey: (*from).into(), is_writable: false },
+        AccountMetaRef { pubkey: AddressLocator::Payer, is_writable: true },
+        AccountMetaRef { pubkey: composed_message_account.into(), is_writable: true },
+        AccountMetaRef { pubkey: SYSTEM_ID.into(), is_writable: false },
+        AccountMetaRef { pubkey: event_authority_account.into(), is_writable: false },
+        AccountMetaRef { pubkey: endpoint_program.into(), is_writable: false },
+    ]
+}

package/src/oapp_info.rs

@@ -0,0 +1,278 @@
+use anchor_lang::{
+    prelude::{borsh, AccountInfo, AnchorDeserialize, AnchorSerialize, InitSpace},
+    Space,
+};
+use anchor_spl::token_interface::spl_token_metadata_interface::solana_borsh;
+use spl_discriminator::SplDiscriminate;
+use spl_type_length_value::{
+    state::TlvStateMut, variable_len_pack::VariableLenPack, SplBorshVariableLenPack,
+};
+
+use crate::errors::OAppError;
+
+/// TLV entry header size in bytes: 8-byte type discriminator + 4-byte u32 length.
+pub const TLV_HEADER_BYTES: usize = 12;
+
+/// Total on-wire size of a TLV entry: header overhead plus the Borsh-serialized
+/// value bytes reported by `Space::INIT_SPACE` (auto-derived via `InitSpace`).
+///
+/// Blanket-implemented for every `Space + SplDiscriminate` type, so any struct
+/// that derives `InitSpace` and `SplDiscriminate` gets `TLV_SPACE` for free —
+/// use it when sizing the containing Anchor account.
+pub trait TlvSpace {
+    const TLV_SPACE: usize;
+}
+
+impl<T: Space + SplDiscriminate> TlvSpace for T {
+    const TLV_SPACE: usize = TLV_HEADER_BYTES + <T as Space>::INIT_SPACE;
+}
+
+/// Borsh schema version of `OAppBase`. See `docs/oapp-info.md` § `schema_version` Bump Rules.
+pub const OAPP_BASE_SCHEMA_VERSION: u8 = 1;
+
+/// IDL version (instructions + events) for this build. See `docs/oapp-info.md` § `idl_version`
+/// Bump Rules.
+pub const OAPP_BASE_IDL_VERSION: IdlVersion = IdlVersion { major: 1, minor: 0 };
+
+/// Sentinel: no app-layer TLV entry follows `OAppBase`.
+pub const NO_APP_DISCRIMINATOR: [u8; 8] = [0u8; 8];
+
+#[derive(Clone, Copy, AnchorSerialize, AnchorDeserialize, InitSpace, PartialEq, Eq, Debug)]
+pub struct IdlVersion {
+    pub major: u8,
+    pub minor: u8,
+}
+
+/// TLV entry type for the OApp framework layer. Written via `init_oapp_base!`.
+#[derive(
+    Clone, AnchorSerialize, AnchorDeserialize, InitSpace, SplDiscriminate, SplBorshVariableLenPack,
+)]
+#[discriminator_hash_input("oapp::base")]
+pub struct OAppBase {
+    /// Borsh schema version of this entry. Bumps when fields are added, removed, reordered, or
+    /// change type. The SDK reads this first to select the correct parser for the remaining bytes.
+    pub schema_version: u8,
+
+    /// IDL version (instructions + events). Bumps independently of `schema_version`.
+    pub idl_version: IdlVersion,
+
+    /// Discriminator of the sibling app-layer TLV entry — the SDK reads this to find the app
+    /// entry. Set to the entry type's `SplDiscriminate::SPL_DISCRIMINATOR`
+    /// (e.g., `OftInfo::SPL_DISCRIMINATOR`), or `NO_APP_DISCRIMINATOR` when no app entry is
+    /// present.
+    pub app_discriminator: [u8; 8],
+}
+
+/// Allocates and writes a new TLV entry into an OAppInfo account's data buffer.
+/// Call this once per entry type during account initialization. Fails if the
+/// type already exists.
+///
+/// **Precondition:** the account must be freshly allocated and zero-filled in
+/// the same instruction — typically via Anchor `#[account(init, ...)]`. Calling
+/// on a reused or partially-written account can leave undetected residual TLV
+/// entries beyond the ones written here, since the underlying TLV parser stops
+/// at the first all-zero discriminator and does not scan trailing bytes.
+pub fn init_tlv_entry<T: SplDiscriminate + VariableLenPack>(
+    info: &AccountInfo,
+    entry: &T,
+) -> anchor_lang::Result<()> {
+    let mut raw = info.try_borrow_mut_data()?;
+    let mut state = TlvStateMut::unpack(&mut raw[..])?;
+    state.alloc_and_pack_variable_len_entry(entry, false)?;
+    Ok(())
+}
+
+/// Overwrites an existing TLV entry in-place. Returns `TlvLengthMismatch` if
+/// the new value's packed length differs from the existing entry's.
+pub fn update_tlv_entry<T: SplDiscriminate + VariableLenPack>(
+    info: &AccountInfo,
+    entry: &T,
+) -> anchor_lang::Result<()> {
+    let new_len = entry.get_packed_len()?;
+    let mut raw = info.try_borrow_mut_data()?;
+    let mut state = TlvStateMut::unpack(&mut raw[..])?;
+
+    let slot = state.get_first_bytes_mut::<T>()?;
+    anchor_lang::require!(new_len == slot.len(), OAppError::TlvLengthMismatch);
+    entry.pack(slot)?;
+    Ok(())
+}
+
+/// Initializes an OAppInfo account by writing the framework `OAppBase` TLV
+/// entry.
+///
+/// Anchor manages account lifecycle (init, seeds, bump); TLV occupies the full
+/// account data from byte 0 (no Anchor discriminator).
+///
+/// ```ignore
+/// // Framework entry only — generic OApp, no app-layer sibling.
+/// oapp::init_oapp_base!(&oapp_info);
+///
+/// // Framework entry pointing to an app-layer TLV entry type.
+/// oapp::init_oapp_base!(&oapp_info, MyAppInfo);
+/// oapp::oapp_info::init_tlv_entry(&oapp_info, &my_app_info)?;
+/// ```
+///
+/// Passing an app-layer type sets `OAppBase.app_discriminator` only; it does not write that
+/// app-layer TLV entry. The program's own initialization helper must call `init_tlv_entry` for
+/// the referenced entry in the same initialize path, so `OAppBase` does not advertise a missing
+/// sibling entry.
+#[macro_export]
+macro_rules! init_oapp_base {
+    // init_oapp_base!(&oapp_info)
+    ($oapp_info:expr $(,)?) => {{
+        $crate::init_oapp_base!(@inner $oapp_info, $crate::oapp_info::NO_APP_DISCRIMINATOR)
+    }};
+
+    // init_oapp_base!(&oapp_info, AppType)
+    ($oapp_info:expr, $app_type:ty $(,)?) => {{
+        $crate::init_oapp_base!(
+            @inner $oapp_info,
+            <[u8; 8]>::from(<$app_type as ::spl_discriminator::SplDiscriminate>::SPL_DISCRIMINATOR)
+        )
+    }};
+
+    // Single implementation — not part of the public API.
+    (@inner $oapp_info:expr, $disc:expr) => {{
+        let _entry = $crate::oapp_info::OAppBase {
+            schema_version: $crate::oapp_info::OAPP_BASE_SCHEMA_VERSION,
+            idl_version: $crate::oapp_info::OAPP_BASE_IDL_VERSION,
+            app_discriminator: $disc,
+        };
+        $crate::oapp_info::init_tlv_entry($oapp_info, &_entry)?;
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anchor_lang::prelude::Pubkey;
+    use spl_type_length_value::state::{TlvState, TlvStateBorrowed, TlvStateMut};
+
+    fn write_entry(entry: OAppBase) -> Vec<u8> {
+        let mut buf = vec![0u8; OAppBase::TLV_SPACE];
+        let mut state = TlvStateMut::unpack(&mut buf[..]).unwrap();
+        let len = entry.get_packed_len().unwrap();
+        state.alloc::<OAppBase>(len, false).unwrap();
+        state.pack_first_variable_len_value(&entry).unwrap();
+        buf
+    }
+
+    fn read_entry(buf: &[u8]) -> OAppBase {
+        let state = TlvStateBorrowed::unpack(buf).unwrap();
+        state.get_first_variable_len_value::<OAppBase>().unwrap()
+    }
+
+    #[derive(
+        Clone,
+        Debug,
+        PartialEq,
+        Eq,
+        AnchorSerialize,
+        AnchorDeserialize,
+        InitSpace,
+        SplDiscriminate,
+        SplBorshVariableLenPack,
+    )]
+    #[discriminator_hash_input("oapp::tests::variable-info")]
+    struct VariableInfo {
+        #[max_len(16)]
+        bytes: Vec<u8>,
+    }
+
+    impl VariableInfo {
+        fn new(bytes: &[u8]) -> Self {
+            Self { bytes: bytes.to_vec() }
+        }
+    }
+
+    fn test_account_info<'a>(
+        key: &'a Pubkey,
+        owner: &'a Pubkey,
+        lamports: &'a mut u64,
+        data: &'a mut [u8],
+    ) -> AccountInfo<'a> {
+        AccountInfo::new(key, false, true, lamports, data, owner, false)
+    }
+
+    fn read_variable_info(info: &AccountInfo) -> VariableInfo {
+        let raw = info.try_borrow_data().unwrap();
+        let state = TlvStateBorrowed::unpack(&raw[..]).unwrap();
+        state.get_first_variable_len_value::<VariableInfo>().unwrap()
+    }
+
+    #[test]
+    fn entry_packed_len_matches_tlv_space() {
+        let entry = OAppBase {
+            schema_version: OAPP_BASE_SCHEMA_VERSION,
+            idl_version: OAPP_BASE_IDL_VERSION,
+            app_discriminator: NO_APP_DISCRIMINATOR,
+        };
+        // get_packed_len and INIT_SPACE both report value bytes only; TLV_SPACE adds framing.
+        assert_eq!(entry.get_packed_len().unwrap(), OAppBase::INIT_SPACE);
+        assert_eq!(entry.get_packed_len().unwrap() + TLV_HEADER_BYTES, OAppBase::TLV_SPACE);
+    }
+
+    #[test]
+    fn tlv_round_trip_default_versions() {
+        let entry = OAppBase {
+            schema_version: OAPP_BASE_SCHEMA_VERSION,
+            idl_version: OAPP_BASE_IDL_VERSION,
+            app_discriminator: NO_APP_DISCRIMINATOR,
+        };
+        let buf = write_entry(entry);
+        let out = read_entry(&buf);
+
+        assert_eq!(out.schema_version, OAPP_BASE_SCHEMA_VERSION);
+        assert_eq!(out.idl_version, OAPP_BASE_IDL_VERSION);
+        assert_eq!(out.app_discriminator, NO_APP_DISCRIMINATOR);
+    }
+
+    #[test]
+    fn tlv_round_trip_with_app_discriminator() {
+        let disc = [1, 2, 3, 4, 5, 6, 7, 8];
+        let entry = OAppBase {
+            schema_version: OAPP_BASE_SCHEMA_VERSION,
+            idl_version: OAPP_BASE_IDL_VERSION,
+            app_discriminator: disc,
+        };
+        let buf = write_entry(entry);
+        let out = read_entry(&buf);
+
+        assert_eq!(out.app_discriminator, disc);
+        assert_eq!(out.schema_version, OAPP_BASE_SCHEMA_VERSION);
+        assert_eq!(out.idl_version, OAPP_BASE_IDL_VERSION);
+    }
+
+    #[test]
+    fn update_tlv_entry_rejects_longer_value() {
+        let key = Pubkey::new_unique();
+        let owner = Pubkey::new_unique();
+        let mut lamports = 1;
+        let mut data = vec![0u8; VariableInfo::TLV_SPACE];
+        let info = test_account_info(&key, &owner, &mut lamports, &mut data);
+
+        let original = VariableInfo::new(&[1, 2, 3]);
+        init_tlv_entry(&info, &original).unwrap();
+
+        let err = update_tlv_entry(&info, &VariableInfo::new(&[1, 2, 3, 4])).unwrap_err();
+        assert_eq!(err, OAppError::TlvLengthMismatch.into());
+        assert_eq!(read_variable_info(&info), original);
+    }
+
+    #[test]
+    fn update_tlv_entry_rejects_shorter_value() {
+        let key = Pubkey::new_unique();
+        let owner = Pubkey::new_unique();
+        let mut lamports = 1;
+        let mut data = vec![0u8; VariableInfo::TLV_SPACE];
+        let info = test_account_info(&key, &owner, &mut lamports, &mut data);
+
+        let original = VariableInfo::new(&[1, 2, 3, 4]);
+        init_tlv_entry(&info, &original).unwrap();
+
+        let err = update_tlv_entry(&info, &VariableInfo::new(&[1, 2, 3])).unwrap_err();
+        assert_eq!(err, OAppError::TlvLengthMismatch.into());
+        assert_eq!(read_variable_info(&info), original);
+    }
+}

package/src/options.rs

@@ -0,0 +1,147 @@
+use crate::errors::OAppError;
+use anchor_lang::prelude::*;
+
+pub const OPTIONS_TYPE_3: u16 = 3;
+
+pub fn combine_options(mut enforced_options: Vec<u8>, extra_options: &[u8]) -> Result<Vec<u8>> {
+    // No enforced options, pass whatever the caller supplied, even if it's empty or legacy type
+    // 1/2 options.
+    if enforced_options.is_empty() {
+        return Ok(extra_options.to_vec());
+    }
+
+    // No caller options, return enforced
+    if extra_options.is_empty() {
+        return Ok(enforced_options);
+    }
+
+    // If caller provided extra_options, must be type 3 as it's the ONLY type that can be
+    // combined.
+    if extra_options.len() >= 2 {
+        assert_type_3(extra_options)?;
+        // Remove the first 2 bytes containing the type from the extra_options and combine with
+        // enforced.
+        enforced_options.extend_from_slice(&extra_options[2..]);
+        return Ok(enforced_options);
+    }
+
+    // No valid set of options was found.
+    Err(OAppError::InvalidOptions.into())
+}
+
+pub fn assert_type_3(options: &[u8]) -> anchor_lang::Result<()> {
+    require!(options.len() >= 2, OAppError::InvalidOptionsLength);
+    let mut option_type_bytes = [0; 2];
+    option_type_bytes.copy_from_slice(&options[0..2]);
+    require!(u16::from_be_bytes(option_type_bytes) == OPTIONS_TYPE_3, OAppError::InvalidOptions);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn type3_header() -> [u8; 2] {
+        OPTIONS_TYPE_3.to_be_bytes()
+    }
+
+    // -----------------------------------------------------------------------
+    // assert_type_3
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn assert_type_3_valid() {
+        assert!(assert_type_3(&type3_header()).is_ok());
+    }
+
+    #[test]
+    fn assert_type_3_empty_returns_invalid_length() {
+        let err = assert_type_3(&[]).unwrap_err();
+        assert_eq!(err, OAppError::InvalidOptionsLength.into());
+    }
+
+    #[test]
+    fn assert_type_3_one_byte_returns_invalid_length() {
+        let err = assert_type_3(&[0x00]).unwrap_err();
+        assert_eq!(err, OAppError::InvalidOptionsLength.into());
+    }
+
+    #[test]
+    fn assert_type_3_wrong_type_returns_invalid_options() {
+        let err = assert_type_3(&[0x00, 0x01]).unwrap_err();
+        assert_eq!(err, OAppError::InvalidOptions.into());
+    }
+
+    // -----------------------------------------------------------------------
+    // combine_options — enforced empty
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn combine_no_enforced_returns_extra_as_is() {
+        let result = combine_options(vec![], &[0x01, 0x02, 0x03]).unwrap();
+        assert_eq!(result, vec![0x01, 0x02, 0x03]);
+    }
+
+    #[test]
+    fn combine_no_enforced_extra_also_empty_returns_empty() {
+        let result = combine_options(vec![], &[]).unwrap();
+        assert_eq!(result, Vec::<u8>::new());
+    }
+
+    // -----------------------------------------------------------------------
+    // combine_options — extra empty
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn combine_enforced_present_extra_empty_returns_enforced() {
+        let enforced = vec![0x00, 0x03, 0xFF];
+        let result = combine_options(enforced.clone(), &[]).unwrap();
+        assert_eq!(result, enforced);
+    }
+
+    // -----------------------------------------------------------------------
+    // combine_options — both present
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn combine_both_present_type3_strips_header_and_appends() {
+        let enforced = vec![0x00, 0x03, 0xAA, 0xBB];
+        let [h0, h1] = type3_header();
+        let extra = vec![h0, h1, 0xCC, 0xDD];
+
+        let result = combine_options(enforced.clone(), &extra).unwrap();
+
+        let mut expected = enforced;
+        expected.extend_from_slice(&[0xCC, 0xDD]);
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn combine_both_present_type3_only_header_no_payload() {
+        let enforced = vec![0xAA];
+        let [h0, h1] = type3_header();
+        let extra = vec![h0, h1]; // type-3 header, zero extra payload
+
+        let result = combine_options(enforced.clone(), &extra).unwrap();
+        assert_eq!(result, enforced); // nothing appended beyond header
+    }
+
+    #[test]
+    fn combine_both_present_non_type3_returns_invalid_options() {
+        let enforced = vec![0x00, 0x03, 0xAA];
+        let extra = vec![0x00, 0x01, 0xBB]; // type 1 — not allowed when enforced exists
+
+        let err = combine_options(enforced, &extra).unwrap_err();
+        assert_eq!(err, OAppError::InvalidOptions.into());
+    }
+
+    #[test]
+    fn combine_both_present_single_byte_extra_returns_invalid_options() {
+        // extra_options.len() == 1 → falls through to the final Err
+        let enforced = vec![0xAA];
+        let extra = vec![0x03]; // only 1 byte
+
+        let err = combine_options(enforced, &extra).unwrap_err();
+        assert_eq!(err, OAppError::InvalidOptions.into());
+    }
+}

package/src/types.rs

@@ -0,0 +1,114 @@
+//! Standard LayerZero OApp types.
+//!
+//! Canonical parameter and return structs for OApp instructions that match
+//! the LayerZero protocol interface. They don't change between implementations.
+
+use anchor_lang::prelude::*;
+
+/// Params for the `set_peer` instruction.
+///
+/// Configures a trusted remote peer address for a specific chain, enabling
+/// cross-chain communication.
+#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
+pub struct SetPeerParams {
+    /// The endpoint ID of the remote chain (e.g., Ethereum mainnet, Arbitrum).
+    pub eid: u32,
+    /// The 32-byte address of the trusted peer on the remote chain.
+    pub peer: [u8; 32],
+}
+
+/// Params for the `set_enforced_options` instruction.
+///
+/// Sets mandatory execution options (e.g., gas limits)
+/// for a specific message type to a specific destination chain.
+#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
+pub struct SetEnforcedOptionsParams {
+    /// The endpoint ID of the destination chain.
+    pub eid: u32,
+    /// The message type identifier (oapp-defined).
+    pub msg_type: u16,
+    /// The encoded execution options to enforce for this destination/message type pair.
+    pub options: Vec<u8>,
+}
+
+/// Params for the `get_enforced_options` instruction (read-only view method).
+///
+/// Queries the stored enforced options for a given destination chain and
+/// message type.
+#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
+pub struct GetEnforcedOptionsParams {
+    /// The endpoint ID of the destination chain to query.
+    pub eid: u32,
+    /// The message type identifier to query.
+    pub msg_type: u16,
+}
+
+/// Params for the `lz_receive` instruction.
+///
+/// Delivered by the LayerZero executor after message verification is complete.
+#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
+pub struct LzReceiveParams {
+    /// The endpoint ID of the source chain that sent the message.
+    pub src_eid: u32,
+    /// The 32-byte address of the sender on the source chain.
+    pub sender: [u8; 32],
+    /// The message sequence number.
+    pub nonce: u64,
+    /// The globally unique identifier for this cross-chain message.
+    pub guid: [u8; 32],
+    /// The encoded message payload (oapp-defined).
+    pub message: Vec<u8>,
+    /// Additional executor-provided data for the receive transaction.
+    pub extra_data: Vec<u8>,
+}
+
+/// Params for the `lz_compose` instruction.
+///
+/// Enables multi-step cross-chain execution (the compose flow).
+#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
+pub struct LzComposeParams {
+    /// The OApp receiver address that sent the compose message.
+    pub from: Pubkey,
+    /// The composer address that will receive the message.
+    pub to: Pubkey,
+    /// The globally unique identifier of the original cross-chain message.
+    pub guid: [u8; 32],
+    /// The index of this composed message (supports multiple composes per message).
+    pub index: u16,
+    /// The encoded composed message payload.
+    pub message: Vec<u8>,
+    /// Additional executor-provided data for the compose transaction.
+    pub extra_data: Vec<u8>,
+}
+
+/// Params for the `next_nonce` instruction (read-only view method).
+///
+/// Queries the next expected nonce for ordered message delivery from a
+/// specific source chain and sender. The default implementation returns 0
+/// (no ordering enforcement); OApps can override to enforce sequencing.
+#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
+pub struct NextNonceParams {
+    /// The endpoint ID of the source chain.
+    pub src_eid: u32,
+    /// The 32-byte address of the remote sender.
+    pub sender: [u8; 32],
+}
+
+/// Params for the `is_compose_msg_sender` instruction (read-only view method).
+///
+/// Validates whether an account is authorized to send composed messages for a
+/// given cross-chain message. The default implementation only permits the OApp
+/// itself; OApps can override for custom authorization logic. Returns `bool`.
+#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
+pub struct IsComposeMsgSenderParams {
+    /// The endpoint ID of the source chain.
+    pub src_eid: u32,
+    /// The 32-byte address of the remote sender.
+    pub sender: [u8; 32],
+    /// The message sequence number.
+    pub nonce: u64,
+    /// The encoded message payload for context.
+    pub message: Vec<u8>,
+    /// The account claiming authorization to send the compose message.
+    pub compose_sender: Pubkey,
+}