chain net in genesis + resolver check

RGB-WG · Jan 31, 2025 · fabb69c · fabb69c
1 parent b434a33
commit fabb69c
Show file tree

Hide file tree

Showing 8 changed files with 59 additions and 40 deletions.
diff --git a/cli/src/args.rs b/cli/src/args.rs
@@ -189,7 +189,7 @@ impl RgbArgs {
                              --esplora --mempool or --electrum argument")),
             }
             .map_err(WalletError::Resolver)?;
-        resolver.check(self.general.network)?;
+        resolver.check_chain_net(self.general.network.into())?;
         Ok(resolver)
     }
 }
diff --git a/cli/src/command.rs b/cli/src/command.rs
@@ -52,7 +52,7 @@ use rgb::{
 use rgbstd::interface::{AllocatedState, ContractIface, OwnedIface};
 use rgbstd::persistence::{MemContractState, StockError};
 use rgbstd::stl::rgb_contract_stl;
-use rgbstd::{KnownState, Layer1, OutputAssignment};
+use rgbstd::{KnownState, OutputAssignment};
 use serde_crate::{Deserialize, Serialize};
 use strict_types::encoding::{FieldName, TypeName};
 use strict_types::StrictVal;
@@ -478,7 +478,7 @@ impl Exec for RgbArgs {
                         let resolver = self.resolver()?;
                         eprint!("- validating the contract {} ... ", contract.contract_id());
                         let contract = contract
-                            .validate(&resolver, self.general.network.is_testnet())
+                            .validate(&resolver, self.general.network.into())
                             .map_err(|(status, _)| {
                                 eprintln!("failure");
                                 status.to_string()
@@ -705,7 +705,7 @@ impl Exec for RgbArgs {
                     issuer.clone(),
                     *schema_id,
                     iface_id,
-                    Layer1::Bitcoin,
+                    self.general.network.into(),
                 )?;
                 let types = builder.type_system().clone();
 
@@ -1247,11 +1247,10 @@ impl Exec for RgbArgs {
                 let mut resolver = self.resolver()?;
                 let consignment = Transfer::load_file(file)?;
                 resolver.add_terminals(&consignment);
-                let status =
-                    match consignment.validate(&resolver, self.general.network.is_testnet()) {
-                        Ok(consignment) => consignment.into_validation_status(),
-                        Err((status, _)) => status,
-                    };
+                let status = match consignment.validate(&resolver, self.general.network.into()) {
+                    Ok(consignment) => consignment.into_validation_status(),
+                    Err((status, _)) => status,
+                };
                 if status.validity() == Validity::Valid {
                     eprintln!("The provided consignment is valid")
                 } else {
@@ -1265,7 +1264,7 @@ impl Exec for RgbArgs {
                 let transfer = Transfer::load_file(file)?;
                 resolver.add_terminals(&transfer);
                 let valid = transfer
-                    .validate(&resolver, self.general.network.is_testnet())
+                    .validate(&resolver, self.general.network.into())
                     .map_err(|(status, _)| status)?;
                 stock.accept_transfer(valid, &resolver)?;
                 eprintln!("Transfer accepted into the stash");

diff --git a/src/indexers/any.rs b/src/indexers/any.rs
@@ -24,16 +24,16 @@
 use std::collections::HashMap;
 
 use bp::{Tx, Txid};
-use bpstd::Network;
 use rgbstd::containers::Consignment;
 use rgbstd::validation::{ResolveWitness, WitnessResolverError};
+use rgbstd::ChainNet;
 
 use crate::vm::WitnessOrd;
 
 // We need to repeat methods of `WitnessResolve` trait here to avoid making
 // wrappers around resolver types. TODO: Use wrappers instead
 pub trait RgbResolver: Send {
-    fn check(&self, network: Network, expected_block_hash: String) -> Result<(), String>;
+    fn check_chain_net(&self, chain_net: ChainNet) -> Result<(), String>;
     fn resolve_pub_witness(&self, txid: Txid) -> Result<Option<Tx>, String>;
     fn resolve_pub_witness_ord(&self, txid: Txid) -> Result<WitnessOrd, String>;
 }
@@ -79,16 +79,9 @@ impl AnyResolver {
             terminal_txes: Default::default(),
         })
     }
-    pub fn check(&self, network: Network) -> Result<(), String> {
-        let expected_block_hash = match network {
-            Network::Mainnet => "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
-            Network::Testnet3 => "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943",
-            Network::Testnet4 => "00000000da84f2bafbbc53dee25a72ae507ff4914b867c565be350b0da8bf043",
-            Network::Signet => "00000008819873e925422c1ff0f99f7cc9bbb232af63a077a480a3633bee1ef6",
-            Network::Regtest => "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206",
-        }
-        .to_string();
-        self.inner.check(network, expected_block_hash)
+
+    pub fn check_chain_net(&self, chain_net: ChainNet) -> Result<(), String> {
+        self.inner.check_chain_net(chain_net)
     }
 
     pub fn add_terminals<const TYPE: bool>(&mut self, consignment: &Consignment<TYPE>) {
@@ -126,4 +119,10 @@ impl ResolveWitness for AnyResolver {
             .resolve_pub_witness_ord(witness_id)
             .map_err(|e| WitnessResolverError::Other(witness_id, e))
     }
+
+    fn check_chain_net(&self, chain_net: ChainNet) -> Result<(), WitnessResolverError> {
+        self.inner
+            .check_chain_net(chain_net)
+            .map_err(|_| WitnessResolverError::WrongChainNet)
+    }
 }
diff --git a/src/indexers/electrum_blocking.rs b/src/indexers/electrum_blocking.rs
@@ -25,10 +25,11 @@ use std::iter;
 use std::num::NonZeroU32;
 
 use bp::ConsensusDecode;
-use bpstd::{Network, Tx, Txid};
+use bpstd::{Tx, Txid};
 use electrum::{Client, ElectrumApi, Param};
 pub use electrum::{Config, ConfigBuilder, Error, Socks5Config};
 use rgbstd::vm::WitnessPos;
+use rgbstd::ChainNet;
 
 use super::RgbResolver;
 use crate::vm::WitnessOrd;
@@ -40,20 +41,31 @@ macro_rules! check {
 }
 
 impl RgbResolver for Client {
-    fn check(&self, network: Network, expected_block_hash: String) -> Result<(), String> {
+    fn check_chain_net(&self, chain_net: ChainNet) -> 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 {
+        let block_hash = check!(self.block_header(0)).block_hash();
+        if chain_net.genesis_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::Testnet4 => "7aa0a7ae1e223414cb807e40cd57e667b718e42aaf9306db9102fe28912b7b4e",
-            Network::Signet => "8153034f45e695453250a8fb7225a5e545144071d8ed7b0d3211efa1f3c92ad8",
-            Network::Regtest => "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b",
+        let txid = match chain_net {
+            ChainNet::BitcoinMainnet => {
+                "33e794d097969002ee05d336686fc03c9e15a597c1b9827669460fac98799036"
+            }
+            ChainNet::BitcoinTestnet3 => {
+                "5e6560fd518aadbed67ee4a55bdc09f19e619544f5511e9343ebba66d2f62653"
+            }
+            ChainNet::BitcoinTestnet4 => {
+                "7aa0a7ae1e223414cb807e40cd57e667b718e42aaf9306db9102fe28912b7b4e"
+            }
+            ChainNet::BitcoinSignet => {
+                "8153034f45e695453250a8fb7225a5e545144071d8ed7b0d3211efa1f3c92ad8"
+            }
+            ChainNet::BitcoinRegtest => {
+                "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
+            }
+            _ => return Err(s!("only bitcoin is supported")),
         };
         if let Err(e) = self.raw_call("blockchain.transaction.get", vec![
             Param::String(txid.to_string()),

diff --git a/src/indexers/esplora_blocking.rs b/src/indexers/esplora_blocking.rs
@@ -22,19 +22,20 @@
 use std::num::NonZeroU32;
 
 use bp::Tx;
-use bpstd::{Network, Txid};
+use bpstd::Txid;
 use esplora::BlockingClient;
 pub use esplora::{Builder, Config, Error};
 use rgbstd::vm::WitnessPos;
+use rgbstd::ChainNet;
 
 use super::RgbResolver;
 use crate::vm::WitnessOrd;
 
 impl RgbResolver for BlockingClient {
-    fn check(&self, _network: Network, expected_block_hash: String) -> Result<(), String> {
+    fn check_chain_net(&self, chain_net: ChainNet) -> 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 {
+        let block_hash = self.block_hash(0)?;
+        if chain_net.genesis_block_hash() != block_hash {
             return Err(s!("resolver is for a network different from the wallet's one"));
         }
         Ok(())

diff --git a/src/indexers/mempool_blocking.rs b/src/indexers/mempool_blocking.rs
@@ -20,9 +20,10 @@
 // limitations under the License.
 
 use bp::Tx;
-use bpstd::{Network, Txid};
+use bpstd::Txid;
 use esplora::{BlockingClient, Config, Error};
 use rgbstd::vm::WitnessOrd;
+use rgbstd::ChainNet;
 
 use super::RgbResolver;
 
@@ -56,8 +57,8 @@ impl MemPoolClient {
 }
 
 impl RgbResolver for MemPoolClient {
-    fn check(&self, network: Network, expected_block_hash: String) -> Result<(), String> {
-        self.inner.check(network, expected_block_hash)
+    fn check_chain_net(&self, chain_net: ChainNet) -> Result<(), String> {
+        self.inner.check_chain_net(chain_net)
     }
 
     fn resolve_pub_witness_ord(&self, txid: Txid) -> Result<WitnessOrd, String> {

diff --git a/src/lib.rs b/src/lib.rs
@@ -38,6 +38,7 @@ pub use pay::{TransferParams, WalletProvider};
 pub use rgbstd::*;
 pub mod resolvers {
     use bp::Tx;
+    use rgbstd::ChainNet;
 
     #[cfg(any(feature = "electrum_blocking", feature = "esplora_blocking"))]
     pub use super::indexers::*;
@@ -54,6 +55,9 @@ pub mod resolvers {
         fn resolve_pub_witness_ord(&self, _: Txid) -> Result<WitnessOrd, WitnessResolverError> {
             panic!("contract issue resolver must not be used for an already-existing contracts")
         }
+        fn check_chain_net(&self, _: ChainNet) -> Result<(), WitnessResolverError> {
+            panic!("contract issue resolver must not be used for an already-existing contracts")
+        }
     }
 }
 pub use filters::{WalletOutpointsFilter, WalletUnspentFilter, WalletWitnessFilter};

diff --git a/src/pay.rs b/src/pay.rs
@@ -36,7 +36,7 @@ use rgbstd::interface::AssignmentsFilter;
 use rgbstd::invoice::{Amount, Beneficiary, InvoiceState, RgbInvoice};
 use rgbstd::persistence::{IndexProvider, StashProvider, StateProvider, Stock};
 use rgbstd::validation::ResolveWitness;
-use rgbstd::{ContractId, DataState};
+use rgbstd::{ChainNet, ContractId, DataState};
 
 use crate::invoice::NonFungible;
 use crate::validation::WitnessResolverError;
@@ -340,6 +340,9 @@ where Self::Descr: DescriptorRgb<K>
                 assert_eq!(witness_id, self.witness_id);
                 Ok(WitnessOrd::Tentative)
             }
+            fn check_chain_net(&self, _: ChainNet) -> Result<(), WitnessResolverError> {
+                unreachable!()
+            }
         }
 
         stock