Trait sapio_miniscript::descriptor::DescriptorTrait

source · 
pub trait DescriptorTrait<Pk: MiniscriptKey> {
    // Required methods
    fn sanity_check(&self) -> Result<(), Error>;
    fn address(&self, network: Network) -> Result<Address, Error>
       where Pk: ToPublicKey;
    fn script_pubkey(&self) -> Script
       where Pk: ToPublicKey;
    fn unsigned_script_sig(&self) -> Script
       where Pk: ToPublicKey;
    fn explicit_script(&self) -> Result<Script, Error>
       where Pk: ToPublicKey;
    fn get_satisfaction<S>(
        &self,
        satisfier: S
    ) -> Result<(Vec<Vec<u8>>, Script), Error>
       where Pk: ToPublicKey,
             S: Satisfier<Pk>;
    fn get_satisfaction_mall<S>(
        &self,
        satisfier: S
    ) -> Result<(Vec<Vec<u8>>, Script), Error>
       where Pk: ToPublicKey,
             S: Satisfier<Pk>;
    fn max_satisfaction_weight(&self) -> Result<usize, Error>;
    fn script_code(&self) -> Result<Script, Error>
       where Pk: ToPublicKey;

    // Provided method
    fn satisfy<S>(&self, txin: &mut TxIn, satisfier: S) -> Result<(), Error>
       where Pk: ToPublicKey,
             S: Satisfier<Pk> { ... }
}
Expand description

A general trait for Bitcoin descriptor. Offers function for witness cost estimation, script pubkey creation satisfaction using the Satisfier trait.

Required Methods§

source

fn sanity_check(&self) -> Result<(), Error>

Whether the descriptor is safe Checks whether all the spend paths in the descriptor are possible on the bitcoin network under the current standardness and consensus rules Also checks whether the descriptor requires signauture on all spend paths And whether the script is malleable. In general, all the guarantees of miniscript hold only for safe scripts. All the analysis guarantees of miniscript only hold safe scripts. The signer may not be able to find satisfactions even if one exists

source

fn address(&self, network: Network) -> Result<Address, Error>
where Pk: ToPublicKey,

Computes the Bitcoin address of the descriptor, if one exists Some descriptors like pk() don’t have any address. Errors:

  • On raw/bare descriptors that don’t have any address
source

fn script_pubkey(&self) -> Script
where Pk: ToPublicKey,

Computes the scriptpubkey of the descriptor

source

fn unsigned_script_sig(&self) -> Script
where Pk: ToPublicKey,

Computes the scriptSig that will be in place for an unsigned input spending an output with this descriptor. For pre-segwit descriptors, which use the scriptSig for signatures, this returns the empty script.

This is used in Segwit transactions to produce an unsigned transaction whose txid will not change during signing (since only the witness data will change).

source

fn explicit_script(&self) -> Result<Script, Error>
where Pk: ToPublicKey,

Computes the “witness script” of the descriptor, i.e. the underlying script before any hashing is done. For Bare, Pkh and Wpkh this is the scriptPubkey; for ShWpkh and Sh this is the redeemScript; for the others it is the witness script. For Tr descriptors, this will error as there is no underlying script

source

fn get_satisfaction<S>( &self, satisfier: S ) -> Result<(Vec<Vec<u8>>, Script), Error>
where Pk: ToPublicKey, S: Satisfier<Pk>,

Returns satisfying non-malleable witness and scriptSig with minimum weight to spend an output controlled by the given descriptor if it possible to construct one using the satisfier S.

source

fn get_satisfaction_mall<S>( &self, satisfier: S ) -> Result<(Vec<Vec<u8>>, Script), Error>
where Pk: ToPublicKey, S: Satisfier<Pk>,

Returns satisfying, possibly malleable witness and scriptSig to spend an output controlled by the given descriptor if it possible to construct one using the satisfier S.

source

fn max_satisfaction_weight(&self) -> Result<usize, Error>

Computes an upper bound on the weight of a satisfying witness to the transaction. Assumes all ec-signatures are 73 bytes, including push opcode and sighash suffix. Includes the weight of the VarInts encoding the scriptSig and witness stack length. Returns Error when the descriptor is impossible to safisfy (ex: sh(OP_FALSE))

source

fn script_code(&self) -> Result<Script, Error>
where Pk: ToPublicKey,

Get the scriptCode of a transaction output.

The scriptCode is the Script of the previous transaction output being serialized in the sighash when evaluating a CHECKSIG & co. OP code. Errors:

  • When the descriptor is Tr

Provided Methods§

source

fn satisfy<S>(&self, txin: &mut TxIn, satisfier: S) -> Result<(), Error>
where Pk: ToPublicKey, S: Satisfier<Pk>,

Attempts to produce a non-malleable satisfying witness and scriptSig to spend an output controlled by the given descriptor; add the data to a given TxIn output.

Examples found in repository?
examples/sign_multisig.rs (line 123)
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

fn main() {
    // Avoid repeatedly typing a pretty-common descriptor type
    type BitcoinDescriptor = miniscript::Descriptor<bitcoin::PublicKey>;

    // Transaction which spends some output
    let mut tx = bitcoin::Transaction {
        version: 2,
        lock_time: 0,
        input: vec![bitcoin::TxIn {
            previous_output: Default::default(),
            script_sig: bitcoin::Script::new(),
            sequence: 0xffffffff,
            witness: Witness::default(),
        }],
        output: vec![bitcoin::TxOut {
            script_pubkey: bitcoin::Script::new(),
            value: 100_000_000,
        }],
    };

    #[cfg_attr(feature="cargo-fmt", rustfmt_skip)]
    let public_keys = vec![
        bitcoin::PublicKey::from_slice(&[2; 33]).expect("key 1"),
        bitcoin::PublicKey::from_slice(&[
            0x02,
            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        ]).expect("key 2"),
        bitcoin::PublicKey::from_slice(&[
            0x03,
            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        ]).expect("key 3"),
    ];
    let bitcoin_sig = bitcoin::EcdsaSig {
        // copied at random off the blockchain; this is not actually a valid
        // signature for this transaction; Miniscript does not verify
        sig: secp256k1::ecdsa::Signature::from_str(
            "3045\
             0221\
             00f7c3648c390d87578cd79c8016940aa8e3511c4104cb78daa8fb8e429375efc1\
             0220\
             531d75c136272f127a5dc14acc0722301cbddc222262934151f140da345af177",
        )
        .unwrap(),
        hash_ty: bitcoin::EcdsaSighashType::All,
    };

    let descriptor_str = format!(
        "wsh(multi(2,{},{},{}))",
        public_keys[0], public_keys[1], public_keys[2],
    );

    // Descriptor for the output being spent
    let my_descriptor =
        BitcoinDescriptor::from_str(&descriptor_str[..]).expect("parse descriptor string");

    // Check weight for witness satisfaction cost ahead of time.
    // 4(scriptSig length of 0) + 1(witness stack size) + 106(serialized witnessScript)
    // + 73*2(signature length + signatures + sighash bytes) + 1(dummy byte) = 258
    assert_eq!(my_descriptor.max_satisfaction_weight().unwrap(), 258);

    // Sometimes it is necessary to have additional information to get the bitcoin::PublicKey
    // from the MiniscriptKey which can supplied by `to_pk_ctx` parameter. For example,
    // when calculating the script pubkey of a descriptor with xpubs, the secp context and
    // child information maybe required.

    // Observe the script properties, just for fun
    assert_eq!(
        format!("{:x}", my_descriptor.script_pubkey()),
        "00200ed49b334a12c37f3df8a2974ad91ff95029215a2b53f78155be737907f06163"
    );

    assert_eq!(
        format!(
            "{:x}",
            my_descriptor
                .explicit_script()
                .expect("wsh descriptors have unique inner script")
        ),
        "52\
         21020202020202020202020202020202020202020202020202020202020202020202\
         21020102030405060708010203040506070801020304050607080000000000000000\
         21030102030405060708010203040506070801020304050607080000000000000000\
         53ae"
    );

    // Attempt to satisfy at age 0, height 0
    let original_txin = tx.input[0].clone();

    let mut sigs = HashMap::<bitcoin::PublicKey, miniscript::bitcoin::EcdsaSig>::new();

    // Doesn't work with no signatures
    assert!(my_descriptor.satisfy(&mut tx.input[0], &sigs).is_err());
    assert_eq!(tx.input[0], original_txin);

    // ...or one signature...
    sigs.insert(public_keys[1], bitcoin_sig);
    assert!(my_descriptor.satisfy(&mut tx.input[0], &sigs).is_err());
    assert_eq!(tx.input[0], original_txin);

    // ...but two signatures is ok
    sigs.insert(public_keys[2], bitcoin_sig);
    assert!(my_descriptor.satisfy(&mut tx.input[0], &sigs).is_ok());
    assert_ne!(tx.input[0], original_txin);
    assert_eq!(tx.input[0].witness.len(), 4); // 0, sig, sig, witness script

    // ...and even if we give it a third signature, only two are used
    sigs.insert(public_keys[0], bitcoin_sig);
    assert!(my_descriptor.satisfy(&mut tx.input[0], &sigs).is_ok());
    assert_ne!(tx.input[0], original_txin);
    assert_eq!(tx.input[0].witness.len(), 4); // 0, sig, sig, witness script
}

Object Safety§

This trait is not object safe.

Implementors§