use super::{Input, Output, SignedTransaction, SpentOutput, VERSION_CONDITIONAL};
use crate::{hash::sha256, Error, Result};
fn put_u32(buf: &mut Vec<u8>, v: u32) {
buf.extend_from_slice(&v.to_be_bytes());
}
fn put_u64(buf: &mut Vec<u8>, v: u64) {
buf.extend_from_slice(&v.to_be_bytes());
}
fn put_bytes(buf: &mut Vec<u8>, b: &[u8]) {
put_u64(buf, b.len() as u64);
buf.extend_from_slice(b);
}
fn output_lock(i: usize, output: &Output) -> Result<Vec<u8>> {
if !output.condition.is_empty() {
let mut out = vec![0x01];
out.extend_from_slice(&output.condition);
return Ok(out);
}
let Some(spk) = &output.script_pub_key else {
return Err(Error::MissingScript(i));
};
let c = spk.canonicalize().ok_or(Error::InvalidScript(i))?;
if c.kind != "p2pkh" {
return Err(Error::InvalidScript(i));
}
let mut out = vec![0x00];
put_bytes(&mut out, c.pubkey_hash.as_bytes());
Ok(out)
}
pub(super) fn legacy_payload(t: &SignedTransaction) -> Vec<u8> {
let mut buf = Vec::with_capacity(t.to.len() + 32 + t.data.len());
buf.extend_from_slice(t.to.as_bytes());
put_u64(&mut buf, t.amount);
put_u64(&mut buf, t.fee);
put_u64(&mut buf, t.nonce);
put_bytes(&mut buf, &t.data);
buf
}
pub(super) fn chain_id_payload(t: &SignedTransaction) -> Vec<u8> {
let mut buf = Vec::with_capacity(64 + t.chain_id.len() + t.to.len() + t.data.len());
put_u32(&mut buf, t.version);
put_bytes(&mut buf, t.chain_id.as_bytes());
put_bytes(&mut buf, t.to.as_bytes());
put_u64(&mut buf, t.amount);
put_u64(&mut buf, t.fee);
put_u64(&mut buf, t.nonce);
put_bytes(&mut buf, &t.data);
buf
}
pub(super) fn utxo_payload(
version: u32,
chain_id: &str,
inputs: &[Input],
outputs: &[Output],
lock_time: u32,
data: &[u8],
) -> Result<Vec<u8>> {
let mut buf = Vec::with_capacity(64 + inputs.len() * 80 + outputs.len() * 80 + data.len());
put_u32(&mut buf, version);
put_bytes(&mut buf, chain_id.as_bytes());
put_u64(&mut buf, inputs.len() as u64);
for input in inputs {
put_bytes(&mut buf, input.previous_outpoint.txid.as_bytes());
put_u32(&mut buf, input.previous_outpoint.index);
put_u32(&mut buf, input.sequence);
}
put_u64(&mut buf, outputs.len() as u64);
for (i, output) in outputs.iter().enumerate() {
put_u64(&mut buf, output.value);
let mut script = Vec::new();
if let Some(spk) = &output.script_pub_key {
let c = spk.canonicalize().ok_or(Error::InvalidScript(i))?;
script.extend_from_slice(c.kind.as_bytes());
script.push(0);
script.extend_from_slice(c.pubkey_hash.as_bytes());
script.push(0);
put_u32(&mut script, c.threshold as u32);
}
put_bytes(&mut buf, &script);
}
put_u32(&mut buf, lock_time);
put_bytes(&mut buf, data);
Ok(buf)
}
pub(super) fn v4_base_payload(
chain_id: &str,
inputs: &[Input],
outputs: &[Output],
lock_time: u32,
data: &[u8],
) -> Result<Vec<u8>> {
let mut buf = Vec::with_capacity(64 + inputs.len() * 80 + outputs.len() * 80 + data.len());
put_u32(&mut buf, VERSION_CONDITIONAL);
put_bytes(&mut buf, chain_id.as_bytes());
put_u64(&mut buf, inputs.len() as u64);
for input in inputs {
put_bytes(&mut buf, input.previous_outpoint.txid.as_bytes());
put_u32(&mut buf, input.previous_outpoint.index);
put_u32(&mut buf, input.sequence);
}
put_u64(&mut buf, outputs.len() as u64);
for (i, output) in outputs.iter().enumerate() {
put_u64(&mut buf, output.value);
put_bytes(&mut buf, &output_lock(i, output)?);
}
put_u32(&mut buf, lock_time);
put_bytes(&mut buf, data);
Ok(buf)
}
pub(super) fn v4_sighash(
chain_id: &str,
inputs: &[Input],
outputs: &[Output],
lock_time: u32,
data: &[u8],
spent: &[SpentOutput],
) -> Result<[u8; 32]> {
if spent.len() != inputs.len() {
return Err(Error::InvalidCondition(format!(
"need {} spent outputs, got {}",
inputs.len(),
spent.len()
)));
}
let base = sha256(&v4_base_payload(chain_id, inputs, outputs, lock_time, data)?);
let mut buf = b"torvyon-v4-sighash".to_vec();
buf.extend_from_slice(&base);
put_u64(&mut buf, spent.len() as u64);
for s in spent {
put_u64(&mut buf, s.value);
put_bytes(&mut buf, &s.lock);
}
Ok(sha256(&buf))
}