Merge pull request #194 from zoedberg/resolvers_checks

resolver: implement check

cli/src/args.rs

@@ -120,11 +120,13 @@ impl RgbArgs {
     }
 
     pub fn resolver(&self) -> Result<AnyResolver, WalletError> {
-        match (&self.resolver.esplora, &self.resolver.electrum) {
+        let resolver = match (&self.resolver.esplora, &self.resolver.electrum) {
             (None, Some(url)) => AnyResolver::electrum_blocking(url),
             (Some(url), None) => AnyResolver::esplora_blocking(url),
             _ => unreachable!("clap is broken"),
         }
-        .map_err(WalletError::Resolver)
+        .map_err(WalletError::Resolver)?;
+        resolver.check(self.general.network)?;
+        Ok(resolver)
     }
 }

src/resolvers/any.rs

@@ -24,6 +24,7 @@
 use std::collections::HashMap;
 
 use bp::Tx;
+use bpstd::Network;
 use rgbstd::containers::Consignment;
 use rgbstd::resolvers::ResolveHeight;
 use rgbstd::validation::{ResolveWitness, WitnessResolverError};
@@ -32,6 +33,7 @@ use rgbstd::{WitnessAnchor, XWitnessId, XWitnessTx};
 use crate::{Txid, WitnessOrd, XChain};
 
 pub trait RgbResolver {
+    fn check(&self, network: Network, expected_block_hash: String) -> Result<(), String>;
     fn resolve_height(&mut self, txid: Txid) -> Result<WitnessAnchor, String>;
     fn resolve_pub_witness(&self, txid: Txid) -> Result<Tx, Option<String>>;
 }
@@ -65,6 +67,17 @@ impl AnyResolver {
         })
     }
 
+    pub fn check(&self, network: Network) -> Result<(), String> {
+        let expected_block_hash = match network {
+            Network::Mainnet => "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
+            Network::Testnet3 => "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943",
+            Network::Signet => "00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6",
+            Network::Regtest => "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206",
+        }
+        .to_string();
+        self.inner.check(network, expected_block_hash)
+    }
+
     pub fn add_terminals<const TYPE: bool>(&mut self, consignment: &Consignment<TYPE>) {
         self.terminal_txes.extend(
             consignment

src/resolvers/electrum_blocking.rs

@@ -24,7 +24,7 @@
 use std::iter;
 
 use bp::ConsensusDecode;
-use bpstd::{Tx, Txid};
+use bpstd::{Network, Tx, Txid};
 use electrum::{Client, ElectrumApi, Error, Param};
 use rgbstd::{WitnessAnchor, WitnessOrd, WitnessPos, XWitnessId};
 
@@ -37,6 +37,36 @@ macro_rules! check {
 }
 
 impl RgbResolver for Client {
+    fn check(&self, network: Network, expected_block_hash: String) -> Result<(), String> {
+        // check the electrum server is for the correct network
+        let block_hash = check!(self.block_header(0)).block_hash().to_string();
+        if expected_block_hash != block_hash {
+            return Err(s!("resolver is for a network different from the wallet's one"));
+        }
+        // check the electrum server has the required functionality (verbose
+        // transactions)
+        let txid = match network {
+            Network::Mainnet => "33e794d097969002ee05d336686fc03c9e15a597c1b9827669460fac98799036",
+            Network::Testnet3 => "5e6560fd518aadbed67ee4a55bdc09f19e619544f5511e9343ebba66d2f62653",
+            Network::Signet => "8153034f45e695453250a8fb7225a5e545144071d8ed7b0d3211efa1f3c92ad8",
+            Network::Regtest => "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b",
+        };
+        if let Err(e) = self.raw_call("blockchain.transaction.get", vec![
+            Param::String(txid.to_string()),
+            Param::Bool(true),
+        ]) {
+            if !e
+                .to_string()
+                .contains("genesis block coinbase is not considered an ordinary transaction")
+            {
+                return Err(s!(
+                    "verbose transactions are unsupported by the provided electrum service"
+                ));
+            }
+        }
+        Ok(())
+    }
+
     fn resolve_height(&mut self, txid: Txid) -> Result<WitnessAnchor, String> {
         let mut witness_anchor = WitnessAnchor {
             witness_ord: WitnessOrd::OffChain,

src/resolvers/esplora_blocking.rs

@@ -20,14 +20,23 @@
 // limitations under the License.
 
 use bp::Tx;
-use bpstd::Txid;
+use bpstd::{Network, Txid};
 use esplora::{BlockingClient, Error};
 use rgbstd::{WitnessAnchor, WitnessOrd, WitnessPos};
 
 use super::RgbResolver;
 use crate::XWitnessId;
 
 impl RgbResolver for BlockingClient {
+    fn check(&self, _network: Network, expected_block_hash: String) -> Result<(), String> {
+        // check the esplora server is for the correct network
+        let block_hash = self.block_hash(0)?.to_string();
+        if expected_block_hash != block_hash {
+            return Err(s!("resolver is for a network different from the wallet's one"));
+        }
+        Ok(())
+    }
+
     fn resolve_height(&mut self, txid: Txid) -> Result<WitnessAnchor, String> {
         let status = self.tx_status(&txid)?;
         let ord = match status