WIP: feat: bitcoin elections

Cargo.toml

@@ -129,6 +129,7 @@ reqwest = { version = "0.11.4" }
 rlp = { version = "0.5.2", default-features = false }
 rocksdb = { version = "0.21.0" }
 serde_bytes = { version = "0.11.14", default-features = false }
+serde-big-array = "0.5.1"
 serde_path_to_error = "*"
 serde_with = { version = "3.11.0", default-features = false }
 scale-decode = { version = "0.13" }

api/bin/chainflip-ingress-egress-tracker/src/witnessing/btc.rs

@@ -52,7 +52,7 @@ where
 			move |header| {
 				let btc_client = btc_client.clone();
 				async move {
-					let block = btc_client.block(header.hash).await;
+					let block = btc_client.block(header.hash).await.expect("TODO: Delete this");
 					(header.data, block.txdata)
 				}
 			}

api/bin/chainflip-ingress-egress-tracker/src/witnessing/state_chain.rs

@@ -370,7 +370,8 @@ where
 		Swapping(_) |
 		LiquidityProvider(_) |
 		LiquidityPools(_) |
-		SolanaElections(_) => {},
+		SolanaElections(_) |
+		BitcoinElections(_) => {},
 	};
 
 	Ok(())

engine/src/btc/retry_rpc.rs

@@ -51,7 +51,7 @@ impl BtcRetryRpcClient {
 
 #[async_trait::async_trait]
 pub trait BtcRetryRpcApi: Clone {
-	async fn block(&self, block_hash: BlockHash) -> VerboseBlock;
+	async fn block(&self, block_hash: BlockHash) -> anyhow::Result<VerboseBlock>;
 
 	async fn block_hash(&self, block_number: cf_chains::btc::BlockNumber) -> BlockHash;
 
@@ -61,19 +61,25 @@ pub trait BtcRetryRpcApi: Clone {
 
 	async fn average_block_fee_rate(&self, block_hash: BlockHash) -> cf_chains::btc::BtcAmount;
 
-	async fn best_block_header(&self) -> BlockHeader;
+	async fn best_block_header(&self) -> anyhow::Result<BlockHeader>;
+
+	async fn block_header(
+		&self,
+		block_number: cf_chains::btc::BlockNumber,
+	) -> anyhow::Result<BlockHeader>;
 }
 
 #[async_trait::async_trait]
 impl BtcRetryRpcApi for BtcRetryRpcClient {
-	async fn block(&self, block_hash: BlockHash) -> VerboseBlock {
+	async fn block(&self, block_hash: BlockHash) -> anyhow::Result<VerboseBlock> {
 		self.retry_client
-			.request(
+			.request_with_limit(
 				RequestLog::new("block".to_string(), Some(format!("{block_hash}"))),
 				Box::pin(move |client| {
 					#[allow(clippy::redundant_async_block)]
 					Box::pin(async move { client.block(block_hash).await })
 				}),
+				2,
 			)
 			.await
 	}
@@ -134,9 +140,9 @@ impl BtcRetryRpcApi for BtcRetryRpcClient {
 			.await
 	}
 
-	async fn best_block_header(&self) -> BlockHeader {
+	async fn best_block_header(&self) -> anyhow::Result<BlockHeader> {
 		self.retry_client
-			.request(
+			.request_with_limit(
 				RequestLog::new("best_block_header".to_string(), None),
 				Box::pin(move |client| {
 					#[allow(clippy::redundant_async_block)]
@@ -147,6 +153,28 @@ impl BtcRetryRpcApi for BtcRetryRpcClient {
 						Ok(header)
 					})
 				}),
+				2,
+			)
+			.await
+	}
+
+	async fn block_header(
+		&self,
+		block_number: cf_chains::btc::BlockNumber,
+	) -> anyhow::Result<BlockHeader> {
+		self.retry_client
+			.request_with_limit(
+				RequestLog::new("block_header".to_string(), Some(block_number.to_string())),
+				Box::pin(move |client| {
+					#[allow(clippy::redundant_async_block)]
+					Box::pin(async move {
+						let block_hash = client.block_hash(block_number).await?;
+						let header = client.block_header(block_hash).await?;
+						assert_eq!(header.hash, block_hash);
+						Ok(header)
+					})
+				}),
+				2,
 			)
 			.await
 	}
@@ -200,7 +228,7 @@ pub mod mocks {
 
 		#[async_trait::async_trait]
 		impl BtcRetryRpcApi for BtcRetryRpcClient {
-			async fn block(&self, block_hash: BlockHash) -> VerboseBlock;
+			async fn block(&self, block_hash: BlockHash) -> anyhow::Result<VerboseBlock>;
 
 			async fn block_hash(&self, block_number: cf_chains::btc::BlockNumber) -> BlockHash;
 
@@ -210,7 +238,12 @@ pub mod mocks {
 
 			async fn average_block_fee_rate(&self, block_hash: BlockHash) -> cf_chains::btc::BtcAmount;
 
-			async fn best_block_header(&self) -> BlockHeader;
+			async fn best_block_header(&self) -> anyhow::Result<BlockHeader>;
+
+			async fn block_header(
+				&self,
+				block_number: cf_chains::btc::BlockNumber,
+			) -> anyhow::Result<BlockHeader>;
 		}
 	}
 }

engine/src/elections.rs

@@ -9,6 +9,7 @@ use crate::{
 	},
 };
 use anyhow::anyhow;
+use cf_chains::instances::ChainInstanceAlias;
 use cf_primitives::MILLISECONDS_PER_BLOCK;
 use cf_utilities::{future_map::FutureMap, task_scope::Scope, UnendingStream};
 use futures::{stream, StreamExt, TryStreamExt};
@@ -31,28 +32,30 @@ const MAXIMUM_SHARED_DATA_CACHE_ITEMS: usize = 1024;
 const MAXIMUM_CONCURRENT_VOTER_REQUESTS: u32 = 32;
 const INITIAL_VOTER_REQUEST_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
 
+pub type ChainInstance<Chain> = <Chain as ChainInstanceAlias>::Instance;
+
 pub struct Voter<
-	Instance: 'static,
-	StateChainClient: ElectoralApi<Instance> + SignedExtrinsicApi + ChainApi,
-	VoterClient: CompositeVoterApi<<state_chain_runtime::Runtime as pallet_cf_elections::Config<Instance>>::ElectoralSystemRunner> + Send + Sync + 'static,
+	Chain: cf_chains::Chain + 'static,
+	StateChainClient: ElectoralApi<Chain, ChainInstance<Chain>> + SignedExtrinsicApi + ChainApi,
+	VoterClient: CompositeVoterApi<<state_chain_runtime::Runtime as pallet_cf_elections::Config<ChainInstance<Chain>>>::ElectoralSystemRunner> + Send + Sync + 'static,
 > where
 	state_chain_runtime::Runtime:
-		pallet_cf_elections::Config<Instance>,
+		pallet_cf_elections::Config<ChainInstance<Chain>>,
 {
 	state_chain_client: Arc<StateChainClient>,
 	voter: RetrierClient<VoterClient>,
-	_phantom: core::marker::PhantomData<Instance>,
+	_phantom: core::marker::PhantomData<Chain>,
 }
 
 impl<
-		Instance: Send + Sync + 'static,
-		StateChainClient: ElectoralApi<Instance> + SignedExtrinsicApi + ChainApi,
-		VoterClient: CompositeVoterApi<<state_chain_runtime::Runtime as pallet_cf_elections::Config<Instance>>::ElectoralSystemRunner> + Clone + Send + Sync + 'static,
-	> Voter<Instance, StateChainClient, VoterClient>
+		Chain: cf_chains::Chain + 'static,
+		StateChainClient: ElectoralApi<Chain, ChainInstance<Chain>> + SignedExtrinsicApi + ChainApi,
+		VoterClient: CompositeVoterApi<<state_chain_runtime::Runtime as pallet_cf_elections::Config<ChainInstance<Chain>>>::ElectoralSystemRunner> + Clone + Send + Sync + 'static,
+	> Voter<Chain, StateChainClient, VoterClient>
 where
 	state_chain_runtime::Runtime:
-		pallet_cf_elections::Config<Instance>,
-	pallet_cf_elections::Call<state_chain_runtime::Runtime, Instance>:
+		pallet_cf_elections::Config<ChainInstance<Chain>>,
+	pallet_cf_elections::Call<state_chain_runtime::Runtime, ChainInstance<Chain>>:
 		std::convert::Into<state_chain_runtime::RuntimeCall>,
 {
 	pub fn new(
@@ -76,9 +79,9 @@ where
 
 	pub async fn continuously_vote(self) {
 		loop {
-			info!("Beginning voting");
+			info!("{}: Beginning voting", Chain::NAME);
 			if let Err(error) = self.reset_and_continuously_vote().await {
-				error!("Voting reset due to error: '{}'", error);
+				error!("{}: Voting reset due to error: '{error}'", Chain::NAME);
 			}
 		}
 	}
@@ -87,41 +90,46 @@ where
 		let mut rng = rand::rngs::OsRng;
 		let latest_unfinalized_block = self.state_chain_client.latest_unfinalized_block();
 		if let Some(_electoral_data) = self.state_chain_client.electoral_data(latest_unfinalized_block).await {
-			let (_, _, block_header, _) = self.state_chain_client.submit_signed_extrinsic(pallet_cf_elections::Call::<state_chain_runtime::Runtime, Instance>::ignore_my_votes {}).await.until_in_block().await?;
+			tracing::info!("{}: Got some electoral data", Chain::NAME);
+			let (_, _, block_header, _) = self.state_chain_client.submit_signed_extrinsic(pallet_cf_elections::Call::<state_chain_runtime::Runtime, ChainInstance<Chain>>::ignore_my_votes {}).await.until_in_block().await?;
 
 			if let Some(electoral_data) = self.state_chain_client.electoral_data(block_header.into()).await {
+				tracing::info!("{}: Got some electoral data 2", Chain::NAME);
 				stream::iter(electoral_data.current_elections).map(|(election_identifier, election_data)| {
 					let state_chain_client = &self.state_chain_client;
 					async move {
 						if election_data.option_existing_vote.is_some() {
-							state_chain_client.finalize_signed_extrinsic(pallet_cf_elections::Call::<state_chain_runtime::Runtime, Instance>::delete_vote {
+							state_chain_client.finalize_signed_extrinsic(pallet_cf_elections::Call::<state_chain_runtime::Runtime, ChainInstance<Chain>>::delete_vote {
 								election_identifier,
 							}).await.until_in_block().await?;
 						}
 						Ok::<_, anyhow::Error>(())
 					}
 				}).buffer_unordered(32).try_collect::<Vec<_>>().await?;
 
-				self.state_chain_client.submit_signed_extrinsic(pallet_cf_elections::Call::<state_chain_runtime::Runtime, Instance>::stop_ignoring_my_votes {}).await.until_in_block().await?;
+				tracing::info!("{}: Submitting signed extrinsic", Chain::NAME);
+				self.state_chain_client.submit_signed_extrinsic(pallet_cf_elections::Call::<state_chain_runtime::Runtime, ChainInstance<Chain>>::stop_ignoring_my_votes {}).await.until_in_block().await?;
+				tracing::info!("{}: Submitted signed extrinsic", Chain::NAME);
 			}
 		}
 
 		let mut unfinalized_block_stream = self.state_chain_client.unfinalized_block_stream().await;
+		// TEMP: Half block time to hack BTC voting.
 		const BLOCK_TIME: std::time::Duration =
-			std::time::Duration::from_millis(MILLISECONDS_PER_BLOCK);
+			std::time::Duration::from_millis(MILLISECONDS_PER_BLOCK / 2);
 		let mut submit_interval = tokio::time::interval(BLOCK_TIME);
 		let mut pending_submissions = BTreeMap::<
-			CompositeElectionIdentifierOf<<state_chain_runtime::Runtime as pallet_cf_elections::Config<Instance>>::ElectoralSystemRunner>,
+			CompositeElectionIdentifierOf<<state_chain_runtime::Runtime as pallet_cf_elections::Config<ChainInstance<Chain>>>::ElectoralSystemRunner>,
 			(
-				<<<state_chain_runtime::Runtime as pallet_cf_elections::Config<Instance>>::ElectoralSystemRunner as ElectoralSystemRunner>::Vote as VoteStorage>::PartialVote,
-				<<<state_chain_runtime::Runtime as pallet_cf_elections::Config<Instance>>::ElectoralSystemRunner as ElectoralSystemRunner>::Vote as VoteStorage>::Vote,
+				<<<state_chain_runtime::Runtime as pallet_cf_elections::Config<ChainInstance<Chain>>>::ElectoralSystemRunner as ElectoralSystemRunner>::Vote as VoteStorage>::PartialVote,
+				<<<state_chain_runtime::Runtime as pallet_cf_elections::Config<ChainInstance<Chain>>>::ElectoralSystemRunner as ElectoralSystemRunner>::Vote as VoteStorage>::Vote,
 			)
 		>::default();
 		let mut vote_tasks = FutureMap::default();
 		let mut shared_data_cache = HashMap::<
 			SharedDataHash,
 			(
-				<<<state_chain_runtime::Runtime as pallet_cf_elections::Config<Instance>>::ElectoralSystemRunner as ElectoralSystemRunner>::Vote as VoteStorage>::SharedData,
+				<<<state_chain_runtime::Runtime as pallet_cf_elections::Config<ChainInstance<Chain>>>::ElectoralSystemRunner as ElectoralSystemRunner>::Vote as VoteStorage>::SharedData,
 				std::time::Instant,
 			)
 		>::default();
@@ -149,10 +157,10 @@ where
 					let state_chain_client = &self.state_chain_client;
 					async move {
 						for (election_identifier, _) in votes.iter() {
-							info!("Submitting vote for election: '{:?}'", election_identifier);
+							info!("{}: Submitting vote for election: '{election_identifier:?}'", Chain::NAME);
 						}
 						// TODO: Use block hash you got this vote tasks details from as the based of the mortal of the extrinsic
-						state_chain_client.submit_signed_extrinsic(pallet_cf_elections::Call::<state_chain_runtime::Runtime, Instance>::vote {
+						state_chain_client.submit_signed_extrinsic(pallet_cf_elections::Call::<state_chain_runtime::Runtime, ChainInstance<Chain>>::vote {
 							authority_votes: BTreeMap::from_iter(votes).try_into().unwrap(/*Safe due to chunking*/),
 						}).await;
 					}
@@ -161,9 +169,9 @@ where
 			let (election_identifier, result_vote) = vote_tasks.next_or_pending() => {
 				match result_vote {
 					Ok(vote) => {
-						info!("Voting task for election: '{:?}' succeeded.", election_identifier);
+						info!("{}: Voting task for election: '{election_identifier:?}' succeeded.", Chain::NAME);
 						// Create the partial_vote early so that SharedData can be provided as soon as the vote has been generated, rather than only after it is submitted.
-						let partial_vote = <<<state_chain_runtime::Runtime as pallet_cf_elections::Config<Instance>>::ElectoralSystemRunner as ElectoralSystemRunner>::Vote as VoteStorage>::vote_into_partial_vote(&vote, |shared_data| {
+						let partial_vote = <<<state_chain_runtime::Runtime as pallet_cf_elections::Config<ChainInstance<Chain>>>::ElectoralSystemRunner as ElectoralSystemRunner>::Vote as VoteStorage>::vote_into_partial_vote(&vote, |shared_data| {
 							let shared_data_hash = SharedDataHash::of(&shared_data);
 							if shared_data_cache.len() > MAXIMUM_SHARED_DATA_CACHE_ITEMS {
 								for shared_data_hash in shared_data_cache.keys().cloned().take(shared_data_cache.len() - MAXIMUM_SHARED_DATA_CACHE_ITEMS).collect::<Vec<_>>() {
@@ -177,7 +185,7 @@ where
 						pending_submissions.insert(election_identifier,	(partial_vote, vote));
 					},
 					Err(error) => {
-						warn!("Voting task for election '{:?}' failed with error: '{:?}'.", election_identifier, error);
+						warn!("{}: Voting task for election '{election_identifier:?}' failed with error: '{error:?}'.", Chain::NAME);
 					}
 				}
 			},
@@ -190,16 +198,18 @@ where
 					added_to_cache.elapsed() < LIFETIME_OF_SHARED_DATA_IN_CACHE
 				});
 
+				tracing::info!("{}: Unfinalised next, getting electoral_data", Chain::NAME);
 				if let Some(electoral_data) = self.state_chain_client.electoral_data(block_info).await {
+					tracing::info!("{}: Unfinalised next, got some electoral_data: {:?}", Chain::NAME, electoral_data);
 					if electoral_data.contributing {
 						for (election_identifier, election_data) in electoral_data.current_elections {
 							if election_data.is_vote_desired {
 								if !vote_tasks.contains_key(&election_identifier) {
-									info!("Voting task for election: '{:?}' initiate.", election_identifier);
+									info!("{}: Voting task for election: '{election_identifier:?}' initiate.", Chain::NAME);
 									vote_tasks.insert(
 										election_identifier,
 										Box::pin(self.voter.request_with_limit(
-											RequestLog::new("vote".to_string(), Some(format!("{election_identifier:?}"))), // Add some identifier for `Instance`.
+											RequestLog::new("vote".to_string(), Some(format!("{}: {election_identifier:?}", Chain::NAME))),
 											Box::pin(move |client| {
 												let election_data = election_data.clone();
 												#[allow(clippy::redundant_async_block)]
@@ -214,7 +224,7 @@ where
 										))
 									);
 								} else {
-									info!("Voting task for election: '{:?}' not initiated as a task is already running for that election.", election_identifier);
+									info!("{}: Voting task for election: '{election_identifier:?}' not initiated as a task is already running for that election.", Chain::NAME);
 								}
 							}
 						}
@@ -232,7 +242,7 @@ where
 									let final_probability = 1.0 / (core::cmp::max(1, core::cmp::min(reference_details.count, electoral_data.authority_count)) as f64);
 
 									if rng.gen_bool((1.0 - lerp_factor) * initial_probability + lerp_factor * final_probability) {
-										self.state_chain_client.submit_signed_extrinsic(pallet_cf_elections::Call::<state_chain_runtime::Runtime, Instance>::provide_shared_data {
+										self.state_chain_client.submit_signed_extrinsic(pallet_cf_elections::Call::<state_chain_runtime::Runtime, ChainInstance<Chain>>::provide_shared_data {
 											shared_data: shared_data.clone(),
 										}).await;
 									}
@@ -242,10 +252,10 @@ where
 					} else {
 						// We expect this to happen when a validator joins the set, since they won't be contributing, but will be a validator.
 						// Therefore they get Some() from `electoral_data` but `contributing` is false, until we reset the voting by throwing an error here.
-						return Err(anyhow!("Validator has just joined the authority set, or has been unexpectedly set as not contributing."));
+						return Err(anyhow!("{}: Validator has just joined the authority set, or has been unexpectedly set as not contributing.", Chain::NAME));
 					}
 				} else {
-					info!("Not voting as not an authority.");
+					info!("{}: Not voting as not an authority.", Chain::NAME);
 				}
 			} else break Ok(()),
 		}

engine/src/elections/voter_api.rs

@@ -78,4 +78,6 @@ macro_rules! generate_voter_api_tuple_impls {
     }
 }
 
+generate_voter_api_tuple_impls!(tuple_1_impls: ((A, A0)));
+generate_voter_api_tuple_impls!(tuple_2_impls: ((A, A0), (B, B0)));
 generate_voter_api_tuple_impls!(tuple_7_impls: ((A, A0), (B, B0), (C, C0), (D, D0), (EE, E0), (FF, F0), (GG, G0)));