Add solana api skeleton (#125)

Author: danimhr

auction-server/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "auction-server"
-version = "0.9.8"
+version = "0.10.0"
 edition = "2021"
 license-file = "license.txt"
 
@@ -39,3 +39,5 @@ opentelemetry = "0.23.0"
 opentelemetry_sdk = { version = "0.23.0", features = ["rt-tokio"]}
 opentelemetry-otlp = { version = "0.16.0" }
 gas-oracle = { path = "../gas-oracle" }
+serde_with = { version = "3.9.0", features = ["base64"] }
+serde_path_to_error = "0.1.16"

auction-server/Cargo.toml

@@ -15,7 +15,11 @@ use {
                 ServerUpdateResponse,
             },
         },
-        auction::Bid,
+        auction::{
+            Bid,
+            BidEvm,
+            BidSvm,
+        },
         config::{
             ChainId,
             RunOptions,
@@ -130,6 +134,8 @@ pub enum RestError {
     TemporarilyUnavailable,
     /// Invalid auth token
     InvalidToken,
+    /// Not implemented
+    NotImplemented,
 }
 
 impl RestError {
@@ -166,6 +172,10 @@ impl RestError {
                 StatusCode::UNAUTHORIZED,
                 "Invalid authorization token".to_string(),
             ),
+            RestError::NotImplemented => (
+                StatusCode::NOT_IMPLEMENTED,
+                "This feature is not implemented".to_string(),
+            ),
         }
     }
 }
@@ -312,6 +322,8 @@ pub async fn start_api(run_options: RunOptions, store: Arc<Store>) -> Result<()>
     schemas(
     APIResponse,
     Bid,
+    BidSvm,
+    BidEvm,
     BidStatus,
     BidStatusWithId,
     BidResult,

auction-server/src/api.rs

@@ -7,6 +7,7 @@ use {
         },
         auction::{
             handle_bid,
+            svm_handle_bid,
             Bid,
         },
         state::{
@@ -47,8 +48,8 @@ pub struct BidResult {
 
 /// Bid on a specific permission key for a specific chain.
 ///
-/// Your bid will be simulated and verified by the server. Depending on the outcome of the auction, a transaction
-/// containing the contract call will be sent to the blockchain expecting the bid amount to be paid after the call.
+/// Your bid will be verified by the server. Depending on the outcome of the auction, a transaction
+/// containing your bid will be sent to the blockchain expecting the bid amount to be paid in the transaction.
 #[utoipa::path(post, path = "/v1/bids", request_body = Bid, responses(
     (status = 200, description = "Bid was placed successfully", body = BidResult,
     example = json!({"status": "OK", "id": "beedbeed-b346-4fa1-8fab-2541a9e1872d"})),
@@ -68,7 +69,11 @@ pub async fn process_bid(
     bid: Bid,
     auth: Auth,
 ) -> Result<Json<BidResult>, RestError> {
-    match handle_bid(store, bid, OffsetDateTime::now_utc(), auth).await {
+    let result = match bid {
+        Bid::Evm(evm_bid) => handle_bid(store, evm_bid, OffsetDateTime::now_utc(), auth).await,
+        Bid::Svm(svm_bid) => svm_handle_bid(store, svm_bid, OffsetDateTime::now_utc(), auth).await,
+    };
+    match result {
         Ok(id) => Ok(BidResult {
             status: "OK".to_string(),
             id,

auction-server/src/api/bid.rs

@@ -76,8 +76,13 @@ use {
     gas_oracle::EthProviderOracle,
     serde::{
         Deserialize,
+        Deserializer,
         Serialize,
     },
+    serde_with::{
+        base64::Base64,
+        serde_as,
+    },
     sqlx::types::time::OffsetDateTime,
     std::{
         result,
@@ -606,7 +611,7 @@ pub async fn run_submission_loop(store: Arc<Store>, chain_id: String) -> Result<
 }
 
 #[derive(Serialize, Deserialize, ToSchema, Clone, Debug)]
-pub struct Bid {
+pub struct BidEvm {
     /// The permission key to bid on.
     #[schema(example = "0xdeadbeef", value_type = String)]
     pub permission_key:  Bytes,
@@ -625,6 +630,60 @@ pub struct Bid {
     pub amount:          BidAmount,
 }
 
+#[serde_as]
+#[derive(Serialize, Deserialize, ToSchema, Clone, Debug)]
+pub struct BidSvm {
+    /// The permission key to bid on.
+    #[schema(example = "SGVsbG8sIFdvcmxkIQ==", value_type = String)]
+    #[serde_as(as = "Base64")]
+    pub permission_key: Bytes,
+    /// The chain id to bid on.
+    #[schema(example = "solana", value_type = String)]
+    pub chain_id:       ChainId,
+    /// Bid amount in lamports.
+    #[schema(example = 10, value_type = u64)]
+    pub amount:         u64,
+    /// The transaction for bid.
+    #[schema(example = "SGVsbG8sIFdvcmxkIQ==", value_type = String)]
+    #[serde_as(as = "Base64")]
+    pub transaction:    Vec<u8>,
+}
+
+#[derive(Serialize, ToSchema, Debug, Clone)]
+#[serde(untagged)] // Remove tags to avoid key-value wrapping
+pub enum Bid {
+    Evm(BidEvm),
+    Svm(BidSvm),
+}
+
+impl<'de> Deserialize<'de> for Bid {
+    fn deserialize<D>(d: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct BidChainId {
+            chain_id: ChainId,
+        }
+
+        let value: serde_json::Value = Deserialize::deserialize(d)?;
+        let bid_id: BidChainId =
+            serde_path_to_error::deserialize(&value).map_err(serde::de::Error::custom)?;
+        match bid_id.chain_id.as_str() {
+            "solana" => {
+                let svm_bid: BidSvm =
+                    serde_path_to_error::deserialize(&value).map_err(serde::de::Error::custom)?;
+                Ok(Bid::Svm(svm_bid))
+            }
+            _ => {
+                let evm_bid: BidEvm =
+                    serde_path_to_error::deserialize(&value).map_err(serde::de::Error::custom)?;
+                Ok(Bid::Evm(evm_bid))
+            }
+        }
+    }
+}
+
 // For now, we are only supporting the EIP1559 enabled networks
 async fn verify_bid_exceeds_gas_cost<G>(
     estimated_gas: U256,
@@ -690,7 +749,7 @@ async fn verify_bid_under_gas_limit(
 #[tracing::instrument(skip_all)]
 pub async fn handle_bid(
     store: Arc<Store>,
-    bid: Bid,
+    bid: BidEvm,
     initiation_time: OffsetDateTime,
     auth: Auth,
 ) -> result::Result<Uuid, RestError> {
@@ -831,3 +890,18 @@ pub async fn run_tracker_loop(store: Arc<Store>, chain_id: String) -> Result<()>
     tracing::info!("Shutting down tracker...");
     Ok(())
 }
+
+#[tracing::instrument(skip_all)]
+pub async fn svm_handle_bid(
+    _store: Arc<Store>,
+    bid: BidSvm,
+    _initiation_time: OffsetDateTime,
+    _auth: Auth,
+) -> result::Result<Uuid, RestError> {
+    if bid.chain_id != "solana" {
+        return Err(RestError::InvalidChainId);
+    }
+
+    // TODO implement this
+    Err(RestError::NotImplemented)
+}