SparseSwap

programs/whirlpool/Cargo.toml

@@ -23,6 +23,8 @@ solana-program = "1.17"
 thiserror = "1.0"
 uint = {version = "0.9.1", default-features = false}
 borsh09 = {package = "borsh", version = "0.9.1"}
+arrayref = "0.3.7"
+bytemuck = "1.14.3"
 solana-security-txt = { version = "=1.1.1" }
 
 [dev-dependencies]

programs/whirlpool/src/errors.rs

@@ -135,6 +135,11 @@ pub enum ErrorCode {
 
     #[msg("Same accounts type is provided more than once")]
     RemainingAccountsDuplicatedAccountsType, // 0x17a5 (6053)
+
+    #[msg("Too many supplemental tick arrays provided")]
+    TooManySupplementalTickArrays, // 0x17a6 (6054)
+    #[msg("TickArray account for different whirlpool provided")]
+    DifferentWhirlpoolTickArrayAccount, // 0x17a7 (6055)
 }
 
 impl From<TryFromIntError> for ErrorCode {

programs/whirlpool/src/instructions/swap.rs

@@ -4,8 +4,8 @@ use anchor_spl::token::{self, Token, TokenAccount};
 use crate::{
     errors::ErrorCode,
     manager::swap_manager::*,
-    state::{TickArray, Whirlpool},
-    util::{to_timestamp_u64, update_and_swap_whirlpool, SwapTickSequence},
+    state::Whirlpool,
+    util::{to_timestamp_u64, update_and_swap_whirlpool, SparseSwapTickSequenceBuilder},
 };
 
 #[derive(Accounts)]
@@ -28,14 +28,17 @@ pub struct Swap<'info> {
     #[account(mut, address = whirlpool.token_vault_b)]
     pub token_vault_b: Box<Account<'info, TokenAccount>>,
 
-    #[account(mut, has_one = whirlpool)]
-    pub tick_array_0: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_0: UncheckedAccount<'info>,
 
-    #[account(mut, has_one = whirlpool)]
-    pub tick_array_1: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_1: UncheckedAccount<'info>,
 
-    #[account(mut, has_one = whirlpool)]
-    pub tick_array_2: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_2: UncheckedAccount<'info>,
 
     #[account(seeds = [b"oracle", whirlpool.key().as_ref()],bump)]
     /// CHECK: Oracle is currently unused and will be enabled on subsequent updates
@@ -54,12 +57,19 @@ pub fn handler(
     let clock = Clock::get()?;
     // Update the global reward growth which increases as a function of time.
     let timestamp = to_timestamp_u64(clock.unix_timestamp)?;
-    let mut swap_tick_sequence = SwapTickSequence::new(
-        ctx.accounts.tick_array_0.load_mut().unwrap(),
-        ctx.accounts.tick_array_1.load_mut().ok(),
-        ctx.accounts.tick_array_2.load_mut().ok(),
-    );
 
+    let builder = SparseSwapTickSequenceBuilder::try_from(
+        whirlpool,
+        a_to_b,
+        vec![
+            ctx.accounts.tick_array_0.to_account_info(),
+            ctx.accounts.tick_array_1.to_account_info(),
+            ctx.accounts.tick_array_2.to_account_info(),
+        ],
+        None,
+    )?;
+    let mut swap_tick_sequence = builder.build()?;
+
     let swap_update = swap(
         &whirlpool,
         &mut swap_tick_sequence,

programs/whirlpool/src/instructions/two_hop_swap.rs

@@ -4,8 +4,8 @@ use anchor_spl::token::{self, Token, TokenAccount};
 use crate::{
     errors::ErrorCode,
     manager::swap_manager::*,
-    state::{TickArray, Whirlpool},
-    util::{to_timestamp_u64, update_and_swap_whirlpool, SwapTickSequence},
+    state::Whirlpool,
+    util::{to_timestamp_u64, update_and_swap_whirlpool, SparseSwapTickSequenceBuilder},
 };
 
 #[derive(Accounts)]
@@ -41,23 +41,29 @@ pub struct TwoHopSwap<'info> {
     #[account(mut, address = whirlpool_two.token_vault_b)]
     pub token_vault_two_b: Box<Account<'info, TokenAccount>>,
 
-    #[account(mut, constraint = tick_array_one_0.load()?.whirlpool == whirlpool_one.key())]
-    pub tick_array_one_0: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_one_0: UncheckedAccount<'info>,
 
-    #[account(mut, constraint = tick_array_one_1.load()?.whirlpool == whirlpool_one.key())]
-    pub tick_array_one_1: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_one_1: UncheckedAccount<'info>,
 
-    #[account(mut, constraint = tick_array_one_2.load()?.whirlpool == whirlpool_one.key())]
-    pub tick_array_one_2: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_one_2: UncheckedAccount<'info>,
 
-    #[account(mut, constraint = tick_array_two_0.load()?.whirlpool == whirlpool_two.key())]
-    pub tick_array_two_0: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_two_0: UncheckedAccount<'info>,
 
-    #[account(mut, constraint = tick_array_two_1.load()?.whirlpool == whirlpool_two.key())]
-    pub tick_array_two_1: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_two_1: UncheckedAccount<'info>,
 
-    #[account(mut, constraint = tick_array_two_2.load()?.whirlpool == whirlpool_two.key())]
-    pub tick_array_two_2: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_two_2: UncheckedAccount<'info>,
 
     #[account(seeds = [b"oracle", whirlpool_one.key().as_ref()],bump)]
     /// CHECK: Oracle is currently unused and will be enabled on subsequent updates
@@ -105,17 +111,29 @@ pub fn handler(
         return Err(ErrorCode::InvalidIntermediaryMint.into());
     }
 
-    let mut swap_tick_sequence_one = SwapTickSequence::new(
-        ctx.accounts.tick_array_one_0.load_mut().unwrap(),
-        ctx.accounts.tick_array_one_1.load_mut().ok(),
-        ctx.accounts.tick_array_one_2.load_mut().ok(),
-    );
-
-    let mut swap_tick_sequence_two = SwapTickSequence::new(
-        ctx.accounts.tick_array_two_0.load_mut().unwrap(),
-        ctx.accounts.tick_array_two_1.load_mut().ok(),
-        ctx.accounts.tick_array_two_2.load_mut().ok(),
-    );
+    let builder_one = SparseSwapTickSequenceBuilder::try_from(
+        whirlpool_one,
+        a_to_b_one,
+        vec![
+            ctx.accounts.tick_array_one_0.to_account_info(),
+            ctx.accounts.tick_array_one_1.to_account_info(),
+            ctx.accounts.tick_array_one_2.to_account_info(),
+        ],
+        None,
+    )?;
+    let mut swap_tick_sequence_one = builder_one.build()?;
+
+    let builder_two = SparseSwapTickSequenceBuilder::try_from(
+        whirlpool_two,
+        a_to_b_two,
+        vec![
+            ctx.accounts.tick_array_two_0.to_account_info(),
+            ctx.accounts.tick_array_two_1.to_account_info(),
+            ctx.accounts.tick_array_two_2.to_account_info(),
+        ],
+        None,
+    )?;
+    let mut swap_tick_sequence_two = builder_two.build()?;
 
     // TODO: WLOG, we could extend this to N-swaps, but the account inputs to the instruction would
     // need to be jankier and we may need to programatically map/verify rather than using anchor constraints

programs/whirlpool/src/instructions/v2/swap.rs

@@ -6,8 +6,8 @@ use crate::util::{calculate_transfer_fee_excluded_amount, calculate_transfer_fee
 use crate::{
     errors::ErrorCode,
     manager::swap_manager::*,
-    state::{TickArray, Whirlpool},
-    util::{to_timestamp_u64, v2::update_and_swap_whirlpool_v2, SwapTickSequence},
+    state::Whirlpool,
+    util::{to_timestamp_u64, v2::update_and_swap_whirlpool_v2, SwapTickSequence, SparseSwapTickSequenceBuilder},
     constants::transfer_memo,
 };
 
@@ -40,14 +40,17 @@ pub struct SwapV2<'info> {
     #[account(mut, address = whirlpool.token_vault_b)]
     pub token_vault_b: Box<InterfaceAccount<'info, TokenAccount>>,
 
-    #[account(mut, has_one = whirlpool)]
-    pub tick_array_0: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_0: UncheckedAccount<'info>,
 
-    #[account(mut, has_one = whirlpool)]
-    pub tick_array_1: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_1: UncheckedAccount<'info>,
 
-    #[account(mut, has_one = whirlpool)]
-    pub tick_array_2: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_2: UncheckedAccount<'info>,
 
     #[account(mut, seeds = [b"oracle", whirlpool.key().as_ref()], bump)]
     /// CHECK: Oracle is currently unused and will be enabled on subsequent updates
@@ -56,6 +59,7 @@ pub struct SwapV2<'info> {
     // remaining accounts
     // - accounts for transfer hook program of token_mint_a
     // - accounts for transfer hook program of token_mint_b
+    // - supplemental TickArray accounts
 }
 
 pub fn handler<'a, 'b, 'c, 'info>(
@@ -79,14 +83,21 @@ pub fn handler<'a, 'b, 'c, 'info>(
         &[
             AccountsType::TransferHookA,
             AccountsType::TransferHookB,
+            AccountsType::SupplementalTickArrays,
         ],
     )?;
 
-    let mut swap_tick_sequence = SwapTickSequence::new(
-        ctx.accounts.tick_array_0.load_mut().unwrap(),
-        ctx.accounts.tick_array_1.load_mut().ok(),
-        ctx.accounts.tick_array_2.load_mut().ok(),
-    );
+    let builder = SparseSwapTickSequenceBuilder::try_from(
+        whirlpool,
+        a_to_b,
+        vec![
+            ctx.accounts.tick_array_0.to_account_info(),
+            ctx.accounts.tick_array_1.to_account_info(),
+            ctx.accounts.tick_array_2.to_account_info(),
+        ],
+        remaining_accounts.supplemental_tick_arrays,
+    )?;
+    let mut swap_tick_sequence = builder.build()?;
 
     let swap_update = swap_with_transfer_fee_extension(
         &whirlpool,

programs/whirlpool/src/instructions/v2/two_hop_swap.rs

@@ -6,8 +6,8 @@ use crate::swap_with_transfer_fee_extension;
 use crate::util::{calculate_transfer_fee_excluded_amount, parse_remaining_accounts, update_and_two_hop_swap_whirlpool_v2, AccountsType, RemainingAccountsInfo};
 use crate::{
     errors::ErrorCode,
-    state::{TickArray, Whirlpool},
-    util::{to_timestamp_u64, SwapTickSequence},
+    state::Whirlpool,
+    util::{to_timestamp_u64, SparseSwapTickSequenceBuilder},
     constants::transfer_memo,
 };
 
@@ -55,23 +55,29 @@ pub struct TwoHopSwapV2<'info> {
 
     pub token_authority: Signer<'info>,
 
-    #[account(mut, constraint = tick_array_one_0.load()?.whirlpool == whirlpool_one.key())]
-    pub tick_array_one_0: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_one_0: UncheckedAccount<'info>,
 
-    #[account(mut, constraint = tick_array_one_1.load()?.whirlpool == whirlpool_one.key())]
-    pub tick_array_one_1: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_one_1: UncheckedAccount<'info>,
 
-    #[account(mut, constraint = tick_array_one_2.load()?.whirlpool == whirlpool_one.key())]
-    pub tick_array_one_2: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_one_2: UncheckedAccount<'info>,
 
-    #[account(mut, constraint = tick_array_two_0.load()?.whirlpool == whirlpool_two.key())]
-    pub tick_array_two_0: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_two_0: UncheckedAccount<'info>,
 
-    #[account(mut, constraint = tick_array_two_1.load()?.whirlpool == whirlpool_two.key())]
-    pub tick_array_two_1: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_two_1: UncheckedAccount<'info>,
 
-    #[account(mut, constraint = tick_array_two_2.load()?.whirlpool == whirlpool_two.key())]
-    pub tick_array_two_2: AccountLoader<'info, TickArray>,
+    #[account(mut)]
+    /// CHECK: checked in the handler
+    pub tick_array_two_2: UncheckedAccount<'info>,
 
     #[account(mut, seeds = [b"oracle", whirlpool_one.key().as_ref()], bump)]
     /// CHECK: Oracle is currently unused and will be enabled on subsequent updates
@@ -87,6 +93,8 @@ pub struct TwoHopSwapV2<'info> {
     // - accounts for transfer hook program of token_mint_input
     // - accounts for transfer hook program of token_mint_intermediate
     // - accounts for transfer hook program of token_mint_output
+    // - supplemental TickArray accounts for whirlpool_one
+    // - supplemental TickArray accounts for whirlpool_two
 }
 
 pub fn handler<'a, 'b, 'c, 'info>(
@@ -135,20 +143,34 @@ pub fn handler<'a, 'b, 'c, 'info>(
             AccountsType::TransferHookInput,
             AccountsType::TransferHookIntermediate,
             AccountsType::TransferHookOutput,
+            AccountsType::SupplementalTickArraysOne,
+            AccountsType::SupplementalTickArraysTwo,
         ],
     )?;
 
-    let mut swap_tick_sequence_one = SwapTickSequence::new(
-        ctx.accounts.tick_array_one_0.load_mut().unwrap(),
-        ctx.accounts.tick_array_one_1.load_mut().ok(),
-        ctx.accounts.tick_array_one_2.load_mut().ok(),
-    );
-
-    let mut swap_tick_sequence_two = SwapTickSequence::new(
-        ctx.accounts.tick_array_two_0.load_mut().unwrap(),
-        ctx.accounts.tick_array_two_1.load_mut().ok(),
-        ctx.accounts.tick_array_two_2.load_mut().ok(),
-    );
+    let builder_one = SparseSwapTickSequenceBuilder::try_from(
+        whirlpool_one,
+        a_to_b_one,
+        vec![
+            ctx.accounts.tick_array_one_0.to_account_info(),
+            ctx.accounts.tick_array_one_1.to_account_info(),
+            ctx.accounts.tick_array_one_2.to_account_info(),
+        ],
+        remaining_accounts.supplemental_tick_arrays_one,
+    )?;
+    let mut swap_tick_sequence_one = builder_one.build()?;
+
+    let builder_two = SparseSwapTickSequenceBuilder::try_from(
+        whirlpool_two,
+        a_to_b_two,
+        vec![
+            ctx.accounts.tick_array_two_0.to_account_info(),
+            ctx.accounts.tick_array_two_1.to_account_info(),
+            ctx.accounts.tick_array_two_2.to_account_info(),
+        ],
+        remaining_accounts.supplemental_tick_arrays_two,
+    )?;
+    let mut swap_tick_sequence_two = builder_two.build()?;
 
     // TODO: WLOG, we could extend this to N-swaps, but the account inputs to the instruction would
     // need to be jankier and we may need to programatically map/verify rather than using anchor constraints