Skip to main content

qualia_client_core/wallet/
signer.rs

1use crate::wallet::transaction::{encode_varint, Transaction};
2use bip32::XPrv;
3use k256::ecdsa::{signature::Signer, SigningKey};
4use sha2::{Digest, Sha256};
5
6pub const SIGHASH_ALL: u32 = 0x01;
7pub const SIGHASH_FORKID: u32 = 0x40;
8
9/// Double SHA-256.
10pub fn double_sha256(data: &[u8]) -> Vec<u8> {
11    let hash1 = Sha256::digest(data);
12    let hash2 = Sha256::digest(&hash1);
13    hash2.to_vec()
14}
15
16/// HASH160 (SHA-256 then RIPEMD-160).
17pub fn hash160(data: &[u8]) -> Vec<u8> {
18    use ripemd::{Digest as _, Ripemd160};
19    let sha = Sha256::digest(data);
20    let rip = Ripemd160::digest(&sha);
21    rip.to_vec()
22}
23
24/// Signs a P2PKH input.
25pub fn sign_p2pkh_input(
26    tx: &Transaction,
27    input_index: usize,
28    prev_value: u64,
29    priv_key: &XPrv,
30) -> Vec<u8> {
31    let sighash_type = SIGHASH_ALL | SIGHASH_FORKID;
32
33    let mut hash_prevouts = Vec::new();
34    for input in &tx.inputs {
35        let mut txid_bytes = hex::decode(&input.prev_txid).unwrap_or_else(|_| vec![0; 32]);
36        txid_bytes.reverse();
37        hash_prevouts.extend_from_slice(&txid_bytes);
38        hash_prevouts.extend_from_slice(&input.prev_out_idx.to_le_bytes());
39    }
40    let hash_prevouts = double_sha256(&hash_prevouts);
41
42    let mut hash_sequence = Vec::new();
43    for input in &tx.inputs {
44        hash_sequence.extend_from_slice(&input.sequence.to_le_bytes());
45    }
46    let hash_sequence = double_sha256(&hash_sequence);
47
48    let mut hash_outputs = Vec::new();
49    for output in &tx.outputs {
50        hash_outputs.extend_from_slice(&output.value.to_le_bytes());
51        hash_outputs.extend_from_slice(&encode_varint(output.pk_script.len() as u64));
52        hash_outputs.extend_from_slice(&output.pk_script);
53    }
54    let hash_outputs = double_sha256(&hash_outputs);
55
56    let mut preimage = Vec::new();
57    preimage.extend_from_slice(&tx.version.to_le_bytes());
58    preimage.extend_from_slice(&hash_prevouts);
59    preimage.extend_from_slice(&hash_sequence);
60
61    let input = &tx.inputs[input_index];
62    let mut txid_bytes = hex::decode(&input.prev_txid).unwrap_or_else(|_| vec![0; 32]);
63    txid_bytes.reverse();
64    preimage.extend_from_slice(&txid_bytes);
65    preimage.extend_from_slice(&input.prev_out_idx.to_le_bytes());
66
67    // scriptCode for P2PKH: 0x19 0x76 0xa9 0x14 <pubkey_hash> 0x88 0xac
68    let pubkey = priv_key.public_key().to_bytes();
69    let pubkey_hash = hash160(&pubkey);
70    let mut script_code = vec![0x76, 0xa9, 0x14];
71    script_code.extend_from_slice(&pubkey_hash);
72    script_code.extend_from_slice(&[0x88, 0xac]);
73    preimage.extend_from_slice(&encode_varint(script_code.len() as u64));
74    preimage.extend_from_slice(&script_code);
75
76    preimage.extend_from_slice(&prev_value.to_le_bytes());
77    preimage.extend_from_slice(&input.sequence.to_le_bytes());
78    preimage.extend_from_slice(&hash_outputs);
79    preimage.extend_from_slice(&tx.lock_time.to_le_bytes());
80    preimage.extend_from_slice(&sighash_type.to_le_bytes());
81
82    let sighash = double_sha256(&preimage);
83
84    let private_key_bytes = priv_key.private_key().to_bytes();
85    let signing_key = SigningKey::from_slice(private_key_bytes.as_slice()).expect("Valid key");
86    let signature: k256::ecdsa::Signature = signing_key.sign(&sighash);
87    let mut der_sig = signature.to_der().to_bytes().to_vec();
88
89    // Append sighash type byte to DER signature
90    der_sig.push(sighash_type as u8);
91
92    // Build final scriptSig: <sig_len><sig><pubkey_len><pubkey>
93    let mut script_sig = Vec::new();
94    script_sig.push(der_sig.len() as u8);
95    script_sig.extend_from_slice(&der_sig);
96    script_sig.push(pubkey.len() as u8);
97    script_sig.extend_from_slice(&pubkey);
98
99    script_sig
100}