// Copyright (c) 2018 The btcsuite developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.

package psbt

import (
	"bytes"
	"encoding/base64"
	"encoding/binary"
	"encoding/hex"
	"testing"

	"github.com/lbryio/lbcd/chaincfg/chainhash"
	"github.com/lbryio/lbcd/txscript"
	"github.com/lbryio/lbcd/wire"
	"github.com/lbryio/lbcutil"
	"github.com/davecgh/go-spew/spew"
)

// Test vectors from:
// // https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki#test-vectors

// createPsbtFromSignedTx is a utility function to create a PSBT from an
// already-signed transaction, so we can test reconstructing, signing and
// extracting it. Returned are: an unsigned transaction serialization, a list
// of scriptSigs, one per input, and a list of witnesses, one per input.
func createPsbtFromSignedTx(serializedSignedTx []byte) (
	*Packet, [][]byte, []wire.TxWitness, error) {

	tx := wire.NewMsgTx(2)
	err := tx.Deserialize(bytes.NewReader(serializedSignedTx))
	if err != nil {
		return nil, nil, nil, err
	}
	scriptSigs := make([][]byte, 0, len(tx.TxIn))
	witnesses := make([]wire.TxWitness, 0, len(tx.TxIn))
	tx2 := tx.Copy()

	// Blank out signature info in inputs
	for i, tin := range tx2.TxIn {
		tin.SignatureScript = nil
		scriptSigs = append(scriptSigs, tx.TxIn[i].SignatureScript)
		tin.Witness = nil
		witnesses = append(witnesses, tx.TxIn[i].Witness)

	}

	// Outputs always contain: (value, scriptPubkey) so don't need
	// amending.  Now tx2 is tx with all signing data stripped out
	unsignedPsbt, err := NewFromUnsignedTx(tx2)
	if err != nil {
		return nil, nil, nil, err
	}
	return unsignedPsbt, scriptSigs, witnesses, nil
}

// These are all valid PSBTs
var validPsbtHex = map[int]string{
	0: "70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab300000000000000",
	1: "70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac000000000001076a47304402204759661797c01b036b25928948686218347d89864b719e1f7fcf57d1e511658702205309eabf56aa4d8891ffd111fdf1336f3a29da866d7f8486d75546ceedaf93190121035cdc61fc7ba971c0b501a646a2a83b102cb43881217ca682dc86e2d73fa882920001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb82308000000",
	2: "70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000001030401000000000000",
	3: "70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac00000000000100df0200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf6000000006a473044022070b2245123e6bf474d60c5b50c043d4c691a5d2435f09a34a7662a9dc251790a022001329ca9dacf280bdf30740ec0390422422c81cb45839457aeb76fc12edd95b3012102657d118d3357b8e0f4c2cd46db7b39f6d9c38d9a70abcb9b2de5dc8dbfe4ce31feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e13000001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb8230800220202ead596687ca806043edc3de116cdf29d5e9257c196cd055cf698c8d02bf24e9910b4a6ba670000008000000080020000800022020394f62be9df19952c5587768aeb7698061ad2c4a25c894f47d8c162b4d7213d0510b4a6ba6700000080010000800200008000",
	4: "70736274ff0100550200000001279a2323a5dfb51fc45f220fa58b0fc13e1e3342792a85d7e36cd6333b5cbc390000000000ffffffff01a05aea0b000000001976a914ffe9c0061097cc3b636f2cb0460fa4fc427d2b4588ac0000000000010120955eea0b0000000017a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87220203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4646304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a010104220020771fd18ad459666dd49f3d564e3dbc42f4c84774e360ada16816a8ed488d5681010547522103b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd462103de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd52ae220603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4610b4a6ba67000000800000008004000080220603de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd10b4a6ba670000008000000080050000800000",
	5: "70736274ff01003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a010000000000000a0f0102030405060708090f0102030405060708090a0b0c0d0e0f0000",
}

// These are all invalid PSBTs for the indicated
// reasons.
var invalidPsbtHex = map[int]string{
	// wire format, not PSBT format
	0: "0200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf6000000006a473044022070b2245123e6bf474d60c5b50c043d4c691a5d2435f09a34a7662a9dc251790a022001329ca9dacf280bdf30740ec0390422422c81cb45839457aeb76fc12edd95b3012102657d118d3357b8e0f4c2cd46db7b39f6d9c38d9a70abcb9b2de5dc8dbfe4ce31feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300",
	// missing outputs
	1: "70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000000",
	// Filled in scriptSig in unsigned tx
	2: "70736274ff0100fd0a010200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be4000000006a47304402204759661797c01b036b25928948686218347d89864b719e1f7fcf57d1e511658702205309eabf56aa4d8891ffd111fdf1336f3a29da866d7f8486d75546ceedaf93190121035cdc61fc7ba971c0b501a646a2a83b102cb43881217ca682dc86e2d73fa88292feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac00000000000001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb82308000000",
	// No unsigned tx
	3: "70736274ff000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000000",
	// Duplicate keys in an input
	4: "70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000001003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a010000000000000000",
	// Invalid global transaction typed key
	5: "70736274ff020001550200000001279a2323a5dfb51fc45f220fa58b0fc13e1e3342792a85d7e36cd6333b5cbc390000000000ffffffff01a05aea0b000000001976a914ffe9c0061097cc3b636f2cb0460fa4fc427d2b4588ac0000000000010120955eea0b0000000017a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87220203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4646304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a010104220020771fd18ad459666dd49f3d564e3dbc42f4c84774e360ada16816a8ed488d5681010547522103b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd462103de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd52ae220603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4610b4a6ba67000000800000008004000080220603de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd10b4a6ba670000008000000080050000800000",
	// Invalid input witness utxo typed key
	6: "70736274ff0100550200000001279a2323a5dfb51fc45f220fa58b0fc13e1e3342792a85d7e36cd6333b5cbc390000000000ffffffff01a05aea0b000000001976a914ffe9c0061097cc3b636f2cb0460fa4fc427d2b4588ac000000000002010020955eea0b0000000017a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87220203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4646304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a010104220020771fd18ad459666dd49f3d564e3dbc42f4c84774e360ada16816a8ed488d5681010547522103b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd462103de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd52ae220603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4610b4a6ba67000000800000008004000080220603de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd10b4a6ba670000008000000080050000800000",
	// Invalid pubkey length for input partial signature typed key
	7: "70736274ff0100550200000001279a2323a5dfb51fc45f220fa58b0fc13e1e3342792a85d7e36cd6333b5cbc390000000000ffffffff01a05aea0b000000001976a914ffe9c0061097cc3b636f2cb0460fa4fc427d2b4588ac0000000000010120955eea0b0000000017a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87210203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd46304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a010104220020771fd18ad459666dd49f3d564e3dbc42f4c84774e360ada16816a8ed488d5681010547522103b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd462103de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd52ae220603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4610b4a6ba67000000800000008004000080220603de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd10b4a6ba670000008000000080050000800000",
	// Invalid redeemscript typed key
	8: "70736274ff0100550200000001279a2323a5dfb51fc45f220fa58b0fc13e1e3342792a85d7e36cd6333b5cbc390000000000ffffffff01a05aea0b000000001976a914ffe9c0061097cc3b636f2cb0460fa4fc427d2b4588ac0000000000010120955eea0b0000000017a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87220203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4646304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a01020400220020771fd18ad459666dd49f3d564e3dbc42f4c84774e360ada16816a8ed488d5681010547522103b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd462103de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd52ae220603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4610b4a6ba67000000800000008004000080220603de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd10b4a6ba670000008000000080050000800000",
	// Invalid witness script typed key
	9: "70736274ff0100550200000001279a2323a5dfb51fc45f220fa58b0fc13e1e3342792a85d7e36cd6333b5cbc390000000000ffffffff01a05aea0b000000001976a914ffe9c0061097cc3b636f2cb0460fa4fc427d2b4588ac0000000000010120955eea0b0000000017a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87220203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4646304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a010104220020771fd18ad459666dd49f3d564e3dbc42f4c84774e360ada16816a8ed488d568102050047522103b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd462103de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd52ae220603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4610b4a6ba67000000800000008004000080220603de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd10b4a6ba670000008000000080050000800000",
	// Invalid bip32 typed key
	10: "70736274ff0100550200000001279a2323a5dfb51fc45f220fa58b0fc13e1e3342792a85d7e36cd6333b5cbc390000000000ffffffff01a05aea0b000000001976a914ffe9c0061097cc3b636f2cb0460fa4fc427d2b4588ac0000000000010120955eea0b0000000017a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87220203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4646304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a010104220020771fd18ad459666dd49f3d564e3dbc42f4c84774e360ada16816a8ed488d5681010547522103b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd462103de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd52ae210603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd10b4a6ba67000000800000008004000080220603de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd10b4a6ba670000008000000080050000800000",
	// Invalid non-witness utxo typed key
	11: "70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f0000000000020000bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f6187650000000107da00473044022074018ad4180097b873323c0015720b3684cc8123891048e7dbcd9b55ad679c99022073d369b740e3eb53dcefa33823c8070514ca55a7dd9544f157c167913261118c01483045022100f61038b308dc1da865a34852746f015772934208c6d24454393cd99bdf2217770220056e675a675a6d0a02b85b14e5e29074d8a25a9b5760bea2816f661910a006ea01475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae0001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e8870107232200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b20289030108da0400473044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01473044022065f45ba5998b59a27ffe1a7bed016af1f1f90d54b3aa8f7450aa5f56a25103bd02207f724703ad1edb96680b284b56d4ffcb88f7fb759eabbe08aa30f29b851383d20147522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae00220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000",
	// Invalid final scriptsig typed key
	12: "70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f618765000000020700da00473044022074018ad4180097b873323c0015720b3684cc8123891048e7dbcd9b55ad679c99022073d369b740e3eb53dcefa33823c8070514ca55a7dd9544f157c167913261118c01483045022100f61038b308dc1da865a34852746f015772934208c6d24454393cd99bdf2217770220056e675a675a6d0a02b85b14e5e29074d8a25a9b5760bea2816f661910a006ea01475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae0001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e8870107232200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b20289030108da0400473044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01473044022065f45ba5998b59a27ffe1a7bed016af1f1f90d54b3aa8f7450aa5f56a25103bd02207f724703ad1edb96680b284b56d4ffcb88f7fb759eabbe08aa30f29b851383d20147522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae00220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000",
	// Invalid final script witness typed key
	13: "70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f6187650000000107da00473044022074018ad4180097b873323c0015720b3684cc8123891048e7dbcd9b55ad679c99022073d369b740e3eb53dcefa33823c8070514ca55a7dd9544f157c167913261118c01483045022100f61038b308dc1da865a34852746f015772934208c6d24454393cd99bdf2217770220056e675a675a6d0a02b85b14e5e29074d8a25a9b5760bea2816f661910a006ea01475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae0001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e8870107232200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903020800da0400473044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01473044022065f45ba5998b59a27ffe1a7bed016af1f1f90d54b3aa8f7450aa5f56a25103bd02207f724703ad1edb96680b284b56d4ffcb88f7fb759eabbe08aa30f29b851383d20147522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae00220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000",
	// Invalid pubkey in output BIP32 derivation paths typed key
	14: "70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f6187650000000107da00473044022074018ad4180097b873323c0015720b3684cc8123891048e7dbcd9b55ad679c99022073d369b740e3eb53dcefa33823c8070514ca55a7dd9544f157c167913261118c01483045022100f61038b308dc1da865a34852746f015772934208c6d24454393cd99bdf2217770220056e675a675a6d0a02b85b14e5e29074d8a25a9b5760bea2816f661910a006ea01475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae0001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e8870107232200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b20289030108da0400473044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01473044022065f45ba5998b59a27ffe1a7bed016af1f1f90d54b3aa8f7450aa5f56a25103bd02207f724703ad1edb96680b284b56d4ffcb88f7fb759eabbe08aa30f29b851383d20147522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae00210203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca58710d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000",
	// Invalid input sighash type typed key
	15: "70736274ff0100730200000001301ae986e516a1ec8ac5b4bc6573d32f83b465e23ad76167d68b38e730b4dbdb0000000000ffffffff02747b01000000000017a91403aa17ae882b5d0d54b25d63104e4ffece7b9ea2876043993b0000000017a914b921b1ba6f722e4bfa83b6557a3139986a42ec8387000000000001011f00ca9a3b00000000160014d2d94b64ae08587eefc8eeb187c601e939f9037c0203000100000000010016001462e9e982fff34dd8239610316b090cd2a3b747cb000100220020876bad832f1d168015ed41232a9ea65a1815d9ef13c0ef8759f64b5b2b278a65010125512103b7ce23a01c5b4bf00a642537cdfabb315b668332867478ef51309d2bd57f8a8751ae00",
	// Invalid output redeemscript typed key
	16: "70736274ff0100730200000001301ae986e516a1ec8ac5b4bc6573d32f83b465e23ad76167d68b38e730b4dbdb0000000000ffffffff02747b01000000000017a91403aa17ae882b5d0d54b25d63104e4ffece7b9ea2876043993b0000000017a914b921b1ba6f722e4bfa83b6557a3139986a42ec8387000000000001011f00ca9a3b00000000160014d2d94b64ae08587eefc8eeb187c601e939f9037c0002000016001462e9e982fff34dd8239610316b090cd2a3b747cb000100220020876bad832f1d168015ed41232a9ea65a1815d9ef13c0ef8759f64b5b2b278a65010125512103b7ce23a01c5b4bf00a642537cdfabb315b668332867478ef51309d2bd57f8a8751ae00",
	// Invalid output witnessScript typed key
	17: "70736274ff0100730200000001301ae986e516a1ec8ac5b4bc6573d32f83b465e23ad76167d68b38e730b4dbdb0000000000ffffffff02747b01000000000017a91403aa17ae882b5d0d54b25d63104e4ffece7b9ea2876043993b0000000017a914b921b1ba6f722e4bfa83b6557a3139986a42ec8387000000000001011f00ca9a3b00000000160014d2d94b64ae08587eefc8eeb187c601e939f9037c00010016001462e9e982fff34dd8239610316b090cd2a3b747cb000100220020876bad832f1d168015ed41232a9ea65a1815d9ef13c0ef8759f64b5b2b278a6521010025512103b7ce23a01c5b4bf00a642537cdfabb315b668332867478ef51309d2bd57f8a8751ae00",
	// Additional cases outside the existing test vectors.
	// Invalid duplicate PartialSig
	18: "70736274ff0100550200000001279a2323a5dfb51fc45f220fa58b0fc13e1e3342792a85d7e36cd6333b5cbc390000000000ffffffff01a05aea0b000000001976a914ffe9c0061097cc3b636f2cb0460fa4fc427d2b4588ac0000000000010120955eea0b0000000017a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87220203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4646304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a01220203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4646304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a010104220020771fd18ad459666dd49f3d564e3dbc42f4c84774e360ada16816a8ed488d5681010547522103b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd462103de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd52ae220603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4610b4a6ba67000000800000008004000080220603de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd10b4a6ba670000008000000080050000800000",
	// Invalid duplicate BIP32 derivation (different derivs, same key)
	19: "70736274ff0100550200000001279a2323a5dfb51fc45f220fa58b0fc13e1e3342792a85d7e36cd6333b5cbc390000000000ffffffff01a05aea0b000000001976a914ffe9c0061097cc3b636f2cb0460fa4fc427d2b4588ac0000000000010120955eea0b0000000017a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87220203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4646304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a010104220020771fd18ad459666dd49f3d564e3dbc42f4c84774e360ada16816a8ed488d5681010547522103b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd462103de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd52ae220603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4610b4a6ba67000000800000008004000080220603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4610b4a6ba670000008000000080050000800000",
}

// This tests that valid PSBT serializations can be parsed
// into Psbt structs.
func TestReadValidPsbtAndReserialize(t *testing.T) {
	for _, v := range validPsbtHex {
		PsbtBytes, err := hex.DecodeString(v)
		if err != nil {
			t.Fatalf("Unable to decode hex: %v", err)
		}

		testPsbt, err := NewFromRawBytes(
			bytes.NewReader(PsbtBytes), false,
		)
		if err != nil {
			t.Fatalf("unable to parse psbt: %v", err)
		}

		t.Logf("Successfully parsed test, got transaction: %v",
			spew.Sdump(testPsbt.UnsignedTx))

		var b bytes.Buffer
		err = testPsbt.Serialize(&b)
		if err != nil {
			t.Fatalf("Unable to serialize created Psbt: %v", err)
		}

		raw := b.Bytes()
		if !bytes.Equal(raw, PsbtBytes) {
			t.Fatalf("Serialized PSBT didn't match: %v",
				hex.EncodeToString(raw))
		}
	}
}

func TestReadInvalidPsbt(t *testing.T) {
	for _, v := range invalidPsbtHex {
		PsbtBytes, err := hex.DecodeString(v)
		if err != nil {
			t.Fatalf("Unable to decode hex: %v", err)
		}

		_, err = NewFromRawBytes(bytes.NewReader(PsbtBytes), false)
		if err == nil {
			t.Fatalf("Incorrectly validated psbt: %v",
				hex.EncodeToString(PsbtBytes))
		}

		t.Logf("Correctly got error: %v", err)
	}
}

func TestSanityCheck(t *testing.T) {
	// TODO(guggero): Remove when checks for segwit v1 are implemented.
	t.Skip("Skipping PSBT sanity checks for segwit v0.")

	// Test strategy:
	// 1. Create an invalid PSBT from a serialization
	// Then ensure that the sanity check fails.
	// 2. Create a valid PSBT from a serialization
	// Then create an updater, add a witness utxo to a non-witness
	// utxo.
	// Then ensure that the sanity check fails.
	// Then add a witnessScript field to a non-witness utxo.
	// Then ensure that the sanity check fails.

	// index 1 contains a psbt with two inputs, first non-witness,
	// second witness.
	psbtraw1, err := hex.DecodeString(validPsbtHex[1])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	psbt1, err := NewFromRawBytes(bytes.NewReader(psbtraw1), false)
	if err != nil {
		t.Fatalf("Unable to create Psbt struct: %v", err)
	}

	// Add a non-witness utxo field to input2 using raw insertion function,
	// so that it becomes invalid, then NewUpdater should fail.
	nonWitnessUtxoRaw, err := hex.DecodeString(
		CUTestHexData["NonWitnessUtxo"],
	)
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	nonWitnessUtxo := wire.NewMsgTx(2)
	err = nonWitnessUtxo.Deserialize(bytes.NewReader(nonWitnessUtxoRaw))
	if err != nil {
		t.Fatalf("Unable to deserialize: %v", err)
	}
	inputs1 := &psbt1.Inputs[1]
	inputs1.NonWitnessUtxo = nonWitnessUtxo

	// The PSBT is now in an inconsistent state; Updater creation should
	// fail.
	updater, err := NewUpdater(psbt1)
	if err == nil {
		t.Fatalf("Failed to identify invalid PSBT state ( " +
			"witness, non-witness fields)")
	}

	// Overwrite back with the correct psbt
	psbtraw1, err = hex.DecodeString(validPsbtHex[1])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	psbt1, err = NewFromRawBytes(bytes.NewReader(psbtraw1), false)
	updater, err = NewUpdater(psbt1)
	if err != nil {
		t.Fatalf("Unable to create Updater: %v", err)
	}

	// Create a fake non-witness utxo field to overlap with
	// the existing witness input at index 1.
	tx := wire.NewMsgTx(2)
	err = tx.Deserialize(bytes.NewReader(nonWitnessUtxoRaw))
	if err != nil {
		t.Fatalf("Error deserializing transaction: %v", err)
	}
	err = updater.AddInNonWitnessUtxo(tx, 1)
	if err == nil {
		t.Fatalf("Incorrectly accepted Psbt with conflicting witness " +
			"and non-witness utxo entries in the same input.")
	}

	// Now we try again; this time we try to add a witnessScript
	// key-value pair to an input which is non-witness, which should
	// also be rejected.
	psbt2, err := NewFromRawBytes(
		bytes.NewReader(psbtraw1), false,
	)
	if err != nil {
		t.Fatalf("Unable to create Psbt struct: %v", err)
	}
	updater2, err := NewUpdater(psbt2)
	if err != nil {
		t.Fatalf("Got error creating  updater2: %v", err)
	}
	witnessScript, err := hex.DecodeString(
		CUTestHexData["Input2WitnessScript"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	err = updater2.AddInWitnessScript(witnessScript, 0)
	if err == nil {
		t.Fatalf("Incorrectly accepted adding witness script field " +
			"to non-witness utxo")
	}
}

// Data for creation and updating tests
// ===============================================================================
var CUTestHexData = map[string]string{
	"scriptPubkey1":  "0014d85c2b71d0060b09c9886aeb815e50991dda124d",
	"scriptPubkey2":  "001400aea9a2e5f0f876a588df5546e8742d1d87008f",
	"txid1":          "75ddabb27b8845f5247975c8a5ba7c6f336c4570708ebe230caf6db5217ae858",
	"txid2":          "1dea7cd05979072a3578cab271c02244ea8a090bbb46aa680a65ecd027048d83",
	"COPsbtHex":      "70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f000000000000000000",
	"NonWitnessUtxo": "0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f618765000000",
	"WitnessUtxo":    "00c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e887",
	// After adding witnessutxo and nonwitness utxo to inputs:
	"UOPsbtHex":           "70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f6187650000000001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e887000000",
	"Input1RedeemScript":  "5221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae",
	"Input2RedeemScript":  "00208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903",
	"Input2WitnessScript": "522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae",
	// After adding redeemscripts and witness scripts to inputs:
	"UOPsbtHex2": "70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f6187650000000104475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae0001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e88701042200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903010547522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae000000",
	// After adding bip32 derivations to inputs and outputs:
	"UOPsbtHex3": "70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f6187650000000104475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae2206029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f10d90c6a4f000000800000008000000080220602dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d710d90c6a4f0000008000000080010000800001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e88701042200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903010547522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae2206023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7310d90c6a4f000000800000008003000080220603089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc10d90c6a4f00000080000000800200008000220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000",
	//After adding sighash types to inputs
	"UOPsbtHex4": "70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f618765000000010304010000000104475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae2206029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f10d90c6a4f000000800000008000000080220602dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d710d90c6a4f0000008000000080010000800001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e8870103040100000001042200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903010547522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae2206023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7310d90c6a4f000000800000008003000080220603089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc10d90c6a4f00000080000000800200008000220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000",
}

// Just one example sanity check of B64 construction; after sighash appending above
var CUTestB64Data = map[string]string{
	"UOPsbtB644": "cHNidP8BAJoCAAAAAljoeiG1ba8MI76OcHBFbDNvfLqlyHV5JPVFiHuyq911AAAAAAD/////g40EJ9DsZQpoqka7CwmK6kQiwHGyyng1Kgd5WdB86h0BAAAAAP////8CcKrwCAAAAAAWABTYXCtx0AYLCcmIauuBXlCZHdoSTQDh9QUAAAAAFgAUAK6pouXw+HaliN9VRuh0LR2HAI8AAAAAAAEAuwIAAAABqtc5MQGL0l+ErkALaISL4J23BurCrBgpi6vucatlb4sAAAAASEcwRAIgWPb8fGoz4bMVSNSByCbAFb0wE1qtQs1neQ2rZtKtJDsCIEoc7SYExnNbY5PltBaR3XiwDwxZQvufdRhW+qk4FX26Af7///8CgPD6AgAAAAAXqRQPuUY0IWlrgsgzryQceMF9295JNIfQ8gonAQAAABepFCnKdPigj4GZlCgYXJe12FLkBj9hh2UAAAABAwQBAAAAAQRHUiEClYO/Oa4KYJdHrRma3dY0+mEIVZ1sXNObTCGD8auW4H8hAtq2H/SaFNtqfQKwzR+7ePxLGDErW05U2uTbovv+9TbXUq4iBgKVg785rgpgl0etGZrd1jT6YQhVnWxc05tMIYPxq5bgfxDZDGpPAAAAgAAAAIAAAACAIgYC2rYf9JoU22p9ArDNH7t4/EsYMStbTlTa5Nui+/71NtcQ2QxqTwAAAIAAAACAAQAAgAABASAAwusLAAAAABepFLf1+vQOPUClpFmx2zU18rcvqSHohwEDBAEAAAABBCIAIIwjUxc3Q7WV37Sge3K6jkLjeX2nTof+fZ10l+OyAokDAQVHUiEDCJ3BDHrG21T5EymvYXMz2ziM6tDCMfcjN50bmQMLAtwhAjrdkE89bc9Z3bkGsN7iNSm3/7ntUOXoYVGSaGAiHw5zUq4iBgI63ZBPPW3PWd25BrDe4jUpt/+57VDl6GFRkmhgIh8OcxDZDGpPAAAAgAAAAIADAACAIgYDCJ3BDHrG21T5EymvYXMz2ziM6tDCMfcjN50bmQMLAtwQ2QxqTwAAAIAAAACAAgAAgAAiAgOppMN/WZbTqiXbrGtXCvBlA5RJKUJGCzVHU+2e7KWHcRDZDGpPAAAAgAAAAIAEAACAACICAn9jmXV9Lv9VoTatAsaEsYOLZVbl8bazQoKpS2tQBRCWENkMak8AAACAAAAAgAUAAIAA",
}

var CUTestAmountData = map[string]int64{
	"amount1": 149990000,
	"amount2": 100000000,
	"amount3": 200000000,
}

var CUTestIndexData = map[string]uint32{
	"index1": 0,
	"index2": 1,
}

var CUMasterKeyFingerPrint = "d90c6a4f"

var CUTestPathData = map[string][]uint32{
	"dpath1": {0 + 0x80000000, 0 + 0x80000000, 0 + 0x80000000},
	"dpath2": {0 + 0x80000000, 0 + 0x80000000, 1 + 0x80000000},
	"dpath3": {0 + 0x80000000, 0 + 0x80000000, 2 + 0x80000000},
	"dpath4": {0 + 0x80000000, 0 + 0x80000000, 3 + 0x80000000},
	"dpath5": {0 + 0x80000000, 0 + 0x80000000, 4 + 0x80000000},
	"dpath6": {0 + 0x80000000, 0 + 0x80000000, 5 + 0x80000000},
}

var CUTestPubkeyData = map[string]string{
	"pub1": "029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f",
	"pub2": "02dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d7",
	"pub3": "03089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc",
	"pub4": "023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e73",
	"pub5": "03a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca58771",
	"pub6": "027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b50051096",
}

// ===============================================================================

func TestPsbtCreator(t *testing.T) {
	spkOut1, err := hex.DecodeString(CUTestHexData["scriptPubkey1"])
	if err != nil {
		t.Fatalf("Error: %v", err)
	}
	spkOut2, err := hex.DecodeString(CUTestHexData["scriptPubkey2"])
	if err != nil {
		t.Fatalf("Error: %v", err)
	}
	out1 := wire.NewTxOut(CUTestAmountData["amount1"], spkOut1)
	out2 := wire.NewTxOut(CUTestAmountData["amount2"], spkOut2)
	outputs := []*wire.TxOut{out1, out2}
	hash1, err := chainhash.NewHashFromStr(CUTestHexData["txid1"])
	if err != nil {
		t.Fatalf("Error: %v", err)
	}
	prevOut1 := wire.NewOutPoint(hash1, uint32(0))
	hash2, err := chainhash.NewHashFromStr(CUTestHexData["txid2"])
	if err != nil {
		t.Fatalf("Error: %v", err)
	}
	prevOut2 := wire.NewOutPoint(hash2, uint32(1))
	inputs := []*wire.OutPoint{prevOut1, prevOut2}

	// Check creation fails with invalid sequences:
	nSequences := []uint32{wire.MaxTxInSequenceNum}
	_, err = New(inputs, outputs, int32(3), uint32(0), nSequences)
	if err == nil {
		t.Fatalf("Did not error when creating transaction with " +
			"invalid nSequences")
	}
	nSequences = append(nSequences, wire.MaxTxInSequenceNum)

	// Check creation fails with invalid version
	_, err = New(inputs, outputs, int32(0), uint32(0), nSequences)
	if err == nil {
		t.Fatalf("Did not error when creating transaction with " +
			"invalid version (3)")
	}

	// Use valid data to create:
	cPsbt, err := New(inputs, outputs, int32(2), uint32(0), nSequences)
	var b bytes.Buffer
	err = cPsbt.Serialize(&b)
	if err != nil {
		t.Fatalf("Unable to serialize created Psbt: %v", err)
	}
	if CUTestHexData["COPsbtHex"] != hex.EncodeToString(b.Bytes()) {
		t.Fatalf("Failed to create expected psbt, instead got: %v",
			hex.EncodeToString(b.Bytes()))
	}

	// Now simulate passing the created PSBT to an Updater
	updater, err := NewUpdater(cPsbt)
	if err != nil {
		t.Fatalf("Unable to create Updater object")
	}
	tx := wire.NewMsgTx(2)
	nonWitnessUtxoHex, err := hex.DecodeString(
		CUTestHexData["NonWitnessUtxo"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	err = tx.Deserialize(bytes.NewReader(nonWitnessUtxoHex))
	if err != nil {
		t.Fatalf("Error deserializing transaction: %v", err)
	}
	witnessUtxoHex, err := hex.DecodeString(
		CUTestHexData["WitnessUtxo"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	txout := wire.TxOut{Value: CUTestAmountData["amount3"],
		PkScript: witnessUtxoHex[9:]}
	err = updater.AddInNonWitnessUtxo(tx, 0)
	if err != nil {
		t.Fatalf("Unable to add NonWitness Utxo to inputs: %v", err)
	}
	err = updater.AddInWitnessUtxo(&txout, 1)
	if err != nil {
		t.Fatalf("Unable to add Witness Utxo to inputs: %v", err)
	}

	b.Reset()

	err = updater.Upsbt.Serialize(&b)
	if err != nil {
		t.Fatalf("Unable to serialize updated Psbt: %v", err)
	}
	if CUTestHexData["UOPsbtHex"] != hex.EncodeToString(b.Bytes()) {
		t.Fatal("Failed to create valid updated PSBT after utxos")
	}
	input1RedeemScript, err := hex.DecodeString(CUTestHexData["Input1RedeemScript"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	err = updater.AddInRedeemScript(input1RedeemScript, 0)
	if err != nil {
		t.Fatalf("Unable to add redeem script: %v", err)
	}
	input2RedeemScript, err := hex.DecodeString(CUTestHexData["Input2RedeemScript"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	err = updater.AddInRedeemScript(input2RedeemScript, 1)
	if err != nil {
		t.Fatalf("Unable to add redeem script: %v", err)
	}
	input2WitnessScript, err := hex.DecodeString(CUTestHexData["Input2WitnessScript"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	err = updater.AddInWitnessScript(input2WitnessScript, 1)
	if err != nil {
		t.Fatalf("Unable to add witness script: %v", err)
	}

	b.Reset()
	err = updater.Upsbt.Serialize(&b)
	if err != nil {
		t.Fatalf("Unable to serialize updated Psbt: %v", err)
	}
	if CUTestHexData["UOPsbtHex2"] != hex.EncodeToString(b.Bytes()) {
		t.Fatal("Failed to create valid updated PSBT after redeem scripts")
	}
	masterKey, err := hex.DecodeString(CUMasterKeyFingerPrint)
	masterKeyInt := binary.LittleEndian.Uint32(masterKey)
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	input1Path1 := CUTestPathData["dpath1"]
	input1Path2 := CUTestPathData["dpath2"]
	input1Key1, err := hex.DecodeString(CUTestPubkeyData["pub1"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	input1Key2, err := hex.DecodeString(CUTestPubkeyData["pub2"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	err = updater.AddInBip32Derivation(masterKeyInt, input1Path1, input1Key1, 0)
	if err != nil {
		t.Fatal("Failed to add first key derivation for input 1")
	}
	err = updater.AddInBip32Derivation(masterKeyInt, input1Path2, input1Key2, 0)
	if err != nil {
		t.Fatal("Failed to add second key derivation for input 1")
	}
	input2Path1 := CUTestPathData["dpath3"]
	input2Path2 := CUTestPathData["dpath4"]
	input2Key1, err := hex.DecodeString(CUTestPubkeyData["pub3"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	input2Key2, err := hex.DecodeString(CUTestPubkeyData["pub4"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}

	// check invalid pubkeys are not accepted
	borkedInput2Key1 := append([]byte{0xff}, input2Key1...)
	err = updater.AddInBip32Derivation(masterKeyInt, input2Path1,
		borkedInput2Key1, 1)
	if err == nil {
		t.Fatalf("Expected invalid pubkey, got: %v", err)
	}

	err = updater.AddInBip32Derivation(masterKeyInt, input2Path1, input2Key1, 1)
	if err != nil {
		t.Fatal("Failed to add first key derivation for input 2")
	}
	err = updater.AddInBip32Derivation(masterKeyInt, input2Path2, input2Key2, 1)
	if err != nil {
		t.Fatal("Failed to add second key derivation for input 2")
	}
	output1Key1, err := hex.DecodeString(CUTestPubkeyData["pub5"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	output1Path := CUTestPathData["dpath5"]

	// check invalid pubkeys are not accepted
	borkedOutput1Key1 := append([]byte{0xab}, output1Key1[:13]...)
	err = updater.AddOutBip32Derivation(masterKeyInt, output1Path,
		borkedOutput1Key1, 0)
	if err == nil {
		t.Fatalf("Expected invalid pubkey, got: %v", err)
	}

	err = updater.AddOutBip32Derivation(masterKeyInt, output1Path, output1Key1, 0)
	if err != nil {
		t.Fatal("Failed to add key to first output")
	}
	output2Key1, err := hex.DecodeString(CUTestPubkeyData["pub6"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	output2Path := CUTestPathData["dpath6"]
	err = updater.AddOutBip32Derivation(masterKeyInt, output2Path, output2Key1, 1)
	if err != nil {
		t.Fatal("Failed to add key to second output")
	}

	b.Reset()
	err = updater.Upsbt.Serialize(&b)
	if err != nil {
		t.Fatalf("Unable to serialize updated Psbt: %v", err)
	}
	if CUTestHexData["UOPsbtHex3"] != hex.EncodeToString(b.Bytes()) {
		t.Fatal("Failed to create valid updated PSBT after BIP32 derivations")
	}
	err = updater.AddInSighashType(txscript.SigHashType(1), 0)
	if err != nil {
		t.Fatal("Failed to add sighash type to first input")
	}
	err = updater.AddInSighashType(txscript.SigHashType(1), 1)
	if err != nil {
		t.Fatal("Failed to add sighash type to second input")
	}

	b.Reset()
	err = updater.Upsbt.Serialize(&b)
	if err != nil {
		t.Fatalf("Unable to serialize updated Psbt: %v", err)
	}
	if CUTestHexData["UOPsbtHex4"] != hex.EncodeToString(b.Bytes()) {
		t.Fatal("Failed to create valid updated PSBT after sighash types")
	}
	b644, err := updater.Upsbt.B64Encode()
	if err != nil {
		t.Fatalf("Unable to B64Encode updated Psbt: %v", err)
	}
	if b644 != CUTestB64Data["UOPsbtB644"] {
		t.Fatalf("Failed to base64 encode updated PSBT after sighash "+
			"types: %v", b644)
	}
}

// Signing test data taken from
// https://github.com/achow101/bitcoin/blob/020628e3a4e88e36647eaf92bac4b3552796ac6a/test/functional/data/rpc_psbt.json
var signerPsbtData = map[string]string{
	"signer1Privkey1": "cP53pDbR5WtAD8dYAW9hhTjuvvTVaEiQBdrz9XPrgLBeRFiyCbQr",
	"signer1Privkey2": "cR6SXDoyfQrcp4piaiHE97Rsgta9mNhGTen9XeonVgwsh4iSgw6d",
	"signer1PsbtB64":  "cHNidP8BAJoCAAAAAljoeiG1ba8MI76OcHBFbDNvfLqlyHV5JPVFiHuyq911AAAAAAD/////g40EJ9DsZQpoqka7CwmK6kQiwHGyyng1Kgd5WdB86h0BAAAAAP////8CcKrwCAAAAAAWABTYXCtx0AYLCcmIauuBXlCZHdoSTQDh9QUAAAAAFgAUAK6pouXw+HaliN9VRuh0LR2HAI8AAAAAAAEAuwIAAAABqtc5MQGL0l+ErkALaISL4J23BurCrBgpi6vucatlb4sAAAAASEcwRAIgWPb8fGoz4bMVSNSByCbAFb0wE1qtQs1neQ2rZtKtJDsCIEoc7SYExnNbY5PltBaR3XiwDwxZQvufdRhW+qk4FX26Af7///8CgPD6AgAAAAAXqRQPuUY0IWlrgsgzryQceMF9295JNIfQ8gonAQAAABepFCnKdPigj4GZlCgYXJe12FLkBj9hh2UAAAABBEdSIQKVg785rgpgl0etGZrd1jT6YQhVnWxc05tMIYPxq5bgfyEC2rYf9JoU22p9ArDNH7t4/EsYMStbTlTa5Nui+/71NtdSriIGApWDvzmuCmCXR60Zmt3WNPphCFWdbFzTm0whg/GrluB/ENkMak8AAACAAAAAgAAAAIAiBgLath/0mhTban0CsM0fu3j8SxgxK1tOVNrk26L7/vU21xDZDGpPAAAAgAAAAIABAACAAQMEAQAAAAABASAAwusLAAAAABepFLf1+vQOPUClpFmx2zU18rcvqSHohwEEIgAgjCNTFzdDtZXftKB7crqOQuN5fadOh/59nXSX47ICiQMBBUdSIQMIncEMesbbVPkTKa9hczPbOIzq0MIx9yM3nRuZAwsC3CECOt2QTz1tz1nduQaw3uI1Kbf/ue1Q5ehhUZJoYCIfDnNSriIGAjrdkE89bc9Z3bkGsN7iNSm3/7ntUOXoYVGSaGAiHw5zENkMak8AAACAAAAAgAMAAIAiBgMIncEMesbbVPkTKa9hczPbOIzq0MIx9yM3nRuZAwsC3BDZDGpPAAAAgAAAAIACAACAAQMEAQAAAAAiAgOppMN/WZbTqiXbrGtXCvBlA5RJKUJGCzVHU+2e7KWHcRDZDGpPAAAAgAAAAIAEAACAACICAn9jmXV9Lv9VoTatAsaEsYOLZVbl8bazQoKpS2tQBRCWENkMak8AAACAAAAAgAUAAIAA",
	"signer1Result":   "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",
	"signer2Privkey1": "cT7J9YpCwY3AVRFSjN6ukeEeWY6mhpbJPxRaDaP5QTdygQRxP9Au",
	"signer2Privkey2": "cNBc3SWUip9PPm1GjRoLEJT6T41iNzCYtD7qro84FMnM5zEqeJsE",
	"signer2Psbt":     "70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f6187650000000104475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae2206029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f10d90c6a4f000000800000008000000080220602dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d710d90c6a4f000000800000008001000080010304010000000001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e88701042200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903010547522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae2206023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7310d90c6a4f000000800000008003000080220603089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc10d90c6a4f0000008000000080020000800103040100000000220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000",
	"signer2Result":   "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",
}

func TestPsbtSigner(t *testing.T) {
	psbt1, err := NewFromRawBytes(
		bytes.NewReader([]byte(signerPsbtData["signer1PsbtB64"])),
		true,
	)
	if err != nil {
		t.Fatalf("Failed to parse PSBT: %v", err)
	}
	psbtUpdater1 := Updater{
		Upsbt: psbt1,
	}
	sig1, err := hex.DecodeString("3044022074018ad4180097b873323c0015720b3684cc8123891048e7dbcd9b55ad679c99022073d369b740e3eb53dcefa33823c8070514ca55a7dd9544f157c167913261118c01")
	pub1, err := hex.DecodeString("029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f")
	res, err := psbtUpdater1.Sign(0, sig1, pub1, nil, nil)
	if err != nil || res != 0 {
		t.Fatalf("Error from adding signatures: %v %v", err, res)
	}
	sig2, err := hex.DecodeString("3044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01")
	pub2, err := hex.DecodeString("03089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc")
	res, err = psbtUpdater1.Sign(1, sig2, pub2, nil, nil)
	if err != nil || res != 0 {
		t.Fatalf("Error from adding signatures: %v %v", err, res)
	}
	signer1Result, err := hex.DecodeString(signerPsbtData["signer1Result"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}

	var b bytes.Buffer
	err = psbtUpdater1.Upsbt.Serialize(&b)
	if err != nil {
		t.Fatalf("Unable to serialize updated Psbt: %v", err)
	}
	if !bytes.Equal(b.Bytes(), signer1Result) {
		t.Fatalf("Failed to add signatures correctly")
	}
}

// Finalizer-extractor test

var finalizerPsbtData = map[string]string{
	"finalizeb64": "cHNidP8BAJoCAAAAAljoeiG1ba8MI76OcHBFbDNvfLqlyHV5JPVFiHuyq911AAAAAAD/////g40EJ9DsZQpoqka7CwmK6kQiwHGyyng1Kgd5WdB86h0BAAAAAP////8CcKrwCAAAAAAWABTYXCtx0AYLCcmIauuBXlCZHdoSTQDh9QUAAAAAFgAUAK6pouXw+HaliN9VRuh0LR2HAI8AAAAAAAEAuwIAAAABqtc5MQGL0l+ErkALaISL4J23BurCrBgpi6vucatlb4sAAAAASEcwRAIgWPb8fGoz4bMVSNSByCbAFb0wE1qtQs1neQ2rZtKtJDsCIEoc7SYExnNbY5PltBaR3XiwDwxZQvufdRhW+qk4FX26Af7///8CgPD6AgAAAAAXqRQPuUY0IWlrgsgzryQceMF9295JNIfQ8gonAQAAABepFCnKdPigj4GZlCgYXJe12FLkBj9hh2UAAAAiAgKVg785rgpgl0etGZrd1jT6YQhVnWxc05tMIYPxq5bgf0cwRAIgdAGK1BgAl7hzMjwAFXILNoTMgSOJEEjn282bVa1nnJkCIHPTabdA4+tT3O+jOCPIBwUUylWn3ZVE8VfBZ5EyYRGMASICAtq2H/SaFNtqfQKwzR+7ePxLGDErW05U2uTbovv+9TbXSDBFAiEA9hA4swjcHahlo0hSdG8BV3KTQgjG0kRUOTzZm98iF3cCIAVuZ1pnWm0KArhbFOXikHTYolqbV2C+ooFvZhkQoAbqAQEDBAEAAAABBEdSIQKVg785rgpgl0etGZrd1jT6YQhVnWxc05tMIYPxq5bgfyEC2rYf9JoU22p9ArDNH7t4/EsYMStbTlTa5Nui+/71NtdSriIGApWDvzmuCmCXR60Zmt3WNPphCFWdbFzTm0whg/GrluB/ENkMak8AAACAAAAAgAAAAIAiBgLath/0mhTban0CsM0fu3j8SxgxK1tOVNrk26L7/vU21xDZDGpPAAAAgAAAAIABAACAAAEBIADC6wsAAAAAF6kUt/X69A49QKWkWbHbNTXyty+pIeiHIgIDCJ3BDHrG21T5EymvYXMz2ziM6tDCMfcjN50bmQMLAtxHMEQCIGLrelVhB6fHP0WsSrWh3d9vcHX7EnWWmn84Pv/3hLyyAiAMBdu3Rw2/LwhVfdNWxzJcHtMJE+mWzThAlF2xIijaXwEiAgI63ZBPPW3PWd25BrDe4jUpt/+57VDl6GFRkmhgIh8Oc0cwRAIgZfRbpZmLWaJ//hp77QFq8fH5DVSzqo90UKpfVqJRA70CIH9yRwOtHtuWaAsoS1bU/8uI9/t1nqu+CKow8puFE4PSAQEDBAEAAAABBCIAIIwjUxc3Q7WV37Sge3K6jkLjeX2nTof+fZ10l+OyAokDAQVHUiEDCJ3BDHrG21T5EymvYXMz2ziM6tDCMfcjN50bmQMLAtwhAjrdkE89bc9Z3bkGsN7iNSm3/7ntUOXoYVGSaGAiHw5zUq4iBgI63ZBPPW3PWd25BrDe4jUpt/+57VDl6GFRkmhgIh8OcxDZDGpPAAAAgAAAAIADAACAIgYDCJ3BDHrG21T5EymvYXMz2ziM6tDCMfcjN50bmQMLAtwQ2QxqTwAAAIAAAACAAgAAgAAiAgOppMN/WZbTqiXbrGtXCvBlA5RJKUJGCzVHU+2e7KWHcRDZDGpPAAAAgAAAAIAEAACAACICAn9jmXV9Lv9VoTatAsaEsYOLZVbl8bazQoKpS2tQBRCWENkMak8AAACAAAAAgAUAAIAA",
	"finalize":    "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",
	"resultb64":   "cHNidP8BAJoCAAAAAljoeiG1ba8MI76OcHBFbDNvfLqlyHV5JPVFiHuyq911AAAAAAD/////g40EJ9DsZQpoqka7CwmK6kQiwHGyyng1Kgd5WdB86h0BAAAAAP////8CcKrwCAAAAAAWABTYXCtx0AYLCcmIauuBXlCZHdoSTQDh9QUAAAAAFgAUAK6pouXw+HaliN9VRuh0LR2HAI8AAAAAAAEAuwIAAAABqtc5MQGL0l+ErkALaISL4J23BurCrBgpi6vucatlb4sAAAAASEcwRAIgWPb8fGoz4bMVSNSByCbAFb0wE1qtQs1neQ2rZtKtJDsCIEoc7SYExnNbY5PltBaR3XiwDwxZQvufdRhW+qk4FX26Af7///8CgPD6AgAAAAAXqRQPuUY0IWlrgsgzryQceMF9295JNIfQ8gonAQAAABepFCnKdPigj4GZlCgYXJe12FLkBj9hh2UAAAABB9oARzBEAiB0AYrUGACXuHMyPAAVcgs2hMyBI4kQSOfbzZtVrWecmQIgc9Npt0Dj61Pc76M4I8gHBRTKVafdlUTxV8FnkTJhEYwBSDBFAiEA9hA4swjcHahlo0hSdG8BV3KTQgjG0kRUOTzZm98iF3cCIAVuZ1pnWm0KArhbFOXikHTYolqbV2C+ooFvZhkQoAbqAUdSIQKVg785rgpgl0etGZrd1jT6YQhVnWxc05tMIYPxq5bgfyEC2rYf9JoU22p9ArDNH7t4/EsYMStbTlTa5Nui+/71NtdSrgABASAAwusLAAAAABepFLf1+vQOPUClpFmx2zU18rcvqSHohwEHIyIAIIwjUxc3Q7WV37Sge3K6jkLjeX2nTof+fZ10l+OyAokDAQjaBABHMEQCIGLrelVhB6fHP0WsSrWh3d9vcHX7EnWWmn84Pv/3hLyyAiAMBdu3Rw2/LwhVfdNWxzJcHtMJE+mWzThAlF2xIijaXwFHMEQCIGX0W6WZi1mif/4ae+0BavHx+Q1Us6qPdFCqX1aiUQO9AiB/ckcDrR7blmgLKEtW1P/LiPf7dZ6rvgiqMPKbhROD0gFHUiEDCJ3BDHrG21T5EymvYXMz2ziM6tDCMfcjN50bmQMLAtwhAjrdkE89bc9Z3bkGsN7iNSm3/7ntUOXoYVGSaGAiHw5zUq4AIgIDqaTDf1mW06ol26xrVwrwZQOUSSlCRgs1R1Ptnuylh3EQ2QxqTwAAAIAAAACABAAAgAAiAgJ/Y5l1fS7/VaE2rQLGhLGDi2VW5fG2s0KCqUtrUAUQlhDZDGpPAAAAgAAAAIAFAACAAA==",
	"result":      "70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f6187650000000107da00473044022074018ad4180097b873323c0015720b3684cc8123891048e7dbcd9b55ad679c99022073d369b740e3eb53dcefa33823c8070514ca55a7dd9544f157c167913261118c01483045022100f61038b308dc1da865a34852746f015772934208c6d24454393cd99bdf2217770220056e675a675a6d0a02b85b14e5e29074d8a25a9b5760bea2816f661910a006ea01475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae0001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e8870107232200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b20289030108da0400473044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01473044022065f45ba5998b59a27ffe1a7bed016af1f1f90d54b3aa8f7450aa5f56a25103bd02207f724703ad1edb96680b284b56d4ffcb88f7fb759eabbe08aa30f29b851383d20147522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae00220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000",
	"network":     "0200000000010258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd7500000000da00473044022074018ad4180097b873323c0015720b3684cc8123891048e7dbcd9b55ad679c99022073d369b740e3eb53dcefa33823c8070514ca55a7dd9544f157c167913261118c01483045022100f61038b308dc1da865a34852746f015772934208c6d24454393cd99bdf2217770220056e675a675a6d0a02b85b14e5e29074d8a25a9b5760bea2816f661910a006ea01475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752aeffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d01000000232200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f000400473044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01473044022065f45ba5998b59a27ffe1a7bed016af1f1f90d54b3aa8f7450aa5f56a25103bd02207f724703ad1edb96680b284b56d4ffcb88f7fb759eabbe08aa30f29b851383d20147522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae00000000",
	"twoOfThree":  "70736274ff01005e01000000019a5fdb3c36f2168ea34a031857863c63bb776fd8a8a9149efd7341dfaf81c9970000000000ffffffff01e013a8040000000022002001c3a65ccfa5b39e31e6bafa504446200b9c88c58b4f21eb7e18412aff154e3f000000000001012bc817a80400000000220020114c9ab91ea00eb3e81a7aa4d0d8f1bc6bd8761f8f00dbccb38060dc2b9fdd5522020242ecd19afda551d58f496c17e3f51df4488089df4caafac3285ed3b9c590f6a847304402207c6ab50f421c59621323460aaf0f731a1b90ca76eddc635aed40e4d2fc86f97e02201b3f8fe931f1f94fde249e2b5b4dbfaff2f9df66dd97c6b518ffa746a4390bd1012202039f0acfe5a292aafc5331f18f6360a3cc53d645ebf0cc7f0509630b22b5d9f547473044022075329343e01033ebe5a22ea6eecf6361feca58752716bdc2260d7f449360a0810220299740ed32f694acc5f99d80c988bb270a030f63947f775382daf4669b272da0010103040100000001056952210242ecd19afda551d58f496c17e3f51df4488089df4caafac3285ed3b9c590f6a821035a654524d301dd0265c2370225a6837298b8ca2099085568cc61a8491287b63921039f0acfe5a292aafc5331f18f6360a3cc53d645ebf0cc7f0509630b22b5d9f54753ae22060242ecd19afda551d58f496c17e3f51df4488089df4caafac3285ed3b9c590f6a818d5f7375b2c000080000000800000008000000000010000002206035a654524d301dd0265c2370225a6837298b8ca2099085568cc61a8491287b63918e2314cf32c000080000000800000008000000000010000002206039f0acfe5a292aafc5331f18f6360a3cc53d645ebf0cc7f0509630b22b5d9f54718e524a1ce2c000080000000800000008000000000010000000000",
}

func TestFinalize2of3(t *testing.T) {
	b, err := hex.DecodeString(finalizerPsbtData["twoOfThree"])
	if err != nil {
		t.Fatalf("Error decoding hex: %v", err)
	}
	p, err := NewFromRawBytes(bytes.NewReader(b), false)
	if p.IsComplete() {
		t.Fatalf("Psbt is complete")
	}
	err = MaybeFinalizeAll(p)
	if err != nil {
		t.Fatalf("Error in MaybeFinalizeAll: %v", err)
	}
	if !p.IsComplete() {
		t.Fatalf("Psbt is not complete")
	}
}

func TestPsbtExtractor(t *testing.T) {
	rawToFinalize, err := base64.StdEncoding.DecodeString(
		finalizerPsbtData["finalizeb64"],
	)
	if err != nil {
		t.Fatalf("Error decoding b64: %v", err)
	}

	psbt1, err := NewFromRawBytes(
		bytes.NewReader(rawToFinalize), false,
	)
	if err != nil {
		t.Fatalf("Failed to parse PSBT: %v", err)
	}

	for i := range psbt1.Inputs {
		err = Finalize(psbt1, i)
		if err != nil {
			t.Fatalf("Error from finalizing PSBT: %v", err)
		}
	}

	finalizer1Result, err := base64.StdEncoding.DecodeString(
		finalizerPsbtData["resultb64"],
	)
	if err != nil {
		t.Fatalf("Unable to decode b64: %v", err)
	}
	finalToNetworkExpected, err := hex.DecodeString(finalizerPsbtData["network"])
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	tx, err := Extract(psbt1)
	if err != nil {
		t.Fatalf("Failed to extract: %v", err)
	}
	var resultToNetwork bytes.Buffer
	if err := tx.Serialize(&resultToNetwork); err != nil {
		t.Fatalf("unable to serialize: %v", err)
	}

	var b bytes.Buffer
	err = psbt1.Serialize(&b)
	if err != nil {
		t.Fatalf("Unable to serialize updated Psbt: %v", err)
	}
	if !bytes.Equal(b.Bytes(), finalizer1Result) {
		t.Fatalf("Failed to finalize transaction: expected %x, "+
			"got %x", finalizer1Result, b.Bytes())
	}
	if !bytes.Equal(finalToNetworkExpected, resultToNetwork.Bytes()) {
		t.Fatalf("Failed to network serialize transaction: %x", b.Bytes())
	}
}

func TestImportFromCore1(t *testing.T) {
	// This example #1 was created manually using Bitcoin Core 0.17 regtest.
	// It contains two inputs, one p2wkh and one p2pkh (non-witness).
	// We take the created PSBT as input, then add the fields for each input
	// separately, then finalize and extract, and compare with the network
	// serialized tx output from Core.
	imported := "cHNidP8BAJwCAAAAAjaoF6eKeGsPiDQxxqqhFDfHWjBtZzRqmaZmvyCVWZ5JAQAAAAD/////RhypNiFfnQSMNpo0SGsgIvDOyMQFAYEHZXD5jp4kCrUAAAAAAP////8CgCcSjAAAAAAXqRQFWy8ScSkkhlGMwfOnx15YwRzApofwX5MDAAAAABepFAt4TyLfGnL9QY6GLYHbpSQj+QclhwAAAAAAAAAAAA=="
	psbt1, err := NewFromRawBytes(bytes.NewReader([]byte(imported)), true)
	if err != nil {
		t.Fatalf("Failed to parse PSBT: %v", err)
	}

	// update with the first input's utxo (witness) and the second input's utxo
	// (non-witness)
	fundingTxInput1Hex := "02000000014f2cbac7d7691fafca30313097d79be9e78aa6670752fcb1fc15508e77586efb000000004847304402201b5568d7cab977ae0892840b779d84e36d62e42fd93b95e648aaebeacd2577d602201d2ebda2b0cddfa0c1a71d3cbcb602e7c9c860a41ed8b4d18d40c92ccbe92aed01feffffff028c636f91000000001600147447b6d7e6193499565779c8eb5184fcfdfee6ef00879303000000001600149e88f2828a074ebf64af23c2168d1816258311d72d010000"
	fundingTxInput2Hex := "020000000001012f03f70c673d83d65da0e8d0db3867b3e7d7bfbd34fd6be65892042e57576eb00000000000feffffff028027128c000000001976a91485780899b61a5506f342bd67a2f635181f50c8b788acb8032c040000000017a914e2e3d32d42d6f043cab39708a6073301df5039db8702473044022047ae396fd8aba8f67482ad16e315fe680db585c1ac6422ffb18dacd9cf5bac350220321176fd6157ef51d9eae9230b0b5bd7dd29bb6247a879189e6aaa8091f3020201210368081f7ff37dfadbed407eba17b232f959e41e6ac78741192c805ebf80d487852f010000"
	fundingTxInput1Bytes, err := hex.DecodeString(fundingTxInput1Hex)
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	txFund1 := wire.NewMsgTx(2)
	err = txFund1.Deserialize(bytes.NewReader(fundingTxInput1Bytes))
	if err != nil {
		t.Fatalf("Error deserializing transaction: %v", err)
	}
	// First input is witness, take correct output:
	txFund1Out := txFund1.TxOut[1]

	fundingTxInput2Bytes, err := hex.DecodeString(fundingTxInput2Hex)
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	txFund2 := wire.NewMsgTx(2)
	err = txFund2.Deserialize(bytes.NewReader(fundingTxInput2Bytes))
	if err != nil {
		t.Fatalf("Error deserializing transaction: %v", err)
	}
	psbtupdater1 := Updater{Upsbt: psbt1}
	psbtupdater1.AddInWitnessUtxo(txFund1Out, 0)
	err = psbtupdater1.AddInNonWitnessUtxo(txFund2, 1)
	if err != nil {
		t.Fatalf("Error inserting non-witness utxo: %v", err)
	}

	// Signing was done with Core; we manually insert the relevant input
	// entries here.
	sig1Hex := "304402200da03ac9890f5d724c42c83c2a62844c08425a274f1a5bca50dcde4126eb20dd02205278897b65cb8e390a0868c9582133c7157b2ad3e81c1c70d8fbd65f51a5658b01"
	sig1, err := hex.DecodeString(sig1Hex)
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	pub1Hex := "024d6b24f372dd4551277c8df4ecc0655101e11c22894c8e05a3468409c865a72c"
	pub1, err := hex.DecodeString(pub1Hex)
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}

	// Check that invalid pubkeys are not accepted.
	pubInvalid := append(pub1, 0x00)

	res, err := psbtupdater1.Sign(0, sig1, pubInvalid, nil, nil)
	if err == nil {
		t.Fatalf("Incorrectly accepted invalid pubkey: %v",
			pubInvalid)
	}

	res, err = psbtupdater1.Sign(0, sig1, pub1, nil, nil)
	if err != nil || res != 0 {
		t.Fatalf("Error from adding signatures: %v %v", err, res)
	}

	sig2Hex := "3044022014eb9c4858f71c9f280bc68402aa742a5187f54c56c8eb07c902eb1eb5804e5502203d66656de8386b9b044346d5605f5ae2b200328fb30476f6ac993fc0dbb0455901"
	sig2, err := hex.DecodeString(sig2Hex)
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	pub2Hex := "03b4c79acdf4e7d978bef4019c421e4c6c67044ed49d27322dc90e808d8080e862"
	pub2, err := hex.DecodeString(pub2Hex)
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}

	// ===============================================================
	// Before adding the signature, we'll make a new PSBT with
	// modifications to the input data and check it fails sanity checks.

	// First an invalid tx:
	psbtBorkedInput2, _ := NewFromRawBytes(bytes.NewReader([]byte(imported)), true)
	borkedUpdater, err := NewUpdater(psbtBorkedInput2)
	if err != nil {
		t.Fatalf("NewUpdater failed while trying to create borked "+
			"version: %v", err)
	}
	borkedUpdater.AddInWitnessUtxo(txFund1Out, 0)

	res, err = borkedUpdater.Sign(0, sig2, pub2, nil, nil)
	if err != ErrInvalidSignatureForInput {
		t.Fatalf("AddPartialSig succeeded, but should have failed "+
			"due to mismatch between pubkey and prevOut; err was: %v", err)
	}

	// Next, a valid tx serialization, but not the right one
	wrongTxBytes, err := hex.DecodeString("020000000001012d1d7b17356d0ad8232a5817d2d2fa5cd97d803c0ed03e013e97b65f4f1e5e7501000000171600147848cfb25bb163c7c63732615980a25eddbadc7bfeffffff022a8227630000000017a91472128ae6b6a1b74e499bedb5efb1cb09c9a6713287107240000000000017a91485f81cb970d854e2513ebf5c5b5d09e4509f4af3870247304402201c09aa8bcd18753ef01d8712a55eea5a0f69b6c4cc2944ac942264ff0662c91402201fc1390bf8b0023dd12ae78d7ec181124e106de57bc8f00812ae92bd024d3045012103ba077fc011aa59393bfe17cf491b3a02a9c4d39df122b2148322da0ec23508f459430800")
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	wrongTx := wire.NewMsgTx(2)
	err = wrongTx.Deserialize(bytes.NewReader(wrongTxBytes))
	if err != nil {
		t.Fatalf("Error deserializing transaction: %v", err)
	}
	psbtBorkedInput2.Inputs[1] = *NewPsbtInput(wrongTx, nil)
	res, err = borkedUpdater.Sign(1, sig2, pub2, nil, nil)
	if err != ErrInvalidSignatureForInput {
		t.Fatalf("Error should have been invalid sig for input, was: %v", err)
	}
	// ======================================================

	res, err = psbtupdater1.Sign(1, sig2, pub2, nil, nil)
	if err != nil || res != 0 {
		t.Fatalf("Failed to add signature to second input: %v %v", err, res)
	}

	// Neither input (p2pkh and p2wkh) require redeem script nor witness script,
	// so there are no more fields to add; we are ready to finalize.
	err = Finalize(psbt1, 0)
	if err != nil {
		t.Fatalf("Failed to finalize the first input, %v", err)
	}
	if psbt1.IsComplete() {
		t.Fatalf("PSBT was complete but has not been fully finalized")
	}
	err = Finalize(psbt1, 1)
	if err != nil {
		t.Fatalf("Failed to finalize second input, %v", err)
	}

	tx, err := Extract(psbt1)
	if err != nil {
		t.Fatalf("unable to extract tx: %v", err)
	}
	var networkSerializedTx bytes.Buffer
	if err := tx.Serialize(&networkSerializedTx); err != nil {
		t.Fatalf("unable to encode tx: %v", err)
	}

	expectedTx := "0200000000010236a817a78a786b0f883431c6aaa11437c75a306d67346a99a666bf2095599e490100000000ffffffff461ca936215f9d048c369a34486b2022f0cec8c4050181076570f98e9e240ab5000000006a473044022014eb9c4858f71c9f280bc68402aa742a5187f54c56c8eb07c902eb1eb5804e5502203d66656de8386b9b044346d5605f5ae2b200328fb30476f6ac993fc0dbb04559012103b4c79acdf4e7d978bef4019c421e4c6c67044ed49d27322dc90e808d8080e862ffffffff028027128c0000000017a914055b2f1271292486518cc1f3a7c75e58c11cc0a687f05f93030000000017a9140b784f22df1a72fd418e862d81dba52423f90725870247304402200da03ac9890f5d724c42c83c2a62844c08425a274f1a5bca50dcde4126eb20dd02205278897b65cb8e390a0868c9582133c7157b2ad3e81c1c70d8fbd65f51a5658b0121024d6b24f372dd4551277c8df4ecc0655101e11c22894c8e05a3468409c865a72c0000000000"
	expectedTxBytes, err := hex.DecodeString(expectedTx)
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	if !bytes.Equal(expectedTxBytes, networkSerializedTx.Bytes()) {
		t.Fatalf("The produced network transaction did not match the expected: %x \n %x \n",
			networkSerializedTx.Bytes(), expectedTxBytes)
	}

}

func TestImportFromCore2(t *testing.T) {
	// This example #2 was created manually using Bitcoin Core 0.17 regtest.
	// It contains two inputs, one p2sh-p2wkh and one fake utxo.
	// The PSBT has been created with walletcreatepsbt and then partial-signed
	// on the real input with walletprocessbst in Core.
	// We first check that the updating here, using the Core created signature,
	// redeem script and signature for the p2sh-p2wkh input, creates the
	// same partial-signed intermediate transaction as Core did after
	// walletprocesspsbt.
	// We then attach a fake
	// input of type p2sh-p2wsh, attach its witnessUtxo, redeemscript and
	// witnessscript fields, and then finalize the whole transaction. Unlike
	// the previous example, we cannot here compare with a Core produced
	// network serialized final transaction, because of the fake input.
	imported := "cHNidP8BAJsCAAAAAkxTQ+rig5QNnUS5nMc+Pccow4IcOJeQRcNNw+7p5ZA5AQAAAAD/////qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqoNAAAAAP////8CAIYOcAAAAAAWABQ1l7nn13RubTwqRQU2BnVV5WlXBWAxMbUAAAAAF6kUkiuXUjfWFgTp6nl/gf9+8zIWR6KHAAAAAAAAAAAA"
	psbt1, err := NewFromRawBytes(bytes.NewReader([]byte(imported)), true)
	if err != nil {
		t.Fatalf("Failed to parse PSBT: %v", err)
	}

	// update with the first input's utxo, taken from its funding
	// transaction
	fundingTxInput1Hex := "02000000017b260536a3c17aee49c41a9b36fdf01a418e0c04df06fbabcb0d4f590b95d175000000006a473044022074a5a13159b6c12d77881c9501aa5c18616fb76c1809fc4d55f18a2e63159a6702200d1aa72be6056a41808898d24da93c0c0192cad65b7c2cc86e00b3e0fbbd57f601210212cc429d61fde565d0c2271a3e4fdb063cb49ae2257fa71460be753ceb56d175feffffff02bc060d8f0000000017a9140b56c31b5dc5a5a22c45a7850e707ad602d94a3087008352840000000017a9149f3679d67a9a486238764f618a93b82a7d999103879a000000"
	fundingTxInput1Bytes, err := hex.DecodeString(fundingTxInput1Hex)
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	txFund1 := wire.NewMsgTx(2)
	err = txFund1.Deserialize(bytes.NewReader(fundingTxInput1Bytes))
	if err != nil {
		t.Fatalf("Error deserializing transaction: %v", err)
	}
	// First input is witness, take correct output:
	txFund1Out := txFund1.TxOut[1]

	psbtupdater1 := Updater{Upsbt: psbt1}
	psbtupdater1.AddInWitnessUtxo(txFund1Out, 0)

	// This input is p2sh-p2wkh, so it requires a redeemscript but not
	// a witness script. The redeemscript is the witness program.
	redeemScript, err := hex.DecodeString("00147aed39420a8b7ab98a83791327ccb70819d1fbe2")
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	psbtupdater1.AddInRedeemScript(redeemScript, 0)

	// Signing for the first input was done with Core; we manually insert the
	// relevant input entries here.
	sig1Hex := "30440220546d182d00e45ef659c329dce6197dc19e0abc795e2c9279873f5a887998b273022044143113fc3475d04fc8d5113e0bbcb42d80514a9f1a2247e9b2a7878e20d44901"
	sig1, err := hex.DecodeString(sig1Hex)
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	pub1Hex := "02bb3ce35af26f4c826eab3e5fc263ef56871b26686a8a995599b7ee6576613104"
	pub1, err := hex.DecodeString(pub1Hex)
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}

	res, err := psbtupdater1.Sign(0, sig1, pub1, nil, nil)
	if err != nil || res != 0 {
		t.Fatalf("Unable to add partial signature: %v %v", err, res)
	}

	// Since this input is now finalizable, we do so:
	err = Finalize(psbt1, 0)
	if err != nil {
		t.Fatalf("Failed to finalize the first input: %v", err)
	}
	if psbt1.IsComplete() {
		t.Fatalf("PSBT was complete but has not been fully finalized")
	}

	// Core also adds the OutRedeemScript field for the output it knows about.
	// Note that usually we would not of course re-create, but rather start
	// from the half-signed version; so this is needed only for a sanity check
	// that we can recreate the half-signed.
	output2RedeemScript, err := hex.DecodeString("0014e0846bd17848ab40ca1f56b655c6fa31667880cc")
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	psbtupdater1.AddOutRedeemScript(output2RedeemScript, 1)
	// The main function of the test is to compare the thus-generated
	// partially (not completely) signed transaction with that generated and
	// encoded by Core.
	expectedPsbtPartialB64 := "cHNidP8BAJsCAAAAAkxTQ+rig5QNnUS5nMc+Pccow4IcOJeQRcNNw+7p5ZA5AQAAAAD/////qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqoNAAAAAP////8CAIYOcAAAAAAWABQ1l7nn13RubTwqRQU2BnVV5WlXBWAxMbUAAAAAF6kUkiuXUjfWFgTp6nl/gf9+8zIWR6KHAAAAAAABASAAg1KEAAAAABepFJ82edZ6mkhiOHZPYYqTuCp9mZEDhwEHFxYAFHrtOUIKi3q5ioN5EyfMtwgZ0fviAQhrAkcwRAIgVG0YLQDkXvZZwync5hl9wZ4KvHleLJJ5hz9aiHmYsnMCIEQUMRP8NHXQT8jVET4LvLQtgFFKnxoiR+myp4eOINRJASECuzzjWvJvTIJuqz5fwmPvVocbJmhqiplVmbfuZXZhMQQAAAABABYAFOCEa9F4SKtAyh9WtlXG+jFmeIDMAA=="
	generatedPsbtPartialB64, err := psbt1.B64Encode()
	if err != nil {
		t.Fatalf("Unable to B64Encode Psbt: %v", err)
	}
	if expectedPsbtPartialB64 != generatedPsbtPartialB64 {
		t.Fatalf("Partial did not match expected: %v", generatedPsbtPartialB64)
	}

	// We now simulate adding the signing data for the second (fake) input,
	// and check that we can finalize and extract. This input is p2sh-p2wsh.
	// the second input is fake, we're going to make it witness type,
	// so create a TxOut struct that fits
	fakeTxOutSerialized, err := hex.DecodeString("00c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e887")
	if err != nil {
		t.Fatalf("Failed to decode hex: %v", err)
	}
	fakevalSerialized := binary.LittleEndian.Uint64(fakeTxOutSerialized[:8])
	fakeScriptPubKey := fakeTxOutSerialized[9:]
	txFund2Out := wire.NewTxOut(int64(fakevalSerialized), fakeScriptPubKey)
	psbt2, err := NewFromRawBytes(bytes.NewReader([]byte(expectedPsbtPartialB64)), true)
	if err != nil {
		t.Fatalf("Failed to load partial PSBT: %v", err)
	}
	psbtupdater2, err := NewUpdater(psbt2)
	if err != nil {
		t.Fatalf("Failed to create updater: %v", err)
	}
	psbtupdater2.AddInWitnessUtxo(txFund2Out, 1)
	// Add redeemScript, which is the witnessscript/program:
	redeemScript, err = hex.DecodeString("00208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903")
	if err != nil {
		t.Fatalf("Failed to decode hex: %v", err)
	}
	err = psbtupdater2.AddInRedeemScript(redeemScript, 1)
	if err != nil {
		t.Fatalf("Failed to add redeemscript to second input: %v", err)
	}
	// Add witnessScript, which here is multisig:
	witnessScript, err := hex.DecodeString("522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae")
	if err != nil {
		t.Fatalf("Failed to decode hex: %v", err)
	}
	// To test multisig checks, add a nonsense version of the multisig script
	witnessScriptNonsense, err := hex.DecodeString("52ffff")
	if err != nil {
		t.Fatalf("Failed to decode hex: %v", err)
	}
	err = psbtupdater2.AddInWitnessScript(witnessScript, 1)
	if err != nil {
		t.Fatalf("Failed to add witnessscript to second input: %v", err)
	}
	// Construct the two partial signatures to be added
	sig21, err := hex.DecodeString("3044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01")
	if err != nil {
		t.Fatalf("Failed to decode hex: %v", err)
	}
	pub21, err := hex.DecodeString("03089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc")
	if err != nil {
		t.Fatalf("Failed to decode hex: %v", err)
	}
	sig22, err := hex.DecodeString("3044022065f45ba5998b59a27ffe1a7bed016af1f1f90d54b3aa8f7450aa5f56a25103bd02207f724703ad1edb96680b284b56d4ffcb88f7fb759eabbe08aa30f29b851383d201")
	if err != nil {
		t.Fatalf("Failed to decode hex: %v", err)
	}
	pub22, err := hex.DecodeString("023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e73")
	if err != nil {
		t.Fatalf("Failed to decode hex: %v", err)
	}
	res, err = psbtupdater2.Sign(1, sig21, pub21, nil, nil)

	// Check that the finalization procedure fails here due to not
	// meeting the multisig policy
	success, err := MaybeFinalize(psbt2, 1)
	if success {
		t.Fatalf("Incorrectly succeeded in finalizing without sigs")
	}
	if err != ErrUnsupportedScriptType {
		t.Fatalf("Got unexpected error type: %v", err)
	}

	res, err = psbtupdater2.Sign(1, sig22, pub22, nil, nil)

	// Check that the finalization procedure also fails with a nonsense
	// script
	err = psbtupdater2.AddInWitnessScript(witnessScriptNonsense, 1)
	if err != nil {
		t.Fatalf("Failed to add witnessscript to second input: %v", err)
	}
	success, err = MaybeFinalize(psbt2, 1)
	if success {
		t.Fatalf("Incorrectly succeeded in finalizing with invalid msigscript")
	}
	if err != ErrUnsupportedScriptType {
		t.Fatalf("Got unexpected error type: %v", err)
	}

	// Restore the correct witnessScript to complete correctly
	err = psbtupdater2.AddInWitnessScript(witnessScript, 1)
	if err != nil {
		t.Fatalf("Failed to add witnessscript to second input: %v", err)
	}

	success, err = MaybeFinalize(psbt2, 1)
	if !success {
		if err != nil {
			t.Fatalf("Failed to finalize second input: %v", err)
		} else {
			t.Fatalf("Input was not finalizable")
		}
	}

	// Add a (fake) witnessOut descriptor field to one of the outputs,
	// for coverage purposes (we aren't currently using this field)
	psbtupdater2.AddOutWitnessScript([]byte{0xff, 0xff, 0xff}, 0)

	// Sanity check; we should not have lost the additional output entry
	// provided by Core initially
	uoutput1 := psbtupdater2.Upsbt.Outputs[1]
	if uoutput1.RedeemScript == nil {
		t.Fatalf("PSBT should contain outredeemscript entry, but it does not.")
	}
	// Nor should we have lost our fake witnessscript output entry
	uoutput2 := psbtupdater2.Upsbt.Outputs[0]
	if uoutput2.WitnessScript == nil {
		t.Fatalf("PSBT should contain outwitnessscript but it does not.")
	}
	var tx bytes.Buffer
	networkSerializedTx, err := Extract(psbt2)
	if err != nil {
		t.Fatalf("unable to extract tx: %v", err)
	}
	if err := networkSerializedTx.Serialize(&tx); err != nil {
		t.Fatalf("unable to encode tx: %v", err)
	}
	expectedSerializedTx, err := hex.DecodeString("020000000001024c5343eae283940d9d44b99cc73e3dc728c3821c38979045c34dc3eee9e5903901000000171600147aed39420a8b7ab98a83791327ccb70819d1fbe2ffffffffaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0d000000232200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903ffffffff0200860e70000000001600143597b9e7d7746e6d3c2a450536067555e5695705603131b50000000017a914922b975237d61604e9ea797f81ff7ef3321647a287024730440220546d182d00e45ef659c329dce6197dc19e0abc795e2c9279873f5a887998b273022044143113fc3475d04fc8d5113e0bbcb42d80514a9f1a2247e9b2a7878e20d449012102bb3ce35af26f4c826eab3e5fc263ef56871b26686a8a995599b7ee65766131040400473044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01473044022065f45ba5998b59a27ffe1a7bed016af1f1f90d54b3aa8f7450aa5f56a25103bd02207f724703ad1edb96680b284b56d4ffcb88f7fb759eabbe08aa30f29b851383d20147522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae00000000")
	if err != nil {
		t.Fatalf("Failed to decode hex: %v", err)
	}
	if !bytes.Equal(expectedSerializedTx, tx.Bytes()) {
		t.Fatalf("Failed to create correct network serialized "+
			"transaction: expected %x, got %x",
			expectedSerializedTx, tx.Bytes())
	}
}

func TestMaybeFinalizeAll(t *testing.T) {
	// The following data is from a 3rd transaction from Core,
	// using 3 inputs, all p2wkh.
	imported := "cHNidP8BAKQCAAAAAzJyXH13IqBFvvZ7y1VSgUgkMvMoPgP5CfFNqsjQexKQAQAAAAD/////fMdLydu5bsoiHN9cFSaBL0Qnq2KLSKx0RA4b938CAgQAAAAAAP/////yKNgfsDAHr/zFz8R9k8EFI26allfg9DdE8Gzj6tGlegEAAAAA/////wHw9E0OAAAAABYAFDnPCRduiEWmmSc1j30SJ8k9u7PHAAAAAAAAAAAA"
	psbt1, err := NewFromRawBytes(bytes.NewReader([]byte(imported)), true)
	if err != nil {
		t.Fatalf("Failed to parse PSBT: %v", err)
	}

	// update with the first input's utxo, taken from its funding
	// transaction
	fundingTxInput1, err := hex.DecodeString("020000000001017b260536a3c17aee49c41a9b36fdf01a418e0c04df06fbabcb0d4f590b95d1750100000017160014af82cd4409241b1de892726324bd780e3b5cd8aafeffffff02a85f9800000000001600149d21f8b306ddfd4dd035080689e88b4c3471e3cc801d2c0400000000160014d97ccd3dfb60820d7d33d862371ca5a73039bd560247304402201a1d2fdb5a7190b7fa59907769f0fc9c91fd3b34f6424acf5868a8ac21ec287102200a59b9d076ecf98c88f2196ed2be0aafff4966ead754041182fff5f92115a783012103604ffd31dc71db2e32c20f09eafe6353cd7515d3648aff829bb4879b553e30629a000000")
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	fundingTxInput2, err := hex.DecodeString("020000000001019c27b886e420fcadb077706b0933efa8bb53e3a250c3ec45cfdba5e05e233f360100000000feffffff0200b4c404000000001600140853f50c7d2d5d2af326a75efdbc83b62551e89afce31c0d000000001600142d6936c082c35607ec3bdb334a932d928150b75802473044022000d962f5e5e6425f9de21da7ac65b4fd8af8f6bfbd33c7ba022827c73866b477022034c59935c1ea10b5ba335d93f55a200c2588ec6058b8c7aedd10d5cbc4654f99012102c30e9f0cd98f6a805464d6b8a326b5679b6c3262934341855ee0436eaedfd2869a000000")
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}
	fundingTxInput3, err := hex.DecodeString("02000000012bf4331bb95df4eadb14f7a28db3fecdc5e87f08c29c2332b66338dd606699f60000000048473044022075ed43f508528da47673550a785702e9a93eca84a11faea91c4e9c66fcab3c9e022054a37610bd40b12263a5933188f062b718e007f290cecde2b6e41da3e1ebbddf01feffffff020c99a8240100000016001483bd916985726094d6d1c5b969722da580b5966a804a5d05000000001600140a2ee13a6696d75006af5e8a026ea49316087dae9a000000")
	if err != nil {
		t.Fatalf("Unable to decode hex: %v", err)
	}

	psbtupdater1 := Updater{Upsbt: psbt1}
	tx := wire.NewMsgTx(2)
	err = tx.Deserialize(bytes.NewReader(fundingTxInput1))
	if err != nil {
		t.Fatalf("Error deserializing transaction: %v", err)
	}
	txFund1Out := tx.TxOut[1]
	psbtupdater1.AddInWitnessUtxo(txFund1Out, 0)

	tx = wire.NewMsgTx(2)
	err = tx.Deserialize(bytes.NewReader(fundingTxInput2))
	if err != nil {
		t.Fatalf("Error deserializing transaction: %v", err)
	}
	txFund2Out := tx.TxOut[0]
	psbtupdater1.AddInWitnessUtxo(txFund2Out, 1)

	tx = wire.NewMsgTx(2)
	err = tx.Deserialize(bytes.NewReader(fundingTxInput3))
	if err != nil {
		t.Fatalf("Error deserializing transaction: %v", err)
	}
	txFund3Out := tx.TxOut[1]
	psbtupdater1.AddInWitnessUtxo(txFund3Out, 2)

	// To be ready for finalization, we need to have  partial signature
	// fields for each input
	sig1, _ := hex.DecodeString("30440220027605ee8015970baf02a72652967a543e1b29a6882d799738ed1baee508822702203818a2f1b9770c46a473f47ad7ae90bcc129a5d047f00fae354c80197a7cf50601")
	pub1, _ := hex.DecodeString("03235fc1f9dc8bbf6fa3df35dfeb0dd486f2d488f139579885eb684510f004f6c1")
	sig2, _ := hex.DecodeString("304402206f5aea4621696610de48736b95a89b1d3a434a4e536d9aae65e039c477cf4c7202203b27a18b0f63be7d3bbf5be1bc2306a7ec8c2da12c2820ff07b73c7f3f1d4d7301")
	pub2, _ := hex.DecodeString("022011b496f0603a268b55a781c7be0c3849f605f09cb2e917ed44288b8144a752")
	sig3, _ := hex.DecodeString("3044022036dbc6f8f85a856e7803cbbcf0a97b7a74806fc592e92d7c06826f911610b98e0220111d43c4b20f756581791334d9c5cbb1a9c07558f28404cabf01c782897ad50501")
	pub3, _ := hex.DecodeString("0381772a80c69e275e20d7f014555b13031e9cacf1c54a44a67ab2bc7eba64f227")
	res, err := psbtupdater1.Sign(0, sig1, pub1, nil, nil)
	if err != nil || res != 0 {
		t.Fatalf("Failed to add partial signature for input 0: %v %v", err, res)
	}
	res, err = psbtupdater1.Sign(1, sig2, pub2, nil, nil)
	if err != nil || res != 0 {
		t.Fatalf("Failed to add partial signature for input 1: %v %v", err, res)
	}

	// Not ready for finalize all, check it fails:
	err = MaybeFinalizeAll(psbt1)
	if err != ErrNotFinalizable {
		t.Fatalf("Expected finalization failure, got: %v", err)
	}

	res, err = psbtupdater1.Sign(2, sig3, pub3, nil, nil)

	// Since this input is now finalizable and is p2wkh only, we can do
	// all at once:
	err = MaybeFinalizeAll(psbt1)
	if err != nil {
		t.Fatalf("Failed to finalize PSBT: %v", err)
	}
	if !psbt1.IsComplete() {
		t.Fatalf("PSBT was finalized but not marked complete")
	}

}

func TestFromUnsigned(t *testing.T) {
	serTx, err := hex.DecodeString("00000000000101e165f072311e71825b47a4797221d7ae56d4b40b7707c540049aee43302448a40000000000feffffff0212f1126a0000000017a9143e836801b2b15aa193449d815c62d6c4b6227c898780778e060000000017a914ba4bdb0b07d67bc60f59c1f4fe54170565254974870000000000")
	if err != nil {
		t.Fatalf("Error: %v", err)
	}
	tx := wire.NewMsgTx(2)
	err = tx.Deserialize(bytes.NewReader(serTx))
	if err != nil {
		t.Fatalf("Error: %v", err)
	}
	psbt1, err := NewFromUnsignedTx(tx)
	if err != nil {
		t.Fatalf("Error: %v", err)
	}
	encoded, err := psbt1.B64Encode()
	if err != nil {
		t.Fatalf("Unable to B64Encode Psbt: %v", err)
	}

	// Compare with output of Core:
	fromCoreB64 := "cHNidP8BAHMAAAAAAeFl8HIxHnGCW0ekeXIh165W1LQLdwfFQASa7kMwJEikAAAAAAD+////AhLxEmoAAAAAF6kUPoNoAbKxWqGTRJ2BXGLWxLYifImHgHeOBgAAAAAXqRS6S9sLB9Z7xg9ZwfT+VBcFZSVJdIcAAAAAAAAAAA=="
	if encoded != fromCoreB64 {
		t.Fatalf("Got incorrect b64: %v", encoded)
	}
	_, err = NewFromRawBytes(bytes.NewReader([]byte(fromCoreB64)), true)
	if err != nil {
		t.Fatalf("Error: %v", err)
	}
}

func TestNonWitnessToWitness(t *testing.T) {
	// We'll start with a PSBT produced by Core for which
	// the first input is signed and we'll provided the signatures for
	// the other three inputs; they are p2sh-p2wkh, p2wkh and legacy
	// respectively.
	// In each case we'll *first* attach the NonWitnessUtxo field,
	// and then call sign; in the first two but not the third case, the
	// NonWitnessUtxo will automatically be replaced with the WitnessUtxo.
	// Finally we'll check that the fully finalized PSBT produced matches
	// the one produced by Core for the same keys.

	psbt1B64 := "cHNidP8BAM4CAAAABHtBMXY+SX95xidmWJP67CTQ02FPUpbNhIxNplAdlvk+AQAAAAD/////G2mt4bX7+sVi1jdbuBa5Q/xsJdgzFCgdHHSZq3ewK6YAAAAAAP/////NrbZb7GzfAg4kOqFWAIbXabq4cAvtVGv+eecIIv1KggEAAAAA/////73s9ifprgErlaONH1rgpNs3l6+t+mz2XGTHsTVWCem/AQAAAAD/////AfAmclMAAAAAF6kUQwsEC5nzbdY5meON2ZQ2thmeFgOHAAAAAAABASAAZc0dAAAAABepFPAv3VTMu5+4WN+/HIji6kG9RpzKhwEHFxYAFLN3PqXSyIHWKqm4ah5m9erc/3OoAQhrAkcwRAIgH7kzGO2iskfCvX0dgkDuzfqJ7tAu7KUZOeykTkJ1SYkCIBv4QRZK1hLz45D0gs+Lz93OE4s37lkPVE+SlXZtazWEASEC3jaf19MMferBn0Bn5lxXJGOqoqmfSvnHclQvB5gJ3nEAAAAAAQAWABTB+Qcq6iqdSvvc6959kd7XHrhYFgA="
	nwutxo1ser, _ := hex.DecodeString("02000000017f7baa6b7377541c4aca372d2dce8e1098ba44aa8379b7ea87644ef27e08ec240000000048473044022072e3b94c33cb5128518cd3903cc0ca19e8c234ac6d462e01ae2bb1da7768ed7d0220167d7ad89f6e1bbb3b866ae6fc2f67b5e7d51eb4f33f7bfe3f4b2673856b815001feffffff0200c2eb0b0000000017a9142dd25c78db2e2e09376eab9cb342e1b03005abe487e4ab953e0000000017a914120b8ca3fb4c7f852e30d4e3714fb64027a0b4c38721020000")
	nwutxo2ser, _ := hex.DecodeString("0200000001f51b0bb5d945dd5532448a4d3fb88134d0bd90493813515f9c2ddb1fa15b9ba60000000048473044022047d83caf88d398245c006374bfa9f27ae968f5f51d640cacd5a214ed2cba397a02204519b26035496855f574a72b73bdcfa46d53995faf64c8f0ab394b628cc5383901feffffff020ccb9f3800000000160014e13544a3c718faa6c5ad7089a6660383c12b072700a3e11100000000160014a5439b477c116b79bd4c7c5131f3e58d54f27bb721020000")
	nwutxo3ser, _ := hex.DecodeString("0200000001eb452f0fc9a8c39edb79f7174763f3cb25dc56db455926e411719a115ef16509000000004847304402205aa80cc615eb4b3f6e89696db4eadd192581a6c46f5c09807d3d98ece1d77355022025007e58c1992a1e5d877ee324bfe0a65db26d29f80941cfa277ac3efbcad2a701feffffff02bce9a9320000000017a9141590e852ac66eb8798afeb2a5ed67c568a2d6561870084d717000000001976a914a57ea05eacf94900d5fb92bccd273cfdb90af36f88ac21020000")

	nwutxo1 := wire.NewMsgTx(2)
	err := nwutxo1.Deserialize(bytes.NewReader(nwutxo1ser))
	if err != nil {
		t.Fatalf("Error deserializing transaction: %v", err)
	}
	nwutxo2 := wire.NewMsgTx(2)
	err = nwutxo2.Deserialize(bytes.NewReader(nwutxo2ser))
	if err != nil {
		t.Fatalf("Error deserializing transaction: %v", err)
	}
	nwutxo3 := wire.NewMsgTx(2)
	err = nwutxo3.Deserialize(bytes.NewReader(nwutxo3ser))
	if err != nil {
		t.Fatalf("Error deserializing transaction: %v", err)
	}

	// import the PSBT
	psbt1, err := NewFromRawBytes(bytes.NewReader([]byte(psbt1B64)), true)
	if err != nil {
		t.Fatalf("Failed to create PSBT: %v", err)
	}

	// check that we recognize the finality of the first input
	if !isFinalized(psbt1, 0) {
		t.Fatalf("First input incorrectly read as not finalized.")
	}

	// Add NonWitnessUtxo fields for each of the other three inputs
	u := Updater{Upsbt: psbt1}
	u.AddInNonWitnessUtxo(nwutxo1, 1)
	u.AddInNonWitnessUtxo(nwutxo2, 2)
	u.AddInNonWitnessUtxo(nwutxo3, 3)

	// Signatures for each of those inputs were created with Core:
	sig1, _ := hex.DecodeString("304402205676877e6162ce40a49ee5a74443cdc1e7915637c42da7b872c2ec2298fd371b02203c1d4a05b1e2a7a588d9ec9b8d4892d2cd59bebe0e777483477a0ec692ebbe6d01")
	pub1, _ := hex.DecodeString("02534f23cb88a048b649672967263bd7570312d5d31d066fa7b303970010a77b2b")
	redeemScript1, _ := hex.DecodeString("00142412be29368c0260cb841eecd9b59d7e01174aa1")

	sig2, _ := hex.DecodeString("3044022065d0a349709b8d8043cfd644cf6c196c1f601a22e1b3fdfbf8c0cc2a80fe2f1702207c87d36b666a8862e81ec5df288707f517d2f35ea1548feb82019de2c8de90f701")
	pub2, _ := hex.DecodeString("0257d88eaf1e79b72ea0a33ae89b57dae95ea68499bdc6770257e010ab899f0abb")

	sig3, _ := hex.DecodeString("30440220290abcaacbd759c4f989762a9ee3468a9231788aab8f50bf65955d8597d8dd3602204d7e394f4419dc5392c6edba6945837458dd750a030ac67a746231903a8eb7db01")
	pub3, _ := hex.DecodeString("0388025f50bb51c0469421ed13381f22f9d46a070ec2837e055c49c5876f0d0968")

	// Add the signatures and any scripts needed to the inputs
	res, err := u.Sign(1, sig1, pub1, redeemScript1, nil)
	if res != 0 || err != nil {
		t.Fatalf("Failed to sign at index %v res %v err %v", 1, res, err)
	}
	res, err = u.Sign(2, sig2, pub2, nil, nil)
	if res != 0 || err != nil {
		t.Fatalf("Failed to sign at index %v res %v err %v", 2, res, err)
	}
	res, err = u.Sign(3, sig3, pub3, nil, nil)
	if res != 0 || err != nil {
		t.Fatalf("Failed to sign at index %v res %v err %v", 3, res, err)
	}

	// Attempt to finalize the rest of the transaction
	_, err = MaybeFinalize(psbt1, 1)
	if err != nil {
		t.Fatalf("Failed to finalize input 1 %v", err)
	}
	_, err = MaybeFinalize(psbt1, 2)
	if err != nil {
		t.Fatalf("Failed to finalize input 2 %v", err)
	}
	_, err = MaybeFinalize(psbt1, 3)
	if err != nil {
		t.Fatalf("Failed to finalize input 3 %v", err)
	}

	// Finally we can check whether both the B64 encoding of the PSBT,
	// and the final network serialized signed transaction, that we generated
	// with Core using the 2 wallets, matches what this code produces:
	expectedFinalizedPsbt := "cHNidP8BAM4CAAAABHtBMXY+SX95xidmWJP67CTQ02FPUpbNhIxNplAdlvk+AQAAAAD/////G2mt4bX7+sVi1jdbuBa5Q/xsJdgzFCgdHHSZq3ewK6YAAAAAAP/////NrbZb7GzfAg4kOqFWAIbXabq4cAvtVGv+eecIIv1KggEAAAAA/////73s9ifprgErlaONH1rgpNs3l6+t+mz2XGTHsTVWCem/AQAAAAD/////AfAmclMAAAAAF6kUQwsEC5nzbdY5meON2ZQ2thmeFgOHAAAAAAABASAAZc0dAAAAABepFPAv3VTMu5+4WN+/HIji6kG9RpzKhwEHFxYAFLN3PqXSyIHWKqm4ah5m9erc/3OoAQhrAkcwRAIgH7kzGO2iskfCvX0dgkDuzfqJ7tAu7KUZOeykTkJ1SYkCIBv4QRZK1hLz45D0gs+Lz93OE4s37lkPVE+SlXZtazWEASEC3jaf19MMferBn0Bn5lxXJGOqoqmfSvnHclQvB5gJ3nEAAQEgAMLrCwAAAAAXqRQt0lx42y4uCTduq5yzQuGwMAWr5IcBBxcWABQkEr4pNowCYMuEHuzZtZ1+ARdKoQEIawJHMEQCIFZ2h35hYs5ApJ7lp0RDzcHnkVY3xC2nuHLC7CKY/TcbAiA8HUoFseKnpYjZ7JuNSJLSzVm+vg53dINHeg7Gkuu+bQEhAlNPI8uIoEi2SWcpZyY711cDEtXTHQZvp7MDlwAQp3srAAEBHwCj4REAAAAAFgAUpUObR3wRa3m9THxRMfPljVTye7cBCGsCRzBEAiBl0KNJcJuNgEPP1kTPbBlsH2AaIuGz/fv4wMwqgP4vFwIgfIfTa2ZqiGLoHsXfKIcH9RfS816hVI/rggGd4sjekPcBIQJX2I6vHnm3LqCjOuibV9rpXqaEmb3GdwJX4BCriZ8KuwABAL0CAAAAAetFLw/JqMOe23n3F0dj88sl3FbbRVkm5BFxmhFe8WUJAAAAAEhHMEQCIFqoDMYV60s/bolpbbTq3RklgabEb1wJgH09mOzh13NVAiAlAH5YwZkqHl2HfuMkv+CmXbJtKfgJQc+id6w++8rSpwH+////ArzpqTIAAAAAF6kUFZDoUqxm64eYr+sqXtZ8VootZWGHAITXFwAAAAAZdqkUpX6gXqz5SQDV+5K8zSc8/bkK82+IrCECAAABB2pHMEQCICkKvKrL11nE+Yl2Kp7jRoqSMXiKq49Qv2WVXYWX2N02AiBNfjlPRBncU5LG7bppRYN0WN11CgMKxnp0YjGQOo632wEhA4gCX1C7UcBGlCHtEzgfIvnUagcOwoN+BVxJxYdvDQloAAEAFgAUwfkHKuoqnUr73OvefZHe1x64WBYA"
	calculatedPsbt, err := u.Upsbt.B64Encode()
	if err != nil {
		t.Fatalf("Failed to base64 encode")
	}
	if expectedFinalizedPsbt != calculatedPsbt {
		t.Fatalf("Failed to generate correct PSBT")
	}

	expectedNetworkSer, _ := hex.DecodeString("020000000001047b4131763e497f79c627665893faec24d0d3614f5296cd848c4da6501d96f93e0100000017160014b3773ea5d2c881d62aa9b86a1e66f5eadcff73a8ffffffff1b69ade1b5fbfac562d6375bb816b943fc6c25d83314281d1c7499ab77b02ba600000000171600142412be29368c0260cb841eecd9b59d7e01174aa1ffffffffcdadb65bec6cdf020e243aa1560086d769bab8700bed546bfe79e70822fd4a820100000000ffffffffbdecf627e9ae012b95a38d1f5ae0a4db3797afadfa6cf65c64c7b1355609e9bf010000006a4730440220290abcaacbd759c4f989762a9ee3468a9231788aab8f50bf65955d8597d8dd3602204d7e394f4419dc5392c6edba6945837458dd750a030ac67a746231903a8eb7db01210388025f50bb51c0469421ed13381f22f9d46a070ec2837e055c49c5876f0d0968ffffffff01f02672530000000017a914430b040b99f36dd63999e38dd99436b6199e1603870247304402201fb93318eda2b247c2bd7d1d8240eecdfa89eed02eeca51939eca44e4275498902201bf841164ad612f3e390f482cf8bcfddce138b37ee590f544f9295766d6b3584012102de369fd7d30c7deac19f4067e65c572463aaa2a99f4af9c772542f079809de710247304402205676877e6162ce40a49ee5a74443cdc1e7915637c42da7b872c2ec2298fd371b02203c1d4a05b1e2a7a588d9ec9b8d4892d2cd59bebe0e777483477a0ec692ebbe6d012102534f23cb88a048b649672967263bd7570312d5d31d066fa7b303970010a77b2b02473044022065d0a349709b8d8043cfd644cf6c196c1f601a22e1b3fdfbf8c0cc2a80fe2f1702207c87d36b666a8862e81ec5df288707f517d2f35ea1548feb82019de2c8de90f701210257d88eaf1e79b72ea0a33ae89b57dae95ea68499bdc6770257e010ab899f0abb0000000000")
	tx, err := Extract(psbt1)
	if err != nil {
		t.Fatalf("Failed to extract: %v", err)
	}
	var b bytes.Buffer
	if err := tx.Serialize(&b); err != nil {
		t.Fatalf("unable to encode tx: %v", err)
	}
	if !bytes.Equal(expectedNetworkSer, b.Bytes()) {
		t.Fatalf("Expected serialized transaction was not produced: %x", b.Bytes())
	}
}

// TestEmptyInputSerialization tests the special serialization case for a wire
// transaction that has no inputs.
func TestEmptyInputSerialization(t *testing.T) {
	// Create and serialize a new, empty PSBT. The wire package will assume
	// it's a non-witness transaction, as there are no inputs.
	psbt, err := New(nil, nil, 2, 0, nil)
	if err != nil {
		t.Fatalf("failed to create empty PSBT: %v", err)
	}
	var buf bytes.Buffer
	err = psbt.Serialize(&buf)
	if err != nil {
		t.Fatalf("failed to serialize empty PSBT: %v", err)
	}

	// Try to deserialize the empty transaction again. The wire package will
	// assume it's a witness transaction because of the special case where
	// there are no inputs. This assumption is wrong and the first attempt
	// will fail. But a workaround should try again to deserialize the TX
	// with the non-witness format.
	psbt2, err := NewFromRawBytes(&buf, false)
	if err != nil {
		t.Fatalf("failed to deserialize empty PSBT: %v", err)
	}
	if len(psbt2.UnsignedTx.TxIn) > 0 || len(psbt2.UnsignedTx.TxOut) > 0 {
		t.Fatalf("deserialized transaction not empty")
	}
}

// TestWitnessForNonWitnessUtxo makes sure that a packet that only has a non-
// witness UTXO set can still be signed correctly by adding witness data. This
// is to make sure that PSBTs following the CVE-2020-14199 bugfix are not
// rejected. See https://github.com/bitcoin/bitcoin/pull/19215.
func TestWitnessForNonWitnessUtxo(t *testing.T) {
	// Our witness UTXO is index 1 of this raw transaction from the test
	// vectors.
	prevTxRaw, _ := hex.DecodeString("0200000000010158e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd7501000000171600145f275f436b09a8cc9a2eb2a2f528485c68a56323feffffff02d8231f1b0100000017a914aed962d6654f9a2b36608eb9d64d2b260db4f1118700c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e88702483045022100a22edcc6e5bc511af4cc4ae0de0fcd75c7e04d8c1c3a8aa9d820ed4b967384ec02200642963597b9b1bc22c75e9f3e117284a962188bf5e8a74c895089046a20ad770121035509a48eb623e10aace8bfd0212fdb8a8e5af3c94b0b133b95e114cab89e4f7965000000")
	prevTx := wire.NewMsgTx(2)
	err := prevTx.Deserialize(bytes.NewReader(prevTxRaw))
	if err != nil {
		t.Fatalf("failed to deserialize previous TX: %v", err)
	}

	// First create a packet that contains one input and one output.
	outPkScript, _ := hex.DecodeString(CUTestHexData["scriptPubkey1"])
	packet := &Packet{
		UnsignedTx: &wire.MsgTx{
			Version:  2,
			LockTime: 0,
			TxIn: []*wire.TxIn{{
				PreviousOutPoint: wire.OutPoint{
					Hash:  prevTx.TxHash(),
					Index: 1,
				},
			}},
			TxOut: []*wire.TxOut{{
				PkScript: outPkScript,
				Value:    1.9 * lbcutil.SatoshiPerBitcoin,
			}},
		},
		Inputs:  []PInput{{}},
		Outputs: []POutput{{}},
	}

	// Create an updater for the packet. This also performs a sanity check.
	updater, err := NewUpdater(packet)
	if err != nil {
		t.Fatalf("failed to sanity check raw packet: %v", err)
	}

	// Now add our witness UTXO to the input. But because hardware wallets
	// that are patched against CVE-2020-14199 require the full non-witness
	// UTXO to be set for all inputs, we do what Core does and add the full
	// transaction in the NonWitnessUtxo instead of just the outpoint in
	// WitnessUtxo.
	err = updater.AddInNonWitnessUtxo(prevTx, 0)
	if err != nil {
		t.Fatalf("failed to update non-witness UTXO: %v", err)
	}

	// Then add the redeem scripts and witness scripts.
	redeemScript, _ := hex.DecodeString(CUTestHexData["Input2RedeemScript"])
	err = updater.AddInRedeemScript(redeemScript, 0)
	if err != nil {
		t.Fatalf("failed to update redeem script: %v", err)
	}
	witnessScript, _ := hex.DecodeString(CUTestHexData["Input2WitnessScript"])
	err = updater.AddInWitnessScript(witnessScript, 0)
	if err != nil {
		t.Fatalf("failed to update redeem script: %v", err)
	}

	// Add the first of the two partial signatures.
	sig1, _ := hex.DecodeString("3044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01")
	pub1, _ := hex.DecodeString("03089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc")
	res, err := updater.Sign(0, sig1, pub1, nil, nil)
	if err != nil {
		t.Fatalf("failed to sign with pubkey 1: %v", err)
	}
	if res != SignSuccesful {
		t.Fatalf("signing was not successful, got result %v", res)
	}

	// Check that the finalization procedure fails here due to not
	// meeting the multisig policy
	success, err := MaybeFinalize(packet, 0)
	if success {
		t.Fatalf("Incorrectly succeeded in finalizing without sigs")
	}
	if err != ErrUnsupportedScriptType {
		t.Fatalf("Got unexpected error type: %v", err)
	}

	// Add the second partial signature.
	sig2, _ := hex.DecodeString("3044022065f45ba5998b59a27ffe1a7bed016af1f1f90d54b3aa8f7450aa5f56a25103bd02207f724703ad1edb96680b284b56d4ffcb88f7fb759eabbe08aa30f29b851383d201")
	pub2, _ := hex.DecodeString("023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e73")
	res, err = updater.Sign(0, sig2, pub2, nil, nil)
	if err != nil {
		t.Fatalf("failed to sign with pubkey 2: %v", err)
	}
	if res != SignSuccesful {
		t.Fatalf("signing was not successful, got result %v", res)
	}

	// Finally make sure we can finalize the packet and extract the raw TX.
	err = MaybeFinalizeAll(packet)
	if err != nil {
		t.Fatalf("error finalizing PSBT: %v", err)
	}
	_, err = Extract(packet)
	if err != nil {
		t.Fatalf("unable to extract funding TX: %v", err)
	}
}