Inside Bitcoin

251    ):
252        self.log.info(f"Importing private Miniscript descriptor '{desc}'")
253        is_taproot = desc.startswith("tr(")
254        desc = descsum_create(desc)
255        res = self.ms_sig_wallet.importdescriptors(
256            [
257                {
258                    "desc": desc,
259                    "active": True,
260                    "range": 0,
261                    "next_index": 0,
262                    "timestamp": "now",
263                }
264            ]
265        )
266        assert res[0]["success"], res
267
268        self.log.info("Generating an address for it and testing it detects funds")
269        addr_type = "bech32m" if is_taproot else "bech32"
270        addr = self.ms_sig_wallet.getnewaddress(address_type=addr_type)
271        txid = self.funder.sendtoaddress(addr, 0.01)
272        self.wait_until(lambda: txid in self.funder.getrawmempool())
273        self.funder.generatetoaddress(1, self.funder.getnewaddress())
274        utxo = self.ms_sig_wallet.listunspent(addresses=[addr])[0]
275        assert_equal(txid, utxo["txid"])
276        assert_equal(utxo["solvable"], True)
277
278        self.log.info("Creating a transaction spending these funds")
279        dest_addr = self.funder.getnewaddress()
280        seq = sequence if sequence is not None else 0xFFFFFFFF - 2
281        lt = locktime if locktime is not None else 0
282        psbt = self.ms_sig_wallet.createpsbt(
283            [
284                {
285                    "txid": txid,
286                    "vout": utxo["vout"],
287                    "sequence": seq,
288                }
289            ],
290            [{dest_addr: 0.009}],
291            lt,
292        )
293
294        self.log.info("Signing it and checking the satisfaction.")
295        if sha256_preimages is not None:
296            psbt = PSBT.from_base64(psbt)
297            for (h, preimage) in sha256_preimages.items():
298                k = PSBT_IN_SHA256.to_bytes(1, "big") + bytes.fromhex(h)
299                psbt.i[0].map[k] = bytes.fromhex(preimage)
300            psbt = psbt.to_base64()
301        res = self.ms_sig_wallet.walletprocesspsbt(psbt=psbt, finalize=False)
302        psbtin = self.nodes[0].decodepsbt(res["psbt"])["inputs"][0]
303        sigs_field_name = "taproot_script_path_sigs" if is_taproot else "partial_signatures"
304        assert_equal(len(psbtin[sigs_field_name]), sigs_count)
305        res = self.ms_sig_wallet.finalizepsbt(res["psbt"])
306        assert_equal(res["complete"], stack_size is not None)
307
308        if stack_size is not None:
309            txin = self.nodes[0].decoderawtransaction(res["hex"])["vin"][0]
310            assert len(txin["txinwitness"]) == stack_size, txin["txinwitness"]
311            self.log.info("Broadcasting the transaction.")
312            # If necessary, satisfy a relative timelock
313            if sequence is not None:
314                self.funder.generatetoaddress(sequence, self.funder.getnewaddress())
315            # If necessary, satisfy an absolute timelock
316            height = self.funder.getblockcount()
317            if locktime is not None and height < locktime:
318                self.funder.generatetoaddress(
319                    locktime - height, self.funder.getnewaddress()
320                )
321            self.ms_sig_wallet.sendrawtransaction(res["hex"])
322
323    def run_test(self):
324        self.log.info("Making a descriptor wallet")
325        self.funder = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
326        self.nodes[0].createwallet(
327            wallet_name="ms_wo", disable_private_keys=True
328        )
329        self.ms_wo_wallet = self.nodes[0].get_wallet_rpc("ms_wo")
330        self.nodes[0].createwallet(wallet_name="ms_sig")
331        self.ms_sig_wallet = self.nodes[0].get_wallet_rpc("ms_sig")
332
333        # Sanity check we wouldn't let an insane Miniscript descriptor in
334        res = self.ms_wo_wallet.importdescriptors(
335            [
336                {
337                    "desc": descsum_create(
338                        "wsh(and_b(ripemd160(1fd9b55a054a2b3f658d97e6b84cf3ee00be429a),a:1))"
339                    ),
340                    "active": False,
341                    "timestamp": "now",
342                }
343            ]
344        )[0]
345        assert_equal(res["success"], False)
346        assert "is not sane: witnesses without signature exist" in res["error"]["message"]
347
348        # Sanity check we wouldn't let an unspendable Miniscript descriptor in
349        res = self.ms_wo_wallet.importdescriptors(
350            [
351                {
352                    "desc": descsum_create("wsh(0)"),
353                    "active": False,
354                    "timestamp": "now",
355                }
356            ]
357        )[0]
358        assert not res["success"] and "is not satisfiable" in res["error"]["message"]
359
360        # Test we can track any type of Miniscript
361        for desc in DESCS:
362            self.watchonly_test(desc)
363
364        # Test we can sign for any Miniscript.
365        for desc in DESCS_PRIV:
366            self.signing_test(
367                desc["desc"],
368                desc["sequence"],
369                desc["locktime"],
370                desc["sigs_count"],
371                desc["stack_size"],
372                desc.get("sha256_preimages"),
373            )
374
375        # Test we can sign for a max-size TapMiniscript. Recompute the maximum accepted size
376        # for a TapMiniscript (see cpp file for details). Then pad a simple pubkey check up
377        # to the maximum size. Make sure we can import and spend this script.
378        leeway_weight = (4 + 4 + 1 + 36 + 4 + 1 + 1 + 8 + 1 + 1 + 33) * 4 + 2
379        max_tapmini_size = 400_000 - 3 - (1 + 65) * 1_000 - 3 - (33 + 32 * 128) - leeway_weight - 5
380        padding = max_tapmini_size - 33 - 1
381        ms = f"pk({TPRVS[0]}/*)"
382        ms = "n" * padding + ":" + ms
383        desc = f"tr({PUBKEYS[0]},{ms})"
384        self.signing_test(desc, None, None, 1, 3, None)
385        # This was really the maximum size, one more byte and we can't import it.
386        ms = "n" + ms
387        desc = f"tr({PUBKEYS[0]},{ms})"
388        res = self.ms_wo_wallet.importdescriptors(
389            [
390                {
391                    "desc": descsum_create(desc),
392                    "active": False,
393                    "timestamp": "now",
394                }
395            ]
396        )[0]
397        assert_equal(res["success"], False)
398        assert "is not a valid descriptor function" in res["error"]["message"]
399
400
401if __name__ == "__main__":
402    WalletMiniscriptTest(__file__).main()
403