use crate::{AsyncBlockSourceResult, BlockData, BlockHeaderData, BlockSource, BlockSourceError, BlockSourceResult};
use bitcoin::hash_types::BlockHash;
use bitcoin::network::constants::Network;
use lightning::chain::BestBlock;
use std::ops::Deref;
pub trait Poll {
fn poll_chain_tip<'a>(&'a self, best_known_chain_tip: ValidatedBlockHeader) ->
AsyncBlockSourceResult<'a, ChainTip>;
fn look_up_previous_header<'a>(&'a self, header: &'a ValidatedBlockHeader) ->
AsyncBlockSourceResult<'a, ValidatedBlockHeader>;
fn fetch_block<'a>(&'a self, header: &'a ValidatedBlockHeader) ->
AsyncBlockSourceResult<'a, ValidatedBlock>;
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ChainTip {
Common,
Better(ValidatedBlockHeader),
Worse(ValidatedBlockHeader),
}
pub trait Validate: sealed::Validate {
type T: std::ops::Deref<Target = Self>;
fn validate(self, block_hash: BlockHash) -> BlockSourceResult<Self::T>;
}
impl Validate for BlockHeaderData {
type T = ValidatedBlockHeader;
fn validate(self, block_hash: BlockHash) -> BlockSourceResult<Self::T> {
let pow_valid_block_hash = self.header
.validate_pow(self.header.target())
.map_err(BlockSourceError::persistent)?;
if pow_valid_block_hash != block_hash {
return Err(BlockSourceError::persistent("invalid block hash"));
}
Ok(ValidatedBlockHeader { block_hash, inner: self })
}
}
impl Validate for BlockData {
type T = ValidatedBlock;
fn validate(self, block_hash: BlockHash) -> BlockSourceResult<Self::T> {
let header = match &self {
BlockData::FullBlock(block) => &block.header,
BlockData::HeaderOnly(header) => header,
};
let pow_valid_block_hash = header
.validate_pow(header.target())
.map_err(BlockSourceError::persistent)?;
if pow_valid_block_hash != block_hash {
return Err(BlockSourceError::persistent("invalid block hash"));
}
if let BlockData::FullBlock(block) = &self {
if !block.check_merkle_root() {
return Err(BlockSourceError::persistent("invalid merkle root"));
}
if !block.check_witness_commitment() {
return Err(BlockSourceError::persistent("invalid witness commitment"));
}
}
Ok(ValidatedBlock { block_hash, inner: self })
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ValidatedBlockHeader {
pub(crate) block_hash: BlockHash,
inner: BlockHeaderData,
}
impl std::ops::Deref for ValidatedBlockHeader {
type Target = BlockHeaderData;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl ValidatedBlockHeader {
fn check_builds_on(&self, previous_header: &ValidatedBlockHeader, network: Network) -> BlockSourceResult<()> {
if self.header.prev_blockhash != previous_header.block_hash {
return Err(BlockSourceError::persistent("invalid previous block hash"));
}
if self.height != previous_header.height + 1 {
return Err(BlockSourceError::persistent("invalid block height"));
}
let work = self.header.work();
if self.chainwork != previous_header.chainwork + work {
return Err(BlockSourceError::persistent("invalid chainwork"));
}
if let Network::Bitcoin = network {
if self.height % 2016 == 0 {
let target = self.header.target();
let previous_target = previous_header.header.target();
let min_target = previous_target.min_difficulty_transition_threshold();
let max_target = previous_target.max_difficulty_transition_threshold();
if target > max_target || target < min_target {
return Err(BlockSourceError::persistent("invalid difficulty transition"))
}
} else if self.header.bits != previous_header.header.bits {
return Err(BlockSourceError::persistent("invalid difficulty"))
}
}
Ok(())
}
pub fn to_best_block(&self) -> BestBlock {
BestBlock::new(self.block_hash, self.inner.height)
}
}
pub struct ValidatedBlock {
pub(crate) block_hash: BlockHash,
inner: BlockData,
}
impl std::ops::Deref for ValidatedBlock {
type Target = BlockData;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
mod sealed {
pub trait Validate {}
impl Validate for crate::BlockHeaderData {}
impl Validate for crate::BlockData {}
}
pub struct ChainPoller<B: Deref<Target=T> + Sized + Send + Sync, T: BlockSource + ?Sized> {
block_source: B,
network: Network,
}
impl<B: Deref<Target=T> + Sized + Send + Sync, T: BlockSource + ?Sized> ChainPoller<B, T> {
pub fn new(block_source: B, network: Network) -> Self {
Self { block_source, network }
}
}
impl<B: Deref<Target=T> + Sized + Send + Sync, T: BlockSource + ?Sized> Poll for ChainPoller<B, T> {
fn poll_chain_tip<'a>(&'a self, best_known_chain_tip: ValidatedBlockHeader) ->
AsyncBlockSourceResult<'a, ChainTip>
{
Box::pin(async move {
let (block_hash, height) = self.block_source.get_best_block().await?;
if block_hash == best_known_chain_tip.header.block_hash() {
return Ok(ChainTip::Common);
}
let chain_tip = self.block_source
.get_header(&block_hash, height).await?
.validate(block_hash)?;
if chain_tip.chainwork > best_known_chain_tip.chainwork {
Ok(ChainTip::Better(chain_tip))
} else {
Ok(ChainTip::Worse(chain_tip))
}
})
}
fn look_up_previous_header<'a>(&'a self, header: &'a ValidatedBlockHeader) ->
AsyncBlockSourceResult<'a, ValidatedBlockHeader>
{
Box::pin(async move {
if header.height == 0 {
return Err(BlockSourceError::persistent("genesis block reached"));
}
let previous_hash = &header.header.prev_blockhash;
let height = header.height - 1;
let previous_header = self.block_source
.get_header(previous_hash, Some(height)).await?
.validate(*previous_hash)?;
header.check_builds_on(&previous_header, self.network)?;
Ok(previous_header)
})
}
fn fetch_block<'a>(&'a self, header: &'a ValidatedBlockHeader) ->
AsyncBlockSourceResult<'a, ValidatedBlock>
{
Box::pin(async move {
self.block_source
.get_block(&header.block_hash).await?
.validate(header.block_hash)
})
}
}
#[cfg(test)]
mod tests {
use crate::*;
use crate::test_utils::Blockchain;
use super::*;
#[tokio::test]
async fn poll_empty_chain() {
let mut chain = Blockchain::default().with_height(0);
let best_known_chain_tip = chain.tip();
chain.disconnect_tip();
let poller = ChainPoller::new(&chain, Network::Bitcoin);
match poller.poll_chain_tip(best_known_chain_tip).await {
Err(e) => {
assert_eq!(e.kind(), BlockSourceErrorKind::Transient);
assert_eq!(e.into_inner().as_ref().to_string(), "empty chain");
},
Ok(_) => panic!("Expected error"),
}
}
#[tokio::test]
async fn poll_chain_without_headers() {
let chain = Blockchain::default().with_height(1).without_headers();
let best_known_chain_tip = chain.at_height(0);
let poller = ChainPoller::new(&chain, Network::Bitcoin);
match poller.poll_chain_tip(best_known_chain_tip).await {
Err(e) => {
assert_eq!(e.kind(), BlockSourceErrorKind::Persistent);
assert_eq!(e.into_inner().as_ref().to_string(), "header not found");
},
Ok(_) => panic!("Expected error"),
}
}
#[tokio::test]
async fn poll_chain_with_invalid_pow() {
let mut chain = Blockchain::default().with_height(1);
let best_known_chain_tip = chain.at_height(0);
chain.blocks.last_mut().unwrap().header.bits =
bitcoin::Target::from_be_bytes([0x01; 32]).to_compact_lossy();
let poller = ChainPoller::new(&chain, Network::Bitcoin);
match poller.poll_chain_tip(best_known_chain_tip).await {
Err(e) => {
assert_eq!(e.kind(), BlockSourceErrorKind::Persistent);
assert_eq!(e.into_inner().as_ref().to_string(), "block target correct but not attained");
},
Ok(_) => panic!("Expected error"),
}
}
#[tokio::test]
async fn poll_chain_with_malformed_headers() {
let chain = Blockchain::default().with_height(1).malformed_headers();
let best_known_chain_tip = chain.at_height(0);
let poller = ChainPoller::new(&chain, Network::Bitcoin);
match poller.poll_chain_tip(best_known_chain_tip).await {
Err(e) => {
assert_eq!(e.kind(), BlockSourceErrorKind::Persistent);
assert_eq!(e.into_inner().as_ref().to_string(), "invalid block hash");
},
Ok(_) => panic!("Expected error"),
}
}
#[tokio::test]
async fn poll_chain_with_common_tip() {
let chain = Blockchain::default().with_height(0);
let best_known_chain_tip = chain.tip();
let poller = ChainPoller::new(&chain, Network::Bitcoin);
match poller.poll_chain_tip(best_known_chain_tip).await {
Err(e) => panic!("Unexpected error: {:?}", e),
Ok(tip) => assert_eq!(tip, ChainTip::Common),
}
}
#[tokio::test]
async fn poll_chain_with_uncommon_tip_but_equal_chainwork() {
let mut chain = Blockchain::default().with_height(1);
let best_known_chain_tip = chain.tip();
chain.blocks.last_mut().unwrap().header.nonce += 1;
let worse_chain_tip = chain.tip();
assert_eq!(best_known_chain_tip.chainwork, worse_chain_tip.chainwork);
let poller = ChainPoller::new(&chain, Network::Bitcoin);
match poller.poll_chain_tip(best_known_chain_tip).await {
Err(e) => panic!("Unexpected error: {:?}", e),
Ok(tip) => assert_eq!(tip, ChainTip::Worse(worse_chain_tip)),
}
}
#[tokio::test]
async fn poll_chain_with_worse_tip() {
let mut chain = Blockchain::default().with_height(1);
let best_known_chain_tip = chain.tip();
chain.disconnect_tip();
let worse_chain_tip = chain.tip();
let poller = ChainPoller::new(&chain, Network::Bitcoin);
match poller.poll_chain_tip(best_known_chain_tip).await {
Err(e) => panic!("Unexpected error: {:?}", e),
Ok(tip) => assert_eq!(tip, ChainTip::Worse(worse_chain_tip)),
}
}
#[tokio::test]
async fn poll_chain_with_better_tip() {
let chain = Blockchain::default().with_height(1);
let best_known_chain_tip = chain.at_height(0);
let better_chain_tip = chain.tip();
let poller = ChainPoller::new(&chain, Network::Bitcoin);
match poller.poll_chain_tip(best_known_chain_tip).await {
Err(e) => panic!("Unexpected error: {:?}", e),
Ok(tip) => assert_eq!(tip, ChainTip::Better(better_chain_tip)),
}
}
}