Merge branch 'master' into svm-dev

Author: chrismaree

programs/svm-spoke/src/instructions/admin.rs

@@ -11,8 +11,8 @@ use crate::{
     event::{
         EmergencyDeleteRootBundle, EnabledDepositRoute, PausedDeposits, PausedFills, RelayedRootBundle, SetXDomainAdmin,
     },
-    initialize_current_time, set_seed,
     state::{RootBundle, Route, State},
+    utils::{initialize_current_time, set_seed},
 };
 
 #[derive(Accounts)]
@@ -35,13 +35,13 @@ pub struct Initialize<'info> {
 
 pub fn initialize(
     ctx: Context<Initialize>,
-    seed: u64,
-    initial_number_of_deposits: u32,
-    chain_id: u64,                  // Across definition of chainId for Solana.
-    remote_domain: u32,             // CCTP domain for Mainnet Ethereum.
-    cross_domain_admin: Pubkey,     // HubPool on Mainnet Ethereum.
-    deposit_quote_time_buffer: u32, // Deposit quote times can't be set more than this amount into the past/future.
-    fill_deadline_buffer: u32,      // Fill deadlines can't be set more than this amount into the future.
+    seed: u64,                       // Seed used to derive a new state to enable testing to reset between runs.
+    initial_number_of_deposits: u32, // Starting number of deposits to offset deposit_id.
+    chain_id: u64,                   // Across definition of chainId for Solana.
+    remote_domain: u32,              // CCTP domain for Mainnet Ethereum.
+    cross_domain_admin: Pubkey,      // HubPool on Mainnet Ethereum.
+    deposit_quote_time_buffer: u32,  // Deposit quote times can't be set more than this amount into the past/future.
+    fill_deadline_buffer: u32,       // Fill deadlines can't be set more than this amount into the future.
 ) -> Result<()> {
     let state = &mut ctx.accounts.state;
     state.owner = *ctx.accounts.signer.key;
@@ -99,11 +99,11 @@ pub fn pause_fills(ctx: Context<PauseFills>, pause: bool) -> Result<()> {
 
 #[derive(Accounts)]
 pub struct TransferOwnership<'info> {
-    #[account(mut, seeds = [b"state", state.seed.to_le_bytes().as_ref()], bump)]
-    pub state: Account<'info, State>,
-
     #[account(address = state.owner @ SvmError::NotOwner)]
     pub signer: Signer<'info>,
+
+    #[account(mut, seeds = [b"state", state.seed.to_le_bytes().as_ref()], bump)]
+    pub state: Account<'info, State>,
 }
 
 pub fn transfer_ownership(ctx: Context<TransferOwnership>, new_owner: Pubkey) -> Result<()> {
@@ -158,7 +158,7 @@ pub struct SetEnableRoute<'info> {
         ],
         bump
     )]
-    pub route: Account<'info, Route>,
+    pub route: Account<'info, Route>, // PDA to store route information for this particular token & chainId pair.
 
     #[account(
         init_if_needed,
@@ -167,11 +167,11 @@ pub struct SetEnableRoute<'info> {
         associated_token::authority = state,
         associated_token::token_program = token_program
     )]
-    pub vault: InterfaceAccount<'info, TokenAccount>,
+    pub vault: InterfaceAccount<'info, TokenAccount>, // ATA, owned by the state, to store the origin token for spoke.
 
     #[account(
         mint::token_program = token_program,
-        // IDL build fails when requiring `address = origin_token` for mint, thus using a custom constraint.
+        // IDL build fails when requiring address = origin_token for mint, thus using a custom constraint.
         constraint = origin_token_mint.key() == origin_token @ SvmError::InvalidMint
     )]
     pub origin_token_mint: InterfaceAccount<'info, Mint>,
@@ -211,7 +211,7 @@ pub struct RelayRootBundle<'info> {
     pub state: Account<'info, State>,
 
     #[account(
-        init, // Init to create root bundle account. Prevents re-initialization.
+        init, // Init to create root bundle account. Prevents re-initialization for a given root..
         payer = payer,
         space = DISCRIMINATOR_SIZE + RootBundle::INIT_SPACE,
         seeds = [b"root_bundle", state.seed.to_le_bytes().as_ref(), state.root_bundle_id.to_le_bytes().as_ref()],

programs/svm-spoke/src/instructions/bundle.rs

@@ -19,14 +19,15 @@ pub struct ExecuteRelayerRefundLeaf<'info> {
     pub signer: Signer<'info>,
 
     #[account(seeds = [b"instruction_params", signer.key().as_ref()], bump)]
-    pub instruction_params: Account<'info, ExecuteRelayerRefundLeafParams>,
+    pub instruction_params: Account<'info, ExecuteRelayerRefundLeafParams>, // Contains all leaf & proof information.
 
     #[account(seeds = [b"state", state.seed.to_le_bytes().as_ref()], bump)]
     pub state: Account<'info, State>,
 
     #[account(
         mut,
         seeds = [b"root_bundle", state.seed.to_le_bytes().as_ref(), instruction_params.root_bundle_id.to_le_bytes().as_ref()], bump,
+        // Realloc to let the size of the dynamic array within root_bundle to grow as leafs are executed.
         realloc = std::cmp::max(
             DISCRIMINATOR_SIZE + RootBundle::INIT_SPACE + instruction_params.relayer_refund_leaf.leaf_id as usize / 8,
             root_bundle.to_account_info().data_len()
@@ -39,7 +40,7 @@ pub struct ExecuteRelayerRefundLeaf<'info> {
     #[account(
         mut,
         associated_token::mint = mint,
-        associated_token::authority = state,
+        associated_token::authority = state, // Ensure owner is the state.
         associated_token::token_program = token_program
     )]
     pub vault: InterfaceAccount<'info, TokenAccount>,
@@ -51,7 +52,7 @@ pub struct ExecuteRelayerRefundLeaf<'info> {
     pub mint: InterfaceAccount<'info, Mint>,
 
     #[account(
-        init_if_needed,
+        init_if_needed, // If first time creating, initialize the liability tracker, else re-use.
         payer = signer,
         space = DISCRIMINATOR_SIZE + TransferLiability::INIT_SPACE,
         seeds = [b"transfer_liability", mint.key().as_ref()],
@@ -64,7 +65,6 @@ pub struct ExecuteRelayerRefundLeaf<'info> {
     pub system_program: Program<'info, System>,
 }
 
-// TODO: update UMIP to consider different encoding for different chains (evm and svm).
 #[derive(AnchorSerialize, AnchorDeserialize, Clone, InitSpace)]
 pub struct RelayerRefundLeaf {
     pub amount_to_return: u64,
@@ -104,7 +104,7 @@ pub fn execute_relayer_refund_leaf<'c, 'info>(
     deferred_refunds: bool,
 ) -> Result<()>
 where
-    'c: 'info, // The lifetime constraint `'c: 'info` ensures that the lifetime `'c` is at least as long as `'info`.
+    'c: 'info, // The lifetime constraint 'c: 'info ensures that the lifetime 'c is at least as long as 'info.
 {
     // Get pre-loaded instruction parameters.
     let instruction_params = &ctx.accounts.instruction_params;
@@ -155,7 +155,6 @@ where
         ctx.accounts.transfer_liability.pending_to_hub_pool += relayer_refund_leaf.amount_to_return;
     }
 
-    // Emit the ExecutedRelayerRefundRoot event
     emit_cpi!(ExecutedRelayerRefundRoot {
         amount_to_return: relayer_refund_leaf.amount_to_return,
         chain_id: relayer_refund_leaf.chain_id,

programs/svm-spoke/src/instructions/deposit.rs

@@ -1,13 +1,12 @@
-use anchor_lang::{prelude::*, solana_program::keccak};
+use anchor_lang::prelude::*;
 use anchor_spl::token_interface::{Mint, TokenAccount, TokenInterface};
 
 use crate::{
     constants::{MAX_EXCLUSIVITY_PERIOD_SECONDS, ZERO_DEPOSIT_ID},
     error::{CommonError, SvmError},
     event::V3FundsDeposited,
-    get_current_time,
     state::{Route, State},
-    utils::transfer_from,
+    utils::{get_current_time, get_unsafe_deposit_id, transfer_from},
 };
 
 #[event_cpi]
@@ -50,7 +49,7 @@ pub struct DepositV3<'info> {
     #[account(
         mut,
         associated_token::mint = mint,
-        associated_token::authority = state,
+        associated_token::authority = state, // Ensure owner is the state as tokens are sent here on deposit.
         associated_token::token_program = token_program
     )]
     pub vault: InterfaceAccount<'info, TokenAccount>,
@@ -247,14 +246,3 @@ pub fn unsafe_deposit_v3(
 
     Ok(())
 }
-
-// Define a dummy context struct so we can export this as a view function in lib.
-#[derive(Accounts)]
-pub struct Null {}
-pub fn get_unsafe_deposit_id(msg_sender: Pubkey, depositor: Pubkey, deposit_nonce: u64) -> [u8; 32] {
-    let mut data = Vec::new();
-
-    AnchorSerialize::serialize(&(msg_sender, depositor, deposit_nonce), &mut data).unwrap();
-
-    keccak::hash(&data).to_bytes()
-}

programs/svm-spoke/src/instructions/fill.rs

@@ -10,9 +10,8 @@ use crate::{
     constraints::is_relay_hash_valid,
     error::{CommonError, SvmError},
     event::{FillType, FilledV3Relay, V3RelayExecutionEventInfo},
-    get_current_time,
     state::{FillStatus, FillStatusAccount, State},
-    utils::{hash_non_empty_message, invoke_handler, transfer_from},
+    utils::{get_current_time, hash_non_empty_message, invoke_handler, transfer_from},
 };
 
 #[event_cpi]
@@ -33,20 +32,20 @@ pub struct FillV3Relay<'info> {
         mint::token_program = token_program,
         address = relay_data.output_token @ SvmError::InvalidMint
     )]
-    pub mint_account: InterfaceAccount<'info, Mint>,
+    pub mint: InterfaceAccount<'info, Mint>,
 
     #[account(
         mut,
-        token::mint = mint_account,
+        token::mint = mint,
         token::authority = signer,
         token::token_program = token_program
     )]
     pub relayer_token_account: InterfaceAccount<'info, TokenAccount>,
 
     #[account(
         mut,
-        associated_token::mint = mint_account,
-        associated_token::authority = relay_data.recipient,
+        associated_token::mint = mint,
+        associated_token::authority = relay_data.recipient, // Ensures tokens go to ATA owned by the recipient.
         associated_token::token_program = token_program
     )]
     pub recipient_token_account: InterfaceAccount<'info, TokenAccount>,
@@ -108,7 +107,7 @@ pub fn fill_v3_relay<'info>(
             relay_data.output_amount,
             state,
             ctx.bumps.state,
-            &ctx.accounts.mint_account,
+            &ctx.accounts.mint,
             &ctx.accounts.token_program,
         )?;
     }
@@ -125,7 +124,6 @@ pub fn fill_v3_relay<'info>(
         )?;
     }
 
-    // Emit the FilledV3Relay event
     // Empty message is not hashed and emits zeroed bytes32 for easier human observability.
     let message_hash = hash_non_empty_message(&relay_data.message);
 
@@ -169,7 +167,6 @@ pub struct CloseFillPda<'info> {
         seeds = [b"fills", relay_hash.as_ref()],
         bump,
         close = signer,
-        // Make sure caller provided relay_hash used in PDA seeds is valid.
         constraint = is_relay_hash_valid(&relay_hash, &relay_data, &state) @ SvmError::InvalidRelayHash
     )]
     pub fill_status: Account<'info, FillStatusAccount>,

programs/svm-spoke/src/instructions/handle_receive_message.rs

@@ -7,15 +7,14 @@ use crate::{
     constants::MESSAGE_TRANSMITTER_PROGRAM_ID,
     error::{CallDataError, SvmError},
     program::SvmSpoke,
+    state::State,
     utils::{self, EncodeInstructionData},
-    State,
 };
 
 #[derive(Accounts)]
 #[instruction(params: HandleReceiveMessageParams)]
 pub struct HandleReceiveMessage<'info> {
-    // authority_pda is a Signer to ensure that this instruction
-    // can only be called by Message Transmitter
+    // authority_pda is a Signer to ensure that this instruction can only be called by the Message Transmitter.
     #[account(
         seeds = [b"message_transmitter_authority", SvmSpoke::id().as_ref()],
         bump = params.authority_bump,

programs/svm-spoke/src/instructions/mod.rs

@@ -7,7 +7,6 @@ mod handle_receive_message;
 mod instruction_params;
 mod refund_claims;
 mod slow_fill;
-mod testable;
 mod token_bridge;
 
 pub use admin::*;
@@ -19,5 +18,4 @@ pub use handle_receive_message::*;
 pub use instruction_params::*;
 pub use refund_claims::*;
 pub use slow_fill::*;
-pub use testable::*;
 pub use token_bridge::*;

programs/svm-spoke/src/instructions/refund_claims.rs

@@ -99,7 +99,6 @@ pub fn claim_relayer_refund(ctx: Context<ClaimRelayerRefund>) -> Result<()> {
     );
     transfer_checked(cpi_context, claim_amount, ctx.accounts.mint.decimals)?;
 
-    // Emit the ClaimedRelayerRefund event.
     emit_cpi!(ClaimedRelayerRefund {
         l2_token_address: ctx.accounts.mint.key(),
         claim_amount,
@@ -181,15 +180,13 @@ pub fn claim_relayer_refund_for(ctx: Context<ClaimRelayerRefundFor>, refund_addr
     );
     transfer_checked(cpi_context, claim_amount, ctx.accounts.mint.decimals)?;
 
-    // Emit the ClaimedRelayerRefund event.
     emit_cpi!(ClaimedRelayerRefund {
         l2_token_address: ctx.accounts.mint.key(),
         claim_amount,
         refund_address,
     });
 
     // There is no need to reset the claim amount as the account will be closed at the end of instruction.
-
     Ok(())
 }
 

programs/svm-spoke/src/instructions/slow_fill.rs

@@ -1,22 +1,20 @@
 use anchor_lang::{prelude::*, solana_program::keccak};
 use anchor_spl::token_interface::{transfer_checked, Mint, TokenAccount, TokenInterface, TransferChecked};
 
+use crate::event::{FillType, FilledV3Relay, RequestedV3SlowFill, V3RelayExecutionEventInfo};
 use crate::{
     common::V3RelayData,
     constants::DISCRIMINATOR_SIZE,
     constraints::is_relay_hash_valid,
     error::{CommonError, SvmError},
-    get_current_time,
     state::{FillStatus, FillStatusAccount, RootBundle, State},
-    utils::{hash_non_empty_message, invoke_handler, verify_merkle_proof},
+    utils::{get_current_time, hash_non_empty_message, invoke_handler, verify_merkle_proof},
 };
 
-use crate::event::{FillType, FilledV3Relay, RequestedV3SlowFill, V3RelayExecutionEventInfo};
-
 #[event_cpi]
 #[derive(Accounts)]
 #[instruction(relay_hash: [u8; 32], relay_data: V3RelayData)]
-pub struct SlowFillV3Relay<'info> {
+pub struct RequestV3SlowFill<'info> {
     #[account(mut)]
     pub signer: Signer<'info>,
 
@@ -33,14 +31,13 @@ pub struct SlowFillV3Relay<'info> {
         space = DISCRIMINATOR_SIZE + FillStatusAccount::INIT_SPACE,
         seeds = [b"fills", relay_hash.as_ref()],
         bump,
-        // Make sure caller provided relay_hash used in PDA seeds is valid.
         constraint = is_relay_hash_valid(&relay_hash, &relay_data, &state) @ SvmError::InvalidRelayHash
     )]
     pub fill_status: Account<'info, FillStatusAccount>,
     pub system_program: Program<'info, System>,
 }
 
-pub fn request_v3_slow_fill(ctx: Context<SlowFillV3Relay>, relay_data: V3RelayData) -> Result<()> {
+pub fn request_v3_slow_fill(ctx: Context<RequestV3SlowFill>, relay_data: V3RelayData) -> Result<()> {
     let state = &ctx.accounts.state;
 
     let current_time = get_current_time(state)?;
@@ -53,18 +50,16 @@ pub fn request_v3_slow_fill(ctx: Context<SlowFillV3Relay>, relay_data: V3RelayDa
         return err!(CommonError::ExpiredFillDeadline);
     }
 
-    // Check the fill status
+    // Check the fill status is unfilled.
     let fill_status_account = &mut ctx.accounts.fill_status;
     if fill_status_account.status != FillStatus::Unfilled {
         return err!(CommonError::InvalidSlowFillRequest);
     }
 
-    // Update the fill status to RequestedSlowFill
-    fill_status_account.status = FillStatus::RequestedSlowFill;
+    fill_status_account.status = FillStatus::RequestedSlowFill; // Update the fill status to RequestedSlowFill
     fill_status_account.relayer = ctx.accounts.signer.key();
 
-    // Emit the RequestedV3SlowFill event
-    // Empty message is not hashed and emits zeroed bytes32 for easier human observability.
+    // Emit the RequestedV3SlowFill event. Empty message is not hashed and emits zeroed bytes32 for easier observability
     let message_hash = hash_non_empty_message(&relay_data.message);
 
     emit_cpi!(RequestedV3SlowFill {
@@ -85,7 +80,6 @@ pub fn request_v3_slow_fill(ctx: Context<SlowFillV3Relay>, relay_data: V3RelayDa
     Ok(())
 }
 
-// Define the V3SlowFill struct
 #[derive(AnchorSerialize, AnchorDeserialize, Clone)]
 pub struct V3SlowFill {
     pub relay_data: V3RelayData,
@@ -112,7 +106,6 @@ impl V3SlowFill {
     }
 }
 
-// Define the V3SlowFill struct
 #[event_cpi]
 #[derive(Accounts)]
 #[instruction(relay_hash: [u8; 32], slow_fill_leaf: V3SlowFill, root_bundle_id: u32)]
@@ -223,7 +216,6 @@ pub fn execute_v3_slow_relay_leaf<'info>(
         )?;
     }
 
-    // Emit the FilledV3Relay event
     // Empty message is not hashed and emits zeroed bytes32 for easier human observability.
     let message_hash = hash_non_empty_message(&relay_data.message);