Merge rust-bitcoin/rust-miniscript#646: Introduce an example binary useful for profiling

c8d3b9ac1f9ec913eb30768439f0f5f4db9a02be fix formatting in big example (Riccardo Casatta)
bc47538c2b0e126fbea20de9c27f4a6aea61d711 add taproot calls in big executable (Riccardo Casatta)
545bbbebe97bbad0080ad58b6ab2d6403ac0211b add satisfy call in big executable (Riccardo Casatta)
959546b5ec6c12a40f6838f48e6ca67690638e21 add psbt finalize call in big executable (Riccardo Casatta)
883132ed7a1d26fd0650dda7732d8dd1e250baad add policy calls in big executable (Riccardo Casatta)
ec751fb06b7af82f20936208c377c61960f53648 Introduce an example binary useful for profiling (Riccardo Casatta)

Pull request description:

  Tools like `cargo bloat` don't work on libraries but on final executable.

  As seen in rust-bitcoin/rust-miniscript#585 and rust-bitcoin/rust-miniscript#584 the parse example is used as a base to profile binary bloat.

  However, since the parse example is not using all the API surface, we may have good optimization that are not recognized as such because the optimized function are not in the tree of the functions used.

  For benchmarking size optimization a specific binary that ideally touch all the API surface is needed and this MR introduce it.

  More coverage will be added if this seem a good idea for reviewers.

ACKs for top commit:
  apoelstra:
    ACK c8d3b9ac1f9ec913eb30768439f0f5f4db9a02be thanks!

Tree-SHA512: 70ac51a222b59b5de76a2ef314be2f3d82b3f5831d90dd7110929a4956a27a6d1eaa4889525dbf54575fb7e07db60f19d67556f2539b61979b4ba681fec0523e

Author: heap-coder

Cargo.toml

@@ -61,6 +61,10 @@ required-features = ["compiler","std"]
 name = "psbt_sign_finalize"
 required-features = ["std", "base64"]
 
+[[example]]
+name = "big"
+required-features = ["std", "base64", "compiler"]
+
 [workspace]
 members = ["bitcoind-tests", "fuzz"]
 exclude = ["embedded"]

examples/big.rs

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: CC0-1.0
+//! This is not an example and will surely panic if executed, the purpose of this is using the
+//! compiled binary with tools like `cargo bloat` that cannot work with libraries.
+//!
+//! Ideal properties:
+//!
+//! * Call all the library API surface.
+//! * Depend on user input so that functions are not stripped out on the base of static input.
+//! * Use results so that calls are not stripped out.
+//!
+
+use std::collections::HashMap;
+use std::str::FromStr;
+
+use bitcoin::{ecdsa, XOnlyPublicKey};
+use miniscript::descriptor::Wsh;
+use miniscript::policy::{Concrete, Liftable};
+use miniscript::psbt::PsbtExt;
+use miniscript::{
+    translate_hash_fail, DefiniteDescriptorKey, Descriptor, DescriptorPublicKey, MiniscriptKey,
+    TranslatePk, Translator,
+};
+use secp256k1::Secp256k1;
+fn main() {
+    let empty = "".to_string();
+    let mut args = std::env::args().collect::<Vec<_>>();
+    let i = args.pop().unwrap_or(empty);
+
+    let d = Descriptor::<DescriptorPublicKey>::from_str(&i).unwrap();
+    use_descriptor(d.clone());
+    use_descriptor(Descriptor::<DefiniteDescriptorKey>::from_str(&i).unwrap());
+    use_descriptor(Descriptor::<bitcoin::PublicKey>::from_str(&i).unwrap());
+    use_descriptor(Descriptor::<String>::from_str(&i).unwrap());
+
+    let a = d
+        .at_derivation_index(0)
+        .unwrap()
+        .address(bitcoin::Network::Bitcoin)
+        .unwrap();
+    println!("{}", a);
+
+    let secp = Secp256k1::new();
+    let (d, m) = Descriptor::parse_descriptor(&secp, &i).unwrap();
+    use_descriptor(d);
+    println!("{:?}", m);
+
+    let p = Concrete::<bitcoin::PublicKey>::from_str(&i).unwrap();
+    let h = Wsh::new(p.compile().unwrap()).unwrap();
+    println!("{}", h);
+    println!("{:?}", h.lift());
+    println!("{:?}", h.script_pubkey());
+    println!("{:?}", h.address(bitcoin::Network::Bitcoin));
+
+    let psbt: bitcoin::Psbt = i.parse().unwrap();
+    let psbt = psbt.finalize(&secp).unwrap();
+    let mut tx = psbt.extract_tx().unwrap();
+    println!("{:?}", tx);
+
+    let d = miniscript::Descriptor::<bitcoin::PublicKey>::from_str(&i).unwrap();
+    let sigs = HashMap::<bitcoin::PublicKey, ecdsa::Signature>::new();
+    d.satisfy(&mut tx.input[0], &sigs).unwrap();
+
+    let pol = Concrete::<String>::from_str(&i).unwrap();
+    let desc = pol.compile_tr(Some("UNSPENDABLE_KEY".to_string())).unwrap();
+    println!("{}", desc);
+    let pk_map = HashMap::new();
+    let mut t = StrPkTranslator { pk_map };
+    let real_desc = desc.translate_pk(&mut t).unwrap();
+    println!("{}", real_desc);
+    let addr = real_desc.address(bitcoin::Network::Bitcoin).unwrap();
+    println!("{}", addr);
+}
+
+fn use_descriptor<K: MiniscriptKey>(d: Descriptor<K>) {
+    println!("{}", d);
+    println!("{:?}", d);
+    println!("{:?}", d.desc_type());
+    println!("{:?}", d.sanity_check());
+}
+
+struct StrPkTranslator {
+    pk_map: HashMap<String, XOnlyPublicKey>,
+}
+
+impl Translator<String, XOnlyPublicKey, ()> for StrPkTranslator {
+    fn pk(&mut self, pk: &String) -> Result<XOnlyPublicKey, ()> {
+        self.pk_map.get(pk).copied().ok_or(())
+    }
+
+    // We don't need to implement these methods as we are not using them in the policy.
+    // Fail if we encounter any hash fragments. See also translate_hash_clone! macro.
+    translate_hash_fail!(String, XOnlyPublicKey, ());
+}