spark_rust/wallet/internal_handlers/implementations/

ssp.rs

use crate::{
    error::{io_error::IoError, network::NetworkError, SparkSdkError},
    signer::traits::SparkSigner,
    wallet::{
        graphql::GraphqlClient,
        handlers::{cooperative_exit::CoopExitRequestId, fees::SparkFeeEstimate},
        internal_handlers::traits::ssp::{
            InitiateCooperativeExitResponse, SspInternalHandlers, SwapLeaf,
        },
        utils::{
            bitcoin::bitcoin_tx_from_bytes,
            mutations::{
                COMPLETE_COOP_EXIT_MUTATION, COMPLETE_LEAVES_SWAP_MUTATION,
                GET_COOP_EXIT_FEE_ESTIMATE_QUERY, GET_LEAVES_SWAP_FEE_ESTIMATE_QUERY,
                GET_LIGHTNING_RECEIVE_FEE_ESTIMATE_QUERY, GET_LIGHTNING_SEND_FEE_ESTIMATE_QUERY,
                REQUEST_COOP_EXIT_MUTATION, REQUEST_LEAVES_SWAP_MUTATION,
                REQUEST_LIGHTNING_RECEIVE_MUTATION, REQUEST_LIGHTNING_SEND_MUTATION,
            },
        },
    },
    SparkSdk,
};
use bitcoin::{Address, Network};
use serde::Deserialize;
use serde_json::{json, Value};
use std::collections::HashMap;
use tonic::async_trait;

#[derive(Debug, Deserialize)]
struct SspLightningSendResponse {
    #[serde(rename = "request_lightning_send")]
    request: SspLightningSendRequest,
}

#[derive(Debug, Deserialize)]
struct SspLightningSendRequest {
    request: SspLightningSendRequestDetails,
}

#[derive(Debug, Deserialize)]
struct SspLightningSendRequestDetails {
    id: String,
}

#[async_trait]
impl<S: SparkSigner + Send + Sync + Clone + 'static> SspInternalHandlers<S> for SparkSdk<S> {
    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    async fn create_invoice_with_ssp(
        &self,
        amount_sats: u64,
        payment_hash: String,
        expiry_secs: i32,
        memo: Option<String>,
        network: Network,
    ) -> Result<(String, i64), SparkSdkError> {
        let mut variable_map = HashMap::new();
        variable_map.insert(
            "network".to_string(),
            json!(network.to_string().to_uppercase()),
        );
        variable_map.insert("amount_sats".to_string(), json!(amount_sats));
        variable_map.insert("payment_hash".to_string(), json!(payment_hash));
        if let Some(memo) = memo {
            variable_map.insert("memo".to_string(), json!(memo));
        }
        variable_map.insert("expiry_secs".to_string(), json!(expiry_secs));

        // Use the custom Requester with the SSP endpoint from config
        let requester = GraphqlClient::with_base_url(
            self.get_spark_address()?,
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::from(NetworkError::GraphQL(e.to_string())))?;

        // Execute the GraphQL request
        let response = requester
            .execute_graphql(REQUEST_LIGHTNING_RECEIVE_MUTATION, variable_map)
            .await?;

        // Extract the encoded_payment_request
        let encoded_invoice = response
            .get("request_lightning_receive")
            .and_then(|v| v.get("request"))
            .and_then(|v| v.get("invoice"))
            .and_then(|v| v.get("encoded_envoice"))
            .and_then(|v| v.as_str())
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?
            .to_string();

        let fees = response
            .get("request_lightning_receive")
            .and_then(|v| v.get("request"))
            .and_then(|v| v.get("fee"))
            .and_then(|v| v.get("original_value"))
            .and_then(|v| v.as_f64())
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        Ok((encoded_invoice, fees as i64))
    }

    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    async fn request_swap_leaves_with_ssp(
        &self,
        adaptor_pubkey: String,
        total_amount_sats: u64,
        target_amount_sats: u64,
        fee_sats: u64,
        user_leaves: Vec<SwapLeaf>,
    ) -> Result<(String, Vec<SwapLeaf>), SparkSdkError> {
        let mut variable_map = HashMap::new();
        variable_map.insert("adaptor_pubkey".to_string(), json!(adaptor_pubkey));
        variable_map.insert("total_amount_sats".to_string(), json!(total_amount_sats));
        variable_map.insert("target_amount_sats".to_string(), json!(target_amount_sats));
        variable_map.insert("fee_sats".to_string(), json!(fee_sats));
        // variable_map.insert(
        //     "network".to_string(),
        //     json!(network.to_string().to_uppercase()),
        // );
        variable_map.insert("user_leaves".to_string(), json!(user_leaves));

        // Use the custom Requester with the SSP endpoint from config
        let requester = GraphqlClient::with_base_url(
            self.get_spark_address()?,
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::from(NetworkError::GraphQL(e.to_string())))?;

        let response = requester
            .execute_graphql(REQUEST_LEAVES_SWAP_MUTATION, variable_map)
            .await?;

        // Extract the response data
        let request = response
            .get("request_leaves_swap")
            .and_then(|v| v.get("request"))
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        let request_id = request
            .get("id")
            .and_then(|v| v.as_str())
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        let swap_leaves = request
            .get("swap_leaves")
            .and_then(|v| v.as_array())
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        let mut leaves = Vec::new();
        for leaf in swap_leaves {
            let leaf_map = leaf
                .as_object()
                .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

            leaves.push(SwapLeaf {
                leaf_id: leaf_map
                    .get("leaf_id")
                    .and_then(|v| v.as_str())
                    .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?
                    .to_string(),
                raw_unsigned_refund_transaction: leaf_map
                    .get("raw_unsigned_refund_transaction")
                    .and_then(|v| v.as_str())
                    .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?
                    .to_string(),
                adaptor_added_signature: leaf_map
                    .get("adaptor_signed_signature")
                    .and_then(|v| v.as_str())
                    .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?
                    .to_string(),
            });
        }

        Ok((request_id.to_string(), leaves))
    }

    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    async fn complete_leaves_swap_with_ssp(
        &self,
        adaptor_secret_key: String,
        user_outbound_transfer_external_id: String,
        leaves_swap_request_id: String,
    ) -> Result<String, SparkSdkError> {
        let mut variable_map = HashMap::new();
        variable_map.insert(
            "adaptor_secret_key".to_string(),
            Value::String(adaptor_secret_key),
        );
        variable_map.insert(
            "user_outbound_transfer_external_id".to_string(),
            Value::String(user_outbound_transfer_external_id),
        );
        variable_map.insert(
            "leaves_swap_request_id".to_string(),
            Value::String(leaves_swap_request_id),
        );

        // Use the custom Requester with the SSP endpoint from config
        let requester = GraphqlClient::with_base_url(
            self.get_spark_address()?,
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::from(NetworkError::GraphQL(e.to_string())))?;

        let response = requester
            .execute_graphql(COMPLETE_LEAVES_SWAP_MUTATION, variable_map)
            .await?;

        // Extract the response data
        let request = response
            .get("complete_leaves_swap")
            .and_then(|v| v.get("request"))
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        let request_id = request
            .get("id")
            .and_then(|v| v.as_str())
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        Ok(request_id.to_string())
    }

    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    async fn initiate_cooperative_exit_with_ssp(
        &self,
        leaf_external_ids: Vec<String>,
        address: &Address,
    ) -> Result<InitiateCooperativeExitResponse, SparkSdkError> {
        let mut variable_map = HashMap::new();
        variable_map.insert(
            "leaf_external_ids".to_string(),
            Value::Array(leaf_external_ids.into_iter().map(Value::String).collect()),
        );
        variable_map.insert(
            "withdrawal_address".to_string(),
            Value::String(address.to_string()),
        );

        // Use the custom Requester with the SSP endpoint from config
        let requester = GraphqlClient::with_base_url(
            self.get_spark_address()?,
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::from(NetworkError::GraphQL(e.to_string())))?;

        let response = requester
            .execute_graphql(REQUEST_COOP_EXIT_MUTATION, variable_map)
            .await?;

        // Extract the response data
        let request = response
            .get("request_coop_exit")
            .and_then(|v| v.get("request"))
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        let request_id = request
            .get("id")
            .and_then(|v| v.as_str())
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        let raw_connector_transaction = request
            .get("raw_connector_transaction")
            .and_then(|v| v.as_str())
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        // Decode and deserialize the connector transaction
        let connector_tx = bitcoin_tx_from_bytes(
            &hex::decode(raw_connector_transaction)
                .map_err(|err| SparkSdkError::from(IoError::Decoding(err)))?,
        )?;

        let response = InitiateCooperativeExitResponse {
            request_id: CoopExitRequestId(
                request_id
                    .split(':')
                    .nth(1)
                    .unwrap_or(request_id)
                    .to_string(),
            ),
            connector_tx,
        };

        #[cfg(feature = "telemetry")]
        tracing::info!("Initiated cooperative exit with SSP");

        Ok(response)
    }

    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    async fn complete_cooperative_exit_with_ssp(
        &self,
        user_outbound_transfer_external_id: String,
        coop_exit_request_id: CoopExitRequestId,
    ) -> Result<CoopExitRequestId, SparkSdkError> {
        let mut variable_map = HashMap::new();
        variable_map.insert(
            "coop_exit_request_id".to_string(),
            Value::String(coop_exit_request_id.0),
        );
        variable_map.insert(
            "user_outbound_transfer_external_id".to_string(),
            Value::String(user_outbound_transfer_external_id),
        );

        // Use the custom Requester with the SSP endpoint from config
        let requester = GraphqlClient::with_base_url(
            self.get_spark_address()?,
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::from(NetworkError::GraphQL(e.to_string())))?;
        let response = requester
            .execute_graphql(COMPLETE_COOP_EXIT_MUTATION, variable_map)
            .await?;

        // Extract the request ID from the response
        let request_id = response
            .get("complete_coop_exit")
            .and_then(|v| v.get("request"))
            .and_then(|v| v.get("id"))
            .and_then(|v| v.as_str())
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        Ok(CoopExitRequestId(request_id.to_string()))
    }

    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    async fn request_lightning_send_with_ssp(
        &self,
        encoded_invoice: String,
        idempotency_key: String,
    ) -> Result<String, SparkSdkError> {
        let mut variable_map = HashMap::new();
        variable_map.insert("encoded_invoice".to_string(), json!(encoded_invoice));
        variable_map.insert("idempotency_key".to_string(), json!(idempotency_key));

        // Use the custom Requester with the SSP endpoint from config
        let requester = GraphqlClient::with_base_url(
            self.get_spark_address()?,
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::from(NetworkError::GraphQL(e.to_string())))?;

        let response = requester
            .execute_graphql(REQUEST_LIGHTNING_SEND_MUTATION, variable_map)
            .await?;

        // Convert the HashMap to a Value before deserializing
        let response_value = serde_json::to_value(response)
            .map_err(|_| SparkSdkError::from(NetworkError::InvalidResponse))?;

        // Parse the response into the SspLightningSendResponse struct
        let response_struct: SspLightningSendResponse = serde_json::from_value(response_value)
            .map_err(|_| SparkSdkError::from(NetworkError::InvalidResponse))?;

        // Extract the request ID from the response struct
        let request_id = response_struct.request.request.id;

        // Extract just the UUID part if it has the prefix
        let uuid_only = if request_id.contains(":") {
            request_id
                .split(':')
                .next_back()
                .unwrap_or(&request_id)
                .to_string()
        } else {
            request_id
        };

        Ok(uuid_only)
    }

    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    async fn get_lightning_receive_fee_estimate_with_ssp(
        &self,
        amount_sats: u64,
    ) -> Result<SparkFeeEstimate, SparkSdkError> {
        let network = self
            .get_network()
            .to_bitcoin_network()
            .to_string()
            .to_uppercase();

        // Create variables map with the network and amount
        let mut variable_map = HashMap::new();
        variable_map.insert("network".to_string(), Value::String(network));
        variable_map.insert(
            "amount_sats".to_string(),
            Value::Number(serde_json::Number::from(amount_sats)),
        );

        // Use the custom Requester with the SSP endpoint from config
        let requester = GraphqlClient::with_base_url(
            self.get_spark_address()?,
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::from(NetworkError::GraphQL(e.to_string())))?;

        let response = requester
            .execute_graphql(GET_LIGHTNING_RECEIVE_FEE_ESTIMATE_QUERY, variable_map)
            .await?;

        // Extract the fee estimate from the response
        let fee_value = response
            .get("lightning_receive_fee_estimate")
            .and_then(|v| v.get("fee_estimate"))
            .and_then(|v| v.get("original_value"))
            .and_then(|v| v.as_u64())
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        Ok(SparkFeeEstimate { fees: fee_value })
    }

    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    async fn get_lightning_send_fee_estimate_with_ssp(
        &self,
        invoice: String,
    ) -> Result<SparkFeeEstimate, SparkSdkError> {
        // Create variables map with the invoice
        let mut variable_map = HashMap::new();
        variable_map.insert("encoded_invoice".to_string(), Value::String(invoice));

        // Use the custom Requester with the SSP endpoint from config
        let requester = GraphqlClient::with_base_url(
            self.get_spark_address()?,
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::from(NetworkError::GraphQL(e.to_string())))?;

        let response = requester
            .execute_graphql(GET_LIGHTNING_SEND_FEE_ESTIMATE_QUERY, variable_map)
            .await?;

        // Extract the fee estimate from the response
        let fee_value = response
            .get("lightning_send_fee_estimate")
            .and_then(|v| v.get("fee_estimate"))
            .and_then(|v| v.get("original_value"))
            .and_then(|v| v.as_u64())
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        Ok(SparkFeeEstimate { fees: fee_value })
    }

    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    async fn get_cooperative_exit_fee_estimate_with_ssp(
        &self,
        leaf_external_ids: Vec<String>,
        on_chain_address: String,
    ) -> Result<SparkFeeEstimate, SparkSdkError> {
        let mut variable_map = HashMap::new();
        variable_map.insert(
            "leaf_external_ids".to_string(),
            Value::Array(leaf_external_ids.into_iter().map(Value::String).collect()),
        );
        variable_map.insert(
            "withdrawal_address".to_string(),
            Value::String(on_chain_address),
        );

        // Use the custom Requester with the SSP endpoint from config
        let requester = GraphqlClient::with_base_url(
            self.get_spark_address()?,
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::from(NetworkError::GraphQL(e.to_string())))?;

        let response = requester
            .execute_graphql(GET_COOP_EXIT_FEE_ESTIMATE_QUERY, variable_map)
            .await?;

        // Extract the fee estimate from the response
        let fee_value = response
            .get("coop_exit_fee_estimate")
            .and_then(|v| v.get("fee_estimate"))
            .and_then(|v| v.get("original_value"))
            .and_then(|v| v.as_u64())
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        Ok(SparkFeeEstimate { fees: fee_value })
    }

    #[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
    async fn get_leaves_swap_fee_estimate_with_ssp(
        &self,
        total_amount_sats: u64,
    ) -> Result<SparkFeeEstimate, SparkSdkError> {
        let mut variable_map = HashMap::new();
        variable_map.insert(
            "total_amount_sats".to_string(),
            Value::Number(total_amount_sats.into()),
        );

        // Use the custom Requester with the SSP endpoint from config
        let requester = GraphqlClient::with_base_url(
            self.get_spark_address()?,
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::from(NetworkError::GraphQL(e.to_string())))?;

        let response = requester
            .execute_graphql(GET_LEAVES_SWAP_FEE_ESTIMATE_QUERY, variable_map)
            .await?;

        // Extract the fee estimate from the response
        let fee_value = response
            .get("leaves_swap_fee_estimate")
            .and_then(|v| v.get("fee_estimate"))
            .and_then(|v| v.get("original_value"))
            .and_then(|v| v.as_u64())
            .ok_or(SparkSdkError::from(NetworkError::InvalidResponse))?;

        Ok(SparkFeeEstimate { fees: fee_value })
    }
}