feat: Waku v2 bridge

Issue #12610

vendor/github.com/btcsuite/btcutil/.gitignore

@@ -0,0 +1,28 @@
+# Temp files
+*~
+
+# Log files
+*.log
+
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe 

vendor/github.com/btcsuite/btcutil/LICENSE

@@ -0,0 +1,16 @@
+ISC License
+
+Copyright (c) 2013-2017 The btcsuite developers
+Copyright (c) 2016-2017 The Lightning Network Developers
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

vendor/github.com/btcsuite/btcutil/README.md

@@ -0,0 +1,49 @@
+btcutil
+=======
+
+[![Build Status](https://github.com/btcsuite/btcutil/workflows/Build%20and%20Test/badge.svg)](https://github.com/btcsuite/btcutil/actions)
+[![ISC License](https://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
+[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](https://godoc.org/github.com/btcsuite/btcutil)
+
+Package btcutil provides bitcoin-specific convenience functions and types.
+A comprehensive suite of tests is provided to ensure proper functionality.  See
+`test_coverage.txt` for the gocov coverage report.  Alternatively, if you are
+running a POSIX OS, you can run the `cov_report.sh` script for a real-time
+report.
+
+This package was developed for btcd, an alternative full-node implementation of
+bitcoin which is under active development by Conformal.  Although it was
+primarily written for btcd, this package has intentionally been designed so it
+can be used as a standalone package for any projects needing the functionality
+provided.
+
+## Installation and Updating
+
+```bash
+$ go get -u github.com/btcsuite/btcutil
+```
+
+## GPG Verification Key
+
+All official release tags are signed by Conformal so users can ensure the code
+has not been tampered with and is coming from the btcsuite developers.  To
+verify the signature perform the following:
+
+- Download the public key from the Conformal website at
+  https://opensource.conformal.com/GIT-GPG-KEY-conformal.txt
+
+- Import the public key into your GPG keyring:
+  ```bash
+  gpg --import GIT-GPG-KEY-conformal.txt
+  ```
+
+- Verify the release tag with the following command where `TAG_NAME` is a
+  placeholder for the specific tag:
+  ```bash
+  git tag -v TAG_NAME
+  ```
+
+## License
+
+Package btcutil is licensed under the [copyfree](http://copyfree.org) ISC
+License.

vendor/github.com/btcsuite/btcutil/address.go

@@ -0,0 +1,683 @@
+// Copyright (c) 2013-2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package btcutil
+
+import (
+	"bytes"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcutil/base58"
+	"github.com/btcsuite/btcutil/bech32"
+	"golang.org/x/crypto/ripemd160"
+)
+
+// UnsupportedWitnessVerError describes an error where a segwit address being
+// decoded has an unsupported witness version.
+type UnsupportedWitnessVerError byte
+
+func (e UnsupportedWitnessVerError) Error() string {
+	return fmt.Sprintf("unsupported witness version: %#x", e)
+}
+
+// UnsupportedWitnessProgLenError describes an error where a segwit address
+// being decoded has an unsupported witness program length.
+type UnsupportedWitnessProgLenError int
+
+func (e UnsupportedWitnessProgLenError) Error() string {
+	return fmt.Sprintf("unsupported witness program length: %d", e)
+}
+
+var (
+	// ErrChecksumMismatch describes an error where decoding failed due
+	// to a bad checksum.
+	ErrChecksumMismatch = errors.New("checksum mismatch")
+
+	// ErrUnknownAddressType describes an error where an address can not
+	// decoded as a specific address type due to the string encoding
+	// begining with an identifier byte unknown to any standard or
+	// registered (via chaincfg.Register) network.
+	ErrUnknownAddressType = errors.New("unknown address type")
+
+	// ErrAddressCollision describes an error where an address can not
+	// be uniquely determined as either a pay-to-pubkey-hash or
+	// pay-to-script-hash address since the leading identifier is used for
+	// describing both address kinds, but for different networks.  Rather
+	// than assuming or defaulting to one or the other, this error is
+	// returned and the caller must decide how to decode the address.
+	ErrAddressCollision = errors.New("address collision")
+)
+
+// encodeAddress returns a human-readable payment address given a ripemd160 hash
+// and netID which encodes the bitcoin network and address type.  It is used
+// in both pay-to-pubkey-hash (P2PKH) and pay-to-script-hash (P2SH) address
+// encoding.
+func encodeAddress(hash160 []byte, netID byte) string {
+	// Format is 1 byte for a network and address class (i.e. P2PKH vs
+	// P2SH), 20 bytes for a RIPEMD160 hash, and 4 bytes of checksum.
+	return base58.CheckEncode(hash160[:ripemd160.Size], netID)
+}
+
+// encodeSegWitAddress creates a bech32 encoded address string representation
+// from witness version and witness program.
+func encodeSegWitAddress(hrp string, witnessVersion byte, witnessProgram []byte) (string, error) {
+	// Group the address bytes into 5 bit groups, as this is what is used to
+	// encode each character in the address string.
+	converted, err := bech32.ConvertBits(witnessProgram, 8, 5, true)
+	if err != nil {
+		return "", err
+	}
+
+	// Concatenate the witness version and program, and encode the resulting
+	// bytes using bech32 encoding.
+	combined := make([]byte, len(converted)+1)
+	combined[0] = witnessVersion
+	copy(combined[1:], converted)
+	bech, err := bech32.Encode(hrp, combined)
+	if err != nil {
+		return "", err
+	}
+
+	// Check validity by decoding the created address.
+	version, program, err := decodeSegWitAddress(bech)
+	if err != nil {
+		return "", fmt.Errorf("invalid segwit address: %v", err)
+	}
+
+	if version != witnessVersion || !bytes.Equal(program, witnessProgram) {
+		return "", fmt.Errorf("invalid segwit address")
+	}
+
+	return bech, nil
+}
+
+// Address is an interface type for any type of destination a transaction
+// output may spend to.  This includes pay-to-pubkey (P2PK), pay-to-pubkey-hash
+// (P2PKH), and pay-to-script-hash (P2SH).  Address is designed to be generic
+// enough that other kinds of addresses may be added in the future without
+// changing the decoding and encoding API.
+type Address interface {
+	// String returns the string encoding of the transaction output
+	// destination.
+	//
+	// Please note that String differs subtly from EncodeAddress: String
+	// will return the value as a string without any conversion, while
+	// EncodeAddress may convert destination types (for example,
+	// converting pubkeys to P2PKH addresses) before encoding as a
+	// payment address string.
+	String() string
+
+	// EncodeAddress returns the string encoding of the payment address
+	// associated with the Address value.  See the comment on String
+	// for how this method differs from String.
+	EncodeAddress() string
+
+	// ScriptAddress returns the raw bytes of the address to be used
+	// when inserting the address into a txout's script.
+	ScriptAddress() []byte
+
+	// IsForNet returns whether or not the address is associated with the
+	// passed bitcoin network.
+	IsForNet(*chaincfg.Params) bool
+}
+
+// DecodeAddress decodes the string encoding of an address and returns
+// the Address if addr is a valid encoding for a known address type.
+//
+// The bitcoin network the address is associated with is extracted if possible.
+// When the address does not encode the network, such as in the case of a raw
+// public key, the address will be associated with the passed defaultNet.
+func DecodeAddress(addr string, defaultNet *chaincfg.Params) (Address, error) {
+	// Bech32 encoded segwit addresses start with a human-readable part
+	// (hrp) followed by '1'. For Bitcoin mainnet the hrp is "bc", and for
+	// testnet it is "tb". If the address string has a prefix that matches
+	// one of the prefixes for the known networks, we try to decode it as
+	// a segwit address.
+	oneIndex := strings.LastIndexByte(addr, '1')
+	if oneIndex > 1 {
+		prefix := addr[:oneIndex+1]
+		if chaincfg.IsBech32SegwitPrefix(prefix) {
+			witnessVer, witnessProg, err := decodeSegWitAddress(addr)
+			if err != nil {
+				return nil, err
+			}
+
+			// We currently only support P2WPKH and P2WSH, which is
+			// witness version 0.
+			if witnessVer != 0 {
+				return nil, UnsupportedWitnessVerError(witnessVer)
+			}
+
+			// The HRP is everything before the found '1'.
+			hrp := prefix[:len(prefix)-1]
+
+			switch len(witnessProg) {
+			case 20:
+				return newAddressWitnessPubKeyHash(hrp, witnessProg)
+			case 32:
+				return newAddressWitnessScriptHash(hrp, witnessProg)
+			default:
+				return nil, UnsupportedWitnessProgLenError(len(witnessProg))
+			}
+		}
+	}
+
+	// Serialized public keys are either 65 bytes (130 hex chars) if
+	// uncompressed/hybrid or 33 bytes (66 hex chars) if compressed.
+	if len(addr) == 130 || len(addr) == 66 {
+		serializedPubKey, err := hex.DecodeString(addr)
+		if err != nil {
+			return nil, err
+		}
+		return NewAddressPubKey(serializedPubKey, defaultNet)
+	}
+
+	// Switch on decoded length to determine the type.
+	decoded, netID, err := base58.CheckDecode(addr)
+	if err != nil {
+		if err == base58.ErrChecksum {
+			return nil, ErrChecksumMismatch
+		}
+		return nil, errors.New("decoded address is of unknown format")
+	}
+	switch len(decoded) {
+	case ripemd160.Size: // P2PKH or P2SH
+		isP2PKH := netID == defaultNet.PubKeyHashAddrID
+		isP2SH := netID == defaultNet.ScriptHashAddrID
+		switch hash160 := decoded; {
+		case isP2PKH && isP2SH:
+			return nil, ErrAddressCollision
+		case isP2PKH:
+			return newAddressPubKeyHash(hash160, netID)
+		case isP2SH:
+			return newAddressScriptHashFromHash(hash160, netID)
+		default:
+			return nil, ErrUnknownAddressType
+		}
+
+	default:
+		return nil, errors.New("decoded address is of unknown size")
+	}
+}
+
+// decodeSegWitAddress parses a bech32 encoded segwit address string and
+// returns the witness version and witness program byte representation.
+func decodeSegWitAddress(address string) (byte, []byte, error) {
+	// Decode the bech32 encoded address.
+	_, data, err := bech32.Decode(address)
+	if err != nil {
+		return 0, nil, err
+	}
+
+	// The first byte of the decoded address is the witness version, it must
+	// exist.
+	if len(data) < 1 {
+		return 0, nil, fmt.Errorf("no witness version")
+	}
+
+	// ...and be <= 16.
+	version := data[0]
+	if version > 16 {
+		return 0, nil, fmt.Errorf("invalid witness version: %v", version)
+	}
+
+	// The remaining characters of the address returned are grouped into
+	// words of 5 bits. In order to restore the original witness program
+	// bytes, we'll need to regroup into 8 bit words.
+	regrouped, err := bech32.ConvertBits(data[1:], 5, 8, false)
+	if err != nil {
+		return 0, nil, err
+	}
+
+	// The regrouped data must be between 2 and 40 bytes.
+	if len(regrouped) < 2 || len(regrouped) > 40 {
+		return 0, nil, fmt.Errorf("invalid data length")
+	}
+
+	// For witness version 0, address MUST be exactly 20 or 32 bytes.
+	if version == 0 && len(regrouped) != 20 && len(regrouped) != 32 {
+		return 0, nil, fmt.Errorf("invalid data length for witness "+
+			"version 0: %v", len(regrouped))
+	}
+
+	return version, regrouped, nil
+}
+
+// AddressPubKeyHash is an Address for a pay-to-pubkey-hash (P2PKH)
+// transaction.
+type AddressPubKeyHash struct {
+	hash  [ripemd160.Size]byte
+	netID byte
+}
+
+// NewAddressPubKeyHash returns a new AddressPubKeyHash.  pkHash mustbe 20
+// bytes.
+func NewAddressPubKeyHash(pkHash []byte, net *chaincfg.Params) (*AddressPubKeyHash, error) {
+	return newAddressPubKeyHash(pkHash, net.PubKeyHashAddrID)
+}
+
+// newAddressPubKeyHash is the internal API to create a pubkey hash address
+// with a known leading identifier byte for a network, rather than looking
+// it up through its parameters.  This is useful when creating a new address
+// structure from a string encoding where the identifer byte is already
+// known.
+func newAddressPubKeyHash(pkHash []byte, netID byte) (*AddressPubKeyHash, error) {
+	// Check for a valid pubkey hash length.
+	if len(pkHash) != ripemd160.Size {
+		return nil, errors.New("pkHash must be 20 bytes")
+	}
+
+	addr := &AddressPubKeyHash{netID: netID}
+	copy(addr.hash[:], pkHash)
+	return addr, nil
+}
+
+// EncodeAddress returns the string encoding of a pay-to-pubkey-hash
+// address.  Part of the Address interface.
+func (a *AddressPubKeyHash) EncodeAddress() string {
+	return encodeAddress(a.hash[:], a.netID)
+}
+
+// ScriptAddress returns the bytes to be included in a txout script to pay
+// to a pubkey hash.  Part of the Address interface.
+func (a *AddressPubKeyHash) ScriptAddress() []byte {
+	return a.hash[:]
+}
+
+// IsForNet returns whether or not the pay-to-pubkey-hash address is associated
+// with the passed bitcoin network.
+func (a *AddressPubKeyHash) IsForNet(net *chaincfg.Params) bool {
+	return a.netID == net.PubKeyHashAddrID
+}
+
+// String returns a human-readable string for the pay-to-pubkey-hash address.
+// This is equivalent to calling EncodeAddress, but is provided so the type can
+// be used as a fmt.Stringer.
+func (a *AddressPubKeyHash) String() string {
+	return a.EncodeAddress()
+}
+
+// Hash160 returns the underlying array of the pubkey hash.  This can be useful
+// when an array is more appropiate than a slice (for example, when used as map
+// keys).
+func (a *AddressPubKeyHash) Hash160() *[ripemd160.Size]byte {
+	return &a.hash
+}
+
+// AddressScriptHash is an Address for a pay-to-script-hash (P2SH)
+// transaction.
+type AddressScriptHash struct {
+	hash  [ripemd160.Size]byte
+	netID byte
+}
+
+// NewAddressScriptHash returns a new AddressScriptHash.
+func NewAddressScriptHash(serializedScript []byte, net *chaincfg.Params) (*AddressScriptHash, error) {
+	scriptHash := Hash160(serializedScript)
+	return newAddressScriptHashFromHash(scriptHash, net.ScriptHashAddrID)
+}
+
+// NewAddressScriptHashFromHash returns a new AddressScriptHash.  scriptHash
+// must be 20 bytes.
+func NewAddressScriptHashFromHash(scriptHash []byte, net *chaincfg.Params) (*AddressScriptHash, error) {
+	return newAddressScriptHashFromHash(scriptHash, net.ScriptHashAddrID)
+}
+
+// newAddressScriptHashFromHash is the internal API to create a script hash
+// address with a known leading identifier byte for a network, rather than
+// looking it up through its parameters.  This is useful when creating a new
+// address structure from a string encoding where the identifer byte is already
+// known.
+func newAddressScriptHashFromHash(scriptHash []byte, netID byte) (*AddressScriptHash, error) {
+	// Check for a valid script hash length.
+	if len(scriptHash) != ripemd160.Size {
+		return nil, errors.New("scriptHash must be 20 bytes")
+	}
+
+	addr := &AddressScriptHash{netID: netID}
+	copy(addr.hash[:], scriptHash)
+	return addr, nil
+}
+
+// EncodeAddress returns the string encoding of a pay-to-script-hash
+// address.  Part of the Address interface.
+func (a *AddressScriptHash) EncodeAddress() string {
+	return encodeAddress(a.hash[:], a.netID)
+}
+
+// ScriptAddress returns the bytes to be included in a txout script to pay
+// to a script hash.  Part of the Address interface.
+func (a *AddressScriptHash) ScriptAddress() []byte {
+	return a.hash[:]
+}
+
+// IsForNet returns whether or not the pay-to-script-hash address is associated
+// with the passed bitcoin network.
+func (a *AddressScriptHash) IsForNet(net *chaincfg.Params) bool {
+	return a.netID == net.ScriptHashAddrID
+}
+
+// String returns a human-readable string for the pay-to-script-hash address.
+// This is equivalent to calling EncodeAddress, but is provided so the type can
+// be used as a fmt.Stringer.
+func (a *AddressScriptHash) String() string {
+	return a.EncodeAddress()
+}
+
+// Hash160 returns the underlying array of the script hash.  This can be useful
+// when an array is more appropiate than a slice (for example, when used as map
+// keys).
+func (a *AddressScriptHash) Hash160() *[ripemd160.Size]byte {
+	return &a.hash
+}
+
+// PubKeyFormat describes what format to use for a pay-to-pubkey address.
+type PubKeyFormat int
+
+const (
+	// PKFUncompressed indicates the pay-to-pubkey address format is an
+	// uncompressed public key.
+	PKFUncompressed PubKeyFormat = iota
+
+	// PKFCompressed indicates the pay-to-pubkey address format is a
+	// compressed public key.
+	PKFCompressed
+
+	// PKFHybrid indicates the pay-to-pubkey address format is a hybrid
+	// public key.
+	PKFHybrid
+)
+
+// AddressPubKey is an Address for a pay-to-pubkey transaction.
+type AddressPubKey struct {
+	pubKeyFormat PubKeyFormat
+	pubKey       *btcec.PublicKey
+	pubKeyHashID byte
+}
+
+// NewAddressPubKey returns a new AddressPubKey which represents a pay-to-pubkey
+// address.  The serializedPubKey parameter must be a valid pubkey and can be
+// uncompressed, compressed, or hybrid.
+func NewAddressPubKey(serializedPubKey []byte, net *chaincfg.Params) (*AddressPubKey, error) {
+	pubKey, err := btcec.ParsePubKey(serializedPubKey, btcec.S256())
+	if err != nil {
+		return nil, err
+	}
+
+	// Set the format of the pubkey.  This probably should be returned
+	// from btcec, but do it here to avoid API churn.  We already know the
+	// pubkey is valid since it parsed above, so it's safe to simply examine
+	// the leading byte to get the format.
+	pkFormat := PKFUncompressed
+	switch serializedPubKey[0] {
+	case 0x02, 0x03:
+		pkFormat = PKFCompressed
+	case 0x06, 0x07:
+		pkFormat = PKFHybrid
+	}
+
+	return &AddressPubKey{
+		pubKeyFormat: pkFormat,
+		pubKey:       pubKey,
+		pubKeyHashID: net.PubKeyHashAddrID,
+	}, nil
+}
+
+// serialize returns the serialization of the public key according to the
+// format associated with the address.
+func (a *AddressPubKey) serialize() []byte {
+	switch a.pubKeyFormat {
+	default:
+		fallthrough
+	case PKFUncompressed:
+		return a.pubKey.SerializeUncompressed()
+
+	case PKFCompressed:
+		return a.pubKey.SerializeCompressed()
+
+	case PKFHybrid:
+		return a.pubKey.SerializeHybrid()
+	}
+}
+
+// EncodeAddress returns the string encoding of the public key as a
+// pay-to-pubkey-hash.  Note that the public key format (uncompressed,
+// compressed, etc) will change the resulting address.  This is expected since
+// pay-to-pubkey-hash is a hash of the serialized public key which obviously
+// differs with the format.  At the time of this writing, most Bitcoin addresses
+// are pay-to-pubkey-hash constructed from the uncompressed public key.
+//
+// Part of the Address interface.
+func (a *AddressPubKey) EncodeAddress() string {
+	return encodeAddress(Hash160(a.serialize()), a.pubKeyHashID)
+}
+
+// ScriptAddress returns the bytes to be included in a txout script to pay
+// to a public key.  Setting the public key format will affect the output of
+// this function accordingly.  Part of the Address interface.
+func (a *AddressPubKey) ScriptAddress() []byte {
+	return a.serialize()
+}
+
+// IsForNet returns whether or not the pay-to-pubkey address is associated
+// with the passed bitcoin network.
+func (a *AddressPubKey) IsForNet(net *chaincfg.Params) bool {
+	return a.pubKeyHashID == net.PubKeyHashAddrID
+}
+
+// String returns the hex-encoded human-readable string for the pay-to-pubkey
+// address.  This is not the same as calling EncodeAddress.
+func (a *AddressPubKey) String() string {
+	return hex.EncodeToString(a.serialize())
+}
+
+// Format returns the format (uncompressed, compressed, etc) of the
+// pay-to-pubkey address.
+func (a *AddressPubKey) Format() PubKeyFormat {
+	return a.pubKeyFormat
+}
+
+// SetFormat sets the format (uncompressed, compressed, etc) of the
+// pay-to-pubkey address.
+func (a *AddressPubKey) SetFormat(pkFormat PubKeyFormat) {
+	a.pubKeyFormat = pkFormat
+}
+
+// AddressPubKeyHash returns the pay-to-pubkey address converted to a
+// pay-to-pubkey-hash address.  Note that the public key format (uncompressed,
+// compressed, etc) will change the resulting address.  This is expected since
+// pay-to-pubkey-hash is a hash of the serialized public key which obviously
+// differs with the format.  At the time of this writing, most Bitcoin addresses
+// are pay-to-pubkey-hash constructed from the uncompressed public key.
+func (a *AddressPubKey) AddressPubKeyHash() *AddressPubKeyHash {
+	addr := &AddressPubKeyHash{netID: a.pubKeyHashID}
+	copy(addr.hash[:], Hash160(a.serialize()))
+	return addr
+}
+
+// PubKey returns the underlying public key for the address.
+func (a *AddressPubKey) PubKey() *btcec.PublicKey {
+	return a.pubKey
+}
+
+// AddressWitnessPubKeyHash is an Address for a pay-to-witness-pubkey-hash
+// (P2WPKH) output. See BIP 173 for further details regarding native segregated
+// witness address encoding:
+// https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki
+type AddressWitnessPubKeyHash struct {
+	hrp            string
+	witnessVersion byte
+	witnessProgram [20]byte
+}
+
+// NewAddressWitnessPubKeyHash returns a new AddressWitnessPubKeyHash.
+func NewAddressWitnessPubKeyHash(witnessProg []byte, net *chaincfg.Params) (*AddressWitnessPubKeyHash, error) {
+	return newAddressWitnessPubKeyHash(net.Bech32HRPSegwit, witnessProg)
+}
+
+// newAddressWitnessPubKeyHash is an internal helper function to create an
+// AddressWitnessPubKeyHash with a known human-readable part, rather than
+// looking it up through its parameters.
+func newAddressWitnessPubKeyHash(hrp string, witnessProg []byte) (*AddressWitnessPubKeyHash, error) {
+	// Check for valid program length for witness version 0, which is 20
+	// for P2WPKH.
+	if len(witnessProg) != 20 {
+		return nil, errors.New("witness program must be 20 " +
+			"bytes for p2wpkh")
+	}
+
+	addr := &AddressWitnessPubKeyHash{
+		hrp:            strings.ToLower(hrp),
+		witnessVersion: 0x00,
+	}
+
+	copy(addr.witnessProgram[:], witnessProg)
+
+	return addr, nil
+}
+
+// EncodeAddress returns the bech32 string encoding of an
+// AddressWitnessPubKeyHash.
+// Part of the Address interface.
+func (a *AddressWitnessPubKeyHash) EncodeAddress() string {
+	str, err := encodeSegWitAddress(a.hrp, a.witnessVersion,
+		a.witnessProgram[:])
+	if err != nil {
+		return ""
+	}
+	return str
+}
+
+// ScriptAddress returns the witness program for this address.
+// Part of the Address interface.
+func (a *AddressWitnessPubKeyHash) ScriptAddress() []byte {
+	return a.witnessProgram[:]
+}
+
+// IsForNet returns whether or not the AddressWitnessPubKeyHash is associated
+// with the passed bitcoin network.
+// Part of the Address interface.
+func (a *AddressWitnessPubKeyHash) IsForNet(net *chaincfg.Params) bool {
+	return a.hrp == net.Bech32HRPSegwit
+}
+
+// String returns a human-readable string for the AddressWitnessPubKeyHash.
+// This is equivalent to calling EncodeAddress, but is provided so the type
+// can be used as a fmt.Stringer.
+// Part of the Address interface.
+func (a *AddressWitnessPubKeyHash) String() string {
+	return a.EncodeAddress()
+}
+
+// Hrp returns the human-readable part of the bech32 encoded
+// AddressWitnessPubKeyHash.
+func (a *AddressWitnessPubKeyHash) Hrp() string {
+	return a.hrp
+}
+
+// WitnessVersion returns the witness version of the AddressWitnessPubKeyHash.
+func (a *AddressWitnessPubKeyHash) WitnessVersion() byte {
+	return a.witnessVersion
+}
+
+// WitnessProgram returns the witness program of the AddressWitnessPubKeyHash.
+func (a *AddressWitnessPubKeyHash) WitnessProgram() []byte {
+	return a.witnessProgram[:]
+}
+
+// Hash160 returns the witness program of the AddressWitnessPubKeyHash as a
+// byte array.
+func (a *AddressWitnessPubKeyHash) Hash160() *[20]byte {
+	return &a.witnessProgram
+}
+
+// AddressWitnessScriptHash is an Address for a pay-to-witness-script-hash
+// (P2WSH) output. See BIP 173 for further details regarding native segregated
+// witness address encoding:
+// https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki
+type AddressWitnessScriptHash struct {
+	hrp            string
+	witnessVersion byte
+	witnessProgram [32]byte
+}
+
+// NewAddressWitnessScriptHash returns a new AddressWitnessPubKeyHash.
+func NewAddressWitnessScriptHash(witnessProg []byte, net *chaincfg.Params) (*AddressWitnessScriptHash, error) {
+	return newAddressWitnessScriptHash(net.Bech32HRPSegwit, witnessProg)
+}
+
+// newAddressWitnessScriptHash is an internal helper function to create an
+// AddressWitnessScriptHash with a known human-readable part, rather than
+// looking it up through its parameters.
+func newAddressWitnessScriptHash(hrp string, witnessProg []byte) (*AddressWitnessScriptHash, error) {
+	// Check for valid program length for witness version 0, which is 32
+	// for P2WSH.
+	if len(witnessProg) != 32 {
+		return nil, errors.New("witness program must be 32 " +
+			"bytes for p2wsh")
+	}
+
+	addr := &AddressWitnessScriptHash{
+		hrp:            strings.ToLower(hrp),
+		witnessVersion: 0x00,
+	}
+
+	copy(addr.witnessProgram[:], witnessProg)
+
+	return addr, nil
+}
+
+// EncodeAddress returns the bech32 string encoding of an
+// AddressWitnessScriptHash.
+// Part of the Address interface.
+func (a *AddressWitnessScriptHash) EncodeAddress() string {
+	str, err := encodeSegWitAddress(a.hrp, a.witnessVersion,
+		a.witnessProgram[:])
+	if err != nil {
+		return ""
+	}
+	return str
+}
+
+// ScriptAddress returns the witness program for this address.
+// Part of the Address interface.
+func (a *AddressWitnessScriptHash) ScriptAddress() []byte {
+	return a.witnessProgram[:]
+}
+
+// IsForNet returns whether or not the AddressWitnessScriptHash is associated
+// with the passed bitcoin network.
+// Part of the Address interface.
+func (a *AddressWitnessScriptHash) IsForNet(net *chaincfg.Params) bool {
+	return a.hrp == net.Bech32HRPSegwit
+}
+
+// String returns a human-readable string for the AddressWitnessScriptHash.
+// This is equivalent to calling EncodeAddress, but is provided so the type
+// can be used as a fmt.Stringer.
+// Part of the Address interface.
+func (a *AddressWitnessScriptHash) String() string {
+	return a.EncodeAddress()
+}
+
+// Hrp returns the human-readable part of the bech32 encoded
+// AddressWitnessScriptHash.
+func (a *AddressWitnessScriptHash) Hrp() string {
+	return a.hrp
+}
+
+// WitnessVersion returns the witness version of the AddressWitnessScriptHash.
+func (a *AddressWitnessScriptHash) WitnessVersion() byte {
+	return a.witnessVersion
+}
+
+// WitnessProgram returns the witness program of the AddressWitnessScriptHash.
+func (a *AddressWitnessScriptHash) WitnessProgram() []byte {
+	return a.witnessProgram[:]
+}

vendor/github.com/btcsuite/btcutil/amount.go

@@ -0,0 +1,122 @@
+// Copyright (c) 2013, 2014 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package btcutil
+
+import (
+	"errors"
+	"math"
+	"strconv"
+)
+
+// AmountUnit describes a method of converting an Amount to something
+// other than the base unit of a bitcoin.  The value of the AmountUnit
+// is the exponent component of the decadic multiple to convert from
+// an amount in bitcoin to an amount counted in units.
+type AmountUnit int
+
+// These constants define various units used when describing a bitcoin
+// monetary amount.
+const (
+	AmountMegaBTC  AmountUnit = 6
+	AmountKiloBTC  AmountUnit = 3
+	AmountBTC      AmountUnit = 0
+	AmountMilliBTC AmountUnit = -3
+	AmountMicroBTC AmountUnit = -6
+	AmountSatoshi  AmountUnit = -8
+)
+
+// String returns the unit as a string.  For recognized units, the SI
+// prefix is used, or "Satoshi" for the base unit.  For all unrecognized
+// units, "1eN BTC" is returned, where N is the AmountUnit.
+func (u AmountUnit) String() string {
+	switch u {
+	case AmountMegaBTC:
+		return "MBTC"
+	case AmountKiloBTC:
+		return "kBTC"
+	case AmountBTC:
+		return "BTC"
+	case AmountMilliBTC:
+		return "mBTC"
+	case AmountMicroBTC:
+		return "μBTC"
+	case AmountSatoshi:
+		return "Satoshi"
+	default:
+		return "1e" + strconv.FormatInt(int64(u), 10) + " BTC"
+	}
+}
+
+// Amount represents the base bitcoin monetary unit (colloquially referred
+// to as a `Satoshi').  A single Amount is equal to 1e-8 of a bitcoin.
+type Amount int64
+
+// round converts a floating point number, which may or may not be representable
+// as an integer, to the Amount integer type by rounding to the nearest integer.
+// This is performed by adding or subtracting 0.5 depending on the sign, and
+// relying on integer truncation to round the value to the nearest Amount.
+func round(f float64) Amount {
+	if f < 0 {
+		return Amount(f - 0.5)
+	}
+	return Amount(f + 0.5)
+}
+
+// NewAmount creates an Amount from a floating point value representing
+// some value in bitcoin.  NewAmount errors if f is NaN or +-Infinity, but
+// does not check that the amount is within the total amount of bitcoin
+// producible as f may not refer to an amount at a single moment in time.
+//
+// NewAmount is for specifically for converting BTC to Satoshi.
+// For creating a new Amount with an int64 value which denotes a quantity of Satoshi,
+// do a simple type conversion from type int64 to Amount.
+// See GoDoc for example: http://godoc.org/github.com/btcsuite/btcutil#example-Amount
+func NewAmount(f float64) (Amount, error) {
+	// The amount is only considered invalid if it cannot be represented
+	// as an integer type.  This may happen if f is NaN or +-Infinity.
+	switch {
+	case math.IsNaN(f):
+		fallthrough
+	case math.IsInf(f, 1):
+		fallthrough
+	case math.IsInf(f, -1):
+		return 0, errors.New("invalid bitcoin amount")
+	}
+
+	return round(f * SatoshiPerBitcoin), nil
+}
+
+// ToUnit converts a monetary amount counted in bitcoin base units to a
+// floating point value representing an amount of bitcoin.
+func (a Amount) ToUnit(u AmountUnit) float64 {
+	return float64(a) / math.Pow10(int(u+8))
+}
+
+// ToBTC is the equivalent of calling ToUnit with AmountBTC.
+func (a Amount) ToBTC() float64 {
+	return a.ToUnit(AmountBTC)
+}
+
+// Format formats a monetary amount counted in bitcoin base units as a
+// string for a given unit.  The conversion will succeed for any unit,
+// however, known units will be formated with an appended label describing
+// the units with SI notation, or "Satoshi" for the base unit.
+func (a Amount) Format(u AmountUnit) string {
+	units := " " + u.String()
+	return strconv.FormatFloat(a.ToUnit(u), 'f', -int(u+8), 64) + units
+}
+
+// String is the equivalent of calling Format with AmountBTC.
+func (a Amount) String() string {
+	return a.Format(AmountBTC)
+}
+
+// MulF64 multiplies an Amount by a floating point value.  While this is not
+// an operation that must typically be done by a full node or wallet, it is
+// useful for services that build on top of bitcoin (for example, calculating
+// a fee by multiplying by a percentage).
+func (a Amount) MulF64(f float64) Amount {
+	return round(float64(a) * f)
+}

vendor/github.com/btcsuite/btcutil/appdata.go

@@ -0,0 +1,105 @@
+// Copyright (c) 2013-2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package btcutil
+
+import (
+	"os"
+	"os/user"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"unicode"
+)
+
+// appDataDir returns an operating system specific directory to be used for
+// storing application data for an application.  See AppDataDir for more
+// details.  This unexported version takes an operating system argument
+// primarily to enable the testing package to properly test the function by
+// forcing an operating system that is not the currently one.
+func appDataDir(goos, appName string, roaming bool) string {
+	if appName == "" || appName == "." {
+		return "."
+	}
+
+	// The caller really shouldn't prepend the appName with a period, but
+	// if they do, handle it gracefully by trimming it.
+	appName = strings.TrimPrefix(appName, ".")
+	appNameUpper := string(unicode.ToUpper(rune(appName[0]))) + appName[1:]
+	appNameLower := string(unicode.ToLower(rune(appName[0]))) + appName[1:]
+
+	// Get the OS specific home directory via the Go standard lib.
+	var homeDir string
+	usr, err := user.Current()
+	if err == nil {
+		homeDir = usr.HomeDir
+	}
+
+	// Fall back to standard HOME environment variable that works
+	// for most POSIX OSes if the directory from the Go standard
+	// lib failed.
+	if err != nil || homeDir == "" {
+		homeDir = os.Getenv("HOME")
+	}
+
+	switch goos {
+	// Attempt to use the LOCALAPPDATA or APPDATA environment variable on
+	// Windows.
+	case "windows":
+		// Windows XP and before didn't have a LOCALAPPDATA, so fallback
+		// to regular APPDATA when LOCALAPPDATA is not set.
+		appData := os.Getenv("LOCALAPPDATA")
+		if roaming || appData == "" {
+			appData = os.Getenv("APPDATA")
+		}
+
+		if appData != "" {
+			return filepath.Join(appData, appNameUpper)
+		}
+
+	case "darwin":
+		if homeDir != "" {
+			return filepath.Join(homeDir, "Library",
+				"Application Support", appNameUpper)
+		}
+
+	case "plan9":
+		if homeDir != "" {
+			return filepath.Join(homeDir, appNameLower)
+		}
+
+	default:
+		if homeDir != "" {
+			return filepath.Join(homeDir, "."+appNameLower)
+		}
+	}
+
+	// Fall back to the current directory if all else fails.
+	return "."
+}
+
+// AppDataDir returns an operating system specific directory to be used for
+// storing application data for an application.
+//
+// The appName parameter is the name of the application the data directory is
+// being requested for.  This function will prepend a period to the appName for
+// POSIX style operating systems since that is standard practice.  An empty
+// appName or one with a single dot is treated as requesting the current
+// directory so only "." will be returned.  Further, the first character
+// of appName will be made lowercase for POSIX style operating systems and
+// uppercase for Mac and Windows since that is standard practice.
+//
+// The roaming parameter only applies to Windows where it specifies the roaming
+// application data profile (%APPDATA%) should be used instead of the local one
+// (%LOCALAPPDATA%) that is used by default.
+//
+// Example results:
+//  dir := AppDataDir("myapp", false)
+//   POSIX (Linux/BSD): ~/.myapp
+//   Mac OS: $HOME/Library/Application Support/Myapp
+//   Windows: %LOCALAPPDATA%\Myapp
+//   Plan 9: $home/myapp
+func AppDataDir(appName string, roaming bool) string {
+	return appDataDir(runtime.GOOS, appName, roaming)
+}

vendor/github.com/btcsuite/btcutil/base58/README.md

@@ -0,0 +1,34 @@
+base58
+==========
+
+[![Build Status](http://img.shields.io/travis/btcsuite/btcutil.svg)](https://travis-ci.org/btcsuite/btcutil)
+[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
+[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](http://godoc.org/github.com/btcsuite/btcutil/base58)
+
+Package base58 provides an API for encoding and decoding to and from the
+modified base58 encoding.  It also provides an API to do Base58Check encoding,
+as described [here](https://en.bitcoin.it/wiki/Base58Check_encoding).
+
+A comprehensive suite of tests is provided to ensure proper functionality.
+
+## Installation and Updating
+
+```bash
+$ go get -u github.com/btcsuite/btcutil/base58
+```
+
+## Examples
+
+* [Decode Example](http://godoc.org/github.com/btcsuite/btcutil/base58#example-Decode)  
+  Demonstrates how to decode modified base58 encoded data.
+* [Encode Example](http://godoc.org/github.com/btcsuite/btcutil/base58#example-Encode)  
+  Demonstrates how to encode data using the modified base58 encoding scheme.
+* [CheckDecode Example](http://godoc.org/github.com/btcsuite/btcutil/base58#example-CheckDecode)  
+  Demonstrates how to decode Base58Check encoded data.
+* [CheckEncode Example](http://godoc.org/github.com/btcsuite/btcutil/base58#example-CheckEncode)  
+  Demonstrates how to encode data using the Base58Check encoding scheme.
+
+## License
+
+Package base58 is licensed under the [copyfree](http://copyfree.org) ISC
+License.

vendor/github.com/btcsuite/btcutil/base58/alphabet.go

@@ -0,0 +1,49 @@
+// Copyright (c) 2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+// AUTOGENERATED by genalphabet.go; do not edit.
+
+package base58
+
+const (
+	// alphabet is the modified base58 alphabet used by Bitcoin.
+	alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+
+	alphabetIdx0 = '1'
+)
+
+var b58 = [256]byte{
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 0, 1, 2, 3, 4, 5, 6,
+	7, 8, 255, 255, 255, 255, 255, 255,
+	255, 9, 10, 11, 12, 13, 14, 15,
+	16, 255, 17, 18, 19, 20, 21, 255,
+	22, 23, 24, 25, 26, 27, 28, 29,
+	30, 31, 32, 255, 255, 255, 255, 255,
+	255, 33, 34, 35, 36, 37, 38, 39,
+	40, 41, 42, 43, 255, 44, 45, 46,
+	47, 48, 49, 50, 51, 52, 53, 54,
+	55, 56, 57, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+	255, 255, 255, 255, 255, 255, 255, 255,
+}

vendor/github.com/btcsuite/btcutil/base58/base58.go

@@ -0,0 +1,138 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package base58
+
+import (
+	"math/big"
+)
+
+//go:generate go run genalphabet.go
+
+var bigRadix = [...]*big.Int{
+	big.NewInt(0),
+	big.NewInt(58),
+	big.NewInt(58 * 58),
+	big.NewInt(58 * 58 * 58),
+	big.NewInt(58 * 58 * 58 * 58),
+	big.NewInt(58 * 58 * 58 * 58 * 58),
+	big.NewInt(58 * 58 * 58 * 58 * 58 * 58),
+	big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58),
+	big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58 * 58),
+	big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58 * 58 * 58),
+	bigRadix10,
+}
+
+var bigRadix10 = big.NewInt(58 * 58 * 58 * 58 * 58 * 58 * 58 * 58 * 58 * 58) // 58^10
+
+// Decode decodes a modified base58 string to a byte slice.
+func Decode(b string) []byte {
+	answer := big.NewInt(0)
+	scratch := new(big.Int)
+
+	// Calculating with big.Int is slow for each iteration.
+	//    x += b58[b[i]] * j
+	//    j *= 58
+	//
+	// Instead we can try to do as much calculations on int64.
+	// We can represent a 10 digit base58 number using an int64.
+	//
+	// Hence we'll try to convert 10, base58 digits at a time.
+	// The rough idea is to calculate `t`, such that:
+	//
+	//   t := b58[b[i+9]] * 58^9 ... + b58[b[i+1]] * 58^1 + b58[b[i]] * 58^0
+	//   x *= 58^10
+	//   x += t
+	//
+	// Of course, in addition, we'll need to handle boundary condition when `b` is not multiple of 58^10.
+	// In that case we'll use the bigRadix[n] lookup for the appropriate power.
+	for t := b; len(t) > 0; {
+		n := len(t)
+		if n > 10 {
+			n = 10
+		}
+
+		total := uint64(0)
+		for _, v := range t[:n] {
+			tmp := b58[v]
+			if tmp == 255 {
+				return []byte("")
+			}
+			total = total*58 + uint64(tmp)
+		}
+
+		answer.Mul(answer, bigRadix[n])
+		scratch.SetUint64(total)
+		answer.Add(answer, scratch)
+
+		t = t[n:]
+	}
+
+	tmpval := answer.Bytes()
+
+	var numZeros int
+	for numZeros = 0; numZeros < len(b); numZeros++ {
+		if b[numZeros] != alphabetIdx0 {
+			break
+		}
+	}
+	flen := numZeros + len(tmpval)
+	val := make([]byte, flen)
+	copy(val[numZeros:], tmpval)
+
+	return val
+}
+
+// Encode encodes a byte slice to a modified base58 string.
+func Encode(b []byte) string {
+	x := new(big.Int)
+	x.SetBytes(b)
+
+	// maximum length of output is log58(2^(8*len(b))) == len(b) * 8 / log(58)
+	maxlen := int(float64(len(b))*1.365658237309761) + 1
+	answer := make([]byte, 0, maxlen)
+	mod := new(big.Int)
+	for x.Sign() > 0 {
+		// Calculating with big.Int is slow for each iteration.
+		//    x, mod = x / 58, x % 58
+		//
+		// Instead we can try to do as much calculations on int64.
+		//    x, mod = x / 58^10, x % 58^10
+		//
+		// Which will give us mod, which is 10 digit base58 number.
+		// We'll loop that 10 times to convert to the answer.
+
+		x.DivMod(x, bigRadix10, mod)
+		if x.Sign() == 0 {
+			// When x = 0, we need to ensure we don't add any extra zeros.
+			m := mod.Int64()
+			for m > 0 {
+				answer = append(answer, alphabet[m%58])
+				m /= 58
+			}
+		} else {
+			m := mod.Int64()
+			for i := 0; i < 10; i++ {
+				answer = append(answer, alphabet[m%58])
+				m /= 58
+			}
+		}
+	}
+
+	// leading zero bytes
+	for _, i := range b {
+		if i != 0 {
+			break
+		}
+		answer = append(answer, alphabetIdx0)
+	}
+
+	// reverse
+	alen := len(answer)
+	for i := 0; i < alen/2; i++ {
+		answer[i], answer[alen-1-i] = answer[alen-1-i], answer[i]
+	}
+
+	return string(answer)
+}

vendor/github.com/btcsuite/btcutil/base58/base58check.go

@@ -0,0 +1,52 @@
+// Copyright (c) 2013-2014 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package base58
+
+import (
+	"crypto/sha256"
+	"errors"
+)
+
+// ErrChecksum indicates that the checksum of a check-encoded string does not verify against
+// the checksum.
+var ErrChecksum = errors.New("checksum error")
+
+// ErrInvalidFormat indicates that the check-encoded string has an invalid format.
+var ErrInvalidFormat = errors.New("invalid format: version and/or checksum bytes missing")
+
+// checksum: first four bytes of sha256^2
+func checksum(input []byte) (cksum [4]byte) {
+	h := sha256.Sum256(input)
+	h2 := sha256.Sum256(h[:])
+	copy(cksum[:], h2[:4])
+	return
+}
+
+// CheckEncode prepends a version byte and appends a four byte checksum.
+func CheckEncode(input []byte, version byte) string {
+	b := make([]byte, 0, 1+len(input)+4)
+	b = append(b, version)
+	b = append(b, input[:]...)
+	cksum := checksum(b)
+	b = append(b, cksum[:]...)
+	return Encode(b)
+}
+
+// CheckDecode decodes a string that was encoded with CheckEncode and verifies the checksum.
+func CheckDecode(input string) (result []byte, version byte, err error) {
+	decoded := Decode(input)
+	if len(decoded) < 5 {
+		return nil, 0, ErrInvalidFormat
+	}
+	version = decoded[0]
+	var cksum [4]byte
+	copy(cksum[:], decoded[len(decoded)-4:])
+	if checksum(decoded[:len(decoded)-4]) != cksum {
+		return nil, 0, ErrChecksum
+	}
+	payload := decoded[1 : len(decoded)-4]
+	result = append(result, payload...)
+	return
+}

vendor/github.com/btcsuite/btcutil/base58/cov_report.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+# This script uses gocov to generate a test coverage report.
+# The gocov tool my be obtained with the following command:
+#   go get github.com/axw/gocov/gocov
+#
+# It will be installed to $GOPATH/bin, so ensure that location is in your $PATH.
+
+# Check for gocov.
+type gocov >/dev/null 2>&1
+if [ $? -ne 0 ]; then
+	echo >&2 "This script requires the gocov tool."
+	echo >&2 "You may obtain it with the following command:"
+	echo >&2 "go get github.com/axw/gocov/gocov"
+	exit 1
+fi
+gocov test | gocov report

vendor/github.com/btcsuite/btcutil/base58/doc.go

@@ -0,0 +1,29 @@
+// Copyright (c) 2014 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+/*
+Package base58 provides an API for working with modified base58 and Base58Check
+encodings.
+
+Modified Base58 Encoding
+
+Standard base58 encoding is similar to standard base64 encoding except, as the
+name implies, it uses a 58 character alphabet which results in an alphanumeric
+string and allows some characters which are problematic for humans to be
+excluded.  Due to this, there can be various base58 alphabets.
+
+The modified base58 alphabet used by Bitcoin, and hence this package, omits the
+0, O, I, and l characters that look the same in many fonts and are therefore
+hard to humans to distinguish.
+
+Base58Check Encoding Scheme
+
+The Base58Check encoding scheme is primarily used for Bitcoin addresses at the
+time of this writing, however it can be used to generically encode arbitrary
+byte arrays into human-readable strings along with a version byte that can be
+used to differentiate the same payload.  For Bitcoin addresses, the extra
+version is used to differentiate the network of otherwise identical public keys
+which helps prevent using an address intended for one network on another.
+*/
+package base58

vendor/github.com/btcsuite/btcutil/bech32/README.md

@@ -0,0 +1,29 @@
+bech32
+==========
+
+[![Build Status](http://img.shields.io/travis/btcsuite/btcutil.svg)](https://travis-ci.org/btcsuite/btcutil)
+[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
+[![GoDoc](https://godoc.org/github.com/btcsuite/btcutil/bech32?status.png)](http://godoc.org/github.com/btcsuite/btcutil/bech32)
+
+Package bech32 provides a Go implementation of the bech32 format specified in
+[BIP 173](https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki).
+
+Test vectors from BIP 173 are added to ensure compatibility with the BIP.
+
+## Installation and Updating
+
+```bash
+$ go get -u github.com/btcsuite/btcutil/bech32
+```
+
+## Examples
+
+* [Bech32 decode Example](http://godoc.org/github.com/btcsuite/btcutil/bech32#example-Bech32Decode)
+  Demonstrates how to decode a bech32 encoded string.
+* [Bech32 encode Example](http://godoc.org/github.com/btcsuite/btcutil/bech32#example-BechEncode)
+  Demonstrates how to encode data into a bech32 string.
+
+## License
+
+Package bech32 is licensed under the [copyfree](http://copyfree.org) ISC
+License.

vendor/github.com/btcsuite/btcutil/bech32/bech32.go

@@ -0,0 +1,378 @@
+// Copyright (c) 2017 The btcsuite developers
+// Copyright (c) 2019 The Decred developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package bech32
+
+import (
+	"strings"
+)
+
+// charset is the set of characters used in the data section of bech32 strings.
+// Note that this is ordered, such that for a given charset[i], i is the binary
+// value of the character.
+const charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+
+// gen encodes the generator polynomial for the bech32 BCH checksum.
+var gen = []int{0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3}
+
+// toBytes converts each character in the string 'chars' to the value of the
+// index of the correspoding character in 'charset'.
+func toBytes(chars string) ([]byte, error) {
+	decoded := make([]byte, 0, len(chars))
+	for i := 0; i < len(chars); i++ {
+		index := strings.IndexByte(charset, chars[i])
+		if index < 0 {
+			return nil, ErrNonCharsetChar(chars[i])
+		}
+		decoded = append(decoded, byte(index))
+	}
+	return decoded, nil
+}
+
+// bech32Polymod calculates the BCH checksum for a given hrp, values and
+// checksum data. Checksum is optional, and if nil a 0 checksum is assumed.
+//
+// Values and checksum (if provided) MUST be encoded as 5 bits per element (base
+// 32), otherwise the results are undefined.
+//
+// For more details on the polymod calculation, please refer to BIP 173.
+func bech32Polymod(hrp string, values, checksum []byte) int {
+	chk := 1
+
+	// Account for the high bits of the HRP in the checksum.
+	for i := 0; i < len(hrp); i++ {
+		b := chk >> 25
+		hiBits := int(hrp[i]) >> 5
+		chk = (chk&0x1ffffff)<<5 ^ hiBits
+		for i := 0; i < 5; i++ {
+			if (b>>uint(i))&1 == 1 {
+				chk ^= gen[i]
+			}
+		}
+	}
+
+	// Account for the separator (0) between high and low bits of the HRP.
+	// x^0 == x, so we eliminate the redundant xor used in the other rounds.
+	b := chk >> 25
+	chk = (chk & 0x1ffffff) << 5
+	for i := 0; i < 5; i++ {
+		if (b>>uint(i))&1 == 1 {
+			chk ^= gen[i]
+		}
+	}
+
+	// Account for the low bits of the HRP.
+	for i := 0; i < len(hrp); i++ {
+		b := chk >> 25
+		loBits := int(hrp[i]) & 31
+		chk = (chk&0x1ffffff)<<5 ^ loBits
+		for i := 0; i < 5; i++ {
+			if (b>>uint(i))&1 == 1 {
+				chk ^= gen[i]
+			}
+		}
+	}
+
+	// Account for the values.
+	for _, v := range values {
+		b := chk >> 25
+		chk = (chk&0x1ffffff)<<5 ^ int(v)
+		for i := 0; i < 5; i++ {
+			if (b>>uint(i))&1 == 1 {
+				chk ^= gen[i]
+			}
+		}
+	}
+
+	if checksum == nil {
+		// A nil checksum is used during encoding, so assume all bytes are zero.
+		// x^0 == x, so we eliminate the redundant xor used in the other rounds.
+		for v := 0; v < 6; v++ {
+			b := chk >> 25
+			chk = (chk & 0x1ffffff) << 5
+			for i := 0; i < 5; i++ {
+				if (b>>uint(i))&1 == 1 {
+					chk ^= gen[i]
+				}
+			}
+		}
+	} else {
+		// Checksum is provided during decoding, so use it.
+		for _, v := range checksum {
+			b := chk >> 25
+			chk = (chk&0x1ffffff)<<5 ^ int(v)
+			for i := 0; i < 5; i++ {
+				if (b>>uint(i))&1 == 1 {
+					chk ^= gen[i]
+				}
+			}
+		}
+	}
+
+	return chk
+}
+
+// writeBech32Checksum calculates the checksum data expected for a string that
+// will have the given hrp and payload data and writes it to the provided string
+// builder.
+//
+// The payload data MUST be encoded as a base 32 (5 bits per element) byte slice
+// and the hrp MUST only use the allowed character set (ascii chars between 33
+// and 126), otherwise the results are undefined.
+//
+// For more details on the checksum calculation, please refer to BIP 173.
+func writeBech32Checksum(hrp string, data []byte, bldr *strings.Builder) {
+	polymod := bech32Polymod(hrp, data, nil) ^ 1
+	for i := 0; i < 6; i++ {
+		b := byte((polymod >> uint(5*(5-i))) & 31)
+
+		// This can't fail, given we explicitly cap the previous b byte by the
+		// first 31 bits.
+		c := charset[b]
+		bldr.WriteByte(c)
+	}
+}
+
+// bech32VerifyChecksum verifies whether the bech32 string specified by the
+// provided hrp and payload data (encoded as 5 bits per element byte slice) has
+// the correct checksum suffix.
+//
+// Data MUST have more than 6 elements, otherwise this function panics.
+//
+// For more details on the checksum verification, please refer to BIP 173.
+func bech32VerifyChecksum(hrp string, data []byte) bool {
+	checksum := data[len(data)-6:]
+	values := data[:len(data)-6]
+	polymod := bech32Polymod(hrp, values, checksum)
+	return polymod == 1
+}
+
+// DecodeNoLimit decodes a bech32 encoded string, returning the human-readable
+// part and the data part excluding the checksum.  This function does NOT
+// validate against the BIP-173 maximum length allowed for bech32 strings and
+// is meant for use in custom applications (such as lightning network payment
+// requests), NOT on-chain addresses.
+//
+// Note that the returned data is 5-bit (base32) encoded and the human-readable
+// part will be lowercase.
+func DecodeNoLimit(bech string) (string, []byte, error) {
+	// The minimum allowed size of a bech32 string is 8 characters, since it
+	// needs a non-empty HRP, a separator, and a 6 character checksum.
+	if len(bech) < 8 {
+		return "", nil, ErrInvalidLength(len(bech))
+	}
+
+	// Only	ASCII characters between 33 and 126 are allowed.
+	var hasLower, hasUpper bool
+	for i := 0; i < len(bech); i++ {
+		if bech[i] < 33 || bech[i] > 126 {
+			return "", nil, ErrInvalidCharacter(bech[i])
+		}
+
+		// The characters must be either all lowercase or all uppercase. Testing
+		// directly with ascii codes is safe here, given the previous test.
+		hasLower = hasLower || (bech[i] >= 97 && bech[i] <= 122)
+		hasUpper = hasUpper || (bech[i] >= 65 && bech[i] <= 90)
+		if hasLower && hasUpper {
+			return "", nil, ErrMixedCase{}
+		}
+	}
+
+	// Bech32 standard uses only the lowercase for of strings for checksum
+	// calculation.
+	if hasUpper {
+		bech = strings.ToLower(bech)
+	}
+
+	// The string is invalid if the last '1' is non-existent, it is the
+	// first character of the string (no human-readable part) or one of the
+	// last 6 characters of the string (since checksum cannot contain '1').
+	one := strings.LastIndexByte(bech, '1')
+	if one < 1 || one+7 > len(bech) {
+		return "", nil, ErrInvalidSeparatorIndex(one)
+	}
+
+	// The human-readable part is everything before the last '1'.
+	hrp := bech[:one]
+	data := bech[one+1:]
+
+	// Each character corresponds to the byte with value of the index in
+	// 'charset'.
+	decoded, err := toBytes(data)
+	if err != nil {
+		return "", nil, err
+	}
+
+	// Verify if the checksum (stored inside decoded[:]) is valid, given the
+	// previously decoded hrp.
+	if !bech32VerifyChecksum(hrp, decoded) {
+		// Invalid checksum. Calculate what it should have been, so that the
+		// error contains this information.
+
+		// Extract the payload bytes and actual checksum in the string.
+		actual := bech[len(bech)-6:]
+		payload := decoded[:len(decoded)-6]
+
+		// Calculate the expected checksum, given the hrp and payload data.
+		var expectedBldr strings.Builder
+		expectedBldr.Grow(6)
+		writeBech32Checksum(hrp, payload, &expectedBldr)
+		expected := expectedBldr.String()
+
+		err = ErrInvalidChecksum{
+			Expected: expected,
+			Actual:   actual,
+		}
+		return "", nil, err
+	}
+
+	// We exclude the last 6 bytes, which is the checksum.
+	return hrp, decoded[:len(decoded)-6], nil
+}
+
+// Decode decodes a bech32 encoded string, returning the human-readable part and
+// the data part excluding the checksum.
+//
+// Note that the returned data is 5-bit (base32) encoded and the human-readable
+// part will be lowercase.
+func Decode(bech string) (string, []byte, error) {
+	// The maximum allowed length for a bech32 string is 90.
+	if len(bech) > 90 {
+		return "", nil, ErrInvalidLength(len(bech))
+	}
+
+	return DecodeNoLimit(bech)
+}
+
+// Encode encodes a byte slice into a bech32 string with the given
+// human-readable part (HRP).  The HRP will be converted to lowercase if needed
+// since mixed cased encodings are not permitted and lowercase is used for
+// checksum purposes.  Note that the bytes must each encode 5 bits (base32).
+func Encode(hrp string, data []byte) (string, error) {
+	// The resulting bech32 string is the concatenation of the lowercase hrp,
+	// the separator 1, data and the 6-byte checksum.
+	hrp = strings.ToLower(hrp)
+	var bldr strings.Builder
+	bldr.Grow(len(hrp) + 1 + len(data) + 6)
+	bldr.WriteString(hrp)
+	bldr.WriteString("1")
+
+	// Write the data part, using the bech32 charset.
+	for _, b := range data {
+		if int(b) >= len(charset) {
+			return "", ErrInvalidDataByte(b)
+		}
+		bldr.WriteByte(charset[b])
+	}
+
+	// Calculate and write the checksum of the data.
+	writeBech32Checksum(hrp, data, &bldr)
+
+	return bldr.String(), nil
+}
+
+// ConvertBits converts a byte slice where each byte is encoding fromBits bits,
+// to a byte slice where each byte is encoding toBits bits.
+func ConvertBits(data []byte, fromBits, toBits uint8, pad bool) ([]byte, error) {
+	if fromBits < 1 || fromBits > 8 || toBits < 1 || toBits > 8 {
+		return nil, ErrInvalidBitGroups{}
+	}
+
+	// Determine the maximum size the resulting array can have after base
+	// conversion, so that we can size it a single time. This might be off
+	// by a byte depending on whether padding is used or not and if the input
+	// data is a multiple of both fromBits and toBits, but we ignore that and
+	// just size it to the maximum possible.
+	maxSize := len(data)*int(fromBits)/int(toBits) + 1
+
+	// The final bytes, each byte encoding toBits bits.
+	regrouped := make([]byte, 0, maxSize)
+
+	// Keep track of the next byte we create and how many bits we have
+	// added to it out of the toBits goal.
+	nextByte := byte(0)
+	filledBits := uint8(0)
+
+	for _, b := range data {
+
+		// Discard unused bits.
+		b = b << (8 - fromBits)
+
+		// How many bits remaining to extract from the input data.
+		remFromBits := fromBits
+		for remFromBits > 0 {
+			// How many bits remaining to be added to the next byte.
+			remToBits := toBits - filledBits
+
+			// The number of bytes to next extract is the minimum of
+			// remFromBits and remToBits.
+			toExtract := remFromBits
+			if remToBits < toExtract {
+				toExtract = remToBits
+			}
+
+			// Add the next bits to nextByte, shifting the already
+			// added bits to the left.
+			nextByte = (nextByte << toExtract) | (b >> (8 - toExtract))
+
+			// Discard the bits we just extracted and get ready for
+			// next iteration.
+			b = b << toExtract
+			remFromBits -= toExtract
+			filledBits += toExtract
+
+			// If the nextByte is completely filled, we add it to
+			// our regrouped bytes and start on the next byte.
+			if filledBits == toBits {
+				regrouped = append(regrouped, nextByte)
+				filledBits = 0
+				nextByte = 0
+			}
+		}
+	}
+
+	// We pad any unfinished group if specified.
+	if pad && filledBits > 0 {
+		nextByte = nextByte << (toBits - filledBits)
+		regrouped = append(regrouped, nextByte)
+		filledBits = 0
+		nextByte = 0
+	}
+
+	// Any incomplete group must be <= 4 bits, and all zeroes.
+	if filledBits > 0 && (filledBits > 4 || nextByte != 0) {
+		return nil, ErrInvalidIncompleteGroup{}
+	}
+
+	return regrouped, nil
+}
+
+// EncodeFromBase256 converts a base256-encoded byte slice into a base32-encoded
+// byte slice and then encodes it into a bech32 string with the given
+// human-readable part (HRP).  The HRP will be converted to lowercase if needed
+// since mixed cased encodings are not permitted and lowercase is used for
+// checksum purposes.
+func EncodeFromBase256(hrp string, data []byte) (string, error) {
+	converted, err := ConvertBits(data, 8, 5, true)
+	if err != nil {
+		return "", err
+	}
+	return Encode(hrp, converted)
+}
+
+// DecodeToBase256 decodes a bech32-encoded string into its associated
+// human-readable part (HRP) and base32-encoded data, converts that data to a
+// base256-encoded byte slice and returns it along with the lowercase HRP.
+func DecodeToBase256(bech string) (string, []byte, error) {
+	hrp, data, err := Decode(bech)
+	if err != nil {
+		return "", nil, err
+	}
+	converted, err := ConvertBits(data, 5, 8, false)
+	if err != nil {
+		return "", nil, err
+	}
+	return hrp, converted, nil
+}

vendor/github.com/btcsuite/btcutil/bech32/doc.go

@@ -0,0 +1,15 @@
+// Copyright (c) 2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+/*
+Package bech32 provides a Go implementation of the bech32 format specified in
+BIP 173.
+
+Bech32 strings consist of a human-readable part (hrp), followed by the
+separator 1, then a checksummed data part encoded using the 32 characters
+"qpzry9x8gf2tvdw0s3jn54khce6mua7l".
+
+More info: https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki
+*/
+package bech32

vendor/github.com/btcsuite/btcutil/bech32/error.go

@@ -0,0 +1,85 @@
+// Copyright (c) 2019 The Decred developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package bech32
+
+import (
+	"fmt"
+)
+
+// ErrMixedCase is returned when the bech32 string has both lower and uppercase
+// characters.
+type ErrMixedCase struct{}
+
+func (e ErrMixedCase) Error() string {
+	return "string not all lowercase or all uppercase"
+}
+
+// ErrInvalidBitGroups is returned when conversion is attempted between byte
+// slices using bit-per-element of unsupported value.
+type ErrInvalidBitGroups struct{}
+
+func (e ErrInvalidBitGroups) Error() string {
+	return "only bit groups between 1 and 8 allowed"
+}
+
+// ErrInvalidIncompleteGroup is returned when then byte slice used as input has
+// data of wrong length.
+type ErrInvalidIncompleteGroup struct{}
+
+func (e ErrInvalidIncompleteGroup) Error() string {
+	return "invalid incomplete group"
+}
+
+// ErrInvalidLength is returned when the bech32 string has an invalid length
+// given the BIP-173 defined restrictions.
+type ErrInvalidLength int
+
+func (e ErrInvalidLength) Error() string {
+	return fmt.Sprintf("invalid bech32 string length %d", int(e))
+}
+
+// ErrInvalidCharacter is returned when the bech32 string has a character
+// outside the range of the supported charset.
+type ErrInvalidCharacter rune
+
+func (e ErrInvalidCharacter) Error() string {
+	return fmt.Sprintf("invalid character in string: '%c'", rune(e))
+}
+
+// ErrInvalidSeparatorIndex is returned when the separator character '1' is
+// in an invalid position in the bech32 string.
+type ErrInvalidSeparatorIndex int
+
+func (e ErrInvalidSeparatorIndex) Error() string {
+	return fmt.Sprintf("invalid separator index %d", int(e))
+}
+
+// ErrNonCharsetChar is returned when a character outside of the specific
+// bech32 charset is used in the string.
+type ErrNonCharsetChar rune
+
+func (e ErrNonCharsetChar) Error() string {
+	return fmt.Sprintf("invalid character not part of charset: %v", int(e))
+}
+
+// ErrInvalidChecksum is returned when the extracted checksum of the string
+// is different than what was expected.
+type ErrInvalidChecksum struct {
+	Expected string
+	Actual   string
+}
+
+func (e ErrInvalidChecksum) Error() string {
+	return fmt.Sprintf("invalid checksum (expected %v got %v)",
+		e.Expected, e.Actual)
+}
+
+// ErrInvalidDataByte is returned when a byte outside the range required for
+// conversion into a string was found.
+type ErrInvalidDataByte byte
+
+func (e ErrInvalidDataByte) Error() string {
+	return fmt.Sprintf("invalid data byte: %v", byte(e))
+}

vendor/github.com/btcsuite/btcutil/block.go

@@ -0,0 +1,265 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package btcutil
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+)
+
+// OutOfRangeError describes an error due to accessing an element that is out
+// of range.
+type OutOfRangeError string
+
+// BlockHeightUnknown is the value returned for a block height that is unknown.
+// This is typically because the block has not been inserted into the main chain
+// yet.
+const BlockHeightUnknown = int32(-1)
+
+// Error satisfies the error interface and prints human-readable errors.
+func (e OutOfRangeError) Error() string {
+	return string(e)
+}
+
+// Block defines a bitcoin block that provides easier and more efficient
+// manipulation of raw blocks.  It also memoizes hashes for the block and its
+// transactions on their first access so subsequent accesses don't have to
+// repeat the relatively expensive hashing operations.
+type Block struct {
+	msgBlock                 *wire.MsgBlock  // Underlying MsgBlock
+	serializedBlock          []byte          // Serialized bytes for the block
+	serializedBlockNoWitness []byte          // Serialized bytes for block w/o witness data
+	blockHash                *chainhash.Hash // Cached block hash
+	blockHeight              int32           // Height in the main block chain
+	transactions             []*Tx           // Transactions
+	txnsGenerated            bool            // ALL wrapped transactions generated
+}
+
+// MsgBlock returns the underlying wire.MsgBlock for the Block.
+func (b *Block) MsgBlock() *wire.MsgBlock {
+	// Return the cached block.
+	return b.msgBlock
+}
+
+// Bytes returns the serialized bytes for the Block.  This is equivalent to
+// calling Serialize on the underlying wire.MsgBlock, however it caches the
+// result so subsequent calls are more efficient.
+func (b *Block) Bytes() ([]byte, error) {
+	// Return the cached serialized bytes if it has already been generated.
+	if len(b.serializedBlock) != 0 {
+		return b.serializedBlock, nil
+	}
+
+	// Serialize the MsgBlock.
+	w := bytes.NewBuffer(make([]byte, 0, b.msgBlock.SerializeSize()))
+	err := b.msgBlock.Serialize(w)
+	if err != nil {
+		return nil, err
+	}
+	serializedBlock := w.Bytes()
+
+	// Cache the serialized bytes and return them.
+	b.serializedBlock = serializedBlock
+	return serializedBlock, nil
+}
+
+// BytesNoWitness returns the serialized bytes for the block with transactions
+// encoded without any witness data.
+func (b *Block) BytesNoWitness() ([]byte, error) {
+	// Return the cached serialized bytes if it has already been generated.
+	if len(b.serializedBlockNoWitness) != 0 {
+		return b.serializedBlockNoWitness, nil
+	}
+
+	// Serialize the MsgBlock.
+	var w bytes.Buffer
+	err := b.msgBlock.SerializeNoWitness(&w)
+	if err != nil {
+		return nil, err
+	}
+	serializedBlock := w.Bytes()
+
+	// Cache the serialized bytes and return them.
+	b.serializedBlockNoWitness = serializedBlock
+	return serializedBlock, nil
+}
+
+// Hash returns the block identifier hash for the Block.  This is equivalent to
+// calling BlockHash on the underlying wire.MsgBlock, however it caches the
+// result so subsequent calls are more efficient.
+func (b *Block) Hash() *chainhash.Hash {
+	// Return the cached block hash if it has already been generated.
+	if b.blockHash != nil {
+		return b.blockHash
+	}
+
+	// Cache the block hash and return it.
+	hash := b.msgBlock.BlockHash()
+	b.blockHash = &hash
+	return &hash
+}
+
+// Tx returns a wrapped transaction (btcutil.Tx) for the transaction at the
+// specified index in the Block.  The supplied index is 0 based.  That is to
+// say, the first transaction in the block is txNum 0.  This is nearly
+// equivalent to accessing the raw transaction (wire.MsgTx) from the
+// underlying wire.MsgBlock, however the wrapped transaction has some helpful
+// properties such as caching the hash so subsequent calls are more efficient.
+func (b *Block) Tx(txNum int) (*Tx, error) {
+	// Ensure the requested transaction is in range.
+	numTx := uint64(len(b.msgBlock.Transactions))
+	if txNum < 0 || uint64(txNum) >= numTx {
+		str := fmt.Sprintf("transaction index %d is out of range - max %d",
+			txNum, numTx-1)
+		return nil, OutOfRangeError(str)
+	}
+
+	// Generate slice to hold all of the wrapped transactions if needed.
+	if len(b.transactions) == 0 {
+		b.transactions = make([]*Tx, numTx)
+	}
+
+	// Return the wrapped transaction if it has already been generated.
+	if b.transactions[txNum] != nil {
+		return b.transactions[txNum], nil
+	}
+
+	// Generate and cache the wrapped transaction and return it.
+	newTx := NewTx(b.msgBlock.Transactions[txNum])
+	newTx.SetIndex(txNum)
+	b.transactions[txNum] = newTx
+	return newTx, nil
+}
+
+// Transactions returns a slice of wrapped transactions (btcutil.Tx) for all
+// transactions in the Block.  This is nearly equivalent to accessing the raw
+// transactions (wire.MsgTx) in the underlying wire.MsgBlock, however it
+// instead provides easy access to wrapped versions (btcutil.Tx) of them.
+func (b *Block) Transactions() []*Tx {
+	// Return transactions if they have ALL already been generated.  This
+	// flag is necessary because the wrapped transactions are lazily
+	// generated in a sparse fashion.
+	if b.txnsGenerated {
+		return b.transactions
+	}
+
+	// Generate slice to hold all of the wrapped transactions if needed.
+	if len(b.transactions) == 0 {
+		b.transactions = make([]*Tx, len(b.msgBlock.Transactions))
+	}
+
+	// Generate and cache the wrapped transactions for all that haven't
+	// already been done.
+	for i, tx := range b.transactions {
+		if tx == nil {
+			newTx := NewTx(b.msgBlock.Transactions[i])
+			newTx.SetIndex(i)
+			b.transactions[i] = newTx
+		}
+	}
+
+	b.txnsGenerated = true
+	return b.transactions
+}
+
+// TxHash returns the hash for the requested transaction number in the Block.
+// The supplied index is 0 based.  That is to say, the first transaction in the
+// block is txNum 0.  This is equivalent to calling TxHash on the underlying
+// wire.MsgTx, however it caches the result so subsequent calls are more
+// efficient.
+func (b *Block) TxHash(txNum int) (*chainhash.Hash, error) {
+	// Attempt to get a wrapped transaction for the specified index.  It
+	// will be created lazily if needed or simply return the cached version
+	// if it has already been generated.
+	tx, err := b.Tx(txNum)
+	if err != nil {
+		return nil, err
+	}
+
+	// Defer to the wrapped transaction which will return the cached hash if
+	// it has already been generated.
+	return tx.Hash(), nil
+}
+
+// TxLoc returns the offsets and lengths of each transaction in a raw block.
+// It is used to allow fast indexing into transactions within the raw byte
+// stream.
+func (b *Block) TxLoc() ([]wire.TxLoc, error) {
+	rawMsg, err := b.Bytes()
+	if err != nil {
+		return nil, err
+	}
+	rbuf := bytes.NewBuffer(rawMsg)
+
+	var mblock wire.MsgBlock
+	txLocs, err := mblock.DeserializeTxLoc(rbuf)
+	if err != nil {
+		return nil, err
+	}
+	return txLocs, err
+}
+
+// Height returns the saved height of the block in the block chain.  This value
+// will be BlockHeightUnknown if it hasn't already explicitly been set.
+func (b *Block) Height() int32 {
+	return b.blockHeight
+}
+
+// SetHeight sets the height of the block in the block chain.
+func (b *Block) SetHeight(height int32) {
+	b.blockHeight = height
+}
+
+// NewBlock returns a new instance of a bitcoin block given an underlying
+// wire.MsgBlock.  See Block.
+func NewBlock(msgBlock *wire.MsgBlock) *Block {
+	return &Block{
+		msgBlock:    msgBlock,
+		blockHeight: BlockHeightUnknown,
+	}
+}
+
+// NewBlockFromBytes returns a new instance of a bitcoin block given the
+// serialized bytes.  See Block.
+func NewBlockFromBytes(serializedBlock []byte) (*Block, error) {
+	br := bytes.NewReader(serializedBlock)
+	b, err := NewBlockFromReader(br)
+	if err != nil {
+		return nil, err
+	}
+	b.serializedBlock = serializedBlock
+	return b, nil
+}
+
+// NewBlockFromReader returns a new instance of a bitcoin block given a
+// Reader to deserialize the block.  See Block.
+func NewBlockFromReader(r io.Reader) (*Block, error) {
+	// Deserialize the bytes into a MsgBlock.
+	var msgBlock wire.MsgBlock
+	err := msgBlock.Deserialize(r)
+	if err != nil {
+		return nil, err
+	}
+
+	b := Block{
+		msgBlock:    &msgBlock,
+		blockHeight: BlockHeightUnknown,
+	}
+	return &b, nil
+}
+
+// NewBlockFromBlockAndBytes returns a new instance of a bitcoin block given
+// an underlying wire.MsgBlock and the serialized bytes for it.  See Block.
+func NewBlockFromBlockAndBytes(msgBlock *wire.MsgBlock, serializedBlock []byte) *Block {
+	return &Block{
+		msgBlock:        msgBlock,
+		serializedBlock: serializedBlock,
+		blockHeight:     BlockHeightUnknown,
+	}
+}

vendor/github.com/btcsuite/btcutil/certgen.go

@@ -0,0 +1,144 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package btcutil
+
+import (
+	"bytes"
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	_ "crypto/sha512" // Needed for RegisterHash in init
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"errors"
+	"fmt"
+	"math/big"
+	"net"
+	"os"
+	"time"
+)
+
+// NewTLSCertPair returns a new PEM-encoded x.509 certificate pair
+// based on a 521-bit ECDSA private key.  The machine's local interface
+// addresses and all variants of IPv4 and IPv6 localhost are included as
+// valid IP addresses.
+func NewTLSCertPair(organization string, validUntil time.Time, extraHosts []string) (cert, key []byte, err error) {
+	now := time.Now()
+	if validUntil.Before(now) {
+		return nil, nil, errors.New("validUntil would create an already-expired certificate")
+	}
+
+	priv, err := ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// end of ASN.1 time
+	endOfTime := time.Date(2049, 12, 31, 23, 59, 59, 0, time.UTC)
+	if validUntil.After(endOfTime) {
+		validUntil = endOfTime
+	}
+
+	serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
+	serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to generate serial number: %s", err)
+	}
+
+	host, err := os.Hostname()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	ipAddresses := []net.IP{net.ParseIP("127.0.0.1"), net.ParseIP("::1")}
+	dnsNames := []string{host}
+	if host != "localhost" {
+		dnsNames = append(dnsNames, "localhost")
+	}
+
+	addIP := func(ipAddr net.IP) {
+		for _, ip := range ipAddresses {
+			if bytes.Equal(ip, ipAddr) {
+				return
+			}
+		}
+		ipAddresses = append(ipAddresses, ipAddr)
+	}
+	addHost := func(host string) {
+		for _, dnsName := range dnsNames {
+			if host == dnsName {
+				return
+			}
+		}
+		dnsNames = append(dnsNames, host)
+	}
+
+	addrs, err := interfaceAddrs()
+	if err != nil {
+		return nil, nil, err
+	}
+	for _, a := range addrs {
+		ipAddr, _, err := net.ParseCIDR(a.String())
+		if err == nil {
+			addIP(ipAddr)
+		}
+	}
+
+	for _, hostStr := range extraHosts {
+		host, _, err := net.SplitHostPort(hostStr)
+		if err != nil {
+			host = hostStr
+		}
+		if ip := net.ParseIP(host); ip != nil {
+			addIP(ip)
+		} else {
+			addHost(host)
+		}
+	}
+
+	template := x509.Certificate{
+		SerialNumber: serialNumber,
+		Subject: pkix.Name{
+			Organization: []string{organization},
+			CommonName:   host,
+		},
+		NotBefore: now.Add(-time.Hour * 24),
+		NotAfter:  validUntil,
+
+		KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature |
+			x509.KeyUsageCertSign,
+		IsCA:                  true, // so can sign self.
+		BasicConstraintsValid: true,
+
+		DNSNames:    dnsNames,
+		IPAddresses: ipAddresses,
+	}
+
+	derBytes, err := x509.CreateCertificate(rand.Reader, &template,
+		&template, &priv.PublicKey, priv)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to create certificate: %v", err)
+	}
+
+	certBuf := &bytes.Buffer{}
+	err = pem.Encode(certBuf, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to encode certificate: %v", err)
+	}
+
+	keybytes, err := x509.MarshalECPrivateKey(priv)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to marshal private key: %v", err)
+	}
+
+	keyBuf := &bytes.Buffer{}
+	err = pem.Encode(keyBuf, &pem.Block{Type: "EC PRIVATE KEY", Bytes: keybytes})
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to encode private key: %v", err)
+	}
+
+	return certBuf.Bytes(), keyBuf.Bytes(), nil
+}

vendor/github.com/btcsuite/btcutil/const.go

@@ -0,0 +1,16 @@
+// Copyright (c) 2013-2014 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package btcutil
+
+const (
+	// SatoshiPerBitcent is the number of satoshi in one bitcoin cent.
+	SatoshiPerBitcent = 1e6
+
+	// SatoshiPerBitcoin is the number of satoshi in one bitcoin (1 BTC).
+	SatoshiPerBitcoin = 1e8
+
+	// MaxSatoshi is the maximum transaction amount allowed in satoshi.
+	MaxSatoshi = 21e6 * SatoshiPerBitcoin
+)

vendor/github.com/btcsuite/btcutil/cov_report.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+# This script uses gocov to generate a test coverage report.
+# The gocov tool my be obtained with the following command:
+#   go get github.com/axw/gocov/gocov
+#
+# It will be installed to $GOPATH/bin, so ensure that location is in your $PATH.
+
+# Check for gocov.
+type gocov >/dev/null 2>&1
+if [ $? -ne 0 ]; then
+	echo >&2 "This script requires the gocov tool."
+	echo >&2 "You may obtain it with the following command:"
+	echo >&2 "go get github.com/axw/gocov/gocov"
+	exit 1
+fi
+gocov test | gocov report

vendor/github.com/btcsuite/btcutil/doc.go

@@ -0,0 +1,46 @@
+// Copyright (c) 2013-2014 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+/*
+Package btcutil provides bitcoin-specific convenience functions and types.
+
+Block Overview
+
+A Block defines a bitcoin block that provides easier and more efficient
+manipulation of raw wire protocol blocks.  It also memoizes hashes for the
+block and its transactions on their first access so subsequent accesses don't
+have to repeat the relatively expensive hashing operations.
+
+Tx Overview
+
+A Tx defines a bitcoin transaction that provides more efficient manipulation of
+raw wire protocol transactions.  It memoizes the hash for the transaction on its
+first access so subsequent accesses don't have to repeat the relatively
+expensive hashing operations.
+
+Address Overview
+
+The Address interface provides an abstraction for a Bitcoin address.  While the
+most common type is a pay-to-pubkey-hash, Bitcoin already supports others and
+may well support more in the future.  This package currently provides
+implementations for the pay-to-pubkey, pay-to-pubkey-hash, and
+pay-to-script-hash address types.
+
+To decode/encode an address:
+
+	// NOTE: The default network is only used for address types which do not
+	// already contain that information.  At this time, that is only
+	// pay-to-pubkey addresses.
+	addrString := "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962" +
+		"e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d57" +
+		"8a4c702b6bf11d5f"
+	defaultNet := &chaincfg.MainNetParams
+	addr, err := btcutil.DecodeAddress(addrString, defaultNet)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println(addr.EncodeAddress())
+*/
+package btcutil

vendor/github.com/btcsuite/btcutil/goclean.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+# The script does automatic checking on a Go package and its sub-packages, including:
+# 1. gofmt         (http://golang.org/cmd/gofmt/)
+# 2. goimports     (https://github.com/bradfitz/goimports)
+# 3. golint        (https://github.com/golang/lint)
+# 4. go vet        (http://golang.org/cmd/vet)
+# 5. gosimple      (https://github.com/dominikh/go-simple)
+# 6. unconvert     (https://github.com/mdempsky/unconvert)
+# 7. race detector (http://blog.golang.org/race-detector)
+# 8. test coverage (http://blog.golang.org/cover)
+#
+
+set -ex
+
+# Automatic checks
+for i in $(find . -name go.mod -type f -print); do
+  module=$(dirname ${i})
+  echo "==> ${module}"
+
+  MODNAME=$(echo $module | sed -E -e "s/^$ROOTPATHPATTERN//" \
+    -e 's,^/,,' -e 's,/v[0-9]+$,,')
+  if [ -z "$MODNAME" ]; then
+    MODNAME=.
+  fi
+
+  # run tests
+  (cd $MODNAME &&
+    echo "mode: atomic" > profile.cov && \
+    env GORACE=halt_on_error=1 go test -race -covermode=atomic -coverprofile=profile.tmp ./... && \
+    cat profile.tmp | tail -n +2 >> profile.cov && \
+    rm profile.tmp && \
+    go tool cover -func profile.cov
+  )
+
+  # check linters
+  (cd $MODNAME && \
+    go mod download && \
+    golangci-lint run --deadline=10m --disable-all \
+      --enable=gofmt \
+      --enable=goimports \
+      --enable=golint \
+      --enable=govet \
+      --enable=gosimple \
+      --enable=unconvert
+  )
+done

vendor/github.com/btcsuite/btcutil/hash160.go

@@ -0,0 +1,23 @@
+// Copyright (c) 2013-2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package btcutil
+
+import (
+	"crypto/sha256"
+	"hash"
+
+	"golang.org/x/crypto/ripemd160"
+)
+
+// Calculate the hash of hasher over buf.
+func calcHash(buf []byte, hasher hash.Hash) []byte {
+	hasher.Write(buf)
+	return hasher.Sum(nil)
+}
+
+// Hash160 calculates the hash ripemd160(sha256(b)).
+func Hash160(buf []byte) []byte {
+	return calcHash(calcHash(buf, sha256.New()), ripemd160.New())
+}

vendor/github.com/btcsuite/btcutil/net.go

@@ -0,0 +1,18 @@
+// Copyright (c) 2013-2014 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+package btcutil
+
+import (
+	"net"
+)
+
+// interfaceAddrs returns a list of the system's network interface addresses.
+// It is wrapped here so that we can substitute it for other functions when
+// building for systems that do not allow access to net.InterfaceAddrs().
+func interfaceAddrs() ([]net.Addr, error) {
+	return net.InterfaceAddrs()
+}

vendor/github.com/btcsuite/btcutil/net_noop.go

@@ -0,0 +1,19 @@
+// Copyright (c) 2013-2014 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package btcutil
+
+import (
+	"net"
+)
+
+// interfaceAddrs returns a list of the system's network interface addresses.
+// It is wrapped here so that we can substitute it for a no-op function that
+// returns an empty slice of net.Addr when building for systems that do not
+// allow access to net.InterfaceAddrs().
+func interfaceAddrs() ([]net.Addr, error) {
+	return []net.Addr{}, nil
+}

vendor/github.com/btcsuite/btcutil/test_coverage.txt

@@ -0,0 +1,72 @@
+
+github.com/conformal/btcutil/base58.go	 Base58Decode			 100.00% (20/20)
+github.com/conformal/btcutil/base58.go	 Base58Encode			 100.00% (15/15)
+github.com/conformal/btcutil/block.go	 Block.Tx			 100.00% (12/12)
+github.com/conformal/btcutil/wif.go	 WIF.String			 100.00% (11/11)
+github.com/conformal/btcutil/block.go	 Block.Transactions		 100.00% (11/11)
+github.com/conformal/btcutil/amount.go	 AmountUnit.String		 100.00% (8/8)
+github.com/conformal/btcutil/tx.go	 NewTxFromReader		 100.00% (6/6)
+github.com/conformal/btcutil/block.go	 NewBlockFromBytes		 100.00% (6/6)
+github.com/conformal/btcutil/block.go	 NewBlockFromReader		 100.00% (6/6)
+github.com/conformal/btcutil/address.go	 encodeAddress			 100.00% (6/6)
+github.com/conformal/btcutil/address.go	 newAddressPubKeyHash		 100.00% (5/5)
+github.com/conformal/btcutil/address.go	 newAddressScriptHashFromHash	 100.00% (5/5)
+github.com/conformal/btcutil/tx.go	 Tx.Sha				 100.00% (5/5)
+github.com/conformal/btcutil/block.go	 Block.Sha			 100.00% (5/5)
+github.com/conformal/btcutil/amount.go	 NewAmount			 100.00% (5/5)
+github.com/conformal/btcutil/amount.go	 round				 100.00% (3/3)
+github.com/conformal/btcutil/address.go	 NewAddressScriptHash		 100.00% (2/2)
+github.com/conformal/btcutil/amount.go	 Amount.Format			 100.00% (2/2)
+github.com/conformal/btcutil/tx.go	 NewTxFromBytes			 100.00% (2/2)
+github.com/conformal/btcutil/hash160.go	 calcHash			 100.00% (2/2)
+github.com/conformal/btcutil/address.go	 AddressPubKeyHash.Hash160	 100.00% (1/1)
+github.com/conformal/btcutil/block.go	 OutOfRangeError.Error		 100.00% (1/1)
+github.com/conformal/btcutil/block.go	 Block.MsgBlock			 100.00% (1/1)
+github.com/conformal/btcutil/tx.go	 Tx.MsgTx			 100.00% (1/1)
+github.com/conformal/btcutil/hash160.go	 Hash160			 100.00% (1/1)
+github.com/conformal/btcutil/block.go	 NewBlockFromBlockAndBytes	 100.00% (1/1)
+github.com/conformal/btcutil/block.go	 Block.Height			 100.00% (1/1)
+github.com/conformal/btcutil/block.go	 Block.SetHeight		 100.00% (1/1)
+github.com/conformal/btcutil/block.go	 NewBlock			 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressPubKeyHash.IsForNet	 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressPubKey.EncodeAddress	 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 NewAddressPubKeyHash		 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressPubKeyHash.EncodeAddress 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressPubKeyHash.ScriptAddress 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressPubKeyHash.String	 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 NewAddressScriptHashFromHash	 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressScriptHash.EncodeAddress 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressScriptHash.ScriptAddress 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressScriptHash.IsForNet	 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressScriptHash.String	 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressScriptHash.Hash160	 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressPubKey.ScriptAddress	 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressPubKey.IsForNet		 100.00% (1/1)
+github.com/conformal/btcutil/address.go	 AddressPubKey.String		 100.00% (1/1)
+github.com/conformal/btcutil/tx.go	 NewTx				 100.00% (1/1)
+github.com/conformal/btcutil/tx.go	 Tx.SetIndex			 100.00% (1/1)
+github.com/conformal/btcutil/amount.go	 Amount.ToUnit			 100.00% (1/1)
+github.com/conformal/btcutil/tx.go	 Tx.Index			 100.00% (1/1)
+github.com/conformal/btcutil/amount.go	 Amount.String			 100.00% (1/1)
+github.com/conformal/btcutil/amount.go	 Amount.MulF64			 100.00% (1/1)
+github.com/conformal/btcutil/appdata.go	 appDataDir			 92.00% (23/25)
+github.com/conformal/btcutil/block.go	 Block.TxLoc			 88.89% (8/9)
+github.com/conformal/btcutil/block.go	 Block.Bytes			 88.89% (8/9)
+github.com/conformal/btcutil/address.go	 NewAddressPubKey		 87.50% (7/8)
+github.com/conformal/btcutil/address.go	 DecodeAddress			 85.00% (17/20)
+github.com/conformal/btcutil/wif.go	 DecodeWIF			 85.00% (17/20)
+github.com/conformal/btcutil/address.go	 AddressPubKey.serialize	 80.00% (4/5)
+github.com/conformal/btcutil/block.go	 Block.TxSha			 75.00% (3/4)
+github.com/conformal/btcutil/wif.go	 paddedAppend			 66.67% (2/3)
+github.com/conformal/btcutil/wif.go	 NewWIF				 66.67% (2/3)
+github.com/conformal/btcutil/certgen.go	 NewTLSCertPair			 0.00% (0/54)
+github.com/conformal/btcutil/wif.go	 WIF.SerializePubKey		 0.00% (0/4)
+github.com/conformal/btcutil/address.go	 AddressPubKey.AddressPubKeyHash 0.00% (0/3)
+github.com/conformal/btcutil/address.go	 AddressPubKey.Format		 0.00% (0/1)
+github.com/conformal/btcutil/address.go	 AddressPubKey.PubKey		 0.00% (0/1)
+github.com/conformal/btcutil/address.go	 AddressPubKey.SetFormat	 0.00% (0/1)
+github.com/conformal/btcutil/wif.go	 WIF.IsForNet			 0.00% (0/1)
+github.com/conformal/btcutil/appdata.go	 AppDataDir			 0.00% (0/1)
+github.com/conformal/btcutil/net.go	 interfaceAddrs			 0.00% (0/1)
+github.com/conformal/btcutil		 ------------------------------- 75.88% (258/340)
+

vendor/github.com/btcsuite/btcutil/tx.go

@@ -0,0 +1,124 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package btcutil
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+)
+
+// TxIndexUnknown is the value returned for a transaction index that is unknown.
+// This is typically because the transaction has not been inserted into a block
+// yet.
+const TxIndexUnknown = -1
+
+// Tx defines a bitcoin transaction that provides easier and more efficient
+// manipulation of raw transactions.  It also memoizes the hash for the
+// transaction on its first access so subsequent accesses don't have to repeat
+// the relatively expensive hashing operations.
+type Tx struct {
+	msgTx         *wire.MsgTx     // Underlying MsgTx
+	txHash        *chainhash.Hash // Cached transaction hash
+	txHashWitness *chainhash.Hash // Cached transaction witness hash
+	txHasWitness  *bool           // If the transaction has witness data
+	txIndex       int             // Position within a block or TxIndexUnknown
+}
+
+// MsgTx returns the underlying wire.MsgTx for the transaction.
+func (t *Tx) MsgTx() *wire.MsgTx {
+	// Return the cached transaction.
+	return t.msgTx
+}
+
+// Hash returns the hash of the transaction.  This is equivalent to
+// calling TxHash on the underlying wire.MsgTx, however it caches the
+// result so subsequent calls are more efficient.
+func (t *Tx) Hash() *chainhash.Hash {
+	// Return the cached hash if it has already been generated.
+	if t.txHash != nil {
+		return t.txHash
+	}
+
+	// Cache the hash and return it.
+	hash := t.msgTx.TxHash()
+	t.txHash = &hash
+	return &hash
+}
+
+// WitnessHash returns the witness hash (wtxid) of the transaction.  This is
+// equivalent to calling WitnessHash on the underlying wire.MsgTx, however it
+// caches the result so subsequent calls are more efficient.
+func (t *Tx) WitnessHash() *chainhash.Hash {
+	// Return the cached hash if it has already been generated.
+	if t.txHashWitness != nil {
+		return t.txHashWitness
+	}
+
+	// Cache the hash and return it.
+	hash := t.msgTx.WitnessHash()
+	t.txHashWitness = &hash
+	return &hash
+}
+
+// HasWitness returns false if none of the inputs within the transaction
+// contain witness data, true false otherwise. This equivalent to calling
+// HasWitness on the underlying wire.MsgTx, however it caches the result so
+// subsequent calls are more efficient.
+func (t *Tx) HasWitness() bool {
+	if t.txHasWitness != nil {
+		return *t.txHasWitness
+	}
+
+	hasWitness := t.msgTx.HasWitness()
+	t.txHasWitness = &hasWitness
+	return hasWitness
+}
+
+// Index returns the saved index of the transaction within a block.  This value
+// will be TxIndexUnknown if it hasn't already explicitly been set.
+func (t *Tx) Index() int {
+	return t.txIndex
+}
+
+// SetIndex sets the index of the transaction in within a block.
+func (t *Tx) SetIndex(index int) {
+	t.txIndex = index
+}
+
+// NewTx returns a new instance of a bitcoin transaction given an underlying
+// wire.MsgTx.  See Tx.
+func NewTx(msgTx *wire.MsgTx) *Tx {
+	return &Tx{
+		msgTx:   msgTx,
+		txIndex: TxIndexUnknown,
+	}
+}
+
+// NewTxFromBytes returns a new instance of a bitcoin transaction given the
+// serialized bytes.  See Tx.
+func NewTxFromBytes(serializedTx []byte) (*Tx, error) {
+	br := bytes.NewReader(serializedTx)
+	return NewTxFromReader(br)
+}
+
+// NewTxFromReader returns a new instance of a bitcoin transaction given a
+// Reader to deserialize the transaction.  See Tx.
+func NewTxFromReader(r io.Reader) (*Tx, error) {
+	// Deserialize the bytes into a MsgTx.
+	var msgTx wire.MsgTx
+	err := msgTx.Deserialize(r)
+	if err != nil {
+		return nil, err
+	}
+
+	t := Tx{
+		msgTx:   &msgTx,
+		txIndex: TxIndexUnknown,
+	}
+	return &t, nil
+}

vendor/github.com/btcsuite/btcutil/wif.go

@@ -0,0 +1,169 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package btcutil
+
+import (
+	"bytes"
+	"errors"
+
+	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcutil/base58"
+)
+
+// ErrMalformedPrivateKey describes an error where a WIF-encoded private
+// key cannot be decoded due to being improperly formatted.  This may occur
+// if the byte length is incorrect or an unexpected magic number was
+// encountered.
+var ErrMalformedPrivateKey = errors.New("malformed private key")
+
+// compressMagic is the magic byte used to identify a WIF encoding for
+// an address created from a compressed serialized public key.
+const compressMagic byte = 0x01
+
+// WIF contains the individual components described by the Wallet Import Format
+// (WIF).  A WIF string is typically used to represent a private key and its
+// associated address in a way that  may be easily copied and imported into or
+// exported from wallet software.  WIF strings may be decoded into this
+// structure by calling DecodeWIF or created with a user-provided private key
+// by calling NewWIF.
+type WIF struct {
+	// PrivKey is the private key being imported or exported.
+	PrivKey *btcec.PrivateKey
+
+	// CompressPubKey specifies whether the address controlled by the
+	// imported or exported private key was created by hashing a
+	// compressed (33-byte) serialized public key, rather than an
+	// uncompressed (65-byte) one.
+	CompressPubKey bool
+
+	// netID is the bitcoin network identifier byte used when
+	// WIF encoding the private key.
+	netID byte
+}
+
+// NewWIF creates a new WIF structure to export an address and its private key
+// as a string encoded in the Wallet Import Format.  The compress argument
+// specifies whether the address intended to be imported or exported was created
+// by serializing the public key compressed rather than uncompressed.
+func NewWIF(privKey *btcec.PrivateKey, net *chaincfg.Params, compress bool) (*WIF, error) {
+	if net == nil {
+		return nil, errors.New("no network")
+	}
+	return &WIF{privKey, compress, net.PrivateKeyID}, nil
+}
+
+// IsForNet returns whether or not the decoded WIF structure is associated
+// with the passed bitcoin network.
+func (w *WIF) IsForNet(net *chaincfg.Params) bool {
+	return w.netID == net.PrivateKeyID
+}
+
+// DecodeWIF creates a new WIF structure by decoding the string encoding of
+// the import format.
+//
+// The WIF string must be a base58-encoded string of the following byte
+// sequence:
+//
+//  * 1 byte to identify the network, must be 0x80 for mainnet or 0xef for
+//    either testnet3 or the regression test network
+//  * 32 bytes of a binary-encoded, big-endian, zero-padded private key
+//  * Optional 1 byte (equal to 0x01) if the address being imported or exported
+//    was created by taking the RIPEMD160 after SHA256 hash of a serialized
+//    compressed (33-byte) public key
+//  * 4 bytes of checksum, must equal the first four bytes of the double SHA256
+//    of every byte before the checksum in this sequence
+//
+// If the base58-decoded byte sequence does not match this, DecodeWIF will
+// return a non-nil error.  ErrMalformedPrivateKey is returned when the WIF
+// is of an impossible length or the expected compressed pubkey magic number
+// does not equal the expected value of 0x01.  ErrChecksumMismatch is returned
+// if the expected WIF checksum does not match the calculated checksum.
+func DecodeWIF(wif string) (*WIF, error) {
+	decoded := base58.Decode(wif)
+	decodedLen := len(decoded)
+	var compress bool
+
+	// Length of base58 decoded WIF must be 32 bytes + an optional 1 byte
+	// (0x01) if compressed, plus 1 byte for netID + 4 bytes of checksum.
+	switch decodedLen {
+	case 1 + btcec.PrivKeyBytesLen + 1 + 4:
+		if decoded[33] != compressMagic {
+			return nil, ErrMalformedPrivateKey
+		}
+		compress = true
+	case 1 + btcec.PrivKeyBytesLen + 4:
+		compress = false
+	default:
+		return nil, ErrMalformedPrivateKey
+	}
+
+	// Checksum is first four bytes of double SHA256 of the identifier byte
+	// and privKey.  Verify this matches the final 4 bytes of the decoded
+	// private key.
+	var tosum []byte
+	if compress {
+		tosum = decoded[:1+btcec.PrivKeyBytesLen+1]
+	} else {
+		tosum = decoded[:1+btcec.PrivKeyBytesLen]
+	}
+	cksum := chainhash.DoubleHashB(tosum)[:4]
+	if !bytes.Equal(cksum, decoded[decodedLen-4:]) {
+		return nil, ErrChecksumMismatch
+	}
+
+	netID := decoded[0]
+	privKeyBytes := decoded[1 : 1+btcec.PrivKeyBytesLen]
+	privKey, _ := btcec.PrivKeyFromBytes(btcec.S256(), privKeyBytes)
+	return &WIF{privKey, compress, netID}, nil
+}
+
+// String creates the Wallet Import Format string encoding of a WIF structure.
+// See DecodeWIF for a detailed breakdown of the format and requirements of
+// a valid WIF string.
+func (w *WIF) String() string {
+	// Precalculate size.  Maximum number of bytes before base58 encoding
+	// is one byte for the network, 32 bytes of private key, possibly one
+	// extra byte if the pubkey is to be compressed, and finally four
+	// bytes of checksum.
+	encodeLen := 1 + btcec.PrivKeyBytesLen + 4
+	if w.CompressPubKey {
+		encodeLen++
+	}
+
+	a := make([]byte, 0, encodeLen)
+	a = append(a, w.netID)
+	// Pad and append bytes manually, instead of using Serialize, to
+	// avoid another call to make.
+	a = paddedAppend(btcec.PrivKeyBytesLen, a, w.PrivKey.D.Bytes())
+	if w.CompressPubKey {
+		a = append(a, compressMagic)
+	}
+	cksum := chainhash.DoubleHashB(a)[:4]
+	a = append(a, cksum...)
+	return base58.Encode(a)
+}
+
+// SerializePubKey serializes the associated public key of the imported or
+// exported private key in either a compressed or uncompressed format.  The
+// serialization format chosen depends on the value of w.CompressPubKey.
+func (w *WIF) SerializePubKey() []byte {
+	pk := (*btcec.PublicKey)(&w.PrivKey.PublicKey)
+	if w.CompressPubKey {
+		return pk.SerializeCompressed()
+	}
+	return pk.SerializeUncompressed()
+}
+
+// paddedAppend appends the src byte slice to dst, returning the new slice.
+// If the length of the source is smaller than the passed size, leading zero
+// bytes are appended to the dst slice before appending src.
+func paddedAppend(size uint, dst, src []byte) []byte {
+	for i := 0; i < int(size)-len(src); i++ {
+		dst = append(dst, 0)
+	}
+	return append(dst, src...)
+}