@layerzerolabs/framework-solana-anchor-trait 0.2.88 → 0.2.90

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/framework-solana-anchor-trait",
-  "version": "0.2.88",
+  "version": "0.2.90",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -14,10 +14,10 @@
     "rustfmt.toml"
   ],
   "devDependencies": {
-    "@layerzerolabs/build-utils-solana": "0.2.88",
-    "@layerzerolabs/typescript-configuration": "0.2.88",
-    "@layerzerolabs/vm-tooling-solana": "0.2.88",
-    "@layerzerolabs/tsup-configuration": "0.2.88"
+    "@layerzerolabs/build-utils-solana": "0.2.90",
+    "@layerzerolabs/tsup-configuration": "0.2.90",
+    "@layerzerolabs/vm-tooling-solana": "0.2.90",
+    "@layerzerolabs/typescript-configuration": "0.2.90"
   },
   "publishConfig": {
     "access": "restricted",

package/src/generation.rs

@@ -44,6 +44,12 @@ pub struct DefaultImpl<Ctx> {
 /// 1. The concrete struct + impl — emitted as-is via [`to_definition`](Self::to_definition).
 /// 2. A `macro_rules!` rule — built by decomposing the struct into attrs/fields and replacing the
 ///    name with `$name` via [`to_extend_rule`](Self::to_extend_rule).
+///
+/// The struct may carry at most a single `'info` lifetime parameter. Extra
+/// type or const generics are rejected at expansion time — the entrypoint
+/// and extend-rule codegen paths reduce the type to a bare ident, so any
+/// non-`'info` generics would be silently dropped and produce malformed
+/// output.
 pub struct DefaultAccounts {
     /// Complete struct definition including attributes, name, generics, and fields.
     pub struct_type: ItemStruct,
@@ -187,12 +193,12 @@ fn generate_instruction<Ix: InstructionSet>(
     // Emit the entrypoint function, with or without a params argument.
     let entrypoints = match &spec.params_type {
         Some(params_type) => quote! {
-            pub fn #entry_fn_ident #fn_generics (#ctx_decl, params: #params_type) -> Result<#return_type> {
+            pub fn #entry_fn_ident #fn_generics (#ctx_decl, params: #params_type) -> ::anchor_lang::Result<#return_type> {
                 #dispatch(#ref_token ctx, &params)
             }
         },
         None => quote! {
-            pub fn #entry_fn_ident #fn_generics (#ctx_decl) -> Result<#return_type> {
+            pub fn #entry_fn_ident #fn_generics (#ctx_decl) -> ::anchor_lang::Result<#return_type> {
                 #dispatch(#ref_token ctx)
             }
         },

package/src/lib.rs

@@ -55,10 +55,13 @@ pub trait InstructionSet: Copy + Ord + 'static {
 /// Declares all instructions in one place, generating a named enum
 /// implementing [`InstructionSet`].
 ///
-/// Each `Variant => mod_name` pair maps an enum variant to the module
-/// whose `spec()` function provides the codegen descriptor. Appending
-/// `(ctx)` passes the [`CodegenContext`] reference to `spec(&ctx)`;
-/// without it, `spec()` is called with no arguments.
+/// Each `Variant => mod_name` pair maps an enum variant to a module whose
+/// `spec()` function provides the codegen descriptor. Each `mod_name` must
+/// be unique — two variants on the same module emit colliding entrypoints.
+///
+/// Appending `(ctx)` after `mod_name` routes to `mod_name::spec(&ctx)`
+/// with the [`CodegenContext`] reference; omitting it calls `spec()` with
+/// no arguments. The marker token is discarded — `ctx` is convention.
 ///
 /// Callers are responsible for declaring their own `mod` items before
 /// invoking this macro.
@@ -81,7 +84,10 @@ pub trait InstructionSet: Copy + Ord + 'static {
 /// ```
 #[macro_export]
 macro_rules! declare_instructions {
-    // Helper: dispatch spec call — with ctx marker passes ctx, without calls spec()
+    // Helper: dispatch spec call. The marker token (conventionally `ctx`) is a
+    // routing sigil — it picks the ctx-passing branch but is otherwise
+    // discarded, so any ident inside the parens produces equivalent generated
+    // code. Without the marker, `spec()` is called with no arguments.
     (@spec_call $ctx:ident, $mod_name:ident ( $marker:ident )) => {
         $mod_name::spec(&$ctx)
     };
@@ -95,7 +101,7 @@ macro_rules! declare_instructions {
             $( $variant, )+
         }
 
-        impl ::anchor_trait::InstructionSet for $name {
+        impl $crate::InstructionSet for $name {
             type Ctx = $ctx;
 
             fn all() -> &'static [Self] {
@@ -118,7 +124,7 @@ macro_rules! declare_instructions {
                 }
             }
 
-            fn spec(self, ctx: &$ctx) -> ::anchor_trait::InstructionSpec<$ctx> {
+            fn spec(self, ctx: &$ctx) -> $crate::InstructionSpec<$ctx> {
                 match self {
                     $( Self::$variant => $crate::declare_instructions!(@spec_call ctx, $mod_name $( ( $ctx_marker ) )? ), )+
                 }

package/tests/snapshots/snapshots__tests__snapshot_all_defaults.snap

@@ -41,22 +41,25 @@ pub mod my_program {
             Ok(())
         }
     }
-    pub fn set_peer(mut ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
+    pub fn set_peer(
+        mut ctx: Context<StdSetPeer>,
+        params: SetPeerParams,
+    ) -> ::anchor_lang::Result<()> {
         StdSetPeer::apply(&mut ctx, &params)
     }
     pub fn get_peer(
         ctx: Context<StdGetPeer>,
         params: GetPeerParams,
-    ) -> Result<[u8; 32]> {
+    ) -> ::anchor_lang::Result<[u8; 32]> {
         StdGetPeer::apply(&ctx, &params)
     }
     pub fn lz_receive(
         mut ctx: Context<MyReceive>,
         params: LzReceiveParams,
-    ) -> Result<()> {
+    ) -> ::anchor_lang::Result<()> {
         __test_instruction__lz_receive_handler::lz_receive(&mut ctx, &params)
     }
-    pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
+    pub fn token(ctx: Context<StdToken>) -> ::anchor_lang::Result<Pubkey> {
         StdToken::apply(&ctx)
     }
 }

package/tests/snapshots/snapshots__tests__snapshot_full_override.snap

@@ -54,22 +54,22 @@ pub mod my_program {
     pub fn set_peer(
         mut ctx: Context<MyCustomAccounts>,
         params: SetPeerParams,
-    ) -> Result<()> {
+    ) -> ::anchor_lang::Result<()> {
         __test_instruction__set_peer_handler::set_peer(&mut ctx, &params)
     }
     pub fn get_peer(
         ctx: Context<StdGetPeer>,
         params: GetPeerParams,
-    ) -> Result<[u8; 32]> {
+    ) -> ::anchor_lang::Result<[u8; 32]> {
         StdGetPeer::apply(&ctx, &params)
     }
     pub fn lz_receive(
         mut ctx: Context<MyReceive>,
         params: LzReceiveParams,
-    ) -> Result<()> {
+    ) -> ::anchor_lang::Result<()> {
         __test_instruction__lz_receive_handler::lz_receive(&mut ctx, &params)
     }
-    pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
+    pub fn token(ctx: Context<StdToken>) -> ::anchor_lang::Result<Pubkey> {
         StdToken::apply(&ctx)
     }
 }

package/tests/snapshots/snapshots__tests__snapshot_handler_override.snap

@@ -51,22 +51,25 @@ pub mod my_program {
             Ok(())
         }
     }
-    pub fn set_peer(mut ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
+    pub fn set_peer(
+        mut ctx: Context<StdSetPeer>,
+        params: SetPeerParams,
+    ) -> ::anchor_lang::Result<()> {
         __test_instruction__set_peer_handler::set_peer(&mut ctx, &params)
     }
     pub fn get_peer(
         ctx: Context<StdGetPeer>,
         params: GetPeerParams,
-    ) -> Result<[u8; 32]> {
+    ) -> ::anchor_lang::Result<[u8; 32]> {
         StdGetPeer::apply(&ctx, &params)
     }
     pub fn lz_receive(
         mut ctx: Context<MyReceive>,
         params: LzReceiveParams,
-    ) -> Result<()> {
+    ) -> ::anchor_lang::Result<()> {
         __test_instruction__lz_receive_handler::lz_receive(&mut ctx, &params)
     }
-    pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
+    pub fn token(ctx: Context<StdToken>) -> ::anchor_lang::Result<Pubkey> {
         StdToken::apply(&ctx)
     }
 }

package/tests/snapshots/snapshots__tests__snapshot_mixed_overrides.snap

@@ -67,22 +67,25 @@ pub mod my_program {
             Ok(())
         }
     }
-    pub fn set_peer(mut ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
+    pub fn set_peer(
+        mut ctx: Context<StdSetPeer>,
+        params: SetPeerParams,
+    ) -> ::anchor_lang::Result<()> {
         __test_instruction__set_peer_handler::set_peer(&mut ctx, &params)
     }
     pub fn get_peer(
         ctx: Context<MyCustomGetPeer>,
         params: GetPeerParams,
-    ) -> Result<[u8; 32]> {
+    ) -> ::anchor_lang::Result<[u8; 32]> {
         __test_instruction__get_peer_handler::get_peer(&ctx, &params)
     }
     pub fn lz_receive(
         mut ctx: Context<MyReceive>,
         params: LzReceiveParams,
-    ) -> Result<()> {
+    ) -> ::anchor_lang::Result<()> {
         __test_instruction__lz_receive_handler::lz_receive(&mut ctx, &params)
     }
-    pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
+    pub fn token(ctx: Context<StdToken>) -> ::anchor_lang::Result<Pubkey> {
         StdToken::apply(&ctx)
     }
 }

package/tests/snapshots/snapshots__tests__snapshot_with_extend_macro.snap

@@ -61,22 +61,25 @@ pub mod my_program {
             Ok(())
         }
     }
-    pub fn set_peer(mut ctx: Context<StdSetPeer>, params: SetPeerParams) -> Result<()> {
+    pub fn set_peer(
+        mut ctx: Context<StdSetPeer>,
+        params: SetPeerParams,
+    ) -> ::anchor_lang::Result<()> {
         StdSetPeer::apply(&mut ctx, &params)
     }
     pub fn get_peer(
         ctx: Context<StdGetPeer>,
         params: GetPeerParams,
-    ) -> Result<[u8; 32]> {
+    ) -> ::anchor_lang::Result<[u8; 32]> {
         StdGetPeer::apply(&ctx, &params)
     }
     pub fn lz_receive(
         mut ctx: Context<MyReceive>,
         params: LzReceiveParams,
-    ) -> Result<()> {
+    ) -> ::anchor_lang::Result<()> {
         __test_instruction__lz_receive_handler::lz_receive(&mut ctx, &params)
     }
-    pub fn token(ctx: Context<StdToken>) -> Result<Pubkey> {
+    pub fn token(ctx: Context<StdToken>) -> ::anchor_lang::Result<Pubkey> {
         StdToken::apply(&ctx)
     }
 }