Feat/confidential

crates/cli/src/commands/regtest.rs

@@ -29,7 +29,7 @@ impl Regtest {
         println!("Esplora: {}", client.esplora_url());
         println!("User: {:?}, Password: {:?}", auth.0.unwrap(), auth.1.unwrap());
         println!();
-        println!("Signer: {:?}", signer.get_wpkh_address()?);
+        println!("Signer: {:?}", signer.get_address());
         println!("======================================");
 
         while running.load(Ordering::SeqCst) {}

crates/regtest/src/error.rs

@@ -1,14 +1,10 @@
 use std::io;
 
-use smplx_sdk::provider::ProviderError;
 use smplx_sdk::provider::RpcError;
 use smplx_sdk::signer::SignerError;
 
 #[derive(thiserror::Error, Debug)]
 pub enum RegtestError {
-    #[error(transparent)]
-    Provider(#[from] ProviderError),
-
     #[error(transparent)]
     Rpc(#[from] RpcError),
 

crates/regtest/src/regtest.rs

@@ -21,9 +21,9 @@ impl Regtest {
             client.rpc_url(),
             client.auth(),
             SimplicityNetwork::default_regtest(),
-        )?);
+        ));
 
-        let signer = Signer::new(config.mnemonic.as_str(), provider)?;
+        let signer = Signer::new(config.mnemonic.as_str(), provider);
 
         Self::prepare_signer(&client, &signer, config.bitcoins)?;
 
@@ -38,13 +38,13 @@ impl Regtest {
         rpc_provider.sweep_initialfreecoins()?;
         rpc_provider.generate_blocks(100)?;
 
-        rpc_provider.send_to_address(&signer.get_wpkh_address()?, btc2sat(bitcoins), None)?;
+        rpc_provider.send_to_address(&signer.get_address(), btc2sat(bitcoins), None)?;
 
         // wait for electrs to index
         let mut attempts = 0;
 
         loop {
-            if !(signer.get_wpkh_utxos()?).is_empty() {
+            if !(signer.get_utxos()?).is_empty() {
                 break;
             }
 

crates/sdk/src/lib.rs

@@ -1,5 +1,4 @@
 pub mod constants;
-pub mod presets;
 pub mod program;
 pub mod provider;
 pub mod signer;

crates/sdk/src/program/core.rs

@@ -5,11 +5,11 @@ use dyn_clone::DynClone;
 use simplicityhl::CompiledProgram;
 use simplicityhl::WitnessValues;
 use simplicityhl::elements::pset::PartiallySignedTransaction;
-use simplicityhl::elements::{Address, Script, Transaction, TxOut, script, taproot};
+use simplicityhl::elements::{Address, Script, Transaction, TxOut, taproot};
 use simplicityhl::simplicity::bitcoin::{XOnlyPublicKey, secp256k1};
 use simplicityhl::simplicity::jet::Elements;
 use simplicityhl::simplicity::jet::elements::{ElementsEnv, ElementsUtxo};
-use simplicityhl::simplicity::{BitMachine, RedeemNode, Value};
+use simplicityhl::simplicity::{BitMachine, RedeemNode, Value, leaf_version};
 use simplicityhl::tracker::{DefaultTracker, TrackerLogLevel};
 
 use super::arguments::ArgumentsTrait;
@@ -71,7 +71,7 @@ impl ProgramTrait for Program {
         }
 
         let target_utxo = &utxos[input_index];
-        let script_pubkey = self.get_tr_address(network)?.script_pubkey();
+        let script_pubkey = self.get_tr_address(network).script_pubkey();
 
         if target_utxo.script_pubkey != script_pubkey {
             return Err(ProgramError::ScriptPubkeyMismatch {
@@ -110,6 +110,7 @@ impl ProgramTrait for Program {
             .satisfy(witness.clone())
             .map_err(ProgramError::WitnessSatisfaction)?;
 
+        // TODO: global config for TrackerLogLevel
         let mut tracker = DefaultTracker::new(satisfied.debug_symbols()).with_log_level(TrackerLogLevel::Debug);
 
         let env = self.get_env(pst, input_index, network)?;
@@ -152,24 +153,24 @@ impl Program {
         }
     }
 
-    pub fn get_tr_address(&self, network: &SimplicityNetwork) -> Result<Address, ProgramError> {
-        let spend_info = self.taproot_spending_info()?;
+    pub fn get_tr_address(&self, network: &SimplicityNetwork) -> Address {
+        let spend_info = self.taproot_spending_info().unwrap();
 
-        Ok(Address::p2tr(
+        Address::p2tr(
             secp256k1::SECP256K1,
             spend_info.internal_key(),
             spend_info.merkle_root(),
             None,
             network.address_params(),
-        ))
+        )
     }
 
-    pub fn get_script_pubkey(&self, network: &SimplicityNetwork) -> Result<Script, ProgramError> {
-        Ok(self.get_tr_address(network)?.script_pubkey())
+    pub fn get_script_pubkey(&self, network: &SimplicityNetwork) -> Script {
+        self.get_tr_address(network).script_pubkey()
     }
 
-    pub fn get_script_hash(&self, network: &SimplicityNetwork) -> Result<[u8; 32], ProgramError> {
-        Ok(hash_script(&self.get_script_pubkey(network)?))
+    pub fn get_script_hash(&self, network: &SimplicityNetwork) -> [u8; 32] {
+        hash_script(&self.get_script_pubkey(network))
     }
 
     fn load(&self) -> Result<CompiledProgram, ProgramError> {
@@ -180,11 +181,12 @@ impl Program {
 
     fn script_version(&self) -> Result<(Script, taproot::LeafVersion), ProgramError> {
         let cmr = self.load()?.commit().cmr();
-        let script = script::Script::from(cmr.as_ref().to_vec());
+        let script = Script::from(cmr.as_ref().to_vec());
 
-        Ok((script, simplicityhl::simplicity::leaf_version()))
+        Ok((script, leaf_version()))
     }
 
+    // TODO: taproot storage
     fn taproot_spending_info(&self) -> Result<taproot::TaprootSpendInfo, ProgramError> {
         let builder = taproot::TaprootBuilder::new();
         let (script, version) = self.script_version()?;

crates/sdk/src/provider/core.rs

@@ -1,14 +1,24 @@
 use std::collections::HashMap;
 
-use simplicityhl::elements::{Address, OutPoint, Script, Transaction, TxOut, Txid};
+use electrsd::bitcoind::bitcoincore_rpc::Auth;
+
+use simplicityhl::elements::{Address, Script, Transaction, Txid};
 
 use crate::provider::SimplicityNetwork;
+use crate::transaction::UTXO;
 
 use super::error::ProviderError;
 
 pub const DEFAULT_FEE_RATE: f32 = 100.0;
 pub const DEFAULT_ESPLORA_TIMEOUT_SECS: u64 = 10;
 
+#[derive(Debug, Clone)]
+pub struct ProviderInfo {
+    pub esplora_url: String,
+    pub elements_url: Option<String>,
+    pub auth: Option<Auth>,
+}
+
 pub trait ProviderTrait {
     fn get_network(&self) -> &SimplicityNetwork;
 
@@ -22,9 +32,9 @@ pub trait ProviderTrait {
 
     fn fetch_transaction(&self, txid: &Txid) -> Result<Transaction, ProviderError>;
 
-    fn fetch_address_utxos(&self, address: &Address) -> Result<Vec<(OutPoint, TxOut)>, ProviderError>;
+    fn fetch_address_utxos(&self, address: &Address) -> Result<Vec<UTXO>, ProviderError>;
 
-    fn fetch_scripthash_utxos(&self, script: &Script) -> Result<Vec<(OutPoint, TxOut)>, ProviderError>;
+    fn fetch_scripthash_utxos(&self, script: &Script) -> Result<Vec<UTXO>, ProviderError>;
 
     fn fetch_fee_estimates(&self) -> Result<HashMap<String, f64>, ProviderError>;
 

crates/sdk/src/provider/esplora.rs

@@ -6,11 +6,12 @@ use std::time::Duration;
 use simplicityhl::elements::hashes::{Hash, sha256};
 
 use simplicityhl::elements::encode;
-use simplicityhl::elements::{Address, OutPoint, Script, Transaction, TxOut, Txid};
+use simplicityhl::elements::{Address, OutPoint, Script, Transaction, Txid};
 
 use serde::Deserialize;
 
 use crate::provider::SimplicityNetwork;
+use crate::transaction::UTXO;
 
 use super::core::{DEFAULT_ESPLORA_TIMEOUT_SECS, ProviderTrait};
 use super::error::ProviderError;
@@ -73,7 +74,7 @@ impl EsploraProvider {
         Ok(OutPoint::new(txid, utxo.vout))
     }
 
-    fn populate_txouts_from_outpoints(&self, outpoints: &[OutPoint]) -> Result<Vec<(OutPoint, TxOut)>, ProviderError> {
+    fn populate_txouts_from_outpoints(&self, outpoints: &[OutPoint]) -> Result<Vec<UTXO>, ProviderError> {
         let set: HashSet<_> = outpoints.iter().collect();
         let mut map = HashMap::new();
 
@@ -86,11 +87,10 @@ impl EsploraProvider {
         // populate TxOuts
         Ok(outpoints
             .iter()
-            .map(|point| {
-                (
-                    *point,
-                    map.get(&point.txid).unwrap().output[point.vout as usize].clone(),
-                )
+            .map(|point| UTXO {
+                outpoint: *point,
+                txout: map.get(&point.txid).unwrap().output[point.vout as usize].clone(),
+                secrets: None,
             })
             .collect())
     }
@@ -250,7 +250,7 @@ impl ProviderTrait for EsploraProvider {
         Ok(tx)
     }
 
-    fn fetch_address_utxos(&self, address: &Address) -> Result<Vec<(OutPoint, TxOut)>, ProviderError> {
+    fn fetch_address_utxos(&self, address: &Address) -> Result<Vec<UTXO>, ProviderError> {
         let url = format!("{}/address/{}/utxo", self.esplora_url, address);
         let timeout_secs = self.timeout.as_secs();
 
@@ -275,7 +275,7 @@ impl ProviderTrait for EsploraProvider {
         self.populate_txouts_from_outpoints(&outpoints)
     }
 
-    fn fetch_scripthash_utxos(&self, script: &Script) -> Result<Vec<(OutPoint, TxOut)>, ProviderError> {
+    fn fetch_scripthash_utxos(&self, script: &Script) -> Result<Vec<UTXO>, ProviderError> {
         let hash = sha256::Hash::hash(script.as_bytes());
         let hash_bytes = hash.to_byte_array();
         let scripthash = hex::encode(hash_bytes);

crates/sdk/src/provider/mod.rs

@@ -5,7 +5,7 @@ pub mod network;
 pub mod rpc;
 pub mod simplex;
 
-pub use core::ProviderTrait;
+pub use core::{ProviderInfo, ProviderTrait};
 pub use esplora::EsploraProvider;
 pub use rpc::elements::ElementsRpc;
 pub use simplex::SimplexProvider;

crates/sdk/src/provider/simplex.rs

@@ -2,13 +2,13 @@ use std::collections::HashMap;
 
 use electrsd::bitcoind::bitcoincore_rpc::Auth;
 
-use simplicityhl::elements::{Address, OutPoint, Script, Transaction, TxOut, Txid};
+use simplicityhl::elements::{Address, Script, Transaction, Txid};
 
 use crate::provider::SimplicityNetwork;
+use crate::transaction::UTXO;
 
 use super::core::ProviderTrait;
 use super::error::ProviderError;
-
 use super::{ElementsRpc, EsploraProvider};
 
 pub struct SimplexProvider {
@@ -17,16 +17,11 @@ pub struct SimplexProvider {
 }
 
 impl SimplexProvider {
-    pub fn new(
-        esplora_url: String,
-        elements_url: String,
-        auth: Auth,
-        network: SimplicityNetwork,
-    ) -> Result<Self, ProviderError> {
-        Ok(Self {
+    pub fn new(esplora_url: String, elements_url: String, auth: Auth, network: SimplicityNetwork) -> Self {
+        Self {
             esplora: EsploraProvider::new(esplora_url, network),
-            elements: ElementsRpc::new(elements_url, auth)?,
-        })
+            elements: ElementsRpc::new(elements_url, auth).unwrap(),
+        }
     }
 }
 
@@ -59,11 +54,11 @@ impl ProviderTrait for SimplexProvider {
         self.esplora.fetch_transaction(txid)
     }
 
-    fn fetch_address_utxos(&self, address: &Address) -> Result<Vec<(OutPoint, TxOut)>, ProviderError> {
+    fn fetch_address_utxos(&self, address: &Address) -> Result<Vec<UTXO>, ProviderError> {
         self.esplora.fetch_address_utxos(address)
     }
 
-    fn fetch_scripthash_utxos(&self, script: &Script) -> Result<Vec<(OutPoint, TxOut)>, ProviderError> {
+    fn fetch_scripthash_utxos(&self, script: &Script) -> Result<Vec<UTXO>, ProviderError> {
         self.esplora.fetch_scripthash_utxos(script)
     }