From 0454b801811d1ce9b95f3e8302540a432f293673 Mon Sep 17 00:00:00 2001
From: DanGould <d@ngould.dev>
Date: Sun, 3 Apr 2022 20:55:00 +0800
Subject: [PATCH] add psbt example

resolves #892

Co-authored-by: Tobin Harding <me@tobin.cc>
---
 Cargo.toml                         |   6 +-
 examples/data/README.md            |   4 +
 examples/data/combine_psbt_hex     |   1 +
 examples/data/create_psbt_hex      |   1 +
 examples/data/extract_tx_hex       |   1 +
 examples/data/finalize_psbt_hex    |   1 +
 examples/data/lex_combine_psbt_hex |   1 +
 examples/data/lex_psbt_1_hex       |   1 +
 examples/data/lex_psbt_2_hex       |   1 +
 examples/data/previous_tx_0_hex    |   1 +
 examples/data/previous_tx_1_hex    |   1 +
 examples/data/sign_1_psbt_hex      |   1 +
 examples/data/sign_2_psbt_hex      |   1 +
 examples/data/update_1_psbt_hex    |   1 +
 examples/data/update_2_psbt_hex    |   1 +
 examples/psbt.rs                   | 711 +++++++++++++++++++++++++++++
 16 files changed, 733 insertions(+), 1 deletion(-)
 create mode 100644 examples/data/README.md
 create mode 100644 examples/data/combine_psbt_hex
 create mode 100644 examples/data/create_psbt_hex
 create mode 100644 examples/data/extract_tx_hex
 create mode 100644 examples/data/finalize_psbt_hex
 create mode 100644 examples/data/lex_combine_psbt_hex
 create mode 100644 examples/data/lex_psbt_1_hex
 create mode 100644 examples/data/lex_psbt_2_hex
 create mode 100644 examples/data/previous_tx_0_hex
 create mode 100644 examples/data/previous_tx_1_hex
 create mode 100644 examples/data/sign_1_psbt_hex
 create mode 100644 examples/data/sign_2_psbt_hex
 create mode 100644 examples/data/update_1_psbt_hex
 create mode 100644 examples/data/update_2_psbt_hex
 create mode 100644 examples/psbt.rs

diff --git a/Cargo.toml b/Cargo.toml
index 0f9050d62f..136ae33c03 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -47,7 +47,7 @@ hashbrown = { version = "0.8", optional = true }
 [dev-dependencies]
 serde_json = "<1.0.45"
 serde_test = "1"
-secp256k1 = { version = "0.22.0", features = [ "recovery", "rand-std" ] }
+secp256k1 = { version = "0.22.0", features = [ "recovery", "rand-std", "global-context" ] }
 bincode = "1.3.1"
 # We need to pin ryu (transitive dep from serde_json) to stay compatible with Rust 1.22.0
 ryu = "<1.0.5"
@@ -58,3 +58,7 @@ name = "bip32"
 [[example]]
 name = "handshake"
 required-features = ["std"]
+
+[[example]]
+name = "psbt"
+required-features = ["std"]
diff --git a/examples/data/README.md b/examples/data/README.md
new file mode 100644
index 0000000000..70ed7a4ef8
--- /dev/null
+++ b/examples/data/README.md
@@ -0,0 +1,4 @@
+Test vector data
+================
+
+This file contains data (hex strings) taken from BIP test vectors.
diff --git a/examples/data/combine_psbt_hex b/examples/data/combine_psbt_hex
new file mode 100644
index 0000000000..47f3870173
--- /dev/null
+++ b/examples/data/combine_psbt_hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/examples/data/create_psbt_hex b/examples/data/create_psbt_hex
new file mode 100644
index 0000000000..b5ef8d5ed0
--- /dev/null
+++ b/examples/data/create_psbt_hex
@@ -0,0 +1 @@
+70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f000000000000000000
\ No newline at end of file
diff --git a/examples/data/extract_tx_hex b/examples/data/extract_tx_hex
new file mode 100644
index 0000000000..41c22961f4
--- /dev/null
+++ b/examples/data/extract_tx_hex
@@ -0,0 +1 @@
+0200000000010258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd7500000000da00473044022074018ad4180097b873323c0015720b3684cc8123891048e7dbcd9b55ad679c99022073d369b740e3eb53dcefa33823c8070514ca55a7dd9544f157c167913261118c01483045022100f61038b308dc1da865a34852746f015772934208c6d24454393cd99bdf2217770220056e675a675a6d0a02b85b14e5e29074d8a25a9b5760bea2816f661910a006ea01475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752aeffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d01000000232200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f000400473044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01473044022065f45ba5998b59a27ffe1a7bed016af1f1f90d54b3aa8f7450aa5f56a25103bd02207f724703ad1edb96680b284b56d4ffcb88f7fb759eabbe08aa30f29b851383d20147522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae00000000
\ No newline at end of file
diff --git a/examples/data/finalize_psbt_hex b/examples/data/finalize_psbt_hex
new file mode 100644
index 0000000000..2866b82b7d
--- /dev/null
+++ b/examples/data/finalize_psbt_hex
@@ -0,0 +1 @@
+70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f6187650000000107da00473044022074018ad4180097b873323c0015720b3684cc8123891048e7dbcd9b55ad679c99022073d369b740e3eb53dcefa33823c8070514ca55a7dd9544f157c167913261118c01483045022100f61038b308dc1da865a34852746f015772934208c6d24454393cd99bdf2217770220056e675a675a6d0a02b85b14e5e29074d8a25a9b5760bea2816f661910a006ea01475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae0001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e8870107232200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b20289030108da0400473044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01473044022065f45ba5998b59a27ffe1a7bed016af1f1f90d54b3aa8f7450aa5f56a25103bd02207f724703ad1edb96680b284b56d4ffcb88f7fb759eabbe08aa30f29b851383d20147522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae00220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000
\ No newline at end of file
diff --git a/examples/data/lex_combine_psbt_hex b/examples/data/lex_combine_psbt_hex
new file mode 100644
index 0000000000..9ee710b6a9
--- /dev/null
+++ b/examples/data/lex_combine_psbt_hex
@@ -0,0 +1 @@
+70736274ff01003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a0100000000000af00102030405060708090f0102030405060708090a0b0c0d0e0f0af00102030405060708100f0102030405060708090a0b0c0d0e0f000af00102030405060708090f0102030405060708090a0b0c0d0e0f0af00102030405060708100f0102030405060708090a0b0c0d0e0f000af00102030405060708090f0102030405060708090a0b0c0d0e0f0af00102030405060708100f0102030405060708090a0b0c0d0e0f00
\ No newline at end of file
diff --git a/examples/data/lex_psbt_1_hex b/examples/data/lex_psbt_1_hex
new file mode 100644
index 0000000000..a125c5298a
--- /dev/null
+++ b/examples/data/lex_psbt_1_hex
@@ -0,0 +1 @@
+70736274ff01003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a0100000000000af00102030405060708090f0102030405060708090a0b0c0d0e0f000af00102030405060708090f0102030405060708090a0b0c0d0e0f000af00102030405060708090f0102030405060708090a0b0c0d0e0f00
\ No newline at end of file
diff --git a/examples/data/lex_psbt_2_hex b/examples/data/lex_psbt_2_hex
new file mode 100644
index 0000000000..766c7eee16
--- /dev/null
+++ b/examples/data/lex_psbt_2_hex
@@ -0,0 +1 @@
+70736274ff01003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a0100000000000af00102030405060708100f0102030405060708090a0b0c0d0e0f000af00102030405060708100f0102030405060708090a0b0c0d0e0f000af00102030405060708100f0102030405060708090a0b0c0d0e0f00
\ No newline at end of file
diff --git a/examples/data/previous_tx_0_hex b/examples/data/previous_tx_0_hex
new file mode 100644
index 0000000000..ce2089453b
--- /dev/null
+++ b/examples/data/previous_tx_0_hex
@@ -0,0 +1 @@
+0200000000010158e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd7501000000171600145f275f436b09a8cc9a2eb2a2f528485c68a56323feffffff02d8231f1b0100000017a914aed962d6654f9a2b36608eb9d64d2b260db4f1118700c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e88702483045022100a22edcc6e5bc511af4cc4ae0de0fcd75c7e04d8c1c3a8aa9d820ed4b967384ec02200642963597b9b1bc22c75e9f3e117284a962188bf5e8a74c895089046a20ad770121035509a48eb623e10aace8bfd0212fdb8a8e5af3c94b0b133b95e114cab89e4f7965000000
\ No newline at end of file
diff --git a/examples/data/previous_tx_1_hex b/examples/data/previous_tx_1_hex
new file mode 100644
index 0000000000..9297523e38
--- /dev/null
+++ b/examples/data/previous_tx_1_hex
@@ -0,0 +1 @@
+0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f618765000000
\ No newline at end of file
diff --git a/examples/data/sign_1_psbt_hex b/examples/data/sign_1_psbt_hex
new file mode 100644
index 0000000000..3bcb9179a9
--- /dev/null
+++ b/examples/data/sign_1_psbt_hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/examples/data/sign_2_psbt_hex b/examples/data/sign_2_psbt_hex
new file mode 100644
index 0000000000..70231338dd
--- /dev/null
+++ b/examples/data/sign_2_psbt_hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/examples/data/update_1_psbt_hex b/examples/data/update_1_psbt_hex
new file mode 100644
index 0000000000..705d70d04b
--- /dev/null
+++ b/examples/data/update_1_psbt_hex
@@ -0,0 +1 @@
+70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f6187650000000104475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae2206029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f10d90c6a4f000000800000008000000080220602dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d710d90c6a4f0000008000000080010000800001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e88701042200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903010547522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae2206023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7310d90c6a4f000000800000008003000080220603089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc10d90c6a4f00000080000000800200008000220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000
\ No newline at end of file
diff --git a/examples/data/update_2_psbt_hex b/examples/data/update_2_psbt_hex
new file mode 100644
index 0000000000..31fbd54f71
--- /dev/null
+++ b/examples/data/update_2_psbt_hex
@@ -0,0 +1 @@
+70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f618765000000010304010000000104475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae2206029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f10d90c6a4f000000800000008000000080220602dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d710d90c6a4f0000008000000080010000800001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e8870103040100000001042200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903010547522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae2206023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7310d90c6a4f000000800000008003000080220603089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc10d90c6a4f00000080000000800200008000220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000
\ No newline at end of file
diff --git a/examples/psbt.rs b/examples/psbt.rs
new file mode 100644
index 0000000000..bfa0098af1
--- /dev/null
+++ b/examples/psbt.rs
@@ -0,0 +1,711 @@
+//! This file implements the test vector workflow in:
+//!
+//!  https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki#test-vectors
+//!
+//! starting at the line:
+//!
+//!  The private keys in the tests below are derived from the following master private key:
+//!
+
+// Attribution: `sign_psbt` logic is based on code in the `wallet` module of the `bdk` project. The
+// code in the two functions `legacy_sighash()` and `segwit_v0_sighash` is copied directly from
+// `bdk`, hence their licence applies to that code.
+//
+// ref: http://github.com/bitcoindevkit/bdk
+//
+// Bitcoin Dev Kit
+// Written in 2020 by Alekos Filini <alekos.filini@gmail.com>
+//
+// Copyright (c) 2020-2021 Bitcoin Dev Kit Developers
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
+extern crate bitcoin;
+
+use std::fmt;
+use std::str::FromStr;
+use std::collections::BTreeMap;
+
+use bitcoin::util::base58;
+use bitcoin::{Amount, Denomination, EcdsaSig, EcdsaSighashType, Network, OutPoint, PublicKey, PrivateKey, Script, Sighash, Transaction, Txid, TxOut, TxIn, Witness};
+use bitcoin::util::address::WitnessVersion;
+use bitcoin::consensus::encode::{serialize_hex, deserialize};
+use bitcoin::blockdata::{opcodes, script};
+use bitcoin::hashes::Hash;
+use bitcoin::hashes::hex::{FromHex};
+use bitcoin::secp256k1::{self, Message, SECP256K1};
+use bitcoin::util::bip32::{ExtendedPrivKey, ExtendedPubKey, Fingerprint, IntoDerivationPath, KeySource};
+use bitcoin::util::psbt::{PartiallySignedTransaction, PsbtSighashType};
+use bitcoin::util::sighash::SighashCache;
+
+const NETWORK: Network = Network::Testnet;
+
+type Psbt = PartiallySignedTransaction; // TODO: Consider adding this alias to `rust-bitcoin`.
+
+macro_rules! hex_script {
+    ($s:expr) => (<Script as FromStr>::from_str($s).unwrap());
+}
+
+macro_rules! hex_psbt {
+    ($s:expr) => (deserialize::<Psbt>(&<Vec<u8> as FromHex>::from_hex($s).unwrap()));
+}
+
+fn main() {
+    let secp = SECP256K1;
+
+    //
+    // Step 0: Create the extended private key from the test vector data.
+    //
+
+    let ext_priv = build_extended_private_key();
+    let ext_pub = ExtendedPubKey::from_priv(&secp, &ext_priv);
+    let fingerprint = ext_pub.fingerprint();
+
+    //
+    // Step 1: The creator.
+    //
+
+    let tx = create_transaction();
+    let psbt = create_psbt(tx);
+
+    //
+    // Step 2: The first updater.
+    //
+
+    // QUESTION: This update implies the updater knows the extended public key,
+    // is that correct? Otherwise where does the fingerprint come from?
+    let psbt = update_psbt(psbt, fingerprint);
+
+    //
+    // Step 3: The second updater.
+    //
+
+    let psbt = update_psbt_with_sighash_all(psbt);
+
+    //
+    // Step 4: The first signer.
+    //
+
+    // Strings from BIP174 test vector.
+    let test_vector = vec![
+        ("cP53pDbR5WtAD8dYAW9hhTjuvvTVaEiQBdrz9XPrgLBeRFiyCbQr", "m/0h/0h/0h"),
+        ("cR6SXDoyfQrcp4piaiHE97Rsgta9mNhGTen9XeonVgwsh4iSgw6d", "m/0h/0h/2h"),
+    ];
+
+    // We pass the keys to the signer after doing verification to make explicit
+    // that signer is only using these two keys.
+    let keys = parse_and_verify_keys(&ext_priv, &test_vector);
+    let psbt_1 = signer_one_sign(psbt.clone(), &keys);
+
+    //
+    // Step 5: The second signer.
+    //
+
+    // Strings from BIP174 test vector.
+    let test_vector = vec![
+        ("cT7J9YpCwY3AVRFSjN6ukeEeWY6mhpbJPxRaDaP5QTdygQRxP9Au", "m/0h/0h/1h"),
+        ("cNBc3SWUip9PPm1GjRoLEJT6T41iNzCYtD7qro84FMnM5zEqeJsE", "m/0h/0h/3h"),
+    ];
+
+    let keys = parse_and_verify_keys(&ext_priv, &test_vector);
+    let psbt_2 = signer_two_sign(psbt, &keys);
+
+    //
+    // Step 6: Combiner the two signed PSBTs.
+    //
+
+    let combined = combine(psbt_1, psbt_2);
+
+    //
+    // Step 7: Finalize the PSBT.
+    //
+
+    let finalized = finalize(combined);
+
+    //
+    // Step 8: Extract the transaction.
+    //
+
+    let _tx = extract_transaction(finalized);
+
+    //
+    // Step 9: Test lexicographical PSBT combiner
+    //
+
+    combine_lexicographically();
+}
+
+/// Attempts to build an extended private key from seed and also directly from a string.
+fn build_extended_private_key() -> ExtendedPrivKey {
+    // Strings from BIP174 test vector.
+    let extended_private_key = "tprv8ZgxMBicQKsPd9TeAdPADNnSyH9SSUUbTVeFszDE23Ki6TBB5nCefAdHkK8Fm3qMQR6sHwA56zqRmKmxnHk37JkiFzvncDqoKmPWubu7hDF";
+    let seed = "cUkG8i1RFfWGWy5ziR11zJ5V4U4W3viSFCfyJmZnvQaUsd1xuF3T";
+
+    let ext_priv = ExtendedPrivKey::from_str(extended_private_key).unwrap();
+
+    // TODO: Fix this so parsing seed works.
+    let seed = base58::from(&seed).unwrap();
+    let seeded = ExtendedPrivKey::new_master(NETWORK, &seed).unwrap();
+    if seeded != ext_priv {
+        eprintln!("Keys from seed and tprv string do not match");
+    }
+
+    ext_priv
+}
+
+/// Creates the initial transaction, called by the PSBT Creator.
+fn create_transaction() -> Transaction {
+    // Strings from BIP174 test vector.
+    let output_0 = TvOutput {
+        amount: "1.49990000",
+        script_pubkey: "0014d85c2b71d0060b09c9886aeb815e50991dda124d",
+
+    };
+    let output_1 = TvOutput {
+        amount: "1.00000000",
+        script_pubkey: "001400aea9a2e5f0f876a588df5546e8742d1d87008f",
+    };
+    let input_0 = TvInput {
+        txid: "75ddabb27b8845f5247975c8a5ba7c6f336c4570708ebe230caf6db5217ae858",
+        index: 0,
+    };
+    let input_1 = TvInput {
+        txid: "1dea7cd05979072a3578cab271c02244ea8a090bbb46aa680a65ecd027048d83",
+        index: 1,
+    };
+    struct TvOutput {
+        amount: &'static str,
+        script_pubkey: &'static str,
+    }
+    struct TvInput {
+        txid: &'static str,
+        index: u32,
+    }
+
+    Transaction {
+        version: 2,
+        lock_time: 0,
+        input: vec![
+            TxIn {
+                previous_output: OutPoint {
+                    txid: Txid::from_hex(input_0.txid).expect("failed to parse txid"),
+                    vout: input_0.index,
+                },
+                script_sig: Script::new(),
+                sequence: 0xFFFFFFFF, // Disable nSequence.
+                witness: Witness::default(),
+            },
+            TxIn {
+                previous_output: OutPoint {
+                    txid: Txid::from_hex(input_1.txid).expect("failed to parse txid"),
+                    vout: input_1.index,
+                },
+                script_sig: Script::new(),
+                sequence: 0xFFFFFFFF,
+                witness: Witness::default(),
+            }
+        ],
+        output: vec![
+            TxOut {
+                value: Amount::from_str_in(output_0.amount, Denomination::Bitcoin).expect("failed to parse amount").as_sat(),
+                script_pubkey: Script::from_str(output_0.script_pubkey).expect("failed to parse script"),
+            },
+            TxOut {
+                value: Amount::from_str_in(output_1.amount, Denomination::Bitcoin).expect("failed to parse amount").as_sat(),
+                script_pubkey: Script::from_str(output_1.script_pubkey).expect("failed to parse script"),
+            }
+        ],
+    }
+}
+
+/// Creates the initial PSBT, called by the Creator. Verifies against BIP174 test vector.
+fn create_psbt(tx: Transaction) -> Psbt {
+    // String from BIP174 test vector.
+    let expected_psbt_hex = include_str!("data/create_psbt_hex");
+
+    let psbt = Psbt::from_unsigned_tx(tx).unwrap();
+
+    let got = serialize_hex(&psbt);
+    assert_eq!(got, expected_psbt_hex);
+
+    psbt
+}
+
+/// Updates `psbt` according to the BIP, returns the newly updated PSBT. Verifies against BIP174 test vector.
+fn update_psbt(mut psbt: Psbt, fingerprint: Fingerprint) -> Psbt {
+    // Strings from BIP174 test vector.
+    let previous_tx_0 = include_str!("data/previous_tx_0_hex");
+    let previous_tx_1 = include_str!("data/previous_tx_1_hex");
+
+    let redeem_script_0 = "5221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae";
+    let redeem_script_1 = "00208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903";
+    let witness_script = "522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae";
+
+    // Public key and its derivation path (these are the child pubkeys for our `ExtendedPrivKey`,
+    // can be verified by deriving the key using this derivation path).
+    let pk_path = vec![
+        ("029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f", "m/0h/0h/0h"),
+        ("02dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d7", "m/0h/0h/1h"),
+        ("03089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc", "m/0h/0h/2h"),
+        ("023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e73", "m/0h/0h/3h"),
+        ("03a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca58771", "m/0h/0h/4h"),
+        ("027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b50051096", "m/0h/0h/5h"),
+    ];
+
+    let expected_psbt_hex = include_str!("data/update_1_psbt_hex");
+
+    let mut input_0 = psbt.inputs[0].clone();
+
+    let v = Vec::from_hex(&previous_tx_1).unwrap();
+    let tx: Transaction = deserialize(&v).unwrap();
+    input_0.non_witness_utxo = Some(tx);
+    input_0.redeem_script = Some(hex_script!(redeem_script_0));
+    input_0.bip32_derivation = bip32_derivation(fingerprint, &pk_path, vec![0, 1]);
+
+    let mut input_1 = psbt.inputs[1].clone();
+
+    let v = Vec::from_hex(&previous_tx_0).unwrap();
+    let tx: Transaction = deserialize(&v).unwrap();
+    input_1.witness_utxo = Some(tx.output[1].clone());
+
+    input_1.redeem_script = Some(hex_script!(redeem_script_1));
+    input_1.witness_script = Some(hex_script!(witness_script));
+    input_1.bip32_derivation = bip32_derivation(fingerprint, &pk_path, vec![2, 3]);
+
+    psbt.inputs = vec![input_0, input_1];
+
+    let mut output_0 = psbt.outputs[0].clone();
+    output_0.bip32_derivation = bip32_derivation(fingerprint, &pk_path, vec![4]);
+
+    let mut output_1 = psbt.outputs[1].clone();
+    output_1.bip32_derivation = bip32_derivation(fingerprint, &pk_path, vec![5]);
+
+    psbt.outputs = vec![output_0, output_1];
+
+    let got = serialize_hex(&psbt);
+    assert_eq!(got, expected_psbt_hex);
+
+    psbt
+}
+
+/// `pk_path` holds tuples of `(public_key, derivation_path)`. `indecies` is used to access the
+/// `pk_path` vector. `fingerprint` is from the parent extended public key.
+fn bip32_derivation(fingerprint: Fingerprint, pk_path: &[(&str, &str)], indecies: Vec<usize>) -> BTreeMap<secp256k1::PublicKey, KeySource> {
+    let mut tree = BTreeMap::new();
+    for i in indecies {
+        let pk = pk_path[i].0;
+        let path = pk_path[i].1;
+
+        let pk = PublicKey::from_str(pk).unwrap();
+        let path = path.into_derivation_path().unwrap();
+
+        tree.insert(pk.inner, (fingerprint, path));
+    }
+    tree
+}
+
+/// Does the second update according to the BIP, returns the newly updated PSBT. Verifies against BIP174 test vector.
+fn update_psbt_with_sighash_all(mut psbt: Psbt) -> Psbt {
+    let expected_psbt_hex = include_str!("data/update_2_psbt_hex");
+
+    let ty = PsbtSighashType::from_str("SIGHASH_ALL").unwrap();
+
+    let mut input_0 = psbt.inputs[0].clone();
+    input_0.sighash_type = Some(ty);
+    let mut input_1 = psbt.inputs[1].clone();
+    input_1.sighash_type = Some(ty);
+
+    psbt.inputs = vec![input_0, input_1];
+
+    let got = serialize_hex(&psbt);
+    assert_eq!(got, expected_psbt_hex);
+
+    psbt
+}
+
+/// Verifies the keys in the test vector are valid for the extended private key and derivation path.
+fn parse_and_verify_keys(ext_priv: &ExtendedPrivKey, sk_path: &[(&str, &str)]) -> Vec<PrivateKey> {
+    let secp = SECP256K1;
+
+    let mut keys = vec![];
+    for (secret_key, derivation_path) in sk_path.iter() {
+        let wifi_priv = PrivateKey::from_wif(secret_key).expect("failed to parse key");
+
+        let path = derivation_path.into_derivation_path().expect("failed to convert derivation path");
+        let derived_priv = ext_priv.derive_priv(&secp, &path).expect("failed to derive ext priv key").to_priv();
+        assert_eq!(wifi_priv, derived_priv);
+        keys.push(wifi_priv)
+    }
+    keys
+}
+
+/// Does the first signing according to the BIP, returns the signed PSBT. Verifies against BIP174 test vector.
+fn signer_one_sign(psbt: Psbt, keys: &[PrivateKey]) -> Psbt {
+    let expected_psbt_hex = include_str!("data/sign_1_psbt_hex");
+
+    let psbt = sign(psbt, keys);
+
+    let got = serialize_hex(&psbt);
+    assert_eq!(got, expected_psbt_hex);
+
+    psbt
+}
+
+/// Does the second signing according to the BIP, returns the signed PSBT. Verifies against BIP174 test vector.
+fn signer_two_sign(psbt: Psbt, keys: &[PrivateKey]) -> Psbt {
+    let expected_psbt_hex = include_str!("data/sign_2_psbt_hex");
+
+    let psbt = sign(psbt, keys);
+
+    let got = serialize_hex(&psbt);
+    assert_eq!(got, expected_psbt_hex);
+
+    psbt
+}
+
+/// Does the combine according to the BIP, returns the combined PSBT. Verifies against BIP174 test vector.
+fn combine(mut this: Psbt, that: Psbt) -> Psbt {
+    let expected_psbt_hex = include_str!("data/combine_psbt_hex");
+
+    this.combine(that).expect("failed to combine PSBTs");
+
+    let want_psbt = hex_psbt!(expected_psbt_hex).unwrap();
+    assert_eq!(this, want_psbt);
+
+    // TODO: Something in PSBT is not roundtripping deserialize/serialize, should it?
+    // let got = serialize_hex(&this);
+    // assert_eq!(got, expected_psbt_hex);  // TODO: This call fails.
+
+    this
+}
+
+/// Does the finalize step according to the BIP, returns the combined PSBT. Verifies against BIP174
+/// test vector.
+fn finalize(psbt: Psbt) -> Psbt {
+    let expected_psbt_hex = include_str!("data/finalize_psbt_hex");
+
+    let psbt = finalize_psbt(psbt);
+
+    let want = hex_psbt!(expected_psbt_hex).unwrap();
+    assert_eq!(psbt, want);
+
+    let got = serialize_hex(&psbt);
+    assert_eq!(got, expected_psbt_hex);
+
+    psbt
+}
+
+/// Does the transaction extractor step according to the BIP, returns the combined PSBT. Verifies
+/// against BIP174 test vector.
+fn extract_transaction(psbt: Psbt) -> Transaction {
+    let expected_tx_hex = include_str!("data/extract_tx_hex");
+
+    let tx = psbt.extract_tx();
+    
+    let got = serialize_hex(&tx);
+    assert_eq!(got, expected_tx_hex);
+
+    tx
+}
+
+/// Combines two PSBTs lexicographically according to the BIP. Verifies against BIP174 test vector.
+fn combine_lexicographically() {
+    let psbt_1_hex = include_str!("data/lex_psbt_1_hex");
+    let psbt_2_hex = include_str!("data/lex_psbt_2_hex");
+
+    let expected_psbt_hex = include_str!("data/lex_combine_psbt_hex");
+    
+    let v = Vec::from_hex(&psbt_1_hex).unwrap();
+    let mut psbt_1: Psbt = deserialize(&v).expect("failed to deserialize psbt 1");
+
+    let v = Vec::from_hex(&psbt_2_hex).unwrap();
+    let psbt_2: Psbt = deserialize(&v).expect("failed to deserialize psbt 2");
+
+    psbt_1.combine(psbt_2).expect("failed to combine PSBTs");
+
+    let got = serialize_hex(&psbt_1);
+    assert_eq!(got, expected_psbt_hex);
+}
+
+/// Signs `psbt` with `keys` if required.
+fn sign(mut psbt: Psbt, keys: &[PrivateKey]) -> Psbt {
+    let secp = SECP256K1;
+
+    let mut inputs = psbt.inputs.clone();
+
+    for (i, input) in inputs.iter_mut().enumerate() {
+        let required_pks: Vec<_> = input.bip32_derivation.keys().collect();
+        for sk in keys {
+            let pk = sk.public_key(&secp);
+            if required_pks.contains(&&pk.inner) {
+                sign_psbt(&sk, &mut psbt, i).expect("failed to sign input with key");
+            }
+        }
+    }
+
+    psbt
+}
+
+/// Signs `psbt` input at `input_index` using `sk`.
+// TODO: Consider adding this code to rust-bitcoin.
+fn sign_psbt(
+    sk: &PrivateKey,
+    psbt: &mut Psbt,
+    input_index: usize,
+) -> Result<(), SignError> {
+    let secp = SECP256K1;
+
+    if input_index >= psbt.inputs.len() || input_index >= psbt.unsigned_tx.input.len() {
+        return Err(SignError::InputIndexOutOfRange);
+    }
+
+    if psbt.inputs[input_index].final_script_sig.is_some()
+        || psbt.inputs[input_index].final_script_witness.is_some()
+    {
+        return Ok(());
+    }
+
+    let pubkey = sk.public_key(secp);
+    if psbt.inputs[input_index].partial_sigs.contains_key(&pubkey) {
+        return Ok(());
+    }
+
+    let (hash, sighash_type) = match psbt.inputs[input_index].witness_utxo {
+        Some(_) => segwit_v0_sighash(psbt, input_index)?,
+        None => legacy_sighash(psbt, input_index)?,
+    };
+
+    // From BIP: Before signing a non-witness input, the Signer must verify that the TXID of the
+    // non-witness UTXO matches the TXID specified in the unsigned transaction.
+    if let Some(tx) = &psbt.inputs[input_index].non_witness_utxo {
+        if tx.txid() != psbt.unsigned_tx.input[input_index].previous_output.txid {
+            return Err(SignError::InvalidTxid);
+        }
+    }
+
+    // From BIP: Before signing a witness input, the Signer must verify that the witnessScript (if
+    // provided) matches the hash specified in the UTXO or the redeemScript, and the redeemScript
+    // (if provided) matches the hash in the UTXO.
+    if let Some(tx) = &psbt.inputs[input_index].witness_utxo {
+        if let Some(script) = &psbt.inputs[input_index].witness_script {
+            let redeem_script = psbt.inputs[1].redeem_script.clone().unwrap();
+
+            let witness_program = Script::new_witness_program(WitnessVersion::V0, &script.wscript_hash());
+            if redeem_script != witness_program {
+                return Err(SignError::WitnessRedeemMismatch);
+            }
+
+
+            let redeem_script = psbt.inputs[1].redeem_script.clone().unwrap();
+            let script = Script::new_p2sh(&redeem_script.script_hash());
+
+            if script != tx.script_pubkey {
+                return Err(SignError::ScritpPubkeyMismatch);
+            }
+
+        }
+    }
+
+    let signature = secp.sign_ecdsa(
+        &Message::from_slice(&hash.into_inner()[..]).unwrap(),
+        &sk.inner,
+    );
+
+    let mut final_signature = Vec::with_capacity(75);
+    final_signature.extend_from_slice(&signature.serialize_der());
+    final_signature.push(sighash_type.to_u32() as u8);
+
+    psbt.inputs[input_index]
+        .partial_sigs = BTreeMap::from([(pubkey, EcdsaSig::from_slice(&final_signature).map_err(|_| SignError::Ecdsa)?)]);
+
+    Ok(())
+}
+
+// Copied directly from `impl ComputeSighash for Legacy` in `bdk`.
+fn legacy_sighash(psbt: &Psbt, input_index: usize) -> Result<(Sighash, EcdsaSighashType), SignError> {
+    if input_index >= psbt.inputs.len() || input_index >= psbt.unsigned_tx.input.len() {
+        return Err(SignError::InputIndexOutOfRange);
+    }
+
+    let psbt_input = &psbt.inputs[input_index];
+    let tx_input = &psbt.unsigned_tx.input[input_index];
+
+    let sighash = psbt_input.sighash_type.unwrap_or(PsbtSighashType::from(EcdsaSighashType::All));
+    let script = match psbt_input.redeem_script {
+        Some(ref redeem_script) => redeem_script.clone(),
+        None => {
+            let non_witness_utxo = psbt_input
+                .non_witness_utxo
+                .as_ref()
+                .ok_or(SignError::MissingNonWitnessUtxo)?;
+            let prev_out = non_witness_utxo
+                .output
+                .get(tx_input.previous_output.vout as usize)
+                .ok_or(SignError::InvalidNonWitnessUtxo)?;
+
+            prev_out.script_pubkey.clone()
+        }
+    };
+
+    Ok((
+        psbt.unsigned_tx
+            .signature_hash(input_index, &script, sighash.to_u32()),
+        sighash.ecdsa_hash_ty().map_err(|_| SignError::Ecdsa)?,
+    ))
+}
+
+// Copied directly from `impl ComputeSighash for Segwitv0` in `bdk`.
+fn segwit_v0_sighash(psbt: &Psbt, input_index: usize) -> Result<(Sighash, EcdsaSighashType), SignError> {
+    if input_index >= psbt.inputs.len() || input_index >= psbt.unsigned_tx.input.len() {
+        return Err(SignError::InputIndexOutOfRange);
+    }
+
+    let psbt_input = &psbt.inputs[input_index];
+    let tx_input = &psbt.unsigned_tx.input[input_index];
+
+    let sighash = psbt_input.sighash_type.unwrap_or(PsbtSighashType::from(EcdsaSighashType::All));
+
+    // Always try first with the non-witness utxo.
+    let utxo = if let Some(prev_tx) = &psbt_input.non_witness_utxo {
+        // Check the provided prev-tx
+        if prev_tx.txid() != tx_input.previous_output.txid {
+            return Err(SignError::InvalidNonWitnessUtxo);
+        }
+
+        // The output should be present, if it's missing the `non_witness_utxo` is invalid.
+        prev_tx
+            .output
+            .get(tx_input.previous_output.vout as usize)
+            .ok_or(SignError::InvalidNonWitnessUtxo)?
+    } else if let Some(witness_utxo) = &psbt_input.witness_utxo {
+        // Fallback to the witness_utxo. If we aren't allowed to use it, signing should fail
+        // before we get to this point.
+        witness_utxo
+    } else {
+        // Nothing has been provided.
+        return Err(SignError::MissingNonWitnessUtxo);
+    };
+    let value = utxo.value;
+
+    let script = match psbt_input.witness_script {
+        Some(ref witness_script) => witness_script.clone(),
+        None => {
+            if utxo.script_pubkey.is_v0_p2wpkh() {
+                p2wpkh_script_code(&utxo.script_pubkey)
+            } else if psbt_input
+                .redeem_script
+                .as_ref()
+                .map(Script::is_v0_p2wpkh)
+                .unwrap_or(false)
+            {
+                p2wpkh_script_code(psbt_input.redeem_script.as_ref().unwrap())
+            } else {
+                return Err(SignError::MissingWitnessScript);
+            }
+        }
+    };
+
+    Ok((
+        SighashCache::new(&psbt.unsigned_tx).segwit_signature_hash(
+            input_index,
+            &script,
+            value,
+            sighash.ecdsa_hash_ty().map_err(|_| SignError::Ecdsa)?,
+        ).map_err(|_| SignError::Sighash)?,
+        sighash.ecdsa_hash_ty().map_err(|_| SignError::Ecdsa)?
+    ))
+}
+
+/// Finalizes a PSBT accord to the Input Finalizer role described in BIP174.
+fn finalize_psbt(mut psbt: Psbt) -> Psbt {
+    use bitcoin::util::psbt::serialize::Serialize;
+
+    // Input 0: legacy UTXO
+
+    let sigs: Vec<_> = psbt.inputs[0].partial_sigs.values().collect();
+    let script_sig = script::Builder::new()
+        // OP_CHECKMULTISIG bug pops +1 value when evaluating so push OP_0.
+        // TODO: Consider adding OP_ZERO alias to rust-bitcoin (`pub static OP_ZERO: All = all::OP_PUSHBYTES_0;`).
+        .push_opcode(opcodes::all::OP_PUSHBYTES_0)
+        .push_slice(&sigs[0].serialize())
+        .push_slice(&sigs[1].serialize())
+        .push_slice(&psbt.inputs[0].redeem_script.clone().unwrap().serialize())
+        .into_script();
+
+    psbt.inputs[0].final_script_sig = Some(script_sig);
+
+    psbt.inputs[0].partial_sigs = BTreeMap::new();
+    psbt.inputs[0].sighash_type = None;
+    psbt.inputs[0].redeem_script = None;
+    psbt.inputs[0].bip32_derivation = BTreeMap::new();
+
+    // Input 1: SegWit UTXO
+
+    let script_sig = script::Builder::new()
+        .push_slice(&psbt.inputs[1].redeem_script.clone().unwrap().serialize())
+        .into_script();
+
+    psbt.inputs[1].final_script_sig = Some(script_sig);
+
+    let sigs: Vec<_> = psbt.inputs[1].partial_sigs.values().collect();
+    let mut script_witness: Witness = Witness::new();
+    script_witness.push([]);    // Pushes 0x00 to the stack.
+    script_witness.push(&sigs[1].serialize());
+    script_witness.push(&sigs[0].serialize());
+    script_witness.push(&psbt.inputs[1].witness_script.clone().unwrap().serialize());
+
+    psbt.inputs[1].final_script_witness = Some(script_witness);
+
+    psbt.inputs[1].partial_sigs = BTreeMap::new();
+    psbt.inputs[1].sighash_type = None;
+    psbt.inputs[1].redeem_script = None;
+    psbt.inputs[1].witness_script = None;
+    psbt.inputs[1].bip32_derivation = BTreeMap::new();
+
+    psbt
+}
+
+fn p2wpkh_script_code(script: &Script) -> Script {
+    script::Builder::new()
+        .push_opcode(opcodes::all::OP_DUP)
+        .push_opcode(opcodes::all::OP_HASH160)
+        .push_slice(&script[2..])
+        .push_opcode(opcodes::all::OP_EQUALVERIFY)
+        .push_opcode(opcodes::all::OP_CHECKSIG)
+        .into_script()
+}
+
+/// Signing error.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum SignError {
+    /// Input index is out of range
+    InputIndexOutOfRange,
+    /// The `non_witness_utxo` field of the transaction is required to sign this input
+    MissingNonWitnessUtxo,
+    /// The `non_witness_utxo` specified is invalid
+    InvalidNonWitnessUtxo,
+    /// The `witness_script` field of the transaction is required to sign this input
+    MissingWitnessScript,
+    /// bitcoin::ecdsa error.
+    Ecdsa,
+    /// Sighash encoding error.
+    Sighash,
+    /// BIP174: non-witness input txid must match txid of unsigned transaction.
+    InvalidTxid,
+    /// BIP174: witness script must match the hash in the redeem script.
+    WitnessRedeemMismatch,
+    /// BIP174: redeem script must match the hash in the UTXO.
+    ScritpPubkeyMismatch,
+}
+
+impl fmt::Display for SignError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+impl std::error::Error for SignError {}