Skip to main content

smplx_test/
context.rs

1use std::path::PathBuf;
2
3use electrsd::bitcoind::bitcoincore_rpc::Auth;
4
5use smplx_regtest::Regtest;
6use smplx_regtest::client::RegtestClient;
7
8use smplx_sdk::provider::{EsploraProvider, ProviderTrait, SimplexProvider, SimplicityNetwork};
9use smplx_sdk::signer::Signer;
10
11use crate::config::TestConfig;
12use crate::error::TestError;
13
14#[allow(dead_code)]
15pub struct TestContext {
16    _client: Option<RegtestClient>,
17    config: TestConfig,
18    signer: Signer,
19}
20
21impl TestContext {
22    pub fn new(config_path: PathBuf) -> Result<Self, TestError> {
23        let config = TestConfig::from_file(&config_path)?;
24
25        let (signer, client) = Self::setup(&config)?;
26
27        Ok(Self {
28            _client: client,
29            config,
30            signer,
31        })
32    }
33
34    pub fn get_provider(&self) -> &dyn ProviderTrait {
35        self.signer.get_provider()
36    }
37
38    pub fn get_config(&self) -> &TestConfig {
39        &self.config
40    }
41
42    pub fn get_network(&self) -> &SimplicityNetwork {
43        self.signer.get_provider().get_network()
44    }
45
46    pub fn get_signer(&self) -> &Signer {
47        &self.signer
48    }
49
50    fn setup(config: &TestConfig) -> Result<(Signer, Option<RegtestClient>), TestError> {
51        let client: Option<RegtestClient>;
52        let signer: Signer;
53
54        match config.esplora.clone() {
55            Some(esplora) => match config.rpc.clone() {
56                Some(rpc) => {
57                    // custom regtest case
58                    let auth = Auth::UserPass(rpc.username, rpc.password);
59                    let provider = Box::new(SimplexProvider::new(
60                        esplora.url,
61                        rpc.url,
62                        auth,
63                        SimplicityNetwork::default_regtest(),
64                    )?);
65
66                    signer = Signer::new(config.mnemonic.as_str(), provider)?;
67                    client = None;
68                }
69                None => {
70                    // external esplora network
71                    let network = match esplora.network.as_str() {
72                        "Liquid" => SimplicityNetwork::Liquid,
73                        "LiquidTestnet" => SimplicityNetwork::LiquidTestnet,
74                        _ => panic!("Impossible branch reached, please report a bug"),
75                    };
76                    let provider = Box::new(EsploraProvider::new(esplora.url, network));
77
78                    signer = Signer::new(config.mnemonic.as_str(), provider)?;
79                    client = None;
80                }
81            },
82            None => {
83                // simplex inner network
84                let (regtest_client, regtest_signer) = Regtest::from_config(config.to_regtest_config())?;
85
86                client = Some(regtest_client);
87                signer = regtest_signer;
88            }
89        }
90
91        Ok((signer, client))
92    }
93}