@layerzerolabs/framework-solana-anchor-trait 0.2.61 → 0.2.63

package/tests/override.rs

@@ -49,7 +49,6 @@ mod tests {
         }
 
         fn spec(self, _ctx: &()) -> InstructionSpec<()> {
-            // Not called by collect() — only needed for generation tests later.
             unimplemented!("TestIx::spec() is not used in override collection tests")
         }
     }
@@ -105,20 +104,19 @@ mod tests {
         let module: syn::ItemMod = syn::parse_quote! {
             mod my_program {
                 #[test_instruction]
-                pub fn set_peer(ctx: Context<MyAccounts>, params: SetPeerParams) -> Result<()> {
+                pub fn set_peer(ctx: &mut Context<MyAccounts>, params: &SetPeerParams) -> Result<()> {
                     Ok(())
                 }
             }
         };
         let overrides = collect_ok(&module);
 
-        // SetPeer should be detected
         let meta = overrides.get(TestIx::SetPeer).expect("SetPeer override should exist");
-        assert_eq!(meta.fn_ident, "set_peer");
-        assert_eq!(meta.accounts_type.to_token_stream().to_string(), "MyAccounts");
+        assert!(
+            meta.context_type.to_token_stream().to_string().contains("MyAccounts"),
+            "context_type should contain MyAccounts"
+        );
         assert_eq!(meta.wrapper_mod.to_string(), "__test_instruction__set_peer_handler");
-
-        // Others untouched
         assert!(overrides.get(TestIx::GetPeer).is_none());
         assert!(overrides.get(TestIx::LzReceive).is_none());
     }
@@ -128,12 +126,12 @@ mod tests {
         let module: syn::ItemMod = syn::parse_quote! {
             mod my_program {
                 #[test_instruction]
-                pub fn set_peer(ctx: Context<PeerAccounts>, params: SetPeerParams) -> Result<()> {
+                pub fn set_peer(ctx: &mut Context<PeerAccounts>, params: &SetPeerParams) -> Result<()> {
                     Ok(())
                 }
 
                 #[test_instruction]
-                pub fn lz_receive(ctx: Context<ReceiveAccounts>, params: LzReceiveParams) -> Result<()> {
+                pub fn lz_receive(ctx: &mut Context<ReceiveAccounts>, params: &LzReceiveParams) -> Result<()> {
                     Ok(())
                 }
             }
@@ -141,12 +139,16 @@ mod tests {
         let overrides = collect_ok(&module);
 
         let peer = overrides.get(TestIx::SetPeer).expect("SetPeer should exist");
-        assert_eq!(peer.fn_ident, "set_peer");
-        assert_eq!(peer.accounts_type.to_token_stream().to_string(), "PeerAccounts");
+        assert!(
+            peer.context_type.to_token_stream().to_string().contains("PeerAccounts"),
+            "context_type should contain PeerAccounts"
+        );
 
         let recv = overrides.get(TestIx::LzReceive).expect("LzReceive should exist");
-        assert_eq!(recv.fn_ident, "lz_receive");
-        assert_eq!(recv.accounts_type.to_token_stream().to_string(), "ReceiveAccounts");
+        assert!(
+            recv.context_type.to_token_stream().to_string().contains("ReceiveAccounts"),
+            "context_type should contain ReceiveAccounts"
+        );
 
         assert!(overrides.get(TestIx::GetPeer).is_none());
     }
@@ -157,8 +159,8 @@ mod tests {
             mod my_program {
                 #[test_instruction]
                 pub fn lz_receive<'info>(
-                    ctx: Context<'_, '_, '_, 'info, MyReceiveAccounts<'info>>,
-                    params: LzReceiveParams,
+                    ctx: &mut Context<'_, '_, '_, 'info, MyReceiveAccounts<'info>>,
+                    params: &LzReceiveParams,
                 ) -> Result<()> {
                     Ok(())
                 }
@@ -167,14 +169,6 @@ mod tests {
         let overrides = collect_ok(&module);
         let meta = overrides.get(TestIx::LzReceive).expect("LzReceive should exist");
 
-        // Inner type is the last type arg: MyReceiveAccounts<'info>
-        assert!(meta
-            .accounts_type
-            .to_token_stream()
-            .to_string()
-            .contains("MyReceiveAccounts < 'info >"));
-
-        // Full context_type preserves all lifetimes
         let full_ctx = meta.context_type.to_token_stream().to_string();
         assert!(full_ctx.contains("Context"), "context_type should contain Context: {full_ctx}");
         assert!(
@@ -186,7 +180,6 @@ mod tests {
             "context_type should preserve named lifetimes: {full_ctx}"
         );
 
-        // Function-level generics should capture <'info>
         let generics = meta.fn_generics.to_token_stream().to_string();
         assert!(generics.contains("'info"), "fn_generics should contain 'info: {generics}");
     }
@@ -196,7 +189,7 @@ mod tests {
         let module: syn::ItemMod = syn::parse_quote! {
             mod my_program {
                 #[test_instruction]
-                pub fn set_peer(ctx: Context<MyAccounts>, params: SetPeerParams) -> Result<()> {
+                pub fn set_peer(ctx: &mut Context<MyAccounts>, params: &SetPeerParams) -> Result<()> {
                     Ok(())
                 }
 
@@ -212,10 +205,7 @@ mod tests {
         let overrides = collect_ok(&module);
         let filtered = overrides.filtered_items(&module).to_string();
 
-        // Override handler should be removed
         assert!(!filtered.contains("set_peer"), "overridden handler should be filtered out");
-
-        // Regular items should remain
         assert!(filtered.contains("helper_function"), "regular fn should be kept");
         assert!(filtered.contains("MyState"), "struct should be kept");
     }
@@ -229,36 +219,49 @@ mod tests {
         let module: syn::ItemMod = syn::parse_quote! {
             mod my_program {
                 #[test_instruction]
-                pub fn get_peer(ctx: Context<GetPeerAccounts>, params: GetPeerParams) -> Result<[u8; 32]> {
+                pub fn get_peer(ctx: &Context<GetPeerAccounts>, params: &GetPeerParams) -> Result<[u8; 32]> {
                     Ok([0u8; 32])
                 }
             }
         };
         let overrides = collect_ok(&module);
-        let wrapper = overrides.wrapper_defs.to_string();
 
-        // Wrapper module should exist with the correct name
-        assert!(
-            wrapper.contains("__test_instruction__get_peer_handler"),
-            "wrapper module should be named correctly: {wrapper}"
-        );
+        // Parse wrapper_defs as a file so we can make structural AST assertions
+        // instead of fragile string checks.
+        let wrapper_file: syn::File =
+            syn::parse2(overrides.wrapper_defs.clone()).expect("wrapper_defs should parse as file");
 
-        // Handler function should be inside the wrapper
-        assert!(wrapper.contains("get_peer"), "handler fn should be inside wrapper: {wrapper}");
+        let wrapper_mod = wrapper_file
+            .items
+            .iter()
+            .find_map(|item| match item {
+                syn::Item::Mod(m) if m.ident == "__test_instruction__get_peer_handler" => Some(m),
+                _ => None,
+            })
+            .expect("wrapper module __test_instruction__get_peer_handler should exist");
 
-        // The override attribute should be stripped from the relocated handler.
-        // The module name itself contains "test_instruction", so check for the
-        // attribute syntax specifically: `# [test_instruction` (tokenized form).
-        assert!(
-            !wrapper.contains("# [test_instruction"),
-            "override attr should be stripped in wrapper: {wrapper}"
-        );
+        let wrapper_items = &wrapper_mod.content.as_ref().expect("wrapper should have body").1;
 
-        // Wrapper should import parent scope
-        assert!(
-            wrapper.contains("use super :: *"),
-            "wrapper should have `use super::*`: {wrapper}"
-        );
+        let has_handler_fn = wrapper_items
+            .iter()
+            .any(|item| matches!(item, syn::Item::Fn(f) if f.sig.ident == "get_peer"));
+        assert!(has_handler_fn, "handler fn `get_peer` should be inside wrapper module");
+
+        let handler_fn = wrapper_items
+            .iter()
+            .find_map(|item| match item {
+                syn::Item::Fn(f) if f.sig.ident == "get_peer" => Some(f),
+                _ => None,
+            })
+            .unwrap();
+        let has_override_attr =
+            handler_fn.attrs.iter().any(|a| a.path().is_ident("test_instruction"));
+        assert!(!has_override_attr, "override attr should be stripped in wrapper");
+
+        let has_use_super = wrapper_items.iter().any(|item| {
+            matches!(item, syn::Item::Use(u) if u.to_token_stream().to_string().contains("super :: *"))
+        });
+        assert!(has_use_super, "wrapper should have `use super::*`");
     }
 
     // -----------------------------------------------------------------------
@@ -325,6 +328,20 @@ mod tests {
         assert!(err.contains("Context"), "error should mention Context<T>: {err}");
     }
 
+    #[test]
+    fn error_handler_reference_to_non_context_type() {
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn set_peer(ctx: &SomethingElse) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let err = collect_err(&module);
+        assert!(err.contains("Context"), "error should mention Context<T>: {err}");
+    }
+
     #[test]
     fn error_bare_function_name_collision() {
         let module: syn::ItemMod = syn::parse_quote! {
@@ -341,6 +358,7 @@ mod tests {
 
     #[test]
     fn error_duplicate_attribute_on_single_function() {
+        // Two `#[test_instruction]` attrs on the same function — caught by `at_most_one()`.
         let module: syn::ItemMod = syn::parse_quote! {
             mod my_program {
                 #[test_instruction]
@@ -354,6 +372,29 @@ mod tests {
         assert!(err.contains("duplicate"), "error should mention duplicate: {err}");
     }
 
+    #[test]
+    fn error_two_handlers_overriding_same_instruction() {
+        // Two separate functions both named `set_peer` — the second hits
+        // `collected.handlers.contains_key(&target)`, a distinct path from
+        // the same-function duplicate-attr check above.
+        let module: syn::ItemMod = syn::parse_quote! {
+            mod my_program {
+                #[test_instruction]
+                pub fn set_peer(ctx: &mut Context<AccountsA>, params: &SetPeerParams) -> Result<()> {
+                    Ok(())
+                }
+
+                #[test_instruction]
+                pub fn set_peer(ctx: &mut Context<AccountsB>, params: &SetPeerParams) -> Result<()> {
+                    Ok(())
+                }
+            }
+        };
+        let err = collect_err(&module);
+        assert!(err.contains("duplicate"), "error should mention duplicate: {err}");
+        assert!(err.contains("set_peer"), "error should mention the instruction name: {err}");
+    }
+
     // -----------------------------------------------------------------------
     // Tests — boundary conditions
     // -----------------------------------------------------------------------
@@ -385,13 +426,13 @@ mod tests {
 
     #[test]
     fn non_override_attrs_preserved_in_wrapper() {
-        // A handler with both the override attr and another attr — the
-        // non-override attr should survive relocation into the wrapper module.
+        // A handler with both the override attr and a non-override attr —
+        // the non-override attr should survive relocation into the wrapper module.
         let module: syn::ItemMod = syn::parse_quote! {
             mod my_program {
                 #[inline(always)]
                 #[test_instruction]
-                pub fn set_peer(ctx: Context<MyAccounts>, params: SetPeerParams) -> Result<()> {
+                pub fn set_peer(ctx: &mut Context<MyAccounts>, params: &SetPeerParams) -> Result<()> {
                     Ok(())
                 }
             }
@@ -399,13 +440,10 @@ mod tests {
         let overrides = collect_ok(&module);
         let wrapper = overrides.wrapper_defs.to_string();
 
-        // The override attr should be stripped
         assert!(
             !wrapper.contains("# [test_instruction"),
             "override attr should be stripped: {wrapper}"
         );
-
-        // The #[inline(always)] attr should be preserved
         assert!(
             wrapper.contains("inline"),
             "non-override attrs should be preserved in wrapper: {wrapper}"

package/tests/snapshots/snapshots__tests__snapshot_all_defaults.snap

@@ -4,13 +4,40 @@ expression: output
 ---
 mod __test_instruction__lz_receive_handler {
     use super::*;
-    pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+    pub fn lz_receive(
+        ctx: &mut Context<MyReceive>,
+        params: &LzReceiveParams,
+    ) -> Result<()> {
         Ok(())
     }
 }
-struct StdSetPeer;
-struct StdGetPeer;
-struct StdToken;
+#[derive(Accounts)]
+pub struct StdSetPeer<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdSetPeer<'_> {
+    pub fn apply(_ctx: &mut Context<Self>, _params: &SetPeerParams) -> Result<()> {
+        unimplemented!()
+    }
+}
+#[derive(Accounts)]
+pub struct StdGetPeer<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdGetPeer<'_> {
+    pub fn apply(_ctx: &Context<Self>, _params: &GetPeerParams) -> Result<[u8; 32]> {
+        unimplemented!()
+    }
+}
+#[derive(Accounts)]
+pub struct StdToken<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdToken<'_> {
+    pub fn apply(_ctx: &Context<Self>) -> Result<Pubkey> {
+        unimplemented!()
+    }
+}
 #[program]
 pub mod my_program {
     use super::*;
@@ -27,7 +54,7 @@ pub mod my_program {
         mut ctx: Context<MyReceive>,
         params: LzReceiveParams,
     ) -> Result<()> {
-        __test_instruction__lz_receive_handler::lz_receive(ctx, params)
+        __test_instruction__lz_receive_handler::lz_receive(&mut ctx, &params)
     }
     pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
         StdToken::apply(&ctx)

package/tests/snapshots/snapshots__tests__snapshot_full_override.snap

@@ -5,8 +5,8 @@ expression: output
 mod __test_instruction__set_peer_handler {
     use super::*;
     pub fn set_peer(
-        ctx: Context<MyCustomAccounts>,
-        params: SetPeerParams,
+        ctx: &mut Context<MyCustomAccounts>,
+        params: &SetPeerParams,
     ) -> Result<()> {
         msg!("fully custom set_peer");
         Ok(())
@@ -14,12 +14,40 @@ mod __test_instruction__set_peer_handler {
 }
 mod __test_instruction__lz_receive_handler {
     use super::*;
-    pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+    pub fn lz_receive(
+        ctx: &mut Context<MyReceive>,
+        params: &LzReceiveParams,
+    ) -> Result<()> {
         Ok(())
     }
 }
-struct StdGetPeer;
-struct StdToken;
+#[derive(Accounts)]
+pub struct StdSetPeer<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdSetPeer<'_> {
+    pub fn apply(_ctx: &mut Context<Self>, _params: &SetPeerParams) -> Result<()> {
+        unimplemented!()
+    }
+}
+#[derive(Accounts)]
+pub struct StdGetPeer<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdGetPeer<'_> {
+    pub fn apply(_ctx: &Context<Self>, _params: &GetPeerParams) -> Result<[u8; 32]> {
+        unimplemented!()
+    }
+}
+#[derive(Accounts)]
+pub struct StdToken<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdToken<'_> {
+    pub fn apply(_ctx: &Context<Self>) -> Result<Pubkey> {
+        unimplemented!()
+    }
+}
 #[program]
 pub mod my_program {
     use super::*;
@@ -27,7 +55,7 @@ pub mod my_program {
         mut ctx: Context<MyCustomAccounts>,
         params: SetPeerParams,
     ) -> Result<()> {
-        __test_instruction__set_peer_handler::set_peer(ctx, params)
+        __test_instruction__set_peer_handler::set_peer(&mut ctx, &params)
     }
     pub fn get_peer(
         ctx: Context<StdGetPeer>,
@@ -39,7 +67,7 @@ pub mod my_program {
         mut ctx: Context<MyReceive>,
         params: LzReceiveParams,
     ) -> Result<()> {
-        __test_instruction__lz_receive_handler::lz_receive(ctx, params)
+        __test_instruction__lz_receive_handler::lz_receive(&mut ctx, &params)
     }
     pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
         StdToken::apply(&ctx)

package/tests/snapshots/snapshots__tests__snapshot_handler_override.snap

@@ -4,25 +4,55 @@ expression: output
 ---
 mod __test_instruction__set_peer_handler {
     use super::*;
-    pub fn set_peer(ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
+    pub fn set_peer(
+        ctx: &mut Context<StdSetPeer>,
+        params: &SetPeerParams,
+    ) -> Result<()> {
         msg!("custom set_peer logic");
         Ok(())
     }
 }
 mod __test_instruction__lz_receive_handler {
     use super::*;
-    pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+    pub fn lz_receive(
+        ctx: &mut Context<MyReceive>,
+        params: &LzReceiveParams,
+    ) -> Result<()> {
         Ok(())
     }
 }
-struct StdSetPeer;
-struct StdGetPeer;
-struct StdToken;
+#[derive(Accounts)]
+pub struct StdSetPeer<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdSetPeer<'_> {
+    pub fn apply(_ctx: &mut Context<Self>, _params: &SetPeerParams) -> Result<()> {
+        unimplemented!()
+    }
+}
+#[derive(Accounts)]
+pub struct StdGetPeer<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdGetPeer<'_> {
+    pub fn apply(_ctx: &Context<Self>, _params: &GetPeerParams) -> Result<[u8; 32]> {
+        unimplemented!()
+    }
+}
+#[derive(Accounts)]
+pub struct StdToken<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdToken<'_> {
+    pub fn apply(_ctx: &Context<Self>) -> Result<Pubkey> {
+        unimplemented!()
+    }
+}
 #[program]
 pub mod my_program {
     use super::*;
     pub fn set_peer(mut ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
-        __test_instruction__set_peer_handler::set_peer(ctx, params)
+        __test_instruction__set_peer_handler::set_peer(&mut ctx, &params)
     }
     pub fn get_peer(
         ctx: Context<StdGetPeer>,
@@ -34,7 +64,7 @@ pub mod my_program {
         mut ctx: Context<MyReceive>,
         params: LzReceiveParams,
     ) -> Result<()> {
-        __test_instruction__lz_receive_handler::lz_receive(ctx, params)
+        __test_instruction__lz_receive_handler::lz_receive(&mut ctx, &params)
     }
     pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
         StdToken::apply(&ctx)

package/tests/snapshots/snapshots__tests__snapshot_mixed_overrides.snap

@@ -5,7 +5,10 @@ expression: output
 struct PreludeMarker;
 mod __test_instruction__set_peer_handler {
     use super::*;
-    pub fn set_peer(ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
+    pub fn set_peer(
+        ctx: &mut Context<StdSetPeer>,
+        params: &SetPeerParams,
+    ) -> Result<()> {
         msg!("handler override set_peer");
         Ok(())
     }
@@ -13,20 +16,48 @@ mod __test_instruction__set_peer_handler {
 mod __test_instruction__get_peer_handler {
     use super::*;
     pub fn get_peer(
-        ctx: Context<MyCustomGetPeer>,
-        params: GetPeerParams,
+        ctx: &Context<MyCustomGetPeer>,
+        params: &GetPeerParams,
     ) -> Result<[u8; 32]> {
         Ok([0u8; 32])
     }
 }
 mod __test_instruction__lz_receive_handler {
     use super::*;
-    pub fn lz_receive(ctx: Context<MyReceive>, params: LzReceiveParams) -> Result<()> {
+    pub fn lz_receive(
+        ctx: &mut Context<MyReceive>,
+        params: &LzReceiveParams,
+    ) -> Result<()> {
         Ok(())
     }
 }
-struct StdSetPeer;
-struct StdToken;
+#[derive(Accounts)]
+pub struct StdSetPeer<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdSetPeer<'_> {
+    pub fn apply(_ctx: &mut Context<Self>, _params: &SetPeerParams) -> Result<()> {
+        unimplemented!()
+    }
+}
+#[derive(Accounts)]
+pub struct StdGetPeer<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdGetPeer<'_> {
+    pub fn apply(_ctx: &Context<Self>, _params: &GetPeerParams) -> Result<[u8; 32]> {
+        unimplemented!()
+    }
+}
+#[derive(Accounts)]
+pub struct StdToken<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdToken<'_> {
+    pub fn apply(_ctx: &Context<Self>) -> Result<Pubkey> {
+        unimplemented!()
+    }
+}
 #[program]
 pub mod my_program {
     use super::*;
@@ -37,19 +68,19 @@ pub mod my_program {
         value: u64,
     }
     pub fn set_peer(mut ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
-        __test_instruction__set_peer_handler::set_peer(ctx, params)
+        __test_instruction__set_peer_handler::set_peer(&mut ctx, &params)
     }
     pub fn get_peer(
         ctx: Context<MyCustomGetPeer>,
         params: GetPeerParams,
     ) -> Result<[u8; 32]> {
-        __test_instruction__get_peer_handler::get_peer(ctx, params)
+        __test_instruction__get_peer_handler::get_peer(&ctx, &params)
     }
     pub fn lz_receive(
         mut ctx: Context<MyReceive>,
         params: LzReceiveParams,
     ) -> Result<()> {
-        __test_instruction__lz_receive_handler::lz_receive(ctx, params)
+        __test_instruction__lz_receive_handler::lz_receive(&mut ctx, &params)
     }
     pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
         StdToken::apply(&ctx)

package/tests/snapshots/snapshots__tests__snapshot_with_extend_macro.snap

@@ -0,0 +1,82 @@
+---
+source: crates/anchor-trait/tests/snapshots.rs
+expression: output
+---
+mod __test_instruction__lz_receive_handler {
+    use super::*;
+    pub fn lz_receive(
+        ctx: &mut Context<MyReceive>,
+        params: &LzReceiveParams,
+    ) -> Result<()> {
+        Ok(())
+    }
+}
+#[derive(Accounts)]
+pub struct StdSetPeer<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdSetPeer<'_> {
+    pub fn apply(_ctx: &mut Context<Self>, _params: &SetPeerParams) -> Result<()> {
+        unimplemented!()
+    }
+}
+#[derive(Accounts)]
+pub struct StdGetPeer<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdGetPeer<'_> {
+    pub fn apply(_ctx: &Context<Self>, _params: &GetPeerParams) -> Result<[u8; 32]> {
+        unimplemented!()
+    }
+}
+#[derive(Accounts)]
+pub struct StdToken<'info> {
+    pub placeholder: UncheckedAccount<'info>,
+}
+impl StdToken<'_> {
+    pub fn apply(_ctx: &Context<Self>) -> Result<Pubkey> {
+        unimplemented!()
+    }
+}
+#[allow(unused_macros)]
+macro_rules! test_extend_accounts {
+    (set_peer, $name:ident, { $($extra:tt)* }) => {
+        #[derive(Accounts)] pub struct $name < 'info > { pub placeholder :
+        UncheckedAccount < 'info >, $($extra)* } impl $name < '_ > { pub fn apply(_ctx :
+        & mut Context < Self >, _params : & SetPeerParams) -> Result < () > {
+        unimplemented!() } }
+    };
+    (get_peer, $name:ident, { $($extra:tt)* }) => {
+        #[derive(Accounts)] pub struct $name < 'info > { pub placeholder :
+        UncheckedAccount < 'info >, $($extra)* } impl $name < '_ > { pub fn apply(_ctx :
+        & Context < Self >, _params : & GetPeerParams) -> Result < [u8; 32] > {
+        unimplemented!() } }
+    };
+    (token, $name:ident, { $($extra:tt)* }) => {
+        #[derive(Accounts)] pub struct $name < 'info > { pub placeholder :
+        UncheckedAccount < 'info >, $($extra)* } impl $name < '_ > { pub fn apply(_ctx :
+        & Context < Self >) -> Result < Pubkey > { unimplemented!() } }
+    };
+}
+#[program]
+pub mod my_program {
+    use super::*;
+    pub fn set_peer(mut ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
+        StdSetPeer::apply(&mut ctx, &params)
+    }
+    pub fn get_peer(
+        ctx: Context<StdGetPeer>,
+        params: GetPeerParams,
+    ) -> Result<[u8; 32]> {
+        StdGetPeer::apply(&ctx, &params)
+    }
+    pub fn lz_receive(
+        mut ctx: Context<MyReceive>,
+        params: LzReceiveParams,
+    ) -> Result<()> {
+        __test_instruction__lz_receive_handler::lz_receive(&mut ctx, &params)
+    }
+    pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
+        StdToken::apply(&ctx)
+    }
+}