use super::{
AddressPolicy, AtomicAmount, BlockHash, Bytes, MAXIMUM_ITEMS, MempoolDelta, SourceText, Txid,
bounded_vec, invalid,
};
use crate::error::Error;
use serde::{Deserialize, Serialize};
use std::collections::BTreeSet;
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, bound(deserialize = "A: AddressPolicy"))]
pub struct BalanceData<A: AddressPolicy> {
pub total_received: AtomicAmount<A>,
pub total_sent: AtomicAmount<A>,
pub confirmed: AtomicAmount<A>,
pub unconfirmed: MempoolDelta<A>,
pub final_balance: AtomicAmount<A>,
pub confirmed_transactions: u64,
pub unconfirmed_transactions: u64,
pub final_transactions: u64,
}
impl<A: AddressPolicy> BalanceData<A> {
pub(crate) fn validate(&self) -> Result<(), Error> {
if self.total_received.raw().checked_sub(self.total_sent.raw())
!= Some(self.confirmed.raw())
|| i128::from(self.confirmed.raw()).checked_add(self.unconfirmed.raw())
!= Some(i128::from(self.final_balance.raw()))
|| self
.confirmed_transactions
.checked_add(self.unconfirmed_transactions)
!= Some(self.final_transactions)
{
return Err(invalid());
}
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "BalanceFields<A>", bound(deserialize = "A: AddressPolicy"))]
pub struct AddressBalance<A: AddressPolicy> {
address: A,
data: BalanceData<A>,
}
impl<A: AddressPolicy> AddressBalance<A> {
pub fn new(address: A, data: BalanceData<A>) -> Result<Self, Error> {
data.validate()?;
Ok(Self { address, data })
}
#[must_use]
pub const fn address(&self) -> &A {
&self.address
}
#[must_use]
pub const fn data(&self) -> &BalanceData<A> {
&self.data
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields, bound(deserialize = "A: AddressPolicy"))]
struct BalanceFields<A: AddressPolicy> {
address: A,
data: BalanceData<A>,
}
impl<A: AddressPolicy> TryFrom<BalanceFields<A>> for AddressBalance<A> {
type Error = Error;
fn try_from(v: BalanceFields<A>) -> Result<Self, Error> {
Self::new(v.address, v.data)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, bound(deserialize = "A: AddressPolicy"))]
pub struct FeeEstimates<A: AddressPolicy> {
pub high_per_kilobyte: AtomicAmount<A>,
pub medium_per_kilobyte: AtomicAmount<A>,
pub low_per_kilobyte: AtomicAmount<A>,
pub tip_height: u64,
pub tip_hash: BlockHash,
pub updated_at: Option<SourceText>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "HistoryRequestFields")]
pub struct HistoryRequest {
before_height: Option<u64>,
minimum_entries: u16,
maximum_entries: u32,
}
impl HistoryRequest {
pub fn new(
before_height: Option<u64>,
minimum_entries: u16,
maximum_entries: u32,
) -> Result<Self, Error> {
if minimum_entries == 0
|| minimum_entries > 2000
|| maximum_entries < u32::from(minimum_entries)
|| maximum_entries > 100_000
|| before_height.is_some_and(|h| h > i64::MAX.cast_unsigned())
{
return Err(invalid());
}
Ok(Self {
before_height,
minimum_entries,
maximum_entries,
})
}
#[must_use]
pub const fn before_height(self) -> Option<u64> {
self.before_height
}
#[must_use]
pub const fn minimum_entries(self) -> u16 {
self.minimum_entries
}
#[must_use]
pub const fn maximum_entries(self) -> u32 {
self.maximum_entries
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct HistoryRequestFields {
before_height: Option<u64>,
minimum_entries: u16,
maximum_entries: u32,
}
impl TryFrom<HistoryRequestFields> for HistoryRequest {
type Error = Error;
fn try_from(v: HistoryRequestFields) -> Result<Self, Error> {
Self::new(v.before_height, v.minimum_entries, v.maximum_entries)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReferenceInclusion {
pub height: u64,
pub block_hash: Option<BlockHash>,
pub transaction_index: Option<u32>,
pub confirmed_at: Option<SourceText>,
}
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum ReferenceDirection {
Input {
index: u32,
},
Output {
index: u32,
},
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, bound(deserialize = "A: AddressPolicy"))]
pub struct TransactionReference<A: AddressPolicy> {
pub txid: Txid,
pub direction: ReferenceDirection,
pub value: AtomicAmount<A>,
pub inclusion: Option<ReferenceInclusion>,
pub confirmations: u64,
pub balance_at_reference: Option<AtomicAmount<A>>,
pub spent: Option<bool>,
pub spent_by: Option<Txid>,
pub double_spend: bool,
pub double_spend_transaction: Option<Txid>,
pub script: Option<Bytes>,
}
impl<A: AddressPolicy> TransactionReference<A> {
fn validate(&self) -> Result<(), Error> {
if self.value.raw() > A::TRANSACTION_MAXIMUM
|| (self.inclusion.is_some() != (self.confirmations > 0))
|| self.spent == Some(false) && self.spent_by.is_some()
{
return Err(invalid());
}
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "HistoryFields<A>", bound(deserialize = "A: AddressPolicy"))]
pub struct HistoryPage<A: AddressPolicy> {
address: A,
request: HistoryRequest,
balance: BalanceData<A>,
confirmed: Vec<TransactionReference<A>>,
unconfirmed: Vec<TransactionReference<A>>,
has_more: Option<bool>,
}
impl<A: AddressPolicy> HistoryPage<A> {
pub fn new(
address: A,
request: HistoryRequest,
balance: BalanceData<A>,
confirmed: Vec<TransactionReference<A>>,
unconfirmed: Vec<TransactionReference<A>>,
has_more: Option<bool>,
) -> Result<Self, Error> {
balance.validate()?;
let length = confirmed
.len()
.checked_add(unconfirmed.len())
.ok_or_else(invalid)?;
if length > request.maximum_entries as usize {
return Err(invalid());
}
let mut identities = BTreeSet::new();
let mut previous_height = None;
for entry in &confirmed {
entry.validate()?;
let height = entry.inclusion.as_ref().ok_or_else(invalid)?.height;
if previous_height.is_some_and(|last| height > last)
|| request.before_height.is_some_and(|before| height >= before)
|| !identities.insert((entry.txid, entry.direction))
{
return Err(invalid());
}
previous_height = Some(height);
}
for entry in &unconfirmed {
entry.validate()?;
if entry.inclusion.is_some() || !identities.insert((entry.txid, entry.direction)) {
return Err(invalid());
}
}
if has_more == Some(true) && (previous_height.is_none() || previous_height == Some(0)) {
return Err(invalid());
}
Ok(Self {
address,
request,
balance,
confirmed,
unconfirmed,
has_more,
})
}
#[must_use]
pub const fn address(&self) -> &A {
&self.address
}
#[must_use]
pub const fn request(&self) -> HistoryRequest {
self.request
}
#[must_use]
pub const fn balance(&self) -> &BalanceData<A> {
&self.balance
}
#[must_use]
pub fn confirmed(&self) -> &[TransactionReference<A>] {
&self.confirmed
}
#[must_use]
pub fn unconfirmed(&self) -> &[TransactionReference<A>] {
&self.unconfirmed
}
#[must_use]
pub const fn has_more(&self) -> Option<bool> {
self.has_more
}
#[must_use]
pub fn next_before_height(&self) -> Option<u64> {
if self.has_more == Some(true) {
self.confirmed.last()?.inclusion.as_ref().map(|v| v.height)
} else {
None
}
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields, bound(deserialize = "A: AddressPolicy"))]
struct HistoryFields<A: AddressPolicy> {
address: A,
request: HistoryRequest,
balance: BalanceData<A>,
#[serde(deserialize_with = "bounded_vec")]
confirmed: Vec<TransactionReference<A>>,
#[serde(deserialize_with = "bounded_vec")]
unconfirmed: Vec<TransactionReference<A>>,
has_more: Option<bool>,
}
impl<A: AddressPolicy> TryFrom<HistoryFields<A>> for HistoryPage<A> {
type Error = Error;
fn try_from(v: HistoryFields<A>) -> Result<Self, Error> {
Self::new(
v.address,
v.request,
v.balance,
v.confirmed,
v.unconfirmed,
v.has_more,
)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "StatusFields")]
pub struct TransactionStatus {
txid: Txid,
inclusion: Option<ReferenceInclusion>,
confirmations: u64,
double_spend: bool,
double_spend_transaction: Option<Txid>,
}
impl TransactionStatus {
pub fn new(
txid: Txid,
inclusion: Option<ReferenceInclusion>,
confirmations: u64,
double_spend: bool,
double_spend_transaction: Option<Txid>,
) -> Result<Self, Error> {
if inclusion.is_some() != (confirmations > 0) {
return Err(invalid());
}
Ok(Self {
txid,
inclusion,
confirmations,
double_spend,
double_spend_transaction,
})
}
#[must_use]
pub const fn txid(&self) -> Txid {
self.txid
}
#[must_use]
pub const fn inclusion(&self) -> Option<&ReferenceInclusion> {
self.inclusion.as_ref()
}
#[must_use]
pub const fn confirmations(&self) -> u64 {
self.confirmations
}
#[must_use]
pub const fn double_spend(&self) -> bool {
self.double_spend
}
#[must_use]
pub const fn double_spend_transaction(&self) -> Option<Txid> {
self.double_spend_transaction
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct StatusFields {
txid: Txid,
inclusion: Option<ReferenceInclusion>,
confirmations: u64,
double_spend: bool,
double_spend_transaction: Option<Txid>,
}
impl TryFrom<StatusFields> for TransactionStatus {
type Error = Error;
fn try_from(v: StatusFields) -> Result<Self, Error> {
Self::new(
v.txid,
v.inclusion,
v.confirmations,
v.double_spend,
v.double_spend_transaction,
)
}
}
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct OutPoint {
pub txid: Txid,
pub output_index: u32,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CoinbaseSource {
ExplicitSentinel,
OmittedPrevoutFields,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, bound(deserialize = "A: AddressPolicy"))]
pub struct TransactionInput<A: AddressPolicy> {
pub previous_output: Option<OutPoint>,
pub coinbase_source: Option<CoinbaseSource>,
pub previous_output_value: Option<AtomicAmount<A>>,
pub sequence: Option<u32>,
pub script: Option<Bytes>,
#[serde(default, deserialize_with = "super::bounded_optional_witness")]
pub witness: Option<Vec<Bytes>>,
#[serde(default, deserialize_with = "super::bounded_optional_addresses")]
pub addresses: Option<Vec<A>>,
pub script_type: Option<SourceText>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, bound(deserialize = "A: AddressPolicy"))]
pub struct TransactionOutput<A: AddressPolicy> {
pub value: AtomicAmount<A>,
pub script: Bytes,
#[serde(default, deserialize_with = "super::bounded_optional_addresses")]
pub addresses: Option<Vec<A>>,
pub spent_by: Option<Txid>,
pub script_type: Option<SourceText>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, bound(deserialize = "A: AddressPolicy"))]
pub struct TransactionData<A: AddressPolicy> {
pub status: TransactionStatus,
pub version: i32,
pub lock_time: Option<u32>,
pub size: u32,
pub virtual_size: Option<u32>,
pub total_output: AtomicAmount<A>,
pub reported_fee: Option<AtomicAmount<A>>,
#[serde(deserialize_with = "bounded_vec")]
pub inputs: Vec<TransactionInput<A>>,
#[serde(deserialize_with = "bounded_vec")]
pub outputs: Vec<TransactionOutput<A>>,
pub raw: Option<Bytes>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(
try_from = "TransactionFields<A>",
bound(deserialize = "A: AddressPolicy")
)]
pub struct Transaction<A: AddressPolicy> {
network: A::Network,
data: TransactionData<A>,
}
impl<A: AddressPolicy> Transaction<A> {
pub fn new(network: A::Network, data: TransactionData<A>) -> Result<Self, Error> {
if data.inputs.is_empty()
|| data.outputs.is_empty()
|| data.inputs.len() > MAXIMUM_ITEMS
|| data.outputs.len() > MAXIMUM_ITEMS
|| data.size == 0
|| data.virtual_size.is_some_and(|v| v == 0 || v > data.size)
|| data
.raw
.as_ref()
.is_some_and(|b| b.as_slice().len() != data.size as usize)
{
return Err(invalid());
}
let mut total_output = 0_u64;
for output in &data.outputs {
total_output = total_output
.checked_add(output.value.raw())
.ok_or_else(invalid)?;
if total_output > A::TRANSACTION_MAXIMUM {
return Err(invalid());
}
validate_addresses(output.addresses.as_deref(), network)?;
}
if total_output != data.total_output.raw()
|| data
.reported_fee
.as_ref()
.is_some_and(|fee| fee.raw() > A::TRANSACTION_MAXIMUM)
{
return Err(invalid());
}
let coinbase = data.inputs[0].previous_output.is_none();
let mut known_input_sum = 0_u64;
let mut complete_inputs = true;
let mut outpoints = BTreeSet::new();
for input in &data.inputs {
if input.previous_output.is_none() != input.coinbase_source.is_some() {
return Err(invalid());
}
if input.previous_output.is_none()
&& (!coinbase || data.inputs.len() != 1 || input.previous_output_value.is_some())
{
return Err(invalid());
}
if let Some(outpoint) = input.previous_output
&& ((!outpoints.insert(outpoint))
|| outpoint.txid.display_bytes() == &[0; 32]
&& outpoint.output_index == u32::MAX)
{
return Err(invalid());
}
if let Some(value) = &input.previous_output_value {
if value.raw() > A::TRANSACTION_MAXIMUM {
return Err(invalid());
}
known_input_sum = known_input_sum
.checked_add(value.raw())
.ok_or_else(invalid)?;
if known_input_sum > A::TRANSACTION_MAXIMUM {
return Err(invalid());
}
} else {
complete_inputs = false;
}
validate_addresses(input.addresses.as_deref(), network)?;
if let Some(witness) = &input.witness {
if witness.len() > 10_000 || !A::SUPPORTS_WITNESS && !witness.is_empty() {
return Err(invalid());
}
let sum = witness
.iter()
.try_fold(0_usize, |s, b| s.checked_add(b.as_slice().len()))
.ok_or_else(invalid)?;
if sum > Bytes::MAXIMUM_BYTES {
return Err(invalid());
}
}
}
if coinbase {
if data.reported_fee.as_ref().is_some_and(|fee| fee.raw() != 0) {
return Err(invalid());
}
} else if let Some(fee) = &data.reported_fee {
let implied_inputs = total_output.checked_add(fee.raw()).ok_or_else(invalid)?;
if implied_inputs > A::TRANSACTION_MAXIMUM
|| known_input_sum > implied_inputs
|| complete_inputs && known_input_sum != implied_inputs
{
return Err(invalid());
}
} else if complete_inputs && known_input_sum < total_output {
return Err(invalid());
}
Ok(Self { network, data })
}
#[must_use]
pub const fn network(&self) -> A::Network {
self.network
}
#[must_use]
pub const fn data(&self) -> &TransactionData<A> {
&self.data
}
#[must_use]
pub fn derived_fee(&self) -> Option<AtomicAmount<A>> {
self.data.inputs[0].previous_output?;
let inputs = self.data.inputs.iter().try_fold(0_u64, |sum, input| {
sum.checked_add(input.previous_output_value.as_ref()?.raw())
})?;
Some(AtomicAmount::new(
inputs.checked_sub(self.data.total_output.raw())?,
))
}
}
fn validate_addresses<A: AddressPolicy>(
addresses: Option<&[A]>,
network: A::Network,
) -> Result<(), Error> {
if let Some(addresses) = addresses {
if addresses.len() > 100 || addresses.iter().any(|a| a.network() != network) {
return Err(invalid());
}
for (index, address) in addresses.iter().enumerate() {
if addresses[..index].contains(address) {
return Err(invalid());
}
}
}
Ok(())
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields, bound(deserialize = "A: AddressPolicy"))]
struct TransactionFields<A: AddressPolicy> {
network: A::Network,
data: TransactionData<A>,
}
impl<A: AddressPolicy> TryFrom<TransactionFields<A>> for Transaction<A> {
type Error = Error;
fn try_from(v: TransactionFields<A>) -> Result<Self, Error> {
Self::new(v.network, v.data)
}
}