@sudobility/contracts 1.10.1 → 1.11.0

package/programs/mailer/src/lib.rs

@@ -33,11 +33,13 @@ 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
@@ -177,6 +179,22 @@ pub enum MailerInstruction {
     /// 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,
+    },
+
     /// Claim recipient share
     /// Accounts:
     /// 0. `[signer]` Recipient
@@ -310,6 +328,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")]
@@ -372,6 +394,19 @@ pub fn process_instruction(
         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)
         }
@@ -489,15 +524,15 @@ fn process_send(
     }
 
     // Load mailer state
-    let (mailer_pda, _) = Pubkey::find_program_address(&[b"mailer"], program_id);
-    if mailer_account.key != &mailer_pda {
-        return Err(MailerError::InvalidPDA.into());
-    }
-
+    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());
@@ -646,10 +681,15 @@ fn process_send_prepared(
     }
 
     // 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());
@@ -795,10 +835,15 @@ 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());
@@ -869,10 +914,15 @@ fn process_send_prepared_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());
@@ -924,6 +974,163 @@ fn process_send_prepared_to_email(
     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
+        );
+    }
+
+    Ok(())
+}
+
 /// Process claim recipient share
 fn process_claim_recipient_share(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResult {
     let account_iter = &mut accounts.iter();
@@ -938,6 +1145,13 @@ 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..])?;
@@ -964,6 +1178,11 @@ 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(
@@ -1001,6 +1220,8 @@ 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..])?;
@@ -1018,6 +1239,10 @@ 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(
@@ -1051,6 +1276,8 @@ 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..])?;
@@ -1091,11 +1318,17 @@ 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());
@@ -1191,10 +1424,7 @@ fn process_reject_delegation(program_id: &Pubkey, accounts: &[AccountInfo]) -> P
     }
 
     // Verify mailer state PDA and ensure contract is not paused
-    let (mailer_pda, _) = Pubkey::find_program_address(&[b"mailer"], program_id);
-    if mailer_account.key != &mailer_pda {
-        return Err(MailerError::InvalidPDA.into());
-    }
+    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..])?;
@@ -1235,6 +1465,8 @@ 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..])?;
@@ -1275,6 +1507,8 @@ fn process_set_custom_fee_percentage(
         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..])?;
@@ -1364,6 +1598,8 @@ fn process_clear_custom_fee_percentage(
         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..])?;
@@ -1402,6 +1638,44 @@ fn process_clear_custom_fee_percentage(
     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,
@@ -1486,6 +1760,8 @@ 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..])?;
@@ -1503,13 +1779,17 @@ 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,
@@ -1525,7 +1805,7 @@ fn process_pause(_program_id: &Pubkey, accounts: &[AccountInfo]) -> ProgramResul
                 mailer_account.clone(),
                 token_program.clone(),
             ],
-            &[&[b"mailer", &[bump]]],
+            &[&[b"mailer", &[mailer_state.bump]]],
         )?;
 
         msg!("Distributed owner funds during pause: {}", amount);
@@ -1548,6 +1828,8 @@ 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..])?;
@@ -1584,6 +1866,8 @@ 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..])?;
@@ -1600,6 +1884,8 @@ 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..])?;
@@ -1612,8 +1898,10 @@ 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,
@@ -1629,7 +1917,7 @@ fn process_distribute_claimable_funds(
             mailer_account.clone(),
             token_program.clone(),
         ],
-        &[&[b"mailer", &[bump]]],
+        &[&[b"mailer", &[mailer_state.bump]]],
     )?;
 
     claim_state.serialize(&mut &mut claim_data[8..])?;
@@ -1653,6 +1941,8 @@ fn process_claim_expired_shares(
         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..])?;
@@ -1706,6 +1996,8 @@ fn process_emergency_unpause(_program_id: &Pubkey, accounts: &[AccountInfo]) ->
         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..])?;