Merge branch 'main' into feature/unspend_utxo_indexer

Author: ivanlele

utxo_indexer/Cargo.toml

@@ -1,3 +1,3 @@
 [workspace]
 resolver = "3"
-members = ["indexer"]
+members = ["indexer", "utxo_test_data_generator"]

utxo_indexer/indexer/src/lib.rs

@@ -0,0 +1,18 @@
+[package]
+name = "utxo_test_data_generator"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+rand = "0.9.2"
+k256 = { version = "0.11", features = ["ecdsa"] }
+anyhow = "1.0.99"
+hex = "0.4"
+sha2 = "0.10.9"
+ripemd = "0.1.3"
+clap = { version = "4.5.47", features = ["derive"] }
+bitcoin = "0.32.7"
+serde_json = "1.0.145"
+serde = { version = "1.0.226", features = ["derive"] }
+log = "0.4.28"
+env_logger = "0.11.8"

utxo_indexer/utxo_test_data_generator/Cargo.toml

@@ -0,0 +1,23 @@
+use std::path::PathBuf;
+
+use clap::Parser;
+
+#[derive(Parser)]
+#[command(version, about = "Sync blockchain block headers", long_about = None)]
+pub struct Cli {
+    /// Amount of utxos that will be generated
+    #[arg(long, default_value = "20")]
+    pub utxos_amount: u32,
+
+    /// Message that will be signed with private key
+    #[arg(long, default_value = "const message")]
+    pub const_message: String,
+
+    /// Private key in hex (will be generated if it doesn't set)
+    #[arg(long)]
+    pub priv_key: Option<String>,
+
+    /// Path to file where generated utxos will be saved
+    #[arg(long)]
+    pub output: Option<PathBuf>,
+}

utxo_indexer/utxo_test_data_generator/src/cli.rs

@@ -0,0 +1 @@
+mod test_data_gen;

utxo_indexer/utxo_test_data_generator/src/lib.rs

@@ -0,0 +1,64 @@
+mod cli;
+mod test_data_gen;
+
+use clap::Parser;
+use log::info;
+use rand::Rng;
+use std::fs::{self, File};
+use std::io::Write;
+
+use crate::test_data_gen::generate_test_utxos;
+
+fn main() {
+    env_logger::Builder::from_default_env()
+        .filter_level(log::LevelFilter::Info)
+        .init();
+
+    let args = cli::Cli::parse();
+
+    let message = args.const_message.as_bytes();
+
+    let priv_key = match args.priv_key {
+        Some(k) => hex::decode(k).unwrap(),
+        None => Vec::new(),
+    };
+
+    let mut rng = rand::rng();
+
+    let private_key: [u8; 32] = if priv_key.is_empty() {
+        rng.random()
+    } else {
+        priv_key.as_slice().try_into().unwrap()
+    };
+
+    let test_utxos = generate_test_utxos(args.utxos_amount, &message, &private_key).unwrap();
+
+    for elem in test_utxos.iter().clone() {
+        println!(
+            "SPK: {}\nAmount: {}\nWitness: {}\n",
+            elem.script_pub_key, elem.amount, elem.witness,
+        )
+    }
+
+    match args.output {
+        Some(mut path) => {
+            if path.extension().and_then(|s| s.to_str()) != Some("json") {
+                path.set_extension("json");
+            }
+
+            if let Some(parent) = path.parent() {
+                fs::create_dir_all(parent).unwrap();
+            }
+
+            let mut file = File::create(&path).unwrap();
+            let as_json = serde_json::to_string_pretty(&test_utxos).unwrap();
+            file.write_all(as_json.as_bytes()).unwrap();
+
+            info!(
+                "UTXOs were successfully saved to {}",
+                path.to_str().unwrap()
+            )
+        }
+        _ => (),
+    }
+}

utxo_indexer/utxo_test_data_generator/src/main.rs

@@ -0,0 +1,90 @@
+use anyhow::{Ok, Result};
+use bitcoin::{
+    opcodes::all::{OP_CHECKSIG, OP_DUP, OP_EQUALVERIFY, OP_HASH160},
+    script::Builder,
+};
+use k256::{
+    ecdsa::{Signature, SigningKey, signature::Signer},
+    elliptic_curve::sec1::ToEncodedPoint,
+};
+use rand::Rng;
+use ripemd::Ripemd160;
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+
+#[allow(dead_code)]
+#[derive(Serialize, Deserialize)]
+pub struct TestUtxo {
+    pub amount: u64,
+    pub script_pub_key: String,
+    pub witness: String,
+}
+
+#[allow(dead_code)]
+pub fn generate_test_utxos(
+    utxos_amount: u32,
+    message: &[u8],
+    priv_key: &[u8; 32],
+) -> Result<Vec<TestUtxo>> {
+    let mut rng = rand::rng();
+    let mut res: Vec<TestUtxo> = Vec::with_capacity(utxos_amount as usize);
+
+    for _ in 0..utxos_amount {
+        let amount: u64 = rng.random_range(1000..=10000000);
+
+        let sign_key = SigningKey::from_bytes(priv_key)?;
+        let pub_key = sign_key.verifying_key().to_encoded_point(true);
+        let pub_key_bytes = pub_key.as_bytes();
+
+        let signature: Signature = sign_key.sign(message);
+        let normalized = signature.normalize_s().unwrap_or(signature).to_der();
+        let der_bytes = normalized.as_bytes();
+
+        let script_pub_key = Builder::new()
+            .push_opcode(OP_DUP)
+            .push_opcode(OP_HASH160)
+            .push_slice(hash160(pub_key_bytes))
+            .push_opcode(OP_EQUALVERIFY)
+            .push_opcode(OP_CHECKSIG);
+
+        res.push(TestUtxo {
+            amount,
+            script_pub_key: hex::encode(script_pub_key.into_bytes()),
+            witness: hex::encode(Vec::from(der_bytes)),
+        });
+    }
+
+    Ok(res)
+}
+
+pub fn hash160(data: &[u8]) -> [u8; 20] {
+    Ripemd160::digest(Sha256::digest(data)).into()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::test_data_gen::{generate_test_utxos, hash160};
+    use k256::{
+        ecdsa::{Signature, SigningKey, signature::Verifier},
+        elliptic_curve::sec1::ToEncodedPoint,
+    };
+
+    #[test]
+    fn text_gen() {
+        let priv_key = [1; 32];
+        let utxos = generate_test_utxos(10, &[0; 32], &priv_key).unwrap();
+
+        for i in 0..10 {
+            let sign_key = SigningKey::from_bytes(&priv_key).unwrap();
+            let ver_key = sign_key.verifying_key();
+
+            assert!(
+                hash160(ver_key.to_encoded_point(true).to_bytes().as_ref())
+                    == hex::decode(&utxos[i].script_pub_key).unwrap()[3..23]
+            );
+
+            let sign = Signature::from_der(&hex::decode(&utxos[i].witness).unwrap()).unwrap();
+            ver_key.verify(&[0; 32], &sign).unwrap();
+        }
+    }
+}