108 lines
3.5 KiB
Rust
108 lines
3.5 KiB
Rust
// Copyright 2019-2023 Parity Technologies (UK) Ltd.
|
|
// This file is part of Parity Bridges Common.
|
|
|
|
// Parity Bridges Common is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// Parity Bridges Common is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Parity Bridges Common. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
//! Types and functions intended to ease adding of new Bizinikiwi -> Bizinikiwi
|
|
//! finality pipelines.
|
|
|
|
pub mod engine;
|
|
|
|
use crate::finality_base::engine::Engine;
|
|
|
|
use async_trait::async_trait;
|
|
use codec::Decode;
|
|
use futures::{stream::unfold, Stream, StreamExt};
|
|
use pezbp_runtime::{HashOf, HeaderIdOf};
|
|
use relay_bizinikiwi_client::{Chain, Client, Error};
|
|
use std::{fmt::Debug, pin::Pin};
|
|
|
|
/// Bizinikiwi -> Bizinikiwi finality related pipeline.
|
|
#[async_trait]
|
|
pub trait BizinikiwiFinalityPipeline: 'static + Clone + Debug + Send + Sync {
|
|
/// Headers of this chain are submitted to the `TargetChain`.
|
|
type SourceChain: Chain;
|
|
/// Headers of the `SourceChain` are submitted to this chain.
|
|
type TargetChain: Chain;
|
|
/// Finality engine.
|
|
type FinalityEngine: Engine<Self::SourceChain>;
|
|
}
|
|
|
|
/// Bizinikiwi finality proof. Specific to the used `FinalityEngine`.
|
|
pub type BizinikiwiFinalityProof<P> =
|
|
<<P as BizinikiwiFinalityPipeline>::FinalityEngine as Engine<
|
|
<P as BizinikiwiFinalityPipeline>::SourceChain,
|
|
>>::FinalityProof;
|
|
|
|
/// Bizinikiwi finality proofs stream.
|
|
pub type BizinikiwiFinalityProofsStream<P> =
|
|
Pin<Box<dyn Stream<Item = BizinikiwiFinalityProof<P>> + Send>>;
|
|
|
|
/// Subscribe to new finality proofs.
|
|
pub async fn finality_proofs<P: BizinikiwiFinalityPipeline>(
|
|
client: &impl Client<P::SourceChain>,
|
|
) -> Result<BizinikiwiFinalityProofsStream<P>, Error> {
|
|
Ok(unfold(
|
|
P::FinalityEngine::source_finality_proofs(client).await?,
|
|
move |mut subscription| async move {
|
|
loop {
|
|
let log_error = |err| {
|
|
tracing::error!(
|
|
target: "bridge",
|
|
error=?err,
|
|
source=%P::SourceChain::NAME,
|
|
"Failed to read justification target from the justifications stream"
|
|
);
|
|
};
|
|
|
|
let next_justification = subscription.next().await?;
|
|
|
|
let decoded_justification =
|
|
<P::FinalityEngine as Engine<P::SourceChain>>::FinalityProof::decode(
|
|
&mut &next_justification[..],
|
|
);
|
|
|
|
let justification = match decoded_justification {
|
|
Ok(j) => j,
|
|
Err(err) => {
|
|
log_error(format!("decode failed with error {err:?}"));
|
|
continue;
|
|
},
|
|
};
|
|
|
|
return Some((justification, subscription));
|
|
}
|
|
},
|
|
)
|
|
.boxed())
|
|
}
|
|
|
|
/// Get the id of the best `SourceChain` header known to the `TargetChain` at the provided
|
|
/// target block using the exposed runtime API method.
|
|
///
|
|
/// The runtime API method should be `<TargetChain>FinalityApi::best_finalized()`.
|
|
pub async fn best_synced_header_id<SourceChain, TargetChain>(
|
|
target_client: &impl Client<TargetChain>,
|
|
at: HashOf<TargetChain>,
|
|
) -> Result<Option<HeaderIdOf<SourceChain>>, Error>
|
|
where
|
|
SourceChain: Chain,
|
|
TargetChain: Chain,
|
|
{
|
|
// now let's read id of best finalized peer header at our best finalized block
|
|
target_client
|
|
.state_call(at, SourceChain::BEST_FINALIZED_HEADER_ID_METHOD.into(), ())
|
|
.await
|
|
}
|