@sudobility/contracts 0.14.0 → 1.9.0

package/programs/mailer/src/lib.rs

@@ -1,6 +1,6 @@
 //! # Native Solana Mailer Program
 //!
-//! A native Solana program for decentralized messaging with delegation management,
+//! A native Solana program for decentralized messaging with delegation management, 
 //! USDC fees and revenue sharing - no Anchor dependencies.
 //!
 //! ## Key Features
@@ -25,6 +25,7 @@
 //! - Standard: Sender pays 10% fee only
 //! - Owner gets 10% of all fees
 
+
 use borsh::{BorshDeserialize, BorshSerialize};
 use solana_program::{
     account_info::{next_account_info, AccountInfo},
@@ -33,13 +34,11 @@ use solana_program::{
     msg,
     program::{invoke, invoke_signed},
     program_error::ProgramError,
-    program_pack::Pack,
     pubkey::Pubkey,
     rent::Rent,
     system_instruction,
     sysvar::Sysvar,
 };
-use spl_token::state::Account as TokenAccount;
 use thiserror::Error;
 
 // Program ID for the Native Mailer program
@@ -98,20 +97,6 @@ impl Delegation {
     pub const LEN: usize = 32 + 1 + 32 + 1; // 66 bytes (max with Some(Pubkey))
 }
 
-/// Fee discount account for custom fee percentages
-/// Stores discount (0-100) instead of percentage for cleaner default behavior
-/// 0 = no discount (100% fee), 100 = full discount (0% fee, free)
-#[derive(BorshSerialize, BorshDeserialize, Debug, Clone)]
-pub struct FeeDiscount {
-    pub account: Pubkey,
-    pub discount: u8, // 0-100: 0 = no discount (full fee), 100 = full discount (free)
-    pub bump: u8,
-}
-
-impl FeeDiscount {
-    pub const LEN: usize = 32 + 1 + 1; // 34 bytes
-}
-
 /// Instructions
 #[derive(BorshSerialize, BorshDeserialize, Debug)]
 pub enum MailerInstruction {
@@ -139,22 +124,6 @@ pub enum MailerInstruction {
         resolve_sender_to_name: bool,
     },
 
-    /// Send prepared message with optional revenue sharing (references off-chain content via mailId)
-    /// Accounts:
-    /// 0. `[signer]` Sender
-    /// 1. `[writable]` Recipient claim account (PDA)
-    /// 2. `[]` Mailer state account (PDA)
-    /// 3. `[writable]` Sender USDC account
-    /// 4. `[writable]` Mailer USDC account
-    /// 5. `[]` Token program
-    /// 6. `[]` System program
-    SendPrepared {
-        to: Pubkey,
-        mail_id: String,
-        revenue_share_to_receiver: bool,
-        resolve_sender_to_name: bool,
-    },
-
     /// Send message to email address (no wallet address known)
     /// Charges only 10% owner fee since recipient wallet is unknown
     /// Accounts:
@@ -177,22 +146,9 @@ pub enum MailerInstruction {
     /// 2. `[writable]` Sender USDC account
     /// 3. `[writable]` Mailer USDC account
     /// 4. `[]` Token program
-    SendPreparedToEmail { to_email: String, mail_id: String },
-
-    /// Send message through webhook (referenced by webhookId)
-    /// Accounts:
-    /// 0. `[signer]` Sender
-    /// 1. `[writable]` Recipient claim account (PDA)
-    /// 2. `[]` Mailer state account (PDA)
-    /// 3. `[writable]` Sender USDC account
-    /// 4. `[writable]` Mailer USDC account
-    /// 5. `[]` Token program
-    /// 6. `[]` System program
-    SendThroughWebhook {
-        to: Pubkey,
-        webhook_id: String,
-        revenue_share_to_receiver: bool,
-        resolve_sender_to_name: bool,
+    SendPreparedToEmail {
+        to_email: String,
+        mail_id: String,
     },
 
     /// Claim recipient share
@@ -235,7 +191,6 @@ pub enum MailerInstruction {
     /// Accounts:
     /// 0. `[signer]` Rejector
     /// 1. `[writable]` Delegation account (PDA)
-    /// 2. `[]` Mailer state account (PDA)
     RejectDelegation,
 
     /// Set delegation fee (owner only)
@@ -243,27 +198,7 @@ pub enum MailerInstruction {
     /// 0. `[signer]` Owner
     /// 1. `[writable]` Mailer state account (PDA)
     SetDelegationFee { new_fee: u64 },
-
-    /// Set custom fee percentage for a specific address (owner only)
-    /// Accounts:
-    /// 0. `[signer]` Owner
-    /// 1. `[]` Mailer state account (PDA)
-    /// 2. `[writable]` Fee discount account (PDA)
-    /// 3. `[]` Account to set custom fee for
-    /// 4. `[signer]` Payer for account creation
-    /// 5. `[]` System program
-    SetCustomFeePercentage {
-        account: Pubkey,
-        percentage: u8, // 0-100: 0 = free, 100 = full fee
-    },
-
-    /// Clear custom fee percentage for a specific address (owner only)
-    /// Accounts:
-    /// 0. `[signer]` Owner
-    /// 1. `[]` Mailer state account (PDA)
-    /// 2. `[writable]` Fee discount account (PDA)
-    ClearCustomFeePercentage { account: Pubkey },
-
+    
     /// Pause the contract (owner only)
     /// Accounts:
     /// 0. `[signer]` Owner
@@ -272,13 +207,13 @@ pub enum MailerInstruction {
     /// 3. `[writable]` Mailer USDC account  
     /// 4. `[]` Token program
     Pause,
-
+    
     /// Unpause the contract (owner only)
     /// Accounts:
     /// 0. `[signer]` Owner
     /// 1. `[writable]` Mailer state account (PDA)
     Unpause,
-
+    
     /// Distribute claimable funds (when paused)
     /// Accounts:
     /// 0. `[signer]` Anyone can call
@@ -289,13 +224,6 @@ pub enum MailerInstruction {
     /// 5. `[]` Token program
     DistributeClaimableFunds { recipient: Pubkey },
 
-    /// Claim expired recipient shares (owner only)
-    /// Accounts:
-    /// 0. `[signer]` Owner
-    /// 1. `[writable]` Mailer state account (PDA)
-    /// 2. `[writable]` Recipient claim account (PDA)
-    ClaimExpiredShares { recipient: Pubkey },
-
     /// Emergency unpause without fund distribution (owner only)
     /// Accounts:
     /// 0. `[signer]` Owner
@@ -328,16 +256,10 @@ pub enum MailerError {
     InvalidPDA,
     #[error("Invalid account owner")]
     InvalidAccountOwner,
-    #[error("Invalid token mint")]
-    InvalidMint,
-    #[error("Invalid token program")]
-    InvalidTokenProgram,
     #[error("Contract is paused")]
     ContractPaused,
     #[error("Contract is not paused")]
     ContractNotPaused,
-    #[error("Invalid percentage (must be 0-100)")]
-    InvalidPercentage,
 }
 
 impl From<MailerError> for ProgramError {
@@ -358,55 +280,15 @@ pub fn process_instruction(
         MailerInstruction::Initialize { usdc_mint } => {
             process_initialize(program_id, accounts, usdc_mint)
         }
-        MailerInstruction::Send {
-            to,
-            subject,
-            _body,
-            revenue_share_to_receiver,
-            resolve_sender_to_name,
-        } => process_send(
-            program_id,
-            accounts,
-            to,
-            subject,
-            _body,
-            revenue_share_to_receiver,
-            resolve_sender_to_name,
-        ),
-        MailerInstruction::SendPrepared {
-            to,
-            mail_id,
-            revenue_share_to_receiver,
-            resolve_sender_to_name,
-        } => process_send_prepared(
-            program_id,
-            accounts,
-            to,
-            mail_id,
-            revenue_share_to_receiver,
-            resolve_sender_to_name,
-        ),
-        MailerInstruction::SendToEmail {
-            to_email,
-            subject,
-            _body,
-        } => process_send_to_email(program_id, accounts, to_email, subject, _body),
+        MailerInstruction::Send { to, subject, _body, revenue_share_to_receiver, resolve_sender_to_name } => {
+            process_send(program_id, accounts, to, subject, _body, revenue_share_to_receiver, resolve_sender_to_name)
+        }
+        MailerInstruction::SendToEmail { to_email, subject, _body } => {
+            process_send_to_email(program_id, accounts, to_email, subject, _body)
+        }
         MailerInstruction::SendPreparedToEmail { to_email, mail_id } => {
             process_send_prepared_to_email(program_id, accounts, to_email, mail_id)
         }
-        MailerInstruction::SendThroughWebhook {
-            to,
-            webhook_id,
-            revenue_share_to_receiver,
-            resolve_sender_to_name,
-        } => process_send_through_webhook(
-            program_id,
-            accounts,
-            to,
-            webhook_id,
-            revenue_share_to_receiver,
-            resolve_sender_to_name,
-        ),
         MailerInstruction::ClaimRecipientShare => {
             process_claim_recipient_share(program_id, accounts)
         }
@@ -419,22 +301,18 @@ pub fn process_instruction(
         MailerInstruction::SetDelegationFee { new_fee } => {
             process_set_delegation_fee(program_id, accounts, new_fee)
         }
-        MailerInstruction::SetCustomFeePercentage {
-            account,
-            percentage,
-        } => process_set_custom_fee_percentage(program_id, accounts, account, percentage),
-        MailerInstruction::ClearCustomFeePercentage { account } => {
-            process_clear_custom_fee_percentage(program_id, accounts, account)
+        MailerInstruction::Pause => {
+            process_pause(program_id, accounts)
+        }
+        MailerInstruction::Unpause => {
+            process_unpause(program_id, accounts)
         }
-        MailerInstruction::Pause => process_pause(program_id, accounts),
-        MailerInstruction::Unpause => process_unpause(program_id, accounts),
         MailerInstruction::DistributeClaimableFunds { recipient } => {
             process_distribute_claimable_funds(program_id, accounts, recipient)
         }
-        MailerInstruction::ClaimExpiredShares { recipient } => {
-            process_claim_expired_shares(program_id, accounts, recipient)
+        MailerInstruction::EmergencyUnpause => {
+            process_emergency_unpause(program_id, accounts)
         }
-        MailerInstruction::EmergencyUnpause => process_emergency_unpause(program_id, accounts),
     }
 }
 
@@ -472,11 +350,7 @@ fn process_initialize(
             space as u64,
             program_id,
         ),
-        &[
-            owner.clone(),
-            mailer_account.clone(),
-            system_program.clone(),
-        ],
+        &[owner.clone(), mailer_account.clone(), system_program.clone()],
         &[&[b"mailer", &[bump]]],
     )?;
 
@@ -524,30 +398,23 @@ fn process_send(
     }
 
     // Load mailer state
-    let (mailer_pda, _) = assert_mailer_account(program_id, mailer_account)?;
     let mailer_data = mailer_account.try_borrow_data()?;
     let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
     drop(mailer_data);
 
-    assert_token_program(token_program)?;
-    assert_token_account(sender_usdc, sender.key, &mailer_state.usdc_mint)?;
-    assert_token_account(mailer_usdc, &mailer_pda, &mailer_state.usdc_mint)?;
-
     // Check if contract is paused
     if mailer_state.paused {
         return Err(MailerError::ContractPaused.into());
     }
 
-    // Calculate effective fee based on custom discount (if any)
-    let effective_fee =
-        calculate_fee_with_discount(program_id, sender.key, accounts, mailer_state.send_fee)?;
-
     if revenue_share_to_receiver {
         // Priority mode: full fee with revenue sharing
 
         // Create or load recipient claim account
-        let (claim_pda, claim_bump) =
-            Pubkey::find_program_address(&[b"claim", to.as_ref()], program_id);
+        let (claim_pda, claim_bump) = Pubkey::find_program_address(
+            &[b"claim", to.as_ref()],
+            program_id
+        );
 
         if recipient_claim.key != &claim_pda {
             return Err(MailerError::InvalidPDA.into());
@@ -567,18 +434,13 @@ fn process_send(
                     space as u64,
                     program_id,
                 ),
-                &[
-                    sender.clone(),
-                    recipient_claim.clone(),
-                    system_program.clone(),
-                ],
+                &[sender.clone(), recipient_claim.clone(), system_program.clone()],
                 &[&[b"claim", to.as_ref(), &[claim_bump]]],
             )?;
 
             // Initialize claim account
             let mut claim_data = recipient_claim.try_borrow_mut_data()?;
-            claim_data[0..8]
-                .copy_from_slice(&hash_discriminator("account:RecipientClaim").to_le_bytes());
+            claim_data[0..8].copy_from_slice(&hash_discriminator("account:RecipientClaim").to_le_bytes());
 
             let claim_state = RecipientClaim {
                 recipient: to,
@@ -591,53 +453,50 @@ fn process_send(
             drop(claim_data);
         }
 
-        // Transfer effective fee (may be discounted)
-        if effective_fee > 0 {
-            invoke(
-                &spl_token::instruction::transfer(
-                    token_program.key,
-                    sender_usdc.key,
-                    mailer_usdc.key,
-                    sender.key,
-                    &[],
-                    effective_fee,
-                )?,
-                &[
-                    sender_usdc.clone(),
-                    mailer_usdc.clone(),
-                    sender.clone(),
-                    token_program.clone(),
-                ],
-            )?;
+        // Transfer full send fee
+        invoke(
+            &spl_token::instruction::transfer(
+                token_program.key,
+                sender_usdc.key,
+                mailer_usdc.key,
+                sender.key,
+                &[],
+                mailer_state.send_fee,
+            )?,
+            &[
+                sender_usdc.clone(),
+                mailer_usdc.clone(),
+                sender.clone(),
+                token_program.clone(),
+            ],
+        )?;
 
-            // Record revenue shares (only if fee > 0)
-            record_shares(recipient_claim, mailer_account, to, effective_fee)?;
-        }
+        // Record revenue shares
+        record_shares(recipient_claim, mailer_account, to, mailer_state.send_fee)?;
 
-        msg!("Priority mail sent from {} to {}: {} (revenue share enabled, resolve sender: {}, effective fee: {})", sender.key, to, subject, _resolve_sender_to_name, effective_fee);
+        msg!("Priority mail sent from {} to {}: {} (revenue share enabled, resolve sender: {})", sender.key, to, subject, _resolve_sender_to_name);
     } else {
         // Standard mode: 10% fee only, no revenue sharing
-        let owner_fee = (effective_fee * 10) / 100; // 10% of effective fee
+
+        let owner_fee = mailer_state.send_fee / 10; // 10% of send_fee
 
         // Transfer only owner fee (10%)
-        if owner_fee > 0 {
-            invoke(
-                &spl_token::instruction::transfer(
-                    token_program.key,
-                    sender_usdc.key,
-                    mailer_usdc.key,
-                    sender.key,
-                    &[],
-                    owner_fee,
-                )?,
-                &[
-                    sender_usdc.clone(),
-                    mailer_usdc.clone(),
-                    sender.clone(),
-                    token_program.clone(),
-                ],
-            )?;
-        }
+        invoke(
+            &spl_token::instruction::transfer(
+                token_program.key,
+                sender_usdc.key,
+                mailer_usdc.key,
+                sender.key,
+                &[],
+                owner_fee,
+            )?,
+            &[
+                sender_usdc.clone(),
+                mailer_usdc.clone(),
+                sender.clone(),
+                token_program.clone(),
+            ],
+        )?;
 
         // Update owner claimable
         let mut mailer_data = mailer_account.try_borrow_mut_data()?;
@@ -645,183 +504,81 @@ fn process_send(
         mailer_state.owner_claimable += owner_fee;
         mailer_state.serialize(&mut &mut mailer_data[8..])?;
 
-        msg!(
-            "Standard mail sent from {} to {}: {} (resolve sender: {}, effective fee: {})",
-            sender.key,
-            to,
-            subject,
-            _resolve_sender_to_name,
-            effective_fee
-        );
+        msg!("Standard mail sent from {} to {}: {} (resolve sender: {})", sender.key, to, subject, _resolve_sender_to_name);
     }
 
     Ok(())
 }
 
-/// Send prepared message with optional revenue sharing (references off-chain content via mailId)
-fn process_send_prepared(
-    program_id: &Pubkey,
+/// Process send to email address (no wallet known, only owner fee)
+fn process_send_to_email(
+    _program_id: &Pubkey,
     accounts: &[AccountInfo],
-    to: Pubkey,
-    mail_id: String,
-    revenue_share_to_receiver: bool,
-    _resolve_sender_to_name: bool,
+    to_email: String,
+    subject: String,
+    _body: String,
 ) -> ProgramResult {
     let account_iter = &mut accounts.iter();
     let sender = next_account_info(account_iter)?;
-    let recipient_claim = next_account_info(account_iter)?;
     let mailer_account = next_account_info(account_iter)?;
     let sender_usdc = next_account_info(account_iter)?;
     let mailer_usdc = next_account_info(account_iter)?;
     let token_program = next_account_info(account_iter)?;
-    let system_program = next_account_info(account_iter)?;
 
     if !sender.is_signer {
         return Err(ProgramError::MissingRequiredSignature);
     }
 
     // Load mailer state
-    let (mailer_pda, _) = assert_mailer_account(program_id, mailer_account)?;
     let mailer_data = mailer_account.try_borrow_data()?;
     let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
     drop(mailer_data);
 
-    assert_token_program(token_program)?;
-    assert_token_account(sender_usdc, sender.key, &mailer_state.usdc_mint)?;
-    assert_token_account(mailer_usdc, &mailer_pda, &mailer_state.usdc_mint)?;
-
     // Check if contract is paused
     if mailer_state.paused {
         return Err(MailerError::ContractPaused.into());
     }
 
-    // Calculate effective fee based on custom discount (if any)
-    let effective_fee =
-        calculate_fee_with_discount(program_id, sender.key, accounts, mailer_state.send_fee)?;
-
-    if revenue_share_to_receiver {
-        // Priority mode: full fee with revenue sharing
-
-        // Create or load recipient claim account
-        let (claim_pda, claim_bump) =
-            Pubkey::find_program_address(&[b"claim", to.as_ref()], program_id);
-
-        if recipient_claim.key != &claim_pda {
-            return Err(MailerError::InvalidPDA.into());
-        }
-
-        // Create claim account if needed
-        if recipient_claim.lamports() == 0 {
-            let rent = Rent::get()?;
-            let space = 8 + RecipientClaim::LEN;
-            let lamports = rent.minimum_balance(space);
-
-            invoke_signed(
-                &system_instruction::create_account(
-                    sender.key,
-                    recipient_claim.key,
-                    lamports,
-                    space as u64,
-                    program_id,
-                ),
-                &[
-                    sender.clone(),
-                    recipient_claim.clone(),
-                    system_program.clone(),
-                ],
-                &[&[b"claim", to.as_ref(), &[claim_bump]]],
-            )?;
-
-            // Initialize claim account
-            let mut claim_data = recipient_claim.try_borrow_mut_data()?;
-            claim_data[0..8]
-                .copy_from_slice(&hash_discriminator("account:RecipientClaim").to_le_bytes());
-
-            let claim_state = RecipientClaim {
-                recipient: to,
-                amount: 0,
-                timestamp: 0,
-                bump: claim_bump,
-            };
-
-            claim_state.serialize(&mut &mut claim_data[8..])?;
-            drop(claim_data);
-        }
-
-        // Transfer effective fee (may be discounted)
-        if effective_fee > 0 {
-            invoke(
-                &spl_token::instruction::transfer(
-                    token_program.key,
-                    sender_usdc.key,
-                    mailer_usdc.key,
-                    sender.key,
-                    &[],
-                    effective_fee,
-                )?,
-                &[
-                    sender_usdc.clone(),
-                    mailer_usdc.clone(),
-                    sender.clone(),
-                    token_program.clone(),
-                ],
-            )?;
-
-            // Record revenue shares (only if fee > 0)
-            record_shares(recipient_claim, mailer_account, to, effective_fee)?;
-        }
+    // Calculate 10% owner fee (no revenue share since no wallet address)
+    let owner_fee = (mailer_state.send_fee * 10) / 100;
 
-        msg!("Priority prepared mail sent from {} to {} (mailId: {}, revenue share enabled, resolve sender: {}, effective fee: {})", sender.key, to, mail_id, _resolve_sender_to_name, effective_fee);
-    } else {
-        // Standard mode: 10% fee only, no revenue sharing
-        let owner_fee = (effective_fee * 10) / 100; // 10% of effective fee
+    // Transfer fee from sender to mailer
+    let transfer_ix = spl_token::instruction::transfer(
+        token_program.key,
+        sender_usdc.key,
+        mailer_usdc.key,
+        sender.key,
+        &[],
+        owner_fee,
+    )?;
 
-        // Transfer only owner fee (10%)
-        if owner_fee > 0 {
-            invoke(
-                &spl_token::instruction::transfer(
-                    token_program.key,
-                    sender_usdc.key,
-                    mailer_usdc.key,
-                    sender.key,
-                    &[],
-                    owner_fee,
-                )?,
-                &[
-                    sender_usdc.clone(),
-                    mailer_usdc.clone(),
-                    sender.clone(),
-                    token_program.clone(),
-                ],
-            )?;
-        }
+    invoke(
+        &transfer_ix,
+        &[
+            sender_usdc.clone(),
+            mailer_usdc.clone(),
+            sender.clone(),
+            token_program.clone(),
+        ],
+    )?;
 
-        // Update owner claimable
-        let mut mailer_data = mailer_account.try_borrow_mut_data()?;
-        let mut mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
-        mailer_state.owner_claimable += owner_fee;
-        mailer_state.serialize(&mut &mut mailer_data[8..])?;
+    // Update owner claimable
+    let mut mailer_data = mailer_account.try_borrow_mut_data()?;
+    let mut mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
+    mailer_state.owner_claimable += owner_fee;
+    mailer_state.serialize(&mut &mut mailer_data[8..])?;
 
-        msg!(
-            "Standard prepared mail sent from {} to {} (mailId: {}, resolve sender: {}, effective fee: {})",
-            sender.key,
-            to,
-            mail_id,
-            _resolve_sender_to_name,
-            effective_fee
-        );
-    }
+    msg!("Mail sent from {} to email {}: {}", sender.key, to_email, subject);
 
     Ok(())
 }
 
-/// Process send to email address (no wallet known, only owner fee)
-fn process_send_to_email(
+/// Process send prepared to email address (no wallet known, only owner fee)
+fn process_send_prepared_to_email(
     _program_id: &Pubkey,
     accounts: &[AccountInfo],
     to_email: String,
-    subject: String,
-    _body: String,
+    mail_id: String,
 ) -> ProgramResult {
     let account_iter = &mut accounts.iter();
     let sender = next_account_info(account_iter)?;
@@ -835,127 +592,37 @@ fn process_send_to_email(
     }
 
     // Load mailer state
-    let (mailer_pda, _) = assert_mailer_account(_program_id, mailer_account)?;
     let mailer_data = mailer_account.try_borrow_data()?;
     let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
     drop(mailer_data);
 
-    assert_token_program(token_program)?;
-    assert_token_account(sender_usdc, sender.key, &mailer_state.usdc_mint)?;
-    assert_token_account(mailer_usdc, &mailer_pda, &mailer_state.usdc_mint)?;
-
     // Check if contract is paused
     if mailer_state.paused {
         return Err(MailerError::ContractPaused.into());
     }
 
-    // Calculate effective fee based on custom discount (if any)
-    let effective_fee =
-        calculate_fee_with_discount(_program_id, sender.key, accounts, mailer_state.send_fee)?;
-
     // Calculate 10% owner fee (no revenue share since no wallet address)
-    let owner_fee = (effective_fee * 10) / 100;
+    let owner_fee = (mailer_state.send_fee * 10) / 100;
 
     // Transfer fee from sender to mailer
-    if owner_fee > 0 {
-        let transfer_ix = spl_token::instruction::transfer(
-            token_program.key,
-            sender_usdc.key,
-            mailer_usdc.key,
-            sender.key,
-            &[],
-            owner_fee,
-        )?;
+    let transfer_ix = spl_token::instruction::transfer(
+        token_program.key,
+        sender_usdc.key,
+        mailer_usdc.key,
+        sender.key,
+        &[],
+        owner_fee,
+    )?;
 
-        invoke(
-            &transfer_ix,
-            &[
-                sender_usdc.clone(),
-                mailer_usdc.clone(),
-                sender.clone(),
-                token_program.clone(),
-            ],
-        )?;
-    }
-
-    // Update owner claimable
-    let mut mailer_data = mailer_account.try_borrow_mut_data()?;
-    let mut mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
-    mailer_state.owner_claimable += owner_fee;
-    mailer_state.serialize(&mut &mut mailer_data[8..])?;
-
-    msg!(
-        "Mail sent from {} to email {}: {} (effective fee: {})",
-        sender.key,
-        to_email,
-        subject,
-        effective_fee
-    );
-
-    Ok(())
-}
-
-/// Process send prepared to email address (no wallet known, only owner fee)
-fn process_send_prepared_to_email(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    to_email: String,
-    mail_id: String,
-) -> ProgramResult {
-    let account_iter = &mut accounts.iter();
-    let sender = next_account_info(account_iter)?;
-    let mailer_account = next_account_info(account_iter)?;
-    let sender_usdc = next_account_info(account_iter)?;
-    let mailer_usdc = next_account_info(account_iter)?;
-    let token_program = next_account_info(account_iter)?;
-
-    if !sender.is_signer {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-
-    // Load mailer state
-    let (mailer_pda, _) = assert_mailer_account(_program_id, mailer_account)?;
-    let mailer_data = mailer_account.try_borrow_data()?;
-    let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
-    drop(mailer_data);
-
-    assert_token_program(token_program)?;
-    assert_token_account(sender_usdc, sender.key, &mailer_state.usdc_mint)?;
-    assert_token_account(mailer_usdc, &mailer_pda, &mailer_state.usdc_mint)?;
-
-    // Check if contract is paused
-    if mailer_state.paused {
-        return Err(MailerError::ContractPaused.into());
-    }
-
-    // Calculate effective fee based on custom discount (if any)
-    let effective_fee =
-        calculate_fee_with_discount(_program_id, sender.key, accounts, mailer_state.send_fee)?;
-
-    // Calculate 10% owner fee (no revenue share since no wallet address)
-    let owner_fee = (effective_fee * 10) / 100;
-
-    // Transfer fee from sender to mailer
-    if owner_fee > 0 {
-        let transfer_ix = spl_token::instruction::transfer(
-            token_program.key,
-            sender_usdc.key,
-            mailer_usdc.key,
-            sender.key,
-            &[],
-            owner_fee,
-        )?;
-
-        invoke(
-            &transfer_ix,
-            &[
-                sender_usdc.clone(),
-                mailer_usdc.clone(),
-                sender.clone(),
-                token_program.clone(),
-            ],
-        )?;
-    }
+    invoke(
+        &transfer_ix,
+        &[
+            sender_usdc.clone(),
+            mailer_usdc.clone(),
+            sender.clone(),
+            token_program.clone(),
+        ],
+    )?;
 
     // Update owner claimable
     let mut mailer_data = mailer_account.try_borrow_mut_data()?;
@@ -963,170 +630,7 @@ fn process_send_prepared_to_email(
     mailer_state.owner_claimable += owner_fee;
     mailer_state.serialize(&mut &mut mailer_data[8..])?;
 
-    msg!(
-        "Prepared mail sent from {} to email {} (mailId: {}, effective fee: {})",
-        sender.key,
-        to_email,
-        mail_id,
-        effective_fee
-    );
-
-    Ok(())
-}
-
-/// Send message through webhook (references webhook by webhookId)
-fn process_send_through_webhook(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    to: Pubkey,
-    webhook_id: String,
-    revenue_share_to_receiver: bool,
-    _resolve_sender_to_name: bool,
-) -> ProgramResult {
-    let account_iter = &mut accounts.iter();
-    let sender = next_account_info(account_iter)?;
-    let recipient_claim = next_account_info(account_iter)?;
-    let mailer_account = next_account_info(account_iter)?;
-    let sender_usdc = next_account_info(account_iter)?;
-    let mailer_usdc = next_account_info(account_iter)?;
-    let token_program = next_account_info(account_iter)?;
-    let system_program = next_account_info(account_iter)?;
-
-    if !sender.is_signer {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-
-    // Load mailer state
-    let (mailer_pda, _) = assert_mailer_account(program_id, mailer_account)?;
-    let mailer_data = mailer_account.try_borrow_data()?;
-    let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
-    drop(mailer_data);
-
-    assert_token_program(token_program)?;
-    assert_token_account(sender_usdc, sender.key, &mailer_state.usdc_mint)?;
-    assert_token_account(mailer_usdc, &mailer_pda, &mailer_state.usdc_mint)?;
-
-    // Check if contract is paused
-    if mailer_state.paused {
-        return Err(MailerError::ContractPaused.into());
-    }
-
-    // Calculate effective fee based on custom discount (if any)
-    let effective_fee =
-        calculate_fee_with_discount(program_id, sender.key, accounts, mailer_state.send_fee)?;
-
-    if revenue_share_to_receiver {
-        // Priority mode: full fee with revenue sharing
-
-        // Create or load recipient claim account
-        let (claim_pda, claim_bump) =
-            Pubkey::find_program_address(&[b"claim", to.as_ref()], program_id);
-
-        if recipient_claim.key != &claim_pda {
-            return Err(MailerError::InvalidPDA.into());
-        }
-
-        // Create claim account if needed
-        if recipient_claim.lamports() == 0 {
-            let rent = Rent::get()?;
-            let space = 8 + RecipientClaim::LEN;
-            let lamports = rent.minimum_balance(space);
-
-            invoke_signed(
-                &system_instruction::create_account(
-                    sender.key,
-                    recipient_claim.key,
-                    lamports,
-                    space as u64,
-                    program_id,
-                ),
-                &[
-                    sender.clone(),
-                    recipient_claim.clone(),
-                    system_program.clone(),
-                ],
-                &[&[b"claim", to.as_ref(), &[claim_bump]]],
-            )?;
-
-            // Initialize claim account
-            let mut claim_data = recipient_claim.try_borrow_mut_data()?;
-            claim_data[0..8]
-                .copy_from_slice(&hash_discriminator("account:RecipientClaim").to_le_bytes());
-
-            let claim_state = RecipientClaim {
-                recipient: to,
-                amount: 0,
-                timestamp: 0,
-                bump: claim_bump,
-            };
-
-            claim_state.serialize(&mut &mut claim_data[8..])?;
-            drop(claim_data);
-        }
-
-        // Transfer effective fee (may be discounted)
-        if effective_fee > 0 {
-            invoke(
-                &spl_token::instruction::transfer(
-                    token_program.key,
-                    sender_usdc.key,
-                    mailer_usdc.key,
-                    sender.key,
-                    &[],
-                    effective_fee,
-                )?,
-                &[
-                    sender_usdc.clone(),
-                    mailer_usdc.clone(),
-                    sender.clone(),
-                    token_program.clone(),
-                ],
-            )?;
-
-            // Record revenue shares (only if fee > 0)
-            record_shares(recipient_claim, mailer_account, to, effective_fee)?;
-        }
-
-        msg!("Webhook mail sent from {} to {} (webhookId: {}, revenue share enabled, resolve sender: {}, effective fee: {})", sender.key, to, webhook_id, _resolve_sender_to_name, effective_fee);
-    } else {
-        // Standard mode: 10% fee only, no revenue sharing
-        let owner_fee = (effective_fee * 10) / 100; // 10% of effective fee
-
-        // Transfer only owner fee (10%)
-        if owner_fee > 0 {
-            invoke(
-                &spl_token::instruction::transfer(
-                    token_program.key,
-                    sender_usdc.key,
-                    mailer_usdc.key,
-                    sender.key,
-                    &[],
-                    owner_fee,
-                )?,
-                &[
-                    sender_usdc.clone(),
-                    mailer_usdc.clone(),
-                    sender.clone(),
-                    token_program.clone(),
-                ],
-            )?;
-        }
-
-        // Update owner claimable
-        let mut mailer_data = mailer_account.try_borrow_mut_data()?;
-        let mut mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
-        mailer_state.owner_claimable += owner_fee;
-        mailer_state.serialize(&mut &mut mailer_data[8..])?;
-
-        msg!(
-            "Webhook mail sent from {} to {} (webhookId: {}, resolve sender: {}, effective fee: {})",
-            sender.key,
-            to,
-            webhook_id,
-            _resolve_sender_to_name,
-            effective_fee
-        );
-    }
+    msg!("Prepared mail sent from {} to email {} (mailId: {})", sender.key, to_email, mail_id);
 
     Ok(())
 }
@@ -1145,13 +649,6 @@ fn process_claim_recipient_share(_program_id: &Pubkey, accounts: &[AccountInfo])
         return Err(ProgramError::MissingRequiredSignature);
     }
 
-    let (mailer_pda, _) = assert_mailer_account(_program_id, mailer_account)?;
-    let (claim_pda, _) =
-        Pubkey::find_program_address(&[b"claim", recipient.key.as_ref()], _program_id);
-    if recipient_claim.key != &claim_pda {
-        return Err(MailerError::InvalidPDA.into());
-    }
-
     // Load claim state
     let mut claim_data = recipient_claim.try_borrow_mut_data()?;
     let mut claim_state: RecipientClaim = BorshDeserialize::deserialize(&mut &claim_data[8..])?;
@@ -1178,11 +675,6 @@ fn process_claim_recipient_share(_program_id: &Pubkey, accounts: &[AccountInfo])
     // Load mailer state for PDA signing
     let mailer_data = mailer_account.try_borrow_data()?;
     let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
-    drop(mailer_data);
-
-    assert_token_program(token_program)?;
-    assert_token_account(recipient_usdc, recipient.key, &mailer_state.usdc_mint)?;
-    assert_token_account(mailer_usdc, &mailer_pda, &mailer_state.usdc_mint)?;
 
     // Transfer USDC from mailer to recipient
     invoke_signed(
@@ -1220,8 +712,6 @@ fn process_claim_owner_share(_program_id: &Pubkey, accounts: &[AccountInfo]) ->
         return Err(ProgramError::MissingRequiredSignature);
     }
 
-    let (mailer_pda, _) = assert_mailer_account(_program_id, mailer_account)?;
-
     // Load and update mailer state
     let mut mailer_data = mailer_account.try_borrow_mut_data()?;
     let mut mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
@@ -1239,10 +729,6 @@ fn process_claim_owner_share(_program_id: &Pubkey, accounts: &[AccountInfo]) ->
     mailer_state.serialize(&mut &mut mailer_data[8..])?;
     drop(mailer_data);
 
-    assert_token_program(token_program)?;
-    assert_token_account(owner_usdc, owner.key, &mailer_state.usdc_mint)?;
-    assert_token_account(mailer_usdc, &mailer_pda, &mailer_state.usdc_mint)?;
-
     // Transfer USDC from mailer to owner
     invoke_signed(
         &spl_token::instruction::transfer(
@@ -1276,8 +762,6 @@ fn process_set_fee(_program_id: &Pubkey, accounts: &[AccountInfo], new_fee: u64)
         return Err(ProgramError::MissingRequiredSignature);
     }
 
-    assert_mailer_account(_program_id, mailer_account)?;
-
     // Load and update mailer state
     let mut mailer_data = mailer_account.try_borrow_mut_data()?;
     let mut mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
@@ -1318,25 +802,21 @@ fn process_delegate_to(
         return Err(ProgramError::MissingRequiredSignature);
     }
 
-    let (mailer_pda, _) = assert_mailer_account(program_id, mailer_account)?;
-
     // Load mailer state
     let mailer_data = mailer_account.try_borrow_data()?;
     let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
     drop(mailer_data);
 
-    assert_token_program(token_program)?;
-    assert_token_account(delegator_usdc, delegator.key, &mailer_state.usdc_mint)?;
-    assert_token_account(mailer_usdc, &mailer_pda, &mailer_state.usdc_mint)?;
-
     // Check if contract is paused
     if mailer_state.paused {
         return Err(MailerError::ContractPaused.into());
     }
 
     // Verify delegation account PDA
-    let (delegation_pda, delegation_bump) =
-        Pubkey::find_program_address(&[b"delegation", delegator.key.as_ref()], program_id);
+    let (delegation_pda, delegation_bump) = Pubkey::find_program_address(
+        &[b"delegation", delegator.key.as_ref()], 
+        program_id
+    );
 
     if delegation_account.key != &delegation_pda {
         return Err(MailerError::InvalidPDA.into());
@@ -1366,8 +846,7 @@ fn process_delegate_to(
 
         // Initialize delegation account
         let mut delegation_data = delegation_account.try_borrow_mut_data()?;
-        delegation_data[0..8]
-            .copy_from_slice(&hash_discriminator("account:Delegation").to_le_bytes());
+        delegation_data[0..8].copy_from_slice(&hash_discriminator("account:Delegation").to_le_bytes());
 
         let delegation_state = Delegation {
             delegator: *delegator.key,
@@ -1403,8 +882,7 @@ fn process_delegate_to(
 
     // Update delegation
     let mut delegation_data = delegation_account.try_borrow_mut_data()?;
-    let mut delegation_state: Delegation =
-        BorshDeserialize::deserialize(&mut &delegation_data[8..])?;
+    let mut delegation_state: Delegation = BorshDeserialize::deserialize(&mut &delegation_data[8..])?;
     delegation_state.delegate = delegate;
     delegation_state.serialize(&mut &mut delegation_data[8..])?;
 
@@ -1413,31 +891,18 @@ fn process_delegate_to(
 }
 
 /// Reject delegation
-fn process_reject_delegation(program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
+fn process_reject_delegation(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
     let account_iter = &mut accounts.iter();
     let rejector = next_account_info(account_iter)?;
     let delegation_account = next_account_info(account_iter)?;
-    let mailer_account = next_account_info(account_iter)?;
 
     if !rejector.is_signer {
         return Err(ProgramError::MissingRequiredSignature);
     }
 
-    // Verify mailer state PDA and ensure contract is not paused
-    let (_mailer_pda, _) = assert_mailer_account(program_id, mailer_account)?;
-
-    let mailer_data = mailer_account.try_borrow_data()?;
-    let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
-    drop(mailer_data);
-
-    if mailer_state.paused {
-        return Err(MailerError::ContractPaused.into());
-    }
-
     // Load and update delegation state
     let mut delegation_data = delegation_account.try_borrow_mut_data()?;
-    let mut delegation_state: Delegation =
-        BorshDeserialize::deserialize(&mut &delegation_data[8..])?;
+    let mut delegation_state: Delegation = BorshDeserialize::deserialize(&mut &delegation_data[8..])?;
 
     // Verify the rejector is the current delegate
     if delegation_state.delegate != Some(*rejector.key) {
@@ -1465,8 +930,6 @@ fn process_set_delegation_fee(
         return Err(ProgramError::MissingRequiredSignature);
     }
 
-    assert_mailer_account(_program_id, mailer_account)?;
-
     // Load and update mailer state
     let mut mailer_data = mailer_account.try_borrow_mut_data()?;
     let mut mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
@@ -1488,194 +951,6 @@ fn process_set_delegation_fee(
     Ok(())
 }
 
-/// Set custom fee percentage for a specific address (owner only)
-fn process_set_custom_fee_percentage(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    account: Pubkey,
-    percentage: u8,
-) -> ProgramResult {
-    let account_iter = &mut accounts.iter();
-    let owner = next_account_info(account_iter)?;
-    let mailer_account = next_account_info(account_iter)?;
-    let fee_discount_account = next_account_info(account_iter)?;
-    let _target_account = next_account_info(account_iter)?;
-    let payer = next_account_info(account_iter)?;
-    let system_program = next_account_info(account_iter)?;
-
-    if !owner.is_signer {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-
-    assert_mailer_account(program_id, mailer_account)?;
-
-    // Load mailer state and verify owner
-    let mailer_data = mailer_account.try_borrow_data()?;
-    let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
-    drop(mailer_data);
-
-    if mailer_state.owner != *owner.key {
-        return Err(MailerError::OnlyOwner.into());
-    }
-
-    // Check if contract is paused
-    if mailer_state.paused {
-        return Err(MailerError::ContractPaused.into());
-    }
-
-    // Validate percentage
-    if percentage > 100 {
-        return Err(MailerError::InvalidPercentage.into());
-    }
-
-    // Verify fee discount account PDA
-    let (discount_pda, bump) =
-        Pubkey::find_program_address(&[b"discount", account.as_ref()], program_id);
-
-    if fee_discount_account.key != &discount_pda {
-        return Err(MailerError::InvalidPDA.into());
-    }
-
-    // Create or update fee discount account
-    if fee_discount_account.lamports() == 0 {
-        let rent = Rent::get()?;
-        let space = 8 + FeeDiscount::LEN;
-        let lamports = rent.minimum_balance(space);
-
-        invoke_signed(
-            &system_instruction::create_account(
-                payer.key,
-                fee_discount_account.key,
-                lamports,
-                space as u64,
-                program_id,
-            ),
-            &[
-                payer.clone(),
-                fee_discount_account.clone(),
-                system_program.clone(),
-            ],
-            &[&[b"discount", account.as_ref(), &[bump]]],
-        )?;
-
-        // Initialize discount account
-        let mut discount_data = fee_discount_account.try_borrow_mut_data()?;
-        discount_data[0..8]
-            .copy_from_slice(&hash_discriminator("account:FeeDiscount").to_le_bytes());
-
-        let fee_discount = FeeDiscount {
-            account,
-            discount: 100 - percentage, // Store as discount: 0% fee = 100 discount, 100% fee = 0 discount
-            bump,
-        };
-
-        fee_discount.serialize(&mut &mut discount_data[8..])?;
-    } else {
-        // Update existing discount account
-        let mut discount_data = fee_discount_account.try_borrow_mut_data()?;
-        let mut fee_discount: FeeDiscount =
-            BorshDeserialize::deserialize(&mut &discount_data[8..])?;
-        fee_discount.discount = 100 - percentage; // Store as discount
-        fee_discount.serialize(&mut &mut discount_data[8..])?;
-    }
-
-    msg!("Custom fee percentage set for {}: {}%", account, percentage);
-    Ok(())
-}
-
-/// Clear custom fee percentage for a specific address (owner only)
-fn process_clear_custom_fee_percentage(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    account: Pubkey,
-) -> ProgramResult {
-    let account_iter = &mut accounts.iter();
-    let owner = next_account_info(account_iter)?;
-    let mailer_account = next_account_info(account_iter)?;
-    let fee_discount_account = next_account_info(account_iter)?;
-
-    if !owner.is_signer {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-
-    assert_mailer_account(program_id, mailer_account)?;
-
-    // Load mailer state and verify owner
-    let mailer_data = mailer_account.try_borrow_data()?;
-    let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
-    drop(mailer_data);
-
-    if mailer_state.owner != *owner.key {
-        return Err(MailerError::OnlyOwner.into());
-    }
-
-    // Check if contract is paused
-    if mailer_state.paused {
-        return Err(MailerError::ContractPaused.into());
-    }
-
-    // Verify fee discount account PDA
-    let (discount_pda, _) =
-        Pubkey::find_program_address(&[b"discount", account.as_ref()], program_id);
-
-    if fee_discount_account.key != &discount_pda {
-        return Err(MailerError::InvalidPDA.into());
-    }
-
-    // Clear by setting discount to 0 (no discount = 100% fee = default behavior)
-    if fee_discount_account.lamports() > 0 {
-        let mut discount_data = fee_discount_account.try_borrow_mut_data()?;
-        let mut fee_discount: FeeDiscount =
-            BorshDeserialize::deserialize(&mut &discount_data[8..])?;
-        fee_discount.discount = 0; // 0 discount = 100% fee = default
-        fee_discount.serialize(&mut &mut discount_data[8..])?;
-    }
-
-    msg!(
-        "Custom fee percentage cleared for {} (reset to 100%)",
-        account
-    );
-    Ok(())
-}
-
-fn assert_token_program(token_program: &AccountInfo) -> Result<(), ProgramError> {
-    if token_program.key != &spl_token::id() {
-        return Err(MailerError::InvalidTokenProgram.into());
-    }
-    Ok(())
-}
-
-fn assert_token_account(
-    token_account_info: &AccountInfo,
-    expected_owner: &Pubkey,
-    expected_mint: &Pubkey,
-) -> Result<(), ProgramError> {
-    let data = token_account_info.try_borrow_data()?;
-    let token_account = TokenAccount::unpack(&data)?;
-    drop(data);
-
-    if token_account.owner != *expected_owner {
-        return Err(MailerError::InvalidAccountOwner.into());
-    }
-
-    if token_account.mint != *expected_mint {
-        return Err(MailerError::InvalidMint.into());
-    }
-
-    Ok(())
-}
-
-fn assert_mailer_account(
-    program_id: &Pubkey,
-    mailer_account: &AccountInfo,
-) -> Result<(Pubkey, u8), ProgramError> {
-    let (mailer_pda, bump) = Pubkey::find_program_address(&[b"mailer"], program_id);
-    if mailer_account.key != &mailer_pda {
-        return Err(MailerError::InvalidPDA.into());
-    }
-    Ok((mailer_pda, bump))
-}
-
 /// Record revenue shares for priority messages
 fn record_shares(
     recipient_claim: &AccountInfo,
@@ -1702,51 +977,10 @@ fn record_shares(
     mailer_state.owner_claimable += owner_amount;
     mailer_state.serialize(&mut &mut mailer_data[8..])?;
 
-    msg!(
-        "Shares recorded: recipient {}, owner {}",
-        recipient_amount,
-        owner_amount
-    );
+    msg!("Shares recorded: recipient {}, owner {}", recipient_amount, owner_amount);
     Ok(())
 }
 
-/// Calculate the effective fee for an account based on custom discount
-/// If no discount account exists, returns full base_fee (default behavior)
-/// Otherwise applies discount: fee = base_fee * (100 - discount) / 100
-fn calculate_fee_with_discount(
-    program_id: &Pubkey,
-    account: &Pubkey,
-    accounts: &[AccountInfo],
-    base_fee: u64,
-) -> Result<u64, ProgramError> {
-    // Try to find fee discount account
-    let (discount_pda, _) =
-        Pubkey::find_program_address(&[b"discount", account.as_ref()], program_id);
-
-    // Check if any account in the accounts slice matches the discount PDA
-    let discount_account = accounts.iter().find(|acc| acc.key == &discount_pda);
-
-    if let Some(discount_acc) = discount_account {
-        // Account exists and has lamports - load the discount
-        if discount_acc.lamports() > 0 {
-            let discount_data = discount_acc.try_borrow_data()?;
-            if discount_data.len() >= 8 + FeeDiscount::LEN {
-                let fee_discount: FeeDiscount =
-                    BorshDeserialize::deserialize(&mut &discount_data[8..])?;
-                let discount = fee_discount.discount as u64;
-
-                // Apply discount: fee = base_fee * (100 - discount) / 100
-                // Examples: discount=0 → 100% fee, discount=50 → 50% fee, discount=100 → 0% fee (free)
-                let effective_fee = (base_fee * (100 - discount)) / 100;
-                return Ok(effective_fee);
-            }
-        }
-    }
-
-    // No discount account or uninitialized - use full fee (default behavior)
-    Ok(base_fee)
-}
-
 /// Pause the contract and distribute owner claimable funds
 fn process_pause(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
     let account_iter = &mut accounts.iter();
@@ -1760,8 +994,6 @@ fn process_pause(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResul
         return Err(ProgramError::MissingRequiredSignature);
     }
 
-    let (mailer_pda, _) = assert_mailer_account(_program_id, mailer_account)?;
-
     // Load and update mailer state
     let mut mailer_data = mailer_account.try_borrow_mut_data()?;
     let mut mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
@@ -1779,17 +1011,13 @@ fn process_pause(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResul
     // Set paused state
     mailer_state.paused = true;
 
-    assert_token_program(token_program)?;
-
     // Distribute owner claimable funds if any
     if mailer_state.owner_claimable > 0 {
         let amount = mailer_state.owner_claimable;
         mailer_state.owner_claimable = 0;
 
-        assert_token_account(owner_usdc, owner.key, &mailer_state.usdc_mint)?;
-        assert_token_account(mailer_usdc, &mailer_pda, &mailer_state.usdc_mint)?;
-
         // Transfer USDC from mailer to owner
+        let (mailer_pda, bump) = Pubkey::find_program_address(&[b"mailer"], _program_id);
         invoke_signed(
             &spl_token::instruction::transfer(
                 token_program.key,
@@ -1799,13 +1027,8 @@ fn process_pause(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResul
                 &[],
                 amount,
             )?,
-            &[
-                mailer_usdc.clone(),
-                owner_usdc.clone(),
-                mailer_account.clone(),
-                token_program.clone(),
-            ],
-            &[&[b"mailer", &[mailer_state.bump]]],
+            &[mailer_usdc.clone(), owner_usdc.clone(), token_program.clone()],
+            &[&[b"mailer", &[bump]]],
         )?;
 
         msg!("Distributed owner funds during pause: {}", amount);
@@ -1813,7 +1036,7 @@ fn process_pause(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResul
 
     // Save updated state
     mailer_state.serialize(&mut &mut mailer_data[8..])?;
-
+    
     msg!("Contract paused by owner: {}", owner.key);
     Ok(())
 }
@@ -1828,8 +1051,6 @@ fn process_unpause(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramRes
         return Err(ProgramError::MissingRequiredSignature);
     }
 
-    assert_mailer_account(_program_id, mailer_account)?;
-
     // Load and update mailer state
     let mut mailer_data = mailer_account.try_borrow_mut_data()?;
     let mut mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
@@ -1847,11 +1068,43 @@ fn process_unpause(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramRes
     // Set unpaused state
     mailer_state.paused = false;
     mailer_state.serialize(&mut &mut mailer_data[8..])?;
-
+    
     msg!("Contract unpaused by owner: {}", owner.key);
     Ok(())
 }
 
+/// Emergency unpause without fund distribution (owner only)
+fn process_emergency_unpause(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
+    let account_iter = &mut accounts.iter();
+    let owner = next_account_info(account_iter)?;
+    let mailer_account = next_account_info(account_iter)?;
+
+    if !owner.is_signer {
+        return Err(ProgramError::MissingRequiredSignature);
+    }
+
+    // Load and update mailer state
+    let mut mailer_data = mailer_account.try_borrow_mut_data()?;
+    let mut mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
+
+    // Verify owner
+    if mailer_state.owner != *owner.key {
+        return Err(MailerError::OnlyOwner.into());
+    }
+
+    // Check if not paused
+    if !mailer_state.paused {
+        return Err(MailerError::ContractNotPaused.into());
+    }
+
+    // Set unpaused state without fund distribution
+    mailer_state.paused = false;
+    mailer_state.serialize(&mut &mut mailer_data[8..])?;
+    
+    msg!("Contract emergency unpaused by owner: {} - funds can be claimed manually", owner.key);
+    Ok(())
+}
+
 /// Distribute claimable funds when contract is paused
 fn process_distribute_claimable_funds(
     _program_id: &Pubkey,
@@ -1866,8 +1119,6 @@ fn process_distribute_claimable_funds(
     let mailer_usdc = next_account_info(account_iter)?;
     let token_program = next_account_info(account_iter)?;
 
-    let (mailer_pda, _) = assert_mailer_account(_program_id, mailer_account)?;
-
     // Load mailer state to check if paused
     let mailer_data = mailer_account.try_borrow_data()?;
     let mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
@@ -1884,8 +1135,6 @@ fn process_distribute_claimable_funds(
         return Err(MailerError::InvalidPDA.into());
     }
 
-    assert_token_program(token_program)?;
-
     // Load and update recipient claim
     let mut claim_data = recipient_claim_account.try_borrow_mut_data()?;
     let mut claim_state: RecipientClaim = BorshDeserialize::deserialize(&mut &claim_data[8..])?;
@@ -1898,10 +1147,8 @@ fn process_distribute_claimable_funds(
     claim_state.amount = 0;
     claim_state.timestamp = 0;
 
-    assert_token_account(recipient_usdc, &recipient, &mailer_state.usdc_mint)?;
-    assert_token_account(mailer_usdc, &mailer_pda, &mailer_state.usdc_mint)?;
-
     // Transfer USDC from mailer to recipient
+    let (mailer_pda, bump) = Pubkey::find_program_address(&[b"mailer"], _program_id);
     invoke_signed(
         &spl_token::instruction::transfer(
             token_program.key,
@@ -1911,118 +1158,16 @@ fn process_distribute_claimable_funds(
             &[],
             amount,
         )?,
-        &[
-            mailer_usdc.clone(),
-            recipient_usdc.clone(),
-            mailer_account.clone(),
-            token_program.clone(),
-        ],
-        &[&[b"mailer", &[mailer_state.bump]]],
+        &[mailer_usdc.clone(), recipient_usdc.clone(), token_program.clone()],
+        &[&[b"mailer", &[bump]]],
     )?;
 
     claim_state.serialize(&mut &mut claim_data[8..])?;
-
+    
     msg!("Distributed claimable funds to {}: {}", recipient, amount);
     Ok(())
 }
 
-/// Claim expired shares and move them under owner control (owner only)
-fn process_claim_expired_shares(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    recipient: Pubkey,
-) -> ProgramResult {
-    let account_iter = &mut accounts.iter();
-    let owner = next_account_info(account_iter)?;
-    let mailer_account = next_account_info(account_iter)?;
-    let recipient_claim_account = next_account_info(account_iter)?;
-
-    if !owner.is_signer {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-
-    let (_mailer_pda, _) = assert_mailer_account(program_id, mailer_account)?;
-
-    // Load and verify mailer state
-    let mut mailer_data = mailer_account.try_borrow_mut_data()?;
-    let mut mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
-
-    if mailer_state.owner != *owner.key {
-        return Err(MailerError::OnlyOwner.into());
-    }
-
-    // Verify recipient claim PDA
-    let (claim_pda, _) = Pubkey::find_program_address(&[b"claim", recipient.as_ref()], program_id);
-    if recipient_claim_account.key != &claim_pda {
-        return Err(MailerError::InvalidPDA.into());
-    }
-
-    // Load and validate claim state
-    let mut claim_data = recipient_claim_account.try_borrow_mut_data()?;
-    let mut claim_state: RecipientClaim = BorshDeserialize::deserialize(&mut &claim_data[8..])?;
-
-    if claim_state.recipient != recipient {
-        return Err(MailerError::InvalidRecipient.into());
-    }
-    if claim_state.amount == 0 {
-        return Err(MailerError::NoClaimableAmount.into());
-    }
-
-    let current_time = Clock::get()?.unix_timestamp;
-    if current_time <= claim_state.timestamp + CLAIM_PERIOD {
-        return Err(MailerError::ClaimPeriodNotExpired.into());
-    }
-
-    let amount = claim_state.amount;
-    claim_state.amount = 0;
-    claim_state.timestamp = 0;
-    claim_state.serialize(&mut &mut claim_data[8..])?;
-    drop(claim_data);
-
-    mailer_state.owner_claimable += amount;
-    mailer_state.serialize(&mut &mut mailer_data[8..])?;
-
-    msg!("Expired shares claimed for {}: {}", recipient, amount);
-    Ok(())
-}
-
-/// Emergency unpause without fund distribution (owner only)
-fn process_emergency_unpause(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
-    let account_iter = &mut accounts.iter();
-    let owner = next_account_info(account_iter)?;
-    let mailer_account = next_account_info(account_iter)?;
-
-    if !owner.is_signer {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-
-    assert_mailer_account(_program_id, mailer_account)?;
-
-    // Load and update mailer state
-    let mut mailer_data = mailer_account.try_borrow_mut_data()?;
-    let mut mailer_state: MailerState = BorshDeserialize::deserialize(&mut &mailer_data[8..])?;
-
-    // Verify owner
-    if mailer_state.owner != *owner.key {
-        return Err(MailerError::OnlyOwner.into());
-    }
-
-    // Check if not paused
-    if !mailer_state.paused {
-        return Err(MailerError::ContractNotPaused.into());
-    }
-
-    // Set unpaused state without fund distribution
-    mailer_state.paused = false;
-    mailer_state.serialize(&mut &mut mailer_data[8..])?;
-
-    msg!(
-        "Contract emergency unpaused by owner: {} - funds can be claimed manually",
-        owner.key
-    );
-    Ok(())
-}
-
 /// Simple hash function for account discriminators
 fn hash_discriminator(name: &str) -> u64 {
     use std::collections::hash_map::DefaultHasher;