Release v0.3.0

vendor/github.com/btcsuite/btcd/integration/rpctest/README.md

@@ -0,0 +1,30 @@
+rpctest
+=======
+
+[![Build Status](http://img.shields.io/travis/btcsuite/btcd.svg)](https://travis-ci.org/btcsuite/btcd)
+[![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/btcd/integration/rpctest)
+
+Package rpctest provides a btcd-specific RPC testing harness crafting and
+executing integration tests by driving a `btcd` instance via the `RPC`
+interface. Each instance of an active harness comes equipped with a simple
+in-memory HD wallet capable of properly syncing to the generated chain,
+creating new addresses, and crafting fully signed transactions paying to an
+arbitrary set of outputs.
+
+This package was designed specifically to act as an RPC testing harness for
+`btcd`. However, the constructs presented are general enough to be adapted to
+any project wishing to programmatically drive a `btcd` instance of its
+systems/integration tests.
+
+## Installation and Updating
+
+```bash
+$ go get -u github.com/btcsuite/btcd/integration/rpctest
+```
+
+## License
+
+Package rpctest is licensed under the [copyfree](http://copyfree.org) ISC
+License.
+

vendor/github.com/btcsuite/btcd/integration/rpctest/blockgen.go

@@ -0,0 +1,207 @@
+// Copyright (c) 2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package rpctest
+
+import (
+	"errors"
+	"math"
+	"math/big"
+	"runtime"
+	"time"
+
+	"github.com/btcsuite/btcd/blockchain"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+)
+
+// solveBlock attempts to find a nonce which makes the passed block header hash
+// to a value less than the target difficulty. When a successful solution is
+// found true is returned and the nonce field of the passed header is updated
+// with the solution. False is returned if no solution exists.
+func solveBlock(header *wire.BlockHeader, targetDifficulty *big.Int) bool {
+	// sbResult is used by the solver goroutines to send results.
+	type sbResult struct {
+		found bool
+		nonce uint32
+	}
+
+	// solver accepts a block header and a nonce range to test. It is
+	// intended to be run as a goroutine.
+	quit := make(chan bool)
+	results := make(chan sbResult)
+	solver := func(hdr wire.BlockHeader, startNonce, stopNonce uint32) {
+		// We need to modify the nonce field of the header, so make sure
+		// we work with a copy of the original header.
+		for i := startNonce; i >= startNonce && i <= stopNonce; i++ {
+			select {
+			case <-quit:
+				return
+			default:
+				hdr.Nonce = i
+				hash := hdr.BlockHash()
+				if blockchain.HashToBig(&hash).Cmp(targetDifficulty) <= 0 {
+					select {
+					case results <- sbResult{true, i}:
+						return
+					case <-quit:
+						return
+					}
+				}
+			}
+		}
+		select {
+		case results <- sbResult{false, 0}:
+		case <-quit:
+			return
+		}
+	}
+
+	startNonce := uint32(0)
+	stopNonce := uint32(math.MaxUint32)
+	numCores := uint32(runtime.NumCPU())
+	noncesPerCore := (stopNonce - startNonce) / numCores
+	for i := uint32(0); i < numCores; i++ {
+		rangeStart := startNonce + (noncesPerCore * i)
+		rangeStop := startNonce + (noncesPerCore * (i + 1)) - 1
+		if i == numCores-1 {
+			rangeStop = stopNonce
+		}
+		go solver(*header, rangeStart, rangeStop)
+	}
+	for i := uint32(0); i < numCores; i++ {
+		result := <-results
+		if result.found {
+			close(quit)
+			header.Nonce = result.nonce
+			return true
+		}
+	}
+
+	return false
+}
+
+// standardCoinbaseScript returns a standard script suitable for use as the
+// signature script of the coinbase transaction of a new block. In particular,
+// it starts with the block height that is required by version 2 blocks.
+func standardCoinbaseScript(nextBlockHeight int32, extraNonce uint64) ([]byte, error) {
+	return txscript.NewScriptBuilder().AddInt64(int64(nextBlockHeight)).
+		AddInt64(int64(extraNonce)).Script()
+}
+
+// createCoinbaseTx returns a coinbase transaction paying an appropriate
+// subsidy based on the passed block height to the provided address.
+func createCoinbaseTx(coinbaseScript []byte, nextBlockHeight int32,
+	addr btcutil.Address, mineTo []wire.TxOut,
+	net *chaincfg.Params) (*btcutil.Tx, error) {
+
+	// Create the script to pay to the provided payment address.
+	pkScript, err := txscript.PayToAddrScript(addr)
+	if err != nil {
+		return nil, err
+	}
+
+	tx := wire.NewMsgTx(wire.TxVersion)
+	tx.AddTxIn(&wire.TxIn{
+		// Coinbase transactions have no inputs, so previous outpoint is
+		// zero hash and max index.
+		PreviousOutPoint: *wire.NewOutPoint(&chainhash.Hash{},
+			wire.MaxPrevOutIndex),
+		SignatureScript: coinbaseScript,
+		Sequence:        wire.MaxTxInSequenceNum,
+	})
+	if len(mineTo) == 0 {
+		tx.AddTxOut(&wire.TxOut{
+			Value:    blockchain.CalcBlockSubsidy(nextBlockHeight, net),
+			PkScript: pkScript,
+		})
+	} else {
+		for i := range mineTo {
+			tx.AddTxOut(&mineTo[i])
+		}
+	}
+	return btcutil.NewTx(tx), nil
+}
+
+// CreateBlock creates a new block building from the previous block with a
+// specified blockversion and timestamp. If the timestamp passed is zero (not
+// initialized), then the timestamp of the previous block will be used plus 1
+// second is used. Passing nil for the previous block results in a block that
+// builds off of the genesis block for the specified chain.
+func CreateBlock(prevBlock *btcutil.Block, inclusionTxs []*btcutil.Tx,
+	blockVersion int32, blockTime time.Time, miningAddr btcutil.Address,
+	mineTo []wire.TxOut, net *chaincfg.Params) (*btcutil.Block, error) {
+
+	var (
+		prevHash      *chainhash.Hash
+		blockHeight   int32
+		prevBlockTime time.Time
+	)
+
+	// If the previous block isn't specified, then we'll construct a block
+	// that builds off of the genesis block for the chain.
+	if prevBlock == nil {
+		prevHash = net.GenesisHash
+		blockHeight = 1
+		prevBlockTime = net.GenesisBlock.Header.Timestamp.Add(time.Minute)
+	} else {
+		prevHash = prevBlock.Hash()
+		blockHeight = prevBlock.Height() + 1
+		prevBlockTime = prevBlock.MsgBlock().Header.Timestamp
+	}
+
+	// If a target block time was specified, then use that as the header's
+	// timestamp. Otherwise, add one second to the previous block unless
+	// it's the genesis block in which case use the current time.
+	var ts time.Time
+	switch {
+	case !blockTime.IsZero():
+		ts = blockTime
+	default:
+		ts = prevBlockTime.Add(time.Second)
+	}
+
+	extraNonce := uint64(0)
+	coinbaseScript, err := standardCoinbaseScript(blockHeight, extraNonce)
+	if err != nil {
+		return nil, err
+	}
+	coinbaseTx, err := createCoinbaseTx(coinbaseScript, blockHeight,
+		miningAddr, mineTo, net)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create a new block ready to be solved.
+	blockTxns := []*btcutil.Tx{coinbaseTx}
+	if inclusionTxs != nil {
+		blockTxns = append(blockTxns, inclusionTxs...)
+	}
+	merkles := blockchain.BuildMerkleTreeStore(blockTxns, false)
+	var block wire.MsgBlock
+	block.Header = wire.BlockHeader{
+		Version:    blockVersion,
+		PrevBlock:  *prevHash,
+		MerkleRoot: *merkles[len(merkles)-1],
+		Timestamp:  ts,
+		Bits:       net.PowLimitBits,
+	}
+	for _, tx := range blockTxns {
+		if err := block.AddTransaction(tx.MsgTx()); err != nil {
+			return nil, err
+		}
+	}
+
+	found := solveBlock(&block.Header, net.PowLimit)
+	if !found {
+		return nil, errors.New("Unable to solve block")
+	}
+
+	utilBlock := btcutil.NewBlock(&block)
+	utilBlock.SetHeight(blockHeight)
+	return utilBlock, nil
+}

vendor/github.com/btcsuite/btcd/integration/rpctest/btcd.go

@@ -0,0 +1,62 @@
+// 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 rpctest
+
+import (
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"sync"
+)
+
+var (
+	// compileMtx guards access to the executable path so that the project is
+	// only compiled once.
+	compileMtx sync.Mutex
+
+	// executablePath is the path to the compiled executable. This is the empty
+	// string until btcd is compiled. This should not be accessed directly;
+	// instead use the function btcdExecutablePath().
+	executablePath string
+)
+
+// btcdExecutablePath returns a path to the btcd executable to be used by
+// rpctests. To ensure the code tests against the most up-to-date version of
+// btcd, this method compiles btcd the first time it is called. After that, the
+// generated binary is used for subsequent test harnesses. The executable file
+// is not cleaned up, but since it lives at a static path in a temp directory,
+// it is not a big deal.
+func btcdExecutablePath() (string, error) {
+	compileMtx.Lock()
+	defer compileMtx.Unlock()
+
+	// If btcd has already been compiled, just use that.
+	if len(executablePath) != 0 {
+		return executablePath, nil
+	}
+
+	testDir, err := baseDir()
+	if err != nil {
+		return "", err
+	}
+
+	// Build btcd and output an executable in a static temp path.
+	outputPath := filepath.Join(testDir, "btcd")
+	if runtime.GOOS == "windows" {
+		outputPath += ".exe"
+	}
+	cmd := exec.Command(
+		"go", "build", "-o", outputPath, "github.com/btcsuite/btcd",
+	)
+	err = cmd.Run()
+	if err != nil {
+		return "", fmt.Errorf("Failed to build btcd: %v", err)
+	}
+
+	// Save executable path so future calls do not recompile.
+	executablePath = outputPath
+	return executablePath, nil
+}

vendor/github.com/btcsuite/btcd/integration/rpctest/doc.go

@@ -0,0 +1,12 @@
+// Package rpctest provides a btcd-specific RPC testing harness crafting and
+// executing integration tests by driving a `btcd` instance via the `RPC`
+// interface. Each instance of an active harness comes equipped with a simple
+// in-memory HD wallet capable of properly syncing to the generated chain,
+// creating new addresses, and crafting fully signed transactions paying to an
+// arbitrary set of outputs.
+//
+// This package was designed specifically to act as an RPC testing harness for
+// `btcd`. However, the constructs presented are general enough to be adapted to
+// any project wishing to programmatically drive a `btcd` instance of its
+// systems/integration tests.
+package rpctest

vendor/github.com/btcsuite/btcd/integration/rpctest/memwallet.go

@@ -0,0 +1,591 @@
+// Copyright (c) 2016-2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package rpctest
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"sync"
+
+	"github.com/btcsuite/btcd/blockchain"
+	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/rpcclient"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+	"github.com/btcsuite/btcutil/hdkeychain"
+)
+
+var (
+	// hdSeed is the BIP 32 seed used by the memWallet to initialize it's
+	// HD root key. This value is hard coded in order to ensure
+	// deterministic behavior across test runs.
+	hdSeed = [chainhash.HashSize]byte{
+		0x79, 0xa6, 0x1a, 0xdb, 0xc6, 0xe5, 0xa2, 0xe1,
+		0x39, 0xd2, 0x71, 0x3a, 0x54, 0x6e, 0xc7, 0xc8,
+		0x75, 0x63, 0x2e, 0x75, 0xf1, 0xdf, 0x9c, 0x3f,
+		0xa6, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	}
+)
+
+// utxo represents an unspent output spendable by the memWallet. The maturity
+// height of the transaction is recorded in order to properly observe the
+// maturity period of direct coinbase outputs.
+type utxo struct {
+	pkScript       []byte
+	value          btcutil.Amount
+	keyIndex       uint32
+	maturityHeight int32
+	isLocked       bool
+}
+
+// isMature returns true if the target utxo is considered "mature" at the
+// passed block height. Otherwise, false is returned.
+func (u *utxo) isMature(height int32) bool {
+	return height >= u.maturityHeight
+}
+
+// chainUpdate encapsulates an update to the current main chain. This struct is
+// used to sync up the memWallet each time a new block is connected to the main
+// chain.
+type chainUpdate struct {
+	blockHeight  int32
+	filteredTxns []*btcutil.Tx
+	isConnect    bool // True if connect, false if disconnect
+}
+
+// undoEntry is functionally the opposite of a chainUpdate. An undoEntry is
+// created for each new block received, then stored in a log in order to
+// properly handle block re-orgs.
+type undoEntry struct {
+	utxosDestroyed map[wire.OutPoint]*utxo
+	utxosCreated   []wire.OutPoint
+}
+
+// memWallet is a simple in-memory wallet whose purpose is to provide basic
+// wallet functionality to the harness. The wallet uses a hard-coded HD key
+// hierarchy which promotes reproducibility between harness test runs.
+type memWallet struct {
+	coinbaseKey  *btcec.PrivateKey
+	coinbaseAddr btcutil.Address
+
+	// hdRoot is the root master private key for the wallet.
+	hdRoot *hdkeychain.ExtendedKey
+
+	// hdIndex is the next available key index offset from the hdRoot.
+	hdIndex uint32
+
+	// currentHeight is the latest height the wallet is known to be synced
+	// to.
+	currentHeight int32
+
+	// addrs tracks all addresses belonging to the wallet. The addresses
+	// are indexed by their keypath from the hdRoot.
+	addrs map[uint32]btcutil.Address
+
+	// utxos is the set of utxos spendable by the wallet.
+	utxos map[wire.OutPoint]*utxo
+
+	// reorgJournal is a map storing an undo entry for each new block
+	// received. Once a block is disconnected, the undo entry for the
+	// particular height is evaluated, thereby rewinding the effect of the
+	// disconnected block on the wallet's set of spendable utxos.
+	reorgJournal map[int32]*undoEntry
+
+	chainUpdates      []*chainUpdate
+	chainUpdateSignal chan struct{}
+	chainMtx          sync.Mutex
+
+	net *chaincfg.Params
+
+	rpc *rpcclient.Client
+
+	sync.RWMutex
+}
+
+// newMemWallet creates and returns a fully initialized instance of the
+// memWallet given a particular blockchain's parameters.
+func newMemWallet(net *chaincfg.Params, harnessID uint32) (*memWallet, error) {
+	// The wallet's final HD seed is: hdSeed || harnessID. This method
+	// ensures that each harness instance uses a deterministic root seed
+	// based on its harness ID.
+	var harnessHDSeed [chainhash.HashSize + 4]byte
+	copy(harnessHDSeed[:], hdSeed[:])
+	binary.BigEndian.PutUint32(harnessHDSeed[:chainhash.HashSize], harnessID)
+
+	hdRoot, err := hdkeychain.NewMaster(harnessHDSeed[:], net)
+	if err != nil {
+		return nil, nil
+	}
+
+	// The first child key from the hd root is reserved as the coinbase
+	// generation address.
+	coinbaseChild, err := hdRoot.Child(0)
+	if err != nil {
+		return nil, err
+	}
+	coinbaseKey, err := coinbaseChild.ECPrivKey()
+	if err != nil {
+		return nil, err
+	}
+	coinbaseAddr, err := keyToAddr(coinbaseKey, net)
+	if err != nil {
+		return nil, err
+	}
+
+	// Track the coinbase generation address to ensure we properly track
+	// newly generated bitcoin we can spend.
+	addrs := make(map[uint32]btcutil.Address)
+	addrs[0] = coinbaseAddr
+
+	return &memWallet{
+		net:               net,
+		coinbaseKey:       coinbaseKey,
+		coinbaseAddr:      coinbaseAddr,
+		hdIndex:           1,
+		hdRoot:            hdRoot,
+		addrs:             addrs,
+		utxos:             make(map[wire.OutPoint]*utxo),
+		chainUpdateSignal: make(chan struct{}),
+		reorgJournal:      make(map[int32]*undoEntry),
+	}, nil
+}
+
+// Start launches all goroutines required for the wallet to function properly.
+func (m *memWallet) Start() {
+	go m.chainSyncer()
+}
+
+// SyncedHeight returns the height the wallet is known to be synced to.
+//
+// This function is safe for concurrent access.
+func (m *memWallet) SyncedHeight() int32 {
+	m.RLock()
+	defer m.RUnlock()
+	return m.currentHeight
+}
+
+// SetRPCClient saves the passed rpc connection to btcd as the wallet's
+// personal rpc connection.
+func (m *memWallet) SetRPCClient(rpcClient *rpcclient.Client) {
+	m.rpc = rpcClient
+}
+
+// IngestBlock is a call-back which is to be triggered each time a new block is
+// connected to the main chain. It queues the update for the chain syncer,
+// calling the private version in sequential order.
+func (m *memWallet) IngestBlock(height int32, header *wire.BlockHeader, filteredTxns []*btcutil.Tx) {
+	// Append this new chain update to the end of the queue of new chain
+	// updates.
+	m.chainMtx.Lock()
+	m.chainUpdates = append(m.chainUpdates, &chainUpdate{height,
+		filteredTxns, true})
+	m.chainMtx.Unlock()
+
+	// Launch a goroutine to signal the chainSyncer that a new update is
+	// available. We do this in a new goroutine in order to avoid blocking
+	// the main loop of the rpc client.
+	go func() {
+		m.chainUpdateSignal <- struct{}{}
+	}()
+}
+
+// ingestBlock updates the wallet's internal utxo state based on the outputs
+// created and destroyed within each block.
+func (m *memWallet) ingestBlock(update *chainUpdate) {
+	// Update the latest synced height, then process each filtered
+	// transaction in the block creating and destroying utxos within
+	// the wallet as a result.
+	m.currentHeight = update.blockHeight
+	undo := &undoEntry{
+		utxosDestroyed: make(map[wire.OutPoint]*utxo),
+	}
+	for _, tx := range update.filteredTxns {
+		mtx := tx.MsgTx()
+		isCoinbase := blockchain.IsCoinBaseTx(mtx)
+		txHash := mtx.TxHash()
+		m.evalOutputs(mtx.TxOut, &txHash, isCoinbase, undo)
+		m.evalInputs(mtx.TxIn, undo)
+	}
+
+	// Finally, record the undo entry for this block so we can
+	// properly update our internal state in response to the block
+	// being re-org'd from the main chain.
+	m.reorgJournal[update.blockHeight] = undo
+}
+
+// chainSyncer is a goroutine dedicated to processing new blocks in order to
+// keep the wallet's utxo state up to date.
+//
+// NOTE: This MUST be run as a goroutine.
+func (m *memWallet) chainSyncer() {
+	var update *chainUpdate
+
+	for range m.chainUpdateSignal {
+		// A new update is available, so pop the new chain update from
+		// the front of the update queue.
+		m.chainMtx.Lock()
+		update = m.chainUpdates[0]
+		m.chainUpdates[0] = nil // Set to nil to prevent GC leak.
+		m.chainUpdates = m.chainUpdates[1:]
+		m.chainMtx.Unlock()
+
+		m.Lock()
+		if update.isConnect {
+			m.ingestBlock(update)
+		} else {
+			m.unwindBlock(update)
+		}
+		m.Unlock()
+	}
+}
+
+// evalOutputs evaluates each of the passed outputs, creating a new matching
+// utxo within the wallet if we're able to spend the output.
+func (m *memWallet) evalOutputs(outputs []*wire.TxOut, txHash *chainhash.Hash,
+	isCoinbase bool, undo *undoEntry) {
+
+	for i, output := range outputs {
+		pkScript := output.PkScript
+
+		// Scan all the addresses we currently control to see if the
+		// output is paying to us.
+		for keyIndex, addr := range m.addrs {
+			pkHash := addr.ScriptAddress()
+			if !bytes.Contains(pkScript, pkHash) {
+				continue
+			}
+
+			// If this is a coinbase output, then we mark the
+			// maturity height at the proper block height in the
+			// future.
+			var maturityHeight int32
+			if isCoinbase {
+				maturityHeight = m.currentHeight + int32(m.net.CoinbaseMaturity)
+			}
+
+			op := wire.OutPoint{Hash: *txHash, Index: uint32(i)}
+			m.utxos[op] = &utxo{
+				value:          btcutil.Amount(output.Value),
+				keyIndex:       keyIndex,
+				maturityHeight: maturityHeight,
+				pkScript:       pkScript,
+			}
+			undo.utxosCreated = append(undo.utxosCreated, op)
+		}
+	}
+}
+
+// evalInputs scans all the passed inputs, destroying any utxos within the
+// wallet which are spent by an input.
+func (m *memWallet) evalInputs(inputs []*wire.TxIn, undo *undoEntry) {
+	for _, txIn := range inputs {
+		op := txIn.PreviousOutPoint
+		oldUtxo, ok := m.utxos[op]
+		if !ok {
+			continue
+		}
+
+		undo.utxosDestroyed[op] = oldUtxo
+		delete(m.utxos, op)
+	}
+}
+
+// UnwindBlock is a call-back which is to be executed each time a block is
+// disconnected from the main chain. It queues the update for the chain syncer,
+// calling the private version in sequential order.
+func (m *memWallet) UnwindBlock(height int32, header *wire.BlockHeader) {
+	// Append this new chain update to the end of the queue of new chain
+	// updates.
+	m.chainMtx.Lock()
+	m.chainUpdates = append(m.chainUpdates, &chainUpdate{height,
+		nil, false})
+	m.chainMtx.Unlock()
+
+	// Launch a goroutine to signal the chainSyncer that a new update is
+	// available. We do this in a new goroutine in order to avoid blocking
+	// the main loop of the rpc client.
+	go func() {
+		m.chainUpdateSignal <- struct{}{}
+	}()
+}
+
+// unwindBlock undoes the effect that a particular block had on the wallet's
+// internal utxo state.
+func (m *memWallet) unwindBlock(update *chainUpdate) {
+	undo := m.reorgJournal[update.blockHeight]
+
+	for _, utxo := range undo.utxosCreated {
+		delete(m.utxos, utxo)
+	}
+
+	for outPoint, utxo := range undo.utxosDestroyed {
+		m.utxos[outPoint] = utxo
+	}
+
+	delete(m.reorgJournal, update.blockHeight)
+}
+
+// newAddress returns a new address from the wallet's hd key chain.  It also
+// loads the address into the RPC client's transaction filter to ensure any
+// transactions that involve it are delivered via the notifications.
+func (m *memWallet) newAddress() (btcutil.Address, error) {
+	index := m.hdIndex
+
+	childKey, err := m.hdRoot.Child(index)
+	if err != nil {
+		return nil, err
+	}
+	privKey, err := childKey.ECPrivKey()
+	if err != nil {
+		return nil, err
+	}
+
+	addr, err := keyToAddr(privKey, m.net)
+	if err != nil {
+		return nil, err
+	}
+
+	err = m.rpc.LoadTxFilter(false, []btcutil.Address{addr}, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	m.addrs[index] = addr
+
+	m.hdIndex++
+
+	return addr, nil
+}
+
+// NewAddress returns a fresh address spendable by the wallet.
+//
+// This function is safe for concurrent access.
+func (m *memWallet) NewAddress() (btcutil.Address, error) {
+	m.Lock()
+	defer m.Unlock()
+
+	return m.newAddress()
+}
+
+// fundTx attempts to fund a transaction sending amt bitcoin. The coins are
+// selected such that the final amount spent pays enough fees as dictated by the
+// passed fee rate. The passed fee rate should be expressed in
+// satoshis-per-byte. The transaction being funded can optionally include a
+// change output indicated by the change boolean.
+//
+// NOTE: The memWallet's mutex must be held when this function is called.
+func (m *memWallet) fundTx(tx *wire.MsgTx, amt btcutil.Amount,
+	feeRate btcutil.Amount, change bool) error {
+
+	const (
+		// spendSize is the largest number of bytes of a sigScript
+		// which spends a p2pkh output: OP_DATA_73 <sig> OP_DATA_33 <pubkey>
+		spendSize = 1 + 73 + 1 + 33
+	)
+
+	var (
+		amtSelected btcutil.Amount
+		txSize      int
+	)
+
+	for outPoint, utxo := range m.utxos {
+		// Skip any outputs that are still currently immature or are
+		// currently locked.
+		if !utxo.isMature(m.currentHeight) || utxo.isLocked {
+			continue
+		}
+
+		amtSelected += utxo.value
+
+		// Add the selected output to the transaction, updating the
+		// current tx size while accounting for the size of the future
+		// sigScript.
+		tx.AddTxIn(wire.NewTxIn(&outPoint, nil, nil))
+		txSize = tx.SerializeSize() + spendSize*len(tx.TxIn)
+
+		// Calculate the fee required for the txn at this point
+		// observing the specified fee rate. If we don't have enough
+		// coins from he current amount selected to pay the fee, then
+		// continue to grab more coins.
+		reqFee := btcutil.Amount(txSize * int(feeRate))
+		if amtSelected-reqFee < amt {
+			continue
+		}
+
+		// If we have any change left over and we should create a change
+		// output, then add an additional output to the transaction
+		// reserved for it.
+		changeVal := amtSelected - amt - reqFee
+		if changeVal > 0 && change {
+			addr, err := m.newAddress()
+			if err != nil {
+				return err
+			}
+			pkScript, err := txscript.PayToAddrScript(addr)
+			if err != nil {
+				return err
+			}
+			changeOutput := &wire.TxOut{
+				Value:    int64(changeVal),
+				PkScript: pkScript,
+			}
+			tx.AddTxOut(changeOutput)
+		}
+
+		return nil
+	}
+
+	// If we've reached this point, then coin selection failed due to an
+	// insufficient amount of coins.
+	return fmt.Errorf("not enough funds for coin selection")
+}
+
+// SendOutputs creates, then sends a transaction paying to the specified output
+// while observing the passed fee rate. The passed fee rate should be expressed
+// in satoshis-per-byte.
+func (m *memWallet) SendOutputs(outputs []*wire.TxOut,
+	feeRate btcutil.Amount) (*chainhash.Hash, error) {
+
+	tx, err := m.CreateTransaction(outputs, feeRate, true)
+	if err != nil {
+		return nil, err
+	}
+
+	return m.rpc.SendRawTransaction(tx, true)
+}
+
+// SendOutputsWithoutChange creates and sends a transaction that pays to the
+// specified outputs while observing the passed fee rate and ignoring a change
+// output. The passed fee rate should be expressed in sat/b.
+func (m *memWallet) SendOutputsWithoutChange(outputs []*wire.TxOut,
+	feeRate btcutil.Amount) (*chainhash.Hash, error) {
+
+	tx, err := m.CreateTransaction(outputs, feeRate, false)
+	if err != nil {
+		return nil, err
+	}
+
+	return m.rpc.SendRawTransaction(tx, true)
+}
+
+// CreateTransaction returns a fully signed transaction paying to the specified
+// outputs while observing the desired fee rate. The passed fee rate should be
+// expressed in satoshis-per-byte. The transaction being created can optionally
+// include a change output indicated by the change boolean.
+//
+// This function is safe for concurrent access.
+func (m *memWallet) CreateTransaction(outputs []*wire.TxOut,
+	feeRate btcutil.Amount, change bool) (*wire.MsgTx, error) {
+
+	m.Lock()
+	defer m.Unlock()
+
+	tx := wire.NewMsgTx(wire.TxVersion)
+
+	// Tally up the total amount to be sent in order to perform coin
+	// selection shortly below.
+	var outputAmt btcutil.Amount
+	for _, output := range outputs {
+		outputAmt += btcutil.Amount(output.Value)
+		tx.AddTxOut(output)
+	}
+
+	// Attempt to fund the transaction with spendable utxos.
+	if err := m.fundTx(tx, outputAmt, feeRate, change); err != nil {
+		return nil, err
+	}
+
+	// Populate all the selected inputs with valid sigScript for spending.
+	// Along the way record all outputs being spent in order to avoid a
+	// potential double spend.
+	spentOutputs := make([]*utxo, 0, len(tx.TxIn))
+	for i, txIn := range tx.TxIn {
+		outPoint := txIn.PreviousOutPoint
+		utxo := m.utxos[outPoint]
+
+		extendedKey, err := m.hdRoot.Child(utxo.keyIndex)
+		if err != nil {
+			return nil, err
+		}
+
+		privKey, err := extendedKey.ECPrivKey()
+		if err != nil {
+			return nil, err
+		}
+
+		sigScript, err := txscript.SignatureScript(tx, i, utxo.pkScript,
+			txscript.SigHashAll, privKey, true)
+		if err != nil {
+			return nil, err
+		}
+
+		txIn.SignatureScript = sigScript
+
+		spentOutputs = append(spentOutputs, utxo)
+	}
+
+	// As these outputs are now being spent by this newly created
+	// transaction, mark the outputs are "locked". This action ensures
+	// these outputs won't be double spent by any subsequent transactions.
+	// These locked outputs can be freed via a call to UnlockOutputs.
+	for _, utxo := range spentOutputs {
+		utxo.isLocked = true
+	}
+
+	return tx, nil
+}
+
+// UnlockOutputs unlocks any outputs which were previously locked due to
+// being selected to fund a transaction via the CreateTransaction method.
+//
+// This function is safe for concurrent access.
+func (m *memWallet) UnlockOutputs(inputs []*wire.TxIn) {
+	m.Lock()
+	defer m.Unlock()
+
+	for _, input := range inputs {
+		utxo, ok := m.utxos[input.PreviousOutPoint]
+		if !ok {
+			continue
+		}
+
+		utxo.isLocked = false
+	}
+}
+
+// ConfirmedBalance returns the confirmed balance of the wallet.
+//
+// This function is safe for concurrent access.
+func (m *memWallet) ConfirmedBalance() btcutil.Amount {
+	m.RLock()
+	defer m.RUnlock()
+
+	var balance btcutil.Amount
+	for _, utxo := range m.utxos {
+		// Prevent any immature or locked outputs from contributing to
+		// the wallet's total confirmed balance.
+		if !utxo.isMature(m.currentHeight) || utxo.isLocked {
+			continue
+		}
+
+		balance += utxo.value
+	}
+
+	return balance
+}
+
+// keyToAddr maps the passed private to corresponding p2pkh address.
+func keyToAddr(key *btcec.PrivateKey, net *chaincfg.Params) (btcutil.Address, error) {
+	serializedKey := key.PubKey().SerializeCompressed()
+	pubKeyAddr, err := btcutil.NewAddressPubKey(serializedKey, net)
+	if err != nil {
+		return nil, err
+	}
+	return pubKeyAddr.AddressPubKeyHash(), nil
+}

vendor/github.com/btcsuite/btcd/integration/rpctest/node.go

@@ -0,0 +1,287 @@
+// Copyright (c) 2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package rpctest
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"time"
+
+	rpc "github.com/btcsuite/btcd/rpcclient"
+	"github.com/btcsuite/btcutil"
+)
+
+// nodeConfig contains all the args, and data required to launch a btcd process
+// and connect the rpc client to it.
+type nodeConfig struct {
+	rpcUser    string
+	rpcPass    string
+	listen     string
+	rpcListen  string
+	rpcConnect string
+	dataDir    string
+	logDir     string
+	profile    string
+	debugLevel string
+	extra      []string
+	prefix     string
+
+	exe          string
+	endpoint     string
+	certFile     string
+	keyFile      string
+	certificates []byte
+}
+
+// newConfig returns a newConfig with all default values.
+func newConfig(prefix, certFile, keyFile string, extra []string) (*nodeConfig, error) {
+	btcdPath, err := btcdExecutablePath()
+	if err != nil {
+		btcdPath = "btcd"
+	}
+
+	a := &nodeConfig{
+		listen:    "127.0.0.1:18555",
+		rpcListen: "127.0.0.1:18556",
+		rpcUser:   "user",
+		rpcPass:   "pass",
+		extra:     extra,
+		prefix:    prefix,
+		exe:       btcdPath,
+		endpoint:  "ws",
+		certFile:  certFile,
+		keyFile:   keyFile,
+	}
+	if err := a.setDefaults(); err != nil {
+		return nil, err
+	}
+	return a, nil
+}
+
+// setDefaults sets the default values of the config. It also creates the
+// temporary data, and log directories which must be cleaned up with a call to
+// cleanup().
+func (n *nodeConfig) setDefaults() error {
+	datadir, err := ioutil.TempDir("", n.prefix+"-data")
+	if err != nil {
+		return err
+	}
+	n.dataDir = datadir
+	logdir, err := ioutil.TempDir("", n.prefix+"-logs")
+	if err != nil {
+		return err
+	}
+	n.logDir = logdir
+	cert, err := ioutil.ReadFile(n.certFile)
+	if err != nil {
+		return err
+	}
+	n.certificates = cert
+	return nil
+}
+
+// arguments returns an array of arguments that be used to launch the btcd
+// process.
+func (n *nodeConfig) arguments() []string {
+	args := []string{}
+	if n.rpcUser != "" {
+		// --rpcuser
+		args = append(args, fmt.Sprintf("--rpcuser=%s", n.rpcUser))
+	}
+	if n.rpcPass != "" {
+		// --rpcpass
+		args = append(args, fmt.Sprintf("--rpcpass=%s", n.rpcPass))
+	}
+	if n.listen != "" {
+		// --listen
+		args = append(args, fmt.Sprintf("--listen=%s", n.listen))
+	}
+	if n.rpcListen != "" {
+		// --rpclisten
+		args = append(args, fmt.Sprintf("--rpclisten=%s", n.rpcListen))
+	}
+	if n.rpcConnect != "" {
+		// --rpcconnect
+		args = append(args, fmt.Sprintf("--rpcconnect=%s", n.rpcConnect))
+	}
+	// --rpccert
+	args = append(args, fmt.Sprintf("--rpccert=%s", n.certFile))
+	// --rpckey
+	args = append(args, fmt.Sprintf("--rpckey=%s", n.keyFile))
+	if n.dataDir != "" {
+		// --datadir
+		args = append(args, fmt.Sprintf("--datadir=%s", n.dataDir))
+	}
+	if n.logDir != "" {
+		// --logdir
+		args = append(args, fmt.Sprintf("--logdir=%s", n.logDir))
+	}
+	if n.profile != "" {
+		// --profile
+		args = append(args, fmt.Sprintf("--profile=%s", n.profile))
+	}
+	if n.debugLevel != "" {
+		// --debuglevel
+		args = append(args, fmt.Sprintf("--debuglevel=%s", n.debugLevel))
+	}
+	args = append(args, n.extra...)
+	return args
+}
+
+// command returns the exec.Cmd which will be used to start the btcd process.
+func (n *nodeConfig) command() *exec.Cmd {
+	return exec.Command(n.exe, n.arguments()...)
+}
+
+// rpcConnConfig returns the rpc connection config that can be used to connect
+// to the btcd process that is launched via Start().
+func (n *nodeConfig) rpcConnConfig() rpc.ConnConfig {
+	return rpc.ConnConfig{
+		Host:                 n.rpcListen,
+		Endpoint:             n.endpoint,
+		User:                 n.rpcUser,
+		Pass:                 n.rpcPass,
+		Certificates:         n.certificates,
+		DisableAutoReconnect: true,
+	}
+}
+
+// String returns the string representation of this nodeConfig.
+func (n *nodeConfig) String() string {
+	return n.prefix
+}
+
+// cleanup removes the tmp data and log directories.
+func (n *nodeConfig) cleanup() error {
+	dirs := []string{
+		n.logDir,
+		n.dataDir,
+	}
+	var err error
+	for _, dir := range dirs {
+		if err = os.RemoveAll(dir); err != nil {
+			log.Printf("Cannot remove dir %s: %v", dir, err)
+		}
+	}
+	return err
+}
+
+// node houses the necessary state required to configure, launch, and manage a
+// btcd process.
+type node struct {
+	config *nodeConfig
+
+	cmd     *exec.Cmd
+	pidFile string
+
+	dataDir string
+}
+
+// newNode creates a new node instance according to the passed config. dataDir
+// will be used to hold a file recording the pid of the launched process, and
+// as the base for the log and data directories for btcd.
+func newNode(config *nodeConfig, dataDir string) (*node, error) {
+	return &node{
+		config:  config,
+		dataDir: dataDir,
+		cmd:     config.command(),
+	}, nil
+}
+
+// start creates a new btcd process, and writes its pid in a file reserved for
+// recording the pid of the launched process. This file can be used to
+// terminate the process in case of a hang, or panic. In the case of a failing
+// test case, or panic, it is important that the process be stopped via stop(),
+// otherwise, it will persist unless explicitly killed.
+func (n *node) start() error {
+	if err := n.cmd.Start(); err != nil {
+		return err
+	}
+
+	pid, err := os.Create(filepath.Join(n.dataDir,
+		fmt.Sprintf("%s.pid", n.config)))
+	if err != nil {
+		return err
+	}
+
+	n.pidFile = pid.Name()
+	if _, err = fmt.Fprintf(pid, "%d\n", n.cmd.Process.Pid); err != nil {
+		return err
+	}
+
+	if err := pid.Close(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// stop interrupts the running btcd process process, and waits until it exits
+// properly. On windows, interrupt is not supported, so a kill signal is used
+// instead
+func (n *node) stop() error {
+	if n.cmd == nil || n.cmd.Process == nil {
+		// return if not properly initialized
+		// or error starting the process
+		return nil
+	}
+	defer n.cmd.Wait()
+	if runtime.GOOS == "windows" {
+		return n.cmd.Process.Signal(os.Kill)
+	}
+	return n.cmd.Process.Signal(os.Interrupt)
+}
+
+// cleanup cleanups process and args files. The file housing the pid of the
+// created process will be deleted, as well as any directories created by the
+// process.
+func (n *node) cleanup() error {
+	if n.pidFile != "" {
+		if err := os.Remove(n.pidFile); err != nil {
+			log.Printf("unable to remove file %s: %v", n.pidFile,
+				err)
+		}
+	}
+
+	return n.config.cleanup()
+}
+
+// shutdown terminates the running btcd process, and cleans up all
+// file/directories created by node.
+func (n *node) shutdown() error {
+	if err := n.stop(); err != nil {
+		return err
+	}
+	if err := n.cleanup(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// genCertPair generates a key/cert pair to the paths provided.
+func genCertPair(certFile, keyFile string) error {
+	org := "rpctest autogenerated cert"
+	validUntil := time.Now().Add(10 * 365 * 24 * time.Hour)
+	cert, key, err := btcutil.NewTLSCertPair(org, validUntil, nil)
+	if err != nil {
+		return err
+	}
+
+	// Write cert and key files.
+	if err = ioutil.WriteFile(certFile, cert, 0666); err != nil {
+		return err
+	}
+	if err = ioutil.WriteFile(keyFile, key, 0600); err != nil {
+		os.Remove(certFile)
+		return err
+	}
+
+	return nil
+}

vendor/github.com/btcsuite/btcd/integration/rpctest/rpc_harness.go

@@ -0,0 +1,500 @@
+// Copyright (c) 2016-2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package rpctest
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net"
+	"os"
+	"path/filepath"
+	"strconv"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/rpcclient"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+)
+
+const (
+	// These constants define the minimum and maximum p2p and rpc port
+	// numbers used by a test harness.  The min port is inclusive while the
+	// max port is exclusive.
+	minPeerPort = 10000
+	maxPeerPort = 35000
+	minRPCPort  = maxPeerPort
+	maxRPCPort  = 60000
+
+	// BlockVersion is the default block version used when generating
+	// blocks.
+	BlockVersion = 4
+)
+
+var (
+	// current number of active test nodes.
+	numTestInstances = 0
+
+	// processID is the process ID of the current running process.  It is
+	// used to calculate ports based upon it when launching an rpc
+	// harnesses.  The intent is to allow multiple process to run in
+	// parallel without port collisions.
+	//
+	// It should be noted however that there is still some small probability
+	// that there will be port collisions either due to other processes
+	// running or simply due to the stars aligning on the process IDs.
+	processID = os.Getpid()
+
+	// testInstances is a private package-level slice used to keep track of
+	// all active test harnesses. This global can be used to perform
+	// various "joins", shutdown several active harnesses after a test,
+	// etc.
+	testInstances = make(map[string]*Harness)
+
+	// Used to protest concurrent access to above declared variables.
+	harnessStateMtx sync.RWMutex
+)
+
+// HarnessTestCase represents a test-case which utilizes an instance of the
+// Harness to exercise functionality.
+type HarnessTestCase func(r *Harness, t *testing.T)
+
+// Harness fully encapsulates an active btcd process to provide a unified
+// platform for creating rpc driven integration tests involving btcd. The
+// active btcd node will typically be run in simnet mode in order to allow for
+// easy generation of test blockchains.  The active btcd process is fully
+// managed by Harness, which handles the necessary initialization, and teardown
+// of the process along with any temporary directories created as a result.
+// Multiple Harness instances may be run concurrently, in order to allow for
+// testing complex scenarios involving multiple nodes. The harness also
+// includes an in-memory wallet to streamline various classes of tests.
+type Harness struct {
+	// ActiveNet is the parameters of the blockchain the Harness belongs
+	// to.
+	ActiveNet *chaincfg.Params
+
+	Node     *rpcclient.Client
+	node     *node
+	handlers *rpcclient.NotificationHandlers
+
+	wallet *memWallet
+
+	testNodeDir    string
+	maxConnRetries int
+	nodeNum        int
+
+	sync.Mutex
+}
+
+// New creates and initializes new instance of the rpc test harness.
+// Optionally, websocket handlers and a specified configuration may be passed.
+// In the case that a nil config is passed, a default configuration will be
+// used.
+//
+// NOTE: This function is safe for concurrent access.
+func New(activeNet *chaincfg.Params, handlers *rpcclient.NotificationHandlers,
+	extraArgs []string) (*Harness, error) {
+
+	harnessStateMtx.Lock()
+	defer harnessStateMtx.Unlock()
+
+	// Add a flag for the appropriate network type based on the provided
+	// chain params.
+	switch activeNet.Net {
+	case wire.MainNet:
+		// No extra flags since mainnet is the default
+	case wire.TestNet3:
+		extraArgs = append(extraArgs, "--testnet")
+	case wire.TestNet:
+		extraArgs = append(extraArgs, "--regtest")
+	case wire.SimNet:
+		extraArgs = append(extraArgs, "--simnet")
+	default:
+		return nil, fmt.Errorf("rpctest.New must be called with one " +
+			"of the supported chain networks")
+	}
+
+	testDir, err := baseDir()
+	if err != nil {
+		return nil, err
+	}
+
+	harnessID := strconv.Itoa(numTestInstances)
+	nodeTestData, err := ioutil.TempDir(testDir, "harness-"+harnessID)
+	if err != nil {
+		return nil, err
+	}
+
+	certFile := filepath.Join(nodeTestData, "rpc.cert")
+	keyFile := filepath.Join(nodeTestData, "rpc.key")
+	if err := genCertPair(certFile, keyFile); err != nil {
+		return nil, err
+	}
+
+	wallet, err := newMemWallet(activeNet, uint32(numTestInstances))
+	if err != nil {
+		return nil, err
+	}
+
+	miningAddr := fmt.Sprintf("--miningaddr=%s", wallet.coinbaseAddr)
+	extraArgs = append(extraArgs, miningAddr)
+
+	config, err := newConfig("rpctest", certFile, keyFile, extraArgs)
+	if err != nil {
+		return nil, err
+	}
+
+	// Generate p2p+rpc listening addresses.
+	config.listen, config.rpcListen = generateListeningAddresses()
+
+	// Create the testing node bounded to the simnet.
+	node, err := newNode(config, nodeTestData)
+	if err != nil {
+		return nil, err
+	}
+
+	nodeNum := numTestInstances
+	numTestInstances++
+
+	if handlers == nil {
+		handlers = &rpcclient.NotificationHandlers{}
+	}
+
+	// If a handler for the OnFilteredBlock{Connected,Disconnected} callback
+	// callback has already been set, then create a wrapper callback which
+	// executes both the currently registered callback and the mem wallet's
+	// callback.
+	if handlers.OnFilteredBlockConnected != nil {
+		obc := handlers.OnFilteredBlockConnected
+		handlers.OnFilteredBlockConnected = func(height int32, header *wire.BlockHeader, filteredTxns []*btcutil.Tx) {
+			wallet.IngestBlock(height, header, filteredTxns)
+			obc(height, header, filteredTxns)
+		}
+	} else {
+		// Otherwise, we can claim the callback ourselves.
+		handlers.OnFilteredBlockConnected = wallet.IngestBlock
+	}
+	if handlers.OnFilteredBlockDisconnected != nil {
+		obd := handlers.OnFilteredBlockDisconnected
+		handlers.OnFilteredBlockDisconnected = func(height int32, header *wire.BlockHeader) {
+			wallet.UnwindBlock(height, header)
+			obd(height, header)
+		}
+	} else {
+		handlers.OnFilteredBlockDisconnected = wallet.UnwindBlock
+	}
+
+	h := &Harness{
+		handlers:       handlers,
+		node:           node,
+		maxConnRetries: 20,
+		testNodeDir:    nodeTestData,
+		ActiveNet:      activeNet,
+		nodeNum:        nodeNum,
+		wallet:         wallet,
+	}
+
+	// Track this newly created test instance within the package level
+	// global map of all active test instances.
+	testInstances[h.testNodeDir] = h
+
+	return h, nil
+}
+
+// SetUp initializes the rpc test state. Initialization includes: starting up a
+// simnet node, creating a websockets client and connecting to the started
+// node, and finally: optionally generating and submitting a testchain with a
+// configurable number of mature coinbase outputs coinbase outputs.
+//
+// NOTE: This method and TearDown should always be called from the same
+// goroutine as they are not concurrent safe.
+func (h *Harness) SetUp(createTestChain bool, numMatureOutputs uint32) error {
+	// Start the btcd node itself. This spawns a new process which will be
+	// managed
+	if err := h.node.start(); err != nil {
+		return err
+	}
+	if err := h.connectRPCClient(); err != nil {
+		return err
+	}
+
+	h.wallet.Start()
+
+	// Filter transactions that pay to the coinbase associated with the
+	// wallet.
+	filterAddrs := []btcutil.Address{h.wallet.coinbaseAddr}
+	if err := h.Node.LoadTxFilter(true, filterAddrs, nil); err != nil {
+		return err
+	}
+
+	// Ensure btcd properly dispatches our registered call-back for each new
+	// block. Otherwise, the memWallet won't function properly.
+	if err := h.Node.NotifyBlocks(); err != nil {
+		return err
+	}
+
+	// Create a test chain with the desired number of mature coinbase
+	// outputs.
+	if createTestChain && numMatureOutputs != 0 {
+		numToGenerate := (uint32(h.ActiveNet.CoinbaseMaturity) +
+			numMatureOutputs)
+		_, err := h.Node.Generate(numToGenerate)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Block until the wallet has fully synced up to the tip of the main
+	// chain.
+	_, height, err := h.Node.GetBestBlock()
+	if err != nil {
+		return err
+	}
+	ticker := time.NewTicker(time.Millisecond * 100)
+	for range ticker.C {
+		walletHeight := h.wallet.SyncedHeight()
+		if walletHeight == height {
+			break
+		}
+	}
+	ticker.Stop()
+
+	return nil
+}
+
+// tearDown stops the running rpc test instance.  All created processes are
+// killed, and temporary directories removed.
+//
+// This function MUST be called with the harness state mutex held (for writes).
+func (h *Harness) tearDown() error {
+	if h.Node != nil {
+		h.Node.Shutdown()
+	}
+
+	if err := h.node.shutdown(); err != nil {
+		return err
+	}
+
+	if err := os.RemoveAll(h.testNodeDir); err != nil {
+		return err
+	}
+
+	delete(testInstances, h.testNodeDir)
+
+	return nil
+}
+
+// TearDown stops the running rpc test instance. All created processes are
+// killed, and temporary directories removed.
+//
+// NOTE: This method and SetUp should always be called from the same goroutine
+// as they are not concurrent safe.
+func (h *Harness) TearDown() error {
+	harnessStateMtx.Lock()
+	defer harnessStateMtx.Unlock()
+
+	return h.tearDown()
+}
+
+// connectRPCClient attempts to establish an RPC connection to the created btcd
+// process belonging to this Harness instance. If the initial connection
+// attempt fails, this function will retry h.maxConnRetries times, backing off
+// the time between subsequent attempts. If after h.maxConnRetries attempts,
+// we're not able to establish a connection, this function returns with an
+// error.
+func (h *Harness) connectRPCClient() error {
+	var client *rpcclient.Client
+	var err error
+
+	rpcConf := h.node.config.rpcConnConfig()
+	for i := 0; i < h.maxConnRetries; i++ {
+		if client, err = rpcclient.New(&rpcConf, h.handlers); err != nil {
+			time.Sleep(time.Duration(i) * 50 * time.Millisecond)
+			continue
+		}
+		break
+	}
+
+	if client == nil {
+		return fmt.Errorf("connection timeout")
+	}
+
+	h.Node = client
+	h.wallet.SetRPCClient(client)
+	return nil
+}
+
+// NewAddress returns a fresh address spendable by the Harness' internal
+// wallet.
+//
+// This function is safe for concurrent access.
+func (h *Harness) NewAddress() (btcutil.Address, error) {
+	return h.wallet.NewAddress()
+}
+
+// ConfirmedBalance returns the confirmed balance of the Harness' internal
+// wallet.
+//
+// This function is safe for concurrent access.
+func (h *Harness) ConfirmedBalance() btcutil.Amount {
+	return h.wallet.ConfirmedBalance()
+}
+
+// SendOutputs creates, signs, and finally broadcasts a transaction spending
+// the harness' available mature coinbase outputs creating new outputs
+// according to targetOutputs.
+//
+// This function is safe for concurrent access.
+func (h *Harness) SendOutputs(targetOutputs []*wire.TxOut,
+	feeRate btcutil.Amount) (*chainhash.Hash, error) {
+
+	return h.wallet.SendOutputs(targetOutputs, feeRate)
+}
+
+// SendOutputsWithoutChange creates and sends a transaction that pays to the
+// specified outputs while observing the passed fee rate and ignoring a change
+// output. The passed fee rate should be expressed in sat/b.
+//
+// This function is safe for concurrent access.
+func (h *Harness) SendOutputsWithoutChange(targetOutputs []*wire.TxOut,
+	feeRate btcutil.Amount) (*chainhash.Hash, error) {
+
+	return h.wallet.SendOutputsWithoutChange(targetOutputs, feeRate)
+}
+
+// CreateTransaction returns a fully signed transaction paying to the specified
+// outputs while observing the desired fee rate. The passed fee rate should be
+// expressed in satoshis-per-byte. The transaction being created can optionally
+// include a change output indicated by the change boolean. Any unspent outputs
+// selected as inputs for the crafted transaction are marked as unspendable in
+// order to avoid potential double-spends by future calls to this method. If the
+// created transaction is cancelled for any reason then the selected inputs MUST
+// be freed via a call to UnlockOutputs. Otherwise, the locked inputs won't be
+// returned to the pool of spendable outputs.
+//
+// This function is safe for concurrent access.
+func (h *Harness) CreateTransaction(targetOutputs []*wire.TxOut,
+	feeRate btcutil.Amount, change bool) (*wire.MsgTx, error) {
+
+	return h.wallet.CreateTransaction(targetOutputs, feeRate, change)
+}
+
+// UnlockOutputs unlocks any outputs which were previously marked as
+// unspendabe due to being selected to fund a transaction via the
+// CreateTransaction method.
+//
+// This function is safe for concurrent access.
+func (h *Harness) UnlockOutputs(inputs []*wire.TxIn) {
+	h.wallet.UnlockOutputs(inputs)
+}
+
+// RPCConfig returns the harnesses current rpc configuration. This allows other
+// potential RPC clients created within tests to connect to a given test
+// harness instance.
+func (h *Harness) RPCConfig() rpcclient.ConnConfig {
+	return h.node.config.rpcConnConfig()
+}
+
+// P2PAddress returns the harness' P2P listening address. This allows potential
+// peers (such as SPV peers) created within tests to connect to a given test
+// harness instance.
+func (h *Harness) P2PAddress() string {
+	return h.node.config.listen
+}
+
+// GenerateAndSubmitBlock creates a block whose contents include the passed
+// transactions and submits it to the running simnet node. For generating
+// blocks with only a coinbase tx, callers can simply pass nil instead of
+// transactions to be mined. Additionally, a custom block version can be set by
+// the caller. A blockVersion of -1 indicates that the current default block
+// version should be used. An uninitialized time.Time should be used for the
+// blockTime parameter if one doesn't wish to set a custom time.
+//
+// This function is safe for concurrent access.
+func (h *Harness) GenerateAndSubmitBlock(txns []*btcutil.Tx, blockVersion int32,
+	blockTime time.Time) (*btcutil.Block, error) {
+	return h.GenerateAndSubmitBlockWithCustomCoinbaseOutputs(txns,
+		blockVersion, blockTime, []wire.TxOut{})
+}
+
+// GenerateAndSubmitBlockWithCustomCoinbaseOutputs creates a block whose
+// contents include the passed coinbase outputs and transactions and submits
+// it to the running simnet node. For generating blocks with only a coinbase tx,
+// callers can simply pass nil instead of transactions to be mined.
+// Additionally, a custom block version can be set by the caller. A blockVersion
+// of -1 indicates that the current default block version should be used. An
+// uninitialized time.Time should be used for the blockTime parameter if one
+// doesn't wish to set a custom time. The mineTo list of outputs will be added
+// to the coinbase; this is not checked for correctness until the block is
+// submitted; thus, it is the caller's responsibility to ensure that the outputs
+// are correct. If the list is empty, the coinbase reward goes to the wallet
+// managed by the Harness.
+//
+// This function is safe for concurrent access.
+func (h *Harness) GenerateAndSubmitBlockWithCustomCoinbaseOutputs(
+	txns []*btcutil.Tx, blockVersion int32, blockTime time.Time,
+	mineTo []wire.TxOut) (*btcutil.Block, error) {
+
+	h.Lock()
+	defer h.Unlock()
+
+	if blockVersion == -1 {
+		blockVersion = BlockVersion
+	}
+
+	prevBlockHash, prevBlockHeight, err := h.Node.GetBestBlock()
+	if err != nil {
+		return nil, err
+	}
+	mBlock, err := h.Node.GetBlock(prevBlockHash)
+	if err != nil {
+		return nil, err
+	}
+	prevBlock := btcutil.NewBlock(mBlock)
+	prevBlock.SetHeight(prevBlockHeight)
+
+	// Create a new block including the specified transactions
+	newBlock, err := CreateBlock(prevBlock, txns, blockVersion,
+		blockTime, h.wallet.coinbaseAddr, mineTo, h.ActiveNet)
+	if err != nil {
+		return nil, err
+	}
+
+	// Submit the block to the simnet node.
+	if err := h.Node.SubmitBlock(newBlock, nil); err != nil {
+		return nil, err
+	}
+
+	return newBlock, nil
+}
+
+// generateListeningAddresses returns two strings representing listening
+// addresses designated for the current rpc test. If there haven't been any
+// test instances created, the default ports are used. Otherwise, in order to
+// support multiple test nodes running at once, the p2p and rpc port are
+// incremented after each initialization.
+func generateListeningAddresses() (string, string) {
+	localhost := "127.0.0.1"
+
+	portString := func(minPort, maxPort int) string {
+		port := minPort + numTestInstances + ((20 * processID) %
+			(maxPort - minPort))
+		return strconv.Itoa(port)
+	}
+
+	p2p := net.JoinHostPort(localhost, portString(minPeerPort, maxPeerPort))
+	rpc := net.JoinHostPort(localhost, portString(minRPCPort, maxRPCPort))
+	return p2p, rpc
+}
+
+// baseDir is the directory path of the temp directory for all rpctest files.
+func baseDir() (string, error) {
+	dirPath := filepath.Join(os.TempDir(), "btcd", "rpctest")
+	err := os.MkdirAll(dirPath, 0755)
+	return dirPath, err
+}

vendor/github.com/btcsuite/btcd/integration/rpctest/utils.go

@@ -0,0 +1,164 @@
+// Copyright (c) 2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package rpctest
+
+import (
+	"reflect"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/rpcclient"
+)
+
+// JoinType is an enum representing a particular type of "node join". A node
+// join is a synchronization tool used to wait until a subset of nodes have a
+// consistent state with respect to an attribute.
+type JoinType uint8
+
+const (
+	// Blocks is a JoinType which waits until all nodes share the same
+	// block height.
+	Blocks JoinType = iota
+
+	// Mempools is a JoinType which blocks until all nodes have identical
+	// mempool.
+	Mempools
+)
+
+// JoinNodes is a synchronization tool used to block until all passed nodes are
+// fully synced with respect to an attribute. This function will block for a
+// period of time, finally returning once all nodes are synced according to the
+// passed JoinType. This function be used to to ensure all active test
+// harnesses are at a consistent state before proceeding to an assertion or
+// check within rpc tests.
+func JoinNodes(nodes []*Harness, joinType JoinType) error {
+	switch joinType {
+	case Blocks:
+		return syncBlocks(nodes)
+	case Mempools:
+		return syncMempools(nodes)
+	}
+	return nil
+}
+
+// syncMempools blocks until all nodes have identical mempools.
+func syncMempools(nodes []*Harness) error {
+	poolsMatch := false
+
+retry:
+	for !poolsMatch {
+		firstPool, err := nodes[0].Node.GetRawMempool()
+		if err != nil {
+			return err
+		}
+
+		// If all nodes have an identical mempool with respect to the
+		// first node, then we're done. Otherwise, drop back to the top
+		// of the loop and retry after a short wait period.
+		for _, node := range nodes[1:] {
+			nodePool, err := node.Node.GetRawMempool()
+			if err != nil {
+				return err
+			}
+
+			if !reflect.DeepEqual(firstPool, nodePool) {
+				time.Sleep(time.Millisecond * 100)
+				continue retry
+			}
+		}
+
+		poolsMatch = true
+	}
+
+	return nil
+}
+
+// syncBlocks blocks until all nodes report the same best chain.
+func syncBlocks(nodes []*Harness) error {
+	blocksMatch := false
+
+retry:
+	for !blocksMatch {
+		var prevHash *chainhash.Hash
+		var prevHeight int32
+		for _, node := range nodes {
+			blockHash, blockHeight, err := node.Node.GetBestBlock()
+			if err != nil {
+				return err
+			}
+			if prevHash != nil && (*blockHash != *prevHash ||
+				blockHeight != prevHeight) {
+
+				time.Sleep(time.Millisecond * 100)
+				continue retry
+			}
+			prevHash, prevHeight = blockHash, blockHeight
+		}
+
+		blocksMatch = true
+	}
+
+	return nil
+}
+
+// ConnectNode establishes a new peer-to-peer connection between the "from"
+// harness and the "to" harness.  The connection made is flagged as persistent,
+// therefore in the case of disconnects, "from" will attempt to reestablish a
+// connection to the "to" harness.
+func ConnectNode(from *Harness, to *Harness) error {
+	peerInfo, err := from.Node.GetPeerInfo()
+	if err != nil {
+		return err
+	}
+	numPeers := len(peerInfo)
+
+	targetAddr := to.node.config.listen
+	if err := from.Node.AddNode(targetAddr, rpcclient.ANAdd); err != nil {
+		return err
+	}
+
+	// Block until a new connection has been established.
+	peerInfo, err = from.Node.GetPeerInfo()
+	if err != nil {
+		return err
+	}
+	for len(peerInfo) <= numPeers {
+		peerInfo, err = from.Node.GetPeerInfo()
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// TearDownAll tears down all active test harnesses.
+func TearDownAll() error {
+	harnessStateMtx.Lock()
+	defer harnessStateMtx.Unlock()
+
+	for _, harness := range testInstances {
+		if err := harness.tearDown(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// ActiveHarnesses returns a slice of all currently active test harnesses. A
+// test harness if considered "active" if it has been created, but not yet torn
+// down.
+func ActiveHarnesses() []*Harness {
+	harnessStateMtx.RLock()
+	defer harnessStateMtx.RUnlock()
+
+	activeNodes := make([]*Harness, 0, len(testInstances))
+	for _, harness := range testInstances {
+		activeNodes = append(activeNodes, harness)
+	}
+
+	return activeNodes
+}