Add referral fee ppm to auction server (#527)

Author: danimhr

auction-server/api-types/src/opportunity.rs

@@ -224,14 +224,24 @@ pub enum OpportunityParamsV1ProgramSvm {
         #[serde_as(as = "DisplayFromStr")]
         router_account: Pubkey,
 
+        // TODO this should be deleted
         /// The referral fee in basis points.
         #[schema(example = 10)]
         referral_fee_bps: u16,
 
+        /// The referral fee in parts per million.
+        #[schema(example = 1000)]
+        referral_fee_ppm: u64,
+
+        // TODO this should be deleted
         /// The platform fee in basis points.
         #[schema(example = 10)]
         platform_fee_bps: u64,
 
+        /// The platform fee in parts per million.
+        #[schema(example = 1000)]
+        platform_fee_ppm: u64,
+
         /// Specifies whether the fees are to be paid in the searcher or user token.
         #[schema(example = "searcher_token")]
         fee_token: FeeToken,
@@ -471,9 +481,9 @@ pub struct ReferralFeeInfo {
     #[schema(example = "DUcTi3rDyS5QEmZ4BNRBejtArmDCWaPYGfN44vBJXKL5", value_type = String)]
     #[serde_as(as = "DisplayFromStr")]
     pub router:           Pubkey,
-    /// The referral fee in basis points.
+    /// The referral fee in parts per million.
     #[schema(example = 10, value_type = u16)]
-    pub referral_fee_bps: u16,
+    pub referral_fee_ppm: u64,
 }
 
 #[derive(Serialize, Deserialize, ToSchema, Clone, PartialEq, Debug)]

auction-server/src/api.rs

@@ -319,8 +319,12 @@ pub enum SwapInstructionError {
         found:    express_relay::FeeToken,
     },
     ReferralFee {
-        expected: u16,
-        found:    u16,
+        expected: u64,
+        found:    u64,
+    },
+    PlatformFee {
+        expected: u64,
+        found:    u64,
     },
     AssociatedRouterTokenAccount {
         expected: Pubkey,
@@ -381,6 +385,11 @@ impl std::fmt::Display for SwapInstructionError {
                 "Associated token account for router does not match. Expected: {:?} found: {:?}",
                 expected, found
             ),
+            SwapInstructionError::PlatformFee { expected, found } => write!(
+                f,
+                "Invalid platform fee ppm {} in swap instruction data. Value does not match the platform fee ppm in swap opportunity {}",
+                found, expected
+            ),
         }
     }
 }

auction-server/src/auction/service/mod.rs

@@ -224,9 +224,10 @@ mod mock_service {
                 auction: entities::Auction,
             ) -> Result<VersionedTransaction, RestError>;
 
-            pub fn extract_swap_data(
+            pub async fn extract_swap_data(
+                &self,
                 instruction: &CompiledInstruction,
-            ) -> Result<express_relay::SwapArgs, RestError>;
+            ) -> Result<express_relay::SwapV2Args, RestError>;
 
             pub fn get_new_status(
                 bid: &entities::Bid,

auction-server/src/auction/service/submit_quote.rs

@@ -84,7 +84,7 @@ impl Service {
         &self,
         signed_bid: entities::Bid,
         auction: entities::Auction,
-        swap_args: express_relay::SwapArgs,
+        swap_args: express_relay::SwapV2Args,
         lock: entities::BidLock,
     ) -> Result<(), RestError> {
         let _lock = lock.lock().await;
@@ -162,7 +162,7 @@ impl Service {
     fn is_within_deadline_buffer(
         &self,
         chain_id: ChainId,
-        swap_args: express_relay::SwapArgs,
+        swap_args: express_relay::SwapV2Args,
     ) -> bool {
         let deadline_buffer_secs = swap_args.deadline - OffsetDateTime::now_utc().unix_timestamp();
 
@@ -235,7 +235,9 @@ impl Service {
             return Err(RestError::BadParameters("Invalid quote.".to_string()));
         }
 
-        let swap_args = Self::extract_swap_data(&swap_instruction)
+        let swap_args = self
+            .extract_swap_data(&swap_instruction)
+            .await
             .map_err(|_| RestError::BadParameters("Invalid quote.".to_string()))?;
 
         let bid_lock = self

auction-server/src/auction/service/verification.rs

@@ -28,6 +28,7 @@ use {
                 TokenAccountInitializationConfigs,
             },
             service::{
+                get_express_relay_metadata::GetExpressRelayMetadataInput,
                 get_live_opportunities::GetLiveOpportunitiesInput,
                 get_opportunities::GetLiveOpportunityByIdInput,
                 get_quote::{
@@ -278,26 +279,50 @@ impl Service {
         })
     }
 
-    pub fn extract_swap_data(
+    pub async fn extract_swap_data(
+        &self,
         instruction: &CompiledInstruction,
-    ) -> Result<express_relay_svm::SwapArgs, RestError> {
-        let discriminator = express_relay_svm::instruction::Swap::DISCRIMINATOR;
-        express_relay_svm::SwapArgs::try_from_slice(
-            &instruction.data.as_slice()[discriminator.len()..],
-        )
-        .map_err(|e| RestError::BadParameters(format!("Invalid swap instruction data: {}", e)))
+    ) -> Result<express_relay_svm::SwapV2Args, RestError> {
+        if instruction
+            .data
+            .starts_with(express_relay_svm::instruction::Swap::DISCRIMINATOR)
+        {
+            let discriminator = express_relay_svm::instruction::Swap::DISCRIMINATOR;
+            let express_relay_metadata = self
+                .opportunity_service
+                .get_express_relay_metadata(GetExpressRelayMetadataInput {
+                    chain_id: self.config.chain_id.clone(),
+                })
+                .await?;
+            let swap_args = express_relay_svm::SwapArgs::try_from_slice(
+                &instruction.data.as_slice()[discriminator.len()..],
+            )
+            .map_err(|e| {
+                RestError::BadParameters(format!("Invalid swap instruction data: {}", e))
+            })?;
+            Ok(swap_args.convert_to_v2(express_relay_metadata.swap_platform_fee_bps))
+        } else {
+            let discriminator = express_relay_svm::instruction::SwapV2::DISCRIMINATOR;
+            express_relay_svm::SwapV2Args::try_from_slice(
+                &instruction.data.as_slice()[discriminator.len()..],
+            )
+            .map_err(|e| RestError::BadParameters(format!("Invalid swap instruction data: {}", e)))
+        }
     }
 
     pub fn extract_express_relay_instruction(
         &self,
         transaction: VersionedTransaction,
         instruction_type: BidPaymentInstructionType,
     ) -> Result<(usize, CompiledInstruction), RestError> {
-        let discriminator = match instruction_type {
+        let valid_discriminators = match instruction_type {
             BidPaymentInstructionType::SubmitBid => {
-                express_relay_svm::instruction::SubmitBid::DISCRIMINATOR
+                vec![express_relay_svm::instruction::SubmitBid::DISCRIMINATOR]
             }
-            BidPaymentInstructionType::Swap => express_relay_svm::instruction::Swap::DISCRIMINATOR,
+            BidPaymentInstructionType::Swap => vec![
+                express_relay_svm::instruction::Swap::DISCRIMINATOR,
+                express_relay_svm::instruction::SwapV2::DISCRIMINATOR,
+            ],
         };
         let instructions = Self::extract_program_instructions(
             &transaction,
@@ -316,7 +341,10 @@ impl Service {
                 instructions.len(),
             )),
         }?;
-        if !instruction.data.starts_with(discriminator) {
+        if valid_discriminators
+            .iter()
+            .all(|discriminator| !instruction.data.starts_with(discriminator))
+        {
             return Err(RestError::BadParameters(
                 "Wrong instruction type for Express Relay Program".to_string(),
             ));
@@ -398,7 +426,7 @@ impl Service {
             bid_data.transaction.clone(),
             BidPaymentInstructionType::Swap,
         )?;
-        let swap_data = Self::extract_swap_data(&swap_instruction)?;
+        let swap_data = self.extract_swap_data(&swap_instruction).await?;
         let SwapAccounts {
             user_wallet,
             mint_searcher,
@@ -508,11 +536,20 @@ impl Service {
             ));
         }
 
-        if swap_data.referral_fee_bps != opportunity_swap_data.referral_fee_bps {
+        if swap_data.referral_fee_ppm != opportunity_swap_data.referral_fee_ppm {
             return Err(RestError::InvalidSwapInstruction(
                 SwapInstructionError::ReferralFee {
-                    expected: opportunity_swap_data.referral_fee_bps,
-                    found:    swap_data.referral_fee_bps,
+                    expected: opportunity_swap_data.referral_fee_ppm,
+                    found:    swap_data.referral_fee_ppm,
+                },
+            ));
+        }
+
+        if swap_data.swap_platform_fee_ppm != opportunity_swap_data.platform_fee_ppm {
+            return Err(RestError::InvalidSwapInstruction(
+                SwapInstructionError::PlatformFee {
+                    expected: opportunity_swap_data.platform_fee_ppm,
+                    found:    swap_data.swap_platform_fee_ppm,
                 },
             ));
         }
@@ -604,7 +641,7 @@ impl Service {
     async fn check_transfer_instruction(
         &self,
         tx: &VersionedTransaction,
-        swap_data: &express_relay_svm::SwapArgs,
+        swap_data: &express_relay_svm::SwapV2Args,
         swap_accounts: &SwapAccounts,
         opportunity_swap_data: &OpportunitySvmProgramSwap,
     ) -> Result<(), RestError> {
@@ -1081,7 +1118,7 @@ impl Service {
     async fn check_wrap_unwrap_native_token_instructions(
         &self,
         tx: &VersionedTransaction,
-        swap_data: &express_relay_svm::SwapArgs,
+        swap_data: &express_relay_svm::SwapV2Args,
         swap_accounts: &SwapAccounts,
         opportunity_swap_data: &OpportunitySvmProgramSwap,
     ) -> Result<(), RestError> {
@@ -1170,7 +1207,7 @@ impl Service {
                         bid_data.transaction.clone(),
                         BidPaymentInstructionType::Swap,
                     )?;
-                let swap_data = Self::extract_swap_data(&swap_instruction)?;
+                let swap_data = self.extract_swap_data(&swap_instruction).await?;
                 let swap_accounts = self
                     .extract_swap_accounts(&bid_data.transaction, &swap_instruction)
                     .await?;
@@ -1229,7 +1266,7 @@ impl Service {
                     &quote_tokens,
                     &user_wallet,
                     &router_token_account,
-                    swap_data.referral_fee_bps,
+                    swap_data.referral_fee_ppm,
                 );
 
                 Ok(BidDataSvm {
@@ -1607,6 +1644,7 @@ mod tests {
             },
         },
         borsh::BorshDeserialize,
+        express_relay::state::FEE_BPS_TO_PPM,
         express_relay_api_types::opportunity as opportunity_api,
         express_relay_client::svm::{
             self,
@@ -1654,10 +1692,12 @@ mod tests {
             Self {
                 user_wallet_address,
                 platform_fee_bps: 0,
+                platform_fee_ppm: 0,
                 token_program_user: spl_token::id(),
                 token_program_searcher: spl_token::id(),
                 fee_token: FeeToken::UserToken,
                 referral_fee_bps: 10,
+                referral_fee_ppm: 1_000,
                 user_mint_user_balance: LAMPORTS_PER_SOL,
                 token_account_initialization_configs:
                     TokenAccountInitializationConfigs::searcher_payer(),
@@ -1721,6 +1761,7 @@ mod tests {
             searcher_token: spl_token::native_mint::id(),
         };
         let referral_fee_bps = 10;
+        let referral_fee_ppm = referral_fee_bps * FEE_BPS_TO_PPM;
 
         let router_token_account = get_associated_token_address_with_program_id(
             &router,
@@ -1737,25 +1778,25 @@ mod tests {
             &tokens_user_specified,
             &user_wallet_address,
             &router_token_account,
-            referral_fee_bps,
+            referral_fee_ppm,
         );
         let permission_account_searcher_token_specified = get_quote_virtual_permission_account(
             &tokens_searcher_specified,
             &user_wallet_address,
             &router_token_account,
-            referral_fee_bps,
+            referral_fee_ppm,
         );
         let permission_account_user_token_wsol = get_quote_virtual_permission_account(
             &tokens_user_wsol,
             &user_wallet_address,
             &router_token_account_wsol,
-            referral_fee_bps,
+            referral_fee_ppm,
         );
         let permission_account_searcher_token_wsol = get_quote_virtual_permission_account(
             &tokens_searcher_wsol,
             &user_wallet_address,
             &router_token_account,
-            referral_fee_bps,
+            referral_fee_ppm,
         );
 
         let opp_user_token_specified = OpportunitySvm {
@@ -1875,7 +1916,7 @@ mod tests {
             &tokens_user_specified,
             &indicative_price_taker,
             &router_token_account,
-            referral_fee_bps,
+            referral_fee_ppm,
         );
 
         let opp_with_indicative_price_taker = OpportunitySvm {
@@ -2026,6 +2067,24 @@ mod tests {
                     .cloned()
             });
 
+        opportunity_service
+            .expect_get_express_relay_metadata()
+            .returning(move |_| {
+                Ok(express_relay::state::ExpressRelayMetadata {
+                    admin:                    Pubkey::new_unique(),
+                    relayer_signer:           Pubkey::new_unique(),
+                    fee_receiver_relayer:     Pubkey::new_unique(),
+                    // the portion of the bid that goes to the router, in bps
+                    split_router_default:     10,
+                    // the portion of the remaining bid (after router fees) that goes to the relayer, in bps
+                    split_relayer:            20,
+                    // the portion of the swap amount that should go to the platform (relayer + express relay), in bps
+                    swap_platform_fee_bps:    30,
+                    // secondary relayer signer, useful for 0-downtime transitioning to a new relayer
+                    secondary_relayer_signer: Pubkey::new_unique(),
+                })
+            });
+
         (
             opportunity_service,
             TestOpportunities {
@@ -2897,7 +2956,7 @@ mod tests {
             OpportunitySvmProgram::Swap(program) => program,
             _ => panic!("Expected swap program"),
         };
-        program.referral_fee_bps += 1;
+        program.referral_fee_ppm += 1;
         opportunity.program = OpportunitySvmProgram::Swap(program.clone());
         let swap_instruction = svm::Svm::get_swap_instruction(GetSwapInstructionParams {
             searcher:             searcher.pubkey(),
@@ -2914,8 +2973,8 @@ mod tests {
         assert_eq!(
             result.unwrap_err(),
             RestError::InvalidSwapInstruction(SwapInstructionError::ReferralFee {
-                expected: program.referral_fee_bps - 1,
-                found:    program.referral_fee_bps,
+                expected: program.referral_fee_ppm - 1,
+                found:    program.referral_fee_ppm,
             })
         );
     }