Add vendor dir (#16) (#4)

* Add vendor dir so builds dont require dep

* Pin specific version go-eth version

vendor/github.com/btcsuite/btcd/blockchain/README.md

@@ -0,0 +1,103 @@
+blockchain
+==========
+
+[![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/blockchain)
+
+Package blockchain implements bitcoin block handling and chain selection rules.
+The test coverage is currently only around 60%, but will be increasing over
+time. 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.  Package blockchain is licensed under the liberal ISC license.
+
+There is an associated blog post about the release of this package
+[here](https://blog.conformal.com/btcchain-the-bitcoin-chain-package-from-bctd/).
+
+This package has intentionally been designed so it can be used as a standalone
+package for any projects needing to handle processing of blocks into the bitcoin
+block chain.
+
+## Installation and Updating
+
+```bash
+$ go get -u github.com/btcsuite/btcd/blockchain
+```
+
+## Bitcoin Chain Processing Overview
+
+Before a block is allowed into the block chain, it must go through an intensive
+series of validation rules.  The following list serves as a general outline of
+those rules to provide some intuition into what is going on under the hood, but
+is by no means exhaustive:
+
+ - Reject duplicate blocks
+ - Perform a series of sanity checks on the block and its transactions such as
+   verifying proof of work, timestamps, number and character of transactions,
+   transaction amounts, script complexity, and merkle root calculations
+ - Compare the block against predetermined checkpoints for expected timestamps
+   and difficulty based on elapsed time since the checkpoint
+ - Save the most recent orphan blocks for a limited time in case their parent
+   blocks become available
+ - Stop processing if the block is an orphan as the rest of the processing
+   depends on the block's position within the block chain
+ - Perform a series of more thorough checks that depend on the block's position
+   within the block chain such as verifying block difficulties adhere to
+   difficulty retarget rules, timestamps are after the median of the last
+   several blocks, all transactions are finalized, checkpoint blocks match, and
+   block versions are in line with the previous blocks
+ - Determine how the block fits into the chain and perform different actions
+   accordingly in order to ensure any side chains which have higher difficulty
+   than the main chain become the new main chain
+ - When a block is being connected to the main chain (either through
+   reorganization of a side chain to the main chain or just extending the
+   main chain), perform further checks on the block's transactions such as
+   verifying transaction duplicates, script complexity for the combination of
+   connected scripts, coinbase maturity, double spends, and connected
+   transaction values
+ - Run the transaction scripts to verify the spender is allowed to spend the
+   coins
+ - Insert the block into the block database
+
+## Examples
+
+* [ProcessBlock Example](http://godoc.org/github.com/btcsuite/btcd/blockchain#example-BlockChain-ProcessBlock)  
+  Demonstrates how to create a new chain instance and use ProcessBlock to
+  attempt to attempt add a block to the chain.  This example intentionally
+  attempts to insert a duplicate genesis block to illustrate how an invalid
+  block is handled.
+
+* [CompactToBig Example](http://godoc.org/github.com/btcsuite/btcd/blockchain#example-CompactToBig)  
+  Demonstrates how to convert the compact "bits" in a block header which
+  represent the target difficulty to a big integer and display it using the
+  typical hex notation.
+
+* [BigToCompact Example](http://godoc.org/github.com/btcsuite/btcd/blockchain#example-BigToCompact)  
+  Demonstrates how to convert how to convert a target difficulty into the
+  compact "bits" in a block header which represent that target difficulty.
+
+## 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 blockchain is licensed under the [copyfree](http://copyfree.org) ISC
+License.

vendor/github.com/btcsuite/btcd/blockchain/accept.go

@@ -0,0 +1,91 @@
+// 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 blockchain
+
+import (
+	"fmt"
+
+	"github.com/btcsuite/btcd/database"
+	"github.com/btcsuite/btcutil"
+)
+
+// maybeAcceptBlock potentially accepts a block into the block chain and, if
+// accepted, returns whether or not it is on the main chain.  It performs
+// several validation checks which depend on its position within the block chain
+// before adding it.  The block is expected to have already gone through
+// ProcessBlock before calling this function with it.
+//
+// The flags are also passed to checkBlockContext and connectBestChain.  See
+// their documentation for how the flags modify their behavior.
+//
+// This function MUST be called with the chain state lock held (for writes).
+func (b *BlockChain) maybeAcceptBlock(block *btcutil.Block, flags BehaviorFlags) (bool, error) {
+	// The height of this block is one more than the referenced previous
+	// block.
+	prevHash := &block.MsgBlock().Header.PrevBlock
+	prevNode := b.index.LookupNode(prevHash)
+	if prevNode == nil {
+		str := fmt.Sprintf("previous block %s is unknown", prevHash)
+		return false, ruleError(ErrPreviousBlockUnknown, str)
+	} else if b.index.NodeStatus(prevNode).KnownInvalid() {
+		str := fmt.Sprintf("previous block %s is known to be invalid", prevHash)
+		return false, ruleError(ErrInvalidAncestorBlock, str)
+	}
+
+	blockHeight := prevNode.height + 1
+	block.SetHeight(blockHeight)
+
+	// The block must pass all of the validation rules which depend on the
+	// position of the block within the block chain.
+	err := b.checkBlockContext(block, prevNode, flags)
+	if err != nil {
+		return false, err
+	}
+
+	// Insert the block into the database if it's not already there.  Even
+	// though it is possible the block will ultimately fail to connect, it
+	// has already passed all proof-of-work and validity tests which means
+	// it would be prohibitively expensive for an attacker to fill up the
+	// disk with a bunch of blocks that fail to connect.  This is necessary
+	// since it allows block download to be decoupled from the much more
+	// expensive connection logic.  It also has some other nice properties
+	// such as making blocks that never become part of the main chain or
+	// blocks that fail to connect available for further analysis.
+	err = b.db.Update(func(dbTx database.Tx) error {
+		return dbMaybeStoreBlock(dbTx, block)
+	})
+	if err != nil {
+		return false, err
+	}
+
+	// Create a new block node for the block and add it to the in-memory
+	// block chain (could be either a side chain or the main chain).
+	blockHeader := &block.MsgBlock().Header
+	newNode := newBlockNode(blockHeader, blockHeight)
+	newNode.status = statusDataStored
+	if prevNode != nil {
+		newNode.parent = prevNode
+		newNode.height = blockHeight
+		newNode.workSum.Add(prevNode.workSum, newNode.workSum)
+	}
+	b.index.AddNode(newNode)
+
+	// Connect the passed block to the chain while respecting proper chain
+	// selection according to the chain with the most proof of work.  This
+	// also handles validation of the transaction scripts.
+	isMainChain, err := b.connectBestChain(newNode, block, flags)
+	if err != nil {
+		return false, err
+	}
+
+	// Notify the caller that the new block was accepted into the block
+	// chain.  The caller would typically want to react by relaying the
+	// inventory to other peers.
+	b.chainLock.Unlock()
+	b.sendNotification(NTBlockAccepted, block)
+	b.chainLock.Lock()
+
+	return isMainChain, nil
+}

vendor/github.com/btcsuite/btcd/blockchain/bench_test.go

@@ -0,0 +1,31 @@
+// 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.
+
+package blockchain
+
+import (
+	"testing"
+
+	"github.com/btcsuite/btcutil"
+)
+
+// BenchmarkIsCoinBase performs a simple benchmark against the IsCoinBase
+// function.
+func BenchmarkIsCoinBase(b *testing.B) {
+	tx, _ := btcutil.NewBlock(&Block100000).Tx(1)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		IsCoinBase(tx)
+	}
+}
+
+// BenchmarkIsCoinBaseTx performs a simple benchmark against the IsCoinBaseTx
+// function.
+func BenchmarkIsCoinBaseTx(b *testing.B) {
+	tx := Block100000.Transactions[1]
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		IsCoinBaseTx(tx)
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/blockindex.go

@@ -0,0 +1,307 @@
+// Copyright (c) 2015-2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package blockchain
+
+import (
+	"math/big"
+	"sort"
+	"sync"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/database"
+	"github.com/btcsuite/btcd/wire"
+)
+
+// blockStatus is a bit field representing the validation state of the block.
+type blockStatus byte
+
+const (
+	// statusDataStored indicates that the block's payload is stored on disk.
+	statusDataStored blockStatus = 1 << iota
+
+	// statusValid indicates that the block has been fully validated.
+	statusValid
+
+	// statusValidateFailed indicates that the block has failed validation.
+	statusValidateFailed
+
+	// statusInvalidAncestor indicates that one of the block's ancestors has
+	// has failed validation, thus the block is also invalid.
+	statusInvalidAncestor
+
+	// statusNone indicates that the block has no validation state flags set.
+	//
+	// NOTE: This must be defined last in order to avoid influencing iota.
+	statusNone blockStatus = 0
+)
+
+// HaveData returns whether the full block data is stored in the database. This
+// will return false for a block node where only the header is downloaded or
+// kept.
+func (status blockStatus) HaveData() bool {
+	return status&statusDataStored != 0
+}
+
+// KnownValid returns whether the block is known to be valid. This will return
+// false for a valid block that has not been fully validated yet.
+func (status blockStatus) KnownValid() bool {
+	return status&statusValid != 0
+}
+
+// KnownInvalid returns whether the block is known to be invalid. This may be
+// because the block itself failed validation or any of its ancestors is
+// invalid. This will return false for invalid blocks that have not been proven
+// invalid yet.
+func (status blockStatus) KnownInvalid() bool {
+	return status&(statusValidateFailed|statusInvalidAncestor) != 0
+}
+
+// blockNode represents a block within the block chain and is primarily used to
+// aid in selecting the best chain to be the main chain.  The main chain is
+// stored into the block database.
+type blockNode struct {
+	// NOTE: Additions, deletions, or modifications to the order of the
+	// definitions in this struct should not be changed without considering
+	// how it affects alignment on 64-bit platforms.  The current order is
+	// specifically crafted to result in minimal padding.  There will be
+	// hundreds of thousands of these in memory, so a few extra bytes of
+	// padding adds up.
+
+	// parent is the parent block for this node.
+	parent *blockNode
+
+	// hash is the double sha 256 of the block.
+	hash chainhash.Hash
+
+	// workSum is the total amount of work in the chain up to and including
+	// this node.
+	workSum *big.Int
+
+	// height is the position in the block chain.
+	height int32
+
+	// Some fields from block headers to aid in best chain selection and
+	// reconstructing headers from memory.  These must be treated as
+	// immutable and are intentionally ordered to avoid padding on 64-bit
+	// platforms.
+	version    int32
+	bits       uint32
+	nonce      uint32
+	timestamp  int64
+	merkleRoot chainhash.Hash
+
+	// status is a bitfield representing the validation state of the block. The
+	// status field, unlike the other fields, may be written to and so should
+	// only be accessed using the concurrent-safe NodeStatus method on
+	// blockIndex once the node has been added to the global index.
+	status blockStatus
+}
+
+// initBlockNode initializes a block node from the given header and height.  The
+// node is completely disconnected from the chain and the workSum value is just
+// the work for the passed block.  The work sum must be updated accordingly when
+// the node is inserted into a chain.
+//
+// This function is NOT safe for concurrent access.  It must only be called when
+// initially creating a node.
+func initBlockNode(node *blockNode, blockHeader *wire.BlockHeader, height int32) {
+	*node = blockNode{
+		hash:       blockHeader.BlockHash(),
+		workSum:    CalcWork(blockHeader.Bits),
+		height:     height,
+		version:    blockHeader.Version,
+		bits:       blockHeader.Bits,
+		nonce:      blockHeader.Nonce,
+		timestamp:  blockHeader.Timestamp.Unix(),
+		merkleRoot: blockHeader.MerkleRoot,
+	}
+}
+
+// newBlockNode returns a new block node for the given block header.  It is
+// completely disconnected from the chain and the workSum value is just the work
+// for the passed block.  The work sum must be updated accordingly when the node
+// is inserted into a chain.
+func newBlockNode(blockHeader *wire.BlockHeader, height int32) *blockNode {
+	var node blockNode
+	initBlockNode(&node, blockHeader, height)
+	return &node
+}
+
+// Header constructs a block header from the node and returns it.
+//
+// This function is safe for concurrent access.
+func (node *blockNode) Header() wire.BlockHeader {
+	// No lock is needed because all accessed fields are immutable.
+	prevHash := zeroHash
+	if node.parent != nil {
+		prevHash = &node.parent.hash
+	}
+	return wire.BlockHeader{
+		Version:    node.version,
+		PrevBlock:  *prevHash,
+		MerkleRoot: node.merkleRoot,
+		Timestamp:  time.Unix(node.timestamp, 0),
+		Bits:       node.bits,
+		Nonce:      node.nonce,
+	}
+}
+
+// Ancestor returns the ancestor block node at the provided height by following
+// the chain backwards from this node.  The returned block will be nil when a
+// height is requested that is after the height of the passed node or is less
+// than zero.
+//
+// This function is safe for concurrent access.
+func (node *blockNode) Ancestor(height int32) *blockNode {
+	if height < 0 || height > node.height {
+		return nil
+	}
+
+	n := node
+	for ; n != nil && n.height != height; n = n.parent {
+		// Intentionally left blank
+	}
+
+	return n
+}
+
+// RelativeAncestor returns the ancestor block node a relative 'distance' blocks
+// before this node.  This is equivalent to calling Ancestor with the node's
+// height minus provided distance.
+//
+// This function is safe for concurrent access.
+func (node *blockNode) RelativeAncestor(distance int32) *blockNode {
+	return node.Ancestor(node.height - distance)
+}
+
+// CalcPastMedianTime calculates the median time of the previous few blocks
+// prior to, and including, the block node.
+//
+// This function is safe for concurrent access.
+func (node *blockNode) CalcPastMedianTime() time.Time {
+	// Create a slice of the previous few block timestamps used to calculate
+	// the median per the number defined by the constant medianTimeBlocks.
+	timestamps := make([]int64, medianTimeBlocks)
+	numNodes := 0
+	iterNode := node
+	for i := 0; i < medianTimeBlocks && iterNode != nil; i++ {
+		timestamps[i] = iterNode.timestamp
+		numNodes++
+
+		iterNode = iterNode.parent
+	}
+
+	// Prune the slice to the actual number of available timestamps which
+	// will be fewer than desired near the beginning of the block chain
+	// and sort them.
+	timestamps = timestamps[:numNodes]
+	sort.Sort(timeSorter(timestamps))
+
+	// NOTE: The consensus rules incorrectly calculate the median for even
+	// numbers of blocks.  A true median averages the middle two elements
+	// for a set with an even number of elements in it.   Since the constant
+	// for the previous number of blocks to be used is odd, this is only an
+	// issue for a few blocks near the beginning of the chain.  I suspect
+	// this is an optimization even though the result is slightly wrong for
+	// a few of the first blocks since after the first few blocks, there
+	// will always be an odd number of blocks in the set per the constant.
+	//
+	// This code follows suit to ensure the same rules are used, however, be
+	// aware that should the medianTimeBlocks constant ever be changed to an
+	// even number, this code will be wrong.
+	medianTimestamp := timestamps[numNodes/2]
+	return time.Unix(medianTimestamp, 0)
+}
+
+// blockIndex provides facilities for keeping track of an in-memory index of the
+// block chain.  Although the name block chain suggests a single chain of
+// blocks, it is actually a tree-shaped structure where any node can have
+// multiple children.  However, there can only be one active branch which does
+// indeed form a chain from the tip all the way back to the genesis block.
+type blockIndex struct {
+	// The following fields are set when the instance is created and can't
+	// be changed afterwards, so there is no need to protect them with a
+	// separate mutex.
+	db          database.DB
+	chainParams *chaincfg.Params
+
+	sync.RWMutex
+	index map[chainhash.Hash]*blockNode
+}
+
+// newBlockIndex returns a new empty instance of a block index.  The index will
+// be dynamically populated as block nodes are loaded from the database and
+// manually added.
+func newBlockIndex(db database.DB, chainParams *chaincfg.Params) *blockIndex {
+	return &blockIndex{
+		db:          db,
+		chainParams: chainParams,
+		index:       make(map[chainhash.Hash]*blockNode),
+	}
+}
+
+// HaveBlock returns whether or not the block index contains the provided hash.
+//
+// This function is safe for concurrent access.
+func (bi *blockIndex) HaveBlock(hash *chainhash.Hash) bool {
+	bi.RLock()
+	_, hasBlock := bi.index[*hash]
+	bi.RUnlock()
+	return hasBlock
+}
+
+// LookupNode returns the block node identified by the provided hash.  It will
+// return nil if there is no entry for the hash.
+//
+// This function is safe for concurrent access.
+func (bi *blockIndex) LookupNode(hash *chainhash.Hash) *blockNode {
+	bi.RLock()
+	node := bi.index[*hash]
+	bi.RUnlock()
+	return node
+}
+
+// AddNode adds the provided node to the block index.  Duplicate entries are not
+// checked so it is up to caller to avoid adding them.
+//
+// This function is safe for concurrent access.
+func (bi *blockIndex) AddNode(node *blockNode) {
+	bi.Lock()
+	bi.index[node.hash] = node
+	bi.Unlock()
+}
+
+// NodeStatus provides concurrent-safe access to the status field of a node.
+//
+// This function is safe for concurrent access.
+func (bi *blockIndex) NodeStatus(node *blockNode) blockStatus {
+	bi.RLock()
+	status := node.status
+	bi.RUnlock()
+	return status
+}
+
+// SetStatusFlags flips the provided status flags on the block node to on,
+// regardless of whether they were on or off previously. This does not unset any
+// flags currently on.
+//
+// This function is safe for concurrent access.
+func (bi *blockIndex) SetStatusFlags(node *blockNode, flags blockStatus) {
+	bi.Lock()
+	node.status |= flags
+	bi.Unlock()
+}
+
+// UnsetStatusFlags flips the provided status flags on the block node to off,
+// regardless of whether they were on or off previously.
+//
+// This function is safe for concurrent access.
+func (bi *blockIndex) UnsetStatusFlags(node *blockNode, flags blockStatus) {
+	bi.Lock()
+	node.status &^= flags
+	bi.Unlock()
+}

vendor/github.com/btcsuite/btcd/blockchain/chain_test.go

@@ -0,0 +1,802 @@
+// 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 blockchain
+
+import (
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+)
+
+// TestHaveBlock tests the HaveBlock API to ensure proper functionality.
+func TestHaveBlock(t *testing.T) {
+	// Load up blocks such that there is a side chain.
+	// (genesis block) -> 1 -> 2 -> 3 -> 4
+	//                          \-> 3a
+	testFiles := []string{
+		"blk_0_to_4.dat.bz2",
+		"blk_3A.dat.bz2",
+	}
+
+	var blocks []*btcutil.Block
+	for _, file := range testFiles {
+		blockTmp, err := loadBlocks(file)
+		if err != nil {
+			t.Errorf("Error loading file: %v\n", err)
+			return
+		}
+		blocks = append(blocks, blockTmp...)
+	}
+
+	// Create a new database and chain instance to run tests against.
+	chain, teardownFunc, err := chainSetup("haveblock",
+		&chaincfg.MainNetParams)
+	if err != nil {
+		t.Errorf("Failed to setup chain instance: %v", err)
+		return
+	}
+	defer teardownFunc()
+
+	// Since we're not dealing with the real block chain, set the coinbase
+	// maturity to 1.
+	chain.TstSetCoinbaseMaturity(1)
+
+	for i := 1; i < len(blocks); i++ {
+		_, isOrphan, err := chain.ProcessBlock(blocks[i], BFNone)
+		if err != nil {
+			t.Errorf("ProcessBlock fail on block %v: %v\n", i, err)
+			return
+		}
+		if isOrphan {
+			t.Errorf("ProcessBlock incorrectly returned block %v "+
+				"is an orphan\n", i)
+			return
+		}
+	}
+
+	// Insert an orphan block.
+	_, isOrphan, err := chain.ProcessBlock(btcutil.NewBlock(&Block100000),
+		BFNone)
+	if err != nil {
+		t.Errorf("Unable to process block: %v", err)
+		return
+	}
+	if !isOrphan {
+		t.Errorf("ProcessBlock indicated block is an not orphan when " +
+			"it should be\n")
+		return
+	}
+
+	tests := []struct {
+		hash string
+		want bool
+	}{
+		// Genesis block should be present (in the main chain).
+		{hash: chaincfg.MainNetParams.GenesisHash.String(), want: true},
+
+		// Block 3a should be present (on a side chain).
+		{hash: "00000000474284d20067a4d33f6a02284e6ef70764a3a26d6a5b9df52ef663dd", want: true},
+
+		// Block 100000 should be present (as an orphan).
+		{hash: "000000000003ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506", want: true},
+
+		// Random hashes should not be available.
+		{hash: "123", want: false},
+	}
+
+	for i, test := range tests {
+		hash, err := chainhash.NewHashFromStr(test.hash)
+		if err != nil {
+			t.Errorf("NewHashFromStr: %v", err)
+			continue
+		}
+
+		result, err := chain.HaveBlock(hash)
+		if err != nil {
+			t.Errorf("HaveBlock #%d unexpected error: %v", i, err)
+			return
+		}
+		if result != test.want {
+			t.Errorf("HaveBlock #%d got %v want %v", i, result,
+				test.want)
+			continue
+		}
+	}
+}
+
+// TestCalcSequenceLock tests the LockTimeToSequence function, and the
+// CalcSequenceLock method of a Chain instance. The tests exercise several
+// combinations of inputs to the CalcSequenceLock function in order to ensure
+// the returned SequenceLocks are correct for each test instance.
+func TestCalcSequenceLock(t *testing.T) {
+	netParams := &chaincfg.SimNetParams
+
+	// We need to activate CSV in order to test the processing logic, so
+	// manually craft the block version that's used to signal the soft-fork
+	// activation.
+	csvBit := netParams.Deployments[chaincfg.DeploymentCSV].BitNumber
+	blockVersion := int32(0x20000000 | (uint32(1) << csvBit))
+
+	// Generate enough synthetic blocks to activate CSV.
+	chain := newFakeChain(netParams)
+	node := chain.bestChain.Tip()
+	blockTime := node.Header().Timestamp
+	numBlocksToActivate := (netParams.MinerConfirmationWindow * 3)
+	for i := uint32(0); i < numBlocksToActivate; i++ {
+		blockTime = blockTime.Add(time.Second)
+		node = newFakeNode(node, blockVersion, 0, blockTime)
+		chain.index.AddNode(node)
+		chain.bestChain.SetTip(node)
+	}
+
+	// Create a utxo view with a fake utxo for the inputs used in the
+	// transactions created below.  This utxo is added such that it has an
+	// age of 4 blocks.
+	targetTx := btcutil.NewTx(&wire.MsgTx{
+		TxOut: []*wire.TxOut{{
+			PkScript: nil,
+			Value:    10,
+		}},
+	})
+	utxoView := NewUtxoViewpoint()
+	utxoView.AddTxOuts(targetTx, int32(numBlocksToActivate)-4)
+	utxoView.SetBestHash(&node.hash)
+
+	// Create a utxo that spends the fake utxo created above for use in the
+	// transactions created in the tests.  It has an age of 4 blocks.  Note
+	// that the sequence lock heights are always calculated from the same
+	// point of view that they were originally calculated from for a given
+	// utxo.  That is to say, the height prior to it.
+	utxo := wire.OutPoint{
+		Hash:  *targetTx.Hash(),
+		Index: 0,
+	}
+	prevUtxoHeight := int32(numBlocksToActivate) - 4
+
+	// Obtain the median time past from the PoV of the input created above.
+	// The MTP for the input is the MTP from the PoV of the block *prior*
+	// to the one that included it.
+	medianTime := node.RelativeAncestor(5).CalcPastMedianTime().Unix()
+
+	// The median time calculated from the PoV of the best block in the
+	// test chain.  For unconfirmed inputs, this value will be used since
+	// the MTP will be calculated from the PoV of the yet-to-be-mined
+	// block.
+	nextMedianTime := node.CalcPastMedianTime().Unix()
+	nextBlockHeight := int32(numBlocksToActivate) + 1
+
+	// Add an additional transaction which will serve as our unconfirmed
+	// output.
+	unConfTx := &wire.MsgTx{
+		TxOut: []*wire.TxOut{{
+			PkScript: nil,
+			Value:    5,
+		}},
+	}
+	unConfUtxo := wire.OutPoint{
+		Hash:  unConfTx.TxHash(),
+		Index: 0,
+	}
+
+	// Adding a utxo with a height of 0x7fffffff indicates that the output
+	// is currently unmined.
+	utxoView.AddTxOuts(btcutil.NewTx(unConfTx), 0x7fffffff)
+
+	tests := []struct {
+		tx      *wire.MsgTx
+		view    *UtxoViewpoint
+		mempool bool
+		want    *SequenceLock
+	}{
+		// A transaction of version one should disable sequence locks
+		// as the new sequence number semantics only apply to
+		// transactions version 2 or higher.
+		{
+			tx: &wire.MsgTx{
+				Version: 1,
+				TxIn: []*wire.TxIn{{
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(false, 3),
+				}},
+			},
+			view: utxoView,
+			want: &SequenceLock{
+				Seconds:     -1,
+				BlockHeight: -1,
+			},
+		},
+		// A transaction with a single input with max sequence number.
+		// This sequence number has the high bit set, so sequence locks
+		// should be disabled.
+		{
+			tx: &wire.MsgTx{
+				Version: 2,
+				TxIn: []*wire.TxIn{{
+					PreviousOutPoint: utxo,
+					Sequence:         wire.MaxTxInSequenceNum,
+				}},
+			},
+			view: utxoView,
+			want: &SequenceLock{
+				Seconds:     -1,
+				BlockHeight: -1,
+			},
+		},
+		// A transaction with a single input whose lock time is
+		// expressed in seconds.  However, the specified lock time is
+		// below the required floor for time based lock times since
+		// they have time granularity of 512 seconds.  As a result, the
+		// seconds lock-time should be just before the median time of
+		// the targeted block.
+		{
+			tx: &wire.MsgTx{
+				Version: 2,
+				TxIn: []*wire.TxIn{{
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(true, 2),
+				}},
+			},
+			view: utxoView,
+			want: &SequenceLock{
+				Seconds:     medianTime - 1,
+				BlockHeight: -1,
+			},
+		},
+		// A transaction with a single input whose lock time is
+		// expressed in seconds.  The number of seconds should be 1023
+		// seconds after the median past time of the last block in the
+		// chain.
+		{
+			tx: &wire.MsgTx{
+				Version: 2,
+				TxIn: []*wire.TxIn{{
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(true, 1024),
+				}},
+			},
+			view: utxoView,
+			want: &SequenceLock{
+				Seconds:     medianTime + 1023,
+				BlockHeight: -1,
+			},
+		},
+		// A transaction with multiple inputs.  The first input has a
+		// lock time expressed in seconds.  The second input has a
+		// sequence lock in blocks with a value of 4.  The last input
+		// has a sequence number with a value of 5, but has the disable
+		// bit set.  So the first lock should be selected as it's the
+		// latest lock that isn't disabled.
+		{
+			tx: &wire.MsgTx{
+				Version: 2,
+				TxIn: []*wire.TxIn{{
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(true, 2560),
+				}, {
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(false, 4),
+				}, {
+					PreviousOutPoint: utxo,
+					Sequence: LockTimeToSequence(false, 5) |
+						wire.SequenceLockTimeDisabled,
+				}},
+			},
+			view: utxoView,
+			want: &SequenceLock{
+				Seconds:     medianTime + (5 << wire.SequenceLockTimeGranularity) - 1,
+				BlockHeight: prevUtxoHeight + 3,
+			},
+		},
+		// Transaction with a single input.  The input's sequence number
+		// encodes a relative lock-time in blocks (3 blocks).  The
+		// sequence lock should  have a value of -1 for seconds, but a
+		// height of 2 meaning it can be included at height 3.
+		{
+			tx: &wire.MsgTx{
+				Version: 2,
+				TxIn: []*wire.TxIn{{
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(false, 3),
+				}},
+			},
+			view: utxoView,
+			want: &SequenceLock{
+				Seconds:     -1,
+				BlockHeight: prevUtxoHeight + 2,
+			},
+		},
+		// A transaction with two inputs with lock times expressed in
+		// seconds.  The selected sequence lock value for seconds should
+		// be the time further in the future.
+		{
+			tx: &wire.MsgTx{
+				Version: 2,
+				TxIn: []*wire.TxIn{{
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(true, 5120),
+				}, {
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(true, 2560),
+				}},
+			},
+			view: utxoView,
+			want: &SequenceLock{
+				Seconds:     medianTime + (10 << wire.SequenceLockTimeGranularity) - 1,
+				BlockHeight: -1,
+			},
+		},
+		// A transaction with two inputs with lock times expressed in
+		// blocks.  The selected sequence lock value for blocks should
+		// be the height further in the future, so a height of 10
+		// indicating it can be included at height 11.
+		{
+			tx: &wire.MsgTx{
+				Version: 2,
+				TxIn: []*wire.TxIn{{
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(false, 1),
+				}, {
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(false, 11),
+				}},
+			},
+			view: utxoView,
+			want: &SequenceLock{
+				Seconds:     -1,
+				BlockHeight: prevUtxoHeight + 10,
+			},
+		},
+		// A transaction with multiple inputs.  Two inputs are time
+		// based, and the other two are block based. The lock lying
+		// further into the future for both inputs should be chosen.
+		{
+			tx: &wire.MsgTx{
+				Version: 2,
+				TxIn: []*wire.TxIn{{
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(true, 2560),
+				}, {
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(true, 6656),
+				}, {
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(false, 3),
+				}, {
+					PreviousOutPoint: utxo,
+					Sequence:         LockTimeToSequence(false, 9),
+				}},
+			},
+			view: utxoView,
+			want: &SequenceLock{
+				Seconds:     medianTime + (13 << wire.SequenceLockTimeGranularity) - 1,
+				BlockHeight: prevUtxoHeight + 8,
+			},
+		},
+		// A transaction with a single unconfirmed input.  As the input
+		// is confirmed, the height of the input should be interpreted
+		// as the height of the *next* block.  So, a 2 block relative
+		// lock means the sequence lock should be for 1 block after the
+		// *next* block height, indicating it can be included 2 blocks
+		// after that.
+		{
+			tx: &wire.MsgTx{
+				Version: 2,
+				TxIn: []*wire.TxIn{{
+					PreviousOutPoint: unConfUtxo,
+					Sequence:         LockTimeToSequence(false, 2),
+				}},
+			},
+			view:    utxoView,
+			mempool: true,
+			want: &SequenceLock{
+				Seconds:     -1,
+				BlockHeight: nextBlockHeight + 1,
+			},
+		},
+		// A transaction with a single unconfirmed input.  The input has
+		// a time based lock, so the lock time should be based off the
+		// MTP of the *next* block.
+		{
+			tx: &wire.MsgTx{
+				Version: 2,
+				TxIn: []*wire.TxIn{{
+					PreviousOutPoint: unConfUtxo,
+					Sequence:         LockTimeToSequence(true, 1024),
+				}},
+			},
+			view:    utxoView,
+			mempool: true,
+			want: &SequenceLock{
+				Seconds:     nextMedianTime + 1023,
+				BlockHeight: -1,
+			},
+		},
+	}
+
+	t.Logf("Running %v SequenceLock tests", len(tests))
+	for i, test := range tests {
+		utilTx := btcutil.NewTx(test.tx)
+		seqLock, err := chain.CalcSequenceLock(utilTx, test.view, test.mempool)
+		if err != nil {
+			t.Fatalf("test #%d, unable to calc sequence lock: %v", i, err)
+		}
+
+		if seqLock.Seconds != test.want.Seconds {
+			t.Fatalf("test #%d got %v seconds want %v seconds",
+				i, seqLock.Seconds, test.want.Seconds)
+		}
+		if seqLock.BlockHeight != test.want.BlockHeight {
+			t.Fatalf("test #%d got height of %v want height of %v ",
+				i, seqLock.BlockHeight, test.want.BlockHeight)
+		}
+	}
+}
+
+// nodeHashes is a convenience function that returns the hashes for all of the
+// passed indexes of the provided nodes.  It is used to construct expected hash
+// slices in the tests.
+func nodeHashes(nodes []*blockNode, indexes ...int) []chainhash.Hash {
+	hashes := make([]chainhash.Hash, 0, len(indexes))
+	for _, idx := range indexes {
+		hashes = append(hashes, nodes[idx].hash)
+	}
+	return hashes
+}
+
+// nodeHeaders is a convenience function that returns the headers for all of
+// the passed indexes of the provided nodes.  It is used to construct expected
+// located headers in the tests.
+func nodeHeaders(nodes []*blockNode, indexes ...int) []wire.BlockHeader {
+	headers := make([]wire.BlockHeader, 0, len(indexes))
+	for _, idx := range indexes {
+		headers = append(headers, nodes[idx].Header())
+	}
+	return headers
+}
+
+// TestLocateInventory ensures that locating inventory via the LocateHeaders and
+// LocateBlocks functions behaves as expected.
+func TestLocateInventory(t *testing.T) {
+	// Construct a synthetic block chain with a block index consisting of
+	// the following structure.
+	// 	genesis -> 1 -> 2 -> ... -> 15 -> 16  -> 17  -> 18
+	// 	                              \-> 16a -> 17a
+	tip := tstTip
+	chain := newFakeChain(&chaincfg.MainNetParams)
+	branch0Nodes := chainedNodes(chain.bestChain.Genesis(), 18)
+	branch1Nodes := chainedNodes(branch0Nodes[14], 2)
+	for _, node := range branch0Nodes {
+		chain.index.AddNode(node)
+	}
+	for _, node := range branch1Nodes {
+		chain.index.AddNode(node)
+	}
+	chain.bestChain.SetTip(tip(branch0Nodes))
+
+	// Create chain views for different branches of the overall chain to
+	// simulate a local and remote node on different parts of the chain.
+	localView := newChainView(tip(branch0Nodes))
+	remoteView := newChainView(tip(branch1Nodes))
+
+	// Create a chain view for a completely unrelated block chain to
+	// simulate a remote node on a totally different chain.
+	unrelatedBranchNodes := chainedNodes(nil, 5)
+	unrelatedView := newChainView(tip(unrelatedBranchNodes))
+
+	tests := []struct {
+		name       string
+		locator    BlockLocator       // locator for requested inventory
+		hashStop   chainhash.Hash     // stop hash for locator
+		maxAllowed uint32             // max to locate, 0 = wire const
+		headers    []wire.BlockHeader // expected located headers
+		hashes     []chainhash.Hash   // expected located hashes
+	}{
+		{
+			// Empty block locators and unknown stop hash.  No
+			// inventory should be located.
+			name:     "no locators, no stop",
+			locator:  nil,
+			hashStop: chainhash.Hash{},
+			headers:  nil,
+			hashes:   nil,
+		},
+		{
+			// Empty block locators and stop hash in side chain.
+			// The expected result is the requested block.
+			name:     "no locators, stop in side",
+			locator:  nil,
+			hashStop: tip(branch1Nodes).hash,
+			headers:  nodeHeaders(branch1Nodes, 1),
+			hashes:   nodeHashes(branch1Nodes, 1),
+		},
+		{
+			// Empty block locators and stop hash in main chain.
+			// The expected result is the requested block.
+			name:     "no locators, stop in main",
+			locator:  nil,
+			hashStop: branch0Nodes[12].hash,
+			headers:  nodeHeaders(branch0Nodes, 12),
+			hashes:   nodeHashes(branch0Nodes, 12),
+		},
+		{
+			// Locators based on remote being on side chain and a
+			// stop hash local node doesn't know about.  The
+			// expected result is the blocks after the fork point in
+			// the main chain and the stop hash has no effect.
+			name:     "remote side chain, unknown stop",
+			locator:  remoteView.BlockLocator(nil),
+			hashStop: chainhash.Hash{0x01},
+			headers:  nodeHeaders(branch0Nodes, 15, 16, 17),
+			hashes:   nodeHashes(branch0Nodes, 15, 16, 17),
+		},
+		{
+			// Locators based on remote being on side chain and a
+			// stop hash in side chain.  The expected result is the
+			// blocks after the fork point in the main chain and the
+			// stop hash has no effect.
+			name:     "remote side chain, stop in side",
+			locator:  remoteView.BlockLocator(nil),
+			hashStop: tip(branch1Nodes).hash,
+			headers:  nodeHeaders(branch0Nodes, 15, 16, 17),
+			hashes:   nodeHashes(branch0Nodes, 15, 16, 17),
+		},
+		{
+			// Locators based on remote being on side chain and a
+			// stop hash in main chain, but before fork point.  The
+			// expected result is the blocks after the fork point in
+			// the main chain and the stop hash has no effect.
+			name:     "remote side chain, stop in main before",
+			locator:  remoteView.BlockLocator(nil),
+			hashStop: branch0Nodes[13].hash,
+			headers:  nodeHeaders(branch0Nodes, 15, 16, 17),
+			hashes:   nodeHashes(branch0Nodes, 15, 16, 17),
+		},
+		{
+			// Locators based on remote being on side chain and a
+			// stop hash in main chain, but exactly at the fork
+			// point.  The expected result is the blocks after the
+			// fork point in the main chain and the stop hash has no
+			// effect.
+			name:     "remote side chain, stop in main exact",
+			locator:  remoteView.BlockLocator(nil),
+			hashStop: branch0Nodes[14].hash,
+			headers:  nodeHeaders(branch0Nodes, 15, 16, 17),
+			hashes:   nodeHashes(branch0Nodes, 15, 16, 17),
+		},
+		{
+			// Locators based on remote being on side chain and a
+			// stop hash in main chain just after the fork point.
+			// The expected result is the blocks after the fork
+			// point in the main chain up to and including the stop
+			// hash.
+			name:     "remote side chain, stop in main after",
+			locator:  remoteView.BlockLocator(nil),
+			hashStop: branch0Nodes[15].hash,
+			headers:  nodeHeaders(branch0Nodes, 15),
+			hashes:   nodeHashes(branch0Nodes, 15),
+		},
+		{
+			// Locators based on remote being on side chain and a
+			// stop hash in main chain some time after the fork
+			// point.  The expected result is the blocks after the
+			// fork point in the main chain up to and including the
+			// stop hash.
+			name:     "remote side chain, stop in main after more",
+			locator:  remoteView.BlockLocator(nil),
+			hashStop: branch0Nodes[16].hash,
+			headers:  nodeHeaders(branch0Nodes, 15, 16),
+			hashes:   nodeHashes(branch0Nodes, 15, 16),
+		},
+		{
+			// Locators based on remote being on main chain in the
+			// past and a stop hash local node doesn't know about.
+			// The expected result is the blocks after the known
+			// point in the main chain and the stop hash has no
+			// effect.
+			name:     "remote main chain past, unknown stop",
+			locator:  localView.BlockLocator(branch0Nodes[12]),
+			hashStop: chainhash.Hash{0x01},
+			headers:  nodeHeaders(branch0Nodes, 13, 14, 15, 16, 17),
+			hashes:   nodeHashes(branch0Nodes, 13, 14, 15, 16, 17),
+		},
+		{
+			// Locators based on remote being on main chain in the
+			// past and a stop hash in a side chain.  The expected
+			// result is the blocks after the known point in the
+			// main chain and the stop hash has no effect.
+			name:     "remote main chain past, stop in side",
+			locator:  localView.BlockLocator(branch0Nodes[12]),
+			hashStop: tip(branch1Nodes).hash,
+			headers:  nodeHeaders(branch0Nodes, 13, 14, 15, 16, 17),
+			hashes:   nodeHashes(branch0Nodes, 13, 14, 15, 16, 17),
+		},
+		{
+			// Locators based on remote being on main chain in the
+			// past and a stop hash in the main chain before that
+			// point.  The expected result is the blocks after the
+			// known point in the main chain and the stop hash has
+			// no effect.
+			name:     "remote main chain past, stop in main before",
+			locator:  localView.BlockLocator(branch0Nodes[12]),
+			hashStop: branch0Nodes[11].hash,
+			headers:  nodeHeaders(branch0Nodes, 13, 14, 15, 16, 17),
+			hashes:   nodeHashes(branch0Nodes, 13, 14, 15, 16, 17),
+		},
+		{
+			// Locators based on remote being on main chain in the
+			// past and a stop hash in the main chain exactly at that
+			// point.  The expected result is the blocks after the
+			// known point in the main chain and the stop hash has
+			// no effect.
+			name:     "remote main chain past, stop in main exact",
+			locator:  localView.BlockLocator(branch0Nodes[12]),
+			hashStop: branch0Nodes[12].hash,
+			headers:  nodeHeaders(branch0Nodes, 13, 14, 15, 16, 17),
+			hashes:   nodeHashes(branch0Nodes, 13, 14, 15, 16, 17),
+		},
+		{
+			// Locators based on remote being on main chain in the
+			// past and a stop hash in the main chain just after
+			// that point.  The expected result is the blocks after
+			// the known point in the main chain and the stop hash
+			// has no effect.
+			name:     "remote main chain past, stop in main after",
+			locator:  localView.BlockLocator(branch0Nodes[12]),
+			hashStop: branch0Nodes[13].hash,
+			headers:  nodeHeaders(branch0Nodes, 13),
+			hashes:   nodeHashes(branch0Nodes, 13),
+		},
+		{
+			// Locators based on remote being on main chain in the
+			// past and a stop hash in the main chain some time
+			// after that point.  The expected result is the blocks
+			// after the known point in the main chain and the stop
+			// hash has no effect.
+			name:     "remote main chain past, stop in main after more",
+			locator:  localView.BlockLocator(branch0Nodes[12]),
+			hashStop: branch0Nodes[15].hash,
+			headers:  nodeHeaders(branch0Nodes, 13, 14, 15),
+			hashes:   nodeHashes(branch0Nodes, 13, 14, 15),
+		},
+		{
+			// Locators based on remote being at exactly the same
+			// point in the main chain and a stop hash local node
+			// doesn't know about.  The expected result is no
+			// located inventory.
+			name:     "remote main chain same, unknown stop",
+			locator:  localView.BlockLocator(nil),
+			hashStop: chainhash.Hash{0x01},
+			headers:  nil,
+			hashes:   nil,
+		},
+		{
+			// Locators based on remote being at exactly the same
+			// point in the main chain and a stop hash at exactly
+			// the same point.  The expected result is no located
+			// inventory.
+			name:     "remote main chain same, stop same point",
+			locator:  localView.BlockLocator(nil),
+			hashStop: tip(branch0Nodes).hash,
+			headers:  nil,
+			hashes:   nil,
+		},
+		{
+			// Locators from remote that don't include any blocks
+			// the local node knows.  This would happen if the
+			// remote node is on a completely separate chain that
+			// isn't rooted with the same genesis block.  The
+			// expected result is the blocks after the genesis
+			// block.
+			name:     "remote unrelated chain",
+			locator:  unrelatedView.BlockLocator(nil),
+			hashStop: chainhash.Hash{},
+			headers: nodeHeaders(branch0Nodes, 0, 1, 2, 3, 4, 5, 6,
+				7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17),
+			hashes: nodeHashes(branch0Nodes, 0, 1, 2, 3, 4, 5, 6,
+				7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17),
+		},
+		{
+			// Locators from remote for second block in main chain
+			// and no stop hash, but with an overridden max limit.
+			// The expected result is the blocks after the second
+			// block limited by the max.
+			name:       "remote genesis",
+			locator:    locatorHashes(branch0Nodes, 0),
+			hashStop:   chainhash.Hash{},
+			maxAllowed: 3,
+			headers:    nodeHeaders(branch0Nodes, 1, 2, 3),
+			hashes:     nodeHashes(branch0Nodes, 1, 2, 3),
+		},
+		{
+			// Poorly formed locator.
+			//
+			// Locator from remote that only includes a single
+			// block on a side chain the local node knows.  The
+			// expected result is the blocks after the genesis
+			// block since even though the block is known, it is on
+			// a side chain and there are no more locators to find
+			// the fork point.
+			name:     "weak locator, single known side block",
+			locator:  locatorHashes(branch1Nodes, 1),
+			hashStop: chainhash.Hash{},
+			headers: nodeHeaders(branch0Nodes, 0, 1, 2, 3, 4, 5, 6,
+				7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17),
+			hashes: nodeHashes(branch0Nodes, 0, 1, 2, 3, 4, 5, 6,
+				7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17),
+		},
+		{
+			// Poorly formed locator.
+			//
+			// Locator from remote that only includes multiple
+			// blocks on a side chain the local node knows however
+			// none in the main chain.  The expected result is the
+			// blocks after the genesis block since even though the
+			// blocks are known, they are all on a side chain and
+			// there are no more locators to find the fork point.
+			name:     "weak locator, multiple known side blocks",
+			locator:  locatorHashes(branch1Nodes, 1),
+			hashStop: chainhash.Hash{},
+			headers: nodeHeaders(branch0Nodes, 0, 1, 2, 3, 4, 5, 6,
+				7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17),
+			hashes: nodeHashes(branch0Nodes, 0, 1, 2, 3, 4, 5, 6,
+				7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17),
+		},
+		{
+			// Poorly formed locator.
+			//
+			// Locator from remote that only includes multiple
+			// blocks on a side chain the local node knows however
+			// none in the main chain but includes a stop hash in
+			// the main chain.  The expected result is the blocks
+			// after the genesis block up to the stop hash since
+			// even though the blocks are known, they are all on a
+			// side chain and there are no more locators to find the
+			// fork point.
+			name:     "weak locator, multiple known side blocks, stop in main",
+			locator:  locatorHashes(branch1Nodes, 1),
+			hashStop: branch0Nodes[5].hash,
+			headers:  nodeHeaders(branch0Nodes, 0, 1, 2, 3, 4, 5),
+			hashes:   nodeHashes(branch0Nodes, 0, 1, 2, 3, 4, 5),
+		},
+	}
+	for _, test := range tests {
+		// Ensure the expected headers are located.
+		var headers []wire.BlockHeader
+		if test.maxAllowed != 0 {
+			// Need to use the unexported function to override the
+			// max allowed for headers.
+			chain.chainLock.RLock()
+			headers = chain.locateHeaders(test.locator,
+				&test.hashStop, test.maxAllowed)
+			chain.chainLock.RUnlock()
+		} else {
+			headers = chain.LocateHeaders(test.locator,
+				&test.hashStop)
+		}
+		if !reflect.DeepEqual(headers, test.headers) {
+			t.Errorf("%s: unxpected headers -- got %v, want %v",
+				test.name, headers, test.headers)
+			continue
+		}
+
+		// Ensure the expected block hashes are located.
+		maxAllowed := uint32(wire.MaxBlocksPerMsg)
+		if test.maxAllowed != 0 {
+			maxAllowed = test.maxAllowed
+		}
+		hashes := chain.LocateBlocks(test.locator, &test.hashStop,
+			maxAllowed)
+		if !reflect.DeepEqual(hashes, test.hashes) {
+			t.Errorf("%s: unxpected hashes -- got %v, want %v",
+				test.name, hashes, test.hashes)
+			continue
+		}
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/chainview.go

@@ -0,0 +1,423 @@
+// 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 blockchain
+
+import (
+	"sync"
+)
+
+// approxNodesPerWeek is an approximation of the number of new blocks there are
+// in a week on average.
+const approxNodesPerWeek = 6 * 24 * 7
+
+// log2FloorMasks defines the masks to use when quickly calculating
+// floor(log2(x)) in a constant log2(32) = 5 steps, where x is a uint32, using
+// shifts.  They are derived from (2^(2^x) - 1) * (2^(2^x)), for x in 4..0.
+var log2FloorMasks = []uint32{0xffff0000, 0xff00, 0xf0, 0xc, 0x2}
+
+// fastLog2Floor calculates and returns floor(log2(x)) in a constant 5 steps.
+func fastLog2Floor(n uint32) uint8 {
+	rv := uint8(0)
+	exponent := uint8(16)
+	for i := 0; i < 5; i++ {
+		if n&log2FloorMasks[i] != 0 {
+			rv += exponent
+			n >>= exponent
+		}
+		exponent >>= 1
+	}
+	return rv
+}
+
+// chainView provides a flat view of a specific branch of the block chain from
+// its tip back to the genesis block and provides various convenience functions
+// for comparing chains.
+//
+// For example, assume a block chain with a side chain as depicted below:
+//   genesis -> 1 -> 2 -> 3 -> 4  -> 5 ->  6  -> 7  -> 8
+//                         \-> 4a -> 5a -> 6a
+//
+// The chain view for the branch ending in 6a consists of:
+//   genesis -> 1 -> 2 -> 3 -> 4a -> 5a -> 6a
+type chainView struct {
+	mtx   sync.Mutex
+	nodes []*blockNode
+}
+
+// newChainView returns a new chain view for the given tip block node.  Passing
+// nil as the tip will result in a chain view that is not initialized.  The tip
+// can be updated at any time via the setTip function.
+func newChainView(tip *blockNode) *chainView {
+	// The mutex is intentionally not held since this is a constructor.
+	var c chainView
+	c.setTip(tip)
+	return &c
+}
+
+// genesis returns the genesis block for the chain view.  This only differs from
+// the exported version in that it is up to the caller to ensure the lock is
+// held.
+//
+// This function MUST be called with the view mutex locked (for reads).
+func (c *chainView) genesis() *blockNode {
+	if len(c.nodes) == 0 {
+		return nil
+	}
+
+	return c.nodes[0]
+}
+
+// Genesis returns the genesis block for the chain view.
+//
+// This function is safe for concurrent access.
+func (c *chainView) Genesis() *blockNode {
+	c.mtx.Lock()
+	genesis := c.genesis()
+	c.mtx.Unlock()
+	return genesis
+}
+
+// tip returns the current tip block node for the chain view.  It will return
+// nil if there is no tip.  This only differs from the exported version in that
+// it is up to the caller to ensure the lock is held.
+//
+// This function MUST be called with the view mutex locked (for reads).
+func (c *chainView) tip() *blockNode {
+	if len(c.nodes) == 0 {
+		return nil
+	}
+
+	return c.nodes[len(c.nodes)-1]
+}
+
+// Tip returns the current tip block node for the chain view.  It will return
+// nil if there is no tip.
+//
+// This function is safe for concurrent access.
+func (c *chainView) Tip() *blockNode {
+	c.mtx.Lock()
+	tip := c.tip()
+	c.mtx.Unlock()
+	return tip
+}
+
+// setTip sets the chain view to use the provided block node as the current tip
+// and ensures the view is consistent by populating it with the nodes obtained
+// by walking backwards all the way to genesis block as necessary.  Further
+// calls will only perform the minimum work needed, so switching between chain
+// tips is efficient.  This only differs from the exported version in that it is
+// up to the caller to ensure the lock is held.
+//
+// This function MUST be called with the view mutex locked (for writes).
+func (c *chainView) setTip(node *blockNode) {
+	if node == nil {
+		// Keep the backing array around for potential future use.
+		c.nodes = c.nodes[:0]
+		return
+	}
+
+	// Create or resize the slice that will hold the block nodes to the
+	// provided tip height.  When creating the slice, it is created with
+	// some additional capacity for the underlying array as append would do
+	// in order to reduce overhead when extending the chain later.  As long
+	// as the underlying array already has enough capacity, simply expand or
+	// contract the slice accordingly.  The additional capacity is chosen
+	// such that the array should only have to be extended about once a
+	// week.
+	needed := node.height + 1
+	if int32(cap(c.nodes)) < needed {
+		nodes := make([]*blockNode, needed, needed+approxNodesPerWeek)
+		copy(nodes, c.nodes)
+		c.nodes = nodes
+	} else {
+		prevLen := int32(len(c.nodes))
+		c.nodes = c.nodes[0:needed]
+		for i := prevLen; i < needed; i++ {
+			c.nodes[i] = nil
+		}
+	}
+
+	for node != nil && c.nodes[node.height] != node {
+		c.nodes[node.height] = node
+		node = node.parent
+	}
+}
+
+// SetTip sets the chain view to use the provided block node as the current tip
+// and ensures the view is consistent by populating it with the nodes obtained
+// by walking backwards all the way to genesis block as necessary.  Further
+// calls will only perform the minimum work needed, so switching between chain
+// tips is efficient.
+//
+// This function is safe for concurrent access.
+func (c *chainView) SetTip(node *blockNode) {
+	c.mtx.Lock()
+	c.setTip(node)
+	c.mtx.Unlock()
+}
+
+// height returns the height of the tip of the chain view.  It will return -1 if
+// there is no tip (which only happens if the chain view has not been
+// initialized).  This only differs from the exported version in that it is up
+// to the caller to ensure the lock is held.
+//
+// This function MUST be called with the view mutex locked (for reads).
+func (c *chainView) height() int32 {
+	return int32(len(c.nodes) - 1)
+}
+
+// Height returns the height of the tip of the chain view.  It will return -1 if
+// there is no tip (which only happens if the chain view has not been
+// initialized).
+//
+// This function is safe for concurrent access.
+func (c *chainView) Height() int32 {
+	c.mtx.Lock()
+	height := c.height()
+	c.mtx.Unlock()
+	return height
+}
+
+// nodeByHeight returns the block node at the specified height.  Nil will be
+// returned if the height does not exist.  This only differs from the exported
+// version in that it is up to the caller to ensure the lock is held.
+//
+// This function MUST be called with the view mutex locked (for reads).
+func (c *chainView) nodeByHeight(height int32) *blockNode {
+	if height < 0 || height >= int32(len(c.nodes)) {
+		return nil
+	}
+
+	return c.nodes[height]
+}
+
+// NodeByHeight returns the block node at the specified height.  Nil will be
+// returned if the height does not exist.
+//
+// This function is safe for concurrent access.
+func (c *chainView) NodeByHeight(height int32) *blockNode {
+	c.mtx.Lock()
+	node := c.nodeByHeight(height)
+	c.mtx.Unlock()
+	return node
+}
+
+// Equals returns whether or not two chain views are the same.  Uninitialized
+// views (tip set to nil) are considered equal.
+//
+// This function is safe for concurrent access.
+func (c *chainView) Equals(other *chainView) bool {
+	c.mtx.Lock()
+	other.mtx.Lock()
+	equals := len(c.nodes) == len(other.nodes) && c.tip() == other.tip()
+	other.mtx.Unlock()
+	c.mtx.Unlock()
+	return equals
+}
+
+// contains returns whether or not the chain view contains the passed block
+// node.  This only differs from the exported version in that it is up to the
+// caller to ensure the lock is held.
+//
+// This function MUST be called with the view mutex locked (for reads).
+func (c *chainView) contains(node *blockNode) bool {
+	return c.nodeByHeight(node.height) == node
+}
+
+// Contains returns whether or not the chain view contains the passed block
+// node.
+//
+// This function is safe for concurrent access.
+func (c *chainView) Contains(node *blockNode) bool {
+	c.mtx.Lock()
+	contains := c.contains(node)
+	c.mtx.Unlock()
+	return contains
+}
+
+// next returns the successor to the provided node for the chain view.  It will
+// return nil if there is no successor or the provided node is not part of the
+// view.  This only differs from the exported version in that it is up to the
+// caller to ensure the lock is held.
+//
+// See the comment on the exported function for more details.
+//
+// This function MUST be called with the view mutex locked (for reads).
+func (c *chainView) next(node *blockNode) *blockNode {
+	if node == nil || !c.contains(node) {
+		return nil
+	}
+
+	return c.nodeByHeight(node.height + 1)
+}
+
+// Next returns the successor to the provided node for the chain view.  It will
+// return nil if there is no successfor or the provided node is not part of the
+// view.
+//
+// For example, assume a block chain with a side chain as depicted below:
+//   genesis -> 1 -> 2 -> 3 -> 4  -> 5 ->  6  -> 7  -> 8
+//                         \-> 4a -> 5a -> 6a
+//
+// Further, assume the view is for the longer chain depicted above.  That is to
+// say it consists of:
+//   genesis -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8
+//
+// Invoking this function with block node 5 would return block node 6 while
+// invoking it with block node 5a would return nil since that node is not part
+// of the view.
+//
+// This function is safe for concurrent access.
+func (c *chainView) Next(node *blockNode) *blockNode {
+	c.mtx.Lock()
+	next := c.next(node)
+	c.mtx.Unlock()
+	return next
+}
+
+// findFork returns the final common block between the provided node and the
+// the chain view.  It will return nil if there is no common block.  This only
+// differs from the exported version in that it is up to the caller to ensure
+// the lock is held.
+//
+// See the exported FindFork comments for more details.
+//
+// This function MUST be called with the view mutex locked (for reads).
+func (c *chainView) findFork(node *blockNode) *blockNode {
+	// No fork point for node that doesn't exist.
+	if node == nil {
+		return nil
+	}
+
+	// When the height of the passed node is higher than the height of the
+	// tip of the current chain view, walk backwards through the nodes of
+	// the other chain until the heights match (or there or no more nodes in
+	// which case there is no common node between the two).
+	//
+	// NOTE: This isn't strictly necessary as the following section will
+	// find the node as well, however, it is more efficient to avoid the
+	// contains check since it is already known that the common node can't
+	// possibly be past the end of the current chain view.  It also allows
+	// this code to take advantage of any potential future optimizations to
+	// the Ancestor function such as using an O(log n) skip list.
+	chainHeight := c.height()
+	if node.height > chainHeight {
+		node = node.Ancestor(chainHeight)
+	}
+
+	// Walk the other chain backwards as long as the current one does not
+	// contain the node or there are no more nodes in which case there is no
+	// common node between the two.
+	for node != nil && !c.contains(node) {
+		node = node.parent
+	}
+
+	return node
+}
+
+// FindFork returns the final common block between the provided node and the
+// the chain view.  It will return nil if there is no common block.
+//
+// For example, assume a block chain with a side chain as depicted below:
+//   genesis -> 1 -> 2 -> ... -> 5 -> 6  -> 7  -> 8
+//                                \-> 6a -> 7a
+//
+// Further, assume the view is for the longer chain depicted above.  That is to
+// say it consists of:
+//   genesis -> 1 -> 2 -> ... -> 5 -> 6 -> 7 -> 8.
+//
+// Invoking this function with block node 7a would return block node 5 while
+// invoking it with block node 7 would return itself since it is already part of
+// the branch formed by the view.
+//
+// This function is safe for concurrent access.
+func (c *chainView) FindFork(node *blockNode) *blockNode {
+	c.mtx.Lock()
+	fork := c.findFork(node)
+	c.mtx.Unlock()
+	return fork
+}
+
+// blockLocator returns a block locator for the passed block node.  The passed
+// node can be nil in which case the block locator for the current tip
+// associated with the view will be returned.  This only differs from the
+// exported version in that it is up to the caller to ensure the lock is held.
+//
+// See the exported BlockLocator function comments for more details.
+//
+// This function MUST be called with the view mutex locked (for reads).
+func (c *chainView) blockLocator(node *blockNode) BlockLocator {
+	// Use the current tip if requested.
+	if node == nil {
+		node = c.tip()
+	}
+	if node == nil {
+		return nil
+	}
+
+	// Calculate the max number of entries that will ultimately be in the
+	// block locator.  See the description of the algorithm for how these
+	// numbers are derived.
+	var maxEntries uint8
+	if node.height <= 12 {
+		maxEntries = uint8(node.height) + 1
+	} else {
+		// Requested hash itself + previous 10 entries + genesis block.
+		// Then floor(log2(height-10)) entries for the skip portion.
+		adjustedHeight := uint32(node.height) - 10
+		maxEntries = 12 + fastLog2Floor(adjustedHeight)
+	}
+	locator := make(BlockLocator, 0, maxEntries)
+
+	step := int32(1)
+	for node != nil {
+		locator = append(locator, &node.hash)
+
+		// Nothing more to add once the genesis block has been added.
+		if node.height == 0 {
+			break
+		}
+
+		// Calculate height of previous node to include ensuring the
+		// final node is the genesis block.
+		height := node.height - step
+		if height < 0 {
+			height = 0
+		}
+
+		// When the node is in the current chain view, all of its
+		// ancestors must be too, so use a much faster O(1) lookup in
+		// that case.  Otherwise, fall back to walking backwards through
+		// the nodes of the other chain to the correct ancestor.
+		if c.contains(node) {
+			node = c.nodes[height]
+		} else {
+			node = node.Ancestor(height)
+		}
+
+		// Once 11 entries have been included, start doubling the
+		// distance between included hashes.
+		if len(locator) > 10 {
+			step *= 2
+		}
+	}
+
+	return locator
+}
+
+// BlockLocator returns a block locator for the passed block node.  The passed
+// node can be nil in which case the block locator for the current tip
+// associated with the view will be returned.
+//
+// See the BlockLocator type for details on the algorithm used to create a block
+// locator.
+//
+// This function is safe for concurrent access.
+func (c *chainView) BlockLocator(node *blockNode) BlockLocator {
+	c.mtx.Lock()
+	locator := c.blockLocator(node)
+	c.mtx.Unlock()
+	return locator
+}

vendor/github.com/btcsuite/btcd/blockchain/chainview_test.go

@@ -0,0 +1,492 @@
+// 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 blockchain
+
+import (
+	"fmt"
+	"math/rand"
+	"reflect"
+	"testing"
+
+	"github.com/btcsuite/btcd/wire"
+)
+
+// testNoncePrng provides a deterministic prng for the nonce in generated fake
+// nodes.  The ensures that the node have unique hashes.
+var testNoncePrng = rand.New(rand.NewSource(0))
+
+// chainedNodes returns the specified number of nodes constructed such that each
+// subsequent node points to the previous one to create a chain.  The first node
+// will point to the passed parent which can be nil if desired.
+func chainedNodes(parent *blockNode, numNodes int) []*blockNode {
+	nodes := make([]*blockNode, numNodes)
+	tip := parent
+	for i := 0; i < numNodes; i++ {
+		// This is invalid, but all that is needed is enough to get the
+		// synthetic tests to work.
+		header := wire.BlockHeader{Nonce: testNoncePrng.Uint32()}
+		height := int32(0)
+		if tip != nil {
+			header.PrevBlock = tip.hash
+			height = tip.height + 1
+		}
+		node := newBlockNode(&header, height)
+		node.parent = tip
+		tip = node
+
+		nodes[i] = node
+	}
+	return nodes
+}
+
+// String returns the block node as a human-readable name.
+func (node blockNode) String() string {
+	return fmt.Sprintf("%s(%d)", node.hash, node.height)
+}
+
+// tstTip is a convenience function to grab the tip of a chain of block nodes
+// created via chainedNodes.
+func tstTip(nodes []*blockNode) *blockNode {
+	return nodes[len(nodes)-1]
+}
+
+// locatorHashes is a convenience function that returns the hashes for all of
+// the passed indexes of the provided nodes.  It is used to construct expected
+// block locators in the tests.
+func locatorHashes(nodes []*blockNode, indexes ...int) BlockLocator {
+	hashes := make(BlockLocator, 0, len(indexes))
+	for _, idx := range indexes {
+		hashes = append(hashes, &nodes[idx].hash)
+	}
+	return hashes
+}
+
+// zipLocators is a convenience function that returns a single block locator
+// given a variable number of them and is used in the tests.
+func zipLocators(locators ...BlockLocator) BlockLocator {
+	var hashes BlockLocator
+	for _, locator := range locators {
+		hashes = append(hashes, locator...)
+	}
+	return hashes
+}
+
+// TestChainView ensures all of the exported functionality of chain views works
+// as intended with the expection of some special cases which are handled in
+// other tests.
+func TestChainView(t *testing.T) {
+	// Construct a synthetic block index consisting of the following
+	// structure.
+	// 0 -> 1 -> 2  -> 3  -> 4
+	//       \-> 2a -> 3a -> 4a  -> 5a -> 6a -> 7a -> ... -> 26a
+	//             \-> 3a'-> 4a' -> 5a'
+	branch0Nodes := chainedNodes(nil, 5)
+	branch1Nodes := chainedNodes(branch0Nodes[1], 25)
+	branch2Nodes := chainedNodes(branch1Nodes[0], 3)
+
+	tip := tstTip
+	tests := []struct {
+		name       string
+		view       *chainView   // active view
+		genesis    *blockNode   // expected genesis block of active view
+		tip        *blockNode   // expected tip of active view
+		side       *chainView   // side chain view
+		sideTip    *blockNode   // expected tip of side chain view
+		fork       *blockNode   // expected fork node
+		contains   []*blockNode // expected nodes in active view
+		noContains []*blockNode // expected nodes NOT in active view
+		equal      *chainView   // view expected equal to active view
+		unequal    *chainView   // view expected NOT equal to active
+		locator    BlockLocator // expected locator for active view tip
+	}{
+		{
+			// Create a view for branch 0 as the active chain and
+			// another view for branch 1 as the side chain.
+			name:       "chain0-chain1",
+			view:       newChainView(tip(branch0Nodes)),
+			genesis:    branch0Nodes[0],
+			tip:        tip(branch0Nodes),
+			side:       newChainView(tip(branch1Nodes)),
+			sideTip:    tip(branch1Nodes),
+			fork:       branch0Nodes[1],
+			contains:   branch0Nodes,
+			noContains: branch1Nodes,
+			equal:      newChainView(tip(branch0Nodes)),
+			unequal:    newChainView(tip(branch1Nodes)),
+			locator:    locatorHashes(branch0Nodes, 4, 3, 2, 1, 0),
+		},
+		{
+			// Create a view for branch 1 as the active chain and
+			// another view for branch 2 as the side chain.
+			name:       "chain1-chain2",
+			view:       newChainView(tip(branch1Nodes)),
+			genesis:    branch0Nodes[0],
+			tip:        tip(branch1Nodes),
+			side:       newChainView(tip(branch2Nodes)),
+			sideTip:    tip(branch2Nodes),
+			fork:       branch1Nodes[0],
+			contains:   branch1Nodes,
+			noContains: branch2Nodes,
+			equal:      newChainView(tip(branch1Nodes)),
+			unequal:    newChainView(tip(branch2Nodes)),
+			locator: zipLocators(
+				locatorHashes(branch1Nodes, 24, 23, 22, 21, 20,
+					19, 18, 17, 16, 15, 14, 13, 11, 7),
+				locatorHashes(branch0Nodes, 1, 0)),
+		},
+		{
+			// Create a view for branch 2 as the active chain and
+			// another view for branch 0 as the side chain.
+			name:       "chain2-chain0",
+			view:       newChainView(tip(branch2Nodes)),
+			genesis:    branch0Nodes[0],
+			tip:        tip(branch2Nodes),
+			side:       newChainView(tip(branch0Nodes)),
+			sideTip:    tip(branch0Nodes),
+			fork:       branch0Nodes[1],
+			contains:   branch2Nodes,
+			noContains: branch0Nodes[2:],
+			equal:      newChainView(tip(branch2Nodes)),
+			unequal:    newChainView(tip(branch0Nodes)),
+			locator: zipLocators(
+				locatorHashes(branch2Nodes, 2, 1, 0),
+				locatorHashes(branch1Nodes, 0),
+				locatorHashes(branch0Nodes, 1, 0)),
+		},
+	}
+testLoop:
+	for _, test := range tests {
+		// Ensure the active and side chain heights are the expected
+		// values.
+		if test.view.Height() != test.tip.height {
+			t.Errorf("%s: unexpected active view height -- got "+
+				"%d, want %d", test.name, test.view.Height(),
+				test.tip.height)
+			continue
+		}
+		if test.side.Height() != test.sideTip.height {
+			t.Errorf("%s: unexpected side view height -- got %d, "+
+				"want %d", test.name, test.side.Height(),
+				test.sideTip.height)
+			continue
+		}
+
+		// Ensure the active and side chain genesis block is the
+		// expected value.
+		if test.view.Genesis() != test.genesis {
+			t.Errorf("%s: unexpected active view genesis -- got "+
+				"%v, want %v", test.name, test.view.Genesis(),
+				test.genesis)
+			continue
+		}
+		if test.side.Genesis() != test.genesis {
+			t.Errorf("%s: unexpected side view genesis -- got %v, "+
+				"want %v", test.name, test.view.Genesis(),
+				test.genesis)
+			continue
+		}
+
+		// Ensure the active and side chain tips are the expected nodes.
+		if test.view.Tip() != test.tip {
+			t.Errorf("%s: unexpected active view tip -- got %v, "+
+				"want %v", test.name, test.view.Tip(), test.tip)
+			continue
+		}
+		if test.side.Tip() != test.sideTip {
+			t.Errorf("%s: unexpected active view tip -- got %v, "+
+				"want %v", test.name, test.side.Tip(),
+				test.sideTip)
+			continue
+		}
+
+		// Ensure that regardless of the order the two chains are
+		// compared they both return the expected fork point.
+		forkNode := test.view.FindFork(test.side.Tip())
+		if forkNode != test.fork {
+			t.Errorf("%s: unexpected fork node (view, side) -- "+
+				"got %v, want %v", test.name, forkNode,
+				test.fork)
+			continue
+		}
+		forkNode = test.side.FindFork(test.view.Tip())
+		if forkNode != test.fork {
+			t.Errorf("%s: unexpected fork node (side, view) -- "+
+				"got %v, want %v", test.name, forkNode,
+				test.fork)
+			continue
+		}
+
+		// Ensure that the fork point for a node that is already part
+		// of the chain view is the node itself.
+		forkNode = test.view.FindFork(test.view.Tip())
+		if forkNode != test.view.Tip() {
+			t.Errorf("%s: unexpected fork node (view, tip) -- "+
+				"got %v, want %v", test.name, forkNode,
+				test.view.Tip())
+			continue
+		}
+
+		// Ensure all expected nodes are contained in the active view.
+		for _, node := range test.contains {
+			if !test.view.Contains(node) {
+				t.Errorf("%s: expected %v in active view",
+					test.name, node)
+				continue testLoop
+			}
+		}
+
+		// Ensure all nodes from side chain view are NOT contained in
+		// the active view.
+		for _, node := range test.noContains {
+			if test.view.Contains(node) {
+				t.Errorf("%s: unexpected %v in active view",
+					test.name, node)
+				continue testLoop
+			}
+		}
+
+		// Ensure equality of different views into the same chain works
+		// as intended.
+		if !test.view.Equals(test.equal) {
+			t.Errorf("%s: unexpected unequal views", test.name)
+			continue
+		}
+		if test.view.Equals(test.unequal) {
+			t.Errorf("%s: unexpected equal views", test.name)
+			continue
+		}
+
+		// Ensure all nodes contained in the view return the expected
+		// next node.
+		for i, node := range test.contains {
+			// Final node expects nil for the next node.
+			var expected *blockNode
+			if i < len(test.contains)-1 {
+				expected = test.contains[i+1]
+			}
+			if next := test.view.Next(node); next != expected {
+				t.Errorf("%s: unexpected next node -- got %v, "+
+					"want %v", test.name, next, expected)
+				continue testLoop
+			}
+		}
+
+		// Ensure nodes that are not contained in the view do not
+		// produce a successor node.
+		for _, node := range test.noContains {
+			if next := test.view.Next(node); next != nil {
+				t.Errorf("%s: unexpected next node -- got %v, "+
+					"want nil", test.name, next)
+				continue testLoop
+			}
+		}
+
+		// Ensure all nodes contained in the view can be retrieved by
+		// height.
+		for _, wantNode := range test.contains {
+			node := test.view.NodeByHeight(wantNode.height)
+			if node != wantNode {
+				t.Errorf("%s: unexpected node for height %d -- "+
+					"got %v, want %v", test.name,
+					wantNode.height, node, wantNode)
+				continue testLoop
+			}
+		}
+
+		// Ensure the block locator for the tip of the active view
+		// consists of the expected hashes.
+		locator := test.view.BlockLocator(test.view.tip())
+		if !reflect.DeepEqual(locator, test.locator) {
+			t.Errorf("%s: unexpected locator -- got %v, want %v",
+				test.name, locator, test.locator)
+			continue
+		}
+	}
+}
+
+// TestChainViewForkCorners ensures that finding the fork between two chains
+// works in some corner cases such as when the two chains have completely
+// unrelated histories.
+func TestChainViewForkCorners(t *testing.T) {
+	// Construct two unrelated single branch synthetic block indexes.
+	branchNodes := chainedNodes(nil, 5)
+	unrelatedBranchNodes := chainedNodes(nil, 7)
+
+	// Create chain views for the two unrelated histories.
+	view1 := newChainView(tstTip(branchNodes))
+	view2 := newChainView(tstTip(unrelatedBranchNodes))
+
+	// Ensure attempting to find a fork point with a node that doesn't exist
+	// doesn't produce a node.
+	if fork := view1.FindFork(nil); fork != nil {
+		t.Fatalf("FindFork: unexpected fork -- got %v, want nil", fork)
+	}
+
+	// Ensure attempting to find a fork point in two chain views with
+	// totally unrelated histories doesn't produce a node.
+	for _, node := range branchNodes {
+		if fork := view2.FindFork(node); fork != nil {
+			t.Fatalf("FindFork: unexpected fork -- got %v, want nil",
+				fork)
+		}
+	}
+	for _, node := range unrelatedBranchNodes {
+		if fork := view1.FindFork(node); fork != nil {
+			t.Fatalf("FindFork: unexpected fork -- got %v, want nil",
+				fork)
+		}
+	}
+}
+
+// TestChainViewSetTip ensures changing the tip works as intended including
+// capacity changes.
+func TestChainViewSetTip(t *testing.T) {
+	// Construct a synthetic block index consisting of the following
+	// structure.
+	// 0 -> 1 -> 2  -> 3  -> 4
+	//       \-> 2a -> 3a -> 4a  -> 5a -> 6a -> 7a -> ... -> 26a
+	branch0Nodes := chainedNodes(nil, 5)
+	branch1Nodes := chainedNodes(branch0Nodes[1], 25)
+
+	tip := tstTip
+	tests := []struct {
+		name     string
+		view     *chainView     // active view
+		tips     []*blockNode   // tips to set
+		contains [][]*blockNode // expected nodes in view for each tip
+	}{
+		{
+			// Create an empty view and set the tip to increasingly
+			// longer chains.
+			name:     "increasing",
+			view:     newChainView(nil),
+			tips:     []*blockNode{tip(branch0Nodes), tip(branch1Nodes)},
+			contains: [][]*blockNode{branch0Nodes, branch1Nodes},
+		},
+		{
+			// Create a view with a longer chain and set the tip to
+			// increasingly shorter chains.
+			name:     "decreasing",
+			view:     newChainView(tip(branch1Nodes)),
+			tips:     []*blockNode{tip(branch0Nodes), nil},
+			contains: [][]*blockNode{branch0Nodes, nil},
+		},
+		{
+			// Create a view with a shorter chain and set the tip to
+			// a longer chain followed by setting it back to the
+			// shorter chain.
+			name:     "small-large-small",
+			view:     newChainView(tip(branch0Nodes)),
+			tips:     []*blockNode{tip(branch1Nodes), tip(branch0Nodes)},
+			contains: [][]*blockNode{branch1Nodes, branch0Nodes},
+		},
+		{
+			// Create a view with a longer chain and set the tip to
+			// a smaller chain followed by setting it back to the
+			// longer chain.
+			name:     "large-small-large",
+			view:     newChainView(tip(branch1Nodes)),
+			tips:     []*blockNode{tip(branch0Nodes), tip(branch1Nodes)},
+			contains: [][]*blockNode{branch0Nodes, branch1Nodes},
+		},
+	}
+
+testLoop:
+	for _, test := range tests {
+		for i, tip := range test.tips {
+			// Ensure the view tip is the expected node.
+			test.view.SetTip(tip)
+			if test.view.Tip() != tip {
+				t.Errorf("%s: unexpected view tip -- got %v, "+
+					"want %v", test.name, test.view.Tip(),
+					tip)
+				continue testLoop
+			}
+
+			// Ensure all expected nodes are contained in the view.
+			for _, node := range test.contains[i] {
+				if !test.view.Contains(node) {
+					t.Errorf("%s: expected %v in active view",
+						test.name, node)
+					continue testLoop
+				}
+			}
+
+		}
+	}
+}
+
+// TestChainViewNil ensures that creating and accessing a nil chain view behaves
+// as expected.
+func TestChainViewNil(t *testing.T) {
+	// Ensure two unininitialized views are considered equal.
+	view := newChainView(nil)
+	if !view.Equals(newChainView(nil)) {
+		t.Fatal("uninitialized nil views unequal")
+	}
+
+	// Ensure the genesis of an uninitialized view does not produce a node.
+	if genesis := view.Genesis(); genesis != nil {
+		t.Fatalf("Genesis: unexpected genesis -- got %v, want nil",
+			genesis)
+	}
+
+	// Ensure the tip of an uninitialized view does not produce a node.
+	if tip := view.Tip(); tip != nil {
+		t.Fatalf("Tip: unexpected tip -- got %v, want nil", tip)
+	}
+
+	// Ensure the height of an uninitialized view is the expected value.
+	if height := view.Height(); height != -1 {
+		t.Fatalf("Height: unexpected height -- got %d, want -1", height)
+	}
+
+	// Ensure attempting to get a node for a height that does not exist does
+	// not produce a node.
+	if node := view.NodeByHeight(10); node != nil {
+		t.Fatalf("NodeByHeight: unexpected node -- got %v, want nil", node)
+	}
+
+	// Ensure an uninitialized view does not report it contains nodes.
+	fakeNode := chainedNodes(nil, 1)[0]
+	if view.Contains(fakeNode) {
+		t.Fatalf("Contains: view claims it contains node %v", fakeNode)
+	}
+
+	// Ensure the next node for a node that does not exist does not produce
+	// a node.
+	if next := view.Next(nil); next != nil {
+		t.Fatalf("Next: unexpected next node -- got %v, want nil", next)
+	}
+
+	// Ensure the next node for a node that exists does not produce a node.
+	if next := view.Next(fakeNode); next != nil {
+		t.Fatalf("Next: unexpected next node -- got %v, want nil", next)
+	}
+
+	// Ensure attempting to find a fork point with a node that doesn't exist
+	// doesn't produce a node.
+	if fork := view.FindFork(nil); fork != nil {
+		t.Fatalf("FindFork: unexpected fork -- got %v, want nil", fork)
+	}
+
+	// Ensure attempting to get a block locator for the tip doesn't produce
+	// one since the tip is nil.
+	if locator := view.BlockLocator(nil); locator != nil {
+		t.Fatalf("BlockLocator: unexpected locator -- got %v, want nil",
+			locator)
+	}
+
+	// Ensure attempting to get a block locator for a node that exists still
+	// works as intended.
+	branchNodes := chainedNodes(nil, 50)
+	wantLocator := locatorHashes(branchNodes, 49, 48, 47, 46, 45, 44, 43,
+		42, 41, 40, 39, 38, 36, 32, 24, 8, 0)
+	locator := view.BlockLocator(tstTip(branchNodes))
+	if !reflect.DeepEqual(locator, wantLocator) {
+		t.Fatalf("BlockLocator: unexpected locator -- got %v, want %v",
+			locator, wantLocator)
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/checkpoints.go

@@ -0,0 +1,261 @@
+// 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 blockchain
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcutil"
+)
+
+// CheckpointConfirmations is the number of blocks before the end of the current
+// best block chain that a good checkpoint candidate must be.
+const CheckpointConfirmations = 2016
+
+// newHashFromStr converts the passed big-endian hex string into a
+// chainhash.Hash.  It only differs from the one available in chainhash in that
+// it ignores the error since it will only (and must only) be called with
+// hard-coded, and therefore known good, hashes.
+func newHashFromStr(hexStr string) *chainhash.Hash {
+	hash, _ := chainhash.NewHashFromStr(hexStr)
+	return hash
+}
+
+// Checkpoints returns a slice of checkpoints (regardless of whether they are
+// already known).  When there are no checkpoints for the chain, it will return
+// nil.
+//
+// This function is safe for concurrent access.
+func (b *BlockChain) Checkpoints() []chaincfg.Checkpoint {
+	return b.checkpoints
+}
+
+// HasCheckpoints returns whether this BlockChain has checkpoints defined.
+//
+// This function is safe for concurrent access.
+func (b *BlockChain) HasCheckpoints() bool {
+	return len(b.checkpoints) > 0
+}
+
+// LatestCheckpoint returns the most recent checkpoint (regardless of whether it
+// is already known). When there are no defined checkpoints for the active chain
+// instance, it will return nil.
+//
+// This function is safe for concurrent access.
+func (b *BlockChain) LatestCheckpoint() *chaincfg.Checkpoint {
+	if !b.HasCheckpoints() {
+		return nil
+	}
+	return &b.checkpoints[len(b.checkpoints)-1]
+}
+
+// verifyCheckpoint returns whether the passed block height and hash combination
+// match the checkpoint data.  It also returns true if there is no checkpoint
+// data for the passed block height.
+func (b *BlockChain) verifyCheckpoint(height int32, hash *chainhash.Hash) bool {
+	if !b.HasCheckpoints() {
+		return true
+	}
+
+	// Nothing to check if there is no checkpoint data for the block height.
+	checkpoint, exists := b.checkpointsByHeight[height]
+	if !exists {
+		return true
+	}
+
+	if !checkpoint.Hash.IsEqual(hash) {
+		return false
+	}
+
+	log.Infof("Verified checkpoint at height %d/block %s", checkpoint.Height,
+		checkpoint.Hash)
+	return true
+}
+
+// findPreviousCheckpoint finds the most recent checkpoint that is already
+// available in the downloaded portion of the block chain and returns the
+// associated block node.  It returns nil if a checkpoint can't be found (this
+// should really only happen for blocks before the first checkpoint).
+//
+// This function MUST be called with the chain lock held (for reads).
+func (b *BlockChain) findPreviousCheckpoint() (*blockNode, error) {
+	if !b.HasCheckpoints() {
+		return nil, nil
+	}
+
+	// Perform the initial search to find and cache the latest known
+	// checkpoint if the best chain is not known yet or we haven't already
+	// previously searched.
+	checkpoints := b.checkpoints
+	numCheckpoints := len(checkpoints)
+	if b.checkpointNode == nil && b.nextCheckpoint == nil {
+		// Loop backwards through the available checkpoints to find one
+		// that is already available.
+		for i := numCheckpoints - 1; i >= 0; i-- {
+			node := b.index.LookupNode(checkpoints[i].Hash)
+			if node == nil || !b.bestChain.Contains(node) {
+				continue
+			}
+
+			// Checkpoint found.  Cache it for future lookups and
+			// set the next expected checkpoint accordingly.
+			b.checkpointNode = node
+			if i < numCheckpoints-1 {
+				b.nextCheckpoint = &checkpoints[i+1]
+			}
+			return b.checkpointNode, nil
+		}
+
+		// No known latest checkpoint.  This will only happen on blocks
+		// before the first known checkpoint.  So, set the next expected
+		// checkpoint to the first checkpoint and return the fact there
+		// is no latest known checkpoint block.
+		b.nextCheckpoint = &checkpoints[0]
+		return nil, nil
+	}
+
+	// At this point we've already searched for the latest known checkpoint,
+	// so when there is no next checkpoint, the current checkpoint lockin
+	// will always be the latest known checkpoint.
+	if b.nextCheckpoint == nil {
+		return b.checkpointNode, nil
+	}
+
+	// When there is a next checkpoint and the height of the current best
+	// chain does not exceed it, the current checkpoint lockin is still
+	// the latest known checkpoint.
+	if b.bestChain.Tip().height < b.nextCheckpoint.Height {
+		return b.checkpointNode, nil
+	}
+
+	// We've reached or exceeded the next checkpoint height.  Note that
+	// once a checkpoint lockin has been reached, forks are prevented from
+	// any blocks before the checkpoint, so we don't have to worry about the
+	// checkpoint going away out from under us due to a chain reorganize.
+
+	// Cache the latest known checkpoint for future lookups.  Note that if
+	// this lookup fails something is very wrong since the chain has already
+	// passed the checkpoint which was verified as accurate before inserting
+	// it.
+	checkpointNode := b.index.LookupNode(b.nextCheckpoint.Hash)
+	if checkpointNode == nil {
+		return nil, AssertError(fmt.Sprintf("findPreviousCheckpoint "+
+			"failed lookup of known good block node %s",
+			b.nextCheckpoint.Hash))
+	}
+	b.checkpointNode = checkpointNode
+
+	// Set the next expected checkpoint.
+	checkpointIndex := -1
+	for i := numCheckpoints - 1; i >= 0; i-- {
+		if checkpoints[i].Hash.IsEqual(b.nextCheckpoint.Hash) {
+			checkpointIndex = i
+			break
+		}
+	}
+	b.nextCheckpoint = nil
+	if checkpointIndex != -1 && checkpointIndex < numCheckpoints-1 {
+		b.nextCheckpoint = &checkpoints[checkpointIndex+1]
+	}
+
+	return b.checkpointNode, nil
+}
+
+// isNonstandardTransaction determines whether a transaction contains any
+// scripts which are not one of the standard types.
+func isNonstandardTransaction(tx *btcutil.Tx) bool {
+	// Check all of the output public key scripts for non-standard scripts.
+	for _, txOut := range tx.MsgTx().TxOut {
+		scriptClass := txscript.GetScriptClass(txOut.PkScript)
+		if scriptClass == txscript.NonStandardTy {
+			return true
+		}
+	}
+	return false
+}
+
+// IsCheckpointCandidate returns whether or not the passed block is a good
+// checkpoint candidate.
+//
+// The factors used to determine a good checkpoint are:
+//  - The block must be in the main chain
+//  - The block must be at least 'CheckpointConfirmations' blocks prior to the
+//    current end of the main chain
+//  - The timestamps for the blocks before and after the checkpoint must have
+//    timestamps which are also before and after the checkpoint, respectively
+//    (due to the median time allowance this is not always the case)
+//  - The block must not contain any strange transaction such as those with
+//    nonstandard scripts
+//
+// The intent is that candidates are reviewed by a developer to make the final
+// decision and then manually added to the list of checkpoints for a network.
+//
+// This function is safe for concurrent access.
+func (b *BlockChain) IsCheckpointCandidate(block *btcutil.Block) (bool, error) {
+	b.chainLock.RLock()
+	defer b.chainLock.RUnlock()
+
+	// A checkpoint must be in the main chain.
+	node := b.index.LookupNode(block.Hash())
+	if node == nil || !b.bestChain.Contains(node) {
+		return false, nil
+	}
+
+	// Ensure the height of the passed block and the entry for the block in
+	// the main chain match.  This should always be the case unless the
+	// caller provided an invalid block.
+	if node.height != block.Height() {
+		return false, fmt.Errorf("passed block height of %d does not "+
+			"match the main chain height of %d", block.Height(),
+			node.height)
+	}
+
+	// A checkpoint must be at least CheckpointConfirmations blocks
+	// before the end of the main chain.
+	mainChainHeight := b.bestChain.Tip().height
+	if node.height > (mainChainHeight - CheckpointConfirmations) {
+		return false, nil
+	}
+
+	// A checkpoint must be have at least one block after it.
+	//
+	// This should always succeed since the check above already made sure it
+	// is CheckpointConfirmations back, but be safe in case the constant
+	// changes.
+	nextNode := b.bestChain.Next(node)
+	if nextNode == nil {
+		return false, nil
+	}
+
+	// A checkpoint must be have at least one block before it.
+	if node.parent == nil {
+		return false, nil
+	}
+
+	// A checkpoint must have timestamps for the block and the blocks on
+	// either side of it in order (due to the median time allowance this is
+	// not always the case).
+	prevTime := time.Unix(node.parent.timestamp, 0)
+	curTime := block.MsgBlock().Header.Timestamp
+	nextTime := time.Unix(nextNode.timestamp, 0)
+	if prevTime.After(curTime) || nextTime.Before(curTime) {
+		return false, nil
+	}
+
+	// A checkpoint must have transactions that only contain standard
+	// scripts.
+	for _, tx := range block.Transactions() {
+		if isNonstandardTransaction(tx) {
+			return false, nil
+		}
+	}
+
+	// All of the checks passed, so the block is a candidate.
+	return true, nil
+}

vendor/github.com/btcsuite/btcd/blockchain/common_test.go

@@ -0,0 +1,298 @@
+// 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 blockchain
+
+import (
+	"compress/bzip2"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/database"
+	_ "github.com/btcsuite/btcd/database/ffldb"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+)
+
+const (
+	// testDbType is the database backend type to use for the tests.
+	testDbType = "ffldb"
+
+	// testDbRoot is the root directory used to create all test databases.
+	testDbRoot = "testdbs"
+
+	// blockDataNet is the expected network in the test block data.
+	blockDataNet = wire.MainNet
+)
+
+// filesExists returns whether or not the named file or directory exists.
+func fileExists(name string) bool {
+	if _, err := os.Stat(name); err != nil {
+		if os.IsNotExist(err) {
+			return false
+		}
+	}
+	return true
+}
+
+// isSupportedDbType returns whether or not the passed database type is
+// currently supported.
+func isSupportedDbType(dbType string) bool {
+	supportedDrivers := database.SupportedDrivers()
+	for _, driver := range supportedDrivers {
+		if dbType == driver {
+			return true
+		}
+	}
+
+	return false
+}
+
+// loadBlocks reads files containing bitcoin block data (gzipped but otherwise
+// in the format bitcoind writes) from disk and returns them as an array of
+// btcutil.Block.  This is largely borrowed from the test code in btcdb.
+func loadBlocks(filename string) (blocks []*btcutil.Block, err error) {
+	filename = filepath.Join("testdata/", filename)
+
+	var network = wire.MainNet
+	var dr io.Reader
+	var fi io.ReadCloser
+
+	fi, err = os.Open(filename)
+	if err != nil {
+		return
+	}
+
+	if strings.HasSuffix(filename, ".bz2") {
+		dr = bzip2.NewReader(fi)
+	} else {
+		dr = fi
+	}
+	defer fi.Close()
+
+	var block *btcutil.Block
+
+	err = nil
+	for height := int64(1); err == nil; height++ {
+		var rintbuf uint32
+		err = binary.Read(dr, binary.LittleEndian, &rintbuf)
+		if err == io.EOF {
+			// hit end of file at expected offset: no warning
+			height--
+			err = nil
+			break
+		}
+		if err != nil {
+			break
+		}
+		if rintbuf != uint32(network) {
+			break
+		}
+		err = binary.Read(dr, binary.LittleEndian, &rintbuf)
+		blocklen := rintbuf
+
+		rbytes := make([]byte, blocklen)
+
+		// read block
+		dr.Read(rbytes)
+
+		block, err = btcutil.NewBlockFromBytes(rbytes)
+		if err != nil {
+			return
+		}
+		blocks = append(blocks, block)
+	}
+
+	return
+}
+
+// chainSetup is used to create a new db and chain instance with the genesis
+// block already inserted.  In addition to the new chain instance, it returns
+// a teardown function the caller should invoke when done testing to clean up.
+func chainSetup(dbName string, params *chaincfg.Params) (*BlockChain, func(), error) {
+	if !isSupportedDbType(testDbType) {
+		return nil, nil, fmt.Errorf("unsupported db type %v", testDbType)
+	}
+
+	// Handle memory database specially since it doesn't need the disk
+	// specific handling.
+	var db database.DB
+	var teardown func()
+	if testDbType == "memdb" {
+		ndb, err := database.Create(testDbType)
+		if err != nil {
+			return nil, nil, fmt.Errorf("error creating db: %v", err)
+		}
+		db = ndb
+
+		// Setup a teardown function for cleaning up.  This function is
+		// returned to the caller to be invoked when it is done testing.
+		teardown = func() {
+			db.Close()
+		}
+	} else {
+		// Create the root directory for test databases.
+		if !fileExists(testDbRoot) {
+			if err := os.MkdirAll(testDbRoot, 0700); err != nil {
+				err := fmt.Errorf("unable to create test db "+
+					"root: %v", err)
+				return nil, nil, err
+			}
+		}
+
+		// Create a new database to store the accepted blocks into.
+		dbPath := filepath.Join(testDbRoot, dbName)
+		_ = os.RemoveAll(dbPath)
+		ndb, err := database.Create(testDbType, dbPath, blockDataNet)
+		if err != nil {
+			return nil, nil, fmt.Errorf("error creating db: %v", err)
+		}
+		db = ndb
+
+		// Setup a teardown function for cleaning up.  This function is
+		// returned to the caller to be invoked when it is done testing.
+		teardown = func() {
+			db.Close()
+			os.RemoveAll(dbPath)
+			os.RemoveAll(testDbRoot)
+		}
+	}
+
+	// Copy the chain params to ensure any modifications the tests do to
+	// the chain parameters do not affect the global instance.
+	paramsCopy := *params
+
+	// Create the main chain instance.
+	chain, err := New(&Config{
+		DB:          db,
+		ChainParams: &paramsCopy,
+		Checkpoints: nil,
+		TimeSource:  NewMedianTime(),
+		SigCache:    txscript.NewSigCache(1000),
+	})
+	if err != nil {
+		teardown()
+		err := fmt.Errorf("failed to create chain instance: %v", err)
+		return nil, nil, err
+	}
+	return chain, teardown, nil
+}
+
+// loadUtxoView returns a utxo view loaded from a file.
+func loadUtxoView(filename string) (*UtxoViewpoint, error) {
+	// The utxostore file format is:
+	// <tx hash><serialized utxo len><serialized utxo>
+	//
+	// The serialized utxo len is a little endian uint32 and the serialized
+	// utxo uses the format described in chainio.go.
+
+	filename = filepath.Join("testdata", filename)
+	fi, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	// Choose read based on whether the file is compressed or not.
+	var r io.Reader
+	if strings.HasSuffix(filename, ".bz2") {
+		r = bzip2.NewReader(fi)
+	} else {
+		r = fi
+	}
+	defer fi.Close()
+
+	view := NewUtxoViewpoint()
+	for {
+		// Hash of the utxo entry.
+		var hash chainhash.Hash
+		_, err := io.ReadAtLeast(r, hash[:], len(hash[:]))
+		if err != nil {
+			// Expected EOF at the right offset.
+			if err == io.EOF {
+				break
+			}
+			return nil, err
+		}
+
+		// Num of serialize utxo entry bytes.
+		var numBytes uint32
+		err = binary.Read(r, binary.LittleEndian, &numBytes)
+		if err != nil {
+			return nil, err
+		}
+
+		// Serialized utxo entry.
+		serialized := make([]byte, numBytes)
+		_, err = io.ReadAtLeast(r, serialized, int(numBytes))
+		if err != nil {
+			return nil, err
+		}
+
+		// Deserialize it and add it to the view.
+		utxoEntry, err := deserializeUtxoEntry(serialized)
+		if err != nil {
+			return nil, err
+		}
+		view.Entries()[hash] = utxoEntry
+	}
+
+	return view, nil
+}
+
+// TstSetCoinbaseMaturity makes the ability to set the coinbase maturity
+// available when running tests.
+func (b *BlockChain) TstSetCoinbaseMaturity(maturity uint16) {
+	b.chainParams.CoinbaseMaturity = maturity
+}
+
+// newFakeChain returns a chain that is usable for syntetic tests.  It is
+// important to note that this chain has no database associated with it, so
+// it is not usable with all functions and the tests must take care when making
+// use of it.
+func newFakeChain(params *chaincfg.Params) *BlockChain {
+	// Create a genesis block node and block index index populated with it
+	// for use when creating the fake chain below.
+	node := newBlockNode(&params.GenesisBlock.Header, 0)
+	index := newBlockIndex(nil, params)
+	index.AddNode(node)
+
+	targetTimespan := int64(params.TargetTimespan / time.Second)
+	targetTimePerBlock := int64(params.TargetTimePerBlock / time.Second)
+	adjustmentFactor := params.RetargetAdjustmentFactor
+	return &BlockChain{
+		chainParams:         params,
+		timeSource:          NewMedianTime(),
+		minRetargetTimespan: targetTimespan / adjustmentFactor,
+		maxRetargetTimespan: targetTimespan * adjustmentFactor,
+		blocksPerRetarget:   int32(targetTimespan / targetTimePerBlock),
+		index:               index,
+		bestChain:           newChainView(node),
+		warningCaches:       newThresholdCaches(vbNumBits),
+		deploymentCaches:    newThresholdCaches(chaincfg.DefinedDeployments),
+	}
+}
+
+// newFakeNode creates a block node connected to the passed parent with the
+// provided fields populated and fake values for the other fields.
+func newFakeNode(parent *blockNode, blockVersion int32, bits uint32, timestamp time.Time) *blockNode {
+	// Make up a header and create a block node from it.
+	header := &wire.BlockHeader{
+		Version:   blockVersion,
+		PrevBlock: parent.hash,
+		Bits:      bits,
+		Timestamp: timestamp,
+	}
+	node := newBlockNode(header, parent.height+1)
+	node.parent = parent
+	node.workSum.Add(parent.workSum, node.workSum)
+	return node
+}

vendor/github.com/btcsuite/btcd/blockchain/compress.go

@@ -0,0 +1,603 @@
+// Copyright (c) 2015-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package blockchain
+
+import (
+	"github.com/btcsuite/btcd/btcec"
+	"github.com/btcsuite/btcd/txscript"
+)
+
+// -----------------------------------------------------------------------------
+// A variable length quantity (VLQ) is an encoding that uses an arbitrary number
+// of binary octets to represent an arbitrarily large integer.  The scheme
+// employs a most significant byte (MSB) base-128 encoding where the high bit in
+// each byte indicates whether or not the byte is the final one.  In addition,
+// to ensure there are no redundant encodings, an offset is subtracted every
+// time a group of 7 bits is shifted out.  Therefore each integer can be
+// represented in exactly one way, and each representation stands for exactly
+// one integer.
+//
+// Another nice property of this encoding is that it provides a compact
+// representation of values that are typically used to indicate sizes.  For
+// example, the values 0 - 127 are represented with a single byte, 128 - 16511
+// with two bytes, and 16512 - 2113663 with three bytes.
+//
+// While the encoding allows arbitrarily large integers, it is artificially
+// limited in this code to an unsigned 64-bit integer for efficiency purposes.
+//
+// Example encodings:
+//           0 -> [0x00]
+//         127 -> [0x7f]                 * Max 1-byte value
+//         128 -> [0x80 0x00]
+//         129 -> [0x80 0x01]
+//         255 -> [0x80 0x7f]
+//         256 -> [0x81 0x00]
+//       16511 -> [0xff 0x7f]            * Max 2-byte value
+//       16512 -> [0x80 0x80 0x00]
+//       32895 -> [0x80 0xff 0x7f]
+//     2113663 -> [0xff 0xff 0x7f]       * Max 3-byte value
+//   270549119 -> [0xff 0xff 0xff 0x7f]  * Max 4-byte value
+//      2^64-1 -> [0x80 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0x7f]
+//
+// References:
+//   https://en.wikipedia.org/wiki/Variable-length_quantity
+//   http://www.codecodex.com/wiki/Variable-Length_Integers
+// -----------------------------------------------------------------------------
+
+// serializeSizeVLQ returns the number of bytes it would take to serialize the
+// passed number as a variable-length quantity according to the format described
+// above.
+func serializeSizeVLQ(n uint64) int {
+	size := 1
+	for ; n > 0x7f; n = (n >> 7) - 1 {
+		size++
+	}
+
+	return size
+}
+
+// putVLQ serializes the provided number to a variable-length quantity according
+// to the format described above and returns the number of bytes of the encoded
+// value.  The result is placed directly into the passed byte slice which must
+// be at least large enough to handle the number of bytes returned by the
+// serializeSizeVLQ function or it will panic.
+func putVLQ(target []byte, n uint64) int {
+	offset := 0
+	for ; ; offset++ {
+		// The high bit is set when another byte follows.
+		highBitMask := byte(0x80)
+		if offset == 0 {
+			highBitMask = 0x00
+		}
+
+		target[offset] = byte(n&0x7f) | highBitMask
+		if n <= 0x7f {
+			break
+		}
+		n = (n >> 7) - 1
+	}
+
+	// Reverse the bytes so it is MSB-encoded.
+	for i, j := 0, offset; i < j; i, j = i+1, j-1 {
+		target[i], target[j] = target[j], target[i]
+	}
+
+	return offset + 1
+}
+
+// deserializeVLQ deserializes the provided variable-length quantity according
+// to the format described above.  It also returns the number of bytes
+// deserialized.
+func deserializeVLQ(serialized []byte) (uint64, int) {
+	var n uint64
+	var size int
+	for _, val := range serialized {
+		size++
+		n = (n << 7) | uint64(val&0x7f)
+		if val&0x80 != 0x80 {
+			break
+		}
+		n++
+	}
+
+	return n, size
+}
+
+// -----------------------------------------------------------------------------
+// In order to reduce the size of stored scripts, a domain specific compression
+// algorithm is used which recognizes standard scripts and stores them using
+// less bytes than the original script.  The compression algorithm used here was
+// obtained from Bitcoin Core, so all credits for the algorithm go to it.
+//
+// The general serialized format is:
+//
+//   <script size or type><script data>
+//
+//   Field                 Type     Size
+//   script size or type   VLQ      variable
+//   script data           []byte   variable
+//
+// The specific serialized format for each recognized standard script is:
+//
+// - Pay-to-pubkey-hash: (21 bytes) - <0><20-byte pubkey hash>
+// - Pay-to-script-hash: (21 bytes) - <1><20-byte script hash>
+// - Pay-to-pubkey**:    (33 bytes) - <2, 3, 4, or 5><32-byte pubkey X value>
+//   2, 3 = compressed pubkey with bit 0 specifying the y coordinate to use
+//   4, 5 = uncompressed pubkey with bit 0 specifying the y coordinate to use
+//   ** Only valid public keys starting with 0x02, 0x03, and 0x04 are supported.
+//
+// Any scripts which are not recognized as one of the aforementioned standard
+// scripts are encoded using the general serialized format and encode the script
+// size as the sum of the actual size of the script and the number of special
+// cases.
+// -----------------------------------------------------------------------------
+
+// The following constants specify the special constants used to identify a
+// special script type in the domain-specific compressed script encoding.
+//
+// NOTE: This section specifically does not use iota since these values are
+// serialized and must be stable for long-term storage.
+const (
+	// cstPayToPubKeyHash identifies a compressed pay-to-pubkey-hash script.
+	cstPayToPubKeyHash = 0
+
+	// cstPayToScriptHash identifies a compressed pay-to-script-hash script.
+	cstPayToScriptHash = 1
+
+	// cstPayToPubKeyComp2 identifies a compressed pay-to-pubkey script to
+	// a compressed pubkey.  Bit 0 specifies which y-coordinate to use
+	// to reconstruct the full uncompressed pubkey.
+	cstPayToPubKeyComp2 = 2
+
+	// cstPayToPubKeyComp3 identifies a compressed pay-to-pubkey script to
+	// a compressed pubkey.  Bit 0 specifies which y-coordinate to use
+	// to reconstruct the full uncompressed pubkey.
+	cstPayToPubKeyComp3 = 3
+
+	// cstPayToPubKeyUncomp4 identifies a compressed pay-to-pubkey script to
+	// an uncompressed pubkey.  Bit 0 specifies which y-coordinate to use
+	// to reconstruct the full uncompressed pubkey.
+	cstPayToPubKeyUncomp4 = 4
+
+	// cstPayToPubKeyUncomp5 identifies a compressed pay-to-pubkey script to
+	// an uncompressed pubkey.  Bit 0 specifies which y-coordinate to use
+	// to reconstruct the full uncompressed pubkey.
+	cstPayToPubKeyUncomp5 = 5
+
+	// numSpecialScripts is the number of special scripts recognized by the
+	// domain-specific script compression algorithm.
+	numSpecialScripts = 6
+)
+
+// isPubKeyHash returns whether or not the passed public key script is a
+// standard pay-to-pubkey-hash script along with the pubkey hash it is paying to
+// if it is.
+func isPubKeyHash(script []byte) (bool, []byte) {
+	if len(script) == 25 && script[0] == txscript.OP_DUP &&
+		script[1] == txscript.OP_HASH160 &&
+		script[2] == txscript.OP_DATA_20 &&
+		script[23] == txscript.OP_EQUALVERIFY &&
+		script[24] == txscript.OP_CHECKSIG {
+
+		return true, script[3:23]
+	}
+
+	return false, nil
+}
+
+// isScriptHash returns whether or not the passed public key script is a
+// standard pay-to-script-hash script along with the script hash it is paying to
+// if it is.
+func isScriptHash(script []byte) (bool, []byte) {
+	if len(script) == 23 && script[0] == txscript.OP_HASH160 &&
+		script[1] == txscript.OP_DATA_20 &&
+		script[22] == txscript.OP_EQUAL {
+
+		return true, script[2:22]
+	}
+
+	return false, nil
+}
+
+// isPubKey returns whether or not the passed public key script is a standard
+// pay-to-pubkey script that pays to a valid compressed or uncompressed public
+// key along with the serialized pubkey it is paying to if it is.
+//
+// NOTE: This function ensures the public key is actually valid since the
+// compression algorithm requires valid pubkeys.  It does not support hybrid
+// pubkeys.  This means that even if the script has the correct form for a
+// pay-to-pubkey script, this function will only return true when it is paying
+// to a valid compressed or uncompressed pubkey.
+func isPubKey(script []byte) (bool, []byte) {
+	// Pay-to-compressed-pubkey script.
+	if len(script) == 35 && script[0] == txscript.OP_DATA_33 &&
+		script[34] == txscript.OP_CHECKSIG && (script[1] == 0x02 ||
+		script[1] == 0x03) {
+
+		// Ensure the public key is valid.
+		serializedPubKey := script[1:34]
+		_, err := btcec.ParsePubKey(serializedPubKey, btcec.S256())
+		if err == nil {
+			return true, serializedPubKey
+		}
+	}
+
+	// Pay-to-uncompressed-pubkey script.
+	if len(script) == 67 && script[0] == txscript.OP_DATA_65 &&
+		script[66] == txscript.OP_CHECKSIG && script[1] == 0x04 {
+
+		// Ensure the public key is valid.
+		serializedPubKey := script[1:66]
+		_, err := btcec.ParsePubKey(serializedPubKey, btcec.S256())
+		if err == nil {
+			return true, serializedPubKey
+		}
+	}
+
+	return false, nil
+}
+
+// compressedScriptSize returns the number of bytes the passed script would take
+// when encoded with the domain specific compression algorithm described above.
+func compressedScriptSize(pkScript []byte, version int32) int {
+	// Pay-to-pubkey-hash script.
+	if valid, _ := isPubKeyHash(pkScript); valid {
+		return 21
+	}
+
+	// Pay-to-script-hash script.
+	if valid, _ := isScriptHash(pkScript); valid {
+		return 21
+	}
+
+	// Pay-to-pubkey (compressed or uncompressed) script.
+	if valid, _ := isPubKey(pkScript); valid {
+		return 33
+	}
+
+	// When none of the above special cases apply, encode the script as is
+	// preceded by the sum of its size and the number of special cases
+	// encoded as a variable length quantity.
+	return serializeSizeVLQ(uint64(len(pkScript)+numSpecialScripts)) +
+		len(pkScript)
+}
+
+// decodeCompressedScriptSize treats the passed serialized bytes as a compressed
+// script, possibly followed by other data, and returns the number of bytes it
+// occupies taking into account the special encoding of the script size by the
+// domain specific compression algorithm described above.
+func decodeCompressedScriptSize(serialized []byte, version int32) int {
+	scriptSize, bytesRead := deserializeVLQ(serialized)
+	if bytesRead == 0 {
+		return 0
+	}
+
+	switch scriptSize {
+	case cstPayToPubKeyHash:
+		return 21
+
+	case cstPayToScriptHash:
+		return 21
+
+	case cstPayToPubKeyComp2, cstPayToPubKeyComp3, cstPayToPubKeyUncomp4,
+		cstPayToPubKeyUncomp5:
+		return 33
+	}
+
+	scriptSize -= numSpecialScripts
+	scriptSize += uint64(bytesRead)
+	return int(scriptSize)
+}
+
+// putCompressedScript compresses the passed script according to the domain
+// specific compression algorithm described above directly into the passed
+// target byte slice.  The target byte slice must be at least large enough to
+// handle the number of bytes returned by the compressedScriptSize function or
+// it will panic.
+func putCompressedScript(target, pkScript []byte, version int32) int {
+	// Pay-to-pubkey-hash script.
+	if valid, hash := isPubKeyHash(pkScript); valid {
+		target[0] = cstPayToPubKeyHash
+		copy(target[1:21], hash)
+		return 21
+	}
+
+	// Pay-to-script-hash script.
+	if valid, hash := isScriptHash(pkScript); valid {
+		target[0] = cstPayToScriptHash
+		copy(target[1:21], hash)
+		return 21
+	}
+
+	// Pay-to-pubkey (compressed or uncompressed) script.
+	if valid, serializedPubKey := isPubKey(pkScript); valid {
+		pubKeyFormat := serializedPubKey[0]
+		switch pubKeyFormat {
+		case 0x02, 0x03:
+			target[0] = pubKeyFormat
+			copy(target[1:33], serializedPubKey[1:33])
+			return 33
+		case 0x04:
+			// Encode the oddness of the serialized pubkey into the
+			// compressed script type.
+			target[0] = pubKeyFormat | (serializedPubKey[64] & 0x01)
+			copy(target[1:33], serializedPubKey[1:33])
+			return 33
+		}
+	}
+
+	// When none of the above special cases apply, encode the unmodified
+	// script preceded by the sum of its size and the number of special
+	// cases encoded as a variable length quantity.
+	encodedSize := uint64(len(pkScript) + numSpecialScripts)
+	vlqSizeLen := putVLQ(target, encodedSize)
+	copy(target[vlqSizeLen:], pkScript)
+	return vlqSizeLen + len(pkScript)
+}
+
+// decompressScript returns the original script obtained by decompressing the
+// passed compressed script according to the domain specific compression
+// algorithm described above.
+//
+// NOTE: The script parameter must already have been proven to be long enough
+// to contain the number of bytes returned by decodeCompressedScriptSize or it
+// will panic.  This is acceptable since it is only an internal function.
+func decompressScript(compressedPkScript []byte, version int32) []byte {
+	// In practice this function will not be called with a zero-length or
+	// nil script since the nil script encoding includes the length, however
+	// the code below assumes the length exists, so just return nil now if
+	// the function ever ends up being called with a nil script in the
+	// future.
+	if len(compressedPkScript) == 0 {
+		return nil
+	}
+
+	// Decode the script size and examine it for the special cases.
+	encodedScriptSize, bytesRead := deserializeVLQ(compressedPkScript)
+	switch encodedScriptSize {
+	// Pay-to-pubkey-hash script.  The resulting script is:
+	// <OP_DUP><OP_HASH160><20 byte hash><OP_EQUALVERIFY><OP_CHECKSIG>
+	case cstPayToPubKeyHash:
+		pkScript := make([]byte, 25)
+		pkScript[0] = txscript.OP_DUP
+		pkScript[1] = txscript.OP_HASH160
+		pkScript[2] = txscript.OP_DATA_20
+		copy(pkScript[3:], compressedPkScript[bytesRead:bytesRead+20])
+		pkScript[23] = txscript.OP_EQUALVERIFY
+		pkScript[24] = txscript.OP_CHECKSIG
+		return pkScript
+
+	// Pay-to-script-hash script.  The resulting script is:
+	// <OP_HASH160><20 byte script hash><OP_EQUAL>
+	case cstPayToScriptHash:
+		pkScript := make([]byte, 23)
+		pkScript[0] = txscript.OP_HASH160
+		pkScript[1] = txscript.OP_DATA_20
+		copy(pkScript[2:], compressedPkScript[bytesRead:bytesRead+20])
+		pkScript[22] = txscript.OP_EQUAL
+		return pkScript
+
+	// Pay-to-compressed-pubkey script.  The resulting script is:
+	// <OP_DATA_33><33 byte compressed pubkey><OP_CHECKSIG>
+	case cstPayToPubKeyComp2, cstPayToPubKeyComp3:
+		pkScript := make([]byte, 35)
+		pkScript[0] = txscript.OP_DATA_33
+		pkScript[1] = byte(encodedScriptSize)
+		copy(pkScript[2:], compressedPkScript[bytesRead:bytesRead+32])
+		pkScript[34] = txscript.OP_CHECKSIG
+		return pkScript
+
+	// Pay-to-uncompressed-pubkey script.  The resulting script is:
+	// <OP_DATA_65><65 byte uncompressed pubkey><OP_CHECKSIG>
+	case cstPayToPubKeyUncomp4, cstPayToPubKeyUncomp5:
+		// Change the leading byte to the appropriate compressed pubkey
+		// identifier (0x02 or 0x03) so it can be decoded as a
+		// compressed pubkey.  This really should never fail since the
+		// encoding ensures it is valid before compressing to this type.
+		compressedKey := make([]byte, 33)
+		compressedKey[0] = byte(encodedScriptSize - 2)
+		copy(compressedKey[1:], compressedPkScript[1:])
+		key, err := btcec.ParsePubKey(compressedKey, btcec.S256())
+		if err != nil {
+			return nil
+		}
+
+		pkScript := make([]byte, 67)
+		pkScript[0] = txscript.OP_DATA_65
+		copy(pkScript[1:], key.SerializeUncompressed())
+		pkScript[66] = txscript.OP_CHECKSIG
+		return pkScript
+	}
+
+	// When none of the special cases apply, the script was encoded using
+	// the general format, so reduce the script size by the number of
+	// special cases and return the unmodified script.
+	scriptSize := int(encodedScriptSize - numSpecialScripts)
+	pkScript := make([]byte, scriptSize)
+	copy(pkScript, compressedPkScript[bytesRead:bytesRead+scriptSize])
+	return pkScript
+}
+
+// -----------------------------------------------------------------------------
+// In order to reduce the size of stored amounts, a domain specific compression
+// algorithm is used which relies on there typically being a lot of zeroes at
+// end of the amounts.  The compression algorithm used here was obtained from
+// Bitcoin Core, so all credits for the algorithm go to it.
+//
+// While this is simply exchanging one uint64 for another, the resulting value
+// for typical amounts has a much smaller magnitude which results in fewer bytes
+// when encoded as variable length quantity.  For example, consider the amount
+// of 0.1 BTC which is 10000000 satoshi.  Encoding 10000000 as a VLQ would take
+// 4 bytes while encoding the compressed value of 8 as a VLQ only takes 1 byte.
+//
+// Essentially the compression is achieved by splitting the value into an
+// exponent in the range [0-9] and a digit in the range [1-9], when possible,
+// and encoding them in a way that can be decoded.  More specifically, the
+// encoding is as follows:
+// - 0 is 0
+// - Find the exponent, e, as the largest power of 10 that evenly divides the
+//   value up to a maximum of 9
+// - When e < 9, the final digit can't be 0 so store it as d and remove it by
+//   dividing the value by 10 (call the result n).  The encoded value is thus:
+//   1 + 10*(9*n + d-1) + e
+// - When e==9, the only thing known is the amount is not 0.  The encoded value
+//   is thus:
+//   1 + 10*(n-1) + e   ==   10 + 10*(n-1)
+//
+// Example encodings:
+// (The numbers in parenthesis are the number of bytes when serialized as a VLQ)
+//            0 (1) -> 0        (1)           *  0.00000000 BTC
+//         1000 (2) -> 4        (1)           *  0.00001000 BTC
+//        10000 (2) -> 5        (1)           *  0.00010000 BTC
+//     12345678 (4) -> 111111101(4)           *  0.12345678 BTC
+//     50000000 (4) -> 47       (1)           *  0.50000000 BTC
+//    100000000 (4) -> 9        (1)           *  1.00000000 BTC
+//    500000000 (5) -> 49       (1)           *  5.00000000 BTC
+//   1000000000 (5) -> 10       (1)           * 10.00000000 BTC
+// -----------------------------------------------------------------------------
+
+// compressTxOutAmount compresses the passed amount according to the domain
+// specific compression algorithm described above.
+func compressTxOutAmount(amount uint64) uint64 {
+	// No need to do any work if it's zero.
+	if amount == 0 {
+		return 0
+	}
+
+	// Find the largest power of 10 (max of 9) that evenly divides the
+	// value.
+	exponent := uint64(0)
+	for amount%10 == 0 && exponent < 9 {
+		amount /= 10
+		exponent++
+	}
+
+	// The compressed result for exponents less than 9 is:
+	// 1 + 10*(9*n + d-1) + e
+	if exponent < 9 {
+		lastDigit := amount % 10
+		amount /= 10
+		return 1 + 10*(9*amount+lastDigit-1) + exponent
+	}
+
+	// The compressed result for an exponent of 9 is:
+	// 1 + 10*(n-1) + e   ==   10 + 10*(n-1)
+	return 10 + 10*(amount-1)
+}
+
+// decompressTxOutAmount returns the original amount the passed compressed
+// amount represents according to the domain specific compression algorithm
+// described above.
+func decompressTxOutAmount(amount uint64) uint64 {
+	// No need to do any work if it's zero.
+	if amount == 0 {
+		return 0
+	}
+
+	// The decompressed amount is either of the following two equations:
+	// x = 1 + 10*(9*n + d - 1) + e
+	// x = 1 + 10*(n - 1)       + 9
+	amount--
+
+	// The decompressed amount is now one of the following two equations:
+	// x = 10*(9*n + d - 1) + e
+	// x = 10*(n - 1)       + 9
+	exponent := amount % 10
+	amount /= 10
+
+	// The decompressed amount is now one of the following two equations:
+	// x = 9*n + d - 1  | where e < 9
+	// x = n - 1        | where e = 9
+	n := uint64(0)
+	if exponent < 9 {
+		lastDigit := amount%9 + 1
+		amount /= 9
+		n = amount*10 + lastDigit
+	} else {
+		n = amount + 1
+	}
+
+	// Apply the exponent.
+	for ; exponent > 0; exponent-- {
+		n *= 10
+	}
+
+	return n
+}
+
+// -----------------------------------------------------------------------------
+// Compressed transaction outputs consist of an amount and a public key script
+// both compressed using the domain specific compression algorithms previously
+// described.
+//
+// The serialized format is:
+//
+//   <compressed amount><compressed script>
+//
+//   Field                 Type     Size
+//     compressed amount   VLQ      variable
+//     compressed script   []byte   variable
+// -----------------------------------------------------------------------------
+
+// compressedTxOutSize returns the number of bytes the passed transaction output
+// fields would take when encoded with the format described above.  The
+// preCompressed flag indicates the provided amount and script are already
+// compressed.  This is useful since loaded utxo entries are not decompressed
+// until the output is accessed.
+func compressedTxOutSize(amount uint64, pkScript []byte, version int32, preCompressed bool) int {
+	if preCompressed {
+		return serializeSizeVLQ(amount) + len(pkScript)
+	}
+
+	return serializeSizeVLQ(compressTxOutAmount(amount)) +
+		compressedScriptSize(pkScript, version)
+}
+
+// putCompressedTxOut potentially compresses the passed amount and script
+// according to their domain specific compression algorithms and encodes them
+// directly into the passed target byte slice with the format described above.
+// The preCompressed flag indicates the provided amount and script are already
+// compressed in which case the values are not modified.  This is useful since
+// loaded utxo entries are not decompressed until the output is accessed.  The
+// target byte slice must be at least large enough to handle the number of bytes
+// returned by the compressedTxOutSize function or it will panic.
+func putCompressedTxOut(target []byte, amount uint64, pkScript []byte, version int32, preCompressed bool) int {
+	if preCompressed {
+		offset := putVLQ(target, amount)
+		copy(target[offset:], pkScript)
+		return offset + len(pkScript)
+	}
+
+	offset := putVLQ(target, compressTxOutAmount(amount))
+	offset += putCompressedScript(target[offset:], pkScript, version)
+	return offset
+}
+
+// decodeCompressedTxOut decodes the passed compressed txout, possibly followed
+// by other data, into its compressed amount and compressed script and returns
+// them along with the number of bytes they occupied.
+func decodeCompressedTxOut(serialized []byte, version int32) (uint64, []byte, int, error) {
+	// Deserialize the compressed amount and ensure there are bytes
+	// remaining for the compressed script.
+	compressedAmount, bytesRead := deserializeVLQ(serialized)
+	if bytesRead >= len(serialized) {
+		return 0, nil, bytesRead, errDeserialize("unexpected end of " +
+			"data after compressed amount")
+	}
+
+	// Decode the compressed script size and ensure there are enough bytes
+	// left in the slice for it.
+	scriptSize := decodeCompressedScriptSize(serialized[bytesRead:], version)
+	if len(serialized[bytesRead:]) < scriptSize {
+		return 0, nil, bytesRead, errDeserialize("unexpected end of " +
+			"data after script size")
+	}
+
+	// Make a copy of the compressed script so the original serialized data
+	// can be released as soon as possible.
+	compressedScript := make([]byte, scriptSize)
+	copy(compressedScript, serialized[bytesRead:bytesRead+scriptSize])
+	return compressedAmount, compressedScript, bytesRead + scriptSize, nil
+}

vendor/github.com/btcsuite/btcd/blockchain/compress_test.go

@@ -0,0 +1,491 @@
+// Copyright (c) 2015-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package blockchain
+
+import (
+	"bytes"
+	"encoding/hex"
+	"testing"
+)
+
+// hexToBytes converts the passed hex string into bytes and will panic if there
+// is an error.  This is only provided for the hard-coded constants so errors in
+// the source code can be detected. It will only (and must only) be called with
+// hard-coded values.
+func hexToBytes(s string) []byte {
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		panic("invalid hex in source file: " + s)
+	}
+	return b
+}
+
+// TestVLQ ensures the variable length quantity serialization, deserialization,
+// and size calculation works as expected.
+func TestVLQ(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		val        uint64
+		serialized []byte
+	}{
+		{0, hexToBytes("00")},
+		{1, hexToBytes("01")},
+		{127, hexToBytes("7f")},
+		{128, hexToBytes("8000")},
+		{129, hexToBytes("8001")},
+		{255, hexToBytes("807f")},
+		{256, hexToBytes("8100")},
+		{16383, hexToBytes("fe7f")},
+		{16384, hexToBytes("ff00")},
+		{16511, hexToBytes("ff7f")}, // Max 2-byte value
+		{16512, hexToBytes("808000")},
+		{16513, hexToBytes("808001")},
+		{16639, hexToBytes("80807f")},
+		{32895, hexToBytes("80ff7f")},
+		{2113663, hexToBytes("ffff7f")}, // Max 3-byte value
+		{2113664, hexToBytes("80808000")},
+		{270549119, hexToBytes("ffffff7f")}, // Max 4-byte value
+		{270549120, hexToBytes("8080808000")},
+		{2147483647, hexToBytes("86fefefe7f")},
+		{2147483648, hexToBytes("86fefeff00")},
+		{4294967295, hexToBytes("8efefefe7f")}, // Max uint32, 5 bytes
+		// Max uint64, 10 bytes
+		{18446744073709551615, hexToBytes("80fefefefefefefefe7f")},
+	}
+
+	for _, test := range tests {
+		// Ensure the function to calculate the serialized size without
+		// actually serializing the value is calculated properly.
+		gotSize := serializeSizeVLQ(test.val)
+		if gotSize != len(test.serialized) {
+			t.Errorf("serializeSizeVLQ: did not get expected size "+
+				"for %d - got %d, want %d", test.val, gotSize,
+				len(test.serialized))
+			continue
+		}
+
+		// Ensure the value serializes to the expected bytes.
+		gotBytes := make([]byte, gotSize)
+		gotBytesWritten := putVLQ(gotBytes, test.val)
+		if !bytes.Equal(gotBytes, test.serialized) {
+			t.Errorf("putVLQUnchecked: did not get expected bytes "+
+				"for %d - got %x, want %x", test.val, gotBytes,
+				test.serialized)
+			continue
+		}
+		if gotBytesWritten != len(test.serialized) {
+			t.Errorf("putVLQUnchecked: did not get expected number "+
+				"of bytes written for %d - got %d, want %d",
+				test.val, gotBytesWritten, len(test.serialized))
+			continue
+		}
+
+		// Ensure the serialized bytes deserialize to the expected
+		// value.
+		gotVal, gotBytesRead := deserializeVLQ(test.serialized)
+		if gotVal != test.val {
+			t.Errorf("deserializeVLQ: did not get expected value "+
+				"for %x - got %d, want %d", test.serialized,
+				gotVal, test.val)
+			continue
+		}
+		if gotBytesRead != len(test.serialized) {
+			t.Errorf("deserializeVLQ: did not get expected number "+
+				"of bytes read for %d - got %d, want %d",
+				test.serialized, gotBytesRead,
+				len(test.serialized))
+			continue
+		}
+	}
+}
+
+// TestScriptCompression ensures the domain-specific script compression and
+// decompression works as expected.
+func TestScriptCompression(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name         string
+		version      int32
+		uncompressed []byte
+		compressed   []byte
+	}{
+		{
+			name:         "nil",
+			version:      1,
+			uncompressed: nil,
+			compressed:   hexToBytes("06"),
+		},
+		{
+			name:         "pay-to-pubkey-hash 1",
+			version:      1,
+			uncompressed: hexToBytes("76a9141018853670f9f3b0582c5b9ee8ce93764ac32b9388ac"),
+			compressed:   hexToBytes("001018853670f9f3b0582c5b9ee8ce93764ac32b93"),
+		},
+		{
+			name:         "pay-to-pubkey-hash 2",
+			version:      1,
+			uncompressed: hexToBytes("76a914e34cce70c86373273efcc54ce7d2a491bb4a0e8488ac"),
+			compressed:   hexToBytes("00e34cce70c86373273efcc54ce7d2a491bb4a0e84"),
+		},
+		{
+			name:         "pay-to-script-hash 1",
+			version:      1,
+			uncompressed: hexToBytes("a914da1745e9b549bd0bfa1a569971c77eba30cd5a4b87"),
+			compressed:   hexToBytes("01da1745e9b549bd0bfa1a569971c77eba30cd5a4b"),
+		},
+		{
+			name:         "pay-to-script-hash 2",
+			version:      1,
+			uncompressed: hexToBytes("a914f815b036d9bbbce5e9f2a00abd1bf3dc91e9551087"),
+			compressed:   hexToBytes("01f815b036d9bbbce5e9f2a00abd1bf3dc91e95510"),
+		},
+		{
+			name:         "pay-to-pubkey compressed 0x02",
+			version:      1,
+			uncompressed: hexToBytes("2102192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4ac"),
+			compressed:   hexToBytes("02192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4"),
+		},
+		{
+			name:         "pay-to-pubkey compressed 0x03",
+			version:      1,
+			uncompressed: hexToBytes("2103b0bd634234abbb1ba1e986e884185c61cf43e001f9137f23c2c409273eb16e65ac"),
+			compressed:   hexToBytes("03b0bd634234abbb1ba1e986e884185c61cf43e001f9137f23c2c409273eb16e65"),
+		},
+		{
+			name:         "pay-to-pubkey uncompressed 0x04 even",
+			version:      1,
+			uncompressed: hexToBytes("4104192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b40d45264838c0bd96852662ce6a847b197376830160c6d2eb5e6a4c44d33f453eac"),
+			compressed:   hexToBytes("04192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4"),
+		},
+		{
+			name:         "pay-to-pubkey uncompressed 0x04 odd",
+			version:      1,
+			uncompressed: hexToBytes("410411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3ac"),
+			compressed:   hexToBytes("0511db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5c"),
+		},
+		{
+			name:         "pay-to-pubkey invalid pubkey",
+			version:      1,
+			uncompressed: hexToBytes("3302aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac"),
+			compressed:   hexToBytes("293302aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac"),
+		},
+		{
+			name:         "null data",
+			version:      1,
+			uncompressed: hexToBytes("6a200102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"),
+			compressed:   hexToBytes("286a200102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"),
+		},
+		{
+			name:         "requires 2 size bytes - data push 200 bytes",
+			version:      1,
+			uncompressed: append(hexToBytes("4cc8"), bytes.Repeat([]byte{0x00}, 200)...),
+			// [0x80, 0x50] = 208 as a variable length quantity
+			// [0x4c, 0xc8] = OP_PUSHDATA1 200
+			compressed: append(hexToBytes("80504cc8"), bytes.Repeat([]byte{0x00}, 200)...),
+		},
+	}
+
+	for _, test := range tests {
+		// Ensure the function to calculate the serialized size without
+		// actually serializing the value is calculated properly.
+		gotSize := compressedScriptSize(test.uncompressed, test.version)
+		if gotSize != len(test.compressed) {
+			t.Errorf("compressedScriptSize (%s): did not get "+
+				"expected size - got %d, want %d", test.name,
+				gotSize, len(test.compressed))
+			continue
+		}
+
+		// Ensure the script compresses to the expected bytes.
+		gotCompressed := make([]byte, gotSize)
+		gotBytesWritten := putCompressedScript(gotCompressed,
+			test.uncompressed, test.version)
+		if !bytes.Equal(gotCompressed, test.compressed) {
+			t.Errorf("putCompressedScript (%s): did not get "+
+				"expected bytes - got %x, want %x", test.name,
+				gotCompressed, test.compressed)
+			continue
+		}
+		if gotBytesWritten != len(test.compressed) {
+			t.Errorf("putCompressedScript (%s): did not get "+
+				"expected number of bytes written - got %d, "+
+				"want %d", test.name, gotBytesWritten,
+				len(test.compressed))
+			continue
+		}
+
+		// Ensure the compressed script size is properly decoded from
+		// the compressed script.
+		gotDecodedSize := decodeCompressedScriptSize(test.compressed,
+			test.version)
+		if gotDecodedSize != len(test.compressed) {
+			t.Errorf("decodeCompressedScriptSize (%s): did not get "+
+				"expected size - got %d, want %d", test.name,
+				gotDecodedSize, len(test.compressed))
+			continue
+		}
+
+		// Ensure the script decompresses to the expected bytes.
+		gotDecompressed := decompressScript(test.compressed, test.version)
+		if !bytes.Equal(gotDecompressed, test.uncompressed) {
+			t.Errorf("decompressScript (%s): did not get expected "+
+				"bytes - got %x, want %x", test.name,
+				gotDecompressed, test.uncompressed)
+			continue
+		}
+	}
+}
+
+// TestScriptCompressionErrors ensures calling various functions related to
+// script compression with incorrect data returns the expected results.
+func TestScriptCompressionErrors(t *testing.T) {
+	t.Parallel()
+
+	// A nil script must result in a decoded size of 0.
+	if gotSize := decodeCompressedScriptSize(nil, 1); gotSize != 0 {
+		t.Fatalf("decodeCompressedScriptSize with nil script did not "+
+			"return 0 - got %d", gotSize)
+	}
+
+	// A nil script must result in a nil decompressed script.
+	if gotScript := decompressScript(nil, 1); gotScript != nil {
+		t.Fatalf("decompressScript with nil script did not return nil "+
+			"decompressed script - got %x", gotScript)
+	}
+
+	// A compressed script for a pay-to-pubkey (uncompressed) that results
+	// in an invalid pubkey must result in a nil decompressed script.
+	compressedScript := hexToBytes("04012d74d0cb94344c9569c2e77901573d8d" +
+		"7903c3ebec3a957724895dca52c6b4")
+	if gotScript := decompressScript(compressedScript, 1); gotScript != nil {
+		t.Fatalf("decompressScript with compressed pay-to-"+
+			"uncompressed-pubkey that is invalid did not return "+
+			"nil decompressed script - got %x", gotScript)
+	}
+}
+
+// TestAmountCompression ensures the domain-specific transaction output amount
+// compression and decompression works as expected.
+func TestAmountCompression(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name         string
+		uncompressed uint64
+		compressed   uint64
+	}{
+		{
+			name:         "0 BTC (sometimes used in nulldata)",
+			uncompressed: 0,
+			compressed:   0,
+		},
+		{
+			name:         "546 Satoshi (current network dust value)",
+			uncompressed: 546,
+			compressed:   4911,
+		},
+		{
+			name:         "0.00001 BTC (typical transaction fee)",
+			uncompressed: 1000,
+			compressed:   4,
+		},
+		{
+			name:         "0.0001 BTC (typical transaction fee)",
+			uncompressed: 10000,
+			compressed:   5,
+		},
+		{
+			name:         "0.12345678 BTC",
+			uncompressed: 12345678,
+			compressed:   111111101,
+		},
+		{
+			name:         "0.5 BTC",
+			uncompressed: 50000000,
+			compressed:   48,
+		},
+		{
+			name:         "1 BTC",
+			uncompressed: 100000000,
+			compressed:   9,
+		},
+		{
+			name:         "5 BTC",
+			uncompressed: 500000000,
+			compressed:   49,
+		},
+		{
+			name:         "21000000 BTC (max minted coins)",
+			uncompressed: 2100000000000000,
+			compressed:   21000000,
+		},
+	}
+
+	for _, test := range tests {
+		// Ensure the amount compresses to the expected value.
+		gotCompressed := compressTxOutAmount(test.uncompressed)
+		if gotCompressed != test.compressed {
+			t.Errorf("compressTxOutAmount (%s): did not get "+
+				"expected value - got %d, want %d", test.name,
+				gotCompressed, test.compressed)
+			continue
+		}
+
+		// Ensure the value decompresses to the expected value.
+		gotDecompressed := decompressTxOutAmount(test.compressed)
+		if gotDecompressed != test.uncompressed {
+			t.Errorf("decompressTxOutAmount (%s): did not get "+
+				"expected value - got %d, want %d", test.name,
+				gotDecompressed, test.uncompressed)
+			continue
+		}
+	}
+}
+
+// TestCompressedTxOut ensures the transaction output serialization and
+// deserialization works as expected.
+func TestCompressedTxOut(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name         string
+		amount       uint64
+		compAmount   uint64
+		pkScript     []byte
+		compPkScript []byte
+		version      int32
+		compressed   []byte
+	}{
+		{
+			name:         "nulldata with 0 BTC",
+			amount:       0,
+			compAmount:   0,
+			pkScript:     hexToBytes("6a200102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"),
+			compPkScript: hexToBytes("286a200102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"),
+			version:      1,
+			compressed:   hexToBytes("00286a200102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20"),
+		},
+		{
+			name:         "pay-to-pubkey-hash dust",
+			amount:       546,
+			compAmount:   4911,
+			pkScript:     hexToBytes("76a9141018853670f9f3b0582c5b9ee8ce93764ac32b9388ac"),
+			compPkScript: hexToBytes("001018853670f9f3b0582c5b9ee8ce93764ac32b93"),
+			version:      1,
+			compressed:   hexToBytes("a52f001018853670f9f3b0582c5b9ee8ce93764ac32b93"),
+		},
+		{
+			name:         "pay-to-pubkey uncompressed 1 BTC",
+			amount:       100000000,
+			compAmount:   9,
+			pkScript:     hexToBytes("4104192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b40d45264838c0bd96852662ce6a847b197376830160c6d2eb5e6a4c44d33f453eac"),
+			compPkScript: hexToBytes("04192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4"),
+			version:      1,
+			compressed:   hexToBytes("0904192d74d0cb94344c9569c2e77901573d8d7903c3ebec3a957724895dca52c6b4"),
+		},
+	}
+
+	for _, test := range tests {
+		// Ensure the function to calculate the serialized size without
+		// actually serializing the txout is calculated properly.
+		gotSize := compressedTxOutSize(test.amount, test.pkScript,
+			test.version, false)
+		if gotSize != len(test.compressed) {
+			t.Errorf("compressedTxOutSize (%s): did not get "+
+				"expected size - got %d, want %d", test.name,
+				gotSize, len(test.compressed))
+			continue
+		}
+
+		// Ensure the txout compresses to the expected value.
+		gotCompressed := make([]byte, gotSize)
+		gotBytesWritten := putCompressedTxOut(gotCompressed,
+			test.amount, test.pkScript, test.version, false)
+		if !bytes.Equal(gotCompressed, test.compressed) {
+			t.Errorf("compressTxOut (%s): did not get expected "+
+				"bytes - got %x, want %x", test.name,
+				gotCompressed, test.compressed)
+			continue
+		}
+		if gotBytesWritten != len(test.compressed) {
+			t.Errorf("compressTxOut (%s): did not get expected "+
+				"number of bytes written - got %d, want %d",
+				test.name, gotBytesWritten,
+				len(test.compressed))
+			continue
+		}
+
+		// Ensure the serialized bytes are decoded back to the expected
+		// compressed values.
+		gotAmount, gotScript, gotBytesRead, err := decodeCompressedTxOut(
+			test.compressed, test.version)
+		if err != nil {
+			t.Errorf("decodeCompressedTxOut (%s): unexpected "+
+				"error: %v", test.name, err)
+			continue
+		}
+		if gotAmount != test.compAmount {
+			t.Errorf("decodeCompressedTxOut (%s): did not get "+
+				"expected amount - got %d, want %d",
+				test.name, gotAmount, test.compAmount)
+			continue
+		}
+		if !bytes.Equal(gotScript, test.compPkScript) {
+			t.Errorf("decodeCompressedTxOut (%s): did not get "+
+				"expected script - got %x, want %x",
+				test.name, gotScript, test.compPkScript)
+			continue
+		}
+		if gotBytesRead != len(test.compressed) {
+			t.Errorf("decodeCompressedTxOut (%s): did not get "+
+				"expected number of bytes read - got %d, want %d",
+				test.name, gotBytesRead, len(test.compressed))
+			continue
+		}
+
+		// Ensure the compressed values decompress to the expected
+		// txout.
+		gotAmount = decompressTxOutAmount(gotAmount)
+		if gotAmount != test.amount {
+			t.Errorf("decompressTxOut (%s): did not get expected "+
+				"value - got %d, want %d", test.name, gotAmount,
+				test.amount)
+			continue
+		}
+		gotScript = decompressScript(gotScript, test.version)
+		if !bytes.Equal(gotScript, test.pkScript) {
+			t.Errorf("decompressTxOut (%s): did not get expected "+
+				"script - got %x, want %x", test.name,
+				gotScript, test.pkScript)
+			continue
+		}
+	}
+}
+
+// TestTxOutCompressionErrors ensures calling various functions related to
+// txout compression with incorrect data returns the expected results.
+func TestTxOutCompressionErrors(t *testing.T) {
+	t.Parallel()
+
+	// A compressed txout with missing compressed script must error.
+	compressedTxOut := hexToBytes("00")
+	_, _, _, err := decodeCompressedTxOut(compressedTxOut, 1)
+	if !isDeserializeErr(err) {
+		t.Fatalf("decodeCompressedTxOut with missing compressed script "+
+			"did not return expected error type - got %T, want "+
+			"errDeserialize", err)
+	}
+
+	// A compressed txout with short compressed script must error.
+	compressedTxOut = hexToBytes("0010")
+	_, _, _, err = decodeCompressedTxOut(compressedTxOut, 1)
+	if !isDeserializeErr(err) {
+		t.Fatalf("decodeCompressedTxOut with short compressed script "+
+			"did not return expected error type - got %T, want "+
+			"errDeserialize", err)
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/difficulty.go

@@ -0,0 +1,312 @@
+// 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 blockchain
+
+import (
+	"math/big"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+)
+
+var (
+	// bigOne is 1 represented as a big.Int.  It is defined here to avoid
+	// the overhead of creating it multiple times.
+	bigOne = big.NewInt(1)
+
+	// oneLsh256 is 1 shifted left 256 bits.  It is defined here to avoid
+	// the overhead of creating it multiple times.
+	oneLsh256 = new(big.Int).Lsh(bigOne, 256)
+)
+
+// HashToBig converts a chainhash.Hash into a big.Int that can be used to
+// perform math comparisons.
+func HashToBig(hash *chainhash.Hash) *big.Int {
+	// A Hash is in little-endian, but the big package wants the bytes in
+	// big-endian, so reverse them.
+	buf := *hash
+	blen := len(buf)
+	for i := 0; i < blen/2; i++ {
+		buf[i], buf[blen-1-i] = buf[blen-1-i], buf[i]
+	}
+
+	return new(big.Int).SetBytes(buf[:])
+}
+
+// CompactToBig converts a compact representation of a whole number N to an
+// unsigned 32-bit number.  The representation is similar to IEEE754 floating
+// point numbers.
+//
+// Like IEEE754 floating point, there are three basic components: the sign,
+// the exponent, and the mantissa.  They are broken out as follows:
+//
+//	* the most significant 8 bits represent the unsigned base 256 exponent
+// 	* bit 23 (the 24th bit) represents the sign bit
+//	* the least significant 23 bits represent the mantissa
+//
+//	-------------------------------------------------
+//	|   Exponent     |    Sign    |    Mantissa     |
+//	-------------------------------------------------
+//	| 8 bits [31-24] | 1 bit [23] | 23 bits [22-00] |
+//	-------------------------------------------------
+//
+// The formula to calculate N is:
+// 	N = (-1^sign) * mantissa * 256^(exponent-3)
+//
+// This compact form is only used in bitcoin to encode unsigned 256-bit numbers
+// which represent difficulty targets, thus there really is not a need for a
+// sign bit, but it is implemented here to stay consistent with bitcoind.
+func CompactToBig(compact uint32) *big.Int {
+	// Extract the mantissa, sign bit, and exponent.
+	mantissa := compact & 0x007fffff
+	isNegative := compact&0x00800000 != 0
+	exponent := uint(compact >> 24)
+
+	// Since the base for the exponent is 256, the exponent can be treated
+	// as the number of bytes to represent the full 256-bit number.  So,
+	// treat the exponent as the number of bytes and shift the mantissa
+	// right or left accordingly.  This is equivalent to:
+	// N = mantissa * 256^(exponent-3)
+	var bn *big.Int
+	if exponent <= 3 {
+		mantissa >>= 8 * (3 - exponent)
+		bn = big.NewInt(int64(mantissa))
+	} else {
+		bn = big.NewInt(int64(mantissa))
+		bn.Lsh(bn, 8*(exponent-3))
+	}
+
+	// Make it negative if the sign bit is set.
+	if isNegative {
+		bn = bn.Neg(bn)
+	}
+
+	return bn
+}
+
+// BigToCompact converts a whole number N to a compact representation using
+// an unsigned 32-bit number.  The compact representation only provides 23 bits
+// of precision, so values larger than (2^23 - 1) only encode the most
+// significant digits of the number.  See CompactToBig for details.
+func BigToCompact(n *big.Int) uint32 {
+	// No need to do any work if it's zero.
+	if n.Sign() == 0 {
+		return 0
+	}
+
+	// Since the base for the exponent is 256, the exponent can be treated
+	// as the number of bytes.  So, shift the number right or left
+	// accordingly.  This is equivalent to:
+	// mantissa = mantissa / 256^(exponent-3)
+	var mantissa uint32
+	exponent := uint(len(n.Bytes()))
+	if exponent <= 3 {
+		mantissa = uint32(n.Bits()[0])
+		mantissa <<= 8 * (3 - exponent)
+	} else {
+		// Use a copy to avoid modifying the caller's original number.
+		tn := new(big.Int).Set(n)
+		mantissa = uint32(tn.Rsh(tn, 8*(exponent-3)).Bits()[0])
+	}
+
+	// When the mantissa already has the sign bit set, the number is too
+	// large to fit into the available 23-bits, so divide the number by 256
+	// and increment the exponent accordingly.
+	if mantissa&0x00800000 != 0 {
+		mantissa >>= 8
+		exponent++
+	}
+
+	// Pack the exponent, sign bit, and mantissa into an unsigned 32-bit
+	// int and return it.
+	compact := uint32(exponent<<24) | mantissa
+	if n.Sign() < 0 {
+		compact |= 0x00800000
+	}
+	return compact
+}
+
+// CalcWork calculates a work value from difficulty bits.  Bitcoin increases
+// the difficulty for generating a block by decreasing the value which the
+// generated hash must be less than.  This difficulty target is stored in each
+// block header using a compact representation as described in the documentation
+// for CompactToBig.  The main chain is selected by choosing the chain that has
+// the most proof of work (highest difficulty).  Since a lower target difficulty
+// value equates to higher actual difficulty, the work value which will be
+// accumulated must be the inverse of the difficulty.  Also, in order to avoid
+// potential division by zero and really small floating point numbers, the
+// result adds 1 to the denominator and multiplies the numerator by 2^256.
+func CalcWork(bits uint32) *big.Int {
+	// Return a work value of zero if the passed difficulty bits represent
+	// a negative number. Note this should not happen in practice with valid
+	// blocks, but an invalid block could trigger it.
+	difficultyNum := CompactToBig(bits)
+	if difficultyNum.Sign() <= 0 {
+		return big.NewInt(0)
+	}
+
+	// (1 << 256) / (difficultyNum + 1)
+	denominator := new(big.Int).Add(difficultyNum, bigOne)
+	return new(big.Int).Div(oneLsh256, denominator)
+}
+
+// calcEasiestDifficulty calculates the easiest possible difficulty that a block
+// can have given starting difficulty bits and a duration.  It is mainly used to
+// verify that claimed proof of work by a block is sane as compared to a
+// known good checkpoint.
+func (b *BlockChain) calcEasiestDifficulty(bits uint32, duration time.Duration) uint32 {
+	// Convert types used in the calculations below.
+	durationVal := int64(duration / time.Second)
+	adjustmentFactor := big.NewInt(b.chainParams.RetargetAdjustmentFactor)
+
+	// The test network rules allow minimum difficulty blocks after more
+	// than twice the desired amount of time needed to generate a block has
+	// elapsed.
+	if b.chainParams.ReduceMinDifficulty {
+		reductionTime := int64(b.chainParams.MinDiffReductionTime /
+			time.Second)
+		if durationVal > reductionTime {
+			return b.chainParams.PowLimitBits
+		}
+	}
+
+	// Since easier difficulty equates to higher numbers, the easiest
+	// difficulty for a given duration is the largest value possible given
+	// the number of retargets for the duration and starting difficulty
+	// multiplied by the max adjustment factor.
+	newTarget := CompactToBig(bits)
+	for durationVal > 0 && newTarget.Cmp(b.chainParams.PowLimit) < 0 {
+		newTarget.Mul(newTarget, adjustmentFactor)
+		durationVal -= b.maxRetargetTimespan
+	}
+
+	// Limit new value to the proof of work limit.
+	if newTarget.Cmp(b.chainParams.PowLimit) > 0 {
+		newTarget.Set(b.chainParams.PowLimit)
+	}
+
+	return BigToCompact(newTarget)
+}
+
+// findPrevTestNetDifficulty returns the difficulty of the previous block which
+// did not have the special testnet minimum difficulty rule applied.
+//
+// This function MUST be called with the chain state lock held (for writes).
+func (b *BlockChain) findPrevTestNetDifficulty(startNode *blockNode) uint32 {
+	// Search backwards through the chain for the last block without
+	// the special rule applied.
+	iterNode := startNode
+	for iterNode != nil && iterNode.height%b.blocksPerRetarget != 0 &&
+		iterNode.bits == b.chainParams.PowLimitBits {
+
+		iterNode = iterNode.parent
+	}
+
+	// Return the found difficulty or the minimum difficulty if no
+	// appropriate block was found.
+	lastBits := b.chainParams.PowLimitBits
+	if iterNode != nil {
+		lastBits = iterNode.bits
+	}
+	return lastBits
+}
+
+// calcNextRequiredDifficulty calculates the required difficulty for the block
+// after the passed previous block node based on the difficulty retarget rules.
+// This function differs from the exported CalcNextRequiredDifficulty in that
+// the exported version uses the current best chain as the previous block node
+// while this function accepts any block node.
+func (b *BlockChain) calcNextRequiredDifficulty(lastNode *blockNode, newBlockTime time.Time) (uint32, error) {
+	// Genesis block.
+	if lastNode == nil {
+		return b.chainParams.PowLimitBits, nil
+	}
+
+	// Return the previous block's difficulty requirements if this block
+	// is not at a difficulty retarget interval.
+	if (lastNode.height+1)%b.blocksPerRetarget != 0 {
+		// For networks that support it, allow special reduction of the
+		// required difficulty once too much time has elapsed without
+		// mining a block.
+		if b.chainParams.ReduceMinDifficulty {
+			// Return minimum difficulty when more than the desired
+			// amount of time has elapsed without mining a block.
+			reductionTime := int64(b.chainParams.MinDiffReductionTime /
+				time.Second)
+			allowMinTime := lastNode.timestamp + reductionTime
+			if newBlockTime.Unix() > allowMinTime {
+				return b.chainParams.PowLimitBits, nil
+			}
+
+			// The block was mined within the desired timeframe, so
+			// return the difficulty for the last block which did
+			// not have the special minimum difficulty rule applied.
+			return b.findPrevTestNetDifficulty(lastNode), nil
+		}
+
+		// For the main network (or any unrecognized networks), simply
+		// return the previous block's difficulty requirements.
+		return lastNode.bits, nil
+	}
+
+	// Get the block node at the previous retarget (targetTimespan days
+	// worth of blocks).
+	firstNode := lastNode.RelativeAncestor(b.blocksPerRetarget - 1)
+	if firstNode == nil {
+		return 0, AssertError("unable to obtain previous retarget block")
+	}
+
+	// Limit the amount of adjustment that can occur to the previous
+	// difficulty.
+	actualTimespan := lastNode.timestamp - firstNode.timestamp
+	adjustedTimespan := actualTimespan
+	if actualTimespan < b.minRetargetTimespan {
+		adjustedTimespan = b.minRetargetTimespan
+	} else if actualTimespan > b.maxRetargetTimespan {
+		adjustedTimespan = b.maxRetargetTimespan
+	}
+
+	// Calculate new target difficulty as:
+	//  currentDifficulty * (adjustedTimespan / targetTimespan)
+	// The result uses integer division which means it will be slightly
+	// rounded down.  Bitcoind also uses integer division to calculate this
+	// result.
+	oldTarget := CompactToBig(lastNode.bits)
+	newTarget := new(big.Int).Mul(oldTarget, big.NewInt(adjustedTimespan))
+	targetTimeSpan := int64(b.chainParams.TargetTimespan / time.Second)
+	newTarget.Div(newTarget, big.NewInt(targetTimeSpan))
+
+	// Limit new value to the proof of work limit.
+	if newTarget.Cmp(b.chainParams.PowLimit) > 0 {
+		newTarget.Set(b.chainParams.PowLimit)
+	}
+
+	// Log new target difficulty and return it.  The new target logging is
+	// intentionally converting the bits back to a number instead of using
+	// newTarget since conversion to the compact representation loses
+	// precision.
+	newTargetBits := BigToCompact(newTarget)
+	log.Debugf("Difficulty retarget at block height %d", lastNode.height+1)
+	log.Debugf("Old target %08x (%064x)", lastNode.bits, oldTarget)
+	log.Debugf("New target %08x (%064x)", newTargetBits, CompactToBig(newTargetBits))
+	log.Debugf("Actual timespan %v, adjusted timespan %v, target timespan %v",
+		time.Duration(actualTimespan)*time.Second,
+		time.Duration(adjustedTimespan)*time.Second,
+		b.chainParams.TargetTimespan)
+
+	return newTargetBits, nil
+}
+
+// CalcNextRequiredDifficulty calculates the required difficulty for the block
+// after the end of the current best chain based on the difficulty retarget
+// rules.
+//
+// This function is safe for concurrent access.
+func (b *BlockChain) CalcNextRequiredDifficulty(timestamp time.Time) (uint32, error) {
+	b.chainLock.Lock()
+	difficulty, err := b.calcNextRequiredDifficulty(b.bestChain.Tip(), timestamp)
+	b.chainLock.Unlock()
+	return difficulty, err
+}

vendor/github.com/btcsuite/btcd/blockchain/difficulty_test.go

@@ -0,0 +1,75 @@
+// Copyright (c) 2014-2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package blockchain
+
+import (
+	"math/big"
+	"testing"
+)
+
+// TestBigToCompact ensures BigToCompact converts big integers to the expected
+// compact representation.
+func TestBigToCompact(t *testing.T) {
+	tests := []struct {
+		in  int64
+		out uint32
+	}{
+		{0, 0},
+		{-1, 25231360},
+	}
+
+	for x, test := range tests {
+		n := big.NewInt(test.in)
+		r := BigToCompact(n)
+		if r != test.out {
+			t.Errorf("TestBigToCompact test #%d failed: got %d want %d\n",
+				x, r, test.out)
+			return
+		}
+	}
+}
+
+// TestCompactToBig ensures CompactToBig converts numbers using the compact
+// representation to the expected big intergers.
+func TestCompactToBig(t *testing.T) {
+	tests := []struct {
+		in  uint32
+		out int64
+	}{
+		{10000000, 0},
+	}
+
+	for x, test := range tests {
+		n := CompactToBig(test.in)
+		want := big.NewInt(test.out)
+		if n.Cmp(want) != 0 {
+			t.Errorf("TestCompactToBig test #%d failed: got %d want %d\n",
+				x, n.Int64(), want.Int64())
+			return
+		}
+	}
+}
+
+// TestCalcWork ensures CalcWork calculates the expected work value from values
+// in compact representation.
+func TestCalcWork(t *testing.T) {
+	tests := []struct {
+		in  uint32
+		out int64
+	}{
+		{10000000, 0},
+	}
+
+	for x, test := range tests {
+		bits := uint32(test.in)
+
+		r := CalcWork(bits)
+		if r.Int64() != test.out {
+			t.Errorf("TestCalcWork test #%d failed: got %v want %d\n",
+				x, r.Int64(), test.out)
+			return
+		}
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/doc.go

@@ -0,0 +1,81 @@
+// 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 blockchain implements bitcoin block handling and chain selection rules.
+
+The bitcoin block handling and chain selection rules are an integral, and quite
+likely the most important, part of bitcoin.  Unfortunately, at the time of
+this writing, these rules are also largely undocumented and had to be
+ascertained from the bitcoind source code.  At its core, bitcoin is a
+distributed consensus of which blocks are valid and which ones will comprise the
+main block chain (public ledger) that ultimately determines accepted
+transactions, so it is extremely important that fully validating nodes agree on
+all rules.
+
+At a high level, this package provides support for inserting new blocks into
+the block chain according to the aforementioned rules.  It includes
+functionality such as rejecting duplicate blocks, ensuring blocks and
+transactions follow all rules, orphan handling, and best chain selection along
+with reorganization.
+
+Since this package does not deal with other bitcoin specifics such as network
+communication or wallets, it provides a notification system which gives the
+caller a high level of flexibility in how they want to react to certain events
+such as orphan blocks which need their parents requested and newly connected
+main chain blocks which might result in wallet updates.
+
+Bitcoin Chain Processing Overview
+
+Before a block is allowed into the block chain, it must go through an intensive
+series of validation rules.  The following list serves as a general outline of
+those rules to provide some intuition into what is going on under the hood, but
+is by no means exhaustive:
+
+ - Reject duplicate blocks
+ - Perform a series of sanity checks on the block and its transactions such as
+   verifying proof of work, timestamps, number and character of transactions,
+   transaction amounts, script complexity, and merkle root calculations
+ - Compare the block against predetermined checkpoints for expected timestamps
+   and difficulty based on elapsed time since the checkpoint
+ - Save the most recent orphan blocks for a limited time in case their parent
+   blocks become available
+ - Stop processing if the block is an orphan as the rest of the processing
+   depends on the block's position within the block chain
+ - Perform a series of more thorough checks that depend on the block's position
+   within the block chain such as verifying block difficulties adhere to
+   difficulty retarget rules, timestamps are after the median of the last
+   several blocks, all transactions are finalized, checkpoint blocks match, and
+   block versions are in line with the previous blocks
+ - Determine how the block fits into the chain and perform different actions
+   accordingly in order to ensure any side chains which have higher difficulty
+   than the main chain become the new main chain
+ - When a block is being connected to the main chain (either through
+   reorganization of a side chain to the main chain or just extending the
+   main chain), perform further checks on the block's transactions such as
+   verifying transaction duplicates, script complexity for the combination of
+   connected scripts, coinbase maturity, double spends, and connected
+   transaction values
+ - Run the transaction scripts to verify the spender is allowed to spend the
+   coins
+ - Insert the block into the block database
+
+Errors
+
+Errors returned by this package are either the raw errors provided by underlying
+calls or of type blockchain.RuleError.  This allows the caller to differentiate
+between unexpected errors, such as database errors, versus errors due to rule
+violations through type assertions.  In addition, callers can programmatically
+determine the specific rule violation by examining the ErrorCode field of the
+type asserted blockchain.RuleError.
+
+Bitcoin Improvement Proposals
+
+This package includes spec changes outlined by the following BIPs:
+
+		BIP0016 (https://en.bitcoin.it/wiki/BIP_0016)
+		BIP0030 (https://en.bitcoin.it/wiki/BIP_0030)
+		BIP0034 (https://en.bitcoin.it/wiki/BIP_0034)
+*/
+package blockchain

vendor/github.com/btcsuite/btcd/blockchain/error.go

@@ -0,0 +1,298 @@
+// Copyright (c) 2014-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package blockchain
+
+import (
+	"fmt"
+)
+
+// DeploymentError identifies an error that indicates a deployment ID was
+// specified that does not exist.
+type DeploymentError uint32
+
+// Error returns the assertion error as a human-readable string and satisfies
+// the error interface.
+func (e DeploymentError) Error() string {
+	return fmt.Sprintf("deployment ID %d does not exist", uint32(e))
+}
+
+// AssertError identifies an error that indicates an internal code consistency
+// issue and should be treated as a critical and unrecoverable error.
+type AssertError string
+
+// Error returns the assertion error as a human-readable string and satisfies
+// the error interface.
+func (e AssertError) Error() string {
+	return "assertion failed: " + string(e)
+}
+
+// ErrorCode identifies a kind of error.
+type ErrorCode int
+
+// These constants are used to identify a specific RuleError.
+const (
+	// ErrDuplicateBlock indicates a block with the same hash already
+	// exists.
+	ErrDuplicateBlock ErrorCode = iota
+
+	// ErrBlockTooBig indicates the serialized block size exceeds the
+	// maximum allowed size.
+	ErrBlockTooBig
+
+	// ErrBlockWeightTooHigh indicates that the block's computed weight
+	// metric exceeds the maximum allowed value.
+	ErrBlockWeightTooHigh
+
+	// ErrBlockVersionTooOld indicates the block version is too old and is
+	// no longer accepted since the majority of the network has upgraded
+	// to a newer version.
+	ErrBlockVersionTooOld
+
+	// ErrInvalidTime indicates the time in the passed block has a precision
+	// that is more than one second.  The chain consensus rules require
+	// timestamps to have a maximum precision of one second.
+	ErrInvalidTime
+
+	// ErrTimeTooOld indicates the time is either before the median time of
+	// the last several blocks per the chain consensus rules or prior to the
+	// most recent checkpoint.
+	ErrTimeTooOld
+
+	// ErrTimeTooNew indicates the time is too far in the future as compared
+	// the current time.
+	ErrTimeTooNew
+
+	// ErrDifficultyTooLow indicates the difficulty for the block is lower
+	// than the difficulty required by the most recent checkpoint.
+	ErrDifficultyTooLow
+
+	// ErrUnexpectedDifficulty indicates specified bits do not align with
+	// the expected value either because it doesn't match the calculated
+	// valued based on difficulty regarted rules or it is out of the valid
+	// range.
+	ErrUnexpectedDifficulty
+
+	// ErrHighHash indicates the block does not hash to a value which is
+	// lower than the required target difficultly.
+	ErrHighHash
+
+	// ErrBadMerkleRoot indicates the calculated merkle root does not match
+	// the expected value.
+	ErrBadMerkleRoot
+
+	// ErrBadCheckpoint indicates a block that is expected to be at a
+	// checkpoint height does not match the expected one.
+	ErrBadCheckpoint
+
+	// ErrForkTooOld indicates a block is attempting to fork the block chain
+	// before the most recent checkpoint.
+	ErrForkTooOld
+
+	// ErrCheckpointTimeTooOld indicates a block has a timestamp before the
+	// most recent checkpoint.
+	ErrCheckpointTimeTooOld
+
+	// ErrNoTransactions indicates the block does not have a least one
+	// transaction.  A valid block must have at least the coinbase
+	// transaction.
+	ErrNoTransactions
+
+	// ErrNoTxInputs indicates a transaction does not have any inputs.  A
+	// valid transaction must have at least one input.
+	ErrNoTxInputs
+
+	// ErrNoTxOutputs indicates a transaction does not have any outputs.  A
+	// valid transaction must have at least one output.
+	ErrNoTxOutputs
+
+	// ErrTxTooBig indicates a transaction exceeds the maximum allowed size
+	// when serialized.
+	ErrTxTooBig
+
+	// ErrBadTxOutValue indicates an output value for a transaction is
+	// invalid in some way such as being out of range.
+	ErrBadTxOutValue
+
+	// ErrDuplicateTxInputs indicates a transaction references the same
+	// input more than once.
+	ErrDuplicateTxInputs
+
+	// ErrBadTxInput indicates a transaction input is invalid in some way
+	// such as referencing a previous transaction outpoint which is out of
+	// range or not referencing one at all.
+	ErrBadTxInput
+
+	// ErrMissingTxOut indicates a transaction output referenced by an input
+	// either does not exist or has already been spent.
+	ErrMissingTxOut
+
+	// ErrUnfinalizedTx indicates a transaction has not been finalized.
+	// A valid block may only contain finalized transactions.
+	ErrUnfinalizedTx
+
+	// ErrDuplicateTx indicates a block contains an identical transaction
+	// (or at least two transactions which hash to the same value).  A
+	// valid block may only contain unique transactions.
+	ErrDuplicateTx
+
+	// ErrOverwriteTx indicates a block contains a transaction that has
+	// the same hash as a previous transaction which has not been fully
+	// spent.
+	ErrOverwriteTx
+
+	// ErrImmatureSpend indicates a transaction is attempting to spend a
+	// coinbase that has not yet reached the required maturity.
+	ErrImmatureSpend
+
+	// ErrSpendTooHigh indicates a transaction is attempting to spend more
+	// value than the sum of all of its inputs.
+	ErrSpendTooHigh
+
+	// ErrBadFees indicates the total fees for a block are invalid due to
+	// exceeding the maximum possible value.
+	ErrBadFees
+
+	// ErrTooManySigOps indicates the total number of signature operations
+	// for a transaction or block exceed the maximum allowed limits.
+	ErrTooManySigOps
+
+	// ErrFirstTxNotCoinbase indicates the first transaction in a block
+	// is not a coinbase transaction.
+	ErrFirstTxNotCoinbase
+
+	// ErrMultipleCoinbases indicates a block contains more than one
+	// coinbase transaction.
+	ErrMultipleCoinbases
+
+	// ErrBadCoinbaseScriptLen indicates the length of the signature script
+	// for a coinbase transaction is not within the valid range.
+	ErrBadCoinbaseScriptLen
+
+	// ErrBadCoinbaseValue indicates the amount of a coinbase value does
+	// not match the expected value of the subsidy plus the sum of all fees.
+	ErrBadCoinbaseValue
+
+	// ErrMissingCoinbaseHeight indicates the coinbase transaction for a
+	// block does not start with the serialized block block height as
+	// required for version 2 and higher blocks.
+	ErrMissingCoinbaseHeight
+
+	// ErrBadCoinbaseHeight indicates the serialized block height in the
+	// coinbase transaction for version 2 and higher blocks does not match
+	// the expected value.
+	ErrBadCoinbaseHeight
+
+	// ErrScriptMalformed indicates a transaction script is malformed in
+	// some way.  For example, it might be longer than the maximum allowed
+	// length or fail to parse.
+	ErrScriptMalformed
+
+	// ErrScriptValidation indicates the result of executing transaction
+	// script failed.  The error covers any failure when executing scripts
+	// such signature verification failures and execution past the end of
+	// the stack.
+	ErrScriptValidation
+
+	// ErrUnexpectedWitness indicates that a block includes transactions
+	// with witness data, but doesn't also have a witness commitment within
+	// the coinbase transaction.
+	ErrUnexpectedWitness
+
+	// ErrInvalidWitnessCommitment indicates that a block's witness
+	// commitment is not well formed.
+	ErrInvalidWitnessCommitment
+
+	// ErrWitnessCommitmentMismatch indicates that the witness commitment
+	// included in the block's coinbase transaction doesn't match the
+	// manually computed witness commitment.
+	ErrWitnessCommitmentMismatch
+
+	// ErrPreviousBlockUnknown indicates that the previous block is not known.
+	ErrPreviousBlockUnknown
+
+	// ErrInvalidAncestorBlock indicates that an ancestor of this block has
+	// already failed validation.
+	ErrInvalidAncestorBlock
+
+	// ErrPrevBlockNotBest indicates that the block's previous block is not the
+	// current chain tip. This is not a block validation rule, but is required
+	// for block proposals submitted via getblocktemplate RPC.
+	ErrPrevBlockNotBest
+)
+
+// Map of ErrorCode values back to their constant names for pretty printing.
+var errorCodeStrings = map[ErrorCode]string{
+	ErrDuplicateBlock:            "ErrDuplicateBlock",
+	ErrBlockTooBig:               "ErrBlockTooBig",
+	ErrBlockVersionTooOld:        "ErrBlockVersionTooOld",
+	ErrBlockWeightTooHigh:        "ErrBlockWeightTooHigh",
+	ErrInvalidTime:               "ErrInvalidTime",
+	ErrTimeTooOld:                "ErrTimeTooOld",
+	ErrTimeTooNew:                "ErrTimeTooNew",
+	ErrDifficultyTooLow:          "ErrDifficultyTooLow",
+	ErrUnexpectedDifficulty:      "ErrUnexpectedDifficulty",
+	ErrHighHash:                  "ErrHighHash",
+	ErrBadMerkleRoot:             "ErrBadMerkleRoot",
+	ErrBadCheckpoint:             "ErrBadCheckpoint",
+	ErrForkTooOld:                "ErrForkTooOld",
+	ErrCheckpointTimeTooOld:      "ErrCheckpointTimeTooOld",
+	ErrNoTransactions:            "ErrNoTransactions",
+	ErrNoTxInputs:                "ErrNoTxInputs",
+	ErrNoTxOutputs:               "ErrNoTxOutputs",
+	ErrTxTooBig:                  "ErrTxTooBig",
+	ErrBadTxOutValue:             "ErrBadTxOutValue",
+	ErrDuplicateTxInputs:         "ErrDuplicateTxInputs",
+	ErrBadTxInput:                "ErrBadTxInput",
+	ErrMissingTxOut:              "ErrMissingTxOut",
+	ErrUnfinalizedTx:             "ErrUnfinalizedTx",
+	ErrDuplicateTx:               "ErrDuplicateTx",
+	ErrOverwriteTx:               "ErrOverwriteTx",
+	ErrImmatureSpend:             "ErrImmatureSpend",
+	ErrSpendTooHigh:              "ErrSpendTooHigh",
+	ErrBadFees:                   "ErrBadFees",
+	ErrTooManySigOps:             "ErrTooManySigOps",
+	ErrFirstTxNotCoinbase:        "ErrFirstTxNotCoinbase",
+	ErrMultipleCoinbases:         "ErrMultipleCoinbases",
+	ErrBadCoinbaseScriptLen:      "ErrBadCoinbaseScriptLen",
+	ErrBadCoinbaseValue:          "ErrBadCoinbaseValue",
+	ErrMissingCoinbaseHeight:     "ErrMissingCoinbaseHeight",
+	ErrBadCoinbaseHeight:         "ErrBadCoinbaseHeight",
+	ErrScriptMalformed:           "ErrScriptMalformed",
+	ErrScriptValidation:          "ErrScriptValidation",
+	ErrUnexpectedWitness:         "ErrUnexpectedWitness",
+	ErrInvalidWitnessCommitment:  "ErrInvalidWitnessCommitment",
+	ErrWitnessCommitmentMismatch: "ErrWitnessCommitmentMismatch",
+	ErrPreviousBlockUnknown:      "ErrPreviousBlockUnknown",
+	ErrInvalidAncestorBlock:      "ErrInvalidAncestorBlock",
+	ErrPrevBlockNotBest:          "ErrPrevBlockNotBest",
+}
+
+// String returns the ErrorCode as a human-readable name.
+func (e ErrorCode) String() string {
+	if s := errorCodeStrings[e]; s != "" {
+		return s
+	}
+	return fmt.Sprintf("Unknown ErrorCode (%d)", int(e))
+}
+
+// RuleError identifies a rule violation.  It is used to indicate that
+// processing of a block or transaction failed due to one of the many validation
+// rules.  The caller can use type assertions to determine if a failure was
+// specifically due to a rule violation and access the ErrorCode field to
+// ascertain the specific reason for the rule violation.
+type RuleError struct {
+	ErrorCode   ErrorCode // Describes the kind of error
+	Description string    // Human readable description of the issue
+}
+
+// Error satisfies the error interface and prints human-readable errors.
+func (e RuleError) Error() string {
+	return e.Description
+}
+
+// ruleError creates an RuleError given a set of arguments.
+func ruleError(c ErrorCode, desc string) RuleError {
+	return RuleError{ErrorCode: c, Description: desc}
+}

vendor/github.com/btcsuite/btcd/blockchain/error_test.go

@@ -0,0 +1,134 @@
+// Copyright (c) 2014-2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package blockchain
+
+import (
+	"testing"
+)
+
+// TestErrorCodeStringer tests the stringized output for the ErrorCode type.
+func TestErrorCodeStringer(t *testing.T) {
+	tests := []struct {
+		in   ErrorCode
+		want string
+	}{
+		{ErrDuplicateBlock, "ErrDuplicateBlock"},
+		{ErrBlockTooBig, "ErrBlockTooBig"},
+		{ErrBlockWeightTooHigh, "ErrBlockWeightTooHigh"},
+		{ErrBlockVersionTooOld, "ErrBlockVersionTooOld"},
+		{ErrInvalidTime, "ErrInvalidTime"},
+		{ErrTimeTooOld, "ErrTimeTooOld"},
+		{ErrTimeTooNew, "ErrTimeTooNew"},
+		{ErrDifficultyTooLow, "ErrDifficultyTooLow"},
+		{ErrUnexpectedDifficulty, "ErrUnexpectedDifficulty"},
+		{ErrHighHash, "ErrHighHash"},
+		{ErrBadMerkleRoot, "ErrBadMerkleRoot"},
+		{ErrBadCheckpoint, "ErrBadCheckpoint"},
+		{ErrForkTooOld, "ErrForkTooOld"},
+		{ErrCheckpointTimeTooOld, "ErrCheckpointTimeTooOld"},
+		{ErrNoTransactions, "ErrNoTransactions"},
+		{ErrNoTxInputs, "ErrNoTxInputs"},
+		{ErrNoTxOutputs, "ErrNoTxOutputs"},
+		{ErrTxTooBig, "ErrTxTooBig"},
+		{ErrBadTxOutValue, "ErrBadTxOutValue"},
+		{ErrDuplicateTxInputs, "ErrDuplicateTxInputs"},
+		{ErrBadTxInput, "ErrBadTxInput"},
+		{ErrBadCheckpoint, "ErrBadCheckpoint"},
+		{ErrMissingTxOut, "ErrMissingTxOut"},
+		{ErrUnfinalizedTx, "ErrUnfinalizedTx"},
+		{ErrDuplicateTx, "ErrDuplicateTx"},
+		{ErrOverwriteTx, "ErrOverwriteTx"},
+		{ErrImmatureSpend, "ErrImmatureSpend"},
+		{ErrSpendTooHigh, "ErrSpendTooHigh"},
+		{ErrBadFees, "ErrBadFees"},
+		{ErrTooManySigOps, "ErrTooManySigOps"},
+		{ErrFirstTxNotCoinbase, "ErrFirstTxNotCoinbase"},
+		{ErrMultipleCoinbases, "ErrMultipleCoinbases"},
+		{ErrBadCoinbaseScriptLen, "ErrBadCoinbaseScriptLen"},
+		{ErrBadCoinbaseValue, "ErrBadCoinbaseValue"},
+		{ErrMissingCoinbaseHeight, "ErrMissingCoinbaseHeight"},
+		{ErrBadCoinbaseHeight, "ErrBadCoinbaseHeight"},
+		{ErrScriptMalformed, "ErrScriptMalformed"},
+		{ErrScriptValidation, "ErrScriptValidation"},
+		{ErrUnexpectedWitness, "ErrUnexpectedWitness"},
+		{ErrInvalidWitnessCommitment, "ErrInvalidWitnessCommitment"},
+		{ErrWitnessCommitmentMismatch, "ErrWitnessCommitmentMismatch"},
+		{ErrPreviousBlockUnknown, "ErrPreviousBlockUnknown"},
+		{ErrInvalidAncestorBlock, "ErrInvalidAncestorBlock"},
+		{ErrPrevBlockNotBest, "ErrPrevBlockNotBest"},
+		{0xffff, "Unknown ErrorCode (65535)"},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		result := test.in.String()
+		if result != test.want {
+			t.Errorf("String #%d\n got: %s want: %s", i, result,
+				test.want)
+			continue
+		}
+	}
+}
+
+// TestRuleError tests the error output for the RuleError type.
+func TestRuleError(t *testing.T) {
+	tests := []struct {
+		in   RuleError
+		want string
+	}{
+		{
+			RuleError{Description: "duplicate block"},
+			"duplicate block",
+		},
+		{
+			RuleError{Description: "human-readable error"},
+			"human-readable error",
+		},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		result := test.in.Error()
+		if result != test.want {
+			t.Errorf("Error #%d\n got: %s want: %s", i, result,
+				test.want)
+			continue
+		}
+	}
+}
+
+// TestDeploymentError tests the stringized output for the DeploymentError type.
+func TestDeploymentError(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		in   DeploymentError
+		want string
+	}{
+		{
+			DeploymentError(0),
+			"deployment ID 0 does not exist",
+		},
+		{
+			DeploymentError(10),
+			"deployment ID 10 does not exist",
+		},
+		{
+			DeploymentError(123),
+			"deployment ID 123 does not exist",
+		},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		result := test.in.Error()
+		if result != test.want {
+			t.Errorf("Error #%d\n got: %s want: %s", i, result,
+				test.want)
+			continue
+		}
+	}
+
+}

vendor/github.com/btcsuite/btcd/blockchain/example_test.go

@@ -0,0 +1,107 @@
+// Copyright (c) 2014-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package blockchain_test
+
+import (
+	"fmt"
+	"math/big"
+	"os"
+	"path/filepath"
+
+	"github.com/btcsuite/btcd/blockchain"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/database"
+	_ "github.com/btcsuite/btcd/database/ffldb"
+	"github.com/btcsuite/btcutil"
+)
+
+// This example demonstrates how to create a new chain instance and use
+// ProcessBlock to attempt to attempt add a block to the chain.  As the package
+// overview documentation describes, this includes all of the Bitcoin consensus
+// rules.  This example intentionally attempts to insert a duplicate genesis
+// block to illustrate how an invalid block is handled.
+func ExampleBlockChain_ProcessBlock() {
+	// Create a new database to store the accepted blocks into.  Typically
+	// this would be opening an existing database and would not be deleting
+	// and creating a new database like this, but it is done here so this is
+	// a complete working example and does not leave temporary files laying
+	// around.
+	dbPath := filepath.Join(os.TempDir(), "exampleprocessblock")
+	_ = os.RemoveAll(dbPath)
+	db, err := database.Create("ffldb", dbPath, chaincfg.MainNetParams.Net)
+	if err != nil {
+		fmt.Printf("Failed to create database: %v\n", err)
+		return
+	}
+	defer os.RemoveAll(dbPath)
+	defer db.Close()
+
+	// Create a new BlockChain instance using the underlying database for
+	// the main bitcoin network.  This example does not demonstrate some
+	// of the other available configuration options such as specifying a
+	// notification callback and signature cache.  Also, the caller would
+	// ordinarily keep a reference to the median time source and add time
+	// values obtained from other peers on the network so the local time is
+	// adjusted to be in agreement with other peers.
+	chain, err := blockchain.New(&blockchain.Config{
+		DB:          db,
+		ChainParams: &chaincfg.MainNetParams,
+		TimeSource:  blockchain.NewMedianTime(),
+	})
+	if err != nil {
+		fmt.Printf("Failed to create chain instance: %v\n", err)
+		return
+	}
+
+	// Process a block.  For this example, we are going to intentionally
+	// cause an error by trying to process the genesis block which already
+	// exists.
+	genesisBlock := btcutil.NewBlock(chaincfg.MainNetParams.GenesisBlock)
+	isMainChain, isOrphan, err := chain.ProcessBlock(genesisBlock,
+		blockchain.BFNone)
+	if err != nil {
+		fmt.Printf("Failed to process block: %v\n", err)
+		return
+	}
+	fmt.Printf("Block accepted. Is it on the main chain?: %v", isMainChain)
+	fmt.Printf("Block accepted. Is it an orphan?: %v", isOrphan)
+
+	// Output:
+	// Failed to process block: already have block 000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f
+}
+
+// This example demonstrates how to convert the compact "bits" in a block header
+// which represent the target difficulty to a big integer and display it using
+// the typical hex notation.
+func ExampleCompactToBig() {
+	// Convert the bits from block 300000 in the main block chain.
+	bits := uint32(419465580)
+	targetDifficulty := blockchain.CompactToBig(bits)
+
+	// Display it in hex.
+	fmt.Printf("%064x\n", targetDifficulty.Bytes())
+
+	// Output:
+	// 0000000000000000896c00000000000000000000000000000000000000000000
+}
+
+// This example demonstrates how to convert a target difficulty into the compact
+// "bits" in a block header which represent that target difficulty .
+func ExampleBigToCompact() {
+	// Convert the target difficulty from block 300000 in the main block
+	// chain to compact form.
+	t := "0000000000000000896c00000000000000000000000000000000000000000000"
+	targetDifficulty, success := new(big.Int).SetString(t, 16)
+	if !success {
+		fmt.Println("invalid target difficulty")
+		return
+	}
+	bits := blockchain.BigToCompact(targetDifficulty)
+
+	fmt.Println(bits)
+
+	// Output:
+	// 419465580
+}

vendor/github.com/btcsuite/btcd/blockchain/fullblocks_test.go

@@ -0,0 +1,310 @@
+// Copyright (c) 2016 The Decred developers
+// 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 blockchain_test
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/btcsuite/btcd/blockchain"
+	"github.com/btcsuite/btcd/blockchain/fullblocktests"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/database"
+	_ "github.com/btcsuite/btcd/database/ffldb"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+)
+
+const (
+	// testDbType is the database backend type to use for the tests.
+	testDbType = "ffldb"
+
+	// testDbRoot is the root directory used to create all test databases.
+	testDbRoot = "testdbs"
+
+	// blockDataNet is the expected network in the test block data.
+	blockDataNet = wire.MainNet
+)
+
+// filesExists returns whether or not the named file or directory exists.
+func fileExists(name string) bool {
+	if _, err := os.Stat(name); err != nil {
+		if os.IsNotExist(err) {
+			return false
+		}
+	}
+	return true
+}
+
+// isSupportedDbType returns whether or not the passed database type is
+// currently supported.
+func isSupportedDbType(dbType string) bool {
+	supportedDrivers := database.SupportedDrivers()
+	for _, driver := range supportedDrivers {
+		if dbType == driver {
+			return true
+		}
+	}
+
+	return false
+}
+
+// chainSetup is used to create a new db and chain instance with the genesis
+// block already inserted.  In addition to the new chain instance, it returns
+// a teardown function the caller should invoke when done testing to clean up.
+func chainSetup(dbName string, params *chaincfg.Params) (*blockchain.BlockChain, func(), error) {
+	if !isSupportedDbType(testDbType) {
+		return nil, nil, fmt.Errorf("unsupported db type %v", testDbType)
+	}
+
+	// Handle memory database specially since it doesn't need the disk
+	// specific handling.
+	var db database.DB
+	var teardown func()
+	if testDbType == "memdb" {
+		ndb, err := database.Create(testDbType)
+		if err != nil {
+			return nil, nil, fmt.Errorf("error creating db: %v", err)
+		}
+		db = ndb
+
+		// Setup a teardown function for cleaning up.  This function is
+		// returned to the caller to be invoked when it is done testing.
+		teardown = func() {
+			db.Close()
+		}
+	} else {
+		// Create the root directory for test databases.
+		if !fileExists(testDbRoot) {
+			if err := os.MkdirAll(testDbRoot, 0700); err != nil {
+				err := fmt.Errorf("unable to create test db "+
+					"root: %v", err)
+				return nil, nil, err
+			}
+		}
+
+		// Create a new database to store the accepted blocks into.
+		dbPath := filepath.Join(testDbRoot, dbName)
+		_ = os.RemoveAll(dbPath)
+		ndb, err := database.Create(testDbType, dbPath, blockDataNet)
+		if err != nil {
+			return nil, nil, fmt.Errorf("error creating db: %v", err)
+		}
+		db = ndb
+
+		// Setup a teardown function for cleaning up.  This function is
+		// returned to the caller to be invoked when it is done testing.
+		teardown = func() {
+			db.Close()
+			os.RemoveAll(dbPath)
+			os.RemoveAll(testDbRoot)
+		}
+	}
+
+	// Copy the chain params to ensure any modifications the tests do to
+	// the chain parameters do not affect the global instance.
+	paramsCopy := *params
+
+	// Create the main chain instance.
+	chain, err := blockchain.New(&blockchain.Config{
+		DB:          db,
+		ChainParams: &paramsCopy,
+		Checkpoints: nil,
+		TimeSource:  blockchain.NewMedianTime(),
+		SigCache:    txscript.NewSigCache(1000),
+	})
+	if err != nil {
+		teardown()
+		err := fmt.Errorf("failed to create chain instance: %v", err)
+		return nil, nil, err
+	}
+	return chain, teardown, nil
+}
+
+// TestFullBlocks ensures all tests generated by the fullblocktests package
+// have the expected result when processed via ProcessBlock.
+func TestFullBlocks(t *testing.T) {
+	tests, err := fullblocktests.Generate(false)
+	if err != nil {
+		t.Fatalf("failed to generate tests: %v", err)
+	}
+
+	// Create a new database and chain instance to run tests against.
+	chain, teardownFunc, err := chainSetup("fullblocktest",
+		&chaincfg.RegressionNetParams)
+	if err != nil {
+		t.Errorf("Failed to setup chain instance: %v", err)
+		return
+	}
+	defer teardownFunc()
+
+	// testAcceptedBlock attempts to process the block in the provided test
+	// instance and ensures that it was accepted according to the flags
+	// specified in the test.
+	testAcceptedBlock := func(item fullblocktests.AcceptedBlock) {
+		blockHeight := item.Height
+		block := btcutil.NewBlock(item.Block)
+		block.SetHeight(blockHeight)
+		t.Logf("Testing block %s (hash %s, height %d)",
+			item.Name, block.Hash(), blockHeight)
+
+		isMainChain, isOrphan, err := chain.ProcessBlock(block,
+			blockchain.BFNone)
+		if err != nil {
+			t.Fatalf("block %q (hash %s, height %d) should "+
+				"have been accepted: %v", item.Name,
+				block.Hash(), blockHeight, err)
+		}
+
+		// Ensure the main chain and orphan flags match the values
+		// specified in the test.
+		if isMainChain != item.IsMainChain {
+			t.Fatalf("block %q (hash %s, height %d) unexpected main "+
+				"chain flag -- got %v, want %v", item.Name,
+				block.Hash(), blockHeight, isMainChain,
+				item.IsMainChain)
+		}
+		if isOrphan != item.IsOrphan {
+			t.Fatalf("block %q (hash %s, height %d) unexpected "+
+				"orphan flag -- got %v, want %v", item.Name,
+				block.Hash(), blockHeight, isOrphan,
+				item.IsOrphan)
+		}
+	}
+
+	// testRejectedBlock attempts to process the block in the provided test
+	// instance and ensures that it was rejected with the reject code
+	// specified in the test.
+	testRejectedBlock := func(item fullblocktests.RejectedBlock) {
+		blockHeight := item.Height
+		block := btcutil.NewBlock(item.Block)
+		block.SetHeight(blockHeight)
+		t.Logf("Testing block %s (hash %s, height %d)",
+			item.Name, block.Hash(), blockHeight)
+
+		_, _, err := chain.ProcessBlock(block, blockchain.BFNone)
+		if err == nil {
+			t.Fatalf("block %q (hash %s, height %d) should not "+
+				"have been accepted", item.Name, block.Hash(),
+				blockHeight)
+		}
+
+		// Ensure the error code is of the expected type and the reject
+		// code matches the value specified in the test instance.
+		rerr, ok := err.(blockchain.RuleError)
+		if !ok {
+			t.Fatalf("block %q (hash %s, height %d) returned "+
+				"unexpected error type -- got %T, want "+
+				"blockchain.RuleError", item.Name, block.Hash(),
+				blockHeight, err)
+		}
+		if rerr.ErrorCode != item.RejectCode {
+			t.Fatalf("block %q (hash %s, height %d) does not have "+
+				"expected reject code -- got %v, want %v",
+				item.Name, block.Hash(), blockHeight,
+				rerr.ErrorCode, item.RejectCode)
+		}
+	}
+
+	// testRejectedNonCanonicalBlock attempts to decode the block in the
+	// provided test instance and ensures that it failed to decode with a
+	// message error.
+	testRejectedNonCanonicalBlock := func(item fullblocktests.RejectedNonCanonicalBlock) {
+		headerLen := len(item.RawBlock)
+		if headerLen > 80 {
+			headerLen = 80
+		}
+		blockHash := chainhash.DoubleHashH(item.RawBlock[0:headerLen])
+		blockHeight := item.Height
+		t.Logf("Testing block %s (hash %s, height %d)", item.Name,
+			blockHash, blockHeight)
+
+		// Ensure there is an error due to deserializing the block.
+		var msgBlock wire.MsgBlock
+		err := msgBlock.BtcDecode(bytes.NewReader(item.RawBlock), 0, wire.BaseEncoding)
+		if _, ok := err.(*wire.MessageError); !ok {
+			t.Fatalf("block %q (hash %s, height %d) should have "+
+				"failed to decode", item.Name, blockHash,
+				blockHeight)
+		}
+	}
+
+	// testOrphanOrRejectedBlock attempts to process the block in the
+	// provided test instance and ensures that it was either accepted as an
+	// orphan or rejected with a rule violation.
+	testOrphanOrRejectedBlock := func(item fullblocktests.OrphanOrRejectedBlock) {
+		blockHeight := item.Height
+		block := btcutil.NewBlock(item.Block)
+		block.SetHeight(blockHeight)
+		t.Logf("Testing block %s (hash %s, height %d)",
+			item.Name, block.Hash(), blockHeight)
+
+		_, isOrphan, err := chain.ProcessBlock(block, blockchain.BFNone)
+		if err != nil {
+			// Ensure the error code is of the expected type.
+			if _, ok := err.(blockchain.RuleError); !ok {
+				t.Fatalf("block %q (hash %s, height %d) "+
+					"returned unexpected error type -- "+
+					"got %T, want blockchain.RuleError",
+					item.Name, block.Hash(), blockHeight,
+					err)
+			}
+		}
+
+		if !isOrphan {
+			t.Fatalf("block %q (hash %s, height %d) was accepted, "+
+				"but is not considered an orphan", item.Name,
+				block.Hash(), blockHeight)
+		}
+	}
+
+	// testExpectedTip ensures the current tip of the blockchain is the
+	// block specified in the provided test instance.
+	testExpectedTip := func(item fullblocktests.ExpectedTip) {
+		blockHeight := item.Height
+		block := btcutil.NewBlock(item.Block)
+		block.SetHeight(blockHeight)
+		t.Logf("Testing tip for block %s (hash %s, height %d)",
+			item.Name, block.Hash(), blockHeight)
+
+		// Ensure hash and height match.
+		best := chain.BestSnapshot()
+		if best.Hash != item.Block.BlockHash() ||
+			best.Height != blockHeight {
+
+			t.Fatalf("block %q (hash %s, height %d) should be "+
+				"the current tip -- got (hash %s, height %d)",
+				item.Name, block.Hash(), blockHeight, best.Hash,
+				best.Height)
+		}
+	}
+
+	for testNum, test := range tests {
+		for itemNum, item := range test {
+			switch item := item.(type) {
+			case fullblocktests.AcceptedBlock:
+				testAcceptedBlock(item)
+			case fullblocktests.RejectedBlock:
+				testRejectedBlock(item)
+			case fullblocktests.RejectedNonCanonicalBlock:
+				testRejectedNonCanonicalBlock(item)
+			case fullblocktests.OrphanOrRejectedBlock:
+				testOrphanOrRejectedBlock(item)
+			case fullblocktests.ExpectedTip:
+				testExpectedTip(item)
+			default:
+				t.Fatalf("test #%d, item #%d is not one of "+
+					"the supported test instance types -- "+
+					"got type: %T", testNum, itemNum, item)
+			}
+		}
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/fullblocktests/README.md

@@ -0,0 +1,29 @@
+fullblocktests
+==============
+
+[![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/blockchain/fullblocktests)
+
+Package fullblocktests provides a set of full block tests to be used for testing
+the consensus validation rules.  The tests are intended to be flexible enough to
+allow both unit-style tests directly against the blockchain code as well as
+integration style tests over the peer-to-peer network.  To achieve that goal,
+each test contains additional information about the expected result, however
+that information can be ignored when doing comparison tests between two
+independent versions over the peer-to-peer network.
+
+This package has intentionally been designed so it can be used as a standalone
+package for any projects needing to test their implementation against a full set
+of blocks that excerise the consensus validation rules.
+
+## Installation and Updating
+
+```bash
+$ go get -u github.com/btcsuite/btcd/blockchain/fullblocktests
+```
+
+## License
+
+Package fullblocktests is licensed under the [copyfree](http://copyfree.org) ISC
+License.

vendor/github.com/btcsuite/btcd/blockchain/fullblocktests/doc.go

@@ -0,0 +1,20 @@
+// 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 fullblocktests provides a set of block consensus validation tests.
+
+All of the generated test instances involve full blocks that are to be used for
+testing the consensus validation rules.  The tests are intended to be flexible
+enough to allow both unit-style tests directly against the blockchain code as
+well as integration style tests over the peer-to-peer network.  To achieve that
+goal, each test contains additional information about the expected result,
+however that information can be ignored when doing comparison tests between two
+independent versions over the peer-to-peer network.
+
+This package has intentionally been designed so it can be used as a standalone
+package for any projects needing to test their implementation against a full set
+of blocks that excerise the consensus validation rules.
+*/
+package fullblocktests

vendor/github.com/btcsuite/btcd/blockchain/fullblocktests/params.go

@@ -0,0 +1,135 @@
+// 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 fullblocktests
+
+import (
+	"encoding/hex"
+	"math/big"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+)
+
+// newHashFromStr converts the passed big-endian hex string into a
+// wire.Hash.  It only differs from the one available in chainhash in that
+// it panics on an error since it will only (and must only) be called with
+// hard-coded, and therefore known good, hashes.
+func newHashFromStr(hexStr string) *chainhash.Hash {
+	hash, err := chainhash.NewHashFromStr(hexStr)
+	if err != nil {
+		panic(err)
+	}
+	return hash
+}
+
+// fromHex converts the passed hex string into a byte slice and will panic if
+// there is an error.  This is only provided for the hard-coded constants so
+// errors in the source code can be detected. It will only (and must only) be
+// called for initialization purposes.
+func fromHex(s string) []byte {
+	r, err := hex.DecodeString(s)
+	if err != nil {
+		panic("invalid hex in source file: " + s)
+	}
+	return r
+}
+
+var (
+	// bigOne is 1 represented as a big.Int.  It is defined here to avoid
+	// the overhead of creating it multiple times.
+	bigOne = big.NewInt(1)
+
+	// regressionPowLimit is the highest proof of work value a Bitcoin block
+	// can have for the regression test network.  It is the value 2^255 - 1.
+	regressionPowLimit = new(big.Int).Sub(new(big.Int).Lsh(bigOne, 255), bigOne)
+
+	// regTestGenesisBlock defines the genesis block of the block chain which serves
+	// as the public transaction ledger for the regression test network.
+	regTestGenesisBlock = wire.MsgBlock{
+		Header: wire.BlockHeader{
+			Version:    1,
+			PrevBlock:  *newHashFromStr("0000000000000000000000000000000000000000000000000000000000000000"),
+			MerkleRoot: *newHashFromStr("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"),
+			Timestamp:  time.Unix(1296688602, 0), // 2011-02-02 23:16:42 +0000 UTC
+			Bits:       0x207fffff,               // 545259519 [7fffff0000000000000000000000000000000000000000000000000000000000]
+			Nonce:      2,
+		},
+		Transactions: []*wire.MsgTx{{
+			Version: 1,
+			TxIn: []*wire.TxIn{{
+				PreviousOutPoint: wire.OutPoint{
+					Hash:  chainhash.Hash{},
+					Index: 0xffffffff,
+				},
+				SignatureScript: fromHex("04ffff001d010445" +
+					"5468652054696d65732030332f4a616e2f" +
+					"32303039204368616e63656c6c6f72206f" +
+					"6e206272696e6b206f66207365636f6e64" +
+					"206261696c6f757420666f72206261686b73"),
+				Sequence: 0xffffffff,
+			}},
+			TxOut: []*wire.TxOut{{
+				Value: 0,
+				PkScript: fromHex("4104678afdb0fe5548271967f1" +
+					"a67130b7105cd6a828e03909a67962e0ea1f" +
+					"61deb649f6bc3f4cef38c4f35504e51ec138" +
+					"c4f35504e51ec112de5c384df7ba0b8d578a" +
+					"4c702b6bf11d5fac"),
+			}},
+			LockTime: 0,
+		}},
+	}
+)
+
+// regressionNetParams defines the network parameters for the regression test
+// network.
+//
+// NOTE: The test generator intentionally does not use the existing definitions
+// in the chaincfg package since the intent is to be able to generate known
+// good tests which exercise that code.  Using the chaincfg parameters would
+// allow them to change out from under the tests potentially invalidating them.
+var regressionNetParams = &chaincfg.Params{
+	Name:        "regtest",
+	Net:         wire.TestNet,
+	DefaultPort: "18444",
+
+	// Chain parameters
+	GenesisBlock:             &regTestGenesisBlock,
+	GenesisHash:              newHashFromStr("5bec7567af40504e0994db3b573c186fffcc4edefe096ff2e58d00523bd7e8a6"),
+	PowLimit:                 regressionPowLimit,
+	PowLimitBits:             0x207fffff,
+	CoinbaseMaturity:         100,
+	BIP0034Height:            100000000, // Not active - Permit ver 1 blocks
+	BIP0065Height:            1351,      // Used by regression tests
+	BIP0066Height:            1251,      // Used by regression tests
+	SubsidyReductionInterval: 150,
+	TargetTimespan:           time.Hour * 24 * 14, // 14 days
+	TargetTimePerBlock:       time.Minute * 10,    // 10 minutes
+	RetargetAdjustmentFactor: 4,                   // 25% less, 400% more
+	ReduceMinDifficulty:      true,
+	MinDiffReductionTime:     time.Minute * 20, // TargetTimePerBlock * 2
+	GenerateSupported:        true,
+
+	// Checkpoints ordered from oldest to newest.
+	Checkpoints: nil,
+
+	// Mempool parameters
+	RelayNonStdTxs: true,
+
+	// Address encoding magics
+	PubKeyHashAddrID: 0x6f, // starts with m or n
+	ScriptHashAddrID: 0xc4, // starts with 2
+	PrivateKeyID:     0xef, // starts with 9 (uncompressed) or c (compressed)
+
+	// BIP32 hierarchical deterministic extended key magics
+	HDPrivateKeyID: [4]byte{0x04, 0x35, 0x83, 0x94}, // starts with tprv
+	HDPublicKeyID:  [4]byte{0x04, 0x35, 0x87, 0xcf}, // starts with tpub
+
+	// BIP44 coin type used in the hierarchical deterministic path for
+	// address generation.
+	HDCoinType: 1,
+}

vendor/github.com/btcsuite/btcd/blockchain/indexers/README.md

@@ -0,0 +1,32 @@
+indexers
+========
+
+[![Build Status](https://travis-ci.org/btcsuite/btcd.png?branch=master)](https://travis-ci.org/btcsuite/btcd)
+[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
+[![GoDoc](https://godoc.org/github.com/btcsuite/btcd/blockchain/indexers?status.png)](http://godoc.org/github.com/btcsuite/btcd/blockchain/indexers)
+
+Package indexers implements optional block chain indexes.
+
+These indexes are typically used to enhance the amount of information available
+via an RPC interface.
+
+## Supported Indexers
+
+- Transaction-by-hash (txbyhashidx) Index
+  - Creates a mapping from the hash of each transaction to the block that
+    contains it along with its offset and length within the serialized block
+- Transaction-by-address (txbyaddridx) Index
+  - Creates a mapping from every address to all transactions which either credit
+    or debit the address
+  - Requires the transaction-by-hash index
+
+## Installation
+
+```bash
+$ go get -u github.com/btcsuite/btcd/blockchain/indexers
+```
+
+## License
+
+Package indexers is licensed under the [copyfree](http://copyfree.org) ISC
+License.

vendor/github.com/btcsuite/btcd/blockchain/indexers/addrindex.go

@@ -0,0 +1,963 @@
+// 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 indexers
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+
+	"github.com/btcsuite/btcd/blockchain"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/database"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+)
+
+const (
+	// addrIndexName is the human-readable name for the index.
+	addrIndexName = "address index"
+
+	// level0MaxEntries is the maximum number of transactions that are
+	// stored in level 0 of an address index entry.  Subsequent levels store
+	// 2^n * level0MaxEntries entries, or in words, double the maximum of
+	// the previous level.
+	level0MaxEntries = 8
+
+	// addrKeySize is the number of bytes an address key consumes in the
+	// index.  It consists of 1 byte address type + 20 bytes hash160.
+	addrKeySize = 1 + 20
+
+	// levelKeySize is the number of bytes a level key in the address index
+	// consumes.  It consists of the address key + 1 byte for the level.
+	levelKeySize = addrKeySize + 1
+
+	// levelOffset is the offset in the level key which identifes the level.
+	levelOffset = levelKeySize - 1
+
+	// addrKeyTypePubKeyHash is the address type in an address key which
+	// represents both a pay-to-pubkey-hash and a pay-to-pubkey address.
+	// This is done because both are identical for the purposes of the
+	// address index.
+	addrKeyTypePubKeyHash = 0
+
+	// addrKeyTypeScriptHash is the address type in an address key which
+	// represents a pay-to-script-hash address.  This is necessary because
+	// the hash of a pubkey address might be the same as that of a script
+	// hash.
+	addrKeyTypeScriptHash = 1
+
+	// addrKeyTypePubKeyHash is the address type in an address key which
+	// represents a pay-to-witness-pubkey-hash address. This is required
+	// as the 20-byte data push of a p2wkh witness program may be the same
+	// data push used a p2pkh address.
+	addrKeyTypeWitnessPubKeyHash = 2
+
+	// addrKeyTypeScriptHash is the address type in an address key which
+	// represents a pay-to-witness-script-hash address. This is required,
+	// as p2wsh are distinct from p2sh addresses since they use a new
+	// script template, as well as a 32-byte data push.
+	addrKeyTypeWitnessScriptHash = 3
+
+	// Size of a transaction entry.  It consists of 4 bytes block id + 4
+	// bytes offset + 4 bytes length.
+	txEntrySize = 4 + 4 + 4
+)
+
+var (
+	// addrIndexKey is the key of the address index and the db bucket used
+	// to house it.
+	addrIndexKey = []byte("txbyaddridx")
+
+	// errUnsupportedAddressType is an error that is used to signal an
+	// unsupported address type has been used.
+	errUnsupportedAddressType = errors.New("address type is not supported " +
+		"by the address index")
+)
+
+// -----------------------------------------------------------------------------
+// The address index maps addresses referenced in the blockchain to a list of
+// all the transactions involving that address.  Transactions are stored
+// according to their order of appearance in the blockchain.  That is to say
+// first by block height and then by offset inside the block.  It is also
+// important to note that this implementation requires the transaction index
+// since it is needed in order to catch up old blocks due to the fact the spent
+// outputs will already be pruned from the utxo set.
+//
+// The approach used to store the index is similar to a log-structured merge
+// tree (LSM tree) and is thus similar to how leveldb works internally.
+//
+// Every address consists of one or more entries identified by a level starting
+// from 0 where each level holds a maximum number of entries such that each
+// subsequent level holds double the maximum of the previous one.  In equation
+// form, the number of entries each level holds is 2^n * firstLevelMaxSize.
+//
+// New transactions are appended to level 0 until it becomes full at which point
+// the entire level 0 entry is appended to the level 1 entry and level 0 is
+// cleared.  This process continues until level 1 becomes full at which point it
+// will be appended to level 2 and cleared and so on.
+//
+// The result of this is the lower levels contain newer transactions and the
+// transactions within each level are ordered from oldest to newest.
+//
+// The intent of this approach is to provide a balance between space efficiency
+// and indexing cost.  Storing one entry per transaction would have the lowest
+// indexing cost, but would waste a lot of space because the same address hash
+// would be duplicated for every transaction key.  On the other hand, storing a
+// single entry with all transactions would be the most space efficient, but
+// would cause indexing cost to grow quadratically with the number of
+// transactions involving the same address.  The approach used here provides
+// logarithmic insertion and retrieval.
+//
+// The serialized key format is:
+//
+//   <addr type><addr hash><level>
+//
+//   Field           Type      Size
+//   addr type       uint8     1 byte
+//   addr hash       hash160   20 bytes
+//   level           uint8     1 byte
+//   -----
+//   Total: 22 bytes
+//
+// The serialized value format is:
+//
+//   [<block id><start offset><tx length>,...]
+//
+//   Field           Type      Size
+//   block id        uint32    4 bytes
+//   start offset    uint32    4 bytes
+//   tx length       uint32    4 bytes
+//   -----
+//   Total: 12 bytes per indexed tx
+// -----------------------------------------------------------------------------
+
+// fetchBlockHashFunc defines a callback function to use in order to convert a
+// serialized block ID to an associated block hash.
+type fetchBlockHashFunc func(serializedID []byte) (*chainhash.Hash, error)
+
+// serializeAddrIndexEntry serializes the provided block id and transaction
+// location according to the format described in detail above.
+func serializeAddrIndexEntry(blockID uint32, txLoc wire.TxLoc) []byte {
+	// Serialize the entry.
+	serialized := make([]byte, 12)
+	byteOrder.PutUint32(serialized, blockID)
+	byteOrder.PutUint32(serialized[4:], uint32(txLoc.TxStart))
+	byteOrder.PutUint32(serialized[8:], uint32(txLoc.TxLen))
+	return serialized
+}
+
+// deserializeAddrIndexEntry decodes the passed serialized byte slice into the
+// provided region struct according to the format described in detail above and
+// uses the passed block hash fetching function in order to conver the block ID
+// to the associated block hash.
+func deserializeAddrIndexEntry(serialized []byte, region *database.BlockRegion, fetchBlockHash fetchBlockHashFunc) error {
+	// Ensure there are enough bytes to decode.
+	if len(serialized) < txEntrySize {
+		return errDeserialize("unexpected end of data")
+	}
+
+	hash, err := fetchBlockHash(serialized[0:4])
+	if err != nil {
+		return err
+	}
+	region.Hash = hash
+	region.Offset = byteOrder.Uint32(serialized[4:8])
+	region.Len = byteOrder.Uint32(serialized[8:12])
+	return nil
+}
+
+// keyForLevel returns the key for a specific address and level in the address
+// index entry.
+func keyForLevel(addrKey [addrKeySize]byte, level uint8) [levelKeySize]byte {
+	var key [levelKeySize]byte
+	copy(key[:], addrKey[:])
+	key[levelOffset] = level
+	return key
+}
+
+// dbPutAddrIndexEntry updates the address index to include the provided entry
+// according to the level-based scheme described in detail above.
+func dbPutAddrIndexEntry(bucket internalBucket, addrKey [addrKeySize]byte, blockID uint32, txLoc wire.TxLoc) error {
+	// Start with level 0 and its initial max number of entries.
+	curLevel := uint8(0)
+	maxLevelBytes := level0MaxEntries * txEntrySize
+
+	// Simply append the new entry to level 0 and return now when it will
+	// fit.  This is the most common path.
+	newData := serializeAddrIndexEntry(blockID, txLoc)
+	level0Key := keyForLevel(addrKey, 0)
+	level0Data := bucket.Get(level0Key[:])
+	if len(level0Data)+len(newData) <= maxLevelBytes {
+		mergedData := newData
+		if len(level0Data) > 0 {
+			mergedData = make([]byte, len(level0Data)+len(newData))
+			copy(mergedData, level0Data)
+			copy(mergedData[len(level0Data):], newData)
+		}
+		return bucket.Put(level0Key[:], mergedData)
+	}
+
+	// At this point, level 0 is full, so merge each level into higher
+	// levels as many times as needed to free up level 0.
+	prevLevelData := level0Data
+	for {
+		// Each new level holds twice as much as the previous one.
+		curLevel++
+		maxLevelBytes *= 2
+
+		// Move to the next level as long as the current level is full.
+		curLevelKey := keyForLevel(addrKey, curLevel)
+		curLevelData := bucket.Get(curLevelKey[:])
+		if len(curLevelData) == maxLevelBytes {
+			prevLevelData = curLevelData
+			continue
+		}
+
+		// The current level has room for the data in the previous one,
+		// so merge the data from previous level into it.
+		mergedData := prevLevelData
+		if len(curLevelData) > 0 {
+			mergedData = make([]byte, len(curLevelData)+
+				len(prevLevelData))
+			copy(mergedData, curLevelData)
+			copy(mergedData[len(curLevelData):], prevLevelData)
+		}
+		err := bucket.Put(curLevelKey[:], mergedData)
+		if err != nil {
+			return err
+		}
+
+		// Move all of the levels before the previous one up a level.
+		for mergeLevel := curLevel - 1; mergeLevel > 0; mergeLevel-- {
+			mergeLevelKey := keyForLevel(addrKey, mergeLevel)
+			prevLevelKey := keyForLevel(addrKey, mergeLevel-1)
+			prevData := bucket.Get(prevLevelKey[:])
+			err := bucket.Put(mergeLevelKey[:], prevData)
+			if err != nil {
+				return err
+			}
+		}
+		break
+	}
+
+	// Finally, insert the new entry into level 0 now that it is empty.
+	return bucket.Put(level0Key[:], newData)
+}
+
+// dbFetchAddrIndexEntries returns block regions for transactions referenced by
+// the given address key and the number of entries skipped since it could have
+// been less in the case where there are less total entries than the requested
+// number of entries to skip.
+func dbFetchAddrIndexEntries(bucket internalBucket, addrKey [addrKeySize]byte, numToSkip, numRequested uint32, reverse bool, fetchBlockHash fetchBlockHashFunc) ([]database.BlockRegion, uint32, error) {
+	// When the reverse flag is not set, all levels need to be fetched
+	// because numToSkip and numRequested are counted from the oldest
+	// transactions (highest level) and thus the total count is needed.
+	// However, when the reverse flag is set, only enough records to satisfy
+	// the requested amount are needed.
+	var level uint8
+	var serialized []byte
+	for !reverse || len(serialized) < int(numToSkip+numRequested)*txEntrySize {
+		curLevelKey := keyForLevel(addrKey, level)
+		levelData := bucket.Get(curLevelKey[:])
+		if levelData == nil {
+			// Stop when there are no more levels.
+			break
+		}
+
+		// Higher levels contain older transactions, so prepend them.
+		prepended := make([]byte, len(serialized)+len(levelData))
+		copy(prepended, levelData)
+		copy(prepended[len(levelData):], serialized)
+		serialized = prepended
+		level++
+	}
+
+	// When the requested number of entries to skip is larger than the
+	// number available, skip them all and return now with the actual number
+	// skipped.
+	numEntries := uint32(len(serialized) / txEntrySize)
+	if numToSkip >= numEntries {
+		return nil, numEntries, nil
+	}
+
+	// Nothing more to do when there are no requested entries.
+	if numRequested == 0 {
+		return nil, numToSkip, nil
+	}
+
+	// Limit the number to load based on the number of available entries,
+	// the number to skip, and the number requested.
+	numToLoad := numEntries - numToSkip
+	if numToLoad > numRequested {
+		numToLoad = numRequested
+	}
+
+	// Start the offset after all skipped entries and load the calculated
+	// number.
+	results := make([]database.BlockRegion, numToLoad)
+	for i := uint32(0); i < numToLoad; i++ {
+		// Calculate the read offset according to the reverse flag.
+		var offset uint32
+		if reverse {
+			offset = (numEntries - numToSkip - i - 1) * txEntrySize
+		} else {
+			offset = (numToSkip + i) * txEntrySize
+		}
+
+		// Deserialize and populate the result.
+		err := deserializeAddrIndexEntry(serialized[offset:],
+			&results[i], fetchBlockHash)
+		if err != nil {
+			// Ensure any deserialization errors are returned as
+			// database corruption errors.
+			if isDeserializeErr(err) {
+				err = database.Error{
+					ErrorCode: database.ErrCorruption,
+					Description: fmt.Sprintf("failed to "+
+						"deserialized address index "+
+						"for key %x: %v", addrKey, err),
+				}
+			}
+
+			return nil, 0, err
+		}
+	}
+
+	return results, numToSkip, nil
+}
+
+// minEntriesToReachLevel returns the minimum number of entries that are
+// required to reach the given address index level.
+func minEntriesToReachLevel(level uint8) int {
+	maxEntriesForLevel := level0MaxEntries
+	minRequired := 1
+	for l := uint8(1); l <= level; l++ {
+		minRequired += maxEntriesForLevel
+		maxEntriesForLevel *= 2
+	}
+	return minRequired
+}
+
+// maxEntriesForLevel returns the maximum number of entries allowed for the
+// given address index level.
+func maxEntriesForLevel(level uint8) int {
+	numEntries := level0MaxEntries
+	for l := level; l > 0; l-- {
+		numEntries *= 2
+	}
+	return numEntries
+}
+
+// dbRemoveAddrIndexEntries removes the specified number of entries from from
+// the address index for the provided key.  An assertion error will be returned
+// if the count exceeds the total number of entries in the index.
+func dbRemoveAddrIndexEntries(bucket internalBucket, addrKey [addrKeySize]byte, count int) error {
+	// Nothing to do if no entries are being deleted.
+	if count <= 0 {
+		return nil
+	}
+
+	// Make use of a local map to track pending updates and define a closure
+	// to apply it to the database.  This is done in order to reduce the
+	// number of database reads and because there is more than one exit
+	// path that needs to apply the updates.
+	pendingUpdates := make(map[uint8][]byte)
+	applyPending := func() error {
+		for level, data := range pendingUpdates {
+			curLevelKey := keyForLevel(addrKey, level)
+			if len(data) == 0 {
+				err := bucket.Delete(curLevelKey[:])
+				if err != nil {
+					return err
+				}
+				continue
+			}
+			err := bucket.Put(curLevelKey[:], data)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	// Loop forwards through the levels while removing entries until the
+	// specified number has been removed.  This will potentially result in
+	// entirely empty lower levels which will be backfilled below.
+	var highestLoadedLevel uint8
+	numRemaining := count
+	for level := uint8(0); numRemaining > 0; level++ {
+		// Load the data for the level from the database.
+		curLevelKey := keyForLevel(addrKey, level)
+		curLevelData := bucket.Get(curLevelKey[:])
+		if len(curLevelData) == 0 && numRemaining > 0 {
+			return AssertError(fmt.Sprintf("dbRemoveAddrIndexEntries "+
+				"not enough entries for address key %x to "+
+				"delete %d entries", addrKey, count))
+		}
+		pendingUpdates[level] = curLevelData
+		highestLoadedLevel = level
+
+		// Delete the entire level as needed.
+		numEntries := len(curLevelData) / txEntrySize
+		if numRemaining >= numEntries {
+			pendingUpdates[level] = nil
+			numRemaining -= numEntries
+			continue
+		}
+
+		// Remove remaining entries to delete from the level.
+		offsetEnd := len(curLevelData) - (numRemaining * txEntrySize)
+		pendingUpdates[level] = curLevelData[:offsetEnd]
+		break
+	}
+
+	// When all elements in level 0 were not removed there is nothing left
+	// to do other than updating the database.
+	if len(pendingUpdates[0]) != 0 {
+		return applyPending()
+	}
+
+	// At this point there are one or more empty levels before the current
+	// level which need to be backfilled and the current level might have
+	// had some entries deleted from it as well.  Since all levels after
+	// level 0 are required to either be empty, half full, or completely
+	// full, the current level must be adjusted accordingly by backfilling
+	// each previous levels in a way which satisfies the requirements.  Any
+	// entries that are left are assigned to level 0 after the loop as they
+	// are guaranteed to fit by the logic in the loop.  In other words, this
+	// effectively squashes all remaining entries in the current level into
+	// the lowest possible levels while following the level rules.
+	//
+	// Note that the level after the current level might also have entries
+	// and gaps are not allowed, so this also keeps track of the lowest
+	// empty level so the code below knows how far to backfill in case it is
+	// required.
+	lowestEmptyLevel := uint8(255)
+	curLevelData := pendingUpdates[highestLoadedLevel]
+	curLevelMaxEntries := maxEntriesForLevel(highestLoadedLevel)
+	for level := highestLoadedLevel; level > 0; level-- {
+		// When there are not enough entries left in the current level
+		// for the number that would be required to reach it, clear the
+		// the current level which effectively moves them all up to the
+		// previous level on the next iteration.  Otherwise, there are
+		// are sufficient entries, so update the current level to
+		// contain as many entries as possible while still leaving
+		// enough remaining entries required to reach the level.
+		numEntries := len(curLevelData) / txEntrySize
+		prevLevelMaxEntries := curLevelMaxEntries / 2
+		minPrevRequired := minEntriesToReachLevel(level - 1)
+		if numEntries < prevLevelMaxEntries+minPrevRequired {
+			lowestEmptyLevel = level
+			pendingUpdates[level] = nil
+		} else {
+			// This level can only be completely full or half full,
+			// so choose the appropriate offset to ensure enough
+			// entries remain to reach the level.
+			var offset int
+			if numEntries-curLevelMaxEntries >= minPrevRequired {
+				offset = curLevelMaxEntries * txEntrySize
+			} else {
+				offset = prevLevelMaxEntries * txEntrySize
+			}
+			pendingUpdates[level] = curLevelData[:offset]
+			curLevelData = curLevelData[offset:]
+		}
+
+		curLevelMaxEntries = prevLevelMaxEntries
+	}
+	pendingUpdates[0] = curLevelData
+	if len(curLevelData) == 0 {
+		lowestEmptyLevel = 0
+	}
+
+	// When the highest loaded level is empty, it's possible the level after
+	// it still has data and thus that data needs to be backfilled as well.
+	for len(pendingUpdates[highestLoadedLevel]) == 0 {
+		// When the next level is empty too, the is no data left to
+		// continue backfilling, so there is nothing left to do.
+		// Otherwise, populate the pending updates map with the newly
+		// loaded data and update the highest loaded level accordingly.
+		level := highestLoadedLevel + 1
+		curLevelKey := keyForLevel(addrKey, level)
+		levelData := bucket.Get(curLevelKey[:])
+		if len(levelData) == 0 {
+			break
+		}
+		pendingUpdates[level] = levelData
+		highestLoadedLevel = level
+
+		// At this point the highest level is not empty, but it might
+		// be half full.  When that is the case, move it up a level to
+		// simplify the code below which backfills all lower levels that
+		// are still empty.  This also means the current level will be
+		// empty, so the loop will perform another another iteration to
+		// potentially backfill this level with data from the next one.
+		curLevelMaxEntries := maxEntriesForLevel(level)
+		if len(levelData)/txEntrySize != curLevelMaxEntries {
+			pendingUpdates[level] = nil
+			pendingUpdates[level-1] = levelData
+			level--
+			curLevelMaxEntries /= 2
+		}
+
+		// Backfill all lower levels that are still empty by iteratively
+		// halfing the data until the lowest empty level is filled.
+		for level > lowestEmptyLevel {
+			offset := (curLevelMaxEntries / 2) * txEntrySize
+			pendingUpdates[level] = levelData[:offset]
+			levelData = levelData[offset:]
+			pendingUpdates[level-1] = levelData
+			level--
+			curLevelMaxEntries /= 2
+		}
+
+		// The lowest possible empty level is now the highest loaded
+		// level.
+		lowestEmptyLevel = highestLoadedLevel
+	}
+
+	// Apply the pending updates.
+	return applyPending()
+}
+
+// addrToKey converts known address types to an addrindex key.  An error is
+// returned for unsupported types.
+func addrToKey(addr btcutil.Address) ([addrKeySize]byte, error) {
+	switch addr := addr.(type) {
+	case *btcutil.AddressPubKeyHash:
+		var result [addrKeySize]byte
+		result[0] = addrKeyTypePubKeyHash
+		copy(result[1:], addr.Hash160()[:])
+		return result, nil
+
+	case *btcutil.AddressScriptHash:
+		var result [addrKeySize]byte
+		result[0] = addrKeyTypeScriptHash
+		copy(result[1:], addr.Hash160()[:])
+		return result, nil
+
+	case *btcutil.AddressPubKey:
+		var result [addrKeySize]byte
+		result[0] = addrKeyTypePubKeyHash
+		copy(result[1:], addr.AddressPubKeyHash().Hash160()[:])
+		return result, nil
+
+	case *btcutil.AddressWitnessScriptHash:
+		var result [addrKeySize]byte
+		result[0] = addrKeyTypeWitnessScriptHash
+
+		// P2WSH outputs utilize a 32-byte data push created by hashing
+		// the script with sha256 instead of hash160. In order to keep
+		// all address entries within the database uniform and compact,
+		// we use a hash160 here to reduce the size of the salient data
+		// push to 20-bytes.
+		copy(result[1:], btcutil.Hash160(addr.ScriptAddress()))
+		return result, nil
+
+	case *btcutil.AddressWitnessPubKeyHash:
+		var result [addrKeySize]byte
+		result[0] = addrKeyTypeWitnessPubKeyHash
+		copy(result[1:], addr.Hash160()[:])
+		return result, nil
+	}
+
+	return [addrKeySize]byte{}, errUnsupportedAddressType
+}
+
+// AddrIndex implements a transaction by address index.  That is to say, it
+// supports querying all transactions that reference a given address because
+// they are either crediting or debiting the address.  The returned transactions
+// are ordered according to their order of appearance in the blockchain.  In
+// other words, first by block height and then by offset inside the block.
+//
+// In addition, support is provided for a memory-only index of unconfirmed
+// transactions such as those which are kept in the memory pool before inclusion
+// in a block.
+type AddrIndex struct {
+	// The following fields are set when the instance is created and can't
+	// be changed afterwards, so there is no need to protect them with a
+	// separate mutex.
+	db          database.DB
+	chainParams *chaincfg.Params
+
+	// The following fields are used to quickly link transactions and
+	// addresses that have not been included into a block yet when an
+	// address index is being maintained.  The are protected by the
+	// unconfirmedLock field.
+	//
+	// The txnsByAddr field is used to keep an index of all transactions
+	// which either create an output to a given address or spend from a
+	// previous output to it keyed by the address.
+	//
+	// The addrsByTx field is essentially the reverse and is used to
+	// keep an index of all addresses which a given transaction involves.
+	// This allows fairly efficient updates when transactions are removed
+	// once they are included into a block.
+	unconfirmedLock sync.RWMutex
+	txnsByAddr      map[[addrKeySize]byte]map[chainhash.Hash]*btcutil.Tx
+	addrsByTx       map[chainhash.Hash]map[[addrKeySize]byte]struct{}
+}
+
+// Ensure the AddrIndex type implements the Indexer interface.
+var _ Indexer = (*AddrIndex)(nil)
+
+// Ensure the AddrIndex type implements the NeedsInputser interface.
+var _ NeedsInputser = (*AddrIndex)(nil)
+
+// NeedsInputs signals that the index requires the referenced inputs in order
+// to properly create the index.
+//
+// This implements the NeedsInputser interface.
+func (idx *AddrIndex) NeedsInputs() bool {
+	return true
+}
+
+// Init is only provided to satisfy the Indexer interface as there is nothing to
+// initialize for this index.
+//
+// This is part of the Indexer interface.
+func (idx *AddrIndex) Init() error {
+	// Nothing to do.
+	return nil
+}
+
+// Key returns the database key to use for the index as a byte slice.
+//
+// This is part of the Indexer interface.
+func (idx *AddrIndex) Key() []byte {
+	return addrIndexKey
+}
+
+// Name returns the human-readable name of the index.
+//
+// This is part of the Indexer interface.
+func (idx *AddrIndex) Name() string {
+	return addrIndexName
+}
+
+// Create is invoked when the indexer manager determines the index needs
+// to be created for the first time.  It creates the bucket for the address
+// index.
+//
+// This is part of the Indexer interface.
+func (idx *AddrIndex) Create(dbTx database.Tx) error {
+	_, err := dbTx.Metadata().CreateBucket(addrIndexKey)
+	return err
+}
+
+// writeIndexData represents the address index data to be written for one block.
+// It consistens of the address mapped to an ordered list of the transactions
+// that involve the address in block.  It is ordered so the transactions can be
+// stored in the order they appear in the block.
+type writeIndexData map[[addrKeySize]byte][]int
+
+// indexPkScript extracts all standard addresses from the passed public key
+// script and maps each of them to the associated transaction using the passed
+// map.
+func (idx *AddrIndex) indexPkScript(data writeIndexData, pkScript []byte, txIdx int) {
+	// Nothing to index if the script is non-standard or otherwise doesn't
+	// contain any addresses.
+	_, addrs, _, err := txscript.ExtractPkScriptAddrs(pkScript,
+		idx.chainParams)
+	if err != nil || len(addrs) == 0 {
+		return
+	}
+
+	for _, addr := range addrs {
+		addrKey, err := addrToKey(addr)
+		if err != nil {
+			// Ignore unsupported address types.
+			continue
+		}
+
+		// Avoid inserting the transaction more than once.  Since the
+		// transactions are indexed serially any duplicates will be
+		// indexed in a row, so checking the most recent entry for the
+		// address is enough to detect duplicates.
+		indexedTxns := data[addrKey]
+		numTxns := len(indexedTxns)
+		if numTxns > 0 && indexedTxns[numTxns-1] == txIdx {
+			continue
+		}
+		indexedTxns = append(indexedTxns, txIdx)
+		data[addrKey] = indexedTxns
+	}
+}
+
+// indexBlock extract all of the standard addresses from all of the transactions
+// in the passed block and maps each of them to the assocaited transaction using
+// the passed map.
+func (idx *AddrIndex) indexBlock(data writeIndexData, block *btcutil.Block, view *blockchain.UtxoViewpoint) {
+	for txIdx, tx := range block.Transactions() {
+		// Coinbases do not reference any inputs.  Since the block is
+		// required to have already gone through full validation, it has
+		// already been proven on the first transaction in the block is
+		// a coinbase.
+		if txIdx != 0 {
+			for _, txIn := range tx.MsgTx().TxIn {
+				// The view should always have the input since
+				// the index contract requires it, however, be
+				// safe and simply ignore any missing entries.
+				origin := &txIn.PreviousOutPoint
+				entry := view.LookupEntry(&origin.Hash)
+				if entry == nil {
+					continue
+				}
+
+				pkScript := entry.PkScriptByIndex(origin.Index)
+				idx.indexPkScript(data, pkScript, txIdx)
+			}
+		}
+
+		for _, txOut := range tx.MsgTx().TxOut {
+			idx.indexPkScript(data, txOut.PkScript, txIdx)
+		}
+	}
+}
+
+// ConnectBlock is invoked by the index manager when a new block has been
+// connected to the main chain.  This indexer adds a mapping for each address
+// the transactions in the block involve.
+//
+// This is part of the Indexer interface.
+func (idx *AddrIndex) ConnectBlock(dbTx database.Tx, block *btcutil.Block, view *blockchain.UtxoViewpoint) error {
+	// The offset and length of the transactions within the serialized
+	// block.
+	txLocs, err := block.TxLoc()
+	if err != nil {
+		return err
+	}
+
+	// Get the internal block ID associated with the block.
+	blockID, err := dbFetchBlockIDByHash(dbTx, block.Hash())
+	if err != nil {
+		return err
+	}
+
+	// Build all of the address to transaction mappings in a local map.
+	addrsToTxns := make(writeIndexData)
+	idx.indexBlock(addrsToTxns, block, view)
+
+	// Add all of the index entries for each address.
+	addrIdxBucket := dbTx.Metadata().Bucket(addrIndexKey)
+	for addrKey, txIdxs := range addrsToTxns {
+		for _, txIdx := range txIdxs {
+			err := dbPutAddrIndexEntry(addrIdxBucket, addrKey,
+				blockID, txLocs[txIdx])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+// DisconnectBlock is invoked by the index manager when a block has been
+// disconnected from the main chain.  This indexer removes the address mappings
+// each transaction in the block involve.
+//
+// This is part of the Indexer interface.
+func (idx *AddrIndex) DisconnectBlock(dbTx database.Tx, block *btcutil.Block, view *blockchain.UtxoViewpoint) error {
+	// Build all of the address to transaction mappings in a local map.
+	addrsToTxns := make(writeIndexData)
+	idx.indexBlock(addrsToTxns, block, view)
+
+	// Remove all of the index entries for each address.
+	bucket := dbTx.Metadata().Bucket(addrIndexKey)
+	for addrKey, txIdxs := range addrsToTxns {
+		err := dbRemoveAddrIndexEntries(bucket, addrKey, len(txIdxs))
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// TxRegionsForAddress returns a slice of block regions which identify each
+// transaction that involves the passed address according to the specified
+// number to skip, number requested, and whether or not the results should be
+// reversed.  It also returns the number actually skipped since it could be less
+// in the case where there are not enough entries.
+//
+// NOTE: These results only include transactions confirmed in blocks.  See the
+// UnconfirmedTxnsForAddress method for obtaining unconfirmed transactions
+// that involve a given address.
+//
+// This function is safe for concurrent access.
+func (idx *AddrIndex) TxRegionsForAddress(dbTx database.Tx, addr btcutil.Address, numToSkip, numRequested uint32, reverse bool) ([]database.BlockRegion, uint32, error) {
+	addrKey, err := addrToKey(addr)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	var regions []database.BlockRegion
+	var skipped uint32
+	err = idx.db.View(func(dbTx database.Tx) error {
+		// Create closure to lookup the block hash given the ID using
+		// the database transaction.
+		fetchBlockHash := func(id []byte) (*chainhash.Hash, error) {
+			// Deserialize and populate the result.
+			return dbFetchBlockHashBySerializedID(dbTx, id)
+		}
+
+		var err error
+		addrIdxBucket := dbTx.Metadata().Bucket(addrIndexKey)
+		regions, skipped, err = dbFetchAddrIndexEntries(addrIdxBucket,
+			addrKey, numToSkip, numRequested, reverse,
+			fetchBlockHash)
+		return err
+	})
+
+	return regions, skipped, err
+}
+
+// indexUnconfirmedAddresses modifies the unconfirmed (memory-only) address
+// index to include mappings for the addresses encoded by the passed public key
+// script to the transaction.
+//
+// This function is safe for concurrent access.
+func (idx *AddrIndex) indexUnconfirmedAddresses(pkScript []byte, tx *btcutil.Tx) {
+	// The error is ignored here since the only reason it can fail is if the
+	// script fails to parse and it was already validated before being
+	// admitted to the mempool.
+	_, addresses, _, _ := txscript.ExtractPkScriptAddrs(pkScript,
+		idx.chainParams)
+	for _, addr := range addresses {
+		// Ignore unsupported address types.
+		addrKey, err := addrToKey(addr)
+		if err != nil {
+			continue
+		}
+
+		// Add a mapping from the address to the transaction.
+		idx.unconfirmedLock.Lock()
+		addrIndexEntry := idx.txnsByAddr[addrKey]
+		if addrIndexEntry == nil {
+			addrIndexEntry = make(map[chainhash.Hash]*btcutil.Tx)
+			idx.txnsByAddr[addrKey] = addrIndexEntry
+		}
+		addrIndexEntry[*tx.Hash()] = tx
+
+		// Add a mapping from the transaction to the address.
+		addrsByTxEntry := idx.addrsByTx[*tx.Hash()]
+		if addrsByTxEntry == nil {
+			addrsByTxEntry = make(map[[addrKeySize]byte]struct{})
+			idx.addrsByTx[*tx.Hash()] = addrsByTxEntry
+		}
+		addrsByTxEntry[addrKey] = struct{}{}
+		idx.unconfirmedLock.Unlock()
+	}
+}
+
+// AddUnconfirmedTx adds all addresses related to the transaction to the
+// unconfirmed (memory-only) address index.
+//
+// NOTE: This transaction MUST have already been validated by the memory pool
+// before calling this function with it and have all of the inputs available in
+// the provided utxo view.  Failure to do so could result in some or all
+// addresses not being indexed.
+//
+// This function is safe for concurrent access.
+func (idx *AddrIndex) AddUnconfirmedTx(tx *btcutil.Tx, utxoView *blockchain.UtxoViewpoint) {
+	// Index addresses of all referenced previous transaction outputs.
+	//
+	// The existence checks are elided since this is only called after the
+	// transaction has already been validated and thus all inputs are
+	// already known to exist.
+	for _, txIn := range tx.MsgTx().TxIn {
+		entry := utxoView.LookupEntry(&txIn.PreviousOutPoint.Hash)
+		if entry == nil {
+			// Ignore missing entries.  This should never happen
+			// in practice since the function comments specifically
+			// call out all inputs must be available.
+			continue
+		}
+		pkScript := entry.PkScriptByIndex(txIn.PreviousOutPoint.Index)
+		idx.indexUnconfirmedAddresses(pkScript, tx)
+	}
+
+	// Index addresses of all created outputs.
+	for _, txOut := range tx.MsgTx().TxOut {
+		idx.indexUnconfirmedAddresses(txOut.PkScript, tx)
+	}
+}
+
+// RemoveUnconfirmedTx removes the passed transaction from the unconfirmed
+// (memory-only) address index.
+//
+// This function is safe for concurrent access.
+func (idx *AddrIndex) RemoveUnconfirmedTx(hash *chainhash.Hash) {
+	idx.unconfirmedLock.Lock()
+	defer idx.unconfirmedLock.Unlock()
+
+	// Remove all address references to the transaction from the address
+	// index and remove the entry for the address altogether if it no longer
+	// references any transactions.
+	for addrKey := range idx.addrsByTx[*hash] {
+		delete(idx.txnsByAddr[addrKey], *hash)
+		if len(idx.txnsByAddr[addrKey]) == 0 {
+			delete(idx.txnsByAddr, addrKey)
+		}
+	}
+
+	// Remove the entry from the transaction to address lookup map as well.
+	delete(idx.addrsByTx, *hash)
+}
+
+// UnconfirmedTxnsForAddress returns all transactions currently in the
+// unconfirmed (memory-only) address index that involve the passed address.
+// Unsupported address types are ignored and will result in no results.
+//
+// This function is safe for concurrent access.
+func (idx *AddrIndex) UnconfirmedTxnsForAddress(addr btcutil.Address) []*btcutil.Tx {
+	// Ignore unsupported address types.
+	addrKey, err := addrToKey(addr)
+	if err != nil {
+		return nil
+	}
+
+	// Protect concurrent access.
+	idx.unconfirmedLock.RLock()
+	defer idx.unconfirmedLock.RUnlock()
+
+	// Return a new slice with the results if there are any.  This ensures
+	// safe concurrency.
+	if txns, exists := idx.txnsByAddr[addrKey]; exists {
+		addressTxns := make([]*btcutil.Tx, 0, len(txns))
+		for _, tx := range txns {
+			addressTxns = append(addressTxns, tx)
+		}
+		return addressTxns
+	}
+
+	return nil
+}
+
+// NewAddrIndex returns a new instance of an indexer that is used to create a
+// mapping of all addresses in the blockchain to the respective transactions
+// that involve them.
+//
+// It implements the Indexer interface which plugs into the IndexManager that in
+// turn is used by the blockchain package.  This allows the index to be
+// seamlessly maintained along with the chain.
+func NewAddrIndex(db database.DB, chainParams *chaincfg.Params) *AddrIndex {
+	return &AddrIndex{
+		db:          db,
+		chainParams: chainParams,
+		txnsByAddr:  make(map[[addrKeySize]byte]map[chainhash.Hash]*btcutil.Tx),
+		addrsByTx:   make(map[chainhash.Hash]map[[addrKeySize]byte]struct{}),
+	}
+}
+
+// DropAddrIndex drops the address index from the provided database if it
+// exists.
+func DropAddrIndex(db database.DB, interrupt <-chan struct{}) error {
+	return dropIndex(db, addrIndexKey, addrIndexName, interrupt)
+}

vendor/github.com/btcsuite/btcd/blockchain/indexers/addrindex_test.go

@@ -0,0 +1,276 @@
+// 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 indexers
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+
+	"github.com/btcsuite/btcd/wire"
+)
+
+// addrIndexBucket provides a mock address index database bucket by implementing
+// the internalBucket interface.
+type addrIndexBucket struct {
+	levels map[[levelKeySize]byte][]byte
+}
+
+// Clone returns a deep copy of the mock address index bucket.
+func (b *addrIndexBucket) Clone() *addrIndexBucket {
+	levels := make(map[[levelKeySize]byte][]byte)
+	for k, v := range b.levels {
+		vCopy := make([]byte, len(v))
+		copy(vCopy, v)
+		levels[k] = vCopy
+	}
+	return &addrIndexBucket{levels: levels}
+}
+
+// Get returns the value associated with the key from the mock address index
+// bucket.
+//
+// This is part of the internalBucket interface.
+func (b *addrIndexBucket) Get(key []byte) []byte {
+	var levelKey [levelKeySize]byte
+	copy(levelKey[:], key)
+	return b.levels[levelKey]
+}
+
+// Put stores the provided key/value pair to the mock address index bucket.
+//
+// This is part of the internalBucket interface.
+func (b *addrIndexBucket) Put(key []byte, value []byte) error {
+	var levelKey [levelKeySize]byte
+	copy(levelKey[:], key)
+	b.levels[levelKey] = value
+	return nil
+}
+
+// Delete removes the provided key from the mock address index bucket.
+//
+// This is part of the internalBucket interface.
+func (b *addrIndexBucket) Delete(key []byte) error {
+	var levelKey [levelKeySize]byte
+	copy(levelKey[:], key)
+	delete(b.levels, levelKey)
+	return nil
+}
+
+// printLevels returns a string with a visual representation of the provided
+// address key taking into account the max size of each level.  It is useful
+// when creating and debugging test cases.
+func (b *addrIndexBucket) printLevels(addrKey [addrKeySize]byte) string {
+	highestLevel := uint8(0)
+	for k := range b.levels {
+		if !bytes.Equal(k[:levelOffset], addrKey[:]) {
+			continue
+		}
+		level := uint8(k[levelOffset])
+		if level > highestLevel {
+			highestLevel = level
+		}
+	}
+
+	var levelBuf bytes.Buffer
+	_, _ = levelBuf.WriteString("\n")
+	maxEntries := level0MaxEntries
+	for level := uint8(0); level <= highestLevel; level++ {
+		data := b.levels[keyForLevel(addrKey, level)]
+		numEntries := len(data) / txEntrySize
+		for i := 0; i < numEntries; i++ {
+			start := i * txEntrySize
+			num := byteOrder.Uint32(data[start:])
+			_, _ = levelBuf.WriteString(fmt.Sprintf("%02d ", num))
+		}
+		for i := numEntries; i < maxEntries; i++ {
+			_, _ = levelBuf.WriteString("_  ")
+		}
+		_, _ = levelBuf.WriteString("\n")
+		maxEntries *= 2
+	}
+
+	return levelBuf.String()
+}
+
+// sanityCheck ensures that all data stored in the bucket for the given address
+// adheres to the level-based rules described by the address index
+// documentation.
+func (b *addrIndexBucket) sanityCheck(addrKey [addrKeySize]byte, expectedTotal int) error {
+	// Find the highest level for the key.
+	highestLevel := uint8(0)
+	for k := range b.levels {
+		if !bytes.Equal(k[:levelOffset], addrKey[:]) {
+			continue
+		}
+		level := uint8(k[levelOffset])
+		if level > highestLevel {
+			highestLevel = level
+		}
+	}
+
+	// Ensure the expected total number of entries are present and that
+	// all levels adhere to the rules described in the address index
+	// documentation.
+	var totalEntries int
+	maxEntries := level0MaxEntries
+	for level := uint8(0); level <= highestLevel; level++ {
+		// Level 0 can'have more entries than the max allowed if the
+		// levels after it have data and it can't be empty.  All other
+		// levels must either be half full or full.
+		data := b.levels[keyForLevel(addrKey, level)]
+		numEntries := len(data) / txEntrySize
+		totalEntries += numEntries
+		if level == 0 {
+			if (highestLevel != 0 && numEntries == 0) ||
+				numEntries > maxEntries {
+
+				return fmt.Errorf("level %d has %d entries",
+					level, numEntries)
+			}
+		} else if numEntries != maxEntries && numEntries != maxEntries/2 {
+			return fmt.Errorf("level %d has %d entries", level,
+				numEntries)
+		}
+		maxEntries *= 2
+	}
+	if totalEntries != expectedTotal {
+		return fmt.Errorf("expected %d entries - got %d", expectedTotal,
+			totalEntries)
+	}
+
+	// Ensure all of the numbers are in order starting from the highest
+	// level moving to the lowest level.
+	expectedNum := uint32(0)
+	for level := highestLevel + 1; level > 0; level-- {
+		data := b.levels[keyForLevel(addrKey, level)]
+		numEntries := len(data) / txEntrySize
+		for i := 0; i < numEntries; i++ {
+			start := i * txEntrySize
+			num := byteOrder.Uint32(data[start:])
+			if num != expectedNum {
+				return fmt.Errorf("level %d offset %d does "+
+					"not contain the expected number of "+
+					"%d - got %d", level, i, num,
+					expectedNum)
+			}
+			expectedNum++
+		}
+	}
+
+	return nil
+}
+
+// TestAddrIndexLevels ensures that adding and deleting entries to the address
+// index creates multiple levels as described by the address index
+// documentation.
+func TestAddrIndexLevels(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name        string
+		key         [addrKeySize]byte
+		numInsert   int
+		printLevels bool // Set to help debug a specific test.
+	}{
+		{
+			name:      "level 0 not full",
+			numInsert: level0MaxEntries - 1,
+		},
+		{
+			name:      "level 1 half",
+			numInsert: level0MaxEntries + 1,
+		},
+		{
+			name:      "level 1 full",
+			numInsert: level0MaxEntries*2 + 1,
+		},
+		{
+			name:      "level 2 half, level 1 half",
+			numInsert: level0MaxEntries*3 + 1,
+		},
+		{
+			name:      "level 2 half, level 1 full",
+			numInsert: level0MaxEntries*4 + 1,
+		},
+		{
+			name:      "level 2 full, level 1 half",
+			numInsert: level0MaxEntries*5 + 1,
+		},
+		{
+			name:      "level 2 full, level 1 full",
+			numInsert: level0MaxEntries*6 + 1,
+		},
+		{
+			name:      "level 3 half, level 2 half, level 1 half",
+			numInsert: level0MaxEntries*7 + 1,
+		},
+		{
+			name:      "level 3 full, level 2 half, level 1 full",
+			numInsert: level0MaxEntries*12 + 1,
+		},
+	}
+
+nextTest:
+	for testNum, test := range tests {
+		// Insert entries in order.
+		populatedBucket := &addrIndexBucket{
+			levels: make(map[[levelKeySize]byte][]byte),
+		}
+		for i := 0; i < test.numInsert; i++ {
+			txLoc := wire.TxLoc{TxStart: i * 2}
+			err := dbPutAddrIndexEntry(populatedBucket, test.key,
+				uint32(i), txLoc)
+			if err != nil {
+				t.Errorf("dbPutAddrIndexEntry #%d (%s) - "+
+					"unexpected error: %v", testNum,
+					test.name, err)
+				continue nextTest
+			}
+		}
+		if test.printLevels {
+			t.Log(populatedBucket.printLevels(test.key))
+		}
+
+		// Delete entries from the populated bucket until all entries
+		// have been deleted.  The bucket is reset to the fully
+		// populated bucket on each iteration so every combination is
+		// tested.  Notice the upper limit purposes exceeds the number
+		// of entries to ensure attempting to delete more entries than
+		// there are works correctly.
+		for numDelete := 0; numDelete <= test.numInsert+1; numDelete++ {
+			// Clone populated bucket to run each delete against.
+			bucket := populatedBucket.Clone()
+
+			// Remove the number of entries for this iteration.
+			err := dbRemoveAddrIndexEntries(bucket, test.key,
+				numDelete)
+			if err != nil {
+				if numDelete <= test.numInsert {
+					t.Errorf("dbRemoveAddrIndexEntries (%s) "+
+						" delete %d - unexpected error: "+
+						"%v", test.name, numDelete, err)
+					continue nextTest
+				}
+			}
+			if test.printLevels {
+				t.Log(bucket.printLevels(test.key))
+			}
+
+			// Sanity check the levels to ensure the adhere to all
+			// rules.
+			numExpected := test.numInsert
+			if numDelete <= test.numInsert {
+				numExpected -= numDelete
+			}
+			err = bucket.sanityCheck(test.key, numExpected)
+			if err != nil {
+				t.Errorf("sanity check fail (%s) delete %d: %v",
+					test.name, numDelete, err)
+				continue nextTest
+			}
+		}
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/indexers/blocklogger.go

@@ -0,0 +1,76 @@
+// 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 indexers
+
+import (
+	"sync"
+	"time"
+
+	"github.com/btcsuite/btclog"
+	"github.com/btcsuite/btcutil"
+)
+
+// blockProgressLogger provides periodic logging for other services in order
+// to show users progress of certain "actions" involving some or all current
+// blocks. Ex: syncing to best chain, indexing all blocks, etc.
+type blockProgressLogger struct {
+	receivedLogBlocks int64
+	receivedLogTx     int64
+	lastBlockLogTime  time.Time
+
+	subsystemLogger btclog.Logger
+	progressAction  string
+	sync.Mutex
+}
+
+// newBlockProgressLogger returns a new block progress logger.
+// The progress message is templated as follows:
+//  {progressAction} {numProcessed} {blocks|block} in the last {timePeriod}
+//  ({numTxs}, height {lastBlockHeight}, {lastBlockTimeStamp})
+func newBlockProgressLogger(progressMessage string, logger btclog.Logger) *blockProgressLogger {
+	return &blockProgressLogger{
+		lastBlockLogTime: time.Now(),
+		progressAction:   progressMessage,
+		subsystemLogger:  logger,
+	}
+}
+
+// LogBlockHeight logs a new block height as an information message to show
+// progress to the user. In order to prevent spam, it limits logging to one
+// message every 10 seconds with duration and totals included.
+func (b *blockProgressLogger) LogBlockHeight(block *btcutil.Block) {
+	b.Lock()
+	defer b.Unlock()
+
+	b.receivedLogBlocks++
+	b.receivedLogTx += int64(len(block.MsgBlock().Transactions))
+
+	now := time.Now()
+	duration := now.Sub(b.lastBlockLogTime)
+	if duration < time.Second*10 {
+		return
+	}
+
+	// Truncate the duration to 10s of milliseconds.
+	durationMillis := int64(duration / time.Millisecond)
+	tDuration := 10 * time.Millisecond * time.Duration(durationMillis/10)
+
+	// Log information about new block height.
+	blockStr := "blocks"
+	if b.receivedLogBlocks == 1 {
+		blockStr = "block"
+	}
+	txStr := "transactions"
+	if b.receivedLogTx == 1 {
+		txStr = "transaction"
+	}
+	b.subsystemLogger.Infof("%s %d %s in the last %s (%d %s, height %d, %s)",
+		b.progressAction, b.receivedLogBlocks, blockStr, tDuration, b.receivedLogTx,
+		txStr, block.Height(), block.MsgBlock().Header.Timestamp)
+
+	b.receivedLogBlocks = 0
+	b.receivedLogTx = 0
+	b.lastBlockLogTime = now
+}

vendor/github.com/btcsuite/btcd/blockchain/indexers/common.go

@@ -0,0 +1,108 @@
+// 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 indexers implements optional block chain indexes.
+*/
+package indexers
+
+import (
+	"encoding/binary"
+	"errors"
+
+	"github.com/btcsuite/btcd/blockchain"
+	"github.com/btcsuite/btcd/database"
+	"github.com/btcsuite/btcutil"
+)
+
+var (
+	// byteOrder is the preferred byte order used for serializing numeric
+	// fields for storage in the database.
+	byteOrder = binary.LittleEndian
+
+	// errInterruptRequested indicates that an operation was cancelled due
+	// to a user-requested interrupt.
+	errInterruptRequested = errors.New("interrupt requested")
+)
+
+// NeedsInputser provides a generic interface for an indexer to specify the it
+// requires the ability to look up inputs for a transaction.
+type NeedsInputser interface {
+	NeedsInputs() bool
+}
+
+// Indexer provides a generic interface for an indexer that is managed by an
+// index manager such as the Manager type provided by this package.
+type Indexer interface {
+	// Key returns the key of the index as a byte slice.
+	Key() []byte
+
+	// Name returns the human-readable name of the index.
+	Name() string
+
+	// Create is invoked when the indexer manager determines the index needs
+	// to be created for the first time.
+	Create(dbTx database.Tx) error
+
+	// Init is invoked when the index manager is first initializing the
+	// index.  This differs from the Create method in that it is called on
+	// every load, including the case the index was just created.
+	Init() error
+
+	// ConnectBlock is invoked when the index manager is notified that a new
+	// block has been connected to the main chain.
+	ConnectBlock(dbTx database.Tx, block *btcutil.Block, view *blockchain.UtxoViewpoint) error
+
+	// DisconnectBlock is invoked when the index manager is notified that a
+	// block has been disconnected from the main chain.
+	DisconnectBlock(dbTx database.Tx, block *btcutil.Block, view *blockchain.UtxoViewpoint) error
+}
+
+// AssertError identifies an error that indicates an internal code consistency
+// issue and should be treated as a critical and unrecoverable error.
+type AssertError string
+
+// Error returns the assertion error as a huma-readable string and satisfies
+// the error interface.
+func (e AssertError) Error() string {
+	return "assertion failed: " + string(e)
+}
+
+// errDeserialize signifies that a problem was encountered when deserializing
+// data.
+type errDeserialize string
+
+// Error implements the error interface.
+func (e errDeserialize) Error() string {
+	return string(e)
+}
+
+// isDeserializeErr returns whether or not the passed error is an errDeserialize
+// error.
+func isDeserializeErr(err error) bool {
+	_, ok := err.(errDeserialize)
+	return ok
+}
+
+// internalBucket is an abstraction over a database bucket.  It is used to make
+// the code easier to test since it allows mock objects in the tests to only
+// implement these functions instead of everything a database.Bucket supports.
+type internalBucket interface {
+	Get(key []byte) []byte
+	Put(key []byte, value []byte) error
+	Delete(key []byte) error
+}
+
+// interruptRequested returns true when the provided channel has been closed.
+// This simplifies early shutdown slightly since the caller can just use an if
+// statement instead of a select.
+func interruptRequested(interrupted <-chan struct{}) bool {
+	select {
+	case <-interrupted:
+		return true
+	default:
+	}
+
+	return false
+}

vendor/github.com/btcsuite/btcd/blockchain/indexers/log.go

@@ -0,0 +1,30 @@
+// 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 indexers
+
+import "github.com/btcsuite/btclog"
+
+// log is a logger that is initialized with no output filters.  This
+// means the package will not perform any logging by default until the caller
+// requests it.
+var log btclog.Logger
+
+// The default amount of logging is none.
+func init() {
+	DisableLog()
+}
+
+// DisableLog disables all library log output.  Logging output is disabled
+// by default until either UseLogger or SetLogWriter are called.
+func DisableLog() {
+	log = btclog.Disabled
+}
+
+// UseLogger uses a specified Logger to output package logging info.
+// This should be used in preference to SetLogWriter if the caller is also
+// using btclog.
+func UseLogger(logger btclog.Logger) {
+	log = logger
+}

vendor/github.com/btcsuite/btcd/blockchain/indexers/manager.go

@@ -0,0 +1,673 @@
+// 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 indexers
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/btcsuite/btcd/blockchain"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/database"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+)
+
+var (
+	// indexTipsBucketName is the name of the db bucket used to house the
+	// current tip of each index.
+	indexTipsBucketName = []byte("idxtips")
+)
+
+// -----------------------------------------------------------------------------
+// The index manager tracks the current tip of each index by using a parent
+// bucket that contains an entry for index.
+//
+// The serialized format for an index tip is:
+//
+//   [<block hash><block height>],...
+//
+//   Field           Type             Size
+//   block hash      chainhash.Hash   chainhash.HashSize
+//   block height    uint32           4 bytes
+// -----------------------------------------------------------------------------
+
+// dbPutIndexerTip uses an existing database transaction to update or add the
+// current tip for the given index to the provided values.
+func dbPutIndexerTip(dbTx database.Tx, idxKey []byte, hash *chainhash.Hash, height int32) error {
+	serialized := make([]byte, chainhash.HashSize+4)
+	copy(serialized, hash[:])
+	byteOrder.PutUint32(serialized[chainhash.HashSize:], uint32(height))
+
+	indexesBucket := dbTx.Metadata().Bucket(indexTipsBucketName)
+	return indexesBucket.Put(idxKey, serialized)
+}
+
+// dbFetchIndexerTip uses an existing database transaction to retrieve the
+// hash and height of the current tip for the provided index.
+func dbFetchIndexerTip(dbTx database.Tx, idxKey []byte) (*chainhash.Hash, int32, error) {
+	indexesBucket := dbTx.Metadata().Bucket(indexTipsBucketName)
+	serialized := indexesBucket.Get(idxKey)
+	if len(serialized) < chainhash.HashSize+4 {
+		return nil, 0, database.Error{
+			ErrorCode: database.ErrCorruption,
+			Description: fmt.Sprintf("unexpected end of data for "+
+				"index %q tip", string(idxKey)),
+		}
+	}
+
+	var hash chainhash.Hash
+	copy(hash[:], serialized[:chainhash.HashSize])
+	height := int32(byteOrder.Uint32(serialized[chainhash.HashSize:]))
+	return &hash, height, nil
+}
+
+// dbIndexConnectBlock adds all of the index entries associated with the
+// given block using the provided indexer and updates the tip of the indexer
+// accordingly.  An error will be returned if the current tip for the indexer is
+// not the previous block for the passed block.
+func dbIndexConnectBlock(dbTx database.Tx, indexer Indexer, block *btcutil.Block, view *blockchain.UtxoViewpoint) error {
+	// Assert that the block being connected properly connects to the
+	// current tip of the index.
+	idxKey := indexer.Key()
+	curTipHash, _, err := dbFetchIndexerTip(dbTx, idxKey)
+	if err != nil {
+		return err
+	}
+	if !curTipHash.IsEqual(&block.MsgBlock().Header.PrevBlock) {
+		return AssertError(fmt.Sprintf("dbIndexConnectBlock must be "+
+			"called with a block that extends the current index "+
+			"tip (%s, tip %s, block %s)", indexer.Name(),
+			curTipHash, block.Hash()))
+	}
+
+	// Notify the indexer with the connected block so it can index it.
+	if err := indexer.ConnectBlock(dbTx, block, view); err != nil {
+		return err
+	}
+
+	// Update the current index tip.
+	return dbPutIndexerTip(dbTx, idxKey, block.Hash(), block.Height())
+}
+
+// dbIndexDisconnectBlock removes all of the index entries associated with the
+// given block using the provided indexer and updates the tip of the indexer
+// accordingly.  An error will be returned if the current tip for the indexer is
+// not the passed block.
+func dbIndexDisconnectBlock(dbTx database.Tx, indexer Indexer, block *btcutil.Block, view *blockchain.UtxoViewpoint) error {
+	// Assert that the block being disconnected is the current tip of the
+	// index.
+	idxKey := indexer.Key()
+	curTipHash, _, err := dbFetchIndexerTip(dbTx, idxKey)
+	if err != nil {
+		return err
+	}
+	if !curTipHash.IsEqual(block.Hash()) {
+		return AssertError(fmt.Sprintf("dbIndexDisconnectBlock must "+
+			"be called with the block at the current index tip "+
+			"(%s, tip %s, block %s)", indexer.Name(),
+			curTipHash, block.Hash()))
+	}
+
+	// Notify the indexer with the disconnected block so it can remove all
+	// of the appropriate entries.
+	if err := indexer.DisconnectBlock(dbTx, block, view); err != nil {
+		return err
+	}
+
+	// Update the current index tip.
+	prevHash := &block.MsgBlock().Header.PrevBlock
+	return dbPutIndexerTip(dbTx, idxKey, prevHash, block.Height()-1)
+}
+
+// Manager defines an index manager that manages multiple optional indexes and
+// implements the blockchain.IndexManager interface so it can be seamlessly
+// plugged into normal chain processing.
+type Manager struct {
+	db             database.DB
+	enabledIndexes []Indexer
+}
+
+// Ensure the Manager type implements the blockchain.IndexManager interface.
+var _ blockchain.IndexManager = (*Manager)(nil)
+
+// indexDropKey returns the key for an index which indicates it is in the
+// process of being dropped.
+func indexDropKey(idxKey []byte) []byte {
+	dropKey := make([]byte, len(idxKey)+1)
+	dropKey[0] = 'd'
+	copy(dropKey[1:], idxKey)
+	return dropKey
+}
+
+// maybeFinishDrops determines if each of the enabled indexes are in the middle
+// of being dropped and finishes dropping them when the are.  This is necessary
+// because dropping and index has to be done in several atomic steps rather than
+// one big atomic step due to the massive number of entries.
+func (m *Manager) maybeFinishDrops(interrupt <-chan struct{}) error {
+	indexNeedsDrop := make([]bool, len(m.enabledIndexes))
+	err := m.db.View(func(dbTx database.Tx) error {
+		// None of the indexes needs to be dropped if the index tips
+		// bucket hasn't been created yet.
+		indexesBucket := dbTx.Metadata().Bucket(indexTipsBucketName)
+		if indexesBucket == nil {
+			return nil
+		}
+
+		// Mark the indexer as requiring a drop if one is already in
+		// progress.
+		for i, indexer := range m.enabledIndexes {
+			dropKey := indexDropKey(indexer.Key())
+			if indexesBucket.Get(dropKey) != nil {
+				indexNeedsDrop[i] = true
+			}
+		}
+
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	if interruptRequested(interrupt) {
+		return errInterruptRequested
+	}
+
+	// Finish dropping any of the enabled indexes that are already in the
+	// middle of being dropped.
+	for i, indexer := range m.enabledIndexes {
+		if !indexNeedsDrop[i] {
+			continue
+		}
+
+		log.Infof("Resuming %s drop", indexer.Name())
+		err := dropIndex(m.db, indexer.Key(), indexer.Name(), interrupt)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// maybeCreateIndexes determines if each of the enabled indexes have already
+// been created and creates them if not.
+func (m *Manager) maybeCreateIndexes(dbTx database.Tx) error {
+	indexesBucket := dbTx.Metadata().Bucket(indexTipsBucketName)
+	for _, indexer := range m.enabledIndexes {
+		// Nothing to do if the index tip already exists.
+		idxKey := indexer.Key()
+		if indexesBucket.Get(idxKey) != nil {
+			continue
+		}
+
+		// The tip for the index does not exist, so create it and
+		// invoke the create callback for the index so it can perform
+		// any one-time initialization it requires.
+		if err := indexer.Create(dbTx); err != nil {
+			return err
+		}
+
+		// Set the tip for the index to values which represent an
+		// uninitialized index.
+		err := dbPutIndexerTip(dbTx, idxKey, &chainhash.Hash{}, -1)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Init initializes the enabled indexes.  This is called during chain
+// initialization and primarily consists of catching up all indexes to the
+// current best chain tip.  This is necessary since each index can be disabled
+// and re-enabled at any time and attempting to catch-up indexes at the same
+// time new blocks are being downloaded would lead to an overall longer time to
+// catch up due to the I/O contention.
+//
+// This is part of the blockchain.IndexManager interface.
+func (m *Manager) Init(chain *blockchain.BlockChain, interrupt <-chan struct{}) error {
+	// Nothing to do when no indexes are enabled.
+	if len(m.enabledIndexes) == 0 {
+		return nil
+	}
+
+	if interruptRequested(interrupt) {
+		return errInterruptRequested
+	}
+
+	// Finish and drops that were previously interrupted.
+	if err := m.maybeFinishDrops(interrupt); err != nil {
+		return err
+	}
+
+	// Create the initial state for the indexes as needed.
+	err := m.db.Update(func(dbTx database.Tx) error {
+		// Create the bucket for the current tips as needed.
+		meta := dbTx.Metadata()
+		_, err := meta.CreateBucketIfNotExists(indexTipsBucketName)
+		if err != nil {
+			return err
+		}
+
+		return m.maybeCreateIndexes(dbTx)
+	})
+	if err != nil {
+		return err
+	}
+
+	// Initialize each of the enabled indexes.
+	for _, indexer := range m.enabledIndexes {
+		if err := indexer.Init(); err != nil {
+			return err
+		}
+	}
+
+	// Rollback indexes to the main chain if their tip is an orphaned fork.
+	// This is fairly unlikely, but it can happen if the chain is
+	// reorganized while the index is disabled.  This has to be done in
+	// reverse order because later indexes can depend on earlier ones.
+	for i := len(m.enabledIndexes); i > 0; i-- {
+		indexer := m.enabledIndexes[i-1]
+
+		// Fetch the current tip for the index.
+		var height int32
+		var hash *chainhash.Hash
+		err := m.db.View(func(dbTx database.Tx) error {
+			idxKey := indexer.Key()
+			hash, height, err = dbFetchIndexerTip(dbTx, idxKey)
+			return err
+		})
+		if err != nil {
+			return err
+		}
+
+		// Nothing to do if the index does not have any entries yet.
+		if height == -1 {
+			continue
+		}
+
+		// Loop until the tip is a block that exists in the main chain.
+		initialHeight := height
+		for !chain.MainChainHasBlock(hash) {
+			// At this point the index tip is orphaned, so load the
+			// orphaned block from the database directly and
+			// disconnect it from the index.  The block has to be
+			// loaded directly since it is no longer in the main
+			// chain and thus the chain.BlockByHash function would
+			// error.
+			err = m.db.Update(func(dbTx database.Tx) error {
+				blockBytes, err := dbTx.FetchBlock(hash)
+				if err != nil {
+					return err
+				}
+				block, err := btcutil.NewBlockFromBytes(blockBytes)
+				if err != nil {
+					return err
+				}
+				block.SetHeight(height)
+
+				// When the index requires all of the referenced
+				// txouts they need to be retrieved from the
+				// transaction index.
+				var view *blockchain.UtxoViewpoint
+				if indexNeedsInputs(indexer) {
+					var err error
+					view, err = makeUtxoView(dbTx, block,
+						interrupt)
+					if err != nil {
+						return err
+					}
+				}
+
+				// Remove all of the index entries associated
+				// with the block and update the indexer tip.
+				err = dbIndexDisconnectBlock(dbTx, indexer,
+					block, view)
+				if err != nil {
+					return err
+				}
+
+				// Update the tip to the previous block.
+				hash = &block.MsgBlock().Header.PrevBlock
+				height--
+
+				return nil
+			})
+			if err != nil {
+				return err
+			}
+
+			if interruptRequested(interrupt) {
+				return errInterruptRequested
+			}
+		}
+
+		if initialHeight != height {
+			log.Infof("Removed %d orphaned blocks from %s "+
+				"(heights %d to %d)", initialHeight-height,
+				indexer.Name(), height+1, initialHeight)
+		}
+	}
+
+	// Fetch the current tip heights for each index along with tracking the
+	// lowest one so the catchup code only needs to start at the earliest
+	// block and is able to skip connecting the block for the indexes that
+	// don't need it.
+	bestHeight := chain.BestSnapshot().Height
+	lowestHeight := bestHeight
+	indexerHeights := make([]int32, len(m.enabledIndexes))
+	err = m.db.View(func(dbTx database.Tx) error {
+		for i, indexer := range m.enabledIndexes {
+			idxKey := indexer.Key()
+			hash, height, err := dbFetchIndexerTip(dbTx, idxKey)
+			if err != nil {
+				return err
+			}
+
+			log.Debugf("Current %s tip (height %d, hash %v)",
+				indexer.Name(), height, hash)
+			indexerHeights[i] = height
+			if height < lowestHeight {
+				lowestHeight = height
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	// Nothing to index if all of the indexes are caught up.
+	if lowestHeight == bestHeight {
+		return nil
+	}
+
+	// Create a progress logger for the indexing process below.
+	progressLogger := newBlockProgressLogger("Indexed", log)
+
+	// At this point, one or more indexes are behind the current best chain
+	// tip and need to be caught up, so log the details and loop through
+	// each block that needs to be indexed.
+	log.Infof("Catching up indexes from height %d to %d", lowestHeight,
+		bestHeight)
+	for height := lowestHeight + 1; height <= bestHeight; height++ {
+		// Load the block for the height since it is required to index
+		// it.
+		block, err := chain.BlockByHeight(height)
+		if err != nil {
+			return err
+		}
+
+		if interruptRequested(interrupt) {
+			return errInterruptRequested
+		}
+
+		// Connect the block for all indexes that need it.
+		var view *blockchain.UtxoViewpoint
+		for i, indexer := range m.enabledIndexes {
+			// Skip indexes that don't need to be updated with this
+			// block.
+			if indexerHeights[i] >= height {
+				continue
+			}
+
+			err := m.db.Update(func(dbTx database.Tx) error {
+				// When the index requires all of the referenced
+				// txouts and they haven't been loaded yet, they
+				// need to be retrieved from the transaction
+				// index.
+				if view == nil && indexNeedsInputs(indexer) {
+					var err error
+					view, err = makeUtxoView(dbTx, block,
+						interrupt)
+					if err != nil {
+						return err
+					}
+				}
+				return dbIndexConnectBlock(dbTx, indexer, block,
+					view)
+			})
+			if err != nil {
+				return err
+			}
+			indexerHeights[i] = height
+		}
+
+		// Log indexing progress.
+		progressLogger.LogBlockHeight(block)
+
+		if interruptRequested(interrupt) {
+			return errInterruptRequested
+		}
+	}
+
+	log.Infof("Indexes caught up to height %d", bestHeight)
+	return nil
+}
+
+// indexNeedsInputs returns whether or not the index needs access to the txouts
+// referenced by the transaction inputs being indexed.
+func indexNeedsInputs(index Indexer) bool {
+	if idx, ok := index.(NeedsInputser); ok {
+		return idx.NeedsInputs()
+	}
+
+	return false
+}
+
+// dbFetchTx looks up the passed transaction hash in the transaction index and
+// loads it from the database.
+func dbFetchTx(dbTx database.Tx, hash *chainhash.Hash) (*wire.MsgTx, error) {
+	// Look up the location of the transaction.
+	blockRegion, err := dbFetchTxIndexEntry(dbTx, hash)
+	if err != nil {
+		return nil, err
+	}
+	if blockRegion == nil {
+		return nil, fmt.Errorf("transaction %v not found", hash)
+	}
+
+	// Load the raw transaction bytes from the database.
+	txBytes, err := dbTx.FetchBlockRegion(blockRegion)
+	if err != nil {
+		return nil, err
+	}
+
+	// Deserialize the transaction.
+	var msgTx wire.MsgTx
+	err = msgTx.Deserialize(bytes.NewReader(txBytes))
+	if err != nil {
+		return nil, err
+	}
+
+	return &msgTx, nil
+}
+
+// makeUtxoView creates a mock unspent transaction output view by using the
+// transaction index in order to look up all inputs referenced by the
+// transactions in the block.  This is sometimes needed when catching indexes up
+// because many of the txouts could actually already be spent however the
+// associated scripts are still required to index them.
+func makeUtxoView(dbTx database.Tx, block *btcutil.Block, interrupt <-chan struct{}) (*blockchain.UtxoViewpoint, error) {
+	view := blockchain.NewUtxoViewpoint()
+	for txIdx, tx := range block.Transactions() {
+		// Coinbases do not reference any inputs.  Since the block is
+		// required to have already gone through full validation, it has
+		// already been proven on the first transaction in the block is
+		// a coinbase.
+		if txIdx == 0 {
+			continue
+		}
+
+		// Use the transaction index to load all of the referenced
+		// inputs and add their outputs to the view.
+		for _, txIn := range tx.MsgTx().TxIn {
+			originOut := &txIn.PreviousOutPoint
+			originTx, err := dbFetchTx(dbTx, &originOut.Hash)
+			if err != nil {
+				return nil, err
+			}
+
+			view.AddTxOuts(btcutil.NewTx(originTx), 0)
+		}
+
+		if interruptRequested(interrupt) {
+			return nil, errInterruptRequested
+		}
+	}
+
+	return view, nil
+}
+
+// ConnectBlock must be invoked when a block is extending the main chain.  It
+// keeps track of the state of each index it is managing, performs some sanity
+// checks, and invokes each indexer.
+//
+// This is part of the blockchain.IndexManager interface.
+func (m *Manager) ConnectBlock(dbTx database.Tx, block *btcutil.Block, view *blockchain.UtxoViewpoint) error {
+	// Call each of the currently active optional indexes with the block
+	// being connected so they can update accordingly.
+	for _, index := range m.enabledIndexes {
+		err := dbIndexConnectBlock(dbTx, index, block, view)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// DisconnectBlock must be invoked when a block is being disconnected from the
+// end of the main chain.  It keeps track of the state of each index it is
+// managing, performs some sanity checks, and invokes each indexer to remove
+// the index entries associated with the block.
+//
+// This is part of the blockchain.IndexManager interface.
+func (m *Manager) DisconnectBlock(dbTx database.Tx, block *btcutil.Block, view *blockchain.UtxoViewpoint) error {
+	// Call each of the currently active optional indexes with the block
+	// being disconnected so they can update accordingly.
+	for _, index := range m.enabledIndexes {
+		err := dbIndexDisconnectBlock(dbTx, index, block, view)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// NewManager returns a new index manager with the provided indexes enabled.
+//
+// The manager returned satisfies the blockchain.IndexManager interface and thus
+// cleanly plugs into the normal blockchain processing path.
+func NewManager(db database.DB, enabledIndexes []Indexer) *Manager {
+	return &Manager{
+		db:             db,
+		enabledIndexes: enabledIndexes,
+	}
+}
+
+// dropIndex drops the passed index from the database.  Since indexes can be
+// massive, it deletes the index in multiple database transactions in order to
+// keep memory usage to reasonable levels.  It also marks the drop in progress
+// so the drop can be resumed if it is stopped before it is done before the
+// index can be used again.
+func dropIndex(db database.DB, idxKey []byte, idxName string, interrupt <-chan struct{}) error {
+	// Nothing to do if the index doesn't already exist.
+	var needsDelete bool
+	err := db.View(func(dbTx database.Tx) error {
+		indexesBucket := dbTx.Metadata().Bucket(indexTipsBucketName)
+		if indexesBucket != nil && indexesBucket.Get(idxKey) != nil {
+			needsDelete = true
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	if !needsDelete {
+		log.Infof("Not dropping %s because it does not exist", idxName)
+		return nil
+	}
+
+	// Mark that the index is in the process of being dropped so that it
+	// can be resumed on the next start if interrupted before the process is
+	// complete.
+	log.Infof("Dropping all %s entries.  This might take a while...",
+		idxName)
+	err = db.Update(func(dbTx database.Tx) error {
+		indexesBucket := dbTx.Metadata().Bucket(indexTipsBucketName)
+		return indexesBucket.Put(indexDropKey(idxKey), idxKey)
+	})
+	if err != nil {
+		return err
+	}
+
+	// Since the indexes can be so large, attempting to simply delete
+	// the bucket in a single database transaction would result in massive
+	// memory usage and likely crash many systems due to ulimits.  In order
+	// to avoid this, use a cursor to delete a maximum number of entries out
+	// of the bucket at a time.
+	const maxDeletions = 2000000
+	var totalDeleted uint64
+	for numDeleted := maxDeletions; numDeleted == maxDeletions; {
+		numDeleted = 0
+		err := db.Update(func(dbTx database.Tx) error {
+			bucket := dbTx.Metadata().Bucket(idxKey)
+			cursor := bucket.Cursor()
+			for ok := cursor.First(); ok; ok = cursor.Next() &&
+				numDeleted < maxDeletions {
+
+				if err := cursor.Delete(); err != nil {
+					return err
+				}
+				numDeleted++
+			}
+			return nil
+		})
+		if err != nil {
+			return err
+		}
+
+		if numDeleted > 0 {
+			totalDeleted += uint64(numDeleted)
+			log.Infof("Deleted %d keys (%d total) from %s",
+				numDeleted, totalDeleted, idxName)
+		}
+
+		if interruptRequested(interrupt) {
+			return errInterruptRequested
+		}
+	}
+
+	// Call extra index specific deinitialization for the transaction index.
+	if idxName == txIndexName {
+		if err := dropBlockIDIndex(db); err != nil {
+			return err
+		}
+	}
+
+	// Remove the index tip, index bucket, and in-progress drop flag now
+	// that all index entries have been removed.
+	err = db.Update(func(dbTx database.Tx) error {
+		meta := dbTx.Metadata()
+		indexesBucket := meta.Bucket(indexTipsBucketName)
+		if err := indexesBucket.Delete(idxKey); err != nil {
+			return err
+		}
+
+		if err := meta.DeleteBucket(idxKey); err != nil {
+			return err
+		}
+
+		return indexesBucket.Delete(indexDropKey(idxKey))
+	})
+	if err != nil {
+		return err
+	}
+
+	log.Infof("Dropped %s", idxName)
+	return nil
+}

vendor/github.com/btcsuite/btcd/blockchain/indexers/txindex.go

@@ -0,0 +1,479 @@
+// 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 indexers
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/btcsuite/btcd/blockchain"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/database"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+)
+
+const (
+	// txIndexName is the human-readable name for the index.
+	txIndexName = "transaction index"
+)
+
+var (
+	// txIndexKey is the key of the transaction index and the db bucket used
+	// to house it.
+	txIndexKey = []byte("txbyhashidx")
+
+	// idByHashIndexBucketName is the name of the db bucket used to house
+	// the block id -> block hash index.
+	idByHashIndexBucketName = []byte("idbyhashidx")
+
+	// hashByIDIndexBucketName is the name of the db bucket used to house
+	// the block hash -> block id index.
+	hashByIDIndexBucketName = []byte("hashbyididx")
+
+	// errNoBlockIDEntry is an error that indicates a requested entry does
+	// not exist in the block ID index.
+	errNoBlockIDEntry = errors.New("no entry in the block ID index")
+)
+
+// -----------------------------------------------------------------------------
+// The transaction index consists of an entry for every transaction in the main
+// chain.  In order to significanly optimize the space requirements a separate
+// index which provides an internal mapping between each block that has been
+// indexed and a unique ID for use within the hash to location mappings.  The ID
+// is simply a sequentially incremented uint32.  This is useful because it is
+// only 4 bytes versus 32 bytes hashes and thus saves a ton of space in the
+// index.
+//
+// There are three buckets used in total.  The first bucket maps the hash of
+// each transaction to the specific block location.  The second bucket maps the
+// hash of each block to the unique ID and the third maps that ID back to the
+// block hash.
+//
+// NOTE: Although it is technically possible for multiple transactions to have
+// the same hash as long as the previous transaction with the same hash is fully
+// spent, this code only stores the most recent one because doing otherwise
+// would add a non-trivial amount of space and overhead for something that will
+// realistically never happen per the probability and even if it did, the old
+// one must be fully spent and so the most likely transaction a caller would
+// want for a given hash is the most recent one anyways.
+//
+// The serialized format for keys and values in the block hash to ID bucket is:
+//   <hash> = <ID>
+//
+//   Field           Type              Size
+//   hash            chainhash.Hash    32 bytes
+//   ID              uint32            4 bytes
+//   -----
+//   Total: 36 bytes
+//
+// The serialized format for keys and values in the ID to block hash bucket is:
+//   <ID> = <hash>
+//
+//   Field           Type              Size
+//   ID              uint32            4 bytes
+//   hash            chainhash.Hash    32 bytes
+//   -----
+//   Total: 36 bytes
+//
+// The serialized format for the keys and values in the tx index bucket is:
+//
+//   <txhash> = <block id><start offset><tx length>
+//
+//   Field           Type              Size
+//   txhash          chainhash.Hash    32 bytes
+//   block id        uint32            4 bytes
+//   start offset    uint32          4 bytes
+//   tx length       uint32          4 bytes
+//   -----
+//   Total: 44 bytes
+// -----------------------------------------------------------------------------
+
+// dbPutBlockIDIndexEntry uses an existing database transaction to update or add
+// the index entries for the hash to id and id to hash mappings for the provided
+// values.
+func dbPutBlockIDIndexEntry(dbTx database.Tx, hash *chainhash.Hash, id uint32) error {
+	// Serialize the height for use in the index entries.
+	var serializedID [4]byte
+	byteOrder.PutUint32(serializedID[:], id)
+
+	// Add the block hash to ID mapping to the index.
+	meta := dbTx.Metadata()
+	hashIndex := meta.Bucket(idByHashIndexBucketName)
+	if err := hashIndex.Put(hash[:], serializedID[:]); err != nil {
+		return err
+	}
+
+	// Add the block ID to hash mapping to the index.
+	idIndex := meta.Bucket(hashByIDIndexBucketName)
+	return idIndex.Put(serializedID[:], hash[:])
+}
+
+// dbRemoveBlockIDIndexEntry uses an existing database transaction remove index
+// entries from the hash to id and id to hash mappings for the provided hash.
+func dbRemoveBlockIDIndexEntry(dbTx database.Tx, hash *chainhash.Hash) error {
+	// Remove the block hash to ID mapping.
+	meta := dbTx.Metadata()
+	hashIndex := meta.Bucket(idByHashIndexBucketName)
+	serializedID := hashIndex.Get(hash[:])
+	if serializedID == nil {
+		return nil
+	}
+	if err := hashIndex.Delete(hash[:]); err != nil {
+		return err
+	}
+
+	// Remove the block ID to hash mapping.
+	idIndex := meta.Bucket(hashByIDIndexBucketName)
+	return idIndex.Delete(serializedID)
+}
+
+// dbFetchBlockIDByHash uses an existing database transaction to retrieve the
+// block id for the provided hash from the index.
+func dbFetchBlockIDByHash(dbTx database.Tx, hash *chainhash.Hash) (uint32, error) {
+	hashIndex := dbTx.Metadata().Bucket(idByHashIndexBucketName)
+	serializedID := hashIndex.Get(hash[:])
+	if serializedID == nil {
+		return 0, errNoBlockIDEntry
+	}
+
+	return byteOrder.Uint32(serializedID), nil
+}
+
+// dbFetchBlockHashBySerializedID uses an existing database transaction to
+// retrieve the hash for the provided serialized block id from the index.
+func dbFetchBlockHashBySerializedID(dbTx database.Tx, serializedID []byte) (*chainhash.Hash, error) {
+	idIndex := dbTx.Metadata().Bucket(hashByIDIndexBucketName)
+	hashBytes := idIndex.Get(serializedID)
+	if hashBytes == nil {
+		return nil, errNoBlockIDEntry
+	}
+
+	var hash chainhash.Hash
+	copy(hash[:], hashBytes)
+	return &hash, nil
+}
+
+// dbFetchBlockHashByID uses an existing database transaction to retrieve the
+// hash for the provided block id from the index.
+func dbFetchBlockHashByID(dbTx database.Tx, id uint32) (*chainhash.Hash, error) {
+	var serializedID [4]byte
+	byteOrder.PutUint32(serializedID[:], id)
+	return dbFetchBlockHashBySerializedID(dbTx, serializedID[:])
+}
+
+// putTxIndexEntry serializes the provided values according to the format
+// described about for a transaction index entry.  The target byte slice must
+// be at least large enough to handle the number of bytes defined by the
+// txEntrySize constant or it will panic.
+func putTxIndexEntry(target []byte, blockID uint32, txLoc wire.TxLoc) {
+	byteOrder.PutUint32(target, blockID)
+	byteOrder.PutUint32(target[4:], uint32(txLoc.TxStart))
+	byteOrder.PutUint32(target[8:], uint32(txLoc.TxLen))
+}
+
+// dbPutTxIndexEntry uses an existing database transaction to update the
+// transaction index given the provided serialized data that is expected to have
+// been serialized putTxIndexEntry.
+func dbPutTxIndexEntry(dbTx database.Tx, txHash *chainhash.Hash, serializedData []byte) error {
+	txIndex := dbTx.Metadata().Bucket(txIndexKey)
+	return txIndex.Put(txHash[:], serializedData)
+}
+
+// dbFetchTxIndexEntry uses an existing database transaction to fetch the block
+// region for the provided transaction hash from the transaction index.  When
+// there is no entry for the provided hash, nil will be returned for the both
+// the region and the error.
+func dbFetchTxIndexEntry(dbTx database.Tx, txHash *chainhash.Hash) (*database.BlockRegion, error) {
+	// Load the record from the database and return now if it doesn't exist.
+	txIndex := dbTx.Metadata().Bucket(txIndexKey)
+	serializedData := txIndex.Get(txHash[:])
+	if len(serializedData) == 0 {
+		return nil, nil
+	}
+
+	// Ensure the serialized data has enough bytes to properly deserialize.
+	if len(serializedData) < 12 {
+		return nil, database.Error{
+			ErrorCode: database.ErrCorruption,
+			Description: fmt.Sprintf("corrupt transaction index "+
+				"entry for %s", txHash),
+		}
+	}
+
+	// Load the block hash associated with the block ID.
+	hash, err := dbFetchBlockHashBySerializedID(dbTx, serializedData[0:4])
+	if err != nil {
+		return nil, database.Error{
+			ErrorCode: database.ErrCorruption,
+			Description: fmt.Sprintf("corrupt transaction index "+
+				"entry for %s: %v", txHash, err),
+		}
+	}
+
+	// Deserialize the final entry.
+	region := database.BlockRegion{Hash: &chainhash.Hash{}}
+	copy(region.Hash[:], hash[:])
+	region.Offset = byteOrder.Uint32(serializedData[4:8])
+	region.Len = byteOrder.Uint32(serializedData[8:12])
+
+	return &region, nil
+}
+
+// dbAddTxIndexEntries uses an existing database transaction to add a
+// transaction index entry for every transaction in the passed block.
+func dbAddTxIndexEntries(dbTx database.Tx, block *btcutil.Block, blockID uint32) error {
+	// The offset and length of the transactions within the serialized
+	// block.
+	txLocs, err := block.TxLoc()
+	if err != nil {
+		return err
+	}
+
+	// As an optimization, allocate a single slice big enough to hold all
+	// of the serialized transaction index entries for the block and
+	// serialize them directly into the slice.  Then, pass the appropriate
+	// subslice to the database to be written.  This approach significantly
+	// cuts down on the number of required allocations.
+	offset := 0
+	serializedValues := make([]byte, len(block.Transactions())*txEntrySize)
+	for i, tx := range block.Transactions() {
+		putTxIndexEntry(serializedValues[offset:], blockID, txLocs[i])
+		endOffset := offset + txEntrySize
+		err := dbPutTxIndexEntry(dbTx, tx.Hash(),
+			serializedValues[offset:endOffset:endOffset])
+		if err != nil {
+			return err
+		}
+		offset += txEntrySize
+	}
+
+	return nil
+}
+
+// dbRemoveTxIndexEntry uses an existing database transaction to remove the most
+// recent transaction index entry for the given hash.
+func dbRemoveTxIndexEntry(dbTx database.Tx, txHash *chainhash.Hash) error {
+	txIndex := dbTx.Metadata().Bucket(txIndexKey)
+	serializedData := txIndex.Get(txHash[:])
+	if len(serializedData) == 0 {
+		return fmt.Errorf("can't remove non-existent transaction %s "+
+			"from the transaction index", txHash)
+	}
+
+	return txIndex.Delete(txHash[:])
+}
+
+// dbRemoveTxIndexEntries uses an existing database transaction to remove the
+// latest transaction entry for every transaction in the passed block.
+func dbRemoveTxIndexEntries(dbTx database.Tx, block *btcutil.Block) error {
+	for _, tx := range block.Transactions() {
+		err := dbRemoveTxIndexEntry(dbTx, tx.Hash())
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// TxIndex implements a transaction by hash index.  That is to say, it supports
+// querying all transactions by their hash.
+type TxIndex struct {
+	db         database.DB
+	curBlockID uint32
+}
+
+// Ensure the TxIndex type implements the Indexer interface.
+var _ Indexer = (*TxIndex)(nil)
+
+// Init initializes the hash-based transaction index.  In particular, it finds
+// the highest used block ID and stores it for later use when connecting or
+// disconnecting blocks.
+//
+// This is part of the Indexer interface.
+func (idx *TxIndex) Init() error {
+	// Find the latest known block id field for the internal block id
+	// index and initialize it.  This is done because it's a lot more
+	// efficient to do a single search at initialize time than it is to
+	// write another value to the database on every update.
+	err := idx.db.View(func(dbTx database.Tx) error {
+		// Scan forward in large gaps to find a block id that doesn't
+		// exist yet to serve as an upper bound for the binary search
+		// below.
+		var highestKnown, nextUnknown uint32
+		testBlockID := uint32(1)
+		increment := uint32(100000)
+		for {
+			_, err := dbFetchBlockHashByID(dbTx, testBlockID)
+			if err != nil {
+				nextUnknown = testBlockID
+				break
+			}
+
+			highestKnown = testBlockID
+			testBlockID += increment
+		}
+		log.Tracef("Forward scan (highest known %d, next unknown %d)",
+			highestKnown, nextUnknown)
+
+		// No used block IDs due to new database.
+		if nextUnknown == 1 {
+			return nil
+		}
+
+		// Use a binary search to find the final highest used block id.
+		// This will take at most ceil(log_2(increment)) attempts.
+		for {
+			testBlockID = (highestKnown + nextUnknown) / 2
+			_, err := dbFetchBlockHashByID(dbTx, testBlockID)
+			if err != nil {
+				nextUnknown = testBlockID
+			} else {
+				highestKnown = testBlockID
+			}
+			log.Tracef("Binary scan (highest known %d, next "+
+				"unknown %d)", highestKnown, nextUnknown)
+			if highestKnown+1 == nextUnknown {
+				break
+			}
+		}
+
+		idx.curBlockID = highestKnown
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	log.Debugf("Current internal block ID: %d", idx.curBlockID)
+	return nil
+}
+
+// Key returns the database key to use for the index as a byte slice.
+//
+// This is part of the Indexer interface.
+func (idx *TxIndex) Key() []byte {
+	return txIndexKey
+}
+
+// Name returns the human-readable name of the index.
+//
+// This is part of the Indexer interface.
+func (idx *TxIndex) Name() string {
+	return txIndexName
+}
+
+// Create is invoked when the indexer manager determines the index needs
+// to be created for the first time.  It creates the buckets for the hash-based
+// transaction index and the internal block ID indexes.
+//
+// This is part of the Indexer interface.
+func (idx *TxIndex) Create(dbTx database.Tx) error {
+	meta := dbTx.Metadata()
+	if _, err := meta.CreateBucket(idByHashIndexBucketName); err != nil {
+		return err
+	}
+	if _, err := meta.CreateBucket(hashByIDIndexBucketName); err != nil {
+		return err
+	}
+	_, err := meta.CreateBucket(txIndexKey)
+	return err
+}
+
+// ConnectBlock is invoked by the index manager when a new block has been
+// connected to the main chain.  This indexer adds a hash-to-transaction mapping
+// for every transaction in the passed block.
+//
+// This is part of the Indexer interface.
+func (idx *TxIndex) ConnectBlock(dbTx database.Tx, block *btcutil.Block, view *blockchain.UtxoViewpoint) error {
+	// Increment the internal block ID to use for the block being connected
+	// and add all of the transactions in the block to the index.
+	newBlockID := idx.curBlockID + 1
+	if err := dbAddTxIndexEntries(dbTx, block, newBlockID); err != nil {
+		return err
+	}
+
+	// Add the new block ID index entry for the block being connected and
+	// update the current internal block ID accordingly.
+	err := dbPutBlockIDIndexEntry(dbTx, block.Hash(), newBlockID)
+	if err != nil {
+		return err
+	}
+	idx.curBlockID = newBlockID
+	return nil
+}
+
+// DisconnectBlock is invoked by the index manager when a block has been
+// disconnected from the main chain.  This indexer removes the
+// hash-to-transaction mapping for every transaction in the block.
+//
+// This is part of the Indexer interface.
+func (idx *TxIndex) DisconnectBlock(dbTx database.Tx, block *btcutil.Block, view *blockchain.UtxoViewpoint) error {
+	// Remove all of the transactions in the block from the index.
+	if err := dbRemoveTxIndexEntries(dbTx, block); err != nil {
+		return err
+	}
+
+	// Remove the block ID index entry for the block being disconnected and
+	// decrement the current internal block ID to account for it.
+	if err := dbRemoveBlockIDIndexEntry(dbTx, block.Hash()); err != nil {
+		return err
+	}
+	idx.curBlockID--
+	return nil
+}
+
+// TxBlockRegion returns the block region for the provided transaction hash
+// from the transaction index.  The block region can in turn be used to load the
+// raw transaction bytes.  When there is no entry for the provided hash, nil
+// will be returned for the both the entry and the error.
+//
+// This function is safe for concurrent access.
+func (idx *TxIndex) TxBlockRegion(hash *chainhash.Hash) (*database.BlockRegion, error) {
+	var region *database.BlockRegion
+	err := idx.db.View(func(dbTx database.Tx) error {
+		var err error
+		region, err = dbFetchTxIndexEntry(dbTx, hash)
+		return err
+	})
+	return region, err
+}
+
+// NewTxIndex returns a new instance of an indexer that is used to create a
+// mapping of the hashes of all transactions in the blockchain to the respective
+// block, location within the block, and size of the transaction.
+//
+// It implements the Indexer interface which plugs into the IndexManager that in
+// turn is used by the blockchain package.  This allows the index to be
+// seamlessly maintained along with the chain.
+func NewTxIndex(db database.DB) *TxIndex {
+	return &TxIndex{db: db}
+}
+
+// dropBlockIDIndex drops the internal block id index.
+func dropBlockIDIndex(db database.DB) error {
+	return db.Update(func(dbTx database.Tx) error {
+		meta := dbTx.Metadata()
+		err := meta.DeleteBucket(idByHashIndexBucketName)
+		if err != nil {
+			return err
+		}
+
+		return meta.DeleteBucket(hashByIDIndexBucketName)
+	})
+}
+
+// DropTxIndex drops the transaction index from the provided database if it
+// exists.  Since the address index relies on it, the address index will also be
+// dropped when it exists.
+func DropTxIndex(db database.DB, interrupt <-chan struct{}) error {
+	err := dropIndex(db, addrIndexKey, addrIndexName, interrupt)
+	if err != nil {
+		return err
+	}
+
+	return dropIndex(db, txIndexKey, txIndexName, interrupt)
+}

vendor/github.com/btcsuite/btcd/blockchain/log.go

@@ -0,0 +1,30 @@
+// 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 blockchain
+
+import (
+	"github.com/btcsuite/btclog"
+)
+
+// log is a logger that is initialized with no output filters.  This
+// means the package will not perform any logging by default until the caller
+// requests it.
+var log btclog.Logger
+
+// The default amount of logging is none.
+func init() {
+	DisableLog()
+}
+
+// DisableLog disables all library log output.  Logging output is disabled
+// by default until UseLogger is called.
+func DisableLog() {
+	log = btclog.Disabled
+}
+
+// UseLogger uses a specified Logger to output package logging info.
+func UseLogger(logger btclog.Logger) {
+	log = logger
+}

vendor/github.com/btcsuite/btcd/blockchain/mediantime.go

@@ -0,0 +1,218 @@
+// 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 blockchain
+
+import (
+	"math"
+	"sort"
+	"sync"
+	"time"
+)
+
+const (
+	// maxAllowedOffsetSeconds is the maximum number of seconds in either
+	// direction that local clock will be adjusted.  When the median time
+	// of the network is outside of this range, no offset will be applied.
+	maxAllowedOffsetSecs = 70 * 60 // 1 hour 10 minutes
+
+	// similarTimeSecs is the number of seconds in either direction from the
+	// local clock that is used to determine that it is likley wrong and
+	// hence to show a warning.
+	similarTimeSecs = 5 * 60 // 5 minutes
+)
+
+var (
+	// maxMedianTimeEntries is the maximum number of entries allowed in the
+	// median time data.  This is a variable as opposed to a constant so the
+	// test code can modify it.
+	maxMedianTimeEntries = 200
+)
+
+// MedianTimeSource provides a mechanism to add several time samples which are
+// used to determine a median time which is then used as an offset to the local
+// clock.
+type MedianTimeSource interface {
+	// AdjustedTime returns the current time adjusted by the median time
+	// offset as calculated from the time samples added by AddTimeSample.
+	AdjustedTime() time.Time
+
+	// AddTimeSample adds a time sample that is used when determining the
+	// median time of the added samples.
+	AddTimeSample(id string, timeVal time.Time)
+
+	// Offset returns the number of seconds to adjust the local clock based
+	// upon the median of the time samples added by AddTimeData.
+	Offset() time.Duration
+}
+
+// int64Sorter implements sort.Interface to allow a slice of 64-bit integers to
+// be sorted.
+type int64Sorter []int64
+
+// Len returns the number of 64-bit integers in the slice.  It is part of the
+// sort.Interface implementation.
+func (s int64Sorter) Len() int {
+	return len(s)
+}
+
+// Swap swaps the 64-bit integers at the passed indices.  It is part of the
+// sort.Interface implementation.
+func (s int64Sorter) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+// Less returns whether the 64-bit integer with index i should sort before the
+// 64-bit integer with index j.  It is part of the sort.Interface
+// implementation.
+func (s int64Sorter) Less(i, j int) bool {
+	return s[i] < s[j]
+}
+
+// medianTime provides an implementation of the MedianTimeSource interface.
+// It is limited to maxMedianTimeEntries includes the same buggy behavior as
+// the time offset mechanism in Bitcoin Core.  This is necessary because it is
+// used in the consensus code.
+type medianTime struct {
+	mtx                sync.Mutex
+	knownIDs           map[string]struct{}
+	offsets            []int64
+	offsetSecs         int64
+	invalidTimeChecked bool
+}
+
+// Ensure the medianTime type implements the MedianTimeSource interface.
+var _ MedianTimeSource = (*medianTime)(nil)
+
+// AdjustedTime returns the current time adjusted by the median time offset as
+// calculated from the time samples added by AddTimeSample.
+//
+// This function is safe for concurrent access and is part of the
+// MedianTimeSource interface implementation.
+func (m *medianTime) AdjustedTime() time.Time {
+	m.mtx.Lock()
+	defer m.mtx.Unlock()
+
+	// Limit the adjusted time to 1 second precision.
+	now := time.Unix(time.Now().Unix(), 0)
+	return now.Add(time.Duration(m.offsetSecs) * time.Second)
+}
+
+// AddTimeSample adds a time sample that is used when determining the median
+// time of the added samples.
+//
+// This function is safe for concurrent access and is part of the
+// MedianTimeSource interface implementation.
+func (m *medianTime) AddTimeSample(sourceID string, timeVal time.Time) {
+	m.mtx.Lock()
+	defer m.mtx.Unlock()
+
+	// Don't add time data from the same source.
+	if _, exists := m.knownIDs[sourceID]; exists {
+		return
+	}
+	m.knownIDs[sourceID] = struct{}{}
+
+	// Truncate the provided offset to seconds and append it to the slice
+	// of offsets while respecting the maximum number of allowed entries by
+	// replacing the oldest entry with the new entry once the maximum number
+	// of entries is reached.
+	now := time.Unix(time.Now().Unix(), 0)
+	offsetSecs := int64(timeVal.Sub(now).Seconds())
+	numOffsets := len(m.offsets)
+	if numOffsets == maxMedianTimeEntries && maxMedianTimeEntries > 0 {
+		m.offsets = m.offsets[1:]
+		numOffsets--
+	}
+	m.offsets = append(m.offsets, offsetSecs)
+	numOffsets++
+
+	// Sort the offsets so the median can be obtained as needed later.
+	sortedOffsets := make([]int64, numOffsets)
+	copy(sortedOffsets, m.offsets)
+	sort.Sort(int64Sorter(sortedOffsets))
+
+	offsetDuration := time.Duration(offsetSecs) * time.Second
+	log.Debugf("Added time sample of %v (total: %v)", offsetDuration,
+		numOffsets)
+
+	// NOTE: The following code intentionally has a bug to mirror the
+	// buggy behavior in Bitcoin Core since the median time is used in the
+	// consensus rules.
+	//
+	// In particular, the offset is only updated when the number of entries
+	// is odd, but the max number of entries is 200, an even number.  Thus,
+	// the offset will never be updated again once the max number of entries
+	// is reached.
+
+	// The median offset is only updated when there are enough offsets and
+	// the number of offsets is odd so the middle value is the true median.
+	// Thus, there is nothing to do when those conditions are not met.
+	if numOffsets < 5 || numOffsets&0x01 != 1 {
+		return
+	}
+
+	// At this point the number of offsets in the list is odd, so the
+	// middle value of the sorted offsets is the median.
+	median := sortedOffsets[numOffsets/2]
+
+	// Set the new offset when the median offset is within the allowed
+	// offset range.
+	if math.Abs(float64(median)) < maxAllowedOffsetSecs {
+		m.offsetSecs = median
+	} else {
+		// The median offset of all added time data is larger than the
+		// maximum allowed offset, so don't use an offset.  This
+		// effectively limits how far the local clock can be skewed.
+		m.offsetSecs = 0
+
+		if !m.invalidTimeChecked {
+			m.invalidTimeChecked = true
+
+			// Find if any time samples have a time that is close
+			// to the local time.
+			var remoteHasCloseTime bool
+			for _, offset := range sortedOffsets {
+				if math.Abs(float64(offset)) < similarTimeSecs {
+					remoteHasCloseTime = true
+					break
+				}
+			}
+
+			// Warn if none of the time samples are close.
+			if !remoteHasCloseTime {
+				log.Warnf("Please check your date and time " +
+					"are correct!  btcd will not work " +
+					"properly with an invalid time")
+			}
+		}
+	}
+
+	medianDuration := time.Duration(m.offsetSecs) * time.Second
+	log.Debugf("New time offset: %v", medianDuration)
+}
+
+// Offset returns the number of seconds to adjust the local clock based upon the
+// median of the time samples added by AddTimeData.
+//
+// This function is safe for concurrent access and is part of the
+// MedianTimeSource interface implementation.
+func (m *medianTime) Offset() time.Duration {
+	m.mtx.Lock()
+	defer m.mtx.Unlock()
+
+	return time.Duration(m.offsetSecs) * time.Second
+}
+
+// NewMedianTime returns a new instance of concurrency-safe implementation of
+// the MedianTimeSource interface.  The returned implementation contains the
+// rules necessary for proper time handling in the chain consensus rules and
+// expects the time samples to be added from the timestamp field of the version
+// message received from remote peers that successfully connect and negotiate.
+func NewMedianTime() MedianTimeSource {
+	return &medianTime{
+		knownIDs: make(map[string]struct{}),
+		offsets:  make([]int64, 0, maxMedianTimeEntries),
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/mediantime_test.go

@@ -0,0 +1,104 @@
+// 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 blockchain
+
+import (
+	"strconv"
+	"testing"
+	"time"
+)
+
+// TestMedianTime tests the medianTime implementation.
+func TestMedianTime(t *testing.T) {
+	tests := []struct {
+		in         []int64
+		wantOffset int64
+		useDupID   bool
+	}{
+		// Not enough samples must result in an offset of 0.
+		{in: []int64{1}, wantOffset: 0},
+		{in: []int64{1, 2}, wantOffset: 0},
+		{in: []int64{1, 2, 3}, wantOffset: 0},
+		{in: []int64{1, 2, 3, 4}, wantOffset: 0},
+
+		// Various number of entries.  The expected offset is only
+		// updated on odd number of elements.
+		{in: []int64{-13, 57, -4, -23, -12}, wantOffset: -12},
+		{in: []int64{55, -13, 61, -52, 39, 55}, wantOffset: 39},
+		{in: []int64{-62, -58, -30, -62, 51, -30, 15}, wantOffset: -30},
+		{in: []int64{29, -47, 39, 54, 42, 41, 8, -33}, wantOffset: 39},
+		{in: []int64{37, 54, 9, -21, -56, -36, 5, -11, -39}, wantOffset: -11},
+		{in: []int64{57, -28, 25, -39, 9, 63, -16, 19, -60, 25}, wantOffset: 9},
+		{in: []int64{-5, -4, -3, -2, -1}, wantOffset: -3, useDupID: true},
+
+		// The offset stops being updated once the max number of entries
+		// has been reached.  This is actually a bug from Bitcoin Core,
+		// but since the time is ultimately used as a part of the
+		// consensus rules, it must be mirrored.
+		{in: []int64{-67, 67, -50, 24, 63, 17, 58, -14, 5, -32, -52}, wantOffset: 17},
+		{in: []int64{-67, 67, -50, 24, 63, 17, 58, -14, 5, -32, -52, 45}, wantOffset: 17},
+		{in: []int64{-67, 67, -50, 24, 63, 17, 58, -14, 5, -32, -52, 45, 4}, wantOffset: 17},
+
+		// Offsets that are too far away from the local time should
+		// be ignored.
+		{in: []int64{-4201, 4202, -4203, 4204, -4205}, wantOffset: 0},
+
+		// Excerise the condition where the median offset is greater
+		// than the max allowed adjustment, but there is at least one
+		// sample that is close enough to the current time to avoid
+		// triggering a warning about an invalid local clock.
+		{in: []int64{4201, 4202, 4203, 4204, -299}, wantOffset: 0},
+	}
+
+	// Modify the max number of allowed median time entries for these tests.
+	maxMedianTimeEntries = 10
+	defer func() { maxMedianTimeEntries = 200 }()
+
+	for i, test := range tests {
+		filter := NewMedianTime()
+		for j, offset := range test.in {
+			id := strconv.Itoa(j)
+			now := time.Unix(time.Now().Unix(), 0)
+			tOffset := now.Add(time.Duration(offset) * time.Second)
+			filter.AddTimeSample(id, tOffset)
+
+			// Ensure the duplicate IDs are ignored.
+			if test.useDupID {
+				// Modify the offsets to ensure the final median
+				// would be different if the duplicate is added.
+				tOffset = tOffset.Add(time.Duration(offset) *
+					time.Second)
+				filter.AddTimeSample(id, tOffset)
+			}
+		}
+
+		// Since it is possible that the time.Now call in AddTimeSample
+		// and the time.Now calls here in the tests will be off by one
+		// second, allow a fudge factor to compensate.
+		gotOffset := filter.Offset()
+		wantOffset := time.Duration(test.wantOffset) * time.Second
+		wantOffset2 := time.Duration(test.wantOffset-1) * time.Second
+		if gotOffset != wantOffset && gotOffset != wantOffset2 {
+			t.Errorf("Offset #%d: unexpected offset -- got %v, "+
+				"want %v or %v", i, gotOffset, wantOffset,
+				wantOffset2)
+			continue
+		}
+
+		// Since it is possible that the time.Now call in AdjustedTime
+		// and the time.Now call here in the tests will be off by one
+		// second, allow a fudge factor to compensate.
+		adjustedTime := filter.AdjustedTime()
+		now := time.Unix(time.Now().Unix(), 0)
+		wantTime := now.Add(filter.Offset())
+		wantTime2 := now.Add(filter.Offset() - time.Second)
+		if !adjustedTime.Equal(wantTime) && !adjustedTime.Equal(wantTime2) {
+			t.Errorf("AdjustedTime #%d: unexpected result -- got %v, "+
+				"want %v or %v", i, adjustedTime, wantTime,
+				wantTime2)
+			continue
+		}
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/merkle.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 blockchain
+
+import (
+	"bytes"
+	"fmt"
+	"math"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcutil"
+)
+
+const (
+	// CoinbaseWitnessDataLen is the required length of the only element within
+	// the coinbase's witness data if the coinbase transaction contains a
+	// witness commitment.
+	CoinbaseWitnessDataLen = 32
+
+	// CoinbaseWitnessPkScriptLength is the length of the public key script
+	// containing an OP_RETURN, the WitnessMagicBytes, and the witness
+	// commitment itself. In order to be a valid candidate for the output
+	// containing the witness commitment
+	CoinbaseWitnessPkScriptLength = 38
+)
+
+var (
+	// WitnessMagicBytes is the prefix marker within the public key script
+	// of a coinbase output to indicate that this output holds the witness
+	// commitment for a block.
+	WitnessMagicBytes = []byte{
+		txscript.OP_RETURN,
+		txscript.OP_DATA_36,
+		0xaa,
+		0x21,
+		0xa9,
+		0xed,
+	}
+)
+
+// nextPowerOfTwo returns the next highest power of two from a given number if
+// it is not already a power of two.  This is a helper function used during the
+// calculation of a merkle tree.
+func nextPowerOfTwo(n int) int {
+	// Return the number if it's already a power of 2.
+	if n&(n-1) == 0 {
+		return n
+	}
+
+	// Figure out and return the next power of two.
+	exponent := uint(math.Log2(float64(n))) + 1
+	return 1 << exponent // 2^exponent
+}
+
+// HashMerkleBranches takes two hashes, treated as the left and right tree
+// nodes, and returns the hash of their concatenation.  This is a helper
+// function used to aid in the generation of a merkle tree.
+func HashMerkleBranches(left *chainhash.Hash, right *chainhash.Hash) *chainhash.Hash {
+	// Concatenate the left and right nodes.
+	var hash [chainhash.HashSize * 2]byte
+	copy(hash[:chainhash.HashSize], left[:])
+	copy(hash[chainhash.HashSize:], right[:])
+
+	newHash := chainhash.DoubleHashH(hash[:])
+	return &newHash
+}
+
+// BuildMerkleTreeStore creates a merkle tree from a slice of transactions,
+// stores it using a linear array, and returns a slice of the backing array.  A
+// linear array was chosen as opposed to an actual tree structure since it uses
+// about half as much memory.  The following describes a merkle tree and how it
+// is stored in a linear array.
+//
+// A merkle tree is a tree in which every non-leaf node is the hash of its
+// children nodes.  A diagram depicting how this works for bitcoin transactions
+// where h(x) is a double sha256 follows:
+//
+//	         root = h1234 = h(h12 + h34)
+//	        /                           \
+//	  h12 = h(h1 + h2)            h34 = h(h3 + h4)
+//	   /            \              /            \
+//	h1 = h(tx1)  h2 = h(tx2)    h3 = h(tx3)  h4 = h(tx4)
+//
+// The above stored as a linear array is as follows:
+//
+// 	[h1 h2 h3 h4 h12 h34 root]
+//
+// As the above shows, the merkle root is always the last element in the array.
+//
+// The number of inputs is not always a power of two which results in a
+// balanced tree structure as above.  In that case, parent nodes with no
+// children are also zero and parent nodes with only a single left node
+// are calculated by concatenating the left node with itself before hashing.
+// Since this function uses nodes that are pointers to the hashes, empty nodes
+// will be nil.
+//
+// The additional bool parameter indicates if we are generating the merkle tree
+// using witness transaction id's rather than regular transaction id's. This
+// also presents an additional case wherein the wtxid of the coinbase transaction
+// is the zeroHash.
+func BuildMerkleTreeStore(transactions []*btcutil.Tx, witness bool) []*chainhash.Hash {
+	// Calculate how many entries are required to hold the binary merkle
+	// tree as a linear array and create an array of that size.
+	nextPoT := nextPowerOfTwo(len(transactions))
+	arraySize := nextPoT*2 - 1
+	merkles := make([]*chainhash.Hash, arraySize)
+
+	// Create the base transaction hashes and populate the array with them.
+	for i, tx := range transactions {
+		// If we're computing a witness merkle root, instead of the
+		// regular txid, we use the modified wtxid which includes a
+		// transaction's witness data within the digest. Additionally,
+		// the coinbase's wtxid is all zeroes.
+		switch {
+		case witness && i == 0:
+			var zeroHash chainhash.Hash
+			merkles[i] = &zeroHash
+		case witness:
+			wSha := tx.MsgTx().WitnessHash()
+			merkles[i] = &wSha
+		default:
+			merkles[i] = tx.Hash()
+		}
+
+	}
+
+	// Start the array offset after the last transaction and adjusted to the
+	// next power of two.
+	offset := nextPoT
+	for i := 0; i < arraySize-1; i += 2 {
+		switch {
+		// When there is no left child node, the parent is nil too.
+		case merkles[i] == nil:
+			merkles[offset] = nil
+
+		// When there is no right child, the parent is generated by
+		// hashing the concatenation of the left child with itself.
+		case merkles[i+1] == nil:
+			newHash := HashMerkleBranches(merkles[i], merkles[i])
+			merkles[offset] = newHash
+
+		// The normal case sets the parent node to the double sha256
+		// of the concatentation of the left and right children.
+		default:
+			newHash := HashMerkleBranches(merkles[i], merkles[i+1])
+			merkles[offset] = newHash
+		}
+		offset++
+	}
+
+	return merkles
+}
+
+// ExtractWitnessCommitment attempts to locate, and return the witness
+// commitment for a block. The witness commitment is of the form:
+// SHA256(witness root || witness nonce). The function additionally returns a
+// boolean indicating if the witness root was located within any of the txOut's
+// in the passed transaction. The witness commitment is stored as the data push
+// for an OP_RETURN with special magic bytes to aide in location.
+func ExtractWitnessCommitment(tx *btcutil.Tx) ([]byte, bool) {
+	// The witness commitment *must* be located within one of the coinbase
+	// transaction's outputs.
+	if !IsCoinBase(tx) {
+		return nil, false
+	}
+
+	msgTx := tx.MsgTx()
+	for i := len(msgTx.TxOut) - 1; i >= 0; i-- {
+		// The public key script that contains the witness commitment
+		// must shared a prefix with the WitnessMagicBytes, and be at
+		// least 38 bytes.
+		pkScript := msgTx.TxOut[i].PkScript
+		if len(pkScript) >= CoinbaseWitnessPkScriptLength &&
+			bytes.HasPrefix(pkScript, WitnessMagicBytes) {
+
+			// The witness commitment itself is a 32-byte hash
+			// directly after the WitnessMagicBytes. The remaining
+			// bytes beyond the 38th byte currently have no consensus
+			// meaning.
+			start := len(WitnessMagicBytes)
+			end := CoinbaseWitnessPkScriptLength
+			return msgTx.TxOut[i].PkScript[start:end], true
+		}
+	}
+
+	return nil, false
+}
+
+// ValidateWitnessCommitment validates the witness commitment (if any) found
+// within the coinbase transaction of the passed block.
+func ValidateWitnessCommitment(blk *btcutil.Block) error {
+	// If the block doesn't have any transactions at all, then we won't be
+	// able to extract a commitment from the non-existent coinbase
+	// transaction. So we exit early here.
+	if len(blk.Transactions()) == 0 {
+		str := "cannot validate witness commitment of block without " +
+			"transactions"
+		return ruleError(ErrNoTransactions, str)
+	}
+
+	coinbaseTx := blk.Transactions()[0]
+	if len(coinbaseTx.MsgTx().TxIn) == 0 {
+		return ruleError(ErrNoTxInputs, "transaction has no inputs")
+	}
+
+	witnessCommitment, witnessFound := ExtractWitnessCommitment(coinbaseTx)
+
+	// If we can't find a witness commitment in any of the coinbase's
+	// outputs, then the block MUST NOT contain any transactions with
+	// witness data.
+	if !witnessFound {
+		for _, tx := range blk.Transactions() {
+			msgTx := tx.MsgTx()
+			if msgTx.HasWitness() {
+				str := fmt.Sprintf("block contains transaction with witness" +
+					" data, yet no witness commitment present")
+				return ruleError(ErrUnexpectedWitness, str)
+			}
+		}
+		return nil
+	}
+
+	// At this point the block contains a witness commitment, so the
+	// coinbase transaction MUST have exactly one witness element within
+	// its witness data and that element must be exactly
+	// CoinbaseWitnessDataLen bytes.
+	coinbaseWitness := coinbaseTx.MsgTx().TxIn[0].Witness
+	if len(coinbaseWitness) != 1 {
+		str := fmt.Sprintf("the coinbase transaction has %d items in "+
+			"its witness stack when only one is allowed",
+			len(coinbaseWitness))
+		return ruleError(ErrInvalidWitnessCommitment, str)
+	}
+	witnessNonce := coinbaseWitness[0]
+	if len(witnessNonce) != CoinbaseWitnessDataLen {
+		str := fmt.Sprintf("the coinbase transaction witness nonce "+
+			"has %d bytes when it must be %d bytes",
+			len(witnessNonce), CoinbaseWitnessDataLen)
+		return ruleError(ErrInvalidWitnessCommitment, str)
+	}
+
+	// Finally, with the preliminary checks out of the way, we can check if
+	// the extracted witnessCommitment is equal to:
+	// SHA256(witnessMerkleRoot || witnessNonce). Where witnessNonce is the
+	// coinbase transaction's only witness item.
+	witnessMerkleTree := BuildMerkleTreeStore(blk.Transactions(), true)
+	witnessMerkleRoot := witnessMerkleTree[len(witnessMerkleTree)-1]
+
+	var witnessPreimage [chainhash.HashSize * 2]byte
+	copy(witnessPreimage[:], witnessMerkleRoot[:])
+	copy(witnessPreimage[chainhash.HashSize:], witnessNonce)
+
+	computedCommitment := chainhash.DoubleHashB(witnessPreimage[:])
+	if !bytes.Equal(computedCommitment, witnessCommitment) {
+		str := fmt.Sprintf("witness commitment does not match: "+
+			"computed %v, coinbase includes %v", computedCommitment,
+			witnessCommitment)
+		return ruleError(ErrWitnessCommitmentMismatch, str)
+	}
+
+	return nil
+}

vendor/github.com/btcsuite/btcd/blockchain/merkle_test.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 blockchain
+
+import (
+	"testing"
+
+	"github.com/btcsuite/btcutil"
+)
+
+// TestMerkle tests the BuildMerkleTreeStore API.
+func TestMerkle(t *testing.T) {
+	block := btcutil.NewBlock(&Block100000)
+	merkles := BuildMerkleTreeStore(block.Transactions(), false)
+	calculatedMerkleRoot := merkles[len(merkles)-1]
+	wantMerkle := &Block100000.Header.MerkleRoot
+	if !wantMerkle.IsEqual(calculatedMerkleRoot) {
+		t.Errorf("BuildMerkleTreeStore: merkle root mismatch - "+
+			"got %v, want %v", calculatedMerkleRoot, wantMerkle)
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/notifications.go

@@ -0,0 +1,81 @@
+// 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 blockchain
+
+import (
+	"fmt"
+)
+
+// NotificationType represents the type of a notification message.
+type NotificationType int
+
+// NotificationCallback is used for a caller to provide a callback for
+// notifications about various chain events.
+type NotificationCallback func(*Notification)
+
+// Constants for the type of a notification message.
+const (
+	// NTBlockAccepted indicates the associated block was accepted into
+	// the block chain.  Note that this does not necessarily mean it was
+	// added to the main chain.  For that, use NTBlockConnected.
+	NTBlockAccepted NotificationType = iota
+
+	// NTBlockConnected indicates the associated block was connected to the
+	// main chain.
+	NTBlockConnected
+
+	// NTBlockDisconnected indicates the associated block was disconnected
+	// from the main chain.
+	NTBlockDisconnected
+)
+
+// notificationTypeStrings is a map of notification types back to their constant
+// names for pretty printing.
+var notificationTypeStrings = map[NotificationType]string{
+	NTBlockAccepted:     "NTBlockAccepted",
+	NTBlockConnected:    "NTBlockConnected",
+	NTBlockDisconnected: "NTBlockDisconnected",
+}
+
+// String returns the NotificationType in human-readable form.
+func (n NotificationType) String() string {
+	if s, ok := notificationTypeStrings[n]; ok {
+		return s
+	}
+	return fmt.Sprintf("Unknown Notification Type (%d)", int(n))
+}
+
+// Notification defines notification that is sent to the caller via the callback
+// function provided during the call to New and consists of a notification type
+// as well as associated data that depends on the type as follows:
+// 	- NTBlockAccepted:     *btcutil.Block
+// 	- NTBlockConnected:    *btcutil.Block
+// 	- NTBlockDisconnected: *btcutil.Block
+type Notification struct {
+	Type NotificationType
+	Data interface{}
+}
+
+// Subscribe to block chain notifications. Registers a callback to be executed
+// when various events take place. See the documentation on Notification and
+// NotificationType for details on the types and contents of notifications.
+func (b *BlockChain) Subscribe(callback NotificationCallback) {
+	b.notificationsLock.Lock()
+	b.notifications = append(b.notifications, callback)
+	b.notificationsLock.Unlock()
+}
+
+// sendNotification sends a notification with the passed type and data if the
+// caller requested notifications by providing a callback function in the call
+// to New.
+func (b *BlockChain) sendNotification(typ NotificationType, data interface{}) {
+	// Generate and send the notification.
+	n := Notification{Type: typ, Data: data}
+	b.notificationsLock.RLock()
+	for _, callback := range b.notifications {
+		callback(&n)
+	}
+	b.notificationsLock.RUnlock()
+}

vendor/github.com/btcsuite/btcd/blockchain/notifications_test.go

@@ -0,0 +1,51 @@
+// 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 blockchain
+
+import (
+	"testing"
+
+	"github.com/btcsuite/btcd/chaincfg"
+)
+
+// TestNotifications ensures that notification callbacks are fired on events.
+func TestNotifications(t *testing.T) {
+	blocks, err := loadBlocks("blk_0_to_4.dat.bz2")
+	if err != nil {
+		t.Fatalf("Error loading file: %v\n", err)
+	}
+
+	// Create a new database and chain instance to run tests against.
+	chain, teardownFunc, err := chainSetup("notifications",
+		&chaincfg.MainNetParams)
+	if err != nil {
+		t.Fatalf("Failed to setup chain instance: %v", err)
+	}
+	defer teardownFunc()
+
+	notificationCount := 0
+	callback := func(notification *Notification) {
+		if notification.Type == NTBlockAccepted {
+			notificationCount++
+		}
+	}
+
+	// Register callback multiple times then assert it is called that many
+	// times.
+	const numSubscribers = 3
+	for i := 0; i < numSubscribers; i++ {
+		chain.Subscribe(callback)
+	}
+
+	_, _, err = chain.ProcessBlock(blocks[1], BFNone)
+	if err != nil {
+		t.Fatalf("ProcessBlock fail on block 1: %v\n", err)
+	}
+
+	if notificationCount != numSubscribers {
+		t.Fatalf("Expected notification callback to be executed %d "+
+			"times, found %d", numSubscribers, notificationCount)
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/process.go

@@ -0,0 +1,244 @@
+// 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 blockchain
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/database"
+	"github.com/btcsuite/btcutil"
+)
+
+// BehaviorFlags is a bitmask defining tweaks to the normal behavior when
+// performing chain processing and consensus rules checks.
+type BehaviorFlags uint32
+
+const (
+	// BFFastAdd may be set to indicate that several checks can be avoided
+	// for the block since it is already known to fit into the chain due to
+	// already proving it correct links into the chain up to a known
+	// checkpoint.  This is primarily used for headers-first mode.
+	BFFastAdd BehaviorFlags = 1 << iota
+
+	// BFNoPoWCheck may be set to indicate the proof of work check which
+	// ensures a block hashes to a value less than the required target will
+	// not be performed.
+	BFNoPoWCheck
+
+	// BFNone is a convenience value to specifically indicate no flags.
+	BFNone BehaviorFlags = 0
+)
+
+// blockExists determines whether a block with the given hash exists either in
+// the main chain or any side chains.
+//
+// This function is safe for concurrent access.
+func (b *BlockChain) blockExists(hash *chainhash.Hash) (bool, error) {
+	// Check block index first (could be main chain or side chain blocks).
+	if b.index.HaveBlock(hash) {
+		return true, nil
+	}
+
+	// Check in the database.
+	var exists bool
+	err := b.db.View(func(dbTx database.Tx) error {
+		var err error
+		exists, err = dbTx.HasBlock(hash)
+		if err != nil || !exists {
+			return err
+		}
+
+		// Ignore side chain blocks in the database.  This is necessary
+		// because there is not currently any record of the associated
+		// block index data such as its block height, so it's not yet
+		// possible to efficiently load the block and do anything useful
+		// with it.
+		//
+		// Ultimately the entire block index should be serialized
+		// instead of only the current main chain so it can be consulted
+		// directly.
+		_, err = dbFetchHeightByHash(dbTx, hash)
+		if isNotInMainChainErr(err) {
+			exists = false
+			return nil
+		}
+		return err
+	})
+	return exists, err
+}
+
+// processOrphans determines if there are any orphans which depend on the passed
+// block hash (they are no longer orphans if true) and potentially accepts them.
+// It repeats the process for the newly accepted blocks (to detect further
+// orphans which may no longer be orphans) until there are no more.
+//
+// The flags do not modify the behavior of this function directly, however they
+// are needed to pass along to maybeAcceptBlock.
+//
+// This function MUST be called with the chain state lock held (for writes).
+func (b *BlockChain) processOrphans(hash *chainhash.Hash, flags BehaviorFlags) error {
+	// Start with processing at least the passed hash.  Leave a little room
+	// for additional orphan blocks that need to be processed without
+	// needing to grow the array in the common case.
+	processHashes := make([]*chainhash.Hash, 0, 10)
+	processHashes = append(processHashes, hash)
+	for len(processHashes) > 0 {
+		// Pop the first hash to process from the slice.
+		processHash := processHashes[0]
+		processHashes[0] = nil // Prevent GC leak.
+		processHashes = processHashes[1:]
+
+		// Look up all orphans that are parented by the block we just
+		// accepted.  This will typically only be one, but it could
+		// be multiple if multiple blocks are mined and broadcast
+		// around the same time.  The one with the most proof of work
+		// will eventually win out.  An indexing for loop is
+		// intentionally used over a range here as range does not
+		// reevaluate the slice on each iteration nor does it adjust the
+		// index for the modified slice.
+		for i := 0; i < len(b.prevOrphans[*processHash]); i++ {
+			orphan := b.prevOrphans[*processHash][i]
+			if orphan == nil {
+				log.Warnf("Found a nil entry at index %d in the "+
+					"orphan dependency list for block %v", i,
+					processHash)
+				continue
+			}
+
+			// Remove the orphan from the orphan pool.
+			orphanHash := orphan.block.Hash()
+			b.removeOrphanBlock(orphan)
+			i--
+
+			// Potentially accept the block into the block chain.
+			_, err := b.maybeAcceptBlock(orphan.block, flags)
+			if err != nil {
+				return err
+			}
+
+			// Add this block to the list of blocks to process so
+			// any orphan blocks that depend on this block are
+			// handled too.
+			processHashes = append(processHashes, orphanHash)
+		}
+	}
+	return nil
+}
+
+// ProcessBlock is the main workhorse for handling insertion of new blocks into
+// the block chain.  It includes functionality such as rejecting duplicate
+// blocks, ensuring blocks follow all rules, orphan handling, and insertion into
+// the block chain along with best chain selection and reorganization.
+//
+// When no errors occurred during processing, the first return value indicates
+// whether or not the block is on the main chain and the second indicates
+// whether or not the block is an orphan.
+//
+// This function is safe for concurrent access.
+func (b *BlockChain) ProcessBlock(block *btcutil.Block, flags BehaviorFlags) (bool, bool, error) {
+	b.chainLock.Lock()
+	defer b.chainLock.Unlock()
+
+	fastAdd := flags&BFFastAdd == BFFastAdd
+
+	blockHash := block.Hash()
+	log.Tracef("Processing block %v", blockHash)
+
+	// The block must not already exist in the main chain or side chains.
+	exists, err := b.blockExists(blockHash)
+	if err != nil {
+		return false, false, err
+	}
+	if exists {
+		str := fmt.Sprintf("already have block %v", blockHash)
+		return false, false, ruleError(ErrDuplicateBlock, str)
+	}
+
+	// The block must not already exist as an orphan.
+	if _, exists := b.orphans[*blockHash]; exists {
+		str := fmt.Sprintf("already have block (orphan) %v", blockHash)
+		return false, false, ruleError(ErrDuplicateBlock, str)
+	}
+
+	// Perform preliminary sanity checks on the block and its transactions.
+	err = checkBlockSanity(block, b.chainParams.PowLimit, b.timeSource, flags)
+	if err != nil {
+		return false, false, err
+	}
+
+	// Find the previous checkpoint and perform some additional checks based
+	// on the checkpoint.  This provides a few nice properties such as
+	// preventing old side chain blocks before the last checkpoint,
+	// rejecting easy to mine, but otherwise bogus, blocks that could be
+	// used to eat memory, and ensuring expected (versus claimed) proof of
+	// work requirements since the previous checkpoint are met.
+	blockHeader := &block.MsgBlock().Header
+	checkpointNode, err := b.findPreviousCheckpoint()
+	if err != nil {
+		return false, false, err
+	}
+	if checkpointNode != nil {
+		// Ensure the block timestamp is after the checkpoint timestamp.
+		checkpointTime := time.Unix(checkpointNode.timestamp, 0)
+		if blockHeader.Timestamp.Before(checkpointTime) {
+			str := fmt.Sprintf("block %v has timestamp %v before "+
+				"last checkpoint timestamp %v", blockHash,
+				blockHeader.Timestamp, checkpointTime)
+			return false, false, ruleError(ErrCheckpointTimeTooOld, str)
+		}
+		if !fastAdd {
+			// Even though the checks prior to now have already ensured the
+			// proof of work exceeds the claimed amount, the claimed amount
+			// is a field in the block header which could be forged.  This
+			// check ensures the proof of work is at least the minimum
+			// expected based on elapsed time since the last checkpoint and
+			// maximum adjustment allowed by the retarget rules.
+			duration := blockHeader.Timestamp.Sub(checkpointTime)
+			requiredTarget := CompactToBig(b.calcEasiestDifficulty(
+				checkpointNode.bits, duration))
+			currentTarget := CompactToBig(blockHeader.Bits)
+			if currentTarget.Cmp(requiredTarget) > 0 {
+				str := fmt.Sprintf("block target difficulty of %064x "+
+					"is too low when compared to the previous "+
+					"checkpoint", currentTarget)
+				return false, false, ruleError(ErrDifficultyTooLow, str)
+			}
+		}
+	}
+
+	// Handle orphan blocks.
+	prevHash := &blockHeader.PrevBlock
+	prevHashExists, err := b.blockExists(prevHash)
+	if err != nil {
+		return false, false, err
+	}
+	if !prevHashExists {
+		log.Infof("Adding orphan block %v with parent %v", blockHash, prevHash)
+		b.addOrphanBlock(block)
+
+		return false, true, nil
+	}
+
+	// The block has passed all context independent checks and appears sane
+	// enough to potentially accept it into the block chain.
+	isMainChain, err := b.maybeAcceptBlock(block, flags)
+	if err != nil {
+		return false, false, err
+	}
+
+	// Accept any orphan blocks that depend on this block (they are
+	// no longer orphans) and repeat for those accepted blocks until
+	// there are no more.
+	err = b.processOrphans(blockHash, flags)
+	if err != nil {
+		return false, false, err
+	}
+
+	log.Debugf("Accepted block %v", blockHash)
+
+	return isMainChain, false, nil
+}

vendor/github.com/btcsuite/btcd/blockchain/scriptval.go

@@ -0,0 +1,333 @@
+// 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 blockchain
+
+import (
+	"fmt"
+	"math"
+	"runtime"
+	"time"
+
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+)
+
+// txValidateItem holds a transaction along with which input to validate.
+type txValidateItem struct {
+	txInIndex int
+	txIn      *wire.TxIn
+	tx        *btcutil.Tx
+	sigHashes *txscript.TxSigHashes
+}
+
+// txValidator provides a type which asynchronously validates transaction
+// inputs.  It provides several channels for communication and a processing
+// function that is intended to be in run multiple goroutines.
+type txValidator struct {
+	validateChan chan *txValidateItem
+	quitChan     chan struct{}
+	resultChan   chan error
+	utxoView     *UtxoViewpoint
+	flags        txscript.ScriptFlags
+	sigCache     *txscript.SigCache
+	hashCache    *txscript.HashCache
+}
+
+// sendResult sends the result of a script pair validation on the internal
+// result channel while respecting the quit channel.  This allows orderly
+// shutdown when the validation process is aborted early due to a validation
+// error in one of the other goroutines.
+func (v *txValidator) sendResult(result error) {
+	select {
+	case v.resultChan <- result:
+	case <-v.quitChan:
+	}
+}
+
+// validateHandler consumes items to validate from the internal validate channel
+// and returns the result of the validation on the internal result channel. It
+// must be run as a goroutine.
+func (v *txValidator) validateHandler() {
+out:
+	for {
+		select {
+		case txVI := <-v.validateChan:
+			// Ensure the referenced input transaction is available.
+			txIn := txVI.txIn
+			originTxHash := &txIn.PreviousOutPoint.Hash
+			originTxIndex := txIn.PreviousOutPoint.Index
+			txEntry := v.utxoView.LookupEntry(originTxHash)
+			if txEntry == nil {
+				str := fmt.Sprintf("unable to find input "+
+					"transaction %v referenced from "+
+					"transaction %v", originTxHash,
+					txVI.tx.Hash())
+				err := ruleError(ErrMissingTxOut, str)
+				v.sendResult(err)
+				break out
+			}
+
+			// Ensure the referenced input transaction public key
+			// script is available.
+			pkScript := txEntry.PkScriptByIndex(originTxIndex)
+			if pkScript == nil {
+				str := fmt.Sprintf("unable to find unspent "+
+					"output %v script referenced from "+
+					"transaction %s:%d",
+					txIn.PreviousOutPoint, txVI.tx.Hash(),
+					txVI.txInIndex)
+				err := ruleError(ErrBadTxInput, str)
+				v.sendResult(err)
+				break out
+			}
+
+			// Create a new script engine for the script pair.
+			sigScript := txIn.SignatureScript
+			witness := txIn.Witness
+			inputAmount := txEntry.AmountByIndex(originTxIndex)
+			vm, err := txscript.NewEngine(pkScript, txVI.tx.MsgTx(),
+				txVI.txInIndex, v.flags, v.sigCache, txVI.sigHashes,
+				inputAmount)
+			if err != nil {
+				str := fmt.Sprintf("failed to parse input "+
+					"%s:%d which references output %s:%d - "+
+					"%v (input witness %x, input script "+
+					"bytes %x, prev output script bytes %x)",
+					txVI.tx.Hash(), txVI.txInIndex, originTxHash,
+					originTxIndex, err, witness, sigScript,
+					pkScript)
+				err := ruleError(ErrScriptMalformed, str)
+				v.sendResult(err)
+				break out
+			}
+
+			// Execute the script pair.
+			if err := vm.Execute(); err != nil {
+				str := fmt.Sprintf("failed to validate input "+
+					"%s:%d which references output %s:%d - "+
+					"%v (input witness %x, input script "+
+					"bytes %x, prev output script bytes %x)",
+					txVI.tx.Hash(), txVI.txInIndex,
+					originTxHash, originTxIndex, err,
+					witness, sigScript, pkScript)
+				err := ruleError(ErrScriptValidation, str)
+				v.sendResult(err)
+				break out
+			}
+
+			// Validation succeeded.
+			v.sendResult(nil)
+
+		case <-v.quitChan:
+			break out
+		}
+	}
+}
+
+// Validate validates the scripts for all of the passed transaction inputs using
+// multiple goroutines.
+func (v *txValidator) Validate(items []*txValidateItem) error {
+	if len(items) == 0 {
+		return nil
+	}
+
+	// Limit the number of goroutines to do script validation based on the
+	// number of processor cores.  This helps ensure the system stays
+	// reasonably responsive under heavy load.
+	maxGoRoutines := runtime.NumCPU() * 3
+	if maxGoRoutines <= 0 {
+		maxGoRoutines = 1
+	}
+	if maxGoRoutines > len(items) {
+		maxGoRoutines = len(items)
+	}
+
+	// Start up validation handlers that are used to asynchronously
+	// validate each transaction input.
+	for i := 0; i < maxGoRoutines; i++ {
+		go v.validateHandler()
+	}
+
+	// Validate each of the inputs.  The quit channel is closed when any
+	// errors occur so all processing goroutines exit regardless of which
+	// input had the validation error.
+	numInputs := len(items)
+	currentItem := 0
+	processedItems := 0
+	for processedItems < numInputs {
+		// Only send items while there are still items that need to
+		// be processed.  The select statement will never select a nil
+		// channel.
+		var validateChan chan *txValidateItem
+		var item *txValidateItem
+		if currentItem < numInputs {
+			validateChan = v.validateChan
+			item = items[currentItem]
+		}
+
+		select {
+		case validateChan <- item:
+			currentItem++
+
+		case err := <-v.resultChan:
+			processedItems++
+			if err != nil {
+				close(v.quitChan)
+				return err
+			}
+		}
+	}
+
+	close(v.quitChan)
+	return nil
+}
+
+// newTxValidator returns a new instance of txValidator to be used for
+// validating transaction scripts asynchronously.
+func newTxValidator(utxoView *UtxoViewpoint, flags txscript.ScriptFlags,
+	sigCache *txscript.SigCache, hashCache *txscript.HashCache) *txValidator {
+	return &txValidator{
+		validateChan: make(chan *txValidateItem),
+		quitChan:     make(chan struct{}),
+		resultChan:   make(chan error),
+		utxoView:     utxoView,
+		sigCache:     sigCache,
+		hashCache:    hashCache,
+		flags:        flags,
+	}
+}
+
+// ValidateTransactionScripts validates the scripts for the passed transaction
+// using multiple goroutines.
+func ValidateTransactionScripts(tx *btcutil.Tx, utxoView *UtxoViewpoint,
+	flags txscript.ScriptFlags, sigCache *txscript.SigCache,
+	hashCache *txscript.HashCache) error {
+
+	// First determine if segwit is active according to the scriptFlags. If
+	// it isn't then we don't need to interact with the HashCache.
+	segwitActive := flags&txscript.ScriptVerifyWitness == txscript.ScriptVerifyWitness
+
+	// If the hashcache doesn't yet has the sighash midstate for this
+	// transaction, then we'll compute them now so we can re-use them
+	// amongst all worker validation goroutines.
+	if segwitActive && tx.MsgTx().HasWitness() &&
+		!hashCache.ContainsHashes(tx.Hash()) {
+		hashCache.AddSigHashes(tx.MsgTx())
+	}
+
+	var cachedHashes *txscript.TxSigHashes
+	if segwitActive && tx.MsgTx().HasWitness() {
+		// The same pointer to the transaction's sighash midstate will
+		// be re-used amongst all validation goroutines. By
+		// pre-computing the sighash here instead of during validation,
+		// we ensure the sighashes
+		// are only computed once.
+		cachedHashes, _ = hashCache.GetSigHashes(tx.Hash())
+	}
+
+	// Collect all of the transaction inputs and required information for
+	// validation.
+	txIns := tx.MsgTx().TxIn
+	txValItems := make([]*txValidateItem, 0, len(txIns))
+	for txInIdx, txIn := range txIns {
+		// Skip coinbases.
+		if txIn.PreviousOutPoint.Index == math.MaxUint32 {
+			continue
+		}
+
+		txVI := &txValidateItem{
+			txInIndex: txInIdx,
+			txIn:      txIn,
+			tx:        tx,
+			sigHashes: cachedHashes,
+		}
+		txValItems = append(txValItems, txVI)
+	}
+
+	// Validate all of the inputs.
+	validator := newTxValidator(utxoView, flags, sigCache, hashCache)
+	return validator.Validate(txValItems)
+}
+
+// checkBlockScripts executes and validates the scripts for all transactions in
+// the passed block using multiple goroutines.
+func checkBlockScripts(block *btcutil.Block, utxoView *UtxoViewpoint,
+	scriptFlags txscript.ScriptFlags, sigCache *txscript.SigCache,
+	hashCache *txscript.HashCache) error {
+
+	// First determine if segwit is active according to the scriptFlags. If
+	// it isn't then we don't need to interact with the HashCache.
+	segwitActive := scriptFlags&txscript.ScriptVerifyWitness == txscript.ScriptVerifyWitness
+
+	// Collect all of the transaction inputs and required information for
+	// validation for all transactions in the block into a single slice.
+	numInputs := 0
+	for _, tx := range block.Transactions() {
+		numInputs += len(tx.MsgTx().TxIn)
+	}
+	txValItems := make([]*txValidateItem, 0, numInputs)
+	for _, tx := range block.Transactions() {
+		hash := tx.Hash()
+
+		// If the HashCache is present, and it doesn't yet contain the
+		// partial sighashes for this transaction, then we add the
+		// sighashes for the transaction. This allows us to take
+		// advantage of the potential speed savings due to the new
+		// digest algorithm (BIP0143).
+		if segwitActive && tx.HasWitness() && hashCache != nil &&
+			!hashCache.ContainsHashes(hash) {
+
+			hashCache.AddSigHashes(tx.MsgTx())
+		}
+
+		var cachedHashes *txscript.TxSigHashes
+		if segwitActive && tx.HasWitness() {
+			if hashCache != nil {
+				cachedHashes, _ = hashCache.GetSigHashes(hash)
+			} else {
+				cachedHashes = txscript.NewTxSigHashes(tx.MsgTx())
+			}
+		}
+
+		for txInIdx, txIn := range tx.MsgTx().TxIn {
+			// Skip coinbases.
+			if txIn.PreviousOutPoint.Index == math.MaxUint32 {
+				continue
+			}
+
+			txVI := &txValidateItem{
+				txInIndex: txInIdx,
+				txIn:      txIn,
+				tx:        tx,
+				sigHashes: cachedHashes,
+			}
+			txValItems = append(txValItems, txVI)
+		}
+	}
+
+	// Validate all of the inputs.
+	validator := newTxValidator(utxoView, scriptFlags, sigCache, hashCache)
+	start := time.Now()
+	if err := validator.Validate(txValItems); err != nil {
+		return err
+	}
+	elapsed := time.Since(start)
+
+	log.Tracef("block %v took %v to verify", block.Hash(), elapsed)
+
+	// If the HashCache is present, once we have validated the block, we no
+	// longer need the cached hashes for these transactions, so we purge
+	// them from the cache.
+	if segwitActive && hashCache != nil {
+		for _, tx := range block.Transactions() {
+			if tx.MsgTx().HasWitness() {
+				hashCache.PurgeSigHashes(tx.Hash())
+			}
+		}
+	}
+
+	return nil
+}

vendor/github.com/btcsuite/btcd/blockchain/scriptval_test.go

@@ -0,0 +1,49 @@
+// 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 blockchain
+
+import (
+	"fmt"
+	"runtime"
+	"testing"
+
+	"github.com/btcsuite/btcd/txscript"
+)
+
+// TestCheckBlockScripts ensures that validating the all of the scripts in a
+// known-good block doesn't return an error.
+func TestCheckBlockScripts(t *testing.T) {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	testBlockNum := 277647
+	blockDataFile := fmt.Sprintf("%d.dat.bz2", testBlockNum)
+	blocks, err := loadBlocks(blockDataFile)
+	if err != nil {
+		t.Errorf("Error loading file: %v\n", err)
+		return
+	}
+	if len(blocks) > 1 {
+		t.Errorf("The test block file must only have one block in it")
+		return
+	}
+	if len(blocks) == 0 {
+		t.Errorf("The test block file may not be empty")
+		return
+	}
+
+	storeDataFile := fmt.Sprintf("%d.utxostore.bz2", testBlockNum)
+	view, err := loadUtxoView(storeDataFile)
+	if err != nil {
+		t.Errorf("Error loading txstore: %v\n", err)
+		return
+	}
+
+	scriptFlags := txscript.ScriptBip16
+	err = checkBlockScripts(blocks[0], view, scriptFlags, nil, nil)
+	if err != nil {
+		t.Errorf("Transaction script validation failed: %v\n", err)
+		return
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/testdata/reorgtest.hex

@@ -0,0 +1,180 @@
+File path:  reorgTest/blk_0_to_4.dat
+
+Block 0:
+   f9beb4d9
+   1d010000
+   
+   01000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
+   00000000 3ba3edfd 7a7b12b2 7ac72c3e 67768f61 7fc81bc3 888a5132 3a9fb8aa 
+   4b1e5e4a 29ab5f49 ffff001d 1dac2b7c 
+   01
+   
+   01000000 01000000 00000000 00000000 00000000 00000000 00000000 00000000 
+   00000000 00ffffff ff4d04ff ff001d01 04455468 65205469 6d657320 30332f4a 
+   616e2f32 30303920 4368616e 63656c6c 6f72206f 6e206272 696e6b20 6f662073 
+   65636f6e 64206261 696c6f75 7420666f 72206261 6e6b73ff ffffff01 00f2052a 
+   01000000 43410467 8afdb0fe 55482719 67f1a671 30b7105c d6a828e0 3909a679 
+   62e0ea1f 61deb649 f6bc3f4c ef38c4f3 5504e51e c112de5c 384df7ba 0b8d578a 
+   4c702b6b f11d5fac 00000000 
+Block 1:
+   f9beb4d9
+   d4000000
+   
+   01000000 6fe28c0a b6f1b372 c1a6a246 ae63f74f 931e8365 e15a089c 68d61900 
+   00000000 3bbd67ad e98fbbb7 0718cd80 f9e9acf9 3b5fae91 7bb2b41d 4c3bb82c 
+   77725ca5 81ad5f49 ffff001d 44e69904 
+   01
+   
+   01000000 01000000 00000000 00000000 00000000 00000000 00000000 00000000 
+   00000000 00ffffff ff04722f 2e2bffff ffff0100 f2052a01 00000043 41046868 
+   0737c76d abb801cb 2204f57d be4e4579 e4f710cd 67dc1b42 27592c81 e9b5cf02 
+   b5ac9e8b 4c9f49be 5251056b 6a6d011e 4c37f6b6 d17ede6b 55faa235 19e2ac00 
+   000000 
+Block 2:
+   f9beb4d9
+   95010000
+   
+   01000000 13ca7940 4c11c63e ca906bbd f190b751 2872b857 1b5143ae e8cb5737 
+   00000000 fc07c983 d7391736 0aeda657 29d0d4d3 2533eb84 76ee9d64 aa27538f 
+   9b4fc00a d9af5f49 ffff001d 630bea22 
+   02
+   
+   01000000 01000000 00000000 00000000 00000000 00000000 00000000 00000000 
+   00000000 00ffffff ff04eb96 14e5ffff ffff0100 f2052a01 00000043 41046868 
+   0737c76d abb801cb 2204f57d be4e4579 e4f710cd 67dc1b42 27592c81 e9b5cf02 
+   b5ac9e8b 4c9f49be 5251056b 6a6d011e 4c37f6b6 d17ede6b 55faa235 19e2ac00 
+   000000 
+   
+   01000000 0163451d 1002611c 1388d5ba 4ddfdf99 196a86b5 990fb5b0 dc786207 
+   4fdcb8ee d2000000 004a4930 46022100 3dde52c6 5e339f45 7fe1015e 70eed208 
+   872eb71e dd484c07 206b190e cb2ec3f8 02210011 c78dcfd0 3d43fa63 61242a33 
+   6291ba2a 8c1ef5bc d5472126 2468f2bf 8dee4d01 ffffffff 0200ca9a 3b000000 
+   001976a9 14cb2abd e8bccacc 32e893df 3a054b9e f7f227a4 ce88ac00 286bee00 
+   00000019 76a914ee 26c56fc1 d942be8d 7a24b2a1 001dd894 69398088 ac000000 
+   00 
+Block 3:
+   f9beb4d9
+   96020000
+   
+   01000000 7d338254 0506faab 0d4cf179 45dda023 49db51f9 6233f24c 28002258 
+   00000000 4806fe80 bf85931b 882ea645 77ca5a03 22bb8af2 3f277b20 55f160cd 
+   972c8e8b 31b25f49 ffff001d e8f0c653 
+   03
+   
+   01000000 01000000 00000000 00000000 00000000 00000000 00000000 00000000 
+   00000000 00ffffff ff044abd 8159ffff ffff0100 f2052a01 00000043 4104b95c 
+   249d84f4 17e3e395 a1274254 28b54067 1cc15881 eb828c17 b722a53f c599e21c 
+   a5e56c90 f340988d 3933acc7 6beb832f d64cab07 8ddf3ce7 32923031 d1a8ac00 
+   000000 
+   
+   01000000 01f287b5 e067e1cf 80f7da8a f89917b5 505094db d82412d9 35b665eb 
+   bad253d3 77010000 008c4930 46022100 96ee0d02 b35fd61e 4960b44f f396f67e 
+   01fe17f9 de4e0c17 b6a963bd ab2b50a6 02210034 920d4daa 7e9f8abe 5675c931 
+   495809f9 0b9c1189 d05fbaf1 dd6696a5 b0d8f301 41046868 0737c76d abb801cb 
+   2204f57d be4e4579 e4f710cd 67dc1b42 27592c81 e9b5cf02 b5ac9e8b 4c9f49be 
+   5251056b 6a6d011e 4c37f6b6 d17ede6b 55faa235 19e2ffff ffff0100 286bee00 
+   00000019 76a914c5 22664fb0 e55cdc5c 0cea73b4 aad97ec8 34323288 ac000000 
+   00 
+   
+   01000000 01f287b5 e067e1cf 80f7da8a f89917b5 505094db d82412d9 35b665eb 
+   bad253d3 77000000 008c4930 46022100 b08b922a c4bde411 1c229f92 9fe6eb6a 
+   50161f98 1f4cf47e a9214d35 bf74d380 022100d2 f6640327 e677a1e1 cc474991 
+   b9a48ba5 bd1e0c94 d1c8df49 f7b0193b 7ea4fa01 4104b95c 249d84f4 17e3e395 
+   a1274254 28b54067 1cc15881 eb828c17 b722a53f c599e21c a5e56c90 f340988d 
+   3933acc7 6beb832f d64cab07 8ddf3ce7 32923031 d1a8ffff ffff0100 ca9a3b00 
+   00000019 76a914c5 22664fb0 e55cdc5c 0cea73b4 aad97ec8 34323288 ac000000 
+   00 
+
+Block 4:
+   f9beb4d9
+   73010000
+   
+   01000000 5da36499 06f35e09 9be42a1d 87b6dd42 11bc1400 6c220694 0807eaae 
+   00000000 48eeeaed 2d9d8522 e6201173 743823fd 4b87cd8a ca8e6408 ec75ca38 
+   302c2ff0 89b45f49 ffff001d 00530839 
+   02
+   
+   01000000 01000000 00000000 00000000 00000000 00000000 00000000 00000000 
+   00000000 00ffffff ff04d41d 2213ffff ffff0100 f2052a01 00000043 4104678a 
+   fdb0fe55 48271967 f1a67130 b7105cd6 a828e039 09a67962 e0ea1f61 deb649f6 
+   bc3f4cef 38c4f355 04e51ec1 12de5c38 4df7ba0b 8d578a4c 702b6bf1 1d5fac00 
+   000000 
+   
+   01000000 0163451d 1002611c 1388d5ba 4ddfdf99 196a86b5 990fb5b0 dc786207 
+   4fdcb8ee d2000000 004a4930 46022100 8c8fd57b 48762135 8d8f3e69 19f33e08 
+   804736ff 83db47aa 248512e2 6df9b8ba 022100b0 c59e5ee7 bfcbfcd1 a4d83da9 
+   55fb260e fda7f42a 25522625 a3d6f2d9 1174a701 ffffffff 0100f205 2a010000 
+   001976a9 14c52266 4fb0e55c dc5c0cea 73b4aad9 7ec83432 3288ac00 000000 
+
+File path:  reorgTest/blk_3A.dat
+Block 3A:
+   f9beb4d9
+   96020000
+   
+   01000000 7d338254 0506faab 0d4cf179 45dda023 49db51f9 6233f24c 28002258 
+   00000000 5a15f573 1177a353 bdca7aab 20e16624 dfe90adc 70accadc 68016732 
+   302c20a7 31b25f49 ffff001d 6a901440 
+   03
+   
+   01000000 01000000 00000000 00000000 00000000 00000000 00000000 00000000 
+   00000000 00ffffff ff04ad1b e7d5ffff ffff0100 f2052a01 00000043 4104ed83 
+   704c95d8 29046f1a c2780621 1132102c 34e9ac7f fa1b7111 0658e5b9 d1bdedc4 
+   16f5cefc 1db0625c d0c75de8 192d2b59 2d7e3b00 bcfb4a0e 860d880f d1fcac00 
+   000000 
+   
+   01000000 01f287b5 e067e1cf 80f7da8a f89917b5 505094db d82412d9 35b665eb 
+   bad253d3 77010000 008c4930 46022100 96ee0d02 b35fd61e 4960b44f f396f67e 
+   01fe17f9 de4e0c17 b6a963bd ab2b50a6 02210034 920d4daa 7e9f8abe 5675c931 
+   495809f9 0b9c1189 d05fbaf1 dd6696a5 b0d8f301 41046868 0737c76d abb801cb 
+   2204f57d be4e4579 e4f710cd 67dc1b42 27592c81 e9b5cf02 b5ac9e8b 4c9f49be 
+   5251056b 6a6d011e 4c37f6b6 d17ede6b 55faa235 19e2ffff ffff0100 286bee00 
+   00000019 76a914c5 22664fb0 e55cdc5c 0cea73b4 aad97ec8 34323288 ac000000 
+   00 
+   
+   01000000 01f287b5 e067e1cf 80f7da8a f89917b5 505094db d82412d9 35b665eb 
+   bad253d3 77000000 008c4930 46022100 9cc67ddd aa6f592a 6b2babd4 d6ff954f 
+   25a784cf 4fe4bb13 afb9f49b 08955119 022100a2 d99545b7 94080757 fcf2b563 
+   f2e91287 86332f46 0ec6b90f f085fb28 41a69701 4104b95c 249d84f4 17e3e395 
+   a1274254 28b54067 1cc15881 eb828c17 b722a53f c599e21c a5e56c90 f340988d 
+   3933acc7 6beb832f d64cab07 8ddf3ce7 32923031 d1a8ffff ffff0100 ca9a3b00 
+   00000019 76a914ee 26c56fc1 d942be8d 7a24b2a1 001dd894 69398088 ac000000 
+   00 
+
+File path:  reorgTest/blk_4A.dat
+Block 4A:
+   f9beb4d9
+   d4000000
+   
+   01000000 aae77468 2205667d 4f413a58 47cc8fe8 9795f1d5 645d5b24 1daf3c92 
+   00000000 361c9cde a09637a0 d0c05c3b 4e7a5d91 9edb184a 0a4c7633 d92e2ddd 
+   f04cb854 89b45f49 ffff001d 9e9aa1e8 
+   01
+   
+   01000000 01000000 00000000 00000000 00000000 00000000 00000000 00000000 
+   00000000 00ffffff ff0401b8 f3eaffff ffff0100 f2052a01 00000043 4104678a 
+   fdb0fe55 48271967 f1a67130 b7105cd6 a828e039 09a67962 e0ea1f61 deb649f6 
+   bc3f4cef 38c4f355 04e51ec1 12de5c38 4df7ba0b 8d578a4c 702b6bf1 1d5fac00 
+   000000 
+
+File path:  reorgTest/blk_5A.dat
+Block 5A:
+   f9beb4d9
+   73010000
+   
+   01000000 ebc7d0de 9c31a71b 7f41d275 2c080ba4 11e1854b d45cb2cf 8c1e4624 
+   00000000 a607774b 79b8eb50 b52a5a32 c1754281 ec67f626 9561df28 57d1fe6a 
+   ea82c696 e1b65f49 ffff001d 4a263577 
+   02
+   
+   01000000 01000000 00000000 00000000 00000000 00000000 00000000 00000000 
+   00000000 00ffffff ff049971 0c7dffff ffff0100 f2052a01 00000043 4104678a 
+   fdb0fe55 48271967 f1a67130 b7105cd6 a828e039 09a67962 e0ea1f61 deb649f6 
+   bc3f4cef 38c4f355 04e51ec1 12de5c38 4df7ba0b 8d578a4c 702b6bf1 1d5fac00 
+   000000 
+   
+   01000000 0163451d 1002611c 1388d5ba 4ddfdf99 196a86b5 990fb5b0 dc786207 
+   4fdcb8ee d2000000 004a4930 46022100 8c8fd57b 48762135 8d8f3e69 19f33e08 
+   804736ff 83db47aa 248512e2 6df9b8ba 022100b0 c59e5ee7 bfcbfcd1 a4d83da9 
+   55fb260e fda7f42a 25522625 a3d6f2d9 1174a701 ffffffff 0100f205 2a010000 
+   001976a9 14c52266 4fb0e55c dc5c0cea 73b4aad9 7ec83432 3288ac00 000000 
+

vendor/github.com/btcsuite/btcd/blockchain/thresholdstate.go

@@ -0,0 +1,356 @@
+// 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 blockchain
+
+import (
+	"fmt"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+)
+
+// ThresholdState define the various threshold states used when voting on
+// consensus changes.
+type ThresholdState byte
+
+// These constants are used to identify specific threshold states.
+const (
+	// ThresholdDefined is the first state for each deployment and is the
+	// state for the genesis block has by definition for all deployments.
+	ThresholdDefined ThresholdState = iota
+
+	// ThresholdStarted is the state for a deployment once its start time
+	// has been reached.
+	ThresholdStarted
+
+	// ThresholdLockedIn is the state for a deployment during the retarget
+	// period which is after the ThresholdStarted state period and the
+	// number of blocks that have voted for the deployment equal or exceed
+	// the required number of votes for the deployment.
+	ThresholdLockedIn
+
+	// ThresholdActive is the state for a deployment for all blocks after a
+	// retarget period in which the deployment was in the ThresholdLockedIn
+	// state.
+	ThresholdActive
+
+	// ThresholdFailed is the state for a deployment once its expiration
+	// time has been reached and it did not reach the ThresholdLockedIn
+	// state.
+	ThresholdFailed
+
+	// numThresholdsStates is the maximum number of threshold states used in
+	// tests.
+	numThresholdsStates
+)
+
+// thresholdStateStrings is a map of ThresholdState values back to their
+// constant names for pretty printing.
+var thresholdStateStrings = map[ThresholdState]string{
+	ThresholdDefined:  "ThresholdDefined",
+	ThresholdStarted:  "ThresholdStarted",
+	ThresholdLockedIn: "ThresholdLockedIn",
+	ThresholdActive:   "ThresholdActive",
+	ThresholdFailed:   "ThresholdFailed",
+}
+
+// String returns the ThresholdState as a human-readable name.
+func (t ThresholdState) String() string {
+	if s := thresholdStateStrings[t]; s != "" {
+		return s
+	}
+	return fmt.Sprintf("Unknown ThresholdState (%d)", int(t))
+}
+
+// thresholdConditionChecker provides a generic interface that is invoked to
+// determine when a consensus rule change threshold should be changed.
+type thresholdConditionChecker interface {
+	// BeginTime returns the unix timestamp for the median block time after
+	// which voting on a rule change starts (at the next window).
+	BeginTime() uint64
+
+	// EndTime returns the unix timestamp for the median block time after
+	// which an attempted rule change fails if it has not already been
+	// locked in or activated.
+	EndTime() uint64
+
+	// RuleChangeActivationThreshold is the number of blocks for which the
+	// condition must be true in order to lock in a rule change.
+	RuleChangeActivationThreshold() uint32
+
+	// MinerConfirmationWindow is the number of blocks in each threshold
+	// state retarget window.
+	MinerConfirmationWindow() uint32
+
+	// Condition returns whether or not the rule change activation condition
+	// has been met.  This typically involves checking whether or not the
+	// bit assocaited with the condition is set, but can be more complex as
+	// needed.
+	Condition(*blockNode) (bool, error)
+}
+
+// thresholdStateCache provides a type to cache the threshold states of each
+// threshold window for a set of IDs.
+type thresholdStateCache struct {
+	entries map[chainhash.Hash]ThresholdState
+}
+
+// Lookup returns the threshold state associated with the given hash along with
+// a boolean that indicates whether or not it is valid.
+func (c *thresholdStateCache) Lookup(hash *chainhash.Hash) (ThresholdState, bool) {
+	state, ok := c.entries[*hash]
+	return state, ok
+}
+
+// Update updates the cache to contain the provided hash to threshold state
+// mapping.
+func (c *thresholdStateCache) Update(hash *chainhash.Hash, state ThresholdState) {
+	c.entries[*hash] = state
+}
+
+// newThresholdCaches returns a new array of caches to be used when calculating
+// threshold states.
+func newThresholdCaches(numCaches uint32) []thresholdStateCache {
+	caches := make([]thresholdStateCache, numCaches)
+	for i := 0; i < len(caches); i++ {
+		caches[i] = thresholdStateCache{
+			entries: make(map[chainhash.Hash]ThresholdState),
+		}
+	}
+	return caches
+}
+
+// thresholdState returns the current rule change threshold state for the block
+// AFTER the given node and deployment ID.  The cache is used to ensure the
+// threshold states for previous windows are only calculated once.
+//
+// This function MUST be called with the chain state lock held (for writes).
+func (b *BlockChain) thresholdState(prevNode *blockNode, checker thresholdConditionChecker, cache *thresholdStateCache) (ThresholdState, error) {
+	// The threshold state for the window that contains the genesis block is
+	// defined by definition.
+	confirmationWindow := int32(checker.MinerConfirmationWindow())
+	if prevNode == nil || (prevNode.height+1) < confirmationWindow {
+		return ThresholdDefined, nil
+	}
+
+	// Get the ancestor that is the last block of the previous confirmation
+	// window in order to get its threshold state.  This can be done because
+	// the state is the same for all blocks within a given window.
+	prevNode = prevNode.Ancestor(prevNode.height -
+		(prevNode.height+1)%confirmationWindow)
+
+	// Iterate backwards through each of the previous confirmation windows
+	// to find the most recently cached threshold state.
+	var neededStates []*blockNode
+	for prevNode != nil {
+		// Nothing more to do if the state of the block is already
+		// cached.
+		if _, ok := cache.Lookup(&prevNode.hash); ok {
+			break
+		}
+
+		// The start and expiration times are based on the median block
+		// time, so calculate it now.
+		medianTime := prevNode.CalcPastMedianTime()
+
+		// The state is simply defined if the start time hasn't been
+		// been reached yet.
+		if uint64(medianTime.Unix()) < checker.BeginTime() {
+			cache.Update(&prevNode.hash, ThresholdDefined)
+			break
+		}
+
+		// Add this node to the list of nodes that need the state
+		// calculated and cached.
+		neededStates = append(neededStates, prevNode)
+
+		// Get the ancestor that is the last block of the previous
+		// confirmation window.
+		prevNode = prevNode.RelativeAncestor(confirmationWindow)
+	}
+
+	// Start with the threshold state for the most recent confirmation
+	// window that has a cached state.
+	state := ThresholdDefined
+	if prevNode != nil {
+		var ok bool
+		state, ok = cache.Lookup(&prevNode.hash)
+		if !ok {
+			return ThresholdFailed, AssertError(fmt.Sprintf(
+				"thresholdState: cache lookup failed for %v",
+				prevNode.hash))
+		}
+	}
+
+	// Since each threshold state depends on the state of the previous
+	// window, iterate starting from the oldest unknown window.
+	for neededNum := len(neededStates) - 1; neededNum >= 0; neededNum-- {
+		prevNode := neededStates[neededNum]
+
+		switch state {
+		case ThresholdDefined:
+			// The deployment of the rule change fails if it expires
+			// before it is accepted and locked in.
+			medianTime := prevNode.CalcPastMedianTime()
+			medianTimeUnix := uint64(medianTime.Unix())
+			if medianTimeUnix >= checker.EndTime() {
+				state = ThresholdFailed
+				break
+			}
+
+			// The state for the rule moves to the started state
+			// once its start time has been reached (and it hasn't
+			// already expired per the above).
+			if medianTimeUnix >= checker.BeginTime() {
+				state = ThresholdStarted
+			}
+
+		case ThresholdStarted:
+			// The deployment of the rule change fails if it expires
+			// before it is accepted and locked in.
+			medianTime := prevNode.CalcPastMedianTime()
+			if uint64(medianTime.Unix()) >= checker.EndTime() {
+				state = ThresholdFailed
+				break
+			}
+
+			// At this point, the rule change is still being voted
+			// on by the miners, so iterate backwards through the
+			// confirmation window to count all of the votes in it.
+			var count uint32
+			countNode := prevNode
+			for i := int32(0); i < confirmationWindow; i++ {
+				condition, err := checker.Condition(countNode)
+				if err != nil {
+					return ThresholdFailed, err
+				}
+				if condition {
+					count++
+				}
+
+				// Get the previous block node.
+				countNode = countNode.parent
+			}
+
+			// The state is locked in if the number of blocks in the
+			// period that voted for the rule change meets the
+			// activation threshold.
+			if count >= checker.RuleChangeActivationThreshold() {
+				state = ThresholdLockedIn
+			}
+
+		case ThresholdLockedIn:
+			// The new rule becomes active when its previous state
+			// was locked in.
+			state = ThresholdActive
+
+		// Nothing to do if the previous state is active or failed since
+		// they are both terminal states.
+		case ThresholdActive:
+		case ThresholdFailed:
+		}
+
+		// Update the cache to avoid recalculating the state in the
+		// future.
+		cache.Update(&prevNode.hash, state)
+	}
+
+	return state, nil
+}
+
+// ThresholdState returns the current rule change threshold state of the given
+// deployment ID for the block AFTER the end of the current best chain.
+//
+// This function is safe for concurrent access.
+func (b *BlockChain) ThresholdState(deploymentID uint32) (ThresholdState, error) {
+	b.chainLock.Lock()
+	state, err := b.deploymentState(b.bestChain.Tip(), deploymentID)
+	b.chainLock.Unlock()
+
+	return state, err
+}
+
+// IsDeploymentActive returns true if the target deploymentID is active, and
+// false otherwise.
+//
+// This function is safe for concurrent access.
+func (b *BlockChain) IsDeploymentActive(deploymentID uint32) (bool, error) {
+	b.chainLock.Lock()
+	state, err := b.deploymentState(b.bestChain.Tip(), deploymentID)
+	b.chainLock.Unlock()
+	if err != nil {
+		return false, err
+	}
+
+	return state == ThresholdActive, nil
+}
+
+// deploymentState returns the current rule change threshold for a given
+// deploymentID. The threshold is evaluated from the point of view of the block
+// node passed in as the first argument to this method.
+//
+// It is important to note that, as the variable name indicates, this function
+// expects the block node prior to the block for which the deployment state is
+// desired.  In other words, the returned deployment state is for the block
+// AFTER the passed node.
+//
+// This function MUST be called with the chain state lock held (for writes).
+func (b *BlockChain) deploymentState(prevNode *blockNode, deploymentID uint32) (ThresholdState, error) {
+	if deploymentID > uint32(len(b.chainParams.Deployments)) {
+		return ThresholdFailed, DeploymentError(deploymentID)
+	}
+
+	deployment := &b.chainParams.Deployments[deploymentID]
+	checker := deploymentChecker{deployment: deployment, chain: b}
+	cache := &b.deploymentCaches[deploymentID]
+
+	return b.thresholdState(prevNode, checker, cache)
+}
+
+// initThresholdCaches initializes the threshold state caches for each warning
+// bit and defined deployment and provides warnings if the chain is current per
+// the warnUnknownVersions and warnUnknownRuleActivations functions.
+func (b *BlockChain) initThresholdCaches() error {
+	// Initialize the warning and deployment caches by calculating the
+	// threshold state for each of them.  This will ensure the caches are
+	// populated and any states that needed to be recalculated due to
+	// definition changes is done now.
+	prevNode := b.bestChain.Tip().parent
+	for bit := uint32(0); bit < vbNumBits; bit++ {
+		checker := bitConditionChecker{bit: bit, chain: b}
+		cache := &b.warningCaches[bit]
+		_, err := b.thresholdState(prevNode, checker, cache)
+		if err != nil {
+			return err
+		}
+	}
+	for id := 0; id < len(b.chainParams.Deployments); id++ {
+		deployment := &b.chainParams.Deployments[id]
+		cache := &b.deploymentCaches[id]
+		checker := deploymentChecker{deployment: deployment, chain: b}
+		_, err := b.thresholdState(prevNode, checker, cache)
+		if err != nil {
+			return err
+		}
+	}
+
+	// No warnings about unknown rules or versions until the chain is
+	// current.
+	if b.isCurrent() {
+		// Warn if a high enough percentage of the last blocks have
+		// unexpected versions.
+		bestNode := b.bestChain.Tip()
+		if err := b.warnUnknownVersions(bestNode); err != nil {
+			return err
+		}
+
+		// Warn if any unknown new rules are either about to activate or
+		// have already been activated.
+		if err := b.warnUnknownRuleActivations(bestNode); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

vendor/github.com/btcsuite/btcd/blockchain/thresholdstate_test.go

@@ -0,0 +1,134 @@
+// 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 blockchain
+
+import (
+	"testing"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+)
+
+// TestThresholdStateStringer tests the stringized output for the
+// ThresholdState type.
+func TestThresholdStateStringer(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		in   ThresholdState
+		want string
+	}{
+		{ThresholdDefined, "ThresholdDefined"},
+		{ThresholdStarted, "ThresholdStarted"},
+		{ThresholdLockedIn, "ThresholdLockedIn"},
+		{ThresholdActive, "ThresholdActive"},
+		{ThresholdFailed, "ThresholdFailed"},
+		{0xff, "Unknown ThresholdState (255)"},
+	}
+
+	// Detect additional threshold states that don't have the stringer added.
+	if len(tests)-1 != int(numThresholdsStates) {
+		t.Errorf("It appears a threshold statewas added without " +
+			"adding an associated stringer test")
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		result := test.in.String()
+		if result != test.want {
+			t.Errorf("String #%d\n got: %s want: %s", i, result,
+				test.want)
+			continue
+		}
+	}
+}
+
+// TestThresholdStateCache ensure the threshold state cache works as intended
+// including adding entries, updating existing entries, and flushing.
+func TestThresholdStateCache(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		numEntries int
+		state      ThresholdState
+	}{
+		{name: "2 entries defined", numEntries: 2, state: ThresholdDefined},
+		{name: "7 entries started", numEntries: 7, state: ThresholdStarted},
+		{name: "10 entries active", numEntries: 10, state: ThresholdActive},
+		{name: "5 entries locked in", numEntries: 5, state: ThresholdLockedIn},
+		{name: "3 entries failed", numEntries: 3, state: ThresholdFailed},
+	}
+
+nextTest:
+	for _, test := range tests {
+		cache := &newThresholdCaches(1)[0]
+		for i := 0; i < test.numEntries; i++ {
+			var hash chainhash.Hash
+			hash[0] = uint8(i + 1)
+
+			// Ensure the hash isn't available in the cache already.
+			_, ok := cache.Lookup(&hash)
+			if ok {
+				t.Errorf("Lookup (%s): has entry for hash %v",
+					test.name, hash)
+				continue nextTest
+			}
+
+			// Ensure hash that was added to the cache reports it's
+			// available and the state is the expected value.
+			cache.Update(&hash, test.state)
+			state, ok := cache.Lookup(&hash)
+			if !ok {
+				t.Errorf("Lookup (%s): missing entry for hash "+
+					"%v", test.name, hash)
+				continue nextTest
+			}
+			if state != test.state {
+				t.Errorf("Lookup (%s): state mismatch - got "+
+					"%v, want %v", test.name, state,
+					test.state)
+				continue nextTest
+			}
+
+			// Ensure adding an existing hash with the same state
+			// doesn't break the existing entry.
+			cache.Update(&hash, test.state)
+			state, ok = cache.Lookup(&hash)
+			if !ok {
+				t.Errorf("Lookup (%s): missing entry after "+
+					"second add for hash %v", test.name,
+					hash)
+				continue nextTest
+			}
+			if state != test.state {
+				t.Errorf("Lookup (%s): state mismatch after "+
+					"second add - got %v, want %v",
+					test.name, state, test.state)
+				continue nextTest
+			}
+
+			// Ensure adding an existing hash with a different state
+			// updates the existing entry.
+			newState := ThresholdFailed
+			if newState == test.state {
+				newState = ThresholdStarted
+			}
+			cache.Update(&hash, newState)
+			state, ok = cache.Lookup(&hash)
+			if !ok {
+				t.Errorf("Lookup (%s): missing entry after "+
+					"state change for hash %v", test.name,
+					hash)
+				continue nextTest
+			}
+			if state != newState {
+				t.Errorf("Lookup (%s): state mismatch after "+
+					"state change - got %v, want %v",
+					test.name, state, newState)
+				continue nextTest
+			}
+		}
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/timesorter.go

@@ -0,0 +1,27 @@
+// 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 blockchain
+
+// timeSorter implements sort.Interface to allow a slice of timestamps to
+// be sorted.
+type timeSorter []int64
+
+// Len returns the number of timestamps in the slice.  It is part of the
+// sort.Interface implementation.
+func (s timeSorter) Len() int {
+	return len(s)
+}
+
+// Swap swaps the timestamps at the passed indices.  It is part of the
+// sort.Interface implementation.
+func (s timeSorter) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+// Less returns whether the timstamp with index i should sort before the
+// timestamp with index j.  It is part of the sort.Interface implementation.
+func (s timeSorter) Less(i, j int) bool {
+	return s[i] < s[j]
+}

vendor/github.com/btcsuite/btcd/blockchain/timesorter_test.go

@@ -0,0 +1,47 @@
+// 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 blockchain
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+)
+
+// TestTimeSorter tests the timeSorter implementation.
+func TestTimeSorter(t *testing.T) {
+	tests := []struct {
+		in   []int64
+		want []int64
+	}{
+		{
+			in: []int64{
+				1351228575, // Fri Oct 26 05:16:15 UTC 2012 (Block #205000)
+				1348310759, // Sat Sep 22 10:45:59 UTC 2012 (Block #200000)
+				1305758502, // Wed May 18 22:41:42 UTC 2011 (Block #125000)
+				1347777156, // Sun Sep 16 06:32:36 UTC 2012 (Block #199000)
+				1349492104, // Sat Oct  6 02:55:04 UTC 2012 (Block #202000)
+			},
+			want: []int64{
+				1305758502, // Wed May 18 22:41:42 UTC 2011 (Block #125000)
+				1347777156, // Sun Sep 16 06:32:36 UTC 2012 (Block #199000)
+				1348310759, // Sat Sep 22 10:45:59 UTC 2012 (Block #200000)
+				1349492104, // Sat Oct  6 02:55:04 UTC 2012 (Block #202000)
+				1351228575, // Fri Oct 26 05:16:15 UTC 2012 (Block #205000)
+			},
+		},
+	}
+
+	for i, test := range tests {
+		result := make([]int64, len(test.in))
+		copy(result, test.in)
+		sort.Sort(timeSorter(result))
+		if !reflect.DeepEqual(result, test.want) {
+			t.Errorf("timeSorter #%d got %v want %v", i, result,
+				test.want)
+			continue
+		}
+	}
+}

vendor/github.com/btcsuite/btcd/blockchain/utxoviewpoint.go

@@ -0,0 +1,632 @@
+// Copyright (c) 2015-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package blockchain
+
+import (
+	"fmt"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/database"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcutil"
+)
+
+// utxoOutput houses details about an individual unspent transaction output such
+// as whether or not it is spent, its public key script, and how much it pays.
+//
+// Standard public key scripts are stored in the database using a compressed
+// format. Since the vast majority of scripts are of the standard form, a fairly
+// significant savings is achieved by discarding the portions of the standard
+// scripts that can be reconstructed.
+//
+// Also, since it is common for only a specific output in a given utxo entry to
+// be referenced from a redeeming transaction, the script and amount for a given
+// output is not uncompressed until the first time it is accessed.  This
+// provides a mechanism to avoid the overhead of needlessly uncompressing all
+// outputs for a given utxo entry at the time of load.
+type utxoOutput struct {
+	spent      bool   // Output is spent.
+	compressed bool   // The amount and public key script are compressed.
+	amount     int64  // The amount of the output.
+	pkScript   []byte // The public key script for the output.
+}
+
+// maybeDecompress decompresses the amount and public key script fields of the
+// utxo and marks it decompressed if needed.
+func (o *utxoOutput) maybeDecompress(version int32) {
+	// Nothing to do if it's not compressed.
+	if !o.compressed {
+		return
+	}
+
+	o.amount = int64(decompressTxOutAmount(uint64(o.amount)))
+	o.pkScript = decompressScript(o.pkScript, version)
+	o.compressed = false
+}
+
+// UtxoEntry contains contextual information about an unspent transaction such
+// as whether or not it is a coinbase transaction, which block it was found in,
+// and the spent status of its outputs.
+type UtxoEntry struct {
+	modified      bool                   // Entry changed since load.
+	version       int32                  // The version of this tx.
+	isCoinBase    bool                   // Whether entry is a coinbase tx.
+	blockHeight   int32                  // Height of block containing tx.
+	sparseOutputs map[uint32]*utxoOutput // Sparse map of unspent outputs.
+}
+
+// Version returns the version of the transaction the utxo represents.
+func (entry *UtxoEntry) Version() int32 {
+	return entry.version
+}
+
+// IsCoinBase returns whether or not the transaction the utxo entry represents
+// is a coinbase.
+func (entry *UtxoEntry) IsCoinBase() bool {
+	return entry.isCoinBase
+}
+
+// BlockHeight returns the height of the block containing the transaction the
+// utxo entry represents.
+func (entry *UtxoEntry) BlockHeight() int32 {
+	return entry.blockHeight
+}
+
+// IsOutputSpent returns whether or not the provided output index has been
+// spent based upon the current state of the unspent transaction output view
+// the entry was obtained from.
+//
+// Returns true if the output index references an output that does not exist
+// either due to it being invalid or because the output is not part of the view
+// due to previously being spent/pruned.
+func (entry *UtxoEntry) IsOutputSpent(outputIndex uint32) bool {
+	output, ok := entry.sparseOutputs[outputIndex]
+	if !ok {
+		return true
+	}
+
+	return output.spent
+}
+
+// SpendOutput marks the output at the provided index as spent.  Specifying an
+// output index that does not exist will not have any effect.
+func (entry *UtxoEntry) SpendOutput(outputIndex uint32) {
+	output, ok := entry.sparseOutputs[outputIndex]
+	if !ok {
+		return
+	}
+
+	// Nothing to do if the output is already spent.
+	if output.spent {
+		return
+	}
+
+	entry.modified = true
+	output.spent = true
+}
+
+// IsFullySpent returns whether or not the transaction the utxo entry represents
+// is fully spent.
+func (entry *UtxoEntry) IsFullySpent() bool {
+	// The entry is not fully spent if any of the outputs are unspent.
+	for _, output := range entry.sparseOutputs {
+		if !output.spent {
+			return false
+		}
+	}
+
+	return true
+}
+
+// AmountByIndex returns the amount of the provided output index.
+//
+// Returns 0 if the output index references an output that does not exist
+// either due to it being invalid or because the output is not part of the view
+// due to previously being spent/pruned.
+func (entry *UtxoEntry) AmountByIndex(outputIndex uint32) int64 {
+	output, ok := entry.sparseOutputs[outputIndex]
+	if !ok {
+		return 0
+	}
+
+	// Ensure the output is decompressed before returning the amount.
+	output.maybeDecompress(entry.version)
+	return output.amount
+}
+
+// PkScriptByIndex returns the public key script for the provided output index.
+//
+// Returns nil if the output index references an output that does not exist
+// either due to it being invalid or because the output is not part of the view
+// due to previously being spent/pruned.
+func (entry *UtxoEntry) PkScriptByIndex(outputIndex uint32) []byte {
+	output, ok := entry.sparseOutputs[outputIndex]
+	if !ok {
+		return nil
+	}
+
+	// Ensure the output is decompressed before returning the script.
+	output.maybeDecompress(entry.version)
+	return output.pkScript
+}
+
+// Clone returns a deep copy of the utxo entry.
+func (entry *UtxoEntry) Clone() *UtxoEntry {
+	if entry == nil {
+		return nil
+	}
+
+	newEntry := &UtxoEntry{
+		version:       entry.version,
+		isCoinBase:    entry.isCoinBase,
+		blockHeight:   entry.blockHeight,
+		sparseOutputs: make(map[uint32]*utxoOutput),
+	}
+	for outputIndex, output := range entry.sparseOutputs {
+		newEntry.sparseOutputs[outputIndex] = &utxoOutput{
+			spent:      output.spent,
+			compressed: output.compressed,
+			amount:     output.amount,
+			pkScript:   output.pkScript,
+		}
+	}
+	return newEntry
+}
+
+// newUtxoEntry returns a new unspent transaction output entry with the provided
+// coinbase flag and block height ready to have unspent outputs added.
+func newUtxoEntry(version int32, isCoinBase bool, blockHeight int32) *UtxoEntry {
+	return &UtxoEntry{
+		version:       version,
+		isCoinBase:    isCoinBase,
+		blockHeight:   blockHeight,
+		sparseOutputs: make(map[uint32]*utxoOutput),
+	}
+}
+
+// UtxoViewpoint represents a view into the set of unspent transaction outputs
+// from a specific point of view in the chain.  For example, it could be for
+// the end of the main chain, some point in the history of the main chain, or
+// down a side chain.
+//
+// The unspent outputs are needed by other transactions for things such as
+// script validation and double spend prevention.
+type UtxoViewpoint struct {
+	entries  map[chainhash.Hash]*UtxoEntry
+	bestHash chainhash.Hash
+}
+
+// BestHash returns the hash of the best block in the chain the view currently
+// respresents.
+func (view *UtxoViewpoint) BestHash() *chainhash.Hash {
+	return &view.bestHash
+}
+
+// SetBestHash sets the hash of the best block in the chain the view currently
+// respresents.
+func (view *UtxoViewpoint) SetBestHash(hash *chainhash.Hash) {
+	view.bestHash = *hash
+}
+
+// LookupEntry returns information about a given transaction according to the
+// current state of the view.  It will return nil if the passed transaction
+// hash does not exist in the view or is otherwise not available such as when
+// it has been disconnected during a reorg.
+func (view *UtxoViewpoint) LookupEntry(txHash *chainhash.Hash) *UtxoEntry {
+	entry, ok := view.entries[*txHash]
+	if !ok {
+		return nil
+	}
+
+	return entry
+}
+
+// AddTxOuts adds all outputs in the passed transaction which are not provably
+// unspendable to the view.  When the view already has entries for any of the
+// outputs, they are simply marked unspent.  All fields will be updated for
+// existing entries since it's possible it has changed during a reorg.
+func (view *UtxoViewpoint) AddTxOuts(tx *btcutil.Tx, blockHeight int32) {
+	// When there are not already any utxos associated with the transaction,
+	// add a new entry for it to the view.
+	entry := view.LookupEntry(tx.Hash())
+	if entry == nil {
+		entry = newUtxoEntry(tx.MsgTx().Version, IsCoinBase(tx),
+			blockHeight)
+		view.entries[*tx.Hash()] = entry
+	} else {
+		entry.blockHeight = blockHeight
+	}
+	entry.modified = true
+
+	// Loop all of the transaction outputs and add those which are not
+	// provably unspendable.
+	for txOutIdx, txOut := range tx.MsgTx().TxOut {
+		if txscript.IsUnspendable(txOut.PkScript) {
+			continue
+		}
+
+		// Update existing entries.  All fields are updated because it's
+		// possible (although extremely unlikely) that the existing
+		// entry is being replaced by a different transaction with the
+		// same hash.  This is allowed so long as the previous
+		// transaction is fully spent.
+		if output, ok := entry.sparseOutputs[uint32(txOutIdx)]; ok {
+			output.spent = false
+			output.compressed = false
+			output.amount = txOut.Value
+			output.pkScript = txOut.PkScript
+			continue
+		}
+
+		// Add the unspent transaction output.
+		entry.sparseOutputs[uint32(txOutIdx)] = &utxoOutput{
+			spent:      false,
+			compressed: false,
+			amount:     txOut.Value,
+			pkScript:   txOut.PkScript,
+		}
+	}
+}
+
+// connectTransaction updates the view by adding all new utxos created by the
+// passed transaction and marking all utxos that the transactions spend as
+// spent.  In addition, when the 'stxos' argument is not nil, it will be updated
+// to append an entry for each spent txout.  An error will be returned if the
+// view does not contain the required utxos.
+func (view *UtxoViewpoint) connectTransaction(tx *btcutil.Tx, blockHeight int32, stxos *[]spentTxOut) error {
+	// Coinbase transactions don't have any inputs to spend.
+	if IsCoinBase(tx) {
+		// Add the transaction's outputs as available utxos.
+		view.AddTxOuts(tx, blockHeight)
+		return nil
+	}
+
+	// Spend the referenced utxos by marking them spent in the view and,
+	// if a slice was provided for the spent txout details, append an entry
+	// to it.
+	for _, txIn := range tx.MsgTx().TxIn {
+		originIndex := txIn.PreviousOutPoint.Index
+		entry := view.entries[txIn.PreviousOutPoint.Hash]
+
+		// Ensure the referenced utxo exists in the view.  This should
+		// never happen unless there is a bug is introduced in the code.
+		if entry == nil {
+			return AssertError(fmt.Sprintf("view missing input %v",
+				txIn.PreviousOutPoint))
+		}
+		entry.SpendOutput(originIndex)
+
+		// Don't create the stxo details if not requested.
+		if stxos == nil {
+			continue
+		}
+
+		// Populate the stxo details using the utxo entry.  When the
+		// transaction is fully spent, set the additional stxo fields
+		// accordingly since those details will no longer be available
+		// in the utxo set.
+		var stxo = spentTxOut{
+			compressed: false,
+			version:    entry.Version(),
+			amount:     entry.AmountByIndex(originIndex),
+			pkScript:   entry.PkScriptByIndex(originIndex),
+		}
+		if entry.IsFullySpent() {
+			stxo.height = entry.BlockHeight()
+			stxo.isCoinBase = entry.IsCoinBase()
+		}
+
+		// Append the entry to the provided spent txouts slice.
+		*stxos = append(*stxos, stxo)
+	}
+
+	// Add the transaction's outputs as available utxos.
+	view.AddTxOuts(tx, blockHeight)
+	return nil
+}
+
+// connectTransactions updates the view by adding all new utxos created by all
+// of the transactions in the passed block, marking all utxos the transactions
+// spend as spent, and setting the best hash for the view to the passed block.
+// In addition, when the 'stxos' argument is not nil, it will be updated to
+// append an entry for each spent txout.
+func (view *UtxoViewpoint) connectTransactions(block *btcutil.Block, stxos *[]spentTxOut) error {
+	for _, tx := range block.Transactions() {
+		err := view.connectTransaction(tx, block.Height(), stxos)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Update the best hash for view to include this block since all of its
+	// transactions have been connected.
+	view.SetBestHash(block.Hash())
+	return nil
+}
+
+// disconnectTransactions updates the view by removing all of the transactions
+// created by the passed block, restoring all utxos the transactions spent by
+// using the provided spent txo information, and setting the best hash for the
+// view to the block before the passed block.
+func (view *UtxoViewpoint) disconnectTransactions(block *btcutil.Block, stxos []spentTxOut) error {
+	// Sanity check the correct number of stxos are provided.
+	if len(stxos) != countSpentOutputs(block) {
+		return AssertError("disconnectTransactions called with bad " +
+			"spent transaction out information")
+	}
+
+	// Loop backwards through all transactions so everything is unspent in
+	// reverse order.  This is necessary since transactions later in a block
+	// can spend from previous ones.
+	stxoIdx := len(stxos) - 1
+	transactions := block.Transactions()
+	for txIdx := len(transactions) - 1; txIdx > -1; txIdx-- {
+		tx := transactions[txIdx]
+
+		// Clear this transaction from the view if it already exists or
+		// create a new empty entry for when it does not.  This is done
+		// because the code relies on its existence in the view in order
+		// to signal modifications have happened.
+		isCoinbase := txIdx == 0
+		entry := view.entries[*tx.Hash()]
+		if entry == nil {
+			entry = newUtxoEntry(tx.MsgTx().Version, isCoinbase,
+				block.Height())
+			view.entries[*tx.Hash()] = entry
+		}
+		entry.modified = true
+		entry.sparseOutputs = make(map[uint32]*utxoOutput)
+
+		// Loop backwards through all of the transaction inputs (except
+		// for the coinbase which has no inputs) and unspend the
+		// referenced txos.  This is necessary to match the order of the
+		// spent txout entries.
+		if isCoinbase {
+			continue
+		}
+		for txInIdx := len(tx.MsgTx().TxIn) - 1; txInIdx > -1; txInIdx-- {
+			// Ensure the spent txout index is decremented to stay
+			// in sync with the transaction input.
+			stxo := &stxos[stxoIdx]
+			stxoIdx--
+
+			// When there is not already an entry for the referenced
+			// transaction in the view, it means it was fully spent,
+			// so create a new utxo entry in order to resurrect it.
+			txIn := tx.MsgTx().TxIn[txInIdx]
+			originHash := &txIn.PreviousOutPoint.Hash
+			originIndex := txIn.PreviousOutPoint.Index
+			entry := view.entries[*originHash]
+			if entry == nil {
+				entry = newUtxoEntry(stxo.version,
+					stxo.isCoinBase, stxo.height)
+				view.entries[*originHash] = entry
+			}
+
+			// Mark the entry as modified since it is either new
+			// or will be changed below.
+			entry.modified = true
+
+			// Restore the specific utxo using the stxo data from
+			// the spend journal if it doesn't already exist in the
+			// view.
+			output, ok := entry.sparseOutputs[originIndex]
+			if !ok {
+				// Add the unspent transaction output.
+				entry.sparseOutputs[originIndex] = &utxoOutput{
+					spent:      false,
+					compressed: stxo.compressed,
+					amount:     stxo.amount,
+					pkScript:   stxo.pkScript,
+				}
+				continue
+			}
+
+			// Mark the existing referenced transaction output as
+			// unspent.
+			output.spent = false
+		}
+	}
+
+	// Update the best hash for view to the previous block since all of the
+	// transactions for the current block have been disconnected.
+	view.SetBestHash(&block.MsgBlock().Header.PrevBlock)
+	return nil
+}
+
+// Entries returns the underlying map that stores of all the utxo entries.
+func (view *UtxoViewpoint) Entries() map[chainhash.Hash]*UtxoEntry {
+	return view.entries
+}
+
+// commit prunes all entries marked modified that are now fully spent and marks
+// all entries as unmodified.
+func (view *UtxoViewpoint) commit() {
+	for txHash, entry := range view.entries {
+		if entry == nil || (entry.modified && entry.IsFullySpent()) {
+			delete(view.entries, txHash)
+			continue
+		}
+
+		entry.modified = false
+	}
+}
+
+// fetchUtxosMain fetches unspent transaction output data about the provided
+// set of transactions from the point of view of the end of the main chain at
+// the time of the call.
+//
+// Upon completion of this function, the view will contain an entry for each
+// requested transaction.  Fully spent transactions, or those which otherwise
+// don't exist, will result in a nil entry in the view.
+func (view *UtxoViewpoint) fetchUtxosMain(db database.DB, txSet map[chainhash.Hash]struct{}) error {
+	// Nothing to do if there are no requested hashes.
+	if len(txSet) == 0 {
+		return nil
+	}
+
+	// Load the unspent transaction output information for the requested set
+	// of transactions from the point of view of the end of the main chain.
+	//
+	// NOTE: Missing entries are not considered an error here and instead
+	// will result in nil entries in the view.  This is intentionally done
+	// since other code uses the presence of an entry in the store as a way
+	// to optimize spend and unspend updates to apply only to the specific
+	// utxos that the caller needs access to.
+	return db.View(func(dbTx database.Tx) error {
+		for hash := range txSet {
+			hashCopy := hash
+			entry, err := dbFetchUtxoEntry(dbTx, &hashCopy)
+			if err != nil {
+				return err
+			}
+
+			view.entries[hash] = entry
+		}
+
+		return nil
+	})
+}
+
+// fetchUtxos loads utxo details about provided set of transaction hashes into
+// the view from the database as needed unless they already exist in the view in
+// which case they are ignored.
+func (view *UtxoViewpoint) fetchUtxos(db database.DB, txSet map[chainhash.Hash]struct{}) error {
+	// Nothing to do if there are no requested hashes.
+	if len(txSet) == 0 {
+		return nil
+	}
+
+	// Filter entries that are already in the view.
+	txNeededSet := make(map[chainhash.Hash]struct{})
+	for hash := range txSet {
+		// Already loaded into the current view.
+		if _, ok := view.entries[hash]; ok {
+			continue
+		}
+
+		txNeededSet[hash] = struct{}{}
+	}
+
+	// Request the input utxos from the database.
+	return view.fetchUtxosMain(db, txNeededSet)
+}
+
+// fetchInputUtxos loads utxo details about the input transactions referenced
+// by the transactions in the given block into the view from the database as
+// needed.  In particular, referenced entries that are earlier in the block are
+// added to the view and entries that are already in the view are not modified.
+func (view *UtxoViewpoint) fetchInputUtxos(db database.DB, block *btcutil.Block) error {
+	// Build a map of in-flight transactions because some of the inputs in
+	// this block could be referencing other transactions earlier in this
+	// block which are not yet in the chain.
+	txInFlight := map[chainhash.Hash]int{}
+	transactions := block.Transactions()
+	for i, tx := range transactions {
+		txInFlight[*tx.Hash()] = i
+	}
+
+	// Loop through all of the transaction inputs (except for the coinbase
+	// which has no inputs) collecting them into sets of what is needed and
+	// what is already known (in-flight).
+	txNeededSet := make(map[chainhash.Hash]struct{})
+	for i, tx := range transactions[1:] {
+		for _, txIn := range tx.MsgTx().TxIn {
+			// It is acceptable for a transaction input to reference
+			// the output of another transaction in this block only
+			// if the referenced transaction comes before the
+			// current one in this block.  Add the outputs of the
+			// referenced transaction as available utxos when this
+			// is the case.  Otherwise, the utxo details are still
+			// needed.
+			//
+			// NOTE: The >= is correct here because i is one less
+			// than the actual position of the transaction within
+			// the block due to skipping the coinbase.
+			originHash := &txIn.PreviousOutPoint.Hash
+			if inFlightIndex, ok := txInFlight[*originHash]; ok &&
+				i >= inFlightIndex {
+
+				originTx := transactions[inFlightIndex]
+				view.AddTxOuts(originTx, block.Height())
+				continue
+			}
+
+			// Don't request entries that are already in the view
+			// from the database.
+			if _, ok := view.entries[*originHash]; ok {
+				continue
+			}
+
+			txNeededSet[*originHash] = struct{}{}
+		}
+	}
+
+	// Request the input utxos from the database.
+	return view.fetchUtxosMain(db, txNeededSet)
+}
+
+// NewUtxoViewpoint returns a new empty unspent transaction output view.
+func NewUtxoViewpoint() *UtxoViewpoint {
+	return &UtxoViewpoint{
+		entries: make(map[chainhash.Hash]*UtxoEntry),
+	}
+}
+
+// FetchUtxoView loads utxo details about the input transactions referenced by
+// the passed transaction from the point of view of the end of the main chain.
+// It also attempts to fetch the utxo details for the transaction itself so the
+// returned view can be examined for duplicate unspent transaction outputs.
+//
+// This function is safe for concurrent access however the returned view is NOT.
+func (b *BlockChain) FetchUtxoView(tx *btcutil.Tx) (*UtxoViewpoint, error) {
+	b.chainLock.RLock()
+	defer b.chainLock.RUnlock()
+
+	// Create a set of needed transactions based on those referenced by the
+	// inputs of the passed transaction.  Also, add the passed transaction
+	// itself as a way for the caller to detect duplicates that are not
+	// fully spent.
+	txNeededSet := make(map[chainhash.Hash]struct{})
+	txNeededSet[*tx.Hash()] = struct{}{}
+	if !IsCoinBase(tx) {
+		for _, txIn := range tx.MsgTx().TxIn {
+			txNeededSet[txIn.PreviousOutPoint.Hash] = struct{}{}
+		}
+	}
+
+	// Request the utxos from the point of view of the end of the main
+	// chain.
+	view := NewUtxoViewpoint()
+	err := view.fetchUtxosMain(b.db, txNeededSet)
+	return view, err
+}
+
+// FetchUtxoEntry loads and returns the unspent transaction output entry for the
+// passed hash from the point of view of the end of the main chain.
+//
+// NOTE: Requesting a hash for which there is no data will NOT return an error.
+// Instead both the entry and the error will be nil.  This is done to allow
+// pruning of fully spent transactions.  In practice this means the caller must
+// check if the returned entry is nil before invoking methods on it.
+//
+// This function is safe for concurrent access however the returned entry (if
+// any) is NOT.
+func (b *BlockChain) FetchUtxoEntry(txHash *chainhash.Hash) (*UtxoEntry, error) {
+	b.chainLock.RLock()
+	defer b.chainLock.RUnlock()
+
+	var entry *UtxoEntry
+	err := b.db.View(func(dbTx database.Tx) error {
+		var err error
+		entry, err = dbFetchUtxoEntry(dbTx, txHash)
+		return err
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return entry, nil
+}

vendor/github.com/btcsuite/btcd/blockchain/validate_test.go

@@ -0,0 +1,487 @@
+// 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 blockchain
+
+import (
+	"math"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+)
+
+// TestSequenceLocksActive tests the SequenceLockActive function to ensure it
+// works as expected in all possible combinations/scenarios.
+func TestSequenceLocksActive(t *testing.T) {
+	seqLock := func(h int32, s int64) *SequenceLock {
+		return &SequenceLock{
+			Seconds:     s,
+			BlockHeight: h,
+		}
+	}
+
+	tests := []struct {
+		seqLock     *SequenceLock
+		blockHeight int32
+		mtp         time.Time
+
+		want bool
+	}{
+		// Block based sequence lock with equal block height.
+		{seqLock: seqLock(1000, -1), blockHeight: 1001, mtp: time.Unix(9, 0), want: true},
+
+		// Time based sequence lock with mtp past the absolute time.
+		{seqLock: seqLock(-1, 30), blockHeight: 2, mtp: time.Unix(31, 0), want: true},
+
+		// Block based sequence lock with current height below seq lock block height.
+		{seqLock: seqLock(1000, -1), blockHeight: 90, mtp: time.Unix(9, 0), want: false},
+
+		// Time based sequence lock with current time before lock time.
+		{seqLock: seqLock(-1, 30), blockHeight: 2, mtp: time.Unix(29, 0), want: false},
+
+		// Block based sequence lock at the same height, so shouldn't yet be active.
+		{seqLock: seqLock(1000, -1), blockHeight: 1000, mtp: time.Unix(9, 0), want: false},
+
+		// Time based sequence lock with current time equal to lock time, so shouldn't yet be active.
+		{seqLock: seqLock(-1, 30), blockHeight: 2, mtp: time.Unix(30, 0), want: false},
+	}
+
+	t.Logf("Running %d sequence locks tests", len(tests))
+	for i, test := range tests {
+		got := SequenceLockActive(test.seqLock,
+			test.blockHeight, test.mtp)
+		if got != test.want {
+			t.Fatalf("SequenceLockActive #%d got %v want %v", i,
+				got, test.want)
+		}
+	}
+}
+
+// TestCheckConnectBlockTemplate tests the CheckConnectBlockTemplate function to
+// ensure it fails.
+func TestCheckConnectBlockTemplate(t *testing.T) {
+	// Create a new database and chain instance to run tests against.
+	chain, teardownFunc, err := chainSetup("checkconnectblocktemplate",
+		&chaincfg.MainNetParams)
+	if err != nil {
+		t.Errorf("Failed to setup chain instance: %v", err)
+		return
+	}
+	defer teardownFunc()
+
+	// Since we're not dealing with the real block chain, set the coinbase
+	// maturity to 1.
+	chain.TstSetCoinbaseMaturity(1)
+
+	// Load up blocks such that there is a side chain.
+	// (genesis block) -> 1 -> 2 -> 3 -> 4
+	//                          \-> 3a
+	testFiles := []string{
+		"blk_0_to_4.dat.bz2",
+		"blk_3A.dat.bz2",
+	}
+
+	var blocks []*btcutil.Block
+	for _, file := range testFiles {
+		blockTmp, err := loadBlocks(file)
+		if err != nil {
+			t.Fatalf("Error loading file: %v\n", err)
+		}
+		blocks = append(blocks, blockTmp...)
+	}
+
+	for i := 1; i <= 3; i++ {
+		isMainChain, _, err := chain.ProcessBlock(blocks[i], BFNone)
+		if err != nil {
+			t.Fatalf("CheckConnectBlockTemplate: Received unexpected error "+
+				"processing block %d: %v", i, err)
+		}
+		if !isMainChain {
+			t.Fatalf("CheckConnectBlockTemplate: Expected block %d to connect "+
+				"to main chain", i)
+		}
+	}
+
+	// Block 3 should fail to connect since it's already inserted.
+	err = chain.CheckConnectBlockTemplate(blocks[3])
+	if err == nil {
+		t.Fatal("CheckConnectBlockTemplate: Did not received expected error " +
+			"on block 3")
+	}
+
+	// Block 4 should connect successfully to tip of chain.
+	err = chain.CheckConnectBlockTemplate(blocks[4])
+	if err != nil {
+		t.Fatalf("CheckConnectBlockTemplate: Received unexpected error on "+
+			"block 4: %v", err)
+	}
+
+	// Block 3a should fail to connect since does not build on chain tip.
+	err = chain.CheckConnectBlockTemplate(blocks[5])
+	if err == nil {
+		t.Fatal("CheckConnectBlockTemplate: Did not received expected error " +
+			"on block 3a")
+	}
+
+	// Block 4 should connect even if proof of work is invalid.
+	invalidPowBlock := *blocks[4].MsgBlock()
+	invalidPowBlock.Header.Nonce++
+	err = chain.CheckConnectBlockTemplate(btcutil.NewBlock(&invalidPowBlock))
+	if err != nil {
+		t.Fatalf("CheckConnectBlockTemplate: Received unexpected error on "+
+			"block 4 with bad nonce: %v", err)
+	}
+
+	// Invalid block building on chain tip should fail to connect.
+	invalidBlock := *blocks[4].MsgBlock()
+	invalidBlock.Header.Bits--
+	err = chain.CheckConnectBlockTemplate(btcutil.NewBlock(&invalidBlock))
+	if err == nil {
+		t.Fatal("CheckConnectBlockTemplate: Did not received expected error " +
+			"on block 4 with invalid difficulty bits")
+	}
+}
+
+// TestCheckBlockSanity tests the CheckBlockSanity function to ensure it works
+// as expected.
+func TestCheckBlockSanity(t *testing.T) {
+	powLimit := chaincfg.MainNetParams.PowLimit
+	block := btcutil.NewBlock(&Block100000)
+	timeSource := NewMedianTime()
+	err := CheckBlockSanity(block, powLimit, timeSource)
+	if err != nil {
+		t.Errorf("CheckBlockSanity: %v", err)
+	}
+
+	// Ensure a block that has a timestamp with a precision higher than one
+	// second fails.
+	timestamp := block.MsgBlock().Header.Timestamp
+	block.MsgBlock().Header.Timestamp = timestamp.Add(time.Nanosecond)
+	err = CheckBlockSanity(block, powLimit, timeSource)
+	if err == nil {
+		t.Errorf("CheckBlockSanity: error is nil when it shouldn't be")
+	}
+}
+
+// TestCheckSerializedHeight tests the checkSerializedHeight function with
+// various serialized heights and also does negative tests to ensure errors
+// and handled properly.
+func TestCheckSerializedHeight(t *testing.T) {
+	// Create an empty coinbase template to be used in the tests below.
+	coinbaseOutpoint := wire.NewOutPoint(&chainhash.Hash{}, math.MaxUint32)
+	coinbaseTx := wire.NewMsgTx(1)
+	coinbaseTx.AddTxIn(wire.NewTxIn(coinbaseOutpoint, nil, nil))
+
+	// Expected rule errors.
+	missingHeightError := RuleError{
+		ErrorCode: ErrMissingCoinbaseHeight,
+	}
+	badHeightError := RuleError{
+		ErrorCode: ErrBadCoinbaseHeight,
+	}
+
+	tests := []struct {
+		sigScript  []byte // Serialized data
+		wantHeight int32  // Expected height
+		err        error  // Expected error type
+	}{
+		// No serialized height length.
+		{[]byte{}, 0, missingHeightError},
+		// Serialized height length with no height bytes.
+		{[]byte{0x02}, 0, missingHeightError},
+		// Serialized height length with too few height bytes.
+		{[]byte{0x02, 0x4a}, 0, missingHeightError},
+		// Serialized height that needs 2 bytes to encode.
+		{[]byte{0x02, 0x4a, 0x52}, 21066, nil},
+		// Serialized height that needs 2 bytes to encode, but backwards
+		// endianness.
+		{[]byte{0x02, 0x4a, 0x52}, 19026, badHeightError},
+		// Serialized height that needs 3 bytes to encode.
+		{[]byte{0x03, 0x40, 0x0d, 0x03}, 200000, nil},
+		// Serialized height that needs 3 bytes to encode, but backwards
+		// endianness.
+		{[]byte{0x03, 0x40, 0x0d, 0x03}, 1074594560, badHeightError},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		msgTx := coinbaseTx.Copy()
+		msgTx.TxIn[0].SignatureScript = test.sigScript
+		tx := btcutil.NewTx(msgTx)
+
+		err := checkSerializedHeight(tx, test.wantHeight)
+		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
+			t.Errorf("checkSerializedHeight #%d wrong error type "+
+				"got: %v <%T>, want: %T", i, err, err, test.err)
+			continue
+		}
+
+		if rerr, ok := err.(RuleError); ok {
+			trerr := test.err.(RuleError)
+			if rerr.ErrorCode != trerr.ErrorCode {
+				t.Errorf("checkSerializedHeight #%d wrong "+
+					"error code got: %v, want: %v", i,
+					rerr.ErrorCode, trerr.ErrorCode)
+				continue
+			}
+		}
+	}
+}
+
+// Block100000 defines block 100,000 of the block chain.  It is used to
+// test Block operations.
+var Block100000 = wire.MsgBlock{
+	Header: wire.BlockHeader{
+		Version: 1,
+		PrevBlock: chainhash.Hash([32]byte{ // Make go vet happy.
+			0x50, 0x12, 0x01, 0x19, 0x17, 0x2a, 0x61, 0x04,
+			0x21, 0xa6, 0xc3, 0x01, 0x1d, 0xd3, 0x30, 0xd9,
+			0xdf, 0x07, 0xb6, 0x36, 0x16, 0xc2, 0xcc, 0x1f,
+			0x1c, 0xd0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+		}), // 000000000002d01c1fccc21636b607dfd930d31d01c3a62104612a1719011250
+		MerkleRoot: chainhash.Hash([32]byte{ // Make go vet happy.
+			0x66, 0x57, 0xa9, 0x25, 0x2a, 0xac, 0xd5, 0xc0,
+			0xb2, 0x94, 0x09, 0x96, 0xec, 0xff, 0x95, 0x22,
+			0x28, 0xc3, 0x06, 0x7c, 0xc3, 0x8d, 0x48, 0x85,
+			0xef, 0xb5, 0xa4, 0xac, 0x42, 0x47, 0xe9, 0xf3,
+		}), // f3e94742aca4b5ef85488dc37c06c3282295ffec960994b2c0d5ac2a25a95766
+		Timestamp: time.Unix(1293623863, 0), // 2010-12-29 11:57:43 +0000 UTC
+		Bits:      0x1b04864c,               // 453281356
+		Nonce:     0x10572b0f,               // 274148111
+	},
+	Transactions: []*wire.MsgTx{
+		{
+			Version: 1,
+			TxIn: []*wire.TxIn{
+				{
+					PreviousOutPoint: wire.OutPoint{
+						Hash:  chainhash.Hash{},
+						Index: 0xffffffff,
+					},
+					SignatureScript: []byte{
+						0x04, 0x4c, 0x86, 0x04, 0x1b, 0x02, 0x06, 0x02,
+					},
+					Sequence: 0xffffffff,
+				},
+			},
+			TxOut: []*wire.TxOut{
+				{
+					Value: 0x12a05f200, // 5000000000
+					PkScript: []byte{
+						0x41, // OP_DATA_65
+						0x04, 0x1b, 0x0e, 0x8c, 0x25, 0x67, 0xc1, 0x25,
+						0x36, 0xaa, 0x13, 0x35, 0x7b, 0x79, 0xa0, 0x73,
+						0xdc, 0x44, 0x44, 0xac, 0xb8, 0x3c, 0x4e, 0xc7,
+						0xa0, 0xe2, 0xf9, 0x9d, 0xd7, 0x45, 0x75, 0x16,
+						0xc5, 0x81, 0x72, 0x42, 0xda, 0x79, 0x69, 0x24,
+						0xca, 0x4e, 0x99, 0x94, 0x7d, 0x08, 0x7f, 0xed,
+						0xf9, 0xce, 0x46, 0x7c, 0xb9, 0xf7, 0xc6, 0x28,
+						0x70, 0x78, 0xf8, 0x01, 0xdf, 0x27, 0x6f, 0xdf,
+						0x84, // 65-byte signature
+						0xac, // OP_CHECKSIG
+					},
+				},
+			},
+			LockTime: 0,
+		},
+		{
+			Version: 1,
+			TxIn: []*wire.TxIn{
+				{
+					PreviousOutPoint: wire.OutPoint{
+						Hash: chainhash.Hash([32]byte{ // Make go vet happy.
+							0x03, 0x2e, 0x38, 0xe9, 0xc0, 0xa8, 0x4c, 0x60,
+							0x46, 0xd6, 0x87, 0xd1, 0x05, 0x56, 0xdc, 0xac,
+							0xc4, 0x1d, 0x27, 0x5e, 0xc5, 0x5f, 0xc0, 0x07,
+							0x79, 0xac, 0x88, 0xfd, 0xf3, 0x57, 0xa1, 0x87,
+						}), // 87a157f3fd88ac7907c05fc55e271dc4acdc5605d187d646604ca8c0e9382e03
+						Index: 0,
+					},
+					SignatureScript: []byte{
+						0x49, // OP_DATA_73
+						0x30, 0x46, 0x02, 0x21, 0x00, 0xc3, 0x52, 0xd3,
+						0xdd, 0x99, 0x3a, 0x98, 0x1b, 0xeb, 0xa4, 0xa6,
+						0x3a, 0xd1, 0x5c, 0x20, 0x92, 0x75, 0xca, 0x94,
+						0x70, 0xab, 0xfc, 0xd5, 0x7d, 0xa9, 0x3b, 0x58,
+						0xe4, 0xeb, 0x5d, 0xce, 0x82, 0x02, 0x21, 0x00,
+						0x84, 0x07, 0x92, 0xbc, 0x1f, 0x45, 0x60, 0x62,
+						0x81, 0x9f, 0x15, 0xd3, 0x3e, 0xe7, 0x05, 0x5c,
+						0xf7, 0xb5, 0xee, 0x1a, 0xf1, 0xeb, 0xcc, 0x60,
+						0x28, 0xd9, 0xcd, 0xb1, 0xc3, 0xaf, 0x77, 0x48,
+						0x01, // 73-byte signature
+						0x41, // OP_DATA_65
+						0x04, 0xf4, 0x6d, 0xb5, 0xe9, 0xd6, 0x1a, 0x9d,
+						0xc2, 0x7b, 0x8d, 0x64, 0xad, 0x23, 0xe7, 0x38,
+						0x3a, 0x4e, 0x6c, 0xa1, 0x64, 0x59, 0x3c, 0x25,
+						0x27, 0xc0, 0x38, 0xc0, 0x85, 0x7e, 0xb6, 0x7e,
+						0xe8, 0xe8, 0x25, 0xdc, 0xa6, 0x50, 0x46, 0xb8,
+						0x2c, 0x93, 0x31, 0x58, 0x6c, 0x82, 0xe0, 0xfd,
+						0x1f, 0x63, 0x3f, 0x25, 0xf8, 0x7c, 0x16, 0x1b,
+						0xc6, 0xf8, 0xa6, 0x30, 0x12, 0x1d, 0xf2, 0xb3,
+						0xd3, // 65-byte pubkey
+					},
+					Sequence: 0xffffffff,
+				},
+			},
+			TxOut: []*wire.TxOut{
+				{
+					Value: 0x2123e300, // 556000000
+					PkScript: []byte{
+						0x76, // OP_DUP
+						0xa9, // OP_HASH160
+						0x14, // OP_DATA_20
+						0xc3, 0x98, 0xef, 0xa9, 0xc3, 0x92, 0xba, 0x60,
+						0x13, 0xc5, 0xe0, 0x4e, 0xe7, 0x29, 0x75, 0x5e,
+						0xf7, 0xf5, 0x8b, 0x32,
+						0x88, // OP_EQUALVERIFY
+						0xac, // OP_CHECKSIG
+					},
+				},
+				{
+					Value: 0x108e20f00, // 4444000000
+					PkScript: []byte{
+						0x76, // OP_DUP
+						0xa9, // OP_HASH160
+						0x14, // OP_DATA_20
+						0x94, 0x8c, 0x76, 0x5a, 0x69, 0x14, 0xd4, 0x3f,
+						0x2a, 0x7a, 0xc1, 0x77, 0xda, 0x2c, 0x2f, 0x6b,
+						0x52, 0xde, 0x3d, 0x7c,
+						0x88, // OP_EQUALVERIFY
+						0xac, // OP_CHECKSIG
+					},
+				},
+			},
+			LockTime: 0,
+		},
+		{
+			Version: 1,
+			TxIn: []*wire.TxIn{
+				{
+					PreviousOutPoint: wire.OutPoint{
+						Hash: chainhash.Hash([32]byte{ // Make go vet happy.
+							0xc3, 0x3e, 0xbf, 0xf2, 0xa7, 0x09, 0xf1, 0x3d,
+							0x9f, 0x9a, 0x75, 0x69, 0xab, 0x16, 0xa3, 0x27,
+							0x86, 0xaf, 0x7d, 0x7e, 0x2d, 0xe0, 0x92, 0x65,
+							0xe4, 0x1c, 0x61, 0xd0, 0x78, 0x29, 0x4e, 0xcf,
+						}), // cf4e2978d0611ce46592e02d7e7daf8627a316ab69759a9f3df109a7f2bf3ec3
+						Index: 1,
+					},
+					SignatureScript: []byte{
+						0x47, // OP_DATA_71
+						0x30, 0x44, 0x02, 0x20, 0x03, 0x2d, 0x30, 0xdf,
+						0x5e, 0xe6, 0xf5, 0x7f, 0xa4, 0x6c, 0xdd, 0xb5,
+						0xeb, 0x8d, 0x0d, 0x9f, 0xe8, 0xde, 0x6b, 0x34,
+						0x2d, 0x27, 0x94, 0x2a, 0xe9, 0x0a, 0x32, 0x31,
+						0xe0, 0xba, 0x33, 0x3e, 0x02, 0x20, 0x3d, 0xee,
+						0xe8, 0x06, 0x0f, 0xdc, 0x70, 0x23, 0x0a, 0x7f,
+						0x5b, 0x4a, 0xd7, 0xd7, 0xbc, 0x3e, 0x62, 0x8c,
+						0xbe, 0x21, 0x9a, 0x88, 0x6b, 0x84, 0x26, 0x9e,
+						0xae, 0xb8, 0x1e, 0x26, 0xb4, 0xfe, 0x01,
+						0x41, // OP_DATA_65
+						0x04, 0xae, 0x31, 0xc3, 0x1b, 0xf9, 0x12, 0x78,
+						0xd9, 0x9b, 0x83, 0x77, 0xa3, 0x5b, 0xbc, 0xe5,
+						0xb2, 0x7d, 0x9f, 0xff, 0x15, 0x45, 0x68, 0x39,
+						0xe9, 0x19, 0x45, 0x3f, 0xc7, 0xb3, 0xf7, 0x21,
+						0xf0, 0xba, 0x40, 0x3f, 0xf9, 0x6c, 0x9d, 0xee,
+						0xb6, 0x80, 0xe5, 0xfd, 0x34, 0x1c, 0x0f, 0xc3,
+						0xa7, 0xb9, 0x0d, 0xa4, 0x63, 0x1e, 0xe3, 0x95,
+						0x60, 0x63, 0x9d, 0xb4, 0x62, 0xe9, 0xcb, 0x85,
+						0x0f, // 65-byte pubkey
+					},
+					Sequence: 0xffffffff,
+				},
+			},
+			TxOut: []*wire.TxOut{
+				{
+					Value: 0xf4240, // 1000000
+					PkScript: []byte{
+						0x76, // OP_DUP
+						0xa9, // OP_HASH160
+						0x14, // OP_DATA_20
+						0xb0, 0xdc, 0xbf, 0x97, 0xea, 0xbf, 0x44, 0x04,
+						0xe3, 0x1d, 0x95, 0x24, 0x77, 0xce, 0x82, 0x2d,
+						0xad, 0xbe, 0x7e, 0x10,
+						0x88, // OP_EQUALVERIFY
+						0xac, // OP_CHECKSIG
+					},
+				},
+				{
+					Value: 0x11d260c0, // 299000000
+					PkScript: []byte{
+						0x76, // OP_DUP
+						0xa9, // OP_HASH160
+						0x14, // OP_DATA_20
+						0x6b, 0x12, 0x81, 0xee, 0xc2, 0x5a, 0xb4, 0xe1,
+						0xe0, 0x79, 0x3f, 0xf4, 0xe0, 0x8a, 0xb1, 0xab,
+						0xb3, 0x40, 0x9c, 0xd9,
+						0x88, // OP_EQUALVERIFY
+						0xac, // OP_CHECKSIG
+					},
+				},
+			},
+			LockTime: 0,
+		},
+		{
+			Version: 1,
+			TxIn: []*wire.TxIn{
+				{
+					PreviousOutPoint: wire.OutPoint{
+						Hash: chainhash.Hash([32]byte{ // Make go vet happy.
+							0x0b, 0x60, 0x72, 0xb3, 0x86, 0xd4, 0xa7, 0x73,
+							0x23, 0x52, 0x37, 0xf6, 0x4c, 0x11, 0x26, 0xac,
+							0x3b, 0x24, 0x0c, 0x84, 0xb9, 0x17, 0xa3, 0x90,
+							0x9b, 0xa1, 0xc4, 0x3d, 0xed, 0x5f, 0x51, 0xf4,
+						}), // f4515fed3dc4a19b90a317b9840c243bac26114cf637522373a7d486b372600b
+						Index: 0,
+					},
+					SignatureScript: []byte{
+						0x49, // OP_DATA_73
+						0x30, 0x46, 0x02, 0x21, 0x00, 0xbb, 0x1a, 0xd2,
+						0x6d, 0xf9, 0x30, 0xa5, 0x1c, 0xce, 0x11, 0x0c,
+						0xf4, 0x4f, 0x7a, 0x48, 0xc3, 0xc5, 0x61, 0xfd,
+						0x97, 0x75, 0x00, 0xb1, 0xae, 0x5d, 0x6b, 0x6f,
+						0xd1, 0x3d, 0x0b, 0x3f, 0x4a, 0x02, 0x21, 0x00,
+						0xc5, 0xb4, 0x29, 0x51, 0xac, 0xed, 0xff, 0x14,
+						0xab, 0xba, 0x27, 0x36, 0xfd, 0x57, 0x4b, 0xdb,
+						0x46, 0x5f, 0x3e, 0x6f, 0x8d, 0xa1, 0x2e, 0x2c,
+						0x53, 0x03, 0x95, 0x4a, 0xca, 0x7f, 0x78, 0xf3,
+						0x01, // 73-byte signature
+						0x41, // OP_DATA_65
+						0x04, 0xa7, 0x13, 0x5b, 0xfe, 0x82, 0x4c, 0x97,
+						0xec, 0xc0, 0x1e, 0xc7, 0xd7, 0xe3, 0x36, 0x18,
+						0x5c, 0x81, 0xe2, 0xaa, 0x2c, 0x41, 0xab, 0x17,
+						0x54, 0x07, 0xc0, 0x94, 0x84, 0xce, 0x96, 0x94,
+						0xb4, 0x49, 0x53, 0xfc, 0xb7, 0x51, 0x20, 0x65,
+						0x64, 0xa9, 0xc2, 0x4d, 0xd0, 0x94, 0xd4, 0x2f,
+						0xdb, 0xfd, 0xd5, 0xaa, 0xd3, 0xe0, 0x63, 0xce,
+						0x6a, 0xf4, 0xcf, 0xaa, 0xea, 0x4e, 0xa1, 0x4f,
+						0xbb, // 65-byte pubkey
+					},
+					Sequence: 0xffffffff,
+				},
+			},
+			TxOut: []*wire.TxOut{
+				{
+					Value: 0xf4240, // 1000000
+					PkScript: []byte{
+						0x76, // OP_DUP
+						0xa9, // OP_HASH160
+						0x14, // OP_DATA_20
+						0x39, 0xaa, 0x3d, 0x56, 0x9e, 0x06, 0xa1, 0xd7,
+						0x92, 0x6d, 0xc4, 0xbe, 0x11, 0x93, 0xc9, 0x9b,
+						0xf2, 0xeb, 0x9e, 0xe0,
+						0x88, // OP_EQUALVERIFY
+						0xac, // OP_CHECKSIG
+					},
+				},
+			},
+			LockTime: 0,
+		},
+	},
+}

vendor/github.com/btcsuite/btcd/blockchain/versionbits.go

@@ -0,0 +1,301 @@
+// 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 blockchain
+
+import (
+	"math"
+
+	"github.com/btcsuite/btcd/chaincfg"
+)
+
+const (
+	// vbLegacyBlockVersion is the highest legacy block version before the
+	// version bits scheme became active.
+	vbLegacyBlockVersion = 4
+
+	// vbTopBits defines the bits to set in the version to signal that the
+	// version bits scheme is being used.
+	vbTopBits = 0x20000000
+
+	// vbTopMask is the bitmask to use to determine whether or not the
+	// version bits scheme is in use.
+	vbTopMask = 0xe0000000
+
+	// vbNumBits is the total number of bits available for use with the
+	// version bits scheme.
+	vbNumBits = 29
+
+	// unknownVerNumToCheck is the number of previous blocks to consider
+	// when checking for a threshold of unknown block versions for the
+	// purposes of warning the user.
+	unknownVerNumToCheck = 100
+
+	// unknownVerWarnNum is the threshold of previous blocks that have an
+	// unknown version to use for the purposes of warning the user.
+	unknownVerWarnNum = unknownVerNumToCheck / 2
+)
+
+// bitConditionChecker provides a thresholdConditionChecker which can be used to
+// test whether or not a specific bit is set when it's not supposed to be
+// according to the expected version based on the known deployments and the
+// current state of the chain.  This is useful for detecting and warning about
+// unknown rule activations.
+type bitConditionChecker struct {
+	bit   uint32
+	chain *BlockChain
+}
+
+// Ensure the bitConditionChecker type implements the thresholdConditionChecker
+// interface.
+var _ thresholdConditionChecker = bitConditionChecker{}
+
+// BeginTime returns the unix timestamp for the median block time after which
+// voting on a rule change starts (at the next window).
+//
+// Since this implementation checks for unknown rules, it returns 0 so the rule
+// is always treated as active.
+//
+// This is part of the thresholdConditionChecker interface implementation.
+func (c bitConditionChecker) BeginTime() uint64 {
+	return 0
+}
+
+// EndTime returns the unix timestamp for the median block time after which an
+// attempted rule change fails if it has not already been locked in or
+// activated.
+//
+// Since this implementation checks for unknown rules, it returns the maximum
+// possible timestamp so the rule is always treated as active.
+//
+// This is part of the thresholdConditionChecker interface implementation.
+func (c bitConditionChecker) EndTime() uint64 {
+	return math.MaxUint64
+}
+
+// RuleChangeActivationThreshold is the number of blocks for which the condition
+// must be true in order to lock in a rule change.
+//
+// This implementation returns the value defined by the chain params the checker
+// is associated with.
+//
+// This is part of the thresholdConditionChecker interface implementation.
+func (c bitConditionChecker) RuleChangeActivationThreshold() uint32 {
+	return c.chain.chainParams.RuleChangeActivationThreshold
+}
+
+// MinerConfirmationWindow is the number of blocks in each threshold state
+// retarget window.
+//
+// This implementation returns the value defined by the chain params the checker
+// is associated with.
+//
+// This is part of the thresholdConditionChecker interface implementation.
+func (c bitConditionChecker) MinerConfirmationWindow() uint32 {
+	return c.chain.chainParams.MinerConfirmationWindow
+}
+
+// Condition returns true when the specific bit associated with the checker is
+// set and it's not supposed to be according to the expected version based on
+// the known deployments and the current state of the chain.
+//
+// This function MUST be called with the chain state lock held (for writes).
+//
+// This is part of the thresholdConditionChecker interface implementation.
+func (c bitConditionChecker) Condition(node *blockNode) (bool, error) {
+	conditionMask := uint32(1) << c.bit
+	version := uint32(node.version)
+	if version&vbTopMask != vbTopBits {
+		return false, nil
+	}
+	if version&conditionMask == 0 {
+		return false, nil
+	}
+
+	expectedVersion, err := c.chain.calcNextBlockVersion(node.parent)
+	if err != nil {
+		return false, err
+	}
+	return uint32(expectedVersion)&conditionMask == 0, nil
+}
+
+// deploymentChecker provides a thresholdConditionChecker which can be used to
+// test a specific deployment rule.  This is required for properly detecting
+// and activating consensus rule changes.
+type deploymentChecker struct {
+	deployment *chaincfg.ConsensusDeployment
+	chain      *BlockChain
+}
+
+// Ensure the deploymentChecker type implements the thresholdConditionChecker
+// interface.
+var _ thresholdConditionChecker = deploymentChecker{}
+
+// BeginTime returns the unix timestamp for the median block time after which
+// voting on a rule change starts (at the next window).
+//
+// This implementation returns the value defined by the specific deployment the
+// checker is associated with.
+//
+// This is part of the thresholdConditionChecker interface implementation.
+func (c deploymentChecker) BeginTime() uint64 {
+	return c.deployment.StartTime
+}
+
+// EndTime returns the unix timestamp for the median block time after which an
+// attempted rule change fails if it has not already been locked in or
+// activated.
+//
+// This implementation returns the value defined by the specific deployment the
+// checker is associated with.
+//
+// This is part of the thresholdConditionChecker interface implementation.
+func (c deploymentChecker) EndTime() uint64 {
+	return c.deployment.ExpireTime
+}
+
+// RuleChangeActivationThreshold is the number of blocks for which the condition
+// must be true in order to lock in a rule change.
+//
+// This implementation returns the value defined by the chain params the checker
+// is associated with.
+//
+// This is part of the thresholdConditionChecker interface implementation.
+func (c deploymentChecker) RuleChangeActivationThreshold() uint32 {
+	return c.chain.chainParams.RuleChangeActivationThreshold
+}
+
+// MinerConfirmationWindow is the number of blocks in each threshold state
+// retarget window.
+//
+// This implementation returns the value defined by the chain params the checker
+// is associated with.
+//
+// This is part of the thresholdConditionChecker interface implementation.
+func (c deploymentChecker) MinerConfirmationWindow() uint32 {
+	return c.chain.chainParams.MinerConfirmationWindow
+}
+
+// Condition returns true when the specific bit defined by the deployment
+// associated with the checker is set.
+//
+// This is part of the thresholdConditionChecker interface implementation.
+func (c deploymentChecker) Condition(node *blockNode) (bool, error) {
+	conditionMask := uint32(1) << c.deployment.BitNumber
+	version := uint32(node.version)
+	return (version&vbTopMask == vbTopBits) && (version&conditionMask != 0),
+		nil
+}
+
+// calcNextBlockVersion calculates the expected version of the block after the
+// passed previous block node based on the state of started and locked in
+// rule change deployments.
+//
+// This function differs from the exported CalcNextBlockVersion in that the
+// exported version uses the current best chain as the previous block node
+// while this function accepts any block node.
+//
+// This function MUST be called with the chain state lock held (for writes).
+func (b *BlockChain) calcNextBlockVersion(prevNode *blockNode) (int32, error) {
+	// Set the appropriate bits for each actively defined rule deployment
+	// that is either in the process of being voted on, or locked in for the
+	// activation at the next threshold window change.
+	expectedVersion := uint32(vbTopBits)
+	for id := 0; id < len(b.chainParams.Deployments); id++ {
+		deployment := &b.chainParams.Deployments[id]
+		cache := &b.deploymentCaches[id]
+		checker := deploymentChecker{deployment: deployment, chain: b}
+		state, err := b.thresholdState(prevNode, checker, cache)
+		if err != nil {
+			return 0, err
+		}
+		if state == ThresholdStarted || state == ThresholdLockedIn {
+			expectedVersion |= uint32(1) << deployment.BitNumber
+		}
+	}
+	return int32(expectedVersion), nil
+}
+
+// CalcNextBlockVersion calculates the expected version of the block after the
+// end of the current best chain based on the state of started and locked in
+// rule change deployments.
+//
+// This function is safe for concurrent access.
+func (b *BlockChain) CalcNextBlockVersion() (int32, error) {
+	b.chainLock.Lock()
+	version, err := b.calcNextBlockVersion(b.bestChain.Tip())
+	b.chainLock.Unlock()
+	return version, err
+}
+
+// warnUnknownRuleActivations displays a warning when any unknown new rules are
+// either about to activate or have been activated.  This will only happen once
+// when new rules have been activated and every block for those about to be
+// activated.
+//
+// This function MUST be called with the chain state lock held (for writes)
+func (b *BlockChain) warnUnknownRuleActivations(node *blockNode) error {
+	// Warn if any unknown new rules are either about to activate or have
+	// already been activated.
+	for bit := uint32(0); bit < vbNumBits; bit++ {
+		checker := bitConditionChecker{bit: bit, chain: b}
+		cache := &b.warningCaches[bit]
+		state, err := b.thresholdState(node.parent, checker, cache)
+		if err != nil {
+			return err
+		}
+
+		switch state {
+		case ThresholdActive:
+			if !b.unknownRulesWarned {
+				log.Warnf("Unknown new rules activated (bit %d)",
+					bit)
+				b.unknownRulesWarned = true
+			}
+
+		case ThresholdLockedIn:
+			window := int32(checker.MinerConfirmationWindow())
+			activationHeight := window - (node.height % window)
+			log.Warnf("Unknown new rules are about to activate in "+
+				"%d blocks (bit %d)", activationHeight, bit)
+		}
+	}
+
+	return nil
+}
+
+// warnUnknownVersions logs a warning if a high enough percentage of the last
+// blocks have unexpected versions.
+//
+// This function MUST be called with the chain state lock held (for writes)
+func (b *BlockChain) warnUnknownVersions(node *blockNode) error {
+	// Nothing to do if already warned.
+	if b.unknownVersionsWarned {
+		return nil
+	}
+
+	// Warn if enough previous blocks have unexpected versions.
+	numUpgraded := uint32(0)
+	for i := uint32(0); i < unknownVerNumToCheck && node != nil; i++ {
+		expectedVersion, err := b.calcNextBlockVersion(node.parent)
+		if err != nil {
+			return err
+		}
+		if expectedVersion > vbLegacyBlockVersion &&
+			(node.version & ^expectedVersion) != 0 {
+
+			numUpgraded++
+		}
+
+		node = node.parent
+	}
+	if numUpgraded > unknownVerWarnNum {
+		log.Warn("Unknown block versions are being mined, so new " +
+			"rules might be in effect.  Are you running the " +
+			"latest version of the software?")
+		b.unknownVersionsWarned = true
+	}
+
+	return nil
+}

vendor/github.com/btcsuite/btcd/blockchain/weight.go

@@ -0,0 +1,111 @@
+// 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 blockchain
+
+import (
+	"fmt"
+
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcutil"
+)
+
+const (
+	// MaxBlockWeight defines the maximum block weight, where "block
+	// weight" is interpreted as defined in BIP0141. A block's weight is
+	// calculated as the sum of the of bytes in the existing transactions
+	// and header, plus the weight of each byte within a transaction. The
+	// weight of a "base" byte is 4, while the weight of a witness byte is
+	// 1. As a result, for a block to be valid, the BlockWeight MUST be
+	// less than, or equal to MaxBlockWeight.
+	MaxBlockWeight = 4000000
+
+	// MaxBlockBaseSize is the maximum number of bytes within a block
+	// which can be allocated to non-witness data.
+	MaxBlockBaseSize = 1000000
+
+	// MaxBlockSigOpsCost is the maximum number of signature operations
+	// allowed for a block. It is calculated via a weighted algorithm which
+	// weights segragated witness sig ops lower than regular sig ops.
+	MaxBlockSigOpsCost = 80000
+
+	// WitnessScaleFactor determines the level of "discount" witness data
+	// receives compared to "base" data. A scale factor of 4, denotes that
+	// witness data is 1/4 as cheap as regular non-witness data.
+	WitnessScaleFactor = 4
+)
+
+// GetBlockWeight computes the value of the weight metric for a given block.
+// Currently the weight metric is simply the sum of the block's serialized size
+// without any witness data scaled proportionally by the WitnessScaleFactor,
+// and the block's serialized size including any witness data.
+func GetBlockWeight(blk *btcutil.Block) int64 {
+	msgBlock := blk.MsgBlock()
+
+	baseSize := msgBlock.SerializeSizeStripped()
+	totalSize := msgBlock.SerializeSize()
+
+	// (baseSize * 3) + totalSize
+	return int64((baseSize * (WitnessScaleFactor - 1)) + totalSize)
+}
+
+// GetTransactionWeight computes the value of the weight metric for a given
+// transaction. Currently the weight metric is simply the sum of the
+// transactions's serialized size without any witness data scaled
+// proportionally by the WitnessScaleFactor, and the transaction's serialized
+// size including any witness data.
+func GetTransactionWeight(tx *btcutil.Tx) int64 {
+	msgTx := tx.MsgTx()
+
+	baseSize := msgTx.SerializeSizeStripped()
+	totalSize := msgTx.SerializeSize()
+
+	// (baseSize * 3) + totalSize
+	return int64((baseSize * (WitnessScaleFactor - 1)) + totalSize)
+}
+
+// GetSigOpCost returns the unified sig op cost for the passed transaction
+// respecting current active soft-forks which modified sig op cost counting.
+// The unified sig op cost for a transaction is computed as the sum of: the
+// legacy sig op count scaled according to the WitnessScaleFactor, the sig op
+// count for all p2sh inputs scaled by the WitnessScaleFactor, and finally the
+// unscaled sig op count for any inputs spending witness programs.
+func GetSigOpCost(tx *btcutil.Tx, isCoinBaseTx bool, utxoView *UtxoViewpoint,
+	bip16, segWit bool) (int, error) {
+
+	numSigOps := CountSigOps(tx) * WitnessScaleFactor
+	if bip16 {
+		numP2SHSigOps, err := CountP2SHSigOps(tx, isCoinBaseTx, utxoView)
+		if err != nil {
+			return 0, nil
+		}
+		numSigOps += (numP2SHSigOps * WitnessScaleFactor)
+	}
+
+	if segWit && !isCoinBaseTx {
+		msgTx := tx.MsgTx()
+		for txInIndex, txIn := range msgTx.TxIn {
+			// Ensure the referenced input transaction is available.
+			originTxHash := &txIn.PreviousOutPoint.Hash
+			originTxIndex := txIn.PreviousOutPoint.Index
+			txEntry := utxoView.LookupEntry(originTxHash)
+			if txEntry == nil || txEntry.IsOutputSpent(originTxIndex) {
+				str := fmt.Sprintf("output %v referenced from "+
+					"transaction %s:%d either does not "+
+					"exist or has already been spent",
+					txIn.PreviousOutPoint, tx.Hash(),
+					txInIndex)
+				return 0, ruleError(ErrMissingTxOut, str)
+			}
+
+			witness := txIn.Witness
+			sigScript := txIn.SignatureScript
+			pkScript := txEntry.PkScriptByIndex(originTxIndex)
+			numSigOps += txscript.GetWitnessSigOpCount(sigScript, pkScript, witness)
+		}
+
+	}
+
+	return numSigOps, nil
+}