spark_rust/spark_test_utils/

faucet.rs

use std::rc::Rc;

use bitcoin::{
    absolute::LockTime,
    key::{Keypair, Secp256k1, TapTweak},
    secp256k1::{Message, SecretKey},
    sighash::{Prevouts, SighashCache},
    transaction::Version,
    Address, Amount, Network, OutPoint, ScriptBuf, Sequence, TapSighashType, Transaction, TxIn,
    TxOut, Witness,
};
use rand::thread_rng;

use crate::{
    error::{CryptoError, NetworkError, SparkSdkError, ValidationError},
    wallet::{
        mempool::MempoolClient,
        utils::bitcoin::{p2tr_address_from_public_key, p2tr_script_from_pubkey},
    },
    SparkNetwork,
};

use crate::spark_test_utils::bitcoind::BitcoindClient;

// Add serde import
use serde::Deserialize;

#[allow(dead_code)]
pub struct FaucetCoin {
    key: SecretKey,
    outpoint: OutPoint,
    txout: TxOut,
}

#[allow(dead_code)]
impl FaucetCoin {
    pub fn tx_to_address(
        &self,
        p2tr_address: &Address,
        amount: Amount,
    ) -> Result<Transaction, SparkSdkError> {
        let secp = Secp256k1::new();

        let value = self.txout.value;
        let fees = Amount::from_sat(1000);

        if value - fees < amount {
            return Err(SparkSdkError::from(ValidationError::InvalidInput {
                field: format!(
                    "Amount {amount} is greater than the coin value {value} (incl. fees)"
                ),
            }));
        }

        // Create a second output that spends the rest of the funds to a throwaway address,
        // otherwise bitcoind will complain about the fees being too high.
        let throwaway_keypair = Keypair::new(&secp, &mut thread_rng());
        let throwaway_address =
            p2tr_address_from_public_key(&throwaway_keypair.public_key(), Network::Regtest);

        self.tx_to_outputs(vec![
            TxOut {
                value: amount,
                script_pubkey: p2tr_address.script_pubkey(),
            },
            TxOut {
                value: value - amount - fees,
                script_pubkey: throwaway_address.script_pubkey(),
            },
        ])
    }

    pub fn tx_to_outputs(&self, outputs: Vec<TxOut>) -> Result<Transaction, SparkSdkError> {
        let secp = Secp256k1::new();

        let mut tx = Transaction {
            version: Version::TWO,
            lock_time: LockTime::ZERO,
            input: vec![TxIn {
                previous_output: self.outpoint,
                script_sig: ScriptBuf::new(),
                sequence: Sequence::default(),
                witness: Witness::new(),
            }],
            output: outputs,
        };

        let mut sighash_cache = SighashCache::new(&mut tx);

        let prevouts_vec = vec![self.txout.clone()];
        let prevouts = Prevouts::All(&prevouts_vec);
        let sighash = sighash_cache
            .taproot_signature_hash(0, &prevouts, None, None, TapSighashType::Default)
            .map_err(|err| {
                SparkSdkError::from(ValidationError::InvalidInput {
                    field: format!("Failed to create taproot signature hash: {err}"),
                })
            })?;

        let keypair = Keypair::from_secret_key(&secp, &self.key);
        let tweaked_keypair = keypair.tap_tweak(&secp, None);

        // Build the Schnorr signature with the tweaked key
        let msg = Message::from_digest_slice(sighash.as_ref())
            .map_err(|e| SparkSdkError::from(CryptoError::Secp256k1(e)))?;
        let schnorr_sig = secp.sign_schnorr_no_aux_rand(&msg, &tweaked_keypair.into());

        tx.input[0].witness.push(schnorr_sig.as_ref());
        Ok(tx)
    }
}

#[allow(dead_code)]
pub struct BitcoinFaucet {
    client: Rc<BitcoindClient>,
    coins: Vec<FaucetCoin>,
}

#[allow(dead_code)]
impl BitcoinFaucet {
    pub fn new(client: Rc<BitcoindClient>) -> Self {
        Self {
            client,
            coins: vec![],
        }
    }

    pub fn fund(&mut self) -> Result<FaucetCoin, SparkSdkError> {
        if self.coins.is_empty() {
            self.refill()?;
        }

        let coin =
            self.coins
                .pop()
                .ok_or(SparkSdkError::from(NetworkError::FaucetRequestFailed {
                    status_code: 0, // Using 0 to indicate internal failure rather than HTTP status code
                }))?;

        Ok(coin)
    }

    pub fn refill(&mut self) -> Result<(), SparkSdkError> {
        let secp = Secp256k1::new();
        let keypair = Keypair::new(&secp, &mut thread_rng());

        let address = p2tr_address_from_public_key(&keypair.public_key(), Network::Regtest);

        let block_hash = self
            .client
            .generate_to_address(1, &address)
            .map_err(|err| {
                SparkSdkError::from(NetworkError::BitcoinRpc(format!(
                    "Failed to generate to address: {}",
                    err
                )))
            })
            .and_then(|block_hashes| {
                block_hashes
                    .first()
                    .ok_or(SparkSdkError::from(NetworkError::BitcoinRpc(
                        "Failed to generate to address: block hashes was empty".to_string(),
                    )))
                    .cloned()
            })?;

        let block = self.client.get_block_info(&block_hash).map_err(|err| {
            SparkSdkError::from(NetworkError::BitcoinRpc(format!(
                "Failed to get block info for {block_hash}: {err}"
            )))
        })?;

        // We don't have all of the transaction data because bitcoin_rpc doesn't have a method for
        // calling `getblock` with verbosity 2, so we have to fetch the transaction separately.
        let coin_txid = block
            .tx
            .first()
            .ok_or(SparkSdkError::from(NetworkError::BitcoinRpc(format!(
                "Failed to get coin txid from block {block_hash}"
            ))))?;

        let coin_tx = self
            .client
            .get_raw_transaction_info(coin_txid, Some(&block_hash))
            .map_err(|err| {
                SparkSdkError::from(NetworkError::BitcoinRpc(format!(
                    "Failed to get raw transaction info for {coin_txid}: {err}"
                )))
            })?;

        // Mine 100 blocks to allow the funds to be spendable
        self.client.mine_blocks(100)?;

        let coin = FaucetCoin {
            key: keypair.secret_key(),
            outpoint: OutPoint {
                txid: *coin_txid,
                vout: 0,
            },
            txout: TxOut {
                value: coin_tx.vout[0].value,
                script_pubkey: coin_tx.vout[0].script_pub_key.script().unwrap(),
            },
        };

        // Split the coin into 0.1 BTC outputs
        let mut remaining_value = coin_tx.vout[0].value;
        let split_amount = Amount::from_sat(10_000_000);
        let fee_reserve = Amount::from_sat(100_000);

        let mut coin_keys: Vec<Keypair> = vec![];
        let mut outputs: Vec<TxOut> = vec![];

        while remaining_value > split_amount + fee_reserve {
            let coin_key = Keypair::new(&secp, &mut thread_rng());
            let coin_script = p2tr_script_from_pubkey(&coin_key.public_key(), Network::Regtest);

            coin_keys.push(coin_key);
            outputs.push(TxOut {
                value: split_amount,
                script_pubkey: coin_script,
            });

            remaining_value -= split_amount;
        }

        let split_tx = coin.tx_to_outputs(outputs)?;
        let split_txid = self.client.send_raw_transaction(&split_tx).map_err(|err| {
            SparkSdkError::from(NetworkError::BitcoinRpc(format!(
                "Failed to send split transaction: {err}"
            )))
        })?;

        self.coins.extend(
            coin_keys
                .iter()
                .enumerate()
                .map(|(i, coin_key)| FaucetCoin {
                    key: coin_key.secret_key(),
                    outpoint: OutPoint {
                        txid: split_txid,
                        vout: i as u32,
                    },
                    txout: split_tx.output[i].clone(),
                }),
        );

        Ok(())
    }
}

pub struct MempoolFaucet {
    client: MempoolClient,
}

impl MempoolFaucet {
    pub fn new() -> Result<Self, SparkSdkError> {
        Ok(Self {
            client: MempoolClient::new()?,
        })
    }
}

#[derive(Deserialize)]
struct MempoolFaucetResponse {
    txid: String,
}

impl MempoolFaucet {
    pub async fn make_faucet_request(
        &self,
        address: &Address,
        amount: u64,
    ) -> Result<String, SparkSdkError> {
        // amount must be less than 100,000 sats
        if amount > 100_000 {
            return Err(SparkSdkError::from(ValidationError::InvalidInput {
                field: "Amount must be less than 100,000".to_string(),
            }));
        }

        let res = self
            .client
            .request_json::<MempoolFaucetResponse>(
                SparkNetwork::Regtest,
                &format!("v1/faucet/{}/{}", address, amount),
            )
            .await?;

        Ok(res.txid)
    }
}