feat(doge): dogecoin replica support

rs/bitcoin/adapter/tests/adapter_test.rs

@@ -57,11 +57,12 @@ fn make_get_successors_request(
     anchor: Vec<u8>,
     headers: Vec<Vec<u8>>,
 ) -> Result<BitcoinAdapterResponseWrapper, ic_interfaces_adapter_client::RpcError> {
-    let request = BitcoinAdapterRequestWrapper::GetSuccessorsRequest(GetSuccessorsRequestInitial {
-        network: Network::Regtest,
-        anchor,
-        processed_block_hashes: headers,
-    });
+    let request =
+        BitcoinAdapterRequestWrapper::GetBtcSuccessorsRequest(GetSuccessorsRequestInitial {
+            network: Network::Regtest,
+            anchor,
+            processed_block_hashes: headers,
+        });
 
     adapter_client.send_blocking(
         request,
@@ -75,7 +76,7 @@ fn make_send_tx_request(
     adapter_client: &BitcoinAdapterClient,
     raw_tx: &[u8],
 ) -> Result<BitcoinAdapterResponseWrapper, ic_interfaces_adapter_client::RpcError> {
-    let request = BitcoinAdapterRequestWrapper::SendTransactionRequest(SendTransactionRequest {
+    let request = BitcoinAdapterRequestWrapper::SendBtcTransactionRequest(SendTransactionRequest {
         network: Network::Regtest,
         transaction: raw_tx.to_vec(),
     });

rs/bitcoin/client/src/lib.rs

@@ -6,8 +6,8 @@ use crate::metrics::{
 };
 use ic_adapter_metrics_client::AdapterMetrics;
 use ic_btc_replica_types::{
-    BitcoinAdapterRequestWrapper, BitcoinAdapterResponseWrapper, GetSuccessorsRequestInitial,
-    GetSuccessorsResponseComplete, SendTransactionRequest, SendTransactionResponse,
+    BitcoinAdapterRequestInner, BitcoinAdapterRequestWrapper, BitcoinAdapterResponseWrapper,
+    GetSuccessorsResponseComplete, SendTransactionResponse,
 };
 use ic_btc_service::{
     btc_service_client::BtcServiceClient, BtcServiceGetSuccessorsRequest,
@@ -65,11 +65,8 @@ impl RpcAdapterClient<BitcoinAdapterRequestWrapper> for BitcoinAdapterClientImpl
         );
         let mut client = self.client.clone();
         self.rt_handle.block_on(async move {
-            let response = match request {
-                BitcoinAdapterRequestWrapper::SendTransactionRequest(SendTransactionRequest {
-                    transaction,
-                    ..
-                }) => {
+            let response = match request.as_inner() {
+                BitcoinAdapterRequestInner::SendTransaction { transaction } => {
                     request_timer.set_label(LABEL_REQUEST_TYPE, LABEL_SEND_TRANSACTION);
                     let send_transaction_request = BtcServiceSendTransactionRequest { transaction };
                     let mut tonic_request = tonic::Request::new(send_transaction_request);
@@ -86,13 +83,10 @@ impl RpcAdapterClient<BitcoinAdapterRequestWrapper> for BitcoinAdapterClientImpl
                         })
                         .map_err(convert_tonic_error)
                 }
-                BitcoinAdapterRequestWrapper::GetSuccessorsRequest(
-                    GetSuccessorsRequestInitial {
-                        anchor,
-                        processed_block_hashes,
-                        ..
-                    },
-                ) => {
+                BitcoinAdapterRequestInner::GetSuccessors {
+                    anchor,
+                    processed_block_hashes,
+                } => {
                     request_timer.set_label(LABEL_REQUEST_TYPE, LABEL_GET_SUCCESSORS);
                     let get_successors_request = BtcServiceGetSuccessorsRequest {
                         anchor,
@@ -153,11 +147,11 @@ impl RpcAdapterClient<BitcoinAdapterRequestWrapper> for BrokenConnectionBitcoinC
             &REQUESTS_LABEL_NAMES,
             [UNKNOWN_LABEL, UNKNOWN_LABEL],
         );
-        match request {
-            BitcoinAdapterRequestWrapper::GetSuccessorsRequest(_) => {
+        match request.as_inner() {
+            BitcoinAdapterRequestInner::GetSuccessors { .. } => {
                 request_timer.set_label(LABEL_REQUEST_TYPE, LABEL_GET_SUCCESSORS)
             }
-            BitcoinAdapterRequestWrapper::SendTransactionRequest(_) => {
+            BitcoinAdapterRequestInner::SendTransaction { .. } => {
                 request_timer.set_label(LABEL_REQUEST_TYPE, LABEL_SEND_TRANSACTION)
             }
         }
@@ -218,6 +212,61 @@ pub struct BitcoinAdapterClients {
     >,
 }
 
+pub struct DogecoinAdapterClients {
+    pub doge_testnet_client: Box<
+        dyn RpcAdapterClient<
+            BitcoinAdapterRequestWrapper,
+            Response = BitcoinAdapterResponseWrapper,
+        >,
+    >,
+    pub doge_mainnet_client: Box<
+        dyn RpcAdapterClient<
+            BitcoinAdapterRequestWrapper,
+            Response = BitcoinAdapterResponseWrapper,
+        >,
+    >,
+}
+
+pub fn setup_dogecoin_adapter_clients(
+    log: ReplicaLogger,
+    metrics_registry: &MetricsRegistry,
+    rt_handle: tokio::runtime::Handle,
+    adapters_config: AdaptersConfig,
+) -> DogecoinAdapterClients {
+    let metrics = Metrics::new(metrics_registry);
+
+    // Register bitcoin adapters metrics.
+    if let Some(metrics_uds_path) = adapters_config.dogecoin_testnet_uds_metrics_path {
+        metrics_registry.register_adapter(AdapterMetrics::new(
+            "dogetestnet",
+            metrics_uds_path,
+            rt_handle.clone(),
+        ));
+    }
+    if let Some(metrics_uds_path) = adapters_config.dogecoin_mainnet_uds_metrics_path {
+        metrics_registry.register_adapter(AdapterMetrics::new(
+            "dogemainnet",
+            metrics_uds_path,
+            rt_handle.clone(),
+        ));
+    }
+
+    DogecoinAdapterClients {
+        doge_testnet_client: setup_bitcoin_adapter_client(
+            log.clone(),
+            metrics.clone(),
+            rt_handle.clone(),
+            adapters_config.dogecoin_testnet_uds_path,
+        ),
+        doge_mainnet_client: setup_bitcoin_adapter_client(
+            log,
+            metrics,
+            rt_handle,
+            adapters_config.dogecoin_mainnet_uds_path,
+        ),
+    }
+}
+
 pub fn setup_bitcoin_adapter_clients(
     log: ReplicaLogger,
     metrics_registry: &MetricsRegistry,

rs/bitcoin/consensus/src/payload_builder.rs

@@ -8,10 +8,11 @@ mod tests;
 mod proptests;
 
 use crate::metrics::BitcoinPayloadBuilderMetrics;
-use ic_btc_interface::Network;
+use ic_btc_interface::Network as BtcNetwork;
+use ic_btc_interface::Network as DogeNetwork;
 use ic_btc_replica_types::{
     BitcoinAdapterRequestWrapper, BitcoinAdapterResponse, BitcoinAdapterResponseWrapper,
-    BitcoinReject,
+    BitcoinReject, Network,
 };
 use ic_config::bitcoin_payload_builder_config::Config;
 use ic_error_types::RejectCode;
@@ -67,21 +68,17 @@ impl GetPayloadError {
     }
 }
 
+type AdapterClient = Box<
+    dyn RpcAdapterClient<BitcoinAdapterRequestWrapper, Response = BitcoinAdapterResponseWrapper>,
+>;
+
 pub struct BitcoinPayloadBuilder {
     state_manager: Arc<dyn StateReader<State = ReplicatedState>>,
     metrics: Arc<BitcoinPayloadBuilderMetrics>,
-    bitcoin_mainnet_adapter_client: Box<
-        dyn RpcAdapterClient<
-            BitcoinAdapterRequestWrapper,
-            Response = BitcoinAdapterResponseWrapper,
-        >,
-    >,
-    bitcoin_testnet_adapter_client: Box<
-        dyn RpcAdapterClient<
-            BitcoinAdapterRequestWrapper,
-            Response = BitcoinAdapterResponseWrapper,
-        >,
-    >,
+    bitcoin_mainnet_adapter_client: AdapterClient,
+    bitcoin_testnet_adapter_client: AdapterClient,
+    dogecoin_mainnet_adapter_client: AdapterClient,
+    dogecoin_testnet_adapter_client: AdapterClient,
     subnet_id: SubnetId,
     registry: Arc<dyn RegistryClient + Send + Sync>,
     config: Config,
@@ -92,18 +89,10 @@ impl BitcoinPayloadBuilder {
     pub fn new(
         state_manager: Arc<dyn StateReader<State = ReplicatedState>>,
         metrics_registry: &MetricsRegistry,
-        bitcoin_mainnet_adapter_client: Box<
-            dyn RpcAdapterClient<
-                BitcoinAdapterRequestWrapper,
-                Response = BitcoinAdapterResponseWrapper,
-            >,
-        >,
-        bitcoin_testnet_adapter_client: Box<
-            dyn RpcAdapterClient<
-                BitcoinAdapterRequestWrapper,
-                Response = BitcoinAdapterResponseWrapper,
-            >,
-        >,
+        bitcoin_mainnet_adapter_client: AdapterClient,
+        bitcoin_testnet_adapter_client: AdapterClient,
+        dogecoin_mainnet_adapter_client: AdapterClient,
+        dogecoin_testnet_adapter_client: AdapterClient,
         subnet_id: SubnetId,
         registry: Arc<dyn RegistryClient + Send + Sync>,
         config: Config,
@@ -114,6 +103,8 @@ impl BitcoinPayloadBuilder {
             metrics: Arc::new(BitcoinPayloadBuilderMetrics::new(metrics_registry)),
             bitcoin_mainnet_adapter_client,
             bitcoin_testnet_adapter_client,
+            dogecoin_mainnet_adapter_client,
+            dogecoin_testnet_adapter_client,
             subnet_id,
             registry,
             config,
@@ -146,8 +137,13 @@ impl BitcoinPayloadBuilder {
             }
 
             let adapter_client = match request.network() {
-                Network::Mainnet => &self.bitcoin_mainnet_adapter_client,
-                Network::Testnet | Network::Regtest => &self.bitcoin_testnet_adapter_client,
+                Network::Bitcoin(BtcNetwork::Mainnet) => &self.bitcoin_mainnet_adapter_client,
+                Network::Bitcoin(BtcNetwork::Testnet) | Network::Bitcoin(BtcNetwork::Regtest) => {
+                    &self.bitcoin_testnet_adapter_client
+                }
+                Network::Dogecoin(DogeNetwork::Mainnet) => &self.dogecoin_mainnet_adapter_client,
+                Network::Dogecoin(DogeNetwork::Testnet)
+                | Network::Dogecoin(DogeNetwork::Regtest) => &self.dogecoin_testnet_adapter_client,
             };
 
             // Send request to the adapter.
@@ -198,15 +194,29 @@ impl BitcoinPayloadBuilder {
                     Err(err) => {
                         let error_message = err.to_string();
                         match request {
-                            BitcoinAdapterRequestWrapper::SendTransactionRequest(context) => {
+                            BitcoinAdapterRequestWrapper::SendBtcTransactionRequest(context) => {
+                                BitcoinAdapterResponseWrapper::SendTransactionReject(
+                                    BitcoinReject {
+                                        reject_code: RejectCode::SysTransient,
+                                        message: error_message,
+                                    },
+                                )
+                            }
+                            BitcoinAdapterRequestWrapper::GetBtcSuccessorsRequest(context) => {
+                                BitcoinAdapterResponseWrapper::GetSuccessorsReject(BitcoinReject {
+                                    reject_code: RejectCode::SysTransient,
+                                    message: error_message,
+                                })
+                            }
+                            BitcoinAdapterRequestWrapper::SendDogeTransactionRequest(context) => {
                                 BitcoinAdapterResponseWrapper::SendTransactionReject(
                                     BitcoinReject {
                                         reject_code: RejectCode::SysTransient,
                                         message: error_message,
                                     },
                                 )
                             }
-                            BitcoinAdapterRequestWrapper::GetSuccessorsRequest(context) => {
+                            BitcoinAdapterRequestWrapper::GetDogeSuccessorsRequest(context) => {
                                 BitcoinAdapterResponseWrapper::GetSuccessorsReject(BitcoinReject {
                                     reject_code: RejectCode::SysTransient,
                                     message: error_message,
@@ -321,7 +331,7 @@ fn bitcoin_requests_iter(
         .map(|(callback_id, context)| {
             (
                 callback_id,
-                BitcoinAdapterRequestWrapper::SendTransactionRequest(context.payload.clone()),
+                BitcoinAdapterRequestWrapper::SendBtcTransactionRequest(context.payload.clone()),
             )
         })
         .chain(
@@ -331,7 +341,9 @@ fn bitcoin_requests_iter(
                 .map(|(callback_id, context)| {
                     (
                         callback_id,
-                        BitcoinAdapterRequestWrapper::GetSuccessorsRequest(context.payload.clone()),
+                        BitcoinAdapterRequestWrapper::GetBtcSuccessorsRequest(
+                            context.payload.clone(),
+                        ),
                     )
                 }),
         )