@btc-vision/bitcoin 6.3.6 → 6.4.0

package/test/integration/transactions.spec.ts

@@ -1,769 +1,668 @@
-import * as assert from 'assert';
-import BIP32Factory from 'bip32';
-import * as ecc from 'tiny-secp256k1';
-import ECPairFactory from 'ecpair';
-import { describe, it } from 'mocha';
-import * as bitcoin from '../..';
-import { regtestUtils } from './_regtest';
-
-const ECPair = ECPairFactory(ecc);
-const rng = require('randombytes');
-const regtest = regtestUtils.network;
-const bip32 = BIP32Factory(ecc);
-
-const validator = (
-    pubkey: Buffer,
-    msghash: Buffer,
-    signature: Buffer,
-): boolean => ECPair.fromPublicKey(pubkey).verify(msghash, signature);
-
-// See bottom of file for some helper functions used to make the payment objects needed.
-
-describe('bitcoinjs-lib (transactions with psbt)', () => {
-    it('can create a 1-to-1 Transaction', () => {
-        const alice = ECPair.fromWIF(
-            'L2uPYXe17xSTqbCjZvL2DsyXPCbXspvcu5mHLDYUgzdUbZGSKrSr',
-        );
-        const psbt = new bitcoin.Psbt();
-        psbt.setVersion(2); // These are defaults. This line is not needed.
-        psbt.setLocktime(0); // These are defaults. This line is not needed.
-        psbt.addInput({
-            // if hash is string, txid, if hash is Buffer, is reversed compared to txid
-            hash: '7d067b4a697a09d2c3cff7d4d9506c9955e93bff41bf82d439da7d030382bc3e',
-            index: 0,
-            sequence: 0xffffffff, // These are defaults. This line is not needed.
-
-            // non-segwit inputs now require passing the whole previous tx as Buffer
-            nonWitnessUtxo: Buffer.from(
-                '0200000001f9f34e95b9d5c8abcd20fc5bd4a825d1517be62f0f775e5f36da944d9' +
-                    '452e550000000006b483045022100c86e9a111afc90f64b4904bd609e9eaed80d48' +
-                    'ca17c162b1aca0a788ac3526f002207bb79b60d4fc6526329bf18a77135dc566020' +
-                    '9e761da46e1c2f1152ec013215801210211755115eabf846720f5cb18f248666fec' +
-                    '631e5e1e66009ce3710ceea5b1ad13ffffffff01' +
-                    // value in satoshis (Int64LE) = 0x015f90 = 90000
-                    '905f010000000000' +
-                    // scriptPubkey length
-                    '19' +
-                    // scriptPubkey
-                    '76a9148bbc95d2709c71607c60ee3f097c1217482f518d88ac' +
-                    // locktime
-                    '00000000',
-                'hex',
-            ),
-
-            // // If this input was segwit, instead of nonWitnessUtxo, you would add
-            // // a witnessUtxo as follows. The scriptPubkey and the value only are needed.
-            // witnessUtxo: {
-            //   script: Buffer.from(
-            //     '76a9148bbc95d2709c71607c60ee3f097c1217482f518d88ac',
-            //     'hex',
-            //   ),
-            //   value: 90000,
-            // },
-
-            // Not featured here:
-            //   redeemScript. A Buffer of the redeemScript for P2SH
-            //   witnessScript. A Buffer of the witnessScript for P2WSH
-        });
-        psbt.addOutput({
-            address: '1KRMKfeZcmosxALVYESdPNez1AP1mEtywp',
-            value: 80000,
-        });
-        psbt.signInput(0, alice);
-        psbt.validateSignaturesOfInput(0, validator);
-        psbt.finalizeAllInputs();
-        assert.strictEqual(
-            psbt.extractTransaction().toHex(),
-            '02000000013ebc8203037dda39d482bf41ff3be955996c50d9d4f7cfc3d2097a694a7' +
-                'b067d000000006b483045022100931b6db94aed25d5486884d83fc37160f37f3368c0' +
-                'd7f48c757112abefec983802205fda64cff98c849577026eb2ce916a50ea70626a766' +
-                '9f8596dd89b720a26b4d501210365db9da3f8a260078a7e8f8b708a1161468fb2323f' +
-                'fda5ec16b261ec1056f455ffffffff0180380100000000001976a914ca0d36044e0dc' +
-                '08a22724efa6f6a07b0ec4c79aa88ac00000000',
-        );
-    });
-
-    it('can create (and broadcast via 3PBP) a typical Transaction', async () => {
-        // these are { payment: Payment; keys: ECPair[] }
-        const alice1 = createPayment('p2pkh');
-        const alice2 = createPayment('p2pkh');
-
-        // give Alice 2 unspent outputs
-        const inputData1 = await getInputData(
-            5e4,
-            alice1.payment,
-            false,
-            'noredeem',
-        );
-        const inputData2 = await getInputData(
-            7e4,
-            alice2.payment,
-            false,
-            'noredeem',
-        );
-        {
-            const {
-                hash, // string of txid or Buffer of tx hash. (txid and hash are reverse order)
-                index, // the output index of the txo you are spending
-                nonWitnessUtxo, // the full previous transaction as a Buffer
-            } = inputData1;
-            assert.deepStrictEqual({ hash, index, nonWitnessUtxo }, inputData1);
-        }
-
-        // network is only needed if you pass an address to addOutput
-        // using script (Buffer of scriptPubkey) instead will avoid needed network.
-        const psbt = new bitcoin.Psbt({ network: regtest })
-            .addInput(inputData1) // alice1 unspent
-            .addInput(inputData2) // alice2 unspent
-            .addOutput({
-                address: 'mwCwTceJvYV27KXBc3NJZys6CjsgsoeHmf',
-                value: 8e4,
-            }) // the actual "spend"
-            .addOutput({
-                address: alice2.payment.address, // OR script, which is a Buffer.
-                value: 1e4,
-            }); // Alice's change
-        // (in)(5e4 + 7e4) - (out)(8e4 + 1e4) = (fee)3e4 = 30000, this is the miner fee
-
-        // Let's show a new feature with PSBT.
-        // We can have multiple signers sign in parallel and combine them.
-        // (this is not necessary, but a nice feature)
-
-        // encode to send out to the signers
-        const psbtBaseText = psbt.toBase64();
-
-        // each signer imports
-        const signer1 = bitcoin.Psbt.fromBase64(psbtBaseText);
-        const signer2 = bitcoin.Psbt.fromBase64(psbtBaseText);
-
-        // Alice signs each input with the respective private keys
-        // signInput and signInputAsync are better
-        // (They take the input index explicitly as the first arg)
-        signer1.signAllInputs(alice1.keys[0]);
-        signer2.signAllInputs(alice2.keys[0]);
-
-        // If your signer object's sign method returns a promise, use the following
-        // await signer2.signAllInputsAsync(alice2.keys[0])
-
-        // encode to send back to combiner (signer 1 and 2 are not near each other)
-        const s1text = signer1.toBase64();
-        const s2text = signer2.toBase64();
-
-        const final1 = bitcoin.Psbt.fromBase64(s1text);
-        const final2 = bitcoin.Psbt.fromBase64(s2text);
-
-        // final1.combine(final2) would give the exact same result
-        psbt.combine(final1, final2);
-
-        // Finalizer wants to check all signatures are valid before finalizing.
-        // If the finalizer wants to check for specific pubkeys, the second arg
-        // can be passed. See the first multisig example below.
-        assert.strictEqual(psbt.validateSignaturesOfInput(0, validator), true);
-        assert.strictEqual(psbt.validateSignaturesOfInput(1, validator), true);
-
-        // This step it new. Since we separate the signing operation and
-        // the creation of the scriptSig and witness stack, we are able to
-        psbt.finalizeAllInputs();
-
-        // build and broadcast our RegTest network
-        await regtestUtils.broadcast(psbt.extractTransaction().toHex());
-        // to build and broadcast to the actual Bitcoin network, see https://github.com/bitcoinjs/bitcoinjs-lib/issues/839
-    });
-
-    it('can create (and broadcast via 3PBP) a Transaction with an OP_RETURN output', async () => {
-        const alice1 = createPayment('p2pkh');
-        const inputData1 = await getInputData(
-            2e5,
-            alice1.payment,
-            false,
-            'noredeem',
-        );
-
-        const data = Buffer.from('bitcoinjs-lib', 'utf8');
-        const embed = bitcoin.payments.embed({ data: [data] });
-
-        const psbt = new bitcoin.Psbt({ network: regtest })
-            .addInput(inputData1)
-            .addOutput({
-                script: embed.output!,
-                value: 1000,
-            })
-            .addOutput({
-                address: regtestUtils.RANDOM_ADDRESS,
-                value: 1e5,
-            })
-            .signInput(0, alice1.keys[0]);
-
-        assert.strictEqual(psbt.validateSignaturesOfInput(0, validator), true);
-        psbt.finalizeAllInputs();
-
-        // build and broadcast to the RegTest network
-        await regtestUtils.broadcast(psbt.extractTransaction().toHex());
-    });
-
-    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2SH(P2MS(2 of 4)) (multisig) input', async () => {
-        const multisig = createPayment('p2sh-p2ms(2 of 4)');
-        const inputData1 = await getInputData(
-            2e4,
-            multisig.payment,
-            false,
-            'p2sh',
-        );
-        {
-            const {
-                hash,
-                index,
-                nonWitnessUtxo,
-                redeemScript, // NEW: P2SH needs to give redeemScript when adding an input.
-            } = inputData1;
-            assert.deepStrictEqual(
-                { hash, index, nonWitnessUtxo, redeemScript },
-                inputData1,
-            );
-        }
-
-        const psbt = new bitcoin.Psbt({ network: regtest })
-            .addInput(inputData1)
-            .addOutput({
-                address: regtestUtils.RANDOM_ADDRESS,
-                value: 1e4,
-            })
-            .signInput(0, multisig.keys[0])
-            .signInput(0, multisig.keys[2]);
-
-        assert.strictEqual(psbt.validateSignaturesOfInput(0, validator), true);
-        assert.strictEqual(
-            psbt.validateSignaturesOfInput(
-                0,
-                validator,
-                multisig.keys[0].publicKey,
-            ),
-            true,
-        );
-        assert.throws(() => {
-            psbt.validateSignaturesOfInput(
-                0,
-                validator,
-                multisig.keys[3].publicKey,
-            );
-        }, new RegExp('No signatures for this pubkey'));
-        psbt.finalizeAllInputs();
-
-        const tx = psbt.extractTransaction();
-
-        // build and broadcast to the Bitcoin RegTest network
-        await regtestUtils.broadcast(tx.toHex());
-
-        await regtestUtils.verify({
-            txId: tx.getId(),
-            address: regtestUtils.RANDOM_ADDRESS,
-            vout: 0,
-            value: 1e4,
-        });
-    });
-
-    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2SH(P2WPKH) input', async () => {
-        const p2sh = createPayment('p2sh-p2wpkh');
-        const inputData = await getInputData(5e4, p2sh.payment, true, 'p2sh');
-        const inputData2 = await getInputData(5e4, p2sh.payment, true, 'p2sh');
-        {
-            const {
-                hash,
-                index,
-                witnessUtxo, // NEW: this is an object of the output being spent { script: Buffer; value: Satoshis; }
-                redeemScript,
-            } = inputData;
-            assert.deepStrictEqual(
-                { hash, index, witnessUtxo, redeemScript },
-                inputData,
-            );
-        }
-        const keyPair = p2sh.keys[0];
-        const outputData = {
-            script: p2sh.payment.output, // sending to myself for fun
-            value: 2e4,
-        };
-        const outputData2 = {
-            script: p2sh.payment.output, // sending to myself for fun
-            value: 7e4,
-        };
-
-        const tx = new bitcoin.Psbt()
-            .addInputs([inputData, inputData2])
-            .addOutputs([outputData, outputData2])
-            .signAllInputs(keyPair)
-            .finalizeAllInputs()
-            .extractTransaction();
-
-        // build and broadcast to the Bitcoin RegTest network
-        await regtestUtils.broadcast(tx.toHex());
-
-        await regtestUtils.verify({
-            txId: tx.getId(),
-            address: p2sh.payment.address,
-            vout: 0,
-            value: 2e4,
-        });
-    });
-
-    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2SH(P2WPKH) input with nonWitnessUtxo', async () => {
-        // For learning purposes, ignore this test.
-        // REPEATING ABOVE BUT WITH nonWitnessUtxo by passing false to getInputData
-        const p2sh = createPayment('p2sh-p2wpkh');
-        const inputData = await getInputData(5e4, p2sh.payment, false, 'p2sh');
-        const inputData2 = await getInputData(5e4, p2sh.payment, false, 'p2sh');
-        const keyPair = p2sh.keys[0];
-        const outputData = {
-            script: p2sh.payment.output,
-            value: 2e4,
-        };
-        const outputData2 = {
-            script: p2sh.payment.output,
-            value: 7e4,
-        };
-        const tx = new bitcoin.Psbt()
-            .addInputs([inputData, inputData2])
-            .addOutputs([outputData, outputData2])
-            .signAllInputs(keyPair)
-            .finalizeAllInputs()
-            .extractTransaction();
-        await regtestUtils.broadcast(tx.toHex());
-        await regtestUtils.verify({
-            txId: tx.getId(),
-            address: p2sh.payment.address,
-            vout: 0,
-            value: 2e4,
-        });
-    });
-
-    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2WPKH input', async () => {
-        // the only thing that changes is you don't give a redeemscript for input data
-
-        const p2wpkh = createPayment('p2wpkh');
-        const inputData = await getInputData(
-            5e4,
-            p2wpkh.payment,
-            true,
-            'noredeem',
-        );
-        {
-            const { hash, index, witnessUtxo } = inputData;
-            assert.deepStrictEqual({ hash, index, witnessUtxo }, inputData);
-        }
-
-        const psbt = new bitcoin.Psbt({ network: regtest })
-            .addInput(inputData)
-            .addOutput({
-                address: regtestUtils.RANDOM_ADDRESS,
-                value: 2e4,
-            })
-            .signInput(0, p2wpkh.keys[0]);
-
-        assert.strictEqual(psbt.validateSignaturesOfInput(0, validator), true);
-        psbt.finalizeAllInputs();
-
-        const tx = psbt.extractTransaction();
-
-        // build and broadcast to the Bitcoin RegTest network
-        await regtestUtils.broadcast(tx.toHex());
-
-        await regtestUtils.verify({
-            txId: tx.getId(),
-            address: regtestUtils.RANDOM_ADDRESS,
-            vout: 0,
-            value: 2e4,
-        });
-    });
-
-    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2WPKH input with nonWitnessUtxo', async () => {
-        // For learning purposes, ignore this test.
-        // REPEATING ABOVE BUT WITH nonWitnessUtxo by passing false to getInputData
-        const p2wpkh = createPayment('p2wpkh');
-        const inputData = await getInputData(
-            5e4,
-            p2wpkh.payment,
-            false,
-            'noredeem',
-        );
-        const psbt = new bitcoin.Psbt({ network: regtest })
-            .addInput(inputData)
-            .addOutput({
-                address: regtestUtils.RANDOM_ADDRESS,
-                value: 2e4,
-            })
-            .signInput(0, p2wpkh.keys[0]);
-        psbt.finalizeAllInputs();
-        const tx = psbt.extractTransaction();
-        await regtestUtils.broadcast(tx.toHex());
-        await regtestUtils.verify({
-            txId: tx.getId(),
-            address: regtestUtils.RANDOM_ADDRESS,
-            vout: 0,
-            value: 2e4,
-        });
-    });
-
-    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2WSH(P2PK) input', async () => {
-        const p2wsh = createPayment('p2wsh-p2pk');
-        const inputData = await getInputData(5e4, p2wsh.payment, true, 'p2wsh');
-        {
-            const {
-                hash,
-                index,
-                witnessUtxo,
-                witnessScript, // NEW: A Buffer of the witnessScript
-            } = inputData;
-            assert.deepStrictEqual(
-                { hash, index, witnessUtxo, witnessScript },
-                inputData,
-            );
-        }
-
-        const psbt = new bitcoin.Psbt({ network: regtest })
-            .addInput(inputData)
-            .addOutput({
-                address: regtestUtils.RANDOM_ADDRESS,
-                value: 2e4,
-            })
-            .signInput(0, p2wsh.keys[0]);
-
-        assert.strictEqual(psbt.validateSignaturesOfInput(0, validator), true);
-        psbt.finalizeAllInputs();
-
-        const tx = psbt.extractTransaction();
-
-        // build and broadcast to the Bitcoin RegTest network
-        await regtestUtils.broadcast(tx.toHex());
-
-        await regtestUtils.verify({
-            txId: tx.getId(),
-            address: regtestUtils.RANDOM_ADDRESS,
-            vout: 0,
-            value: 2e4,
-        });
-    });
-
-    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2WSH(P2PK) input with nonWitnessUtxo', async () => {
-        // For learning purposes, ignore this test.
-        // REPEATING ABOVE BUT WITH nonWitnessUtxo by passing false to getInputData
-        const p2wsh = createPayment('p2wsh-p2pk');
-        const inputData = await getInputData(
-            5e4,
-            p2wsh.payment,
-            false,
-            'p2wsh',
-        );
-        const psbt = new bitcoin.Psbt({ network: regtest })
-            .addInput(inputData)
-            .addOutput({
-                address: regtestUtils.RANDOM_ADDRESS,
-                value: 2e4,
-            })
-            .signInput(0, p2wsh.keys[0]);
-        psbt.finalizeAllInputs();
-        const tx = psbt.extractTransaction();
-        await regtestUtils.broadcast(tx.toHex());
-        await regtestUtils.verify({
-            txId: tx.getId(),
-            address: regtestUtils.RANDOM_ADDRESS,
-            vout: 0,
-            value: 2e4,
-        });
-    });
-
-    it(
-        'can create (and broadcast via 3PBP) a Transaction, w/ a ' +
-            'P2SH(P2WSH(P2MS(3 of 4))) (SegWit multisig) input',
-        async () => {
-            const p2sh = createPayment('p2sh-p2wsh-p2ms(3 of 4)');
-            const inputData = await getInputData(
-                5e4,
-                p2sh.payment,
-                true,
-                'p2sh-p2wsh',
-            );
-            {
-                const {
-                    hash,
-                    index,
-                    witnessUtxo,
-                    redeemScript,
-                    witnessScript,
-                } = inputData;
-                assert.deepStrictEqual(
-                    { hash, index, witnessUtxo, redeemScript, witnessScript },
-                    inputData,
-                );
-            }
-
-            const psbt = new bitcoin.Psbt({ network: regtest })
-                .addInput(inputData)
-                .addOutput({
-                    address: regtestUtils.RANDOM_ADDRESS,
-                    value: 2e4,
-                })
-                .signInput(0, p2sh.keys[0])
-                .signInput(0, p2sh.keys[2])
-                .signInput(0, p2sh.keys[3]);
-
-            assert.strictEqual(
-                psbt.validateSignaturesOfInput(0, validator),
-                true,
-            );
-            assert.strictEqual(
-                psbt.validateSignaturesOfInput(
-                    0,
-                    validator,
-                    p2sh.keys[3].publicKey,
-                ),
-                true,
-            );
-            assert.throws(() => {
-                psbt.validateSignaturesOfInput(
-                    0,
-                    validator,
-                    p2sh.keys[1].publicKey,
-                );
-            }, new RegExp('No signatures for this pubkey'));
-            psbt.finalizeAllInputs();
-
-            const tx = psbt.extractTransaction();
-
-            // build and broadcast to the Bitcoin RegTest network
-            await regtestUtils.broadcast(tx.toHex());
-
-            await regtestUtils.verify({
-                txId: tx.getId(),
-                address: regtestUtils.RANDOM_ADDRESS,
-                vout: 0,
-                value: 2e4,
-            });
-        },
-    );
-
-    it(
-        'can create (and broadcast via 3PBP) a Transaction, w/ a ' +
-            'P2SH(P2WSH(P2MS(3 of 4))) (SegWit multisig) input with nonWitnessUtxo',
-        async () => {
-            // For learning purposes, ignore this test.
-            // REPEATING ABOVE BUT WITH nonWitnessUtxo by passing false to getInputData
-            const p2sh = createPayment('p2sh-p2wsh-p2ms(3 of 4)');
-            const inputData = await getInputData(
-                5e4,
-                p2sh.payment,
-                false,
-                'p2sh-p2wsh',
-            );
-            const psbt = new bitcoin.Psbt({ network: regtest })
-                .addInput(inputData)
-                .addOutput({
-                    address: regtestUtils.RANDOM_ADDRESS,
-                    value: 2e4,
-                })
-                .signInput(0, p2sh.keys[0])
-                .signInput(0, p2sh.keys[2])
-                .signInput(0, p2sh.keys[3]);
-            psbt.finalizeAllInputs();
-            const tx = psbt.extractTransaction();
-            await regtestUtils.broadcast(tx.toHex());
-            await regtestUtils.verify({
-                txId: tx.getId(),
-                address: regtestUtils.RANDOM_ADDRESS,
-                vout: 0,
-                value: 2e4,
-            });
-        },
-    );
-
-    it(
-        'can create (and broadcast via 3PBP) a Transaction, w/ a ' +
-            'P2SH(P2MS(2 of 2)) input with nonWitnessUtxo',
-        async () => {
-            const myKey = ECPair.makeRandom({ network: regtest });
-            const myKeys = [
-                myKey,
-                ECPair.fromPrivateKey(myKey.privateKey!, { network: regtest }),
-            ];
-            const p2sh = createPayment('p2sh-p2ms(2 of 2)', myKeys);
-            const inputData = await getInputData(
-                5e4,
-                p2sh.payment,
-                false,
-                'p2sh',
-            );
-            const psbt = new bitcoin.Psbt({ network: regtest })
-                .addInput(inputData)
-                .addOutput({
-                    address: regtestUtils.RANDOM_ADDRESS,
-                    value: 2e4,
-                })
-                .signInput(0, p2sh.keys[0]);
-            psbt.finalizeAllInputs();
-            const tx = psbt.extractTransaction();
-            await regtestUtils.broadcast(tx.toHex());
-            await regtestUtils.verify({
-                txId: tx.getId(),
-                address: regtestUtils.RANDOM_ADDRESS,
-                vout: 0,
-                value: 2e4,
-            });
-        },
-    );
-
-    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2WPKH input using HD', async () => {
-        const hdRoot = bip32.fromSeed(rng(64));
-        const masterFingerprint = hdRoot.fingerprint;
-        const path = "m/84'/0'/0'/0/0";
-        const childNode = hdRoot.derivePath(path);
-        const pubkey = childNode.publicKey;
-
-        // This information should be added to your input via updateInput
-        // You can add multiple bip32Derivation objects for multisig, but
-        // each must have a unique pubkey.
-        //
-        // This is useful because as long as you store the masterFingerprint on
-        // the PSBT Creator's server, you can have the PSBT Creator do the heavy
-        // lifting with derivation from your m/84'/0'/0' xpub, (deriving only 0/0 )
-        // and your signer just needs to pass in an HDSigner interface (ie. bip32 library)
-        const updateData = {
-            bip32Derivation: [
-                {
-                    masterFingerprint,
-                    path,
-                    pubkey,
-                },
-            ],
-        };
-        const p2wpkh = createPayment('p2wpkh', [childNode]);
-        const inputData = await getInputData(
-            5e4,
-            p2wpkh.payment,
-            true,
-            'noredeem',
-        );
-        {
-            const { hash, index, witnessUtxo } = inputData;
-            assert.deepStrictEqual({ hash, index, witnessUtxo }, inputData);
-        }
-
-        // You can add extra attributes for updateData into the addInput(s) object(s)
-        Object.assign(inputData, updateData);
-
-        const psbt = new bitcoin.Psbt({ network: regtest })
-            .addInput(inputData)
-            // .updateInput(0, updateData) // if you didn't merge the bip32Derivation with inputData
-            .addOutput({
-                address: regtestUtils.RANDOM_ADDRESS,
-                value: 2e4,
-            })
-            .signInputHD(0, hdRoot); // must sign with root!!!
-
-        assert.strictEqual(psbt.validateSignaturesOfInput(0, validator), true);
-        assert.strictEqual(
-            psbt.validateSignaturesOfInput(0, validator, childNode.publicKey),
-            true,
-        );
-        psbt.finalizeAllInputs();
-
-        const tx = psbt.extractTransaction();
-
-        // build and broadcast to the Bitcoin RegTest network
-        await regtestUtils.broadcast(tx.toHex());
-
-        await regtestUtils.verify({
-            txId: tx.getId(),
-            address: regtestUtils.RANDOM_ADDRESS,
-            vout: 0,
-            value: 2e4,
-        });
-    });
-});
-
-function createPayment(_type: string, myKeys?: any[], network?: any): any {
-    network = network || regtest;
-    const splitType = _type.split('-').reverse();
-    const isMultisig = splitType[0].slice(0, 4) === 'p2ms';
-    const keys = myKeys || [];
-    let m: number | undefined;
-    if (isMultisig) {
-        const match = splitType[0].match(/^p2ms\((\d+) of (\d+)\)$/);
-        m = parseInt(match![1], 10);
-        let n = parseInt(match![2], 10);
-        if (keys.length > 0 && keys.length !== n) {
-            throw new Error('Need n keys for multisig');
-        }
-        while (!myKeys && n > 1) {
-            keys.push(ECPair.makeRandom({ network }));
-            n--;
-        }
-    }
-    if (!myKeys) keys.push(ECPair.makeRandom({ network }));
-
-    let payment: any;
-    splitType.forEach(type => {
-        if (type.slice(0, 4) === 'p2ms') {
-            payment = bitcoin.payments.p2ms({
-                m,
-                pubkeys: keys
-                    .map(key => key.publicKey)
-                    .sort((a, b) => a.compare(b)),
-                network,
-            });
-        } else if (['p2sh', 'p2wsh'].indexOf(type) > -1) {
-            payment = (bitcoin.payments as any)[type]({
-                redeem: payment,
-                network,
-            });
-        } else {
-            payment = (bitcoin.payments as any)[type]({
-                pubkey: keys[0].publicKey,
-                network,
-            });
-        }
-    });
-
-    return {
-        payment,
-        keys,
-    };
-}
-
-function getWitnessUtxo(out: any): any {
-    delete out.address;
-    out.script = Buffer.from(out.script, 'hex');
-    return out;
-}
-
-async function getInputData(
-    amount: number,
-    payment: any,
-    isSegwit: boolean,
-    redeemType: string,
-): Promise<any> {
-    const unspent = await regtestUtils.faucetComplex(payment.output, amount);
-    const utx = await regtestUtils.fetch(unspent.txId);
-    // for non segwit inputs, you must pass the full transaction buffer
-    const nonWitnessUtxo = Buffer.from(utx.txHex, 'hex');
-    // for segwit inputs, you only need the output script and value as an object.
-    const witnessUtxo = getWitnessUtxo(utx.outs[unspent.vout]);
-    const mixin = isSegwit ? { witnessUtxo } : { nonWitnessUtxo };
-    const mixin2: any = {};
-    switch (redeemType) {
-        case 'p2sh':
-            mixin2.redeemScript = payment.redeem.output;
-            break;
-        case 'p2wsh':
-            mixin2.witnessScript = payment.redeem.output;
-            break;
-        case 'p2sh-p2wsh':
-            mixin2.witnessScript = payment.redeem.redeem.output;
-            mixin2.redeemScript = payment.redeem.output;
-            break;
-    }
-    return {
-        hash: unspent.txId,
-        index: unspent.vout,
-        ...mixin,
-        ...mixin2,
-    };
-}
+import assert from 'assert';
+import { BIP32Factory } from 'bip32';
+import * as ecc from 'tiny-secp256k1';
+import { ECPairFactory } from 'ecpair';
+import { describe, it } from 'mocha';
+import * as bitcoin from '../../src/index.js';
+import { regtestUtils } from './_regtest.js';
+
+import rng from 'randombytes';
+
+const ECPair = ECPairFactory(ecc);
+const regtest = { ...regtestUtils.network, bech32Opnet: 'opreg' };
+const bip32 = BIP32Factory(ecc);
+
+const validator = (pubkey: Buffer, msghash: Buffer, signature: Buffer): boolean =>
+    ECPair.fromPublicKey(pubkey).verify(msghash, signature);
+
+// See bottom of file for some helper functions used to make the payment objects needed.
+
+describe('bitcoinjs-lib (transactions with psbt)', () => {
+    it('can create a 1-to-1 Transaction', () => {
+        const alice = ECPair.fromWIF('L2uPYXe17xSTqbCjZvL2DsyXPCbXspvcu5mHLDYUgzdUbZGSKrSr');
+        const psbt = new bitcoin.Psbt();
+        psbt.setVersion(2); // These are defaults. This line is not needed.
+        psbt.setLocktime(0); // These are defaults. This line is not needed.
+        psbt.addInput({
+            // if hash is string, txid, if hash is Buffer, is reversed compared to txid
+            hash: '7d067b4a697a09d2c3cff7d4d9506c9955e93bff41bf82d439da7d030382bc3e',
+            index: 0,
+            sequence: 0xffffffff, // These are defaults. This line is not needed.
+
+            // non-segwit inputs now require passing the whole previous tx as Buffer
+            nonWitnessUtxo: Buffer.from(
+                '0200000001f9f34e95b9d5c8abcd20fc5bd4a825d1517be62f0f775e5f36da944d9' +
+                    '452e550000000006b483045022100c86e9a111afc90f64b4904bd609e9eaed80d48' +
+                    'ca17c162b1aca0a788ac3526f002207bb79b60d4fc6526329bf18a77135dc566020' +
+                    '9e761da46e1c2f1152ec013215801210211755115eabf846720f5cb18f248666fec' +
+                    '631e5e1e66009ce3710ceea5b1ad13ffffffff01' +
+                    // value in satoshis (Int64LE) = 0x015f90 = 90000
+                    '905f010000000000' +
+                    // scriptPubkey length
+                    '19' +
+                    // scriptPubkey
+                    '76a9148bbc95d2709c71607c60ee3f097c1217482f518d88ac' +
+                    // locktime
+                    '00000000',
+                'hex',
+            ),
+
+            // // If this input was segwit, instead of nonWitnessUtxo, you would add
+            // // a witnessUtxo as follows. The scriptPubkey and the value only are needed.
+            // witnessUtxo: {
+            //   script: Buffer.from(
+            //     '76a9148bbc95d2709c71607c60ee3f097c1217482f518d88ac',
+            //     'hex',
+            //   ),
+            //   value: 90000,
+            // },
+
+            // Not featured here:
+            //   redeemScript. A Buffer of the redeemScript for P2SH
+            //   witnessScript. A Buffer of the witnessScript for P2WSH
+        });
+        psbt.addOutput({
+            address: '1KRMKfeZcmosxALVYESdPNez1AP1mEtywp',
+            value: 80000,
+        });
+        psbt.signInput(0, alice);
+        psbt.validateSignaturesOfInput(0, validator);
+        psbt.finalizeAllInputs();
+        assert.strictEqual(
+            psbt.extractTransaction().toHex(),
+            '02000000013ebc8203037dda39d482bf41ff3be955996c50d9d4f7cfc3d2097a694a7' +
+                'b067d000000006b483045022100931b6db94aed25d5486884d83fc37160f37f3368c0' +
+                'd7f48c757112abefec983802205fda64cff98c849577026eb2ce916a50ea70626a766' +
+                '9f8596dd89b720a26b4d501210365db9da3f8a260078a7e8f8b708a1161468fb2323f' +
+                'fda5ec16b261ec1056f455ffffffff0180380100000000001976a914ca0d36044e0dc' +
+                '08a22724efa6f6a07b0ec4c79aa88ac00000000',
+        );
+    });
+
+    it('can create (and broadcast via 3PBP) a typical Transaction', async () => {
+        // these are { payment: Payment; keys: ECPair[] }
+        const alice1 = createPayment('p2pkh');
+        const alice2 = createPayment('p2pkh');
+
+        // give Alice 2 unspent outputs
+        const inputData1 = await getInputData(5e4, alice1.payment, false, 'noredeem');
+        const inputData2 = await getInputData(7e4, alice2.payment, false, 'noredeem');
+        {
+            const {
+                hash, // string of txid or Buffer of tx hash. (txid and hash are reverse order)
+                index, // the output index of the txo you are spending
+                nonWitnessUtxo, // the full previous transaction as a Buffer
+            } = inputData1;
+            assert.deepStrictEqual({ hash, index, nonWitnessUtxo }, inputData1);
+        }
+
+        // network is only needed if you pass an address to addOutput
+        // using script (Buffer of scriptPubkey) instead will avoid needed network.
+        const psbt = new bitcoin.Psbt({ network: regtest })
+            .addInput(inputData1) // alice1 unspent
+            .addInput(inputData2) // alice2 unspent
+            .addOutput({
+                address: 'mwCwTceJvYV27KXBc3NJZys6CjsgsoeHmf',
+                value: 8e4,
+            }) // the actual "spend"
+            .addOutput({
+                address: alice2.payment.address, // OR script, which is a Buffer.
+                value: 1e4,
+            }); // Alice's change
+        // (in)(5e4 + 7e4) - (out)(8e4 + 1e4) = (fee)3e4 = 30000, this is the miner fee
+
+        // Let's show a new feature with PSBT.
+        // We can have multiple signers sign in parallel and combine them.
+        // (this is not necessary, but a nice feature)
+
+        // encode to send out to the signers
+        const psbtBaseText = psbt.toBase64();
+
+        // each signer imports
+        const signer1 = bitcoin.Psbt.fromBase64(psbtBaseText);
+        const signer2 = bitcoin.Psbt.fromBase64(psbtBaseText);
+
+        // Alice signs each input with the respective private keys
+        // signInput and signInputAsync are better
+        // (They take the input index explicitly as the first arg)
+        signer1.signAllInputs(alice1.keys[0]);
+        signer2.signAllInputs(alice2.keys[0]);
+
+        // If your signer object's sign method returns a promise, use the following
+        // await signer2.signAllInputsAsync(alice2.keys[0])
+
+        // encode to send back to combiner (signer 1 and 2 are not near each other)
+        const s1text = signer1.toBase64();
+        const s2text = signer2.toBase64();
+
+        const final1 = bitcoin.Psbt.fromBase64(s1text);
+        const final2 = bitcoin.Psbt.fromBase64(s2text);
+
+        // final1.combine(final2) would give the exact same result
+        psbt.combine(final1, final2);
+
+        // Finalizer wants to check all signatures are valid before finalizing.
+        // If the finalizer wants to check for specific pubkeys, the second arg
+        // can be passed. See the first multisig example below.
+        assert.strictEqual(psbt.validateSignaturesOfInput(0, validator), true);
+        assert.strictEqual(psbt.validateSignaturesOfInput(1, validator), true);
+
+        // This step it new. Since we separate the signing operation and
+        // the creation of the scriptSig and witness stack, we are able to
+        psbt.finalizeAllInputs();
+
+        // build and broadcast our RegTest network
+        await regtestUtils.broadcast(psbt.extractTransaction().toHex());
+        // to build and broadcast to the actual Bitcoin network, see https://github.com/bitcoinjs/bitcoinjs-lib/issues/839
+    });
+
+    /*it('can create (and broadcast via 3PBP) a Transaction with an OP_RETURN output', async () => {
+        const alice1 = createPayment('p2pkh');
+        const inputData1 = await getInputData(2e5, alice1.payment, false, 'noredeem');
+
+        const data = Buffer.from('bitcoinjs-lib', 'utf8');
+        const embed = bitcoin.payments.embed({ data: [data] });
+
+        const psbt = new bitcoin.Psbt({ network: regtest })
+            .addInput(inputData1)
+            .addOutput({
+                script: embed.output!,
+                value: 1000,
+            })
+            .addOutput({
+                address: regtestUtils.RANDOM_ADDRESS,
+                value: 1e5,
+            })
+            .signInput(0, alice1.keys[0]);
+
+        assert.strictEqual(psbt.validateSignaturesOfInput(0, validator), true);
+        psbt.finalizeAllInputs();
+
+        // build and broadcast to the RegTest network
+        await regtestUtils.broadcast(psbt.extractTransaction().toHex());
+    });*/
+
+    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2SH(P2MS(2 of 4)) (multisig) input', async () => {
+        const multisig = createPayment('p2sh-p2ms(2 of 4)');
+        const inputData1 = await getInputData(2e4, multisig.payment, false, 'p2sh');
+        {
+            const {
+                hash,
+                index,
+                nonWitnessUtxo,
+                redeemScript, // NEW: P2SH needs to give redeemScript when adding an input.
+            } = inputData1;
+            assert.deepStrictEqual({ hash, index, nonWitnessUtxo, redeemScript }, inputData1);
+        }
+
+        const psbt = new bitcoin.Psbt({ network: regtest })
+            .addInput(inputData1)
+            .addOutput({
+                address: regtestUtils.RANDOM_ADDRESS,
+                value: 1e4,
+            })
+            .signInput(0, multisig.keys[0])
+            .signInput(0, multisig.keys[2]);
+
+        assert.strictEqual(psbt.validateSignaturesOfInput(0, validator), true);
+        assert.strictEqual(
+            psbt.validateSignaturesOfInput(0, validator, multisig.keys[0].publicKey),
+            true,
+        );
+        assert.throws(() => {
+            psbt.validateSignaturesOfInput(0, validator, multisig.keys[3].publicKey);
+        }, new RegExp('No signatures for this pubkey'));
+        psbt.finalizeAllInputs();
+
+        const tx = psbt.extractTransaction();
+
+        // build and broadcast to the Bitcoin RegTest network
+        await regtestUtils.broadcast(tx.toHex());
+
+        await regtestUtils.verify({
+            txId: tx.getId(),
+            address: regtestUtils.RANDOM_ADDRESS,
+            vout: 0,
+            value: 1e4,
+        });
+    });
+
+    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2SH(P2WPKH) input', async () => {
+        const p2sh = createPayment('p2sh-p2wpkh');
+        const inputData = await getInputData(5e4, p2sh.payment, true, 'p2sh');
+        const inputData2 = await getInputData(5e4, p2sh.payment, true, 'p2sh');
+        {
+            const {
+                hash,
+                index,
+                witnessUtxo, // NEW: this is an object of the output being spent { script: Buffer; value: Satoshis; }
+                redeemScript,
+            } = inputData;
+            assert.deepStrictEqual({ hash, index, witnessUtxo, redeemScript }, inputData);
+        }
+        const keyPair = p2sh.keys[0];
+        const outputData = {
+            script: p2sh.payment.output, // sending to myself for fun
+            value: 2e4,
+        };
+        const outputData2 = {
+            script: p2sh.payment.output, // sending to myself for fun
+            value: 7e4,
+        };
+
+        const tx = new bitcoin.Psbt()
+            .addInputs([inputData, inputData2])
+            .addOutputs([outputData, outputData2])
+            .signAllInputs(keyPair)
+            .finalizeAllInputs()
+            .extractTransaction();
+
+        // build and broadcast to the Bitcoin RegTest network
+        await regtestUtils.broadcast(tx.toHex());
+
+        await regtestUtils.verify({
+            txId: tx.getId(),
+            address: p2sh.payment.address,
+            vout: 0,
+            value: 2e4,
+        });
+    });
+
+    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2SH(P2WPKH) input with nonWitnessUtxo', async () => {
+        // For learning purposes, ignore this test.
+        // REPEATING ABOVE BUT WITH nonWitnessUtxo by passing false to getInputData
+        const p2sh = createPayment('p2sh-p2wpkh');
+        const inputData = await getInputData(5e4, p2sh.payment, false, 'p2sh');
+        const inputData2 = await getInputData(5e4, p2sh.payment, false, 'p2sh');
+        const keyPair = p2sh.keys[0];
+        const outputData = {
+            script: p2sh.payment.output,
+            value: 2e4,
+        };
+        const outputData2 = {
+            script: p2sh.payment.output,
+            value: 7e4,
+        };
+        const tx = new bitcoin.Psbt()
+            .addInputs([inputData, inputData2])
+            .addOutputs([outputData, outputData2])
+            .signAllInputs(keyPair)
+            .finalizeAllInputs()
+            .extractTransaction();
+        await regtestUtils.broadcast(tx.toHex());
+        await regtestUtils.verify({
+            txId: tx.getId(),
+            address: p2sh.payment.address,
+            vout: 0,
+            value: 2e4,
+        });
+    });
+
+    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2WPKH input', async () => {
+        // the only thing that changes is you don't give a redeemscript for input data
+
+        const p2wpkh = createPayment('p2wpkh');
+        const inputData = await getInputData(5e4, p2wpkh.payment, true, 'noredeem');
+        {
+            const { hash, index, witnessUtxo } = inputData;
+            assert.deepStrictEqual({ hash, index, witnessUtxo }, inputData);
+        }
+
+        const psbt = new bitcoin.Psbt({ network: regtest })
+            .addInput(inputData)
+            .addOutput({
+                address: regtestUtils.RANDOM_ADDRESS,
+                value: 2e4,
+            })
+            .signInput(0, p2wpkh.keys[0]);
+
+        assert.strictEqual(psbt.validateSignaturesOfInput(0, validator), true);
+        psbt.finalizeAllInputs();
+
+        const tx = psbt.extractTransaction();
+
+        // build and broadcast to the Bitcoin RegTest network
+        await regtestUtils.broadcast(tx.toHex());
+
+        await regtestUtils.verify({
+            txId: tx.getId(),
+            address: regtestUtils.RANDOM_ADDRESS,
+            vout: 0,
+            value: 2e4,
+        });
+    });
+
+    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2WPKH input with nonWitnessUtxo', async () => {
+        // For learning purposes, ignore this test.
+        // REPEATING ABOVE BUT WITH nonWitnessUtxo by passing false to getInputData
+        const p2wpkh = createPayment('p2wpkh');
+        const inputData = await getInputData(5e4, p2wpkh.payment, false, 'noredeem');
+        const psbt = new bitcoin.Psbt({ network: regtest })
+            .addInput(inputData)
+            .addOutput({
+                address: regtestUtils.RANDOM_ADDRESS,
+                value: 2e4,
+            })
+            .signInput(0, p2wpkh.keys[0]);
+        psbt.finalizeAllInputs();
+        const tx = psbt.extractTransaction();
+        await regtestUtils.broadcast(tx.toHex());
+        await regtestUtils.verify({
+            txId: tx.getId(),
+            address: regtestUtils.RANDOM_ADDRESS,
+            vout: 0,
+            value: 2e4,
+        });
+    });
+
+    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2WSH(P2PK) input', async () => {
+        const p2wsh = createPayment('p2wsh-p2pk');
+        const inputData = await getInputData(5e4, p2wsh.payment, true, 'p2wsh');
+        {
+            const {
+                hash,
+                index,
+                witnessUtxo,
+                witnessScript, // NEW: A Buffer of the witnessScript
+            } = inputData;
+            assert.deepStrictEqual({ hash, index, witnessUtxo, witnessScript }, inputData);
+        }
+
+        const psbt = new bitcoin.Psbt({ network: regtest })
+            .addInput(inputData)
+            .addOutput({
+                address: regtestUtils.RANDOM_ADDRESS,
+                value: 2e4,
+            })
+            .signInput(0, p2wsh.keys[0]);
+
+        assert.strictEqual(psbt.validateSignaturesOfInput(0, validator), true);
+        psbt.finalizeAllInputs();
+
+        const tx = psbt.extractTransaction();
+
+        // build and broadcast to the Bitcoin RegTest network
+        await regtestUtils.broadcast(tx.toHex());
+
+        await regtestUtils.verify({
+            txId: tx.getId(),
+            address: regtestUtils.RANDOM_ADDRESS,
+            vout: 0,
+            value: 2e4,
+        });
+    });
+
+    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2WSH(P2PK) input with nonWitnessUtxo', async () => {
+        // For learning purposes, ignore this test.
+        // REPEATING ABOVE BUT WITH nonWitnessUtxo by passing false to getInputData
+        const p2wsh = createPayment('p2wsh-p2pk');
+        const inputData = await getInputData(5e4, p2wsh.payment, false, 'p2wsh');
+        const psbt = new bitcoin.Psbt({ network: regtest })
+            .addInput(inputData)
+            .addOutput({
+                address: regtestUtils.RANDOM_ADDRESS,
+                value: 2e4,
+            })
+            .signInput(0, p2wsh.keys[0]);
+        psbt.finalizeAllInputs();
+        const tx = psbt.extractTransaction();
+        await regtestUtils.broadcast(tx.toHex());
+        await regtestUtils.verify({
+            txId: tx.getId(),
+            address: regtestUtils.RANDOM_ADDRESS,
+            vout: 0,
+            value: 2e4,
+        });
+    });
+
+    it(
+        'can create (and broadcast via 3PBP) a Transaction, w/ a ' +
+            'P2SH(P2WSH(P2MS(3 of 4))) (SegWit multisig) input',
+        async () => {
+            const p2sh = createPayment('p2sh-p2wsh-p2ms(3 of 4)');
+            const inputData = await getInputData(5e4, p2sh.payment, true, 'p2sh-p2wsh');
+            {
+                const { hash, index, witnessUtxo, redeemScript, witnessScript } = inputData;
+                assert.deepStrictEqual(
+                    { hash, index, witnessUtxo, redeemScript, witnessScript },
+                    inputData,
+                );
+            }
+
+            const psbt = new bitcoin.Psbt({ network: regtest })
+                .addInput(inputData)
+                .addOutput({
+                    address: regtestUtils.RANDOM_ADDRESS,
+                    value: 2e4,
+                })
+                .signInput(0, p2sh.keys[0])
+                .signInput(0, p2sh.keys[2])
+                .signInput(0, p2sh.keys[3]);
+
+            assert.strictEqual(psbt.validateSignaturesOfInput(0, validator), true);
+            assert.strictEqual(
+                psbt.validateSignaturesOfInput(0, validator, p2sh.keys[3].publicKey),
+                true,
+            );
+            assert.throws(() => {
+                psbt.validateSignaturesOfInput(0, validator, p2sh.keys[1].publicKey);
+            }, new RegExp('No signatures for this pubkey'));
+            psbt.finalizeAllInputs();
+
+            const tx = psbt.extractTransaction();
+
+            // build and broadcast to the Bitcoin RegTest network
+            await regtestUtils.broadcast(tx.toHex());
+
+            await regtestUtils.verify({
+                txId: tx.getId(),
+                address: regtestUtils.RANDOM_ADDRESS,
+                vout: 0,
+                value: 2e4,
+            });
+        },
+    );
+
+    it(
+        'can create (and broadcast via 3PBP) a Transaction, w/ a ' +
+            'P2SH(P2WSH(P2MS(3 of 4))) (SegWit multisig) input with nonWitnessUtxo',
+        async () => {
+            // For learning purposes, ignore this test.
+            // REPEATING ABOVE BUT WITH nonWitnessUtxo by passing false to getInputData
+            const p2sh = createPayment('p2sh-p2wsh-p2ms(3 of 4)');
+            const inputData = await getInputData(5e4, p2sh.payment, false, 'p2sh-p2wsh');
+            const psbt = new bitcoin.Psbt({ network: regtest })
+                .addInput(inputData)
+                .addOutput({
+                    address: regtestUtils.RANDOM_ADDRESS,
+                    value: 2e4,
+                })
+                .signInput(0, p2sh.keys[0])
+                .signInput(0, p2sh.keys[2])
+                .signInput(0, p2sh.keys[3]);
+            psbt.finalizeAllInputs();
+            const tx = psbt.extractTransaction();
+            await regtestUtils.broadcast(tx.toHex());
+            await regtestUtils.verify({
+                txId: tx.getId(),
+                address: regtestUtils.RANDOM_ADDRESS,
+                vout: 0,
+                value: 2e4,
+            });
+        },
+    );
+
+    it(
+        'can create (and broadcast via 3PBP) a Transaction, w/ a ' +
+            'P2SH(P2MS(2 of 2)) input with nonWitnessUtxo',
+        async () => {
+            const myKey = ECPair.makeRandom({ network: regtest });
+            const myKeys = [myKey, ECPair.fromPrivateKey(myKey.privateKey!, { network: regtest })];
+            const p2sh = createPayment('p2sh-p2ms(2 of 2)', myKeys);
+            const inputData = await getInputData(5e4, p2sh.payment, false, 'p2sh');
+            const psbt = new bitcoin.Psbt({ network: regtest })
+                .addInput(inputData)
+                .addOutput({
+                    address: regtestUtils.RANDOM_ADDRESS,
+                    value: 2e4,
+                })
+                .signInput(0, p2sh.keys[0]);
+            psbt.finalizeAllInputs();
+            const tx = psbt.extractTransaction();
+            await regtestUtils.broadcast(tx.toHex());
+            await regtestUtils.verify({
+                txId: tx.getId(),
+                address: regtestUtils.RANDOM_ADDRESS,
+                vout: 0,
+                value: 2e4,
+            });
+        },
+    );
+
+    it('can create (and broadcast via 3PBP) a Transaction, w/ a P2WPKH input using HD', async () => {
+        const hdRoot = bip32.fromSeed(rng(64));
+        const masterFingerprint = hdRoot.fingerprint;
+        const path = "m/84'/0'/0'/0/0";
+        const childNode = hdRoot.derivePath(path);
+        const pubkey = childNode.publicKey;
+
+        // This information should be added to your input via updateInput
+        // You can add multiple bip32Derivation objects for multisig, but
+        // each must have a unique pubkey.
+        //
+        // This is useful because as long as you store the masterFingerprint on
+        // the PSBT Creator's server, you can have the PSBT Creator do the heavy
+        // lifting with derivation from your m/84'/0'/0' xpub, (deriving only 0/0 )
+        // and your signer just needs to pass in an HDSigner interface (ie. bip32 library)
+        const updateData = {
+            bip32Derivation: [
+                {
+                    masterFingerprint,
+                    path,
+                    pubkey,
+                },
+            ],
+        };
+        const p2wpkh = createPayment('p2wpkh', [childNode]);
+        const inputData = await getInputData(5e4, p2wpkh.payment, true, 'noredeem');
+        {
+            const { hash, index, witnessUtxo } = inputData;
+            assert.deepStrictEqual({ hash, index, witnessUtxo }, inputData);
+        }
+
+        // You can add extra attributes for updateData into the addInput(s) object(s)
+        Object.assign(inputData, updateData);
+
+        const psbt = new bitcoin.Psbt({ network: regtest })
+            .addInput(inputData)
+            // .updateInput(0, updateData) // if you didn't merge the bip32Derivation with inputData
+            .addOutput({
+                address: regtestUtils.RANDOM_ADDRESS,
+                value: 2e4,
+            })
+            .signInputHD(0, hdRoot); // must sign with root!!!
+
+        assert.strictEqual(psbt.validateSignaturesOfInput(0, validator), true);
+        assert.strictEqual(psbt.validateSignaturesOfInput(0, validator, childNode.publicKey), true);
+        psbt.finalizeAllInputs();
+
+        const tx = psbt.extractTransaction();
+
+        // build and broadcast to the Bitcoin RegTest network
+        await regtestUtils.broadcast(tx.toHex());
+
+        await regtestUtils.verify({
+            txId: tx.getId(),
+            address: regtestUtils.RANDOM_ADDRESS,
+            vout: 0,
+            value: 2e4,
+        });
+    });
+});
+
+function createPayment(_type: string, myKeys?: any[], network?: any): any {
+    network = network || regtest;
+    const splitType = _type.split('-').reverse();
+    const isMultisig = splitType[0].slice(0, 4) === 'p2ms';
+    const keys = myKeys || [];
+    let m: number | undefined;
+    if (isMultisig) {
+        const match = splitType[0].match(/^p2ms\((\d+) of (\d+)\)$/);
+        m = parseInt(match![1], 10);
+        let n = parseInt(match![2], 10);
+        if (keys.length > 0 && keys.length !== n) {
+            throw new Error('Need n keys for multisig');
+        }
+        while (!myKeys && n > 1) {
+            keys.push(ECPair.makeRandom({ network }));
+            n--;
+        }
+    }
+    if (!myKeys) keys.push(ECPair.makeRandom({ network }));
+
+    let payment: any;
+    splitType.forEach((type) => {
+        if (type.slice(0, 4) === 'p2ms') {
+            payment = bitcoin.payments.p2ms({
+                m,
+                pubkeys: keys.map((key) => key.publicKey).sort((a, b) => a.compare(b)),
+                network,
+            });
+        } else if (['p2sh', 'p2wsh'].indexOf(type) > -1) {
+            payment = (bitcoin.payments as any)[type]({
+                redeem: payment,
+                network,
+            });
+        } else {
+            payment = (bitcoin.payments as any)[type]({
+                pubkey: keys[0].publicKey,
+                network,
+            });
+        }
+    });
+
+    return {
+        payment,
+        keys,
+    };
+}
+
+function getWitnessUtxo(out: any): any {
+    delete out.address;
+    out.script = Buffer.from(out.script, 'hex');
+    return out;
+}
+
+async function getInputData(
+    amount: number,
+    payment: any,
+    isSegwit: boolean,
+    redeemType: string,
+): Promise<any> {
+    const unspent = await regtestUtils.faucetComplex(payment.output, amount);
+    const utx = await regtestUtils.fetch(unspent.txId);
+    // for non segwit inputs, you must pass the full transaction buffer
+    const nonWitnessUtxo = Buffer.from(utx.txHex, 'hex');
+    // for segwit inputs, you only need the output script and value as an object.
+    const witnessUtxo = getWitnessUtxo(utx.outs[unspent.vout]);
+    const mixin = isSegwit ? { witnessUtxo } : { nonWitnessUtxo };
+    const mixin2: any = {};
+    switch (redeemType) {
+        case 'p2sh':
+            mixin2.redeemScript = payment.redeem.output;
+            break;
+        case 'p2wsh':
+            mixin2.witnessScript = payment.redeem.output;
+            break;
+        case 'p2sh-p2wsh':
+            mixin2.witnessScript = payment.redeem.redeem.output;
+            mixin2.redeemScript = payment.redeem.output;
+            break;
+    }
+    return {
+        hash: unspent.txId,
+        index: unspent.vout,
+        ...mixin,
+        ...mixin2,
+    };
+}