@layerzerolabs/oapp-solana-contracts 1.2.11

package/macros/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "oapp-macros"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[features]
+default = []
+idl-build = ["anchor-lang/idl-build"]
+
+[dependencies]
+anchor-lang = { version = "1.0.2" }
+anchor-trait = { path = "../dependencies/framework-solana-anchor-trait" }
+syn = { version = "2.0", features = ["full", "parsing", "extra-traits"] }
+quote = "1.0"
+proc-macro2 = "1.0"
+darling = "0.20"
+sha2 = "0.10"
+
+[dev-dependencies]
+trybuild = "1.0"

package/macros/src/composer.rs

@@ -0,0 +1,43 @@
+//! Top-level `#[composer]` attribute macro implementation.
+//!
+//! Flow: parse module, then collect → generate → assemble.
+//! All three instructions are required — no attribute args needed.
+
+use crate::instructions::composer::{ComposerCodegenContext, ComposerInstructionSet};
+use anchor_trait::{generate_instructions, Assembly, InstructionOverrides, OverrideConfig};
+use proc_macro2::TokenStream;
+use syn::ItemMod;
+
+const OVERRIDE_CONFIG: OverrideConfig = OverrideConfig {
+    attr_name: "composer_instruction",
+    domain: "Composer",
+};
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+pub fn expand(_attr: TokenStream, item: TokenStream) -> syn::Result<TokenStream> {
+    let module = syn::parse2::<ItemMod>(item)?;
+
+    // 1. Collect overrides
+    let overrides = InstructionOverrides::collect(&module, OVERRIDE_CONFIG)?;
+
+    // 2. Generate instructions
+    let codegen_ctx = ComposerCodegenContext;
+    let instructions = generate_instructions::<ComposerInstructionSet>(&codegen_ctx, &overrides)?;
+
+    // 3. Assemble output
+    let prelude = TokenStream::new();
+    let extra_mod_attrs = TokenStream::new();
+
+    Ok(Assembly {
+        prelude,
+        overrides,
+        instructions,
+        extra_mod_attrs,
+        source_mod: module,
+        extend_macro_name: None,
+    }
+    .assemble())
+}

package/macros/src/instructions/composer/lz_compose.rs

@@ -0,0 +1,17 @@
+//! Code generator for the `lz_compose` instruction.
+//!
+//! This instruction has no default implementation — users MUST provide
+//! a custom handler named `lz_compose` with `#[composer_instruction]`.
+
+use super::ComposerCodegenContext;
+use anchor_trait::InstructionSpec;
+use quote::quote;
+
+pub(super) fn spec() -> InstructionSpec<ComposerCodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(::oapp::types::LzComposeParams)),
+        return_type: quote!(()),
+        is_view: false,
+        default_impl: None,
+    }
+}

package/macros/src/instructions/composer/lz_compose_types_info.rs

@@ -0,0 +1,29 @@
+//! Code generator for the `lz_compose_types_info` instruction.
+//!
+//! Required override (no default). Users MUST provide a custom handler
+//! named `lz_compose_types_info` with `#[composer_instruction]`.
+//!
+//! The off-chain LayerZero Executor invokes this instruction with a fixed
+//! 2-account list, in this order:
+//!   1. `composer_account` — the program-specific Composer store
+//!   2. `lz_compose_types_accounts` PDA at `[LZ_COMPOSE_TYPES_SEED, composer_account.key()]`
+//!
+//! Custom handlers MUST declare an `Accounts` struct matching this shape.
+//! The framework does not enforce it at compile time, so a mismatch only
+//! surfaces as a runtime failure when the Executor calls the deployed program.
+//!
+//! This follows the same V2 account-discovery model as `lz_receive_types_info`.
+//! See `docs/lz-compose-types.md` for the compose-specific differences.
+
+use super::ComposerCodegenContext;
+use anchor_trait::InstructionSpec;
+use quote::quote;
+
+pub(super) fn spec() -> InstructionSpec<ComposerCodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(::oapp::types::LzComposeParams)),
+        return_type: quote!((u8, ::oapp::lz_compose_types_v2::LzComposeTypesV2Accounts)),
+        is_view: true,
+        default_impl: None,
+    }
+}

package/macros/src/instructions/composer/lz_compose_types_v2.rs

@@ -0,0 +1,17 @@
+//! Code generator for the `lz_compose_types_v2` instruction.
+//!
+//! This instruction has no default implementation — users MUST provide
+//! a custom handler named `lz_compose_types_v2` with `#[composer_instruction]`.
+
+use super::ComposerCodegenContext;
+use anchor_trait::InstructionSpec;
+use quote::quote;
+
+pub(super) fn spec() -> InstructionSpec<ComposerCodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(::oapp::types::LzComposeParams)),
+        return_type: quote!(::oapp::lz_compose_types_v2::LzComposeTypesV2Result),
+        is_view: true,
+        default_impl: None,
+    }
+}

package/macros/src/instructions/composer/mod.rs

@@ -0,0 +1,23 @@
+//! Composer instruction definitions and code generation.
+//!
+//! Each sub-module defines a `spec()` returning the instruction's codegen descriptor.
+//! `InstructionName::spec()` maps instruction variants to their specs.
+
+mod lz_compose;
+mod lz_compose_types_info;
+mod lz_compose_types_v2;
+
+use anchor_trait::declare_instructions;
+
+/// Domain-specific context for Composer code generation.
+/// Currently a unit struct — all instructions are required with no defaults.
+pub(crate) struct ComposerCodegenContext;
+
+declare_instructions! {
+    name    = ComposerInstructionSet;
+    context = ComposerCodegenContext;
+
+    LzComposeTypesInfo => lz_compose_types_info,
+    LzComposeTypesV2   => lz_compose_types_v2,
+    LzCompose          => lz_compose,
+}

package/macros/src/instructions/mod.rs

@@ -0,0 +1,4 @@
+//! Instruction definitions and code generation, organized by domain.
+
+pub(crate) mod composer;
+pub(crate) mod oapp;

package/macros/src/instructions/oapp/accept_default_admin_transfer.rs

@@ -0,0 +1,50 @@
+//! Generates an RBAC **handler override** for `accept_default_admin_transfer`
+//! that also calls `set_delegate`, keeping the endpoint delegate in sync with
+//! the new default admin — matching the EVM `OAppCoreRBACUpgradeable` behaviour.
+//!
+//! This is **not** an OApp instruction. It produces a `#[rbac_instruction]`
+//! handler that reuses the RBAC-generated `StdAcceptDefaultAdminTransfer`
+//! accounts struct (handler override level), so there is no duplicate struct.
+//!
+//! # Prerequisites
+//!
+//! The generated handler calls `endpoint_cpi::set_delegate`, which requires the
+//! `OAppRegistry` PDA (seeds `[OAPP_SEED, oapp.key()]`) to already exist.  That
+//! PDA is created by `endpoint_cpi::register_oapp` — a step the `#[oapp]` macro
+//! neither generates nor enforces.
+//!
+//! **`register_oapp` is a mandatory call in the OApp's `initialize` handler.**
+//! Omitting it means `accept_default_admin_transfer` will always fail once a
+//! default-admin transfer is initiated, permanently bricking the admin transfer
+//! flow.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+
+/// Returns the handler function token stream to be placed inside the module.
+///
+/// Uses `Context<StdAcceptDefaultAdminTransfer>` so the RBAC macro treats it
+/// as a **handler override** — RBAC still generates the accounts struct, but
+/// the entrypoint dispatches to this handler instead of the default `apply`.
+pub(crate) fn generate() -> TokenStream {
+    quote! {
+        /// OApp override: accept admin transfer + sync endpoint delegate.
+        #[rbac_instruction]
+        pub fn accept_default_admin_transfer(ctx: &mut Context<StdAcceptDefaultAdminTransfer>) -> Result<()> {
+            StdAcceptDefaultAdminTransfer::apply(ctx)?;
+
+            let seeds = ctx.accounts.default_admin.signer_seeds();
+            ::oapp::endpoint_cpi::set_delegate(
+                ::oapp::endpoint::ID,
+                ctx.accounts.default_admin.key(), // oapp_key
+                &ctx.remaining_accounts,
+                &seeds,
+                ::oapp::endpoint::types::SetDelegateParams {
+                    delegate: ctx.accounts.authority.key(),
+                },
+            )?;
+
+            Ok(())
+        }
+    }
+}

package/macros/src/instructions/oapp/get_enforced_options.rs

@@ -0,0 +1,57 @@
+//! Code generator for the `get_enforced_options` instruction.
+
+use super::CodegenContext;
+use anchor_trait::{DefaultAccounts, DefaultImpl, InstructionSpec};
+use quote::{format_ident, quote};
+use syn::parse_quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(::oapp::types::GetEnforcedOptionsParams)),
+        return_type: quote!(Option<Vec<u8>>),
+        is_view: true,
+        default_impl: Some(DefaultImpl {
+            handler_ident: format_ident!("apply"),
+            generator: generate_default_impl,
+        }),
+    }
+}
+
+fn generate_default_impl(
+    ctx: &CodegenContext,
+    spec: &InstructionSpec<CodegenContext>,
+) -> DefaultAccounts {
+    let handler_ident = &spec.default_impl.as_ref().unwrap().handler_ident;
+    let params_type = spec.params_type.as_ref().unwrap();
+    let return_type = &spec.return_type;
+    let oapp_type = &ctx.oapp_type;
+
+    DefaultAccounts {
+        struct_type: parse_quote! {
+            #[derive(Accounts)]
+            #[instruction(params: #params_type)]
+            pub struct StdGetEnforcedOptions<'info> {
+                pub oapp: Account<'info, #oapp_type>,
+
+                #[account(
+                    seeds = [
+                        ::oapp::ENFORCED_OPTIONS_SEED,
+                        oapp.key().as_ref(),
+                        &params.eid.to_be_bytes(),
+                        &params.msg_type.to_be_bytes(),
+                    ],
+                    bump,
+                )]
+                pub enforced_options: UncheckedAccount<'info>,
+            }
+        },
+        impl_block: parse_quote! {
+            impl StdGetEnforcedOptions<'_> {
+                pub fn #handler_ident(ctx: &Context<Self>, _params: &#params_type) -> Result<#return_type> {
+                    let eo = ::oapp::utils::try_load_account::<EnforcedOptions>(&ctx.accounts.enforced_options)?;
+                    Ok(eo.map(|eo| eo.options))
+                }
+            }
+        },
+    }
+}

package/macros/src/instructions/oapp/get_peer.rs

@@ -0,0 +1,55 @@
+//! Code generator for the `get_peer` instruction.
+
+use super::CodegenContext;
+use anchor_trait::{DefaultAccounts, DefaultImpl, InstructionSpec};
+use quote::{format_ident, quote};
+use syn::parse_quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(u32)),
+        return_type: quote!(Option<[u8; 32]>),
+        is_view: true,
+        default_impl: Some(DefaultImpl {
+            handler_ident: format_ident!("apply"),
+            generator: generate_default_impl,
+        }),
+    }
+}
+
+fn generate_default_impl(
+    ctx: &CodegenContext,
+    spec: &InstructionSpec<CodegenContext>,
+) -> DefaultAccounts {
+    let handler_ident = &spec.default_impl.as_ref().unwrap().handler_ident;
+    let params_type = spec.params_type.as_ref().unwrap();
+    let return_type = &spec.return_type;
+    let oapp_type = &ctx.oapp_type;
+
+    DefaultAccounts {
+        struct_type: parse_quote! {
+            #[derive(Accounts)]
+            #[instruction(eid: #params_type)]
+            pub struct StdGetPeer<'info> {
+                pub oapp: Account<'info, #oapp_type>,
+
+                #[account(
+                    seeds = [::oapp::PEER_SEED, oapp.key().as_ref(), &eid.to_be_bytes()],
+                    bump,
+                )]
+                pub peer: UncheckedAccount<'info>,
+            }
+        },
+        impl_block: parse_quote! {
+            impl StdGetPeer<'_> {
+                /// Returns `None` both when the peer PDA is uninitialized and when it
+                /// holds the zero address, so callers can rely on `is_some()` as an
+                /// existence check.
+                pub fn #handler_ident(ctx: &Context<Self>, _eid: &#params_type) -> Result<#return_type> {
+                    let peer = ::oapp::utils::try_load_account::<OAppPeer>(&ctx.accounts.peer)?;
+                    Ok(peer.and_then(|p| (p.address != [0u8; 32]).then_some(p.address)))
+                }
+            }
+        },
+    }
+}

package/macros/src/instructions/oapp/init_enforced_options.rs

@@ -0,0 +1,87 @@
+//! Code generator for the `init_enforced_options` instruction.
+//!
+//! Creates the EnforcedOptions PDA at the correct size for the initial options buffer.
+//! Subsequent updates (including resize) use `set_enforced_options`.
+
+use super::CodegenContext;
+use anchor_trait::{DefaultAccounts, DefaultImpl, InstructionSpec};
+use quote::{format_ident, quote};
+use syn::parse_quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(::oapp::types::SetEnforcedOptionsParams)),
+        return_type: quote!(()),
+        is_view: false,
+        default_impl: Some(DefaultImpl {
+            handler_ident: format_ident!("apply"),
+            generator: generate_default_impl,
+        }),
+    }
+}
+
+fn generate_default_impl(
+    ctx: &CodegenContext,
+    spec: &InstructionSpec<CodegenContext>,
+) -> DefaultAccounts {
+    let handler_ident = &spec.default_impl.as_ref().unwrap().handler_ident;
+    let params_type = spec.params_type.as_ref().unwrap();
+    let return_type = &spec.return_type;
+    let oapp_type = &ctx.oapp_type;
+    let role_type = &ctx.role_type;
+
+    DefaultAccounts {
+        struct_type: parse_quote! {
+            #[::rbac::only_role(role = #role_type::default_admin_role(), state = oapp, authority = authority)]
+            #[event_cpi]
+            #[derive(Accounts)]
+            #[instruction(params: #params_type)]
+            pub struct StdInitEnforcedOptions<'info> {
+                pub authority: Signer<'info>,
+
+                #[account(mut)]
+                pub payer: Signer<'info>,
+
+                pub oapp: Account<'info, #oapp_type>,
+
+                #[account(
+                    init,
+                    payer = payer,
+                    space = EnforcedOptions::space(params.options.len()),
+                    seeds = [
+                        ::oapp::ENFORCED_OPTIONS_SEED,
+                        oapp.key().as_ref(),
+                        &params.eid.to_be_bytes(),
+                        &params.msg_type.to_be_bytes(),
+                    ],
+                    bump
+                )]
+                pub enforced_options: Account<'info, EnforcedOptions>,
+
+                pub system_program: Program<'info, System>,
+            }
+        },
+        impl_block: parse_quote! {
+            impl StdInitEnforcedOptions<'_> {
+                pub fn #handler_ident(ctx: &mut Context<Self>, params: &#params_type) -> Result<#return_type> {
+                    if !params.options.is_empty() {
+                        ::oapp::options::assert_type_3(&params.options)?;
+                    }
+
+                    let enforced_options = &mut ctx.accounts.enforced_options;
+                    enforced_options.options = params.options.clone();
+                    enforced_options.bump = ctx.bumps.enforced_options;
+
+                    emit_cpi!(::oapp::events::EnforcedOptionsSet {
+                        oapp: ctx.accounts.oapp.key(),
+                        eid: params.eid,
+                        msg_type: params.msg_type,
+                        options: params.options.clone(),
+                    });
+
+                    Ok(())
+                }
+            }
+        },
+    }
+}

package/macros/src/instructions/oapp/is_compose_msg_sender.rs

@@ -0,0 +1,44 @@
+//! Code generator for the `is_compose_msg_sender` instruction.
+
+use super::CodegenContext;
+use anchor_trait::{DefaultAccounts, DefaultImpl, InstructionSpec};
+use quote::{format_ident, quote};
+use syn::parse_quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(::oapp::types::IsComposeMsgSenderParams)),
+        return_type: quote!(bool),
+        is_view: true,
+        default_impl: Some(DefaultImpl {
+            handler_ident: format_ident!("apply"),
+            generator: generate_default_impl,
+        }),
+    }
+}
+
+fn generate_default_impl(
+    ctx: &CodegenContext,
+    spec: &InstructionSpec<CodegenContext>,
+) -> DefaultAccounts {
+    let handler_ident = &spec.default_impl.as_ref().unwrap().handler_ident;
+    let params_type = spec.params_type.as_ref().unwrap();
+    let return_type = &spec.return_type;
+    let oapp_type = &ctx.oapp_type;
+
+    DefaultAccounts {
+        struct_type: parse_quote! {
+            #[derive(Accounts)]
+            pub struct StdIsComposeMsgSender<'info> {
+                pub oapp: Account<'info, #oapp_type>,
+            }
+        },
+        impl_block: parse_quote! {
+            impl StdIsComposeMsgSender<'_> {
+                pub fn #handler_ident(ctx: &Context<Self>, params: &#params_type) -> Result<#return_type> {
+                    Ok(params.compose_sender == ctx.accounts.oapp.key())
+                }
+            }
+        },
+    }
+}

package/macros/src/instructions/oapp/lz_receive.rs

@@ -0,0 +1,33 @@
+//! Code generator for the `lz_receive` instruction.
+//!
+//! This instruction has no default implementation — users MUST provide
+//! a custom handler named `lz_receive` with `#[oapp_instruction]`.
+//!
+//! # Security
+//!
+//! The handler MUST verify that `(params.src_eid, params.sender)` corresponds
+//! to a registered peer — the Endpoint does not perform this check. Bind the
+//! `OAppPeer` PDA to `params.src_eid` via `seeds` and enforce
+//! `peer.address == params.sender` declaratively with `constraint`:
+//!
+//! ```ignore
+//! #[account(
+//!     seeds = [::oapp::PEER_SEED, oapp.key().as_ref(), &params.src_eid.to_be_bytes()],
+//!     bump = peer.bump,
+//!     constraint = peer.address == params.sender,
+//! )]
+//! pub peer: Account<'info, OAppPeer>,
+//! ```
+
+use super::CodegenContext;
+use anchor_trait::InstructionSpec;
+use quote::quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(::oapp::types::LzReceiveParams)),
+        return_type: quote!(()),
+        is_view: false,
+        default_impl: None,
+    }
+}

package/macros/src/instructions/oapp/lz_receive_types_info.rs

@@ -0,0 +1,28 @@
+//! Code generator for the `lz_receive_types_info` instruction.
+//!
+//! Required override (no default). Users MUST provide a custom handler
+//! named `lz_receive_types_info` with `#[oapp_instruction]`.
+//!
+//! The off-chain LayerZero Executor invokes this instruction with a fixed
+//! 2-account list, in this order:
+//!   1. `oapp_account` — the program-specific OApp store
+//!   2. `lz_receive_types_accounts` PDA at `[LZ_RECEIVE_TYPES_SEED, oapp_account.key()]`
+//!
+//! Custom handlers MUST declare an `Accounts` struct matching this shape.
+//! The framework does not enforce it at compile time, so a mismatch only
+//! surfaces as a runtime failure when the Executor calls the deployed program.
+//!
+//! See: <https://docs.layerzero.network/v2/developers/solana/oapp/overview#how-lz_receive_types_v2-works>
+
+use super::CodegenContext;
+use anchor_trait::InstructionSpec;
+use quote::quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(::oapp::types::LzReceiveParams)),
+        return_type: quote!((u8, ::oapp::lz_receive_types_v2::LzReceiveTypesV2Accounts)),
+        is_view: true,
+        default_impl: None,
+    }
+}

package/macros/src/instructions/oapp/lz_receive_types_v2.rs

@@ -0,0 +1,17 @@
+//! Code generator for the `lz_receive_types_v2` instruction.
+//!
+//! This instruction has no default implementation — users MUST provide
+//! a custom handler named `lz_receive_types_v2` with `#[oapp_instruction]`.
+
+use super::CodegenContext;
+use anchor_trait::InstructionSpec;
+use quote::quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(::oapp::types::LzReceiveParams)),
+        return_type: quote!(::oapp::lz_receive_types_v2::LzReceiveTypesV2Result),
+        is_view: true,
+        default_impl: None,
+    }
+}

package/macros/src/instructions/oapp/mod.rs

@@ -0,0 +1,41 @@
+//! OApp instruction definitions and code generation.
+//!
+//! Each sub-module defines a `spec()` returning the instruction's codegen descriptor.
+//! `InstructionName::spec()` maps instruction variants to their specs.
+
+pub(crate) mod accept_default_admin_transfer;
+mod get_enforced_options;
+mod get_peer;
+mod init_enforced_options;
+mod is_compose_msg_sender;
+mod lz_receive;
+mod lz_receive_types_info;
+mod lz_receive_types_v2;
+mod next_nonce;
+mod set_enforced_options;
+mod set_peer;
+
+use anchor_trait::declare_instructions;
+use proc_macro2::TokenStream;
+
+/// Domain-specific context carrying resolved types for OApp code generation.
+pub(crate) struct CodegenContext {
+    pub role_type: TokenStream,
+    pub oapp_type: TokenStream,
+}
+
+declare_instructions! {
+    name    = OAppInstructionSet;
+    context = CodegenContext;
+
+    SetPeer              => set_peer,
+    GetPeer              => get_peer,
+    InitEnforcedOptions  => init_enforced_options,
+    SetEnforcedOptions   => set_enforced_options,
+    GetEnforcedOptions   => get_enforced_options,
+    NextNonce            => next_nonce,
+    IsComposeMsgSender   => is_compose_msg_sender,
+    LzReceiveTypesInfo   => lz_receive_types_info,
+    LzReceiveTypesV2     => lz_receive_types_v2,
+    LzReceive            => lz_receive,
+}

package/macros/src/instructions/oapp/next_nonce.rs

@@ -0,0 +1,52 @@
+//! Code generator for the `next_nonce` instruction.
+
+use super::CodegenContext;
+use anchor_trait::{DefaultAccounts, DefaultImpl, InstructionSpec};
+use quote::{format_ident, quote};
+use syn::parse_quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(::oapp::types::NextNonceParams)),
+        return_type: quote!(u64),
+        is_view: true,
+        default_impl: Some(DefaultImpl {
+            handler_ident: format_ident!("apply"),
+            generator: generate_default_impl,
+        }),
+    }
+}
+
+fn generate_default_impl(
+    ctx: &CodegenContext,
+    spec: &InstructionSpec<CodegenContext>,
+) -> DefaultAccounts {
+    let handler_ident = &spec.default_impl.as_ref().unwrap().handler_ident;
+    let params_type = spec.params_type.as_ref().unwrap();
+    let return_type = &spec.return_type;
+    let oapp_type = &ctx.oapp_type;
+
+    DefaultAccounts {
+        struct_type: parse_quote! {
+            #[derive(Accounts)]
+            #[instruction(params: #params_type)]
+            pub struct StdNextNonce<'info> {
+                pub oapp: Account<'info, #oapp_type>,
+
+                #[account(
+                    seeds = [::oapp::NONCE_SEED, oapp.key().as_ref(), &params.src_eid.to_be_bytes(), &params.sender],
+                    bump
+                )]
+                pub nonce_account: UncheckedAccount<'info>,
+            }
+        },
+        impl_block: parse_quote! {
+            impl StdNextNonce<'_> {
+                pub fn #handler_ident(ctx: &Context<Self>, _params: &#params_type) -> Result<#return_type> {
+                    // path nonce starts from 1. if 0 it means that there is no specific nonce enforcement
+                    return Ok(0);
+                }
+            }
+        },
+    }
+}