Blinding API cleanups

examples/pset_blind_coinjoin.rs

@@ -266,20 +266,16 @@ fn main() {
     // ----------------------------------------------------------
     // B Adds it's own outputs. Step 2 completed
     // ----- Step 3: B to blind it's own outputs
-    let inp_txout_sec = [
-        None,
-        Some(&asset_txout_secrets.sec),
-    ];
+    let mut inp_txout_sec = HashMap::new();
+    inp_txout_sec.insert(1, asset_txout_secrets.sec);
 
     pset.blind_non_last(&mut rng, &secp, &inp_txout_sec).unwrap();
     assert_eq!(pset, deser_pset(&tests["pset_coinjoined_B_blinded"]));
 
     // Step 4: A blinds it's own inputs
-    let inp_txout_sec = [
-        Some(&btc_txout_secrets.sec),
-        None,
-    ];
-    pset.blind_last(&mut rng, &secp, &inp_txout_sec).unwrap();
+    let mut inp_txout_sec_a = HashMap::new();
+    inp_txout_sec_a.insert(0, btc_txout_secrets.sec);
+    pset.blind_last(&mut rng, &secp, &inp_txout_sec_a).unwrap();
     assert_eq!(pset, deser_pset(&tests["pset_coinjoined_blinded"]));
 
     // check whether the blinding was correct

examples/raw_blind.rs

@@ -10,7 +10,7 @@ use elements::{
     bitcoin::PublicKey, pset::PartiallySignedTransaction as Pset, Address, AddressParams, OutPoint,
     Script, TxOutSecrets, TxOutWitness, Txid, WScriptHash,
 };
-use elements::{pset, secp256k1_zkp};
+use elements::{pset, secp256k1_zkp, SurjectionInput};
 
 use elements::encode::{deserialize, serialize_hex};
 use elements::hashes::hex::FromHex;
@@ -168,8 +168,8 @@ fn main() {
     // Add outputs
     // Send 5_000 worth of asset units to new address
     let inputs = [
-        (btc_txout.asset, Some(&btc_txout_secrets.sec)),
-        (asset_txout.asset, Some(&asset_txout_secrets.sec)),
+        (SurjectionInput::from_txout_secrets(btc_txout_secrets.sec)),
+        (SurjectionInput::from_txout_secrets(asset_txout_secrets.sec)),
     ];
 
     let dest_wsh =
@@ -179,7 +179,7 @@ fn main() {
     let dest_blind_pk =
         PublicKey::from_str("0212bf0ea45b733dfde8ecb5e896306c4165c666c99fc5d1ab887f71393a975cea")
             .unwrap();
-    let (dest_asset_txout, dest_abf, dest_vbf) = TxOut::new_not_last_confidential(
+    let (dest_asset_txout, dest_abf, dest_vbf, _) = TxOut::new_not_last_confidential(
         &mut rng,
         &secp,
         dest_amt,
@@ -200,7 +200,7 @@ fn main() {
     let change_wsh =
         WScriptHash::from_str("f6b43d56e004e9d0b1ec2fc3c95511d81af08420992be8dec7f86cdf8970b3e2")
             .unwrap();
-    let (change_asset_txout, asset_change_abf, asset_change_vbf) =
+    let (change_asset_txout, asset_change_abf, asset_change_vbf, _) =
         TxOut::new_not_last_confidential(
             &mut rng,
             &secp,
@@ -254,19 +254,16 @@ fn main() {
 
     // For the last output we require all secrets.
     let inputs = [
-        (btc_txout.asset, &btc_txout_secrets.sec),
-        (asset_txout.asset, &asset_txout_secrets.sec),
+        btc_txout_secrets.sec,
+        asset_txout_secrets.sec,
     ];
-    let (btc_change_txout, _abf, _vbf) = TxOut::new_last_confidential(
+    let (btc_change_txout, _abf, _vbf, _) = TxOut::new_last_confidential(
         &mut rng,
         &secp,
         change_amt,
-        Address::p2wsh(
-            &Script::new_v0_wsh(&change_wsh),
-            Some(change_blind_pk.inner),
-            &PARAMS,
-        ),
         btc_txout_secrets.sec.asset,
+        Script::new_v0_wsh(&change_wsh),
+        change_blind_pk.inner,
         &inputs,
         &output_secrets,
     )

src/address.rs

@@ -146,6 +146,15 @@ impl AddressParams {
         bech_hrp: "ert",
         blech_hrp: "el",
     };
+
+    /// The default liquid testnet network address parameters.
+    pub const LIQUID_TESTNET: AddressParams = AddressParams {
+        p2pkh_prefix: 36,
+        p2sh_prefix: 19,
+        blinded_prefix: 23,
+        bech_hrp: "tex",
+        blech_hrp: "tlq",
+    };
 }
 
 /// The method used to produce an address
@@ -439,7 +448,7 @@ impl Address {
         if data.len() < 2 || data.len() > 40 + if blinded { 33 } else { 0 } {
             return Err(AddressError::InvalidWitnessProgramLength(data.len() - if blinded { 33 } else { 0 }));
         }
- 
+
         // Specific segwit v0 check.
         if !blinded && version.to_u8() == 0 && data.len() != 20 && data.len() != 32 {
             return Err(AddressError::InvalidSegwitV0ProgramLength(data.len()));
@@ -649,20 +658,19 @@ impl FromStr for Address {
         // shorthands
         let liq = &AddressParams::LIQUID;
         let ele = &AddressParams::ELEMENTS;
+        let liq_test = &AddressParams::LIQUID_TESTNET;
+
+        let net_arr = [liq, ele, liq_test];
 
-        // Bech32.
         let prefix = find_prefix(s);
-        if match_prefix(prefix, liq.bech_hrp) {
-            return Address::from_bech32(s, false, liq);
-        }
-        if match_prefix(prefix, liq.blech_hrp) {
-            return Address::from_bech32(s, true, liq);
-        }
-        if match_prefix(prefix, ele.bech_hrp) {
-            return Address::from_bech32(s, false, ele);
-        }
-        if match_prefix(prefix, ele.blech_hrp) {
-            return Address::from_bech32(s, true, ele);
+        for net in net_arr.iter() {
+            // Bech32.
+            if match_prefix(prefix, net.bech_hrp) {
+                return Address::from_bech32(s, false, net);
+            }
+            if match_prefix(prefix, net.blech_hrp) {
+                return Address::from_bech32(s, true, net);
+            }
         }
 
         // Base58.
@@ -675,11 +683,10 @@ impl FromStr for Address {
         }
 
         let p = data[0];
-        if p == liq.p2pkh_prefix || p == liq.p2sh_prefix || p == liq.blinded_prefix {
-            return Address::from_base58(&data, liq);
-        }
-        if p == ele.p2pkh_prefix || p == ele.p2sh_prefix || p == ele.blinded_prefix {
-            return Address::from_base58(&data, ele);
+        for net in net_arr.iter() {
+            if p == net.p2pkh_prefix || p == net.p2sh_prefix || p == net.blinded_prefix {
+                return Address::from_base58(&data, net);
+            }
         }
 
         Err(AddressError::InvalidAddress(s.to_owned()))