refactor: add strategy swaps

src/bin/bitmaskd.rs

@@ -25,9 +25,9 @@ use bitcoin_30::secp256k1::{ecdh::SharedSecret, PublicKey, SecretKey};
 use bitmask_core::{
     bitcoin::{save_mnemonic, sign_and_publish_psbt_file},
     carbonado::{
-        handle_file,
+        handle_file, marketplace_retrieve, marketplace_store,
         metrics::{metrics, metrics_csv},
-        server_retrieve, server_store, store,
+        store,
     },
     constants::{
         get_marketplace_nostr_key, get_marketplace_seed, get_network, get_udas_utxo, switch_network,
@@ -524,7 +524,7 @@ async fn co_server_store(
     body: Bytes,
 ) -> Result<impl IntoResponse, AppError> {
     info!("POST /carbonado/server/{name}, {} bytes", body.len());
-    let (filepath, encoded) = server_store(&name, &body, None).await?;
+    let (filepath, encoded) = marketplace_store(&name, &body, None).await?;
 
     match OpenOptions::new()
         .read(true)
@@ -624,7 +624,7 @@ async fn co_metadata(
 async fn co_server_retrieve(Path(name): Path<String>) -> Result<impl IntoResponse, AppError> {
     info!("GET /server/{name}");
 
-    let result = server_retrieve(&name).await;
+    let result = marketplace_retrieve(&name).await;
     let cc = CacheControl::new().with_no_cache();
 
     match result {
@@ -684,6 +684,56 @@ async fn rgb_proxy_media_data_save(
     Ok((StatusCode::OK, Json(resp)))
 }
 
+async fn rgb_auction_get_offer(
+    Path(offer_id): Path<String>,
+    Json(_request): Json<String>,
+) -> Result<impl IntoResponse, AppError> {
+    info!("GET /auction/{offer_id}");
+    Ok((StatusCode::OK, Json("")))
+}
+
+async fn rgb_auction_create_offer(
+    TypedHeader(_auth): TypedHeader<Authorization<Bearer>>,
+    Path(offer_id): Path<String>,
+    Json(_request): Json<String>,
+) -> Result<impl IntoResponse, AppError> {
+    info!("POST /auction/{offer_id}");
+    Ok((StatusCode::OK, Json("")))
+}
+
+async fn rgb_auction_destroy_offer(
+    TypedHeader(_auth): TypedHeader<Authorization<Bearer>>,
+    Path(offer_id): Path<String>,
+) -> Result<impl IntoResponse, AppError> {
+    info!("DELETE /auction/{offer_id}");
+    Ok((StatusCode::OK, Json("")))
+}
+
+async fn rgb_auction_get_bid(
+    Path((offer_id, bid_id)): Path<(String, String)>,
+    Json(_request): Json<String>,
+) -> Result<impl IntoResponse, AppError> {
+    info!("GET /auction/{offer_id}/{bid_id}");
+    Ok((StatusCode::OK, Json("")))
+}
+
+async fn rgb_auction_create_bid(
+    TypedHeader(_auth): TypedHeader<Authorization<Bearer>>,
+    Path((offer_id, bid_id)): Path<(String, String)>,
+    Json(_request): Json<String>,
+) -> Result<impl IntoResponse, AppError> {
+    info!("POST /auction/{offer_id}/{bid_id}");
+    Ok((StatusCode::OK, Json("")))
+}
+
+async fn rgb_auction_destroy_bid(
+    TypedHeader(_auth): TypedHeader<Authorization<Bearer>>,
+    Path((offer_id, bid_id)): Path<(String, String)>,
+) -> Result<impl IntoResponse, AppError> {
+    info!("DELETE /auction/{offer_id}/{bid_id}");
+    Ok((StatusCode::OK, Json("")))
+}
+
 const BMC_VERSION: &str = env!("CARGO_PKG_VERSION");
 
 async fn status() -> Result<impl IntoResponse, AppError> {
@@ -822,6 +872,18 @@ async fn main() -> Result<()> {
         .route("/proxy/media-metadata", post(rgb_proxy_media_data_save))
         .route("/proxy/media-metadata/:id", get(rgb_proxy_media_retrieve))
         .route("/proxy/media/:id", get(rgb_proxy_metadata_retrieve))
+        .route("/auctions/:offer_id", get(rgb_auction_get_offer))
+        .route("/auctions/:offer_id", post(rgb_auction_create_offer))
+        .route("/auctions/:offer_id", delete(rgb_auction_destroy_offer))
+        .route("/auctions/:offer_id/bid/:bid_id", get(rgb_auction_get_bid))
+        .route(
+            "/auctions/:offer_id/bid/:bid_id",
+            post(rgb_auction_create_bid),
+        )
+        .route(
+            "/auction/:offer_id/bid/:bid_id",
+            delete(rgb_auction_destroy_bid),
+        )
         .route("/metrics.json", get(json_metrics))
         .route("/metrics.csv", get(csv_metrics));
 

src/bitcoin/psbt.rs

@@ -9,6 +9,9 @@ use crate::{
 
 #[derive(Error, Debug)]
 pub enum BitcoinPsbtError {
+    /// Could not broadcast PSBT
+    #[error("Could not broadcast PSBT")]
+    CouldNotBroadcastPsbt(String),
     /// Could not finalize when signing PSBT
     #[error("Could not finalize when signing PSBT")]
     CouldNotFinalizePsbt,
@@ -70,7 +73,10 @@ pub async fn publish_psbt(
     let tx = psbt.extract_tx();
     debug!("tx:", &serialize(&tx.clone()).to_hex());
     let blockchain = get_blockchain().await;
-    blockchain.broadcast(&tx).await?;
+    blockchain
+        .broadcast(&tx)
+        .await
+        .map_err(|op| BitcoinPsbtError::CouldNotBroadcastPsbt(op.to_string()))?;
 
     let txid = tx.txid();
     let tx = blockchain.get_tx(&txid).await?;

src/carbonado.rs

@@ -9,19 +9,24 @@ pub mod error;
 pub mod metrics;
 
 #[cfg(not(target_arch = "wasm32"))]
-pub use server::{handle_file, retrieve, retrieve_metadata, server_retrieve, server_store, store};
+pub use server::{
+    auctions_retrieve, auctions_store, handle_file, marketplace_retrieve, marketplace_store,
+    retrieve, retrieve_metadata, store,
+};
 
 #[cfg(not(target_arch = "wasm32"))]
 mod server {
-    use crate::constants::get_marketplace_nostr_key;
+    use crate::constants::{get_coordinator_nostr_key, get_marketplace_nostr_key};
 
     use super::*;
 
     use std::{
         io::{Error, ErrorKind},
         path::PathBuf,
+        str::FromStr,
     };
 
+    use bitcoin_30::secp256k1::ecdh::SharedSecret;
     use tokio::fs;
 
     pub async fn store(
@@ -51,7 +56,7 @@ mod server {
         Ok(())
     }
 
-    pub async fn server_store(
+    pub async fn marketplace_store(
         name: &str,
         input: &[u8],
         metadata: Option<Vec<u8>>,
@@ -78,6 +83,37 @@ mod server {
         Ok((filepath, body))
     }
 
+    pub async fn auctions_store(
+        bundle_id: &str,
+        name: &str,
+        input: &[u8],
+        metadata: Option<Vec<u8>>,
+    ) -> Result<(PathBuf, Vec<u8>), CarbonadoError> {
+        let coordinator_key: String = get_coordinator_nostr_key().await;
+
+        let level = 15;
+        let sk = hex::decode(coordinator_key)?;
+        let secret_key = SecretKey::from_slice(&sk)?;
+        let public_key =
+            PublicKey::from_str(bundle_id).map_err(|_| CarbonadoError::WrongNostrPublicKey)?;
+
+        let share_sk = SharedSecret::new(&public_key, &secret_key);
+        let pk = share_sk.secret_bytes();
+        let pk_hex = hex::encode(pk);
+
+        let mut meta: Option<[u8; 8]> = default!();
+        if let Some(metadata) = metadata {
+            let mut inner: [u8; 8] = default!();
+            inner[..metadata.len()].copy_from_slice(&metadata);
+            meta = Some(inner);
+        }
+
+        let (body, _encode_info) = carbonado::file::encode(&sk, Some(&pk), input, level, meta)?;
+        let filepath = handle_file(&pk_hex, name, body.len()).await?;
+        fs::write(filepath.clone(), body.clone()).await?;
+        Ok((filepath, body))
+    }
+
     pub async fn retrieve(
         sk: &str,
         name: &str,
@@ -120,7 +156,9 @@ mod server {
         Ok((Vec::new(), None))
     }
 
-    pub async fn server_retrieve(name: &str) -> Result<(Vec<u8>, Option<Vec<u8>>), CarbonadoError> {
+    pub async fn marketplace_retrieve(
+        name: &str,
+    ) -> Result<(Vec<u8>, Option<Vec<u8>>), CarbonadoError> {
         let marketplace_key: String = get_marketplace_nostr_key().await;
 
         let sk = hex::decode(marketplace_key)?;
@@ -144,6 +182,37 @@ mod server {
         Ok((Vec::new(), None))
     }
 
+    pub async fn auctions_retrieve(
+        bundle_id: &str,
+        name: &str,
+    ) -> Result<(Vec<u8>, Option<Vec<u8>>), CarbonadoError> {
+        let coordinator_key: String = get_coordinator_nostr_key().await;
+
+        let sk = hex::decode(coordinator_key)?;
+        let secret_key = SecretKey::from_slice(&sk)?;
+        let public_key =
+            PublicKey::from_str(bundle_id).map_err(|_| CarbonadoError::WrongNostrPublicKey)?;
+
+        let share_sk = SharedSecret::new(&public_key, &secret_key);
+        let pk = share_sk.secret_bytes();
+        let pk = hex::encode(pk);
+
+        let mut final_name = name.to_string();
+        let network = NETWORK.read().await.to_string();
+        let networks = ["bitcoin", "testnet", "signet", "regtest"];
+        if !networks.into_iter().any(|x| name.contains(x)) {
+            final_name = format!("{network}-{name}");
+        }
+
+        let filepath = handle_file(&pk, &final_name, 0).await?;
+        if let Ok(bytes) = fs::read(filepath).await {
+            let (header, decoded) = carbonado::file::decode(&sk, &bytes)?;
+            return Ok((decoded, header.metadata.map(|m| m.to_vec())));
+        }
+
+        Ok((Vec::new(), None))
+    }
+
     pub async fn handle_file(
         pk: &str,
         name: &str,
@@ -210,7 +279,10 @@ mod server {
 }
 
 #[cfg(target_arch = "wasm32")]
-pub use client::{retrieve, retrieve_metadata, server_retrieve, server_store, store};
+pub use client::{
+    auctions_retrieve, auctions_store, marketplace_retrieve, marketplace_store, retrieve,
+    retrieve_metadata, store,
+};
 
 #[cfg(target_arch = "wasm32")]
 mod client {
@@ -296,7 +368,7 @@ mod client {
         }
     }
 
-    pub async fn server_store(
+    pub async fn marketplace_store(
         name: &str,
         input: &[u8],
         _metadata: Option<Vec<u8>>,
@@ -328,6 +400,15 @@ mod client {
         }
     }
 
+    pub async fn auctions_store(
+        _bundle_id: &str,
+        _name: &str,
+        _input: &[u8],
+        _metadata: Option<Vec<u8>>,
+    ) -> Result<(), CarbonadoError> {
+        todo!()
+    }
+
     pub async fn retrieve_metadata(sk: &str, name: &str) -> Result<FileMetadata, CarbonadoError> {
         let sk = hex::decode(sk)?;
         let secret_key = SecretKey::from_slice(&sk)?;
@@ -416,7 +497,9 @@ mod client {
         Ok((Vec::new(), None))
     }
 
-    pub async fn server_retrieve(name: &str) -> Result<(Vec<u8>, Option<Vec<u8>>), CarbonadoError> {
+    pub async fn marketplace_retrieve(
+        name: &str,
+    ) -> Result<(Vec<u8>, Option<Vec<u8>>), CarbonadoError> {
         let network = NETWORK.read().await.to_string();
         let endpoints = CARBONADO_ENDPOINT.read().await.to_string();
         let endpoints: Vec<&str> = endpoints.split(',').collect();
@@ -438,6 +521,13 @@ mod client {
         Ok((encoded.to_vec(), None))
     }
 
+    pub async fn auctions_retrieve(
+        _bundle_id: &str,
+        _name: &str,
+    ) -> Result<(Vec<u8>, Option<Vec<u8>>), CarbonadoError> {
+        todo!()
+    }
+
     async fn fetch_post(url: String, body: Arc<Vec<u8>>) -> Result<JsValue, JsValue> {
         let array = Uint8Array::new_with_length(body.len() as u32);
         array.copy_from(&body);

src/carbonado/error.rs

@@ -27,6 +27,8 @@ pub enum CarbonadoError {
     AllEndpointsFailed,
     /// Wrong Nostr private key
     WrongNostrPrivateKey,
+    /// Wrong Nostr public key
+    WrongNostrPublicKey,
     /// Debug: {0}
     Debug(String),
 }

src/constants.rs

@@ -76,6 +76,10 @@ pub async fn get_marketplace_fee_xpub() -> String {
     MARKETPLACE_FEE_XPUB.read().await.to_string()
 }
 
+pub async fn get_coordinator_nostr_key() -> String {
+    MARKETPLACE_NOSTR.read().await.to_string()
+}
+
 pub static UDAS_UTXO: Lazy<RwLock<String>> = Lazy::new(|| RwLock::new(dot_env("UDAS_UTXO")));
 
 pub async fn get_udas_utxo() -> String {
@@ -220,5 +224,4 @@ pub mod storage_keys {
     pub const ASSETS_OFFERS: &str = "bitmask-asset_offers.c15";
     pub const ASSETS_BIDS: &str = "bitmask-asset_bids.c15";
     pub const MARKETPLACE_OFFERS: &str = "bitmask-marketplace_public_offers.c15";
-    pub const MARKETPLACE_BIDS: &str = "bitmask-marketplace_public_bids.c15";
 }