chore: update composers

Author: St0rmBr3w

examples/oft-solana-composer-library/Cargo.lock

@@ -22,4 +22,5 @@ anchor-spl = "0.29.0"
 raydium-clmm-cpi = { git = "https://github.com/St0rmBr3w/raydium-cpi/", package = "raydium-clmm-cpi", branch = "anchor-0.29.0" }
 oapp = { git = "https://github.com/LayerZero-Labs/LayerZero-v2.git", rev = "34321ac15e47e0dafd25d66659e2f3d1b9b6db8f" }
 utils = { git = "https://github.com/LayerZero-Labs/LayerZero-v2.git", rev = "34321ac15e47e0dafd25d66659e2f3d1b9b6db8f" }
+spl-memo = "=4.0.0"
 solana-helper = "0.1.0"

examples/oft-solana-composer-library/programs/composer/Cargo.toml

@@ -1,63 +1,91 @@
+use crate::*;
 use anchor_lang::prelude::*;
-use anchor_spl::token::{Token, TokenAccount};
-use anchor_spl::token_interface::{Token2022};
+use anchor_spl::token::{Token};
+use anchor_spl::token_interface::{Token2022, TokenAccount, Mint};
 use raydium_clmm_cpi::cpi::accounts::SwapSingleV2;
 use raydium_clmm_cpi::cpi::swap_v2;
-use std::str::FromStr;
-
-// LayerZero / OApp endpoint CPI helpers:
+use raydium_clmm_cpi::{
+    program::RaydiumClmm,
+    states::{AmmConfig, ObservationState, PoolState},
+};
 use oapp::endpoint::{instructions::ClearComposeParams, ID as ENDPOINT_ID};
-use oapp::endpoint_cpi::{clear_compose};
+use oapp::endpoint_cpi::clear_compose;
 use oapp::LzComposeParams;
-
-// Use our minimal AmmV3 type instead of importing from the raydium_amm_v3 crate.
-#[derive(Clone, Debug)]
-pub struct AmmV3;
-
-impl anchor_lang::Id for AmmV3 {
-    fn id() -> Pubkey {
-        Pubkey::from_str("CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK").unwrap()
-    }
-}
+use spl_memo;
 
 #[derive(Accounts)]
 pub struct LzCompose<'info> {
-    #[account(seeds = [b"composer"], bump)]
-    pub lz_program: AccountInfo<'info>,
+    // Use the stored “oft” field as the unique seed.
+    #[account(
+        mut,
+        seeds = [COMPOSER_SEED, &composer.oft.to_bytes()],
+        bump = composer.bump
+    )]
+    pub composer: Account<'info, Composer>,
+
+    pub clmm_program: Program<'info, RaydiumClmm>,
+    /// The user performing the swap.
     pub payer: Signer<'info>,
-    #[account(seeds = [b"authority"], bump)]
-    pub authority: AccountInfo<'info>,
-    pub amm_config: AccountInfo<'info>,
+
+    /// The factory state to read protocol fees.
+    #[account(address = pool_state.load()?.amm_config)]
+    pub amm_config: Box<Account<'info, AmmConfig>>,
+
+    /// The program account of the pool in which the swap will be performed.
     #[account(mut)]
-    pub pool_state: AccountInfo<'info>,
+    pub pool_state: AccountLoader<'info, PoolState>,
+
+    /// The user token account for input token.
     #[account(mut)]
-    pub source_token_account: Account<'info, TokenAccount>,
+    pub input_token_account: Box<InterfaceAccount<'info, TokenAccount>>,
+
+    /// The user token account for output token.
     #[account(mut)]
-    pub dest_token_account: Account<'info, TokenAccount>,
+    pub output_token_account: Box<InterfaceAccount<'info, TokenAccount>>,
+
+    /// The vault token account for input token.
     #[account(mut)]
-    pub input_vault: AccountInfo<'info>,
+    pub input_vault: Box<InterfaceAccount<'info, TokenAccount>>,
+
+    /// The vault token account for output token.
     #[account(mut)]
-    pub output_vault: AccountInfo<'info>,
+    pub output_vault: Box<InterfaceAccount<'info, TokenAccount>>,
+
+    /// The program account for the most recent oracle observation.
+    #[account(mut, address = pool_state.load()?.observation_key)]
+    pub observation_state: AccountLoader<'info, ObservationState>,
+
+    /// SPL program for token transfers.
     pub token_program: Program<'info, Token>,
+
+    /// SPL program 2022 for token transfers.
     pub token_program_2022: Program<'info, Token2022>,
-    #[account(mut)]
-    pub input_token_mint: AccountInfo<'info>,
-    #[account(mut)]
-    pub output_token_mint: AccountInfo<'info>,
-    #[account(mut)]
-    pub observation_state: AccountInfo<'info>,
-    /// CHECK: Required for memo instructions.
-    pub memo_program: AccountInfo<'info>,
+
+    /// CHECK: Must match spl_memo::id().
+    #[account(address = spl_memo::id())]
+    pub memo_program: UncheckedAccount<'info>,
+
+    /// The mint of the input token vault.
+    #[account(address = input_vault.mint)]
+    pub input_vault_mint: Box<InterfaceAccount<'info, Mint>>,
+
+    /// The mint of the output token vault.
+    #[account(address = output_vault.mint)]
+    pub output_vault_mint: Box<InterfaceAccount<'info, Mint>>,
+
+    // Extra accounts required by the CPI.
+    /// The authority account for the swap.
+    pub authority: AccountInfo<'info>,
+
+    /// Tick arrays for the swap range.
     #[account(mut)]
     pub tick_array_lower: AccountInfo<'info>,
     #[account(mut)]
     pub tick_array_current: AccountInfo<'info>,
     #[account(mut)]
     pub tick_array_upper: AccountInfo<'info>,
-    pub raydium_program: Program<'info, AmmV3>,
 }
 
-/// Processes the lz_compose instruction.
 impl LzCompose<'_> {
     pub fn apply(ctx: &mut Context<LzCompose>, params: &LzComposeParams) -> Result<()> {
         let msg = &params.message;
@@ -66,38 +94,33 @@ impl LzCompose<'_> {
         let mut compose_from = [0u8; 32];
         compose_from.copy_from_slice(&msg[40..72]);
         let inner = &msg[72..];
-
         let min_amount_out = u64::from_be_bytes(inner[0..8].try_into().unwrap());
 
-        // Build the CPI accounts struct for Raydium's SwapSingleV2.
+        // Build CPI accounts struct.
         let cpi_accounts = SwapSingleV2 {
             payer: ctx.accounts.payer.to_account_info(),
             amm_config: ctx.accounts.amm_config.to_account_info(),
             pool_state: ctx.accounts.pool_state.to_account_info(),
-            input_token_account: ctx.accounts.source_token_account.to_account_info(),
-            output_token_account: ctx.accounts.dest_token_account.to_account_info(),
+            input_token_account: ctx.accounts.input_token_account.to_account_info(),
+            output_token_account: ctx.accounts.output_token_account.to_account_info(),
             input_vault: ctx.accounts.input_vault.to_account_info(),
             output_vault: ctx.accounts.output_vault.to_account_info(),
             observation_state: ctx.accounts.observation_state.to_account_info(),
             token_program: ctx.accounts.token_program.to_account_info(),
             token_program_2022: ctx.accounts.token_program_2022.to_account_info(),
             memo_program: ctx.accounts.memo_program.to_account_info(),
-            input_vault_mint: ctx.accounts.input_token_mint.to_account_info(),
-            output_vault_mint: ctx.accounts.output_token_mint.to_account_info(),
+            input_vault_mint: ctx.accounts.input_vault_mint.to_account_info(),
+            output_vault_mint: ctx.accounts.output_vault_mint.to_account_info(),
         };
 
-        // Build the CPI context with the Raydium CLMM program.
-        let mut cpi_ctx =
-            CpiContext::new(ctx.accounts.raydium_program.to_account_info(), cpi_accounts);
-
-        // Attach remaining accounts in the exact order required.
+        let mut cpi_ctx = CpiContext::new(ctx.accounts.clmm_program.to_account_info(), cpi_accounts);
         cpi_ctx = cpi_ctx.with_remaining_accounts(vec![
             ctx.accounts.payer.to_account_info(),
             ctx.accounts.authority.to_account_info(),
             ctx.accounts.amm_config.to_account_info(),
             ctx.accounts.pool_state.to_account_info(),
-            ctx.accounts.source_token_account.to_account_info(),
-            ctx.accounts.dest_token_account.to_account_info(),
+            ctx.accounts.input_token_account.to_account_info(),
+            ctx.accounts.output_token_account.to_account_info(),
             ctx.accounts.input_vault.to_account_info(),
             ctx.accounts.output_vault.to_account_info(),
             ctx.accounts.observation_state.to_account_info(),
@@ -106,29 +129,28 @@ impl LzCompose<'_> {
             ctx.accounts.tick_array_upper.to_account_info(),
         ]);
 
-        // Execute the CPI swap call.
-        swap_v2(
-            cpi_ctx,
-            amount_ld,
-            min_amount_out,
-            0u128, // sqrt_price_limit_x64 (adjust as needed)
-            true,  // is_base_input
-        )?;
+        swap_v2(cpi_ctx, amount_ld, min_amount_out, 0u128, true)?;
+
+        // Use the stored "oft" field as the seed instead of a non-existent “id”.
+        let seeds: &[&[u8]] = &[
+            COMPOSER_SEED,
+            &ctx.accounts.composer.oft.to_bytes(),
+            &[ctx.accounts.composer.bump],
+        ];
 
-        // Clear the LayerZero compose message.
         let clear_params = ClearComposeParams {
-            from: compose_from.into(),
+            from: params.from,
             guid: params.guid,
             index: params.index,
             message: params.message.clone(),
         };
 
         clear_compose(
             ENDPOINT_ID,
-            ctx.accounts.lz_program.key(),
+            ctx.accounts.composer.key(),
             &ctx.remaining_accounts,
-            &[b"composer"],
+            seeds,
             clear_params,
         )
     }
-}
+}