@sudobility/contracts 0.15.1 → 1.9.0

package/programs/mailer/tests/integration_tests.rs

@@ -1,4 +1,3 @@
-use borsh::BorshDeserialize;
 use solana_program::{
     instruction::{AccountMeta, Instruction},
     program_pack::Pack,
@@ -14,10 +13,11 @@ use spl_token::{
     instruction as spl_instruction,
     state::{Account as TokenAccount, Mint},
 };
+use borsh::BorshDeserialize;
 use std::str::FromStr;
 
 // Import our program
-use mailer::{Delegation, MailerInstruction, MailerState, RecipientClaim};
+use mailer::{MailerInstruction, MailerState, RecipientClaim, Delegation};
 
 // Program ID for tests
 const PROGRAM_ID_STR: &str = "9FLkBDGpZBcR8LMsQ7MwwV6X9P4TDFgN3DeRh5qYyHJF";
@@ -51,8 +51,7 @@ async fn create_usdc_mint(
                 &payer.pubkey(),
                 None,
                 6, // USDC has 6 decimals
-            )
-            .unwrap(),
+            ).unwrap(),
         ],
         Some(&payer.pubkey()),
     );
@@ -83,8 +82,12 @@ async fn create_token_account(
                 TokenAccount::LEN as u64,
                 &spl_token::id(),
             ),
-            spl_instruction::initialize_account(&spl_token::id(), &account.pubkey(), mint, owner)
-                .unwrap(),
+            spl_instruction::initialize_account(
+                &spl_token::id(),
+                &account.pubkey(),
+                mint,
+                owner,
+            ).unwrap(),
         ],
         Some(&payer.pubkey()),
     );
@@ -111,8 +114,7 @@ async fn mint_to(
             &payer.pubkey(),
             &[],
             amount,
-        )
-        .unwrap()],
+        ).unwrap()],
         Some(&payer.pubkey()),
     );
     transaction.sign(&[payer], recent_blockhash);
@@ -168,7 +170,7 @@ async fn test_initialize_program() {
     // Verify the mailer state was initialized correctly
     let account = banks_client.get_account(mailer_pda).await.unwrap().unwrap();
     let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &account.data[8..]).unwrap();
-
+    
     assert_eq!(mailer_state.owner, payer.pubkey());
     assert_eq!(mailer_state.usdc_mint, usdc_mint);
     assert_eq!(mailer_state.send_fee, 100_000); // 0.1 USDC
@@ -188,7 +190,7 @@ async fn test_send_priority_message() {
     // Create USDC mint and accounts
     let usdc_mint = create_usdc_mint(&mut banks_client, &payer, recent_blockhash).await;
     let (mailer_pda, _) = get_mailer_pda();
-
+    
     // Initialize the program first
     let init_instruction = Instruction::new_with_borsh(
         program_id(),
@@ -205,33 +207,11 @@ async fn test_send_priority_message() {
     banks_client.process_transaction(transaction).await.unwrap();
 
     // Create token accounts
-    let sender_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &payer.pubkey(),
-    )
-    .await;
-    let mailer_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &mailer_pda,
-    )
-    .await;
-
+    let sender_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &payer.pubkey()).await;
+    let mailer_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &mailer_pda).await;
+    
     // Mint USDC to sender
-    mint_to(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &sender_usdc,
-        1_000_000,
-    )
-    .await; // 1 USDC
+    mint_to(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &sender_usdc, 1_000_000).await; // 1 USDC
 
     // Get recipient claim PDA
     let (recipient_claim_pda, _) = get_claim_pda(&payer.pubkey());
@@ -267,22 +247,16 @@ async fn test_send_priority_message() {
     let _recent_blockhash = banks_client.get_latest_blockhash().await.unwrap();
 
     // Verify recipient claim was created with correct amount
-    let claim_account = banks_client
-        .get_account(recipient_claim_pda)
-        .await
-        .unwrap()
-        .unwrap();
-    let recipient_claim: RecipientClaim =
-        BorshDeserialize::deserialize(&mut &claim_account.data[8..]).unwrap();
-
+    let claim_account = banks_client.get_account(recipient_claim_pda).await.unwrap().unwrap();
+    let recipient_claim: RecipientClaim = BorshDeserialize::deserialize(&mut &claim_account.data[8..]).unwrap();
+    
     assert_eq!(recipient_claim.recipient, payer.pubkey());
     assert_eq!(recipient_claim.amount, 90_000); // 90% of send_fee (100,000)
 
     // Verify mailer state was updated with owner share
     let mailer_account = banks_client.get_account(mailer_pda).await.unwrap().unwrap();
-    let mailer_state: MailerState =
-        BorshDeserialize::deserialize(&mut &mailer_account.data[8..]).unwrap();
-
+    let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_account.data[8..]).unwrap();
+    
     // Debug output
     println!("Debug - Mailer state:");
     println!("  owner: {}", mailer_state.owner);
@@ -291,7 +265,7 @@ async fn test_send_priority_message() {
     println!("  delegation_fee: {}", mailer_state.delegation_fee);
     println!("  owner_claimable: {}", mailer_state.owner_claimable);
     println!("  bump: {}", mailer_state.bump);
-
+    
     assert_eq!(mailer_state.owner_claimable, 10_000); // 10% of send_fee
 }
 
@@ -307,7 +281,7 @@ async fn test_send_standard_message() {
     // Setup similar to priority test
     let usdc_mint = create_usdc_mint(&mut banks_client, &payer, recent_blockhash).await;
     let (mailer_pda, _) = get_mailer_pda();
-
+    
     // Initialize the program
     let init_instruction = Instruction::new_with_borsh(
         program_id(),
@@ -324,33 +298,11 @@ async fn test_send_standard_message() {
     banks_client.process_transaction(transaction).await.unwrap();
 
     // Create token accounts
-    let sender_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &payer.pubkey(),
-    )
-    .await;
-    let mailer_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &mailer_pda,
-    )
-    .await;
-
+    let sender_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &payer.pubkey()).await;
+    let mailer_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &mailer_pda).await;
+    
     // Mint USDC to sender
-    mint_to(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &sender_usdc,
-        1_000_000,
-    )
-    .await;
+    mint_to(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &sender_usdc, 1_000_000).await;
 
     // Get recipient claim PDA (needed even if not used for standard send)
     let (recipient_claim_pda, _) = get_claim_pda(&payer.pubkey());
@@ -384,207 +336,7 @@ async fn test_send_standard_message() {
 
     // Verify only owner fee was charged (10% of send_fee = 10,000)
     let mailer_account = banks_client.get_account(mailer_pda).await.unwrap().unwrap();
-    let mailer_state: MailerState =
-        BorshDeserialize::deserialize(&mut &mailer_account.data[8..]).unwrap();
-    assert_eq!(mailer_state.owner_claimable, 10_000); // Only 10% fee
-}
-
-#[tokio::test]
-async fn test_send_through_webhook_priority() {
-    let program_test = ProgramTest::new(
-        "mailer",
-        program_id(),
-        processor!(mailer::process_instruction),
-    );
-    let (mut banks_client, payer, recent_blockhash) = program_test.start().await;
-
-    // Setup similar to priority test
-    let usdc_mint = create_usdc_mint(&mut banks_client, &payer, recent_blockhash).await;
-    let (mailer_pda, _) = get_mailer_pda();
-
-    // Initialize the program
-    let init_instruction = Instruction::new_with_borsh(
-        program_id(),
-        &MailerInstruction::Initialize { usdc_mint },
-        vec![
-            AccountMeta::new(payer.pubkey(), true),
-            AccountMeta::new(mailer_pda, false),
-            AccountMeta::new_readonly(system_program::id(), false),
-        ],
-    );
-
-    let mut transaction = Transaction::new_with_payer(&[init_instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Create token accounts
-    let sender_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &payer.pubkey(),
-    )
-    .await;
-    let mailer_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &mailer_pda,
-    )
-    .await;
-
-    // Mint USDC to sender
-    mint_to(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &sender_usdc,
-        1_000_000,
-    )
-    .await; // 1 USDC
-
-    // Get recipient claim PDA
-    let (recipient_claim_pda, _) = get_claim_pda(&payer.pubkey());
-
-    // Send message through webhook with revenue sharing (priority mode)
-    let instruction_data = MailerInstruction::SendThroughWebhook {
-        to: payer.pubkey(),
-        webhook_id: "webhook-123".to_string(),
-        revenue_share_to_receiver: true,
-        resolve_sender_to_name: false,
-    };
-
-    let instruction = Instruction::new_with_borsh(
-        program_id(),
-        &instruction_data,
-        vec![
-            AccountMeta::new(payer.pubkey(), true),
-            AccountMeta::new(recipient_claim_pda, false),
-            AccountMeta::new(mailer_pda, false), // Must be writable for record_shares to update owner_claimable
-            AccountMeta::new(sender_usdc, false),
-            AccountMeta::new(mailer_usdc, false),
-            AccountMeta::new_readonly(spl_token::id(), false),
-            AccountMeta::new_readonly(system_program::id(), false),
-        ],
-    );
-
-    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Verify recipient claim was created with correct amount
-    let claim_account = banks_client
-        .get_account(recipient_claim_pda)
-        .await
-        .unwrap()
-        .unwrap();
-    let recipient_claim: RecipientClaim =
-        BorshDeserialize::deserialize(&mut &claim_account.data[8..]).unwrap();
-
-    assert_eq!(recipient_claim.recipient, payer.pubkey());
-    assert_eq!(recipient_claim.amount, 90_000); // 90% of send_fee (100,000)
-
-    // Verify mailer state was updated with owner share
-    let mailer_account = banks_client.get_account(mailer_pda).await.unwrap().unwrap();
-    let mailer_state: MailerState =
-        BorshDeserialize::deserialize(&mut &mailer_account.data[8..]).unwrap();
-
-    assert_eq!(mailer_state.owner_claimable, 10_000); // 10% of send_fee
-}
-
-#[tokio::test]
-async fn test_send_through_webhook_standard() {
-    let program_test = ProgramTest::new(
-        "mailer",
-        program_id(),
-        processor!(mailer::process_instruction),
-    );
-    let (mut banks_client, payer, recent_blockhash) = program_test.start().await;
-
-    // Setup similar to standard test
-    let usdc_mint = create_usdc_mint(&mut banks_client, &payer, recent_blockhash).await;
-    let (mailer_pda, _) = get_mailer_pda();
-
-    // Initialize the program
-    let init_instruction = Instruction::new_with_borsh(
-        program_id(),
-        &MailerInstruction::Initialize { usdc_mint },
-        vec![
-            AccountMeta::new(payer.pubkey(), true),
-            AccountMeta::new(mailer_pda, false),
-            AccountMeta::new_readonly(system_program::id(), false),
-        ],
-    );
-
-    let mut transaction = Transaction::new_with_payer(&[init_instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Create token accounts
-    let sender_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &payer.pubkey(),
-    )
-    .await;
-    let mailer_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &mailer_pda,
-    )
-    .await;
-
-    // Mint USDC to sender
-    mint_to(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &sender_usdc,
-        1_000_000,
-    )
-    .await;
-
-    // Get recipient claim PDA (needed even if not used for standard send)
-    let (recipient_claim_pda, _) = get_claim_pda(&payer.pubkey());
-
-    // Send webhook message (standard mode - no revenue sharing)
-    let instruction_data = MailerInstruction::SendThroughWebhook {
-        to: payer.pubkey(),
-        webhook_id: "webhook-456".to_string(),
-        revenue_share_to_receiver: false,
-        resolve_sender_to_name: false,
-    };
-
-    let instruction = Instruction::new_with_borsh(
-        program_id(),
-        &instruction_data,
-        vec![
-            AccountMeta::new(payer.pubkey(), true),
-            AccountMeta::new_readonly(recipient_claim_pda, false), // Not used for standard send but required
-            AccountMeta::new(mailer_pda, false), // Needs to be writable to update owner_claimable
-            AccountMeta::new(sender_usdc, false),
-            AccountMeta::new(mailer_usdc, false),
-            AccountMeta::new_readonly(spl_token::id(), false),
-            AccountMeta::new_readonly(system_program::id(), false),
-        ],
-    );
-
-    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer.pubkey()));
-    transaction.sign(&[&payer], recent_blockhash);
-    banks_client.process_transaction(transaction).await.unwrap();
-
-    // Verify only owner fee was charged (10% of send_fee = 10,000)
-    let mailer_account = banks_client.get_account(mailer_pda).await.unwrap().unwrap();
-    let mailer_state: MailerState =
-        BorshDeserialize::deserialize(&mut &mailer_account.data[8..]).unwrap();
+    let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_account.data[8..]).unwrap();
     assert_eq!(mailer_state.owner_claimable, 10_000); // Only 10% fee
 }
 
@@ -600,7 +352,7 @@ async fn test_claim_recipient_share() {
     // Setup and send priority message first (similar to previous test)
     let usdc_mint = create_usdc_mint(&mut banks_client, &payer, recent_blockhash).await;
     let (mailer_pda, _) = get_mailer_pda();
-
+    
     // Initialize
     let init_instruction = Instruction::new_with_borsh(
         program_id(),
@@ -617,33 +369,11 @@ async fn test_claim_recipient_share() {
     banks_client.process_transaction(transaction).await.unwrap();
 
     // Create token accounts
-    let sender_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &payer.pubkey(),
-    )
-    .await;
-    let mailer_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &mailer_pda,
-    )
-    .await;
-
+    let sender_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &payer.pubkey()).await;
+    let mailer_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &mailer_pda).await;
+    
     // Mint USDC
-    mint_to(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &sender_usdc,
-        1_000_000,
-    )
-    .await;
+    mint_to(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &sender_usdc, 1_000_000).await;
 
     let (recipient_claim_pda, _) = get_claim_pda(&payer.pubkey());
 
@@ -655,7 +385,7 @@ async fn test_claim_recipient_share() {
             subject: "Test".to_string(),
             _body: "Test".to_string(),
             revenue_share_to_receiver: true,
-            resolve_sender_to_name: false,
+        resolve_sender_to_name: false,
         },
         vec![
             AccountMeta::new(payer.pubkey(), true),
@@ -673,14 +403,7 @@ async fn test_claim_recipient_share() {
     banks_client.process_transaction(transaction).await.unwrap();
 
     // Create recipient's own USDC account to receive the claim
-    let recipient_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &payer.pubkey(),
-    )
-    .await;
+    let recipient_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &payer.pubkey()).await;
 
     // Now claim the recipient share
     let claim_instruction = Instruction::new_with_borsh(
@@ -701,21 +424,12 @@ async fn test_claim_recipient_share() {
     banks_client.process_transaction(transaction).await.unwrap();
 
     // Verify the claim was processed
-    let claim_account = banks_client
-        .get_account(recipient_claim_pda)
-        .await
-        .unwrap()
-        .unwrap();
-    let recipient_claim: RecipientClaim =
-        BorshDeserialize::deserialize(&mut &claim_account.data[8..]).unwrap();
+    let claim_account = banks_client.get_account(recipient_claim_pda).await.unwrap().unwrap();
+    let recipient_claim: RecipientClaim = BorshDeserialize::deserialize(&mut &claim_account.data[8..]).unwrap();
     assert_eq!(recipient_claim.amount, 0); // Should be zero after claiming
 
     // Verify tokens were transferred to recipient
-    let recipient_token_account = banks_client
-        .get_account(recipient_usdc)
-        .await
-        .unwrap()
-        .unwrap();
+    let recipient_token_account = banks_client.get_account(recipient_usdc).await.unwrap().unwrap();
     let token_account_data = TokenAccount::unpack(&recipient_token_account.data).unwrap();
     assert_eq!(token_account_data.amount, 90_000); // 90% of 100,000
 }
@@ -732,7 +446,7 @@ async fn test_claim_owner_share() {
     // Setup and send a message to accumulate owner fees
     let usdc_mint = create_usdc_mint(&mut banks_client, &payer, recent_blockhash).await;
     let (mailer_pda, _) = get_mailer_pda();
-
+    
     // Initialize
     let init_instruction = Instruction::new_with_borsh(
         program_id(),
@@ -749,40 +463,11 @@ async fn test_claim_owner_share() {
     banks_client.process_transaction(transaction).await.unwrap();
 
     // Setup token accounts and send standard message to accumulate owner fees
-    let sender_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &payer.pubkey(),
-    )
-    .await;
-    let mailer_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &mailer_pda,
-    )
-    .await;
-    let owner_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &payer.pubkey(),
-    )
-    .await;
-
-    mint_to(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &sender_usdc,
-        1_000_000,
-    )
-    .await;
+    let sender_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &payer.pubkey()).await;
+    let mailer_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &mailer_pda).await;
+    let owner_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &payer.pubkey()).await;
+    
+    mint_to(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &sender_usdc, 1_000_000).await;
 
     let (recipient_claim_pda, _) = get_claim_pda(&payer.pubkey());
 
@@ -794,7 +479,7 @@ async fn test_claim_owner_share() {
             subject: "Test".to_string(),
             _body: "Test".to_string(),
             revenue_share_to_receiver: false,
-            resolve_sender_to_name: false,
+        resolve_sender_to_name: false,
         },
         vec![
             AccountMeta::new(payer.pubkey(), true),
@@ -830,8 +515,7 @@ async fn test_claim_owner_share() {
 
     // Verify owner claimable was reset
     let mailer_account = banks_client.get_account(mailer_pda).await.unwrap().unwrap();
-    let mailer_state: MailerState =
-        BorshDeserialize::deserialize(&mut &mailer_account.data[8..]).unwrap();
+    let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_account.data[8..]).unwrap();
     assert_eq!(mailer_state.owner_claimable, 0);
 
     // Verify tokens were transferred to owner
@@ -851,7 +535,7 @@ async fn test_set_fees() {
 
     let usdc_mint = create_usdc_mint(&mut banks_client, &payer, recent_blockhash).await;
     let (mailer_pda, _) = get_mailer_pda();
-
+    
     // Initialize
     let init_instruction = Instruction::new_with_borsh(
         program_id(),
@@ -877,38 +561,32 @@ async fn test_set_fees() {
         ],
     );
 
-    let mut transaction =
-        Transaction::new_with_payer(&[set_fee_instruction], Some(&payer.pubkey()));
+    let mut transaction = Transaction::new_with_payer(&[set_fee_instruction], Some(&payer.pubkey()));
     transaction.sign(&[&payer], recent_blockhash);
     banks_client.process_transaction(transaction).await.unwrap();
 
     // Verify fee was updated
     let mailer_account = banks_client.get_account(mailer_pda).await.unwrap().unwrap();
-    let mailer_state: MailerState =
-        BorshDeserialize::deserialize(&mut &mailer_account.data[8..]).unwrap();
+    let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_account.data[8..]).unwrap();
     assert_eq!(mailer_state.send_fee, 200_000);
 
     // Test setting delegation fee
     let set_delegation_fee_instruction = Instruction::new_with_borsh(
         program_id(),
-        &MailerInstruction::SetDelegationFee {
-            new_fee: 20_000_000,
-        },
+        &MailerInstruction::SetDelegationFee { new_fee: 20_000_000 },
         vec![
             AccountMeta::new(payer.pubkey(), true),
             AccountMeta::new(mailer_pda, false),
         ],
     );
 
-    let mut transaction =
-        Transaction::new_with_payer(&[set_delegation_fee_instruction], Some(&payer.pubkey()));
+    let mut transaction = Transaction::new_with_payer(&[set_delegation_fee_instruction], Some(&payer.pubkey()));
     transaction.sign(&[&payer], recent_blockhash);
     banks_client.process_transaction(transaction).await.unwrap();
 
     // Verify delegation fee was updated
     let mailer_account = banks_client.get_account(mailer_pda).await.unwrap().unwrap();
-    let mailer_state: MailerState =
-        BorshDeserialize::deserialize(&mut &mailer_account.data[8..]).unwrap();
+    let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_account.data[8..]).unwrap();
     assert_eq!(mailer_state.delegation_fee, 20_000_000);
 }
 
@@ -923,7 +601,7 @@ async fn test_delegation_functionality() {
 
     let usdc_mint = create_usdc_mint(&mut banks_client, &payer, recent_blockhash).await;
     let (mailer_pda, _) = get_mailer_pda();
-
+    
     // Initialize
     let init_instruction = Instruction::new_with_borsh(
         program_id(),
@@ -940,32 +618,10 @@ async fn test_delegation_functionality() {
     banks_client.process_transaction(transaction).await.unwrap();
 
     // Setup token accounts
-    let delegator_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &payer.pubkey(),
-    )
-    .await;
-    let mailer_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &mailer_pda,
-    )
-    .await;
-
-    mint_to(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &delegator_usdc,
-        50_000_000,
-    )
-    .await; // 50 USDC
+    let delegator_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &payer.pubkey()).await;
+    let mailer_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &mailer_pda).await;
+    
+    mint_to(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &delegator_usdc, 50_000_000).await; // 50 USDC
 
     let delegate = Keypair::new();
     let (delegation_pda, _) = get_delegation_pda(&payer.pubkey());
@@ -987,19 +643,13 @@ async fn test_delegation_functionality() {
         ],
     );
 
-    let mut transaction =
-        Transaction::new_with_payer(&[delegate_instruction], Some(&payer.pubkey()));
+    let mut transaction = Transaction::new_with_payer(&[delegate_instruction], Some(&payer.pubkey()));
     transaction.sign(&[&payer], recent_blockhash);
     banks_client.process_transaction(transaction).await.unwrap();
 
     // Verify delegation was created
-    let delegation_account = banks_client
-        .get_account(delegation_pda)
-        .await
-        .unwrap()
-        .unwrap();
-    let delegation: Delegation =
-        BorshDeserialize::deserialize(&mut &delegation_account.data[8..]).unwrap();
+    let delegation_account = banks_client.get_account(delegation_pda).await.unwrap().unwrap();
+    let delegation: Delegation = BorshDeserialize::deserialize(&mut &delegation_account.data[8..]).unwrap();
     assert_eq!(delegation.delegator, payer.pubkey());
     assert_eq!(delegation.delegate, Some(delegate.pubkey()));
 
@@ -1012,7 +662,6 @@ async fn test_delegation_functionality() {
         vec![
             AccountMeta::new(delegate.pubkey(), true),
             AccountMeta::new(delegation_pda, false),
-            AccountMeta::new_readonly(mailer_pda, false),
         ],
     );
 
@@ -1038,25 +687,11 @@ async fn test_error_conditions() {
 
     let usdc_mint = create_usdc_mint(&mut banks_client, &payer, recent_blockhash).await;
     let (mailer_pda, _) = get_mailer_pda();
-
+    
     // Test claiming with no claimable amount (should fail)
     let (recipient_claim_pda, _) = get_claim_pda(&payer.pubkey());
-    let recipient_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &payer.pubkey(),
-    )
-    .await;
-    let mailer_usdc = create_token_account(
-        &mut banks_client,
-        &payer,
-        recent_blockhash,
-        &usdc_mint,
-        &mailer_pda,
-    )
-    .await;
+    let recipient_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &payer.pubkey()).await;
+    let mailer_usdc = create_token_account(&mut banks_client, &payer, recent_blockhash, &usdc_mint, &mailer_pda).await;
 
     let claim_instruction = Instruction::new_with_borsh(
         program_id(),
@@ -1073,164 +708,8 @@ async fn test_error_conditions() {
 
     let mut transaction = Transaction::new_with_payer(&[claim_instruction], Some(&payer.pubkey()));
     transaction.sign(&[&payer], recent_blockhash);
-
+    
     // This should fail because no claim exists
     let result = banks_client.process_transaction(transaction).await;
     assert!(result.is_err());
-}
-
-#[tokio::test]
-async fn test_claim_expired_shares_moves_funds_to_owner() {
-    let program_test = ProgramTest::new(
-        "mailer",
-        program_id(),
-        processor!(mailer::process_instruction),
-    );
-    let mut context = program_test.start_with_context().await;
-
-    let mut recent_blockhash = context.last_blockhash;
-
-    // Create USDC mint and initialize the program
-    let usdc_mint =
-        create_usdc_mint(&mut context.banks_client, &context.payer, recent_blockhash).await;
-    recent_blockhash = context.banks_client.get_latest_blockhash().await.unwrap();
-
-    let (mailer_pda, _) = get_mailer_pda();
-    let init_instruction = Instruction::new_with_borsh(
-        program_id(),
-        &MailerInstruction::Initialize { usdc_mint },
-        vec![
-            AccountMeta::new(context.payer.pubkey(), true),
-            AccountMeta::new(mailer_pda, false),
-            AccountMeta::new_readonly(system_program::id(), false),
-        ],
-    );
-
-    let mut transaction =
-        Transaction::new_with_payer(&[init_instruction], Some(&context.payer.pubkey()));
-    transaction.sign(&[&context.payer], recent_blockhash);
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-    recent_blockhash = context.banks_client.get_latest_blockhash().await.unwrap();
-
-    // Prepare token accounts and fund the sender
-    let sender_usdc = create_token_account(
-        &mut context.banks_client,
-        &context.payer,
-        recent_blockhash,
-        &usdc_mint,
-        &context.payer.pubkey(),
-    )
-    .await;
-    recent_blockhash = context.banks_client.get_latest_blockhash().await.unwrap();
-
-    let mailer_usdc = create_token_account(
-        &mut context.banks_client,
-        &context.payer,
-        recent_blockhash,
-        &usdc_mint,
-        &mailer_pda,
-    )
-    .await;
-    recent_blockhash = context.banks_client.get_latest_blockhash().await.unwrap();
-
-    mint_to(
-        &mut context.banks_client,
-        &context.payer,
-        recent_blockhash,
-        &usdc_mint,
-        &sender_usdc,
-        1_000_000,
-    )
-    .await; // 1 USDC to cover priority message
-    recent_blockhash = context.banks_client.get_latest_blockhash().await.unwrap();
-
-    let (recipient_claim_pda, _) = get_claim_pda(&context.payer.pubkey());
-
-    // Send a priority message to create the claim record
-    let send_instruction = Instruction::new_with_borsh(
-        program_id(),
-        &MailerInstruction::Send {
-            to: context.payer.pubkey(),
-            subject: "Expired claim".to_string(),
-            _body: "Body".to_string(),
-            revenue_share_to_receiver: true,
-            resolve_sender_to_name: false,
-        },
-        vec![
-            AccountMeta::new(context.payer.pubkey(), true),
-            AccountMeta::new(recipient_claim_pda, false),
-            AccountMeta::new(mailer_pda, false),
-            AccountMeta::new(sender_usdc, false),
-            AccountMeta::new(mailer_usdc, false),
-            AccountMeta::new_readonly(spl_token::id(), false),
-            AccountMeta::new_readonly(system_program::id(), false),
-        ],
-    );
-
-    let mut transaction =
-        Transaction::new_with_payer(&[send_instruction], Some(&context.payer.pubkey()));
-    transaction.sign(&[&context.payer], recent_blockhash);
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // Warp forward so the claim expires (claim period is 60 days = 5,184,000 seconds)
-    // Manually set the clock to a future timestamp beyond the claim period
-    use solana_sdk::clock::Clock;
-    let mut clock = context.banks_client.get_sysvar::<Clock>().await.unwrap();
-    clock.unix_timestamp += 60 * 24 * 60 * 60 + 1; // 60 days + 1 second
-    context.set_sysvar(&clock);
-
-    recent_blockhash = context.banks_client.get_latest_blockhash().await.unwrap();
-
-    // Owner reclaims expired shares
-    let claim_expired_instruction = Instruction::new_with_borsh(
-        program_id(),
-        &MailerInstruction::ClaimExpiredShares {
-            recipient: context.payer.pubkey(),
-        },
-        vec![
-            AccountMeta::new(context.payer.pubkey(), true),
-            AccountMeta::new(mailer_pda, false),
-            AccountMeta::new(recipient_claim_pda, false),
-        ],
-    );
-
-    let mut transaction =
-        Transaction::new_with_payer(&[claim_expired_instruction], Some(&context.payer.pubkey()));
-    transaction.sign(&[&context.payer], recent_blockhash);
-    context
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .unwrap();
-
-    // Recipient claim should be cleared
-    let claim_account = context
-        .banks_client
-        .get_account(recipient_claim_pda)
-        .await
-        .unwrap()
-        .unwrap();
-    let claim_state: RecipientClaim =
-        BorshDeserialize::deserialize(&mut &claim_account.data[8..]).unwrap();
-    assert_eq!(claim_state.amount, 0);
-    assert_eq!(claim_state.timestamp, 0);
-
-    // Owner claimable should now include both original owner share and reclaimed amount (total 100,000)
-    let mailer_account = context
-        .banks_client
-        .get_account(mailer_pda)
-        .await
-        .unwrap()
-        .unwrap();
-    let mailer_state: MailerState =
-        BorshDeserialize::deserialize(&mut &mailer_account.data[8..]).unwrap();
-    assert_eq!(mailer_state.owner_claimable, 100_000);
-}
+}