use super::{
Address, AddressNamespace, BlockHash, BlockHeader, CollectionLimit, Satoshis, TokenData, Txid,
identity::sha256d_display,
records::{MAX_ENTRIES, MAX_MONEY, bounded_entries},
};
use crate::error::{Error, ValidationError};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::{collections::HashSet, fmt};
fn optional_addresses<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Vec<Address>>, D::Error> {
#[derive(Deserialize)]
struct Addresses(#[serde(deserialize_with = "super::records::bounded_addresses")] Vec<Address>);
let values = Option::<Addresses>::deserialize(d)?.map(|v| v.0);
if values.as_ref().is_some_and(|v| v.len() > 100) {
return Err(serde::de::Error::custom("address collection exceeds limit"));
}
Ok(values)
}
#[derive(Clone, Eq, PartialEq)]
pub struct Bytes(Vec<u8>);
impl Bytes {
pub const MAX_BYTES: usize = 1024 * 1024;
pub fn new(value: Vec<u8>) -> Result<Self, Error> {
if value.len() > Self::MAX_BYTES {
return Err(ValidationError::InvalidBitcoinCashBytes.into());
}
Ok(Self(value))
}
pub fn from_hex(value: &str) -> Result<Self, Error> {
if value.len() > 2 * Self::MAX_BYTES
|| !value.len().is_multiple_of(2)
|| value.starts_with("0x")
{
return Err(ValidationError::InvalidBitcoinCashBytes.into());
}
Self::new(
const_hex::decode(value)
.map_err(|_| Error::Validation(ValidationError::InvalidBitcoinCashBytes))?,
)
}
#[must_use]
pub fn as_slice(&self) -> &[u8] {
&self.0
}
#[must_use]
pub fn hex(&self) -> String {
const_hex::encode(&self.0)
}
}
impl fmt::Debug for Bytes {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Bytes")
.field("length", &self.0.len())
.finish()
}
}
impl Serialize for Bytes {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(&self.hex())
}
}
impl<'de> Deserialize<'de> for Bytes {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
Self::from_hex(&String::deserialize(d)?).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Eq, PartialEq)]
pub struct SourceText(String);
impl SourceText {
pub fn new(value: impl Into<String>) -> Result<Self, Error> {
let value = value.into();
if value.is_empty() || value.len() > 128 || value.chars().any(char::is_control) {
return Err(super::invalid());
}
Ok(Self(value))
}
#[must_use]
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Debug for SourceText {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SourceText")
.field("length", &self.0.len())
.finish()
}
}
impl Serialize for SourceText {
fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(&self.0)
}
}
impl<'de> Deserialize<'de> for SourceText {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
Self::new(String::deserialize(d)?).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "RawFields")]
pub struct RawTransaction {
bytes: Bytes,
txid: Txid,
}
impl RawTransaction {
pub fn new(bytes: Bytes) -> Result<Self, Error> {
if bytes.as_slice().is_empty() {
return Err(super::invalid());
}
let txid = Txid::from_display_bytes(sha256d_display(bytes.as_slice()));
Ok(Self { bytes, txid })
}
#[must_use]
pub const fn bytes(&self) -> &Bytes {
&self.bytes
}
#[must_use]
pub const fn txid(&self) -> Txid {
self.txid
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct RawFields {
bytes: Bytes,
txid: Txid,
}
impl TryFrom<RawFields> for RawTransaction {
type Error = Error;
fn try_from(v: RawFields) -> Result<Self, Error> {
let result = Self::new(v.bytes)?;
if result.txid != v.txid {
return Err(super::invalid());
}
Ok(result)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum SourceHeight {
Unknown,
Zero,
Positive {
height: u32,
},
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "InclusionFields")]
pub struct SourceInclusion {
height: u32,
block_hash: BlockHash,
header: BlockHeader,
}
impl SourceInclusion {
pub fn new(height: u32, block_hash: BlockHash, header: BlockHeader) -> Result<Self, Error> {
if height == 0 || header.hash() != block_hash {
return Err(super::invalid());
}
Ok(Self {
height,
block_hash,
header,
})
}
#[must_use]
pub const fn height(&self) -> u32 {
self.height
}
#[must_use]
pub const fn block_hash(&self) -> BlockHash {
self.block_hash
}
#[must_use]
pub const fn header(&self) -> &BlockHeader {
&self.header
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct InclusionFields {
height: u32,
block_hash: BlockHash,
header: BlockHeader,
}
impl TryFrom<InclusionFields> for SourceInclusion {
type Error = Error;
fn try_from(v: InclusionFields) -> Result<Self, Error> {
Self::new(v.height, v.block_hash, v.header)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "StatusFields")]
pub struct TransactionStatus {
txid: Txid,
source_height: SourceHeight,
inclusion: Option<SourceInclusion>,
}
impl TransactionStatus {
pub fn new(
txid: Txid,
source_height: SourceHeight,
inclusion: Option<SourceInclusion>,
) -> Result<Self, Error> {
match source_height {
SourceHeight::Positive { height }
if height == 0 || inclusion.as_ref().is_none_or(|v| v.height() != height) =>
{
return Err(super::invalid());
}
SourceHeight::Unknown | SourceHeight::Zero if inclusion.is_some() => {
return Err(super::invalid());
}
_ => {}
}
Ok(Self {
txid,
source_height,
inclusion,
})
}
#[must_use]
pub const fn txid(&self) -> Txid {
self.txid
}
#[must_use]
pub const fn source_height(&self) -> SourceHeight {
self.source_height
}
#[must_use]
pub const fn inclusion(&self) -> Option<&SourceInclusion> {
self.inclusion.as_ref()
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct StatusFields {
txid: Txid,
source_height: SourceHeight,
inclusion: Option<SourceInclusion>,
}
impl TryFrom<StatusFields> for TransactionStatus {
type Error = Error;
fn try_from(v: StatusFields) -> Result<Self, Error> {
Self::new(v.txid, v.source_height, v.inclusion)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum TransactionInput {
Coinbase {
unlocking_bytes: Bytes,
sequence: u32,
},
Ordinary {
previous_txid: Txid,
output_index: u32,
unlocking_bytes: Bytes,
sequence: u32,
},
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TransactionOutput {
pub index: u32,
pub value: Satoshis,
pub locking_bytes: Bytes,
pub script_type: SourceText,
#[serde(default, deserialize_with = "optional_addresses")]
pub addresses: Option<Vec<Address>>,
pub required_signatures: Option<u32>,
pub token_data: Option<TokenData>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TransactionData {
pub namespace: AddressNamespace,
pub raw: RawTransaction,
pub reported_txid: Txid,
pub reported_hash: Option<Txid>,
pub version: i32,
pub lock_time: u32,
pub size: u32,
#[serde(deserialize_with = "bounded_entries")]
pub inputs: Vec<TransactionInput>,
#[serde(deserialize_with = "bounded_entries")]
pub outputs: Vec<TransactionOutput>,
pub reported_confirmations: Option<u32>,
pub reported_block_time: Option<u64>,
pub reported_block_hash: Option<BlockHash>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "TransactionFields")]
pub struct Transaction {
query_txid: Txid,
limit: CollectionLimit,
data: TransactionData,
status: TransactionStatus,
}
impl Transaction {
pub fn new(
query_txid: Txid,
limit: CollectionLimit,
data: TransactionData,
status: TransactionStatus,
) -> Result<Self, Error> {
if data.raw.txid() != query_txid
|| data.reported_txid != query_txid
|| data.reported_hash.is_some_and(|v| v != query_txid)
|| status.txid() != query_txid
|| data.size as usize != data.raw.bytes().as_slice().len()
|| data.inputs.is_empty()
|| data.outputs.is_empty()
|| data.inputs.len() > limit.get() as usize
|| data.outputs.len() > limit.get() as usize
|| data.inputs.len() > MAX_ENTRIES
|| data.outputs.len() > MAX_ENTRIES
{
return Err(super::invalid());
}
let mut outpoints = HashSet::new();
for input in &data.inputs {
match input {
TransactionInput::Coinbase { .. } if data.inputs.len() != 1 => {
return Err(super::invalid());
}
TransactionInput::Ordinary {
previous_txid,
output_index,
..
} if !outpoints.insert((*previous_txid, *output_index))
|| previous_txid.display_bytes() == [0; 32] && *output_index == u32::MAX =>
{
return Err(super::invalid());
}
TransactionInput::Coinbase { .. } | TransactionInput::Ordinary { .. } => {}
}
}
let mut total = 0_u64;
for (position, output) in data.outputs.iter().enumerate() {
total = total
.checked_add(output.value.raw())
.ok_or_else(super::invalid)?;
if output.index as usize != position
|| total > MAX_MONEY
|| output.addresses.as_ref().is_some_and(|values| {
values.len() > 100 || values.iter().any(|v| v.namespace() != data.namespace)
})
{
return Err(super::invalid());
}
}
if let Some(inclusion) = status.inclusion() {
if data
.reported_block_hash
.is_some_and(|v| v != inclusion.block_hash())
|| data.reported_confirmations == Some(0)
{
return Err(super::invalid());
}
} else if data.reported_block_hash.is_some()
|| data.reported_block_time.is_some()
|| data.reported_confirmations.is_some_and(|v| v > 0)
{
return Err(super::invalid());
}
Ok(Self {
query_txid,
limit,
data,
status,
})
}
#[must_use]
pub const fn txid(&self) -> Txid {
self.query_txid
}
#[must_use]
pub const fn data(&self) -> &TransactionData {
&self.data
}
#[must_use]
pub const fn status(&self) -> &TransactionStatus {
&self.status
}
#[must_use]
pub const fn limit(&self) -> CollectionLimit {
self.limit
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct TransactionFields {
query_txid: Txid,
limit: CollectionLimit,
data: TransactionData,
status: TransactionStatus,
}
impl TryFrom<TransactionFields> for Transaction {
type Error = Error;
fn try_from(v: TransactionFields) -> Result<Self, Error> {
Self::new(v.query_txid, v.limit, v.data, v.status)
}
}