spark_sdk/wallet/internal_handlers/implementations/

ssp.rs

use std::collections::HashMap;

use crate::{
    constants::spark::SSP_PING_SUCCESS_STATUS_CODE,
    error::SparkSdkError,
    signer::traits::SparkSigner,
    wallet::{
        graphql::GraphqlClient,
        internal_handlers::{
            traits::ssp::{SspInternalHandlers, SwapLeaf},
            utils::bitcoin_tx_from_bytes,
        },
    },
    SparkNetwork, SparkSdk,
};
use bitcoin::Network;
use serde_json::{json, Value};
use tonic::async_trait;

#[async_trait]
impl<S: SparkSigner + Send + Sync + Clone + 'static> SspInternalHandlers<S> for SparkSdk<S> {
    async fn ping_ssp(&self) -> Result<bool, SparkSdkError> {
        // make a REST request to the SSP endpoint
        let client = reqwest::Client::new();
        let response = client
            .get(self.config.spark_config.ssp_endpoint.clone())
            .send()
            .await
            .map_err(|e| SparkSdkError::InvalidResponse(e.to_string()))?;

        Ok(response.status().as_u16() == SSP_PING_SUCCESS_STATUS_CODE)
    }

    async fn create_invoice_with_ssp(
        &self,
        amount_sats: i64,
        payment_hash: String,
        expiry_secs: Option<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));
        }
        if let Some(expiry_secs) = expiry_secs {
            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(
            hex::encode(self.get_identity_public_key().to_vec()),
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;

        // Define the GraphQL mutation
        let query = r#"
        mutation RequestLightningReceive(
            $network: BitcoinNetwork!
            $amount_sats: Long!
            $payment_hash: Hash32!
            $expiry_secs: Int
            $memo: String
        ) {
            request_lightning_receive(input: {
                network: $network
                amount_sats: $amount_sats
                payment_hash: $payment_hash
                expiry_secs: $expiry_secs
                memo: $memo
            }) {
                request {
                    id
                    created_at
                    updated_at
                    invoice {
                        encoded_envoice
                    }
                    fee {
                        original_value
                        original_unit
                    }
                }
            }
        }"#;

        // Execute the GraphQL request
        let response = requester
            .execute_graphql(query, variable_map)
            .await
            .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;

        // 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::InvalidResponse(
                "Missing encoded_envoice".into(),
            ))?
            .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::InvalidResponse("Missing fees".into()))?;

        Ok((encoded_invoice, fees as i64))
    }

    async fn pay_invoice_with_ssp(&self, invoice: String) -> Result<String, SparkSdkError> {
        let mut variable_map = HashMap::new();
        variable_map.insert("encoded_invoice".to_string(), json!(invoice));
        variable_map.insert(
            "idempotency_key".to_string(),
            json!(uuid::Uuid::now_v7().to_string()),
        );

        // Define the GraphQL mutation
        let query = r#"
            mutation RequestLightningSend($input: RequestLightningSendInput!) {
                request_lightning_send(input: $input) {
                    payment {
                        id
                    }
                }
            }"#;

        // Execute the GraphQL request
        let requester = GraphqlClient::with_base_url(
            hex::encode(self.get_identity_public_key().to_vec()),
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;

        let response = requester
            .execute_graphql(query, variable_map)
            .await
            .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;

        // Extract the payment ID
        let payment_id = response
            .get("request_lightning_send")
            .and_then(|v| v.get("payment"))
            .and_then(|v| v.get("id"))
            .and_then(|v| v.as_str())
            .ok_or(SparkSdkError::InvalidResponse("Missing payment ID".into()))?
            .to_string();

        Ok(payment_id)
    }

    async fn request_swap_leaves_with_ssp(
        &self,
        adaptor_pubkey: String,
        total_amount_sats: u64,
        target_amount_sats: u64,
        fee_sats: u64,
        network: SparkNetwork,
        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));

        // Define the GraphQL mutation
        let query = r#"
            mutation RequestLeavesSwap(
                $adaptor_pubkey: String!
                $total_amount_sats: Int!
                $target_amount_sats: Int!
                $fee_sats: Int!
                $network: BitcoinNetwork!
                $user_leaves: [UserLeafInput!]!
            ) {
                request_leaves_swap(input: {
                    adaptor_pubkey: $adaptor_pubkey
                    total_amount_sats: $total_amount_sats
                    target_amount_sats: $target_amount_sats
                    fee_sats: $fee_sats
                    network: $network
                    user_leaves: $user_leaves
                }) {
                    request {
                        id
                        swap_leaves {
                            leaf_id
                            raw_unsigned_refund_transaction
                            adaptor_signed_signature
                        }
                    }
                }
            }"#;

        // Execute the GraphQL request
        let requester = GraphqlClient::with_base_url(
            hex::encode(self.get_identity_public_key().to_vec()),
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;

        let response = requester
            .execute_graphql(query, variable_map)
            .await
            .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;

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

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

        let swap_leaves = request
            .get("swap_leaves")
            .and_then(|v| v.as_array())
            .ok_or(SparkSdkError::InvalidResponse("Missing swap leaves".into()))?;

        let mut leaves = Vec::new();
        for leaf in swap_leaves {
            let leaf_map = leaf.as_object().ok_or(SparkSdkError::InvalidResponse(
                "Invalid swap leaf format".into(),
            ))?;

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

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

    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),
        );

        let query = r#"
            mutation CompleteLeavesSwap(
            $adaptor_secret_key: String!
            $user_outbound_transfer_external_id: UUID!
            $leaves_swap_request_id: ID!
            ) {
            complete_leaves_swap(input: {
                adaptor_secret_key: $adaptor_secret_key
                user_outbound_transfer_external_id: $user_outbound_transfer_external_id
                leaves_swap_request_id: $leaves_swap_request_id
            }) {
                request {
                id
                }
            }
        }"#;

        // Execute the GraphQL request
        let requester = GraphqlClient::with_base_url(
            hex::encode(self.get_identity_public_key().to_vec()),
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;

        let response = requester
            .execute_graphql(query, variable_map)
            .await
            .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;

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

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

        Ok(request_id.to_string())
    }

    async fn initiate_cooperative_exit_with_ssp(
        &self,
        leaf_external_ids: Vec<String>,
        address: String,
    ) -> Result<(String, Vec<u8>, bitcoin::Transaction), 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));

        let query = r#"
            mutation RequestCoopExit(
                $leaf_external_ids: [UUID!]!
                $withdrawal_address: String!
            ) {
                request_coop_exit(input: {
                    leaf_external_ids: $leaf_external_ids
                    withdrawal_address: $withdrawal_address
                }) {
                    request {
                        id
                        created_at
                        updated_at
                        fee {
                            original_value
                            original_unit
                        }
                        status
                        raw_connector_transaction
                        expires_at
                    }
                }
            }"#;

        // Execute the GraphQL request
        let requester = GraphqlClient::with_base_url(
            hex::encode(self.get_identity_public_key().to_vec()),
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;

        let response = requester
            .execute_graphql(query, variable_map)
            .await
            .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;

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

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

        let raw_connector_transaction = request
            .get("raw_connector_transaction")
            .and_then(|v| v.as_str())
            .ok_or(SparkSdkError::InvalidResponse(
                "Missing raw connector transaction".into(),
            ))?;

        // Decode and deserialize the connector transaction
        let connector_tx_bytes = hex::decode(raw_connector_transaction)
            .map_err(|e| SparkSdkError::InvalidResponse(format!("Invalid hex: {}", e)))?;

        let connector_tx = bitcoin_tx_from_bytes(&connector_tx_bytes)
            .map_err(|e| SparkSdkError::InvalidResponse(format!("Invalid transaction: {}", e)))?;

        // Get the txid being spent in the first input
        let coop_exit_txid = connector_tx.input[0].previous_output.txid.clone(); // TODO: verify if this is correct
        let coop_exit_txid_bytes = hex::decode(coop_exit_txid.to_string()).unwrap();

        Ok((request_id.to_string(), coop_exit_txid_bytes, connector_tx))
    }

    async fn complete_cooperative_exit_with_ssp(
        &self,
        user_outbound_transfer_external_id: String,
        coop_exit_request_id: String,
    ) -> Result<String, SparkSdkError> {
        let mut variable_map = HashMap::new();
        variable_map.insert(
            "coop_exit_request_id".to_string(),
            Value::String(coop_exit_request_id),
        );
        variable_map.insert(
            "user_outbound_transfer_external_id".to_string(),
            Value::String(user_outbound_transfer_external_id),
        );

        // Define the GraphQL mutation
        let query = r#"
            mutation CompleteCoopExit($coop_exit_request_id: ID!) {
                complete_coop_exit(input: { request_id: $coop_exit_request_id }) {
                    request {
                        id
                    }
                }
            }"#;

        // Execute the GraphQL request
        let requester = GraphqlClient::with_base_url(
            hex::encode(self.get_identity_public_key().to_vec()),
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;
        let response = requester
            .execute_graphql(query, variable_map)
            .await
            .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;

        // 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::InvalidResponse("Missing request id".into()))?;

        Ok(request_id.to_string())
    }

    async fn request_lightning_send_with_ssp(
        &self,
        encoded_invoice: String,
        idompotency_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!(idompotency_key));

        // Define the GraphQL mutation
        let query = r#"
            mutation RequestLightningSend($encoded_invoice: String!, $idempotency_key: String!) {
                request_lightning_send(input: {
                    encoded_invoice: $encoded_invoice,
                    idempotency_key: $idempotency_key
                }) {
                    request {
                        id
                        created_at
                        updated_at
                        encoded_invoice
                        fee {
                            original_value
                            original_unit
                        }
                        status
                    }
                }
            }"#;

        // Execute the GraphQL request
        let requester = GraphqlClient::with_base_url(
            hex::encode(self.get_identity_public_key().to_vec()),
            Some(self.config.spark_config.ssp_endpoint.clone()),
        )
        .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;

        let response = requester
            .execute_graphql(query, variable_map)
            .await
            .map_err(|e| SparkSdkError::GraphQLRequestFailed(e.to_string()))?;

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

        Ok(request_id.to_string())
    }
}