spark_rust/wallet/utils/

bitcoin.rs

use crate::common_types::types::SecretKey;
use bitcoin::consensus::{deserialize, Encodable};
use bitcoin::hashes::Hash;
use bitcoin::key::TapTweak;
use bitcoin::secp256k1::Scalar;
use bitcoin::secp256k1::{PublicKey, Secp256k1};
use bitcoin::{Address, Network, ScriptBuf, TapTweakHash, Transaction, TxOut, XOnlyPublicKey};

use crate::error::{transaction::TransactionError, validation::ValidationError, SparkSdkError};

// P2TR functions
pub(crate) fn p2tr_script_from_pubkey(pubkey: &PublicKey, network: Network) -> ScriptBuf {
    let secp = Secp256k1::new();
    let xonly = XOnlyPublicKey::from(*pubkey);
    let address = Address::p2tr(&secp, xonly, None, network);
    address.script_pubkey()
}

pub(crate) fn p2tr_address_from_public_key(pubkey: &PublicKey, network: Network) -> Address {
    let secp = Secp256k1::new();
    let xonly = XOnlyPublicKey::from(*pubkey);

    Address::p2tr(&secp, xonly, None, network)
}

// Transaction functions
pub(crate) fn bitcoin_tx_from_hex(raw_tx_hex: &str) -> Result<Transaction, SparkSdkError> {
    let tx_bytes = hex::decode(raw_tx_hex).map_err(|e| {
        SparkSdkError::from(TransactionError::InvalidBitcoinTransaction(format!(
            "Failed to decode hex: {}",
            e
        )))
    })?;
    bitcoin_tx_from_bytes(&tx_bytes)
}

pub(crate) fn serialize_bitcoin_transaction(
    transaction: &Transaction,
) -> Result<Vec<u8>, SparkSdkError> {
    let mut buf = Vec::new();
    transaction.consensus_encode(&mut buf).map_err(|e| {
        SparkSdkError::from(TransactionError::InvalidBitcoinTransaction(format!(
            "Failed to serialize Bitcoin transaction: {}",
            e
        )))
    })?;

    Ok(buf)
}

pub(crate) fn bitcoin_tx_from_bytes(raw_tx_bytes: &[u8]) -> Result<Transaction, SparkSdkError> {
    if raw_tx_bytes.is_empty() {
        return Err(SparkSdkError::from(
            TransactionError::InvalidBitcoinTransaction(
                "Cannot deserialize Bitcoin transaction: buffer is empty".to_string(),
            ),
        ));
    }

    let transaction = deserialize(raw_tx_bytes).map_err(|_| {
        SparkSdkError::from(TransactionError::InvalidBitcoinTransaction(
            "Invalid transaction".to_string(),
        ))
    })?;

    Ok(transaction)
}

pub(crate) fn sighash_from_tx(
    tx: &bitcoin::Transaction,
    input_index: usize,
    prev_output: &bitcoin::TxOut,
) -> Result<[u8; 32], SparkSdkError> {
    let prevouts_arr = [prev_output.clone()];
    let prev_output_fetcher = bitcoin::sighash::Prevouts::All(&prevouts_arr);

    let sighash = bitcoin::sighash::SighashCache::new(tx)
        .taproot_key_spend_signature_hash(
            input_index,
            &prev_output_fetcher,
            bitcoin::sighash::TapSighashType::Default,
        )
        .map_err(|e| {
            SparkSdkError::from(ValidationError::InvalidInput {
                field: format!("Failed to calculate sighash: {}", e),
            })
        })?;

    Ok(sighash.to_raw_hash().to_byte_array())
}

pub(crate) fn sighash_from_tx_new(
    tx: &Transaction,
    input_index: usize,
    prev_output: &TxOut,
) -> Result<[u8; 32], SparkSdkError> {
    // Create a vector filled with the same prev_output for all inputs
    let prevouts = vec![prev_output.clone(); tx.input.len()];

    // Create a PrevoutsFetcher that will return the same prevout for all inputs
    let prev_output_fetcher = bitcoin::sighash::Prevouts::All(&prevouts);

    // Now calculate the sighash (for Taproot, using SIGHASH_DEFAULT)
    let sighash = bitcoin::sighash::SighashCache::new(tx)
        .taproot_key_spend_signature_hash(
            input_index,
            &prev_output_fetcher,
            bitcoin::sighash::TapSighashType::Default,
        )
        .map_err(|e| {
            SparkSdkError::from(ValidationError::InvalidInput {
                field: format!("Failed to calculate sighash: {}", e),
            })
        })?;

    Ok(sighash.to_byte_array())
}

pub(crate) fn compute_taproot_key_no_script(
    pubkey: bitcoin::secp256k1::PublicKey,
) -> Result<bitcoin::XOnlyPublicKey, SparkSdkError> {
    let (x_only_pub, _) = pubkey.x_only_public_key();

    // BIP341 taproot tweak with empty script tree
    let (tweaked_key, _parity) = x_only_pub.tap_tweak(&bitcoin::secp256k1::Secp256k1::new(), None);

    Ok(tweaked_key.to_inner())
}

#[cfg(test)]
mod tests {
    use super::*;
    use bitcoin::absolute::LockTime;
    use bitcoin::transaction::Version;
    use bitcoin::Network;
    use bitcoin::{Amount, OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Witness};

    #[test]
    fn test_p2tr_address_from_public_key() {
        let test_vectors = vec![
            (
                "0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
                "bc1pmfr3p9j00pfxjh0zmgp99y8zftmd3s5pmedqhyptwy6lm87hf5sspknck9",
                Network::Bitcoin,
            ),
            (
                "03797dd653040d344fd048c1ad05d4cbcb2178b30c6a0c4276994795f3e833da41",
                "tb1p8dlmzllfah294ntwatr8j5uuvcj7yg0dete94ck2krrk0ka2c9qqex96hv",
                Network::Testnet,
            ),
        ];

        for (pubkey_hex, expected_addr, network) in test_vectors {
            let pubkey = PublicKey::from_slice(&hex::decode(pubkey_hex).unwrap()).unwrap();
            let addr = p2tr_address_from_public_key(&pubkey, network);
            assert_eq!(&addr.to_string(), expected_addr);
        }
    }

    #[test]
    fn test_tx_from_raw_tx_hex() {
        let raw_tx_hex = "02000000000102dc552c6c0ef5ed0d8cd64bd1d2d1ffd7cf0ec0b5ad8df2a4c6269b59cffcc696010000000000000000603fbd40e86ee82258c57571c557b89a444aabf5b6a05574e6c6848379febe9a00000000000000000002e86905000000000022512024741d89092c5965f35a63802352fa9c7fae4a23d471b9dceb3379e8ff6b7dd1d054080000000000220020aea091435e74e3c1eba0bd964e67a05f300ace9e73efa66fe54767908f3e68800140f607486d87f59af453d62cffe00b6836d8cca2c89a340fab5fe842b20696908c77fd2f64900feb0cbb1c14da3e02271503fc465fcfb1b043c8187dccdd494558014067dff0f0c321fc8abc28bf555acfdfa5ee889b6909b24bc66cedf05e8cc2750a4d95037c3dc9c24f1e502198bade56fef61a2504809f5b2a60a62afeaf8bf52e00000000";
        let result_hex = bitcoin_tx_from_hex(raw_tx_hex);
        assert!(result_hex.is_ok());

        let tx_bytes = hex::decode(raw_tx_hex).unwrap();
        let result_bytes = bitcoin_tx_from_bytes(&tx_bytes);
        assert!(result_bytes.is_ok());

        assert_eq!(result_hex.unwrap(), result_bytes.unwrap());
    }

    #[test]
    fn test_sighash_from_tx() {
        let prev_tx_hex = "020000000001010cb9feccc0bdaac30304e469c50b4420c13c43d466e13813fcf42a73defd3f010000000000ffffffff018038010000000000225120d21e50e12ae122b4a5662c09b67cec7449c8182913bc06761e8b65f0fa2242f701400536f9b7542799f98739eeb6c6adaeb12d7bd418771bc5c6847f2abd19297bd466153600af26ccf0accb605c11ad667c842c5713832af4b7b11f1bcebe57745900000000";
        let prev_tx = bitcoin_tx_from_hex(prev_tx_hex).unwrap();

        let tx = Transaction {
            version: Version::TWO,
            lock_time: LockTime::ZERO,
            input: vec![TxIn {
                previous_output: OutPoint {
                    txid: prev_tx.compute_txid(),
                    vout: 0,
                },
                script_sig: ScriptBuf::new(),
                sequence: bitcoin::Sequence::MAX,
                witness: Witness::default(),
            }],
            output: vec![TxOut {
                value: Amount::from_sat(70_000),
                script_pubkey: prev_tx.output[0].script_pubkey.clone(),
            }],
        };

        let sighash = sighash_from_tx(&tx, 0, &prev_tx.output[0]).unwrap();
        assert_eq!(
            hex::encode(sighash),
            "8da5e7aa2b03491d7c2f4359ea4968dd58f69adf9af1a2c6881be0295591c293"
        );
    }
}

/// Computes a taproot key without script paths, equivalent to computeTaprootKeyNoScript in JS
///
/// # Arguments
/// * `pubkey` - The x-only public key (32 bytes)
///
/// # Returns
/// * The tweaked x-only public key (32 bytes)
#[cfg_attr(feature = "telemetry", tracing::instrument(skip_all))]
pub fn compute_taproot_key_no_script_from_internal_key(
    pubkey: &[u8],
) -> Result<[u8; 33], SparkSdkError> {
    // Validate input
    if pubkey.len() != 32 {
        return Err(SparkSdkError::from(ValidationError::InvalidInput {
            field: "Public key must be 32 bytes".to_string(),
        }));
    }

    // Create secp context
    let secp = Secp256k1::new();

    // Parse the x-only public key
    let x_only_key = XOnlyPublicKey::from_slice(pubkey).map_err(|_| {
        SparkSdkError::from(ValidationError::InvalidInput {
            field: "Invalid x-only public key".to_string(),
        })
    })?;

    // Compute the taproot tweak (tagged hash)
    let tweak = TapTweakHash::hash(pubkey);
    let tweak_bytes = tweak.to_byte_array();
    let tweak_scalar = Scalar::from_be_bytes(tweak_bytes).map_err(|_| {
        SparkSdkError::from(ValidationError::InvalidInput {
            field: "Failed to convert tweak to scalar".to_string(),
        })
    })?;

    // Apply the tweak to the public key
    let (tweaked_key, _parity) = x_only_key.add_tweak(&secp, &tweak_scalar).map_err(|_| {
        SparkSdkError::from(ValidationError::InvalidInput {
            field: "Failed to tweak public key".to_string(),
        })
    })?;

    // Construct the full public key
    let taproot_key = PublicKey::from_x_only_public_key(tweaked_key, _parity);

    // Return the serialized tweaked key
    Ok(taproot_key.serialize())
}

pub fn parse_secret_key(bytes: &Vec<u8>) -> Result<SecretKey, SparkSdkError> {
    let secret_key = bitcoin::secp256k1::SecretKey::from_slice(bytes).map_err(|e| {
        SparkSdkError::from(ValidationError::InvalidArgument {
            argument: format!("Private key is not valid: {}", e),
        })
    })?;

    Ok(secret_key)
}

pub fn parse_public_key(bytes: &Vec<u8>) -> Result<PublicKey, SparkSdkError> {
    let public_key = bitcoin::secp256k1::PublicKey::from_slice(bytes).map_err(|e| {
        SparkSdkError::from(ValidationError::InvalidArgument {
            argument: format!("Public key is not valid: {}", e),
        })
    })?;

    Ok(public_key)
}