use std::{collections::BTreeSet, fmt};
use serde::{
Deserialize, Deserializer, Serialize, Serializer,
de::{SeqAccess, Visitor},
};
use super::{Address, Network, Satoshis, TransactionStatus, Txid, Wtxid};
use crate::error::{Error, ValidationError};
const MAX_WEIGHT: u64 = bitcoin::Weight::MAX_BLOCK.to_wu();
pub(crate) const MAX_INPUTS: usize = 4_000_000 / (41 * 4);
#[cfg(feature = "bitcoin-esplora")]
pub(crate) const MAX_OUTPUTS: usize = 4_000_000 / (9 * 4);
fn invalid_transaction() -> Error {
ValidationError::InvalidBitcoinTransaction.into()
}
#[derive(Clone, Eq, PartialEq)]
pub struct Bytes(Vec<u8>);
impl Bytes {
pub const MAX_LEN: usize = bitcoin::consensus::encode::MAX_VEC_SIZE;
pub fn new(bytes: Vec<u8>) -> Result<Self, Error> {
if bytes.len() > Self::MAX_LEN {
return Err(ValidationError::InvalidBitcoinBytes.into());
}
Ok(Self(bytes))
}
pub fn from_hex(value: &str) -> Result<Self, Error> {
if value.len() > 2 * Self::MAX_LEN
|| !value.len().is_multiple_of(2)
|| !value
.bytes()
.all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
{
return Err(ValidationError::InvalidBitcoinBytes.into());
}
const_hex::decode(value)
.map(Self)
.map_err(|_| ValidationError::InvalidBitcoinBytes.into())
}
#[must_use]
pub fn as_slice(&self) -> &[u8] {
&self.0
}
}
impl fmt::Debug for Bytes {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("Bytes")
.field("length", &self.0.len())
.finish()
}
}
impl Serialize for Bytes {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(&const_hex::encode(&self.0))
}
}
impl<'de> Deserialize<'de> for Bytes {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
struct BytesVisitor;
impl Visitor<'_> for BytesVisitor {
type Value = Bytes;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("bounded canonical Bitcoin hexadecimal bytes")
}
fn visit_str<E: serde::de::Error>(self, value: &str) -> Result<Bytes, E> {
Bytes::from_hex(value).map_err(E::custom)
}
}
deserializer.deserialize_str(BytesVisitor)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "OutPointFields")]
pub struct OutPoint {
txid: Txid,
vout: u32,
}
impl OutPoint {
pub fn new(txid: Txid, vout: u32) -> Result<Self, Error> {
if txid.to_string() == "0".repeat(64) && vout == u32::MAX {
return Err(invalid_transaction());
}
Ok(Self { txid, vout })
}
#[must_use]
pub const fn txid(self) -> Txid {
self.txid
}
#[must_use]
pub const fn vout(self) -> u32 {
self.vout
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct OutPointFields {
txid: Txid,
vout: u32,
}
impl TryFrom<OutPointFields> for OutPoint {
type Error = Error;
fn try_from(value: OutPointFields) -> Result<Self, Error> {
Self::new(value.txid, value.vout)
}
}
#[derive(Clone, Copy, Debug)]
pub struct TransactionInput<'a>(&'a bitcoin::TxIn);
impl<'a> TransactionInput<'a> {
#[must_use]
pub fn previous_output(self) -> Option<OutPoint> {
(!self.0.previous_output.is_null()).then_some(OutPoint {
txid: Txid::from_native(self.0.previous_output.txid),
vout: self.0.previous_output.vout,
})
}
#[must_use]
pub fn script_sig(self) -> &'a [u8] {
self.0.script_sig.as_bytes()
}
#[must_use]
pub const fn sequence(self) -> u32 {
self.0.sequence.0
}
#[must_use]
pub fn witness(self) -> impl ExactSizeIterator<Item = &'a [u8]> {
self.0.witness.iter()
}
}
#[derive(Clone, Copy, Debug)]
pub struct TransactionOutput<'a>(&'a bitcoin::TxOut);
impl<'a> TransactionOutput<'a> {
#[must_use]
pub fn value(self) -> Satoshis {
Satoshis::new(self.0.value.to_sat())
}
#[must_use]
pub fn script_pubkey(self) -> &'a [u8] {
self.0.script_pubkey.as_bytes()
}
#[must_use]
pub fn address(self, network: Network) -> Option<Address> {
Address::from_script(&self.0.script_pubkey, network)
}
}
#[derive(Clone, Eq, PartialEq)]
pub struct TransactionBody(bitcoin::Transaction);
impl TransactionBody {
pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error> {
if bytes.is_empty() || bytes.len() > Bytes::MAX_LEN {
return Err(invalid_transaction());
}
let transaction: bitcoin::Transaction =
bitcoin::consensus::deserialize(bytes).map_err(|_| invalid_transaction())?;
if transaction.input.is_empty()
|| transaction.output.is_empty()
|| transaction.weight().to_wu() > MAX_WEIGHT
|| bitcoin::consensus::serialize(&transaction) != bytes
{
return Err(invalid_transaction());
}
let mut seen = BTreeSet::new();
for input in &transaction.input {
if !seen.insert(input.previous_output)
|| (!transaction.is_coinbase() && input.previous_output.is_null())
|| (transaction.is_coinbase() && !(2..=100).contains(&input.script_sig.len()))
{
return Err(invalid_transaction());
}
}
let mut output_sum = 0_u64;
for output in &transaction.output {
output_sum = output_sum
.checked_add(output.value.to_sat())
.ok_or_else(invalid_transaction)?;
if output.value.to_sat() > bitcoin::Amount::MAX_MONEY.to_sat()
|| output_sum > bitcoin::Amount::MAX_MONEY.to_sat()
{
return Err(invalid_transaction());
}
}
Ok(Self(transaction))
}
pub fn from_hex(value: &str) -> Result<Self, Error> {
Self::from_bytes(Bytes::from_hex(value)?.as_slice())
}
#[must_use]
pub fn to_bytes(&self) -> Vec<u8> {
bitcoin::consensus::serialize(&self.0)
}
#[must_use]
pub fn txid(&self) -> Txid {
Txid::from_native(self.0.compute_txid())
}
#[must_use]
pub fn wtxid(&self) -> Wtxid {
Wtxid::from_native(self.0.compute_wtxid())
}
#[must_use]
pub const fn version(&self) -> i32 {
self.0.version.0
}
#[must_use]
pub fn lock_time(&self) -> u32 {
self.0.lock_time.to_consensus_u32()
}
#[must_use]
pub fn is_coinbase(&self) -> bool {
self.0.is_coinbase()
}
#[must_use]
pub fn size(&self) -> usize {
self.0.total_size()
}
#[must_use]
pub fn weight(&self) -> u64 {
self.0.weight().to_wu()
}
#[must_use]
pub fn vsize(&self) -> usize {
self.0.vsize()
}
pub fn inputs(&self) -> impl ExactSizeIterator<Item = TransactionInput<'_>> {
self.0.input.iter().map(TransactionInput)
}
pub fn outputs(&self) -> impl ExactSizeIterator<Item = TransactionOutput<'_>> {
self.0.output.iter().map(TransactionOutput)
}
}
impl fmt::Debug for TransactionBody {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("TransactionBody")
.field("txid", &self.txid())
.field("wtxid", &self.wtxid())
.field("size", &self.size())
.field("inputs", &self.0.input.len())
.field("outputs", &self.0.output.len())
.finish()
}
}
impl Serialize for TransactionBody {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(&const_hex::encode(self.to_bytes()))
}
}
impl<'de> Deserialize<'de> for TransactionBody {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let bytes = Bytes::deserialize(deserializer)?;
Self::from_bytes(bytes.as_slice()).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "PreviousOutputFields")]
pub struct PreviousOutput {
value: Satoshis,
script_pubkey: Bytes,
}
impl PreviousOutput {
pub fn new(value: Satoshis, script_pubkey: Bytes) -> Result<Self, Error> {
if value.raw() > bitcoin::Amount::MAX_MONEY.to_sat() {
return Err(invalid_transaction());
}
Ok(Self {
value,
script_pubkey,
})
}
#[must_use]
pub const fn value(&self) -> Satoshis {
self.value
}
#[must_use]
pub fn script_pubkey(&self) -> &[u8] {
self.script_pubkey.as_slice()
}
#[must_use]
pub fn address(&self, network: Network) -> Option<Address> {
Address::from_script(bitcoin::Script::from_bytes(self.script_pubkey()), network)
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct PreviousOutputFields {
value: Satoshis,
script_pubkey: Bytes,
}
impl TryFrom<PreviousOutputFields> for PreviousOutput {
type Error = Error;
fn try_from(value: PreviousOutputFields) -> Result<Self, Error> {
Self::new(value.value, value.script_pubkey)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "TransactionFields")]
pub struct Transaction {
network: Network,
body: TransactionBody,
previous_outputs: Vec<Option<PreviousOutput>>,
reported_fee: Option<Satoshis>,
status: TransactionStatus,
}
impl Transaction {
pub fn new(
network: Network,
body: TransactionBody,
previous_outputs: Vec<Option<PreviousOutput>>,
reported_fee: Option<Satoshis>,
status: TransactionStatus,
) -> Result<Self, Error> {
if previous_outputs.len() != body.inputs().len()
|| (body.is_coinbase()
&& (previous_outputs.iter().any(Option::is_some)
|| reported_fee.is_some_and(|fee| fee.raw() != 0)))
{
return Err(invalid_transaction());
}
let value = Self {
network,
body,
previous_outputs,
reported_fee,
status,
};
let output_sum = value
.body
.outputs()
.try_fold(0_u64, |sum, output| sum.checked_add(output.value().raw()))
.ok_or_else(invalid_transaction)?;
let reported_funding = value
.reported_fee
.map(|fee| {
output_sum
.checked_add(fee.raw())
.filter(|funding| *funding <= bitcoin::Amount::MAX_MONEY.to_sat())
.ok_or_else(invalid_transaction)
})
.transpose()?;
if !value.body.is_coinbase() {
let mut complete = true;
let mut input_sum = 0_u64;
for output in &value.previous_outputs {
if let Some(output) = output {
input_sum = input_sum
.checked_add(output.value.raw())
.ok_or_else(invalid_transaction)?;
} else {
complete = false;
}
}
if input_sum > bitcoin::Amount::MAX_MONEY.to_sat()
|| reported_funding.is_some_and(|funding| input_sum > funding)
|| (complete
&& (input_sum < output_sum
|| value
.reported_fee
.is_some_and(|reported| reported.raw() != input_sum - output_sum)))
{
return Err(invalid_transaction());
}
}
Ok(value)
}
#[must_use]
pub const fn network(&self) -> Network {
self.network
}
#[must_use]
pub const fn body(&self) -> &TransactionBody {
&self.body
}
#[must_use]
pub fn previous_outputs(&self) -> &[Option<PreviousOutput>] {
&self.previous_outputs
}
#[must_use]
pub const fn reported_fee(&self) -> Option<Satoshis> {
self.reported_fee
}
#[must_use]
pub fn fee_from_previous_outputs(&self) -> Option<Satoshis> {
if self.body.is_coinbase() {
return None;
}
let total = self
.previous_outputs
.iter()
.try_fold(0_u64, |sum, output| {
sum.checked_add(output.as_ref()?.value.raw())
})?;
let outputs = self
.body
.outputs()
.try_fold(0_u64, |sum, output| sum.checked_add(output.value().raw()))?;
total.checked_sub(outputs).map(Satoshis::new)
}
#[must_use]
pub const fn status(&self) -> TransactionStatus {
self.status
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct TransactionFields {
network: Network,
body: TransactionBody,
#[serde(deserialize_with = "deserialize_previous_outputs")]
previous_outputs: Vec<Option<PreviousOutput>>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
reported_fee: Option<Satoshis>,
status: TransactionStatus,
}
impl TryFrom<TransactionFields> for Transaction {
type Error = Error;
fn try_from(value: TransactionFields) -> Result<Self, Error> {
Self::new(
value.network,
value.body,
value.previous_outputs,
value.reported_fee,
value.status,
)
}
}
fn deserialize_previous_outputs<'de, D: Deserializer<'de>>(
deserializer: D,
) -> Result<Vec<Option<PreviousOutput>>, D::Error> {
deserialize_bounded_vec::<_, _, MAX_INPUTS>(deserializer)
}
pub(crate) fn deserialize_bounded_vec<
'de,
D: Deserializer<'de>,
T: Deserialize<'de>,
const MAX: usize,
>(
deserializer: D,
) -> Result<Vec<T>, D::Error> {
struct BoundedVisitor<T, const MAX: usize>(std::marker::PhantomData<T>);
impl<'de, T: Deserialize<'de>, const MAX: usize> Visitor<'de> for BoundedVisitor<T, MAX> {
type Value = Vec<T>;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("a bounded Bitcoin transaction collection")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut sequence: A) -> Result<Vec<T>, A::Error> {
let mut values = Vec::new();
while let Some(value) = sequence.next_element()? {
if values.len() == MAX {
return Err(serde::de::Error::custom(
ValidationError::InvalidBitcoinTransaction,
));
}
values.push(value);
}
Ok(values)
}
}
deserializer.deserialize_seq(BoundedVisitor::<T, MAX>(std::marker::PhantomData))
}