torvyon-core 0.1.3

Keys, addresses, post-quantum signing and transaction building for the Torvyon blockchain
Documentation
//! Byte-exact ports of the node's signing payloads (`internal/tx/transaction.go`).

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)
}

/// Version 0. Never change: historical signatures depend on these bytes.
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
}

/// Version 2.
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
}

/// Version 3 (UTXO). Scripts commit only to type, pubkey_hash and
/// threshold — see "Known issue" in `spec/transactions.md`.
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)
}

/// Version 4 base payload: everything covered by txid; witnesses excluded.
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)
}

/// Version 4 sighash: SHA256("torvyon-v4-sighash" || SHA256(base) || spent outputs).
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))
}