Feat/cu price (#47)

jordy25519 · web-flow · commit 222b3f53b28c · 2024-04-05T13:38:07.000+08:00
* Allow setting CU price per request
* Refactor controller methods to receive context struct
diff --git a/README.md b/README.md
@@ -121,9 +121,11 @@ A `subAccountId` URL query parameter may be supplied to switch the sub-account p
 
 e.g `http://<gateway>/v1/orders?subAccountId=3` will return orders for the wallet's sub-account 3
 
-## CU Limits
+## CU Price & Limits
 
-CU limit may be set on transaction request with the query parameter `computeUnitLimit=300000`, the default if unset is `200000`.
+**CU limit** may be set on transaction request with the query parameter `computeUnitLimit=300000`, the default if unset is `200000`.
+
+**CU price** in micro-lamports may be set on transaction request with the query parameter `computeUnitPrice=1000`, the default if unset is a dynamic value from chain set at 90-th percentile of the local fee market.  
 
 The following error is logged when a tx does not have enough CU limit, increasing the cu limit can fix it or reducing number complexity of the order e..g number of orders/markets per batch.
 
@@ -134,13 +136,11 @@ The following error is logged when a tx does not have enough CU limit, increasin
 **example request**
 
 ```bash
-$ curl 'localhost:8080/v2/orders?computeUnitLimit=300000' -X POST \
+$ curl 'localhost:8080/v2/orders?computeUnitLimit=300000&computeUnitPrice=1000' -X POST \
 -H 'content-type: application/json' \
 -d # { order data ...}
 ```
 
-The CU price (aka priority fee) is automatically inferred from onchain fee data at 75th percentile.
-
 ## API Examples
 
 Please refer to https://drift-labs.github.io/v2-teacher/ for further examples and reference documentation on various types, fields, and operations available on drift.
diff --git a/src/controller.rs b/src/controller.rs
@@ -4,7 +4,7 @@ use drift_sdk::{
     event_subscriber::{try_parse_log, CommitmentConfig},
     math::liquidation::calculate_liquidation_price_and_unrealized_pnl,
     types::{
-        Context, MarketId, MarketType, ModifyOrderParams, RpcSendTransactionConfig, SdkError,
+        self, MarketId, MarketType, ModifyOrderParams, RpcSendTransactionConfig, SdkError,
         SdkResult, VersionedMessage,
     },
     AccountProvider, DriftClient, Pubkey, RpcAccountProvider, TransactionBuilder, Wallet,
@@ -15,7 +15,7 @@ use rust_decimal::Decimal;
 use solana_client::{client_error::ClientErrorKind, rpc_config::RpcTransactionConfig};
 use solana_sdk::signature::Signature;
 use solana_transaction_status::{option_serializer::OptionSerializer, UiTransactionEncoding};
-use std::{borrow::Cow, str::FromStr, sync::Arc, time::Duration};
+use std::{borrow::Cow, str::FromStr, sync::Arc};
 use thiserror::Error;
 
 use crate::{
@@ -27,7 +27,7 @@ use crate::{
         TxEventsResponse, TxResponse, PRICE_DECIMALS,
     },
     websocket::map_drift_event_for_account,
-    LOG_TARGET,
+    Context, LOG_TARGET,
 };
 
 pub type GatewayResult<T> = Result<T, ControllerError>;
@@ -84,9 +84,9 @@ impl AppState {
         let (state_commitment, tx_commitment) =
             commitment.unwrap_or((CommitmentConfig::confirmed(), CommitmentConfig::confirmed()));
         let context = if devnet {
-            Context::DevNet
+            types::Context::DevNet
         } else {
-            Context::MainNet
+            types::Context::MainNet
         };
 
         let account_provider = RpcAccountProvider::with_commitment(endpoint, state_commitment);
@@ -132,35 +132,36 @@ impl AppState {
     /// 4) catch all. cancel all orders
     pub async fn cancel_orders(
         &self,
+        ctx: Context,
         req: CancelOrdersRequest,
-        sub_account_id: Option<u16>,
-        cu_limit: Option<u32>,
     ) -> GatewayResult<TxResponse> {
-        let sub_account = self.resolve_sub_account(sub_account_id);
+        let sub_account = self.resolve_sub_account(ctx.sub_account_id);
         let (account_data, pf) = tokio::join!(
             self.client.get_user_account(&sub_account),
             get_priority_fee(&self.client)
         );
+        let priority_fee = ctx.cu_price.unwrap_or(pf);
+        debug!(target: LOG_TARGET, "priority_fee: {priority_fee:?}");
         let builder = TransactionBuilder::new(
             self.client.program_data(),
             sub_account,
             Cow::Owned(account_data?),
             self.delegated,
         )
-        .with_priority_fee(pf, cu_limit);
+        .with_priority_fee(priority_fee, ctx.cu_limit);
         let tx = build_cancel_ix(builder, req)?.build();
         self.send_tx(tx, "cancel_orders").await
     }
 
     /// Return orders by position if given, otherwise return all positions
     pub async fn get_positions(
         &self,
+        ctx: Context,
         req: Option<GetPositionsRequest>,
-        sub_account_id: Option<u16>,
     ) -> GatewayResult<GetPositionsResponse> {
         let (all_spot, all_perp) = self
             .client
-            .all_positions(&self.resolve_sub_account(sub_account_id))
+            .all_positions(&self.resolve_sub_account(ctx.sub_account_id))
             .await?;
 
         // calculating spot token balance requires knowing the 'spot market account' data
@@ -204,10 +205,10 @@ impl AppState {
 
     pub async fn get_position_extended(
         &self,
-        sub_account_id: Option<u16>,
+        ctx: Context,
         market: Market,
     ) -> GatewayResult<PerpPosition> {
-        let sub_account = self.resolve_sub_account(sub_account_id);
+        let sub_account = self.resolve_sub_account(ctx.sub_account_id);
         let (perp_position, user, oracle) = tokio::join!(
             self.client.perp_position(&sub_account, market.market_index),
             self.client.get_user_account(&sub_account),
@@ -247,10 +248,10 @@ impl AppState {
     /// Return orders by market if given, otherwise return all orders
     pub async fn get_orders(
         &self,
+        ctx: Context,
         req: Option<GetOrdersRequest>,
-        sub_account_id: Option<u16>,
     ) -> GatewayResult<GetOrdersResponse> {
-        let sub_account = self.resolve_sub_account(sub_account_id);
+        let sub_account = self.resolve_sub_account(ctx.sub_account_id);
         let orders = self.client.all_orders(&sub_account).await?;
         Ok(GetOrdersResponse {
             orders: orders
@@ -299,9 +300,8 @@ impl AppState {
 
     pub async fn cancel_and_place_orders(
         &self,
+        ctx: Context,
         req: CancelAndPlaceRequest,
-        sub_account_id: Option<u16>,
-        cu_limit: Option<u32>,
     ) -> GatewayResult<TxResponse> {
         let orders = req
             .place
@@ -313,7 +313,7 @@ impl AppState {
             })
             .collect();
 
-        let sub_account = self.resolve_sub_account(sub_account_id);
+        let sub_account = self.resolve_sub_account(ctx.sub_account_id);
         let (account_data, pf) = tokio::join!(
             self.client.get_user_account(&sub_account),
             get_priority_fee(&self.client)
@@ -325,7 +325,7 @@ impl AppState {
             Cow::Owned(account_data?),
             self.delegated,
         )
-        .with_priority_fee(pf, cu_limit);
+        .with_priority_fee(ctx.cu_price.unwrap_or(pf), ctx.cu_limit);
 
         let builder = build_cancel_ix(builder, req.cancel)?;
         let tx = build_modify_ix(builder, req.modify, self.client.program_data())?
@@ -337,16 +337,18 @@ impl AppState {
 
     pub async fn place_orders(
         &self,
+        ctx: Context,
         req: PlaceOrdersRequest,
-        sub_account_id: Option<u16>,
-        cu_limit: Option<u32>,
     ) -> GatewayResult<TxResponse> {
-        let sub_account = self.resolve_sub_account(sub_account_id);
+        let sub_account = self.resolve_sub_account(ctx.sub_account_id);
         let (account_data, pf) = tokio::join!(
             self.client.get_user_account(&sub_account),
             get_priority_fee(&self.client)
         );
 
+        let priority_fee = ctx.cu_price.unwrap_or(pf);
+        debug!(target: LOG_TARGET, "priority fee: {priority_fee:?}");
+
         let orders = req
             .orders
             .into_iter()
@@ -361,7 +363,7 @@ impl AppState {
             Cow::Owned(account_data?),
             self.delegated,
         )
-        .with_priority_fee(pf, cu_limit)
+        .with_priority_fee(priority_fee, ctx.cu_limit)
         .place_orders(orders)
         .build();
 
@@ -370,11 +372,10 @@ impl AppState {
 
     pub async fn modify_orders(
         &self,
+        ctx: Context,
         req: ModifyOrdersRequest,
-        sub_account_id: Option<u16>,
-        cu_limit: Option<u32>,
     ) -> GatewayResult<TxResponse> {
-        let sub_account = self.resolve_sub_account(sub_account_id);
+        let sub_account = self.resolve_sub_account(ctx.sub_account_id);
         let (account_data, pf) = tokio::join!(
             self.client.get_user_account(&sub_account),
             get_priority_fee(&self.client)
@@ -386,7 +387,7 @@ impl AppState {
             Cow::Owned(account_data?),
             self.delegated,
         )
-        .with_priority_fee(pf, cu_limit);
+        .with_priority_fee(ctx.cu_price.unwrap_or(pf), ctx.cu_limit);
         let tx = build_modify_ix(builder, req, self.client.program_data())?.build();
         self.send_tx(tx, "modify_orders").await
     }
@@ -402,8 +403,8 @@ impl AppState {
 
     pub async fn get_tx_events_for_subaccount_id(
         &self,
+        ctx: Context,
         tx_sig: &str,
-        sub_account_id: Option<u16>,
     ) -> GatewayResult<TxEventsResponse> {
         let signature = Signature::from_str(tx_sig).map_err(|err| {
             warn!(target: LOG_TARGET, "failed to parse transaction signature: {err:?}");
@@ -432,7 +433,7 @@ impl AppState {
                 if let Some(meta) = tx.transaction.meta {
                     match meta.log_messages {
                         OptionSerializer::Some(logs) => {
-                            let sub_account = self.resolve_sub_account(sub_account_id);
+                            let sub_account = self.resolve_sub_account(ctx.sub_account_id);
                             for (tx_idx, log) in logs.iter().enumerate() {
                                 if let Some(evt) = try_parse_log(log.as_str(), tx_sig, tx_idx) {
                                     let (_, gw_event) = map_drift_event_for_account(
@@ -508,7 +509,6 @@ impl AppState {
         let client = Arc::clone(&self.client);
         let commitment = self.tx_commitment.commitment;
         tokio::spawn(async move {
-            tokio::time::sleep(Duration::from_millis(200)).await;
             if let Err(err) = client
                 .inner()
                 .send_transaction_with_config(
@@ -641,7 +641,7 @@ async fn get_priority_fee<T: AccountProvider>(client: &DriftClient<T>) -> u64 {
         .await
     {
         recent_fees.sort_unstable();
-        let idx = (recent_fees.len() * 3) / 4; // 75-th percentile
+        let idx = (recent_fees.len() * 90) / 100; // 90-th percentile
         priority_fee = recent_fees[idx];
     } else {
         warn!(target: "controller", "failed to fetch live priority fee");
@@ -660,7 +660,7 @@ mod tests {
         // flakey needs a mainnet RPC getProgramAccounts
         let account_provider = RpcAccountProvider::new("https://api.devnet.solana.com");
         let client = DriftClient::new(
-            Context::DevNet,
+            types::Context::DevNet,
             account_provider,
             Wallet::read_only(Pubkey::new_unique()),
         )
diff --git a/src/main.rs b/src/main.rs
