feat: add bria-client to stablesats

Cargo.toml

@@ -12,4 +12,5 @@ members = [
   "bitfinex-client",
   "bitfinex-price",
   "galoy-client",
+  "bria-client",
 ]

bria-client/Cargo.toml

@@ -0,0 +1,44 @@
+[package]
+name = "bria-client"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+
+fail-on-warnings = []
+
+[dependencies]
+shared = { path = "../shared", package = "stablesats-shared" }
+
+anyhow = "1.0.72"
+chrono = { version = "0.4", features = [
+    "clock",
+    "serde",
+], default-features = false }
+prost = "0.11"
+tonic = "0.9"
+axum-core = "0.3.4"
+tokio = "1.29.1"
+futures = "0.3.27"
+thiserror = "1.0.40"
+serde = { version = "1.0.158", features = ["derive"] }
+rust_decimal = "1.29.0"
+tracing = "0.1.37"
+opentelemetry = { version = "0.18.0", features = ["trace"] }
+tracing-opentelemetry = "0.18.0"
+rust_decimal_macros = "1.29.0"
+rusty-money = "0.4.1"
+serde_json = "1.0.93"
+serde_with = { version = "2.3.1", features = ["chrono_0_4"] }
+url = "2.4.0"
+async-trait = "0.1.67"
+prost-wkt-types = { version = "0.4.2", features = ["vendored-protoc"]}
+
+[build-dependencies]
+protobuf-src = { version = "1.1.0" }
+tonic-build = { version = "0.8", features = ["prost"] }
+
+[dev-dependencies]
+anyhow = "1.0.70"

bria-client/build.rs

@@ -0,0 +1,11 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("cargo:rerun-if-changed=migrations");
+    std::env::set_var("PROTOC", protobuf_src::protoc());
+
+    tonic_build::configure()
+        .type_attribute(".", "#[derive(serde::Serialize)]")
+        .type_attribute(".", "#[serde(rename_all = \"camelCase\")]")
+        .extern_path(".google.protobuf.Struct", "::prost_wkt_types::Struct")
+        .compile(&["../proto/bria/bria_service.proto"], &["../proto"])?;
+    Ok(())
+}

bria-client/src/client/bria_client.rs

@@ -0,0 +1,113 @@
+use super::{config::BriaClientConfig, proto};
+use crate::error::BriaClientError;
+
+type ProtoClient = proto::bria_service_client::BriaServiceClient<tonic::transport::Channel>;
+
+pub const PROFILE_API_KEY_HEADER: &str = "x-bria-api-key";
+
+#[derive(Debug)]
+pub struct OnchainAddress {
+    pub address: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct BriaClient {
+    config: BriaClientConfig,
+    proto_client: ProtoClient,
+}
+
+impl BriaClient {
+    pub async fn connect(config: BriaClientConfig) -> Result<Self, BriaClientError> {
+        let proto_client = ProtoClient::connect(config.url.clone())
+            .await
+            .map_err(|_| BriaClientError::ConnectionError(config.url.clone()))?;
+
+        if config.key.is_empty() {
+            return Err(BriaClientError::EmptyKey);
+        }
+
+        Ok(Self {
+            config,
+            proto_client,
+        })
+    }
+
+    pub fn inject_auth_token<T>(
+        &self,
+        mut request: tonic::Request<T>,
+    ) -> Result<tonic::Request<T>, BriaClientError> {
+        let key = &self.config.key;
+        request.metadata_mut().insert(
+            PROFILE_API_KEY_HEADER,
+            tonic::metadata::MetadataValue::try_from(key)
+                .map_err(|_| BriaClientError::CouldNotCreateMetadataValue)?,
+        );
+        Ok(request)
+    }
+
+    pub async fn onchain_address(&mut self) -> Result<OnchainAddress, BriaClientError> {
+        match self.get_address().await {
+            Ok(addr) => Ok(addr),
+            Err(_) => self.new_address().await,
+        }
+    }
+
+    async fn get_address(&mut self) -> Result<OnchainAddress, BriaClientError> {
+        let request = tonic::Request::new(proto::GetAddressRequest {
+            identifier: Some(proto::get_address_request::Identifier::ExternalId(
+                self.config.external_id.clone(),
+            )),
+        });
+
+        self.proto_client
+            .get_address(self.inject_auth_token(request)?)
+            .await
+            .ok()
+            .and_then(|res| {
+                res.into_inner()
+                    .address
+                    .map(|addr| OnchainAddress { address: addr })
+            })
+            .ok_or(BriaClientError::AddressNotFound)
+    }
+
+    async fn new_address(&mut self) -> Result<OnchainAddress, BriaClientError> {
+        let request = tonic::Request::new(proto::NewAddressRequest {
+            wallet_name: self.config.wallet_name.clone(),
+            external_id: Some(self.config.external_id.clone()),
+            metadata: None,
+        });
+        self.proto_client
+            .new_address(self.inject_auth_token(request)?)
+            .await
+            .map(|res| OnchainAddress {
+                address: res.into_inner().address,
+            })
+            .map_err(|e| BriaClientError::CouldNotGenerateNewAddress(e.message().to_string()))
+    }
+
+    pub async fn send_onchain_payment(
+        &mut self,
+        destination: String,
+        satoshis: u64,
+        metadata: Option<serde_json::Value>,
+    ) -> Result<String, BriaClientError> {
+        let request = tonic::Request::new(proto::SubmitPayoutRequest {
+            wallet_name: self.config.wallet_name.clone(),
+            payout_queue_name: self.config.payout_queue_name.clone(),
+            destination: Some(proto::submit_payout_request::Destination::OnchainAddress(
+                destination,
+            )),
+            satoshis,
+            external_id: None,
+            metadata: metadata.map(serde_json::from_value).transpose()?,
+        });
+
+        let response = self
+            .proto_client
+            .submit_payout(self.inject_auth_token(request)?)
+            .await
+            .map_err(|e| BriaClientError::CouldNotSendOnchainPayment(e.message().to_string()))?;
+        Ok(response.into_inner().id)
+    }
+}

bria-client/src/client/config.rs

@@ -0,0 +1,19 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Deserialize, Serialize, Default)]
+pub struct BriaClientConfig {
+    #[serde(default = "default_url")]
+    pub url: String,
+    #[serde(default)]
+    pub key: String,
+    #[serde(default)]
+    pub wallet_name: String,
+    #[serde(default)]
+    pub payout_queue_name: String,
+    #[serde(default)]
+    pub external_id: String,
+}
+
+fn default_url() -> String {
+    "http://localhost:2742".to_string()
+}

bria-client/src/client/mod.rs

@@ -0,0 +1,10 @@
+#[allow(clippy::all)]
+pub mod proto {
+    tonic::include_proto!("services.bria.v1");
+}
+
+mod bria_client;
+mod config;
+
+pub use bria_client::*;
+pub use config::*;

bria-client/src/error.rs

@@ -0,0 +1,25 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum BriaClientError {
+    #[error("Couldn't connect to bria at url: {0}")]
+    ConnectionError(String),
+    #[error("Bria key cannot be empty")]
+    EmptyKey,
+    #[error("Couldn't create MetadataValue")]
+    CouldNotCreateMetadataValue,
+    #[error("Couldn't find address for the given external_id")]
+    AddressNotFound,
+    #[error("Couldn't generate a new address: {0}")]
+    CouldNotGenerateNewAddress(String),
+    #[error("Couldn't send onchain payment: {0}")]
+    CouldNotSendOnchainPayment(String),
+    #[error("Could not parse Send Onchain Payment Metadata: {0}")]
+    CouldNotParseSendOnchainPaymentMetadata(serde_json::Error),
+}
+
+impl From<serde_json::Error> for BriaClientError {
+    fn from(err: serde_json::Error) -> BriaClientError {
+        BriaClientError::CouldNotParseSendOnchainPaymentMetadata(err)
+    }
+}