multi: update btcsuite API's to latest upstream changes

This commit makes a large number of minor changes concerning API usage within the deamon to match the latest version on the upstream btcsuite libraries. The major changes are the switch from wire.ShaHash to chainhash.Hash, and that wire.NewMsgTx() now takes a paramter indicating the version of the transaction to be created.
2017-01-05 13:56:27 -08:00 · 2017-01-05 13:56:27 -08:00 · 5affed38fc
commit 5affed38fc
parent 5d37c1d9e7
40 changed files with 234 additions and 211 deletions
--- a/breacharbiter.go
+++ b/breacharbiter.go
@ -8,6 +8,7 @@ import (
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/lnwallet"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/txscript"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
@ -292,7 +293,7 @@ func (b *breachArbiter) exactRetribution(confChan *chainntnfs.ConfirmationEvent,
 	// dispatched once the justice tx is confirmed. After confirmation we
 	// notify the caller that initiated the retribution work low that the
 	// deed has been done.
-	justiceTXID := justiceTx.TxSha()
+	justiceTXID := justiceTx.TxHash()
 	confChan, err = b.notifier.RegisterConfirmationsNtfn(&justiceTXID, 1)
 	if err != nil {
 		brarLog.Errorf("unable to register for conf for txid: %v",
@ -404,7 +405,7 @@ func (b *breachArbiter) breachObserver(contract *lnwallet.LightningChannel,
 		// send the retribution information to the utxo nursery.
 		// TODO(roasbeef): populate htlc breaches
 		b.breachedContracts <- &retributionInfo{
-			commitHash: breachInfo.BreachTransaction.TxSha(),
+			commitHash: breachInfo.BreachTransaction.TxHash(),
 			chanPoint:  *chanPoint,

 			selfOutput: &breachedOutput{
@ -444,7 +445,7 @@ type breachedOutput struct {
 // transaction which spends all outputs of the commitment transaction into an
 // output controlled by the wallet.
 type retributionInfo struct {
-	commitHash wire.ShaHash
+	commitHash chainhash.Hash
 	chanPoint  wire.OutPoint

 	selfOutput *breachedOutput
@ -478,7 +479,7 @@ func (b *breachArbiter) createJusticeTx(r *retributionInfo) (*wire.MsgTx, error)

 	// With the fee calculate, we can now create the justice transaction
 	// using the information gathered above.
-	justiceTx := wire.NewMsgTx()
+	justiceTx := wire.NewMsgTx(2)
 	justiceTx.AddTxOut(&wire.TxOut{
 		PkScript: pkScriptOfJustice,
 		Value:    sweepedAmt,
--- a/chainntnfs/btcdnotify/btcd.go
+++ b/chainntnfs/btcdnotify/btcd.go
@ -9,6 +9,7 @@ import (

 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/roasbeef/btcd/btcjson"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcrpcclient"
 	"github.com/roasbeef/btcutil"
@ -30,7 +31,7 @@ var (
 // used as an element within an unbounded queue in order to avoid blocking the
 // main rpc dispatch rule.
 type chainUpdate struct {
-	blockHash   *wire.ShaHash
+	blockHash   *chainhash.Hash
 	blockHeight int32
 }

@ -55,7 +56,7 @@ type BtcdNotifier struct {

 	spendNotifications map[wire.OutPoint][]*spendNotification

-	confNotifications map[wire.ShaHash][]*confirmationsNotification
+	confNotifications map[chainhash.Hash][]*confirmationsNotification
 	confHeap          *confirmationHeap

 	blockEpochClients []chan *chainntnfs.BlockEpoch
@ -85,7 +86,7 @@ func New(config *btcrpcclient.ConnConfig) (*BtcdNotifier, error) {
 		notificationRegistry: make(chan interface{}),

 		spendNotifications: make(map[wire.OutPoint][]*spendNotification),
-		confNotifications:  make(map[wire.ShaHash][]*confirmationsNotification),
+		confNotifications:  make(map[chainhash.Hash][]*confirmationsNotification),
 		confHeap:           newConfirmationHeap(),

 		disconnectedBlockHashes: make(chan *blockNtfn, 20),
@ -180,14 +181,14 @@ func (b *BtcdNotifier) Stop() error {
 // blockNtfn packages a notification of a connected/disconnected block along
 // with its height at the time.
 type blockNtfn struct {
-	sha    *wire.ShaHash
+	sha    *chainhash.Hash
 	height int32
 }

 // onBlockConnected implements on OnBlockConnected callback for btcrpcclient.
 // Ingesting a block updates the wallet's internal utxo state based on the
 // outputs created and destroyed within each block.
-func (b *BtcdNotifier) onBlockConnected(hash *wire.ShaHash, height int32, t time.Time) {
+func (b *BtcdNotifier) onBlockConnected(hash *chainhash.Hash, height int32, t time.Time) {
 	// Append this new chain update to the end of the queue of new chain
 	// updates.
 	b.chainUpdateMtx.Lock()
@ -203,7 +204,7 @@ func (b *BtcdNotifier) onBlockConnected(hash *wire.ShaHash, height int32, t time
 }

 // onBlockDisconnected implements on OnBlockDisconnected callback for btcrpcclient.
-func (b *BtcdNotifier) onBlockDisconnected(hash *wire.ShaHash, height int32, t time.Time) {
+func (b *BtcdNotifier) onBlockDisconnected(hash *chainhash.Hash, height int32, t time.Time) {
 }

 // onRedeemingTx implements on OnRedeemingTx callback for btcrpcclient.
@ -293,7 +294,7 @@ out:
 				// notification on a heap to be triggered in
 				// the future once additional confirmations are
 				// attained.
-				txSha := tx.TxSha()
+				txSha := tx.TxHash()
 				b.checkConfirmationTrigger(&txSha, update, i)
 			}

@ -323,7 +324,7 @@ out:
 				// summary, finally sending off the details to
 				// the notification subscriber.
 				if clients, ok := b.spendNotifications[prevOut]; ok {
-					spenderSha := newSpend.tx.Sha()
+					spenderSha := newSpend.tx.Hash()
 					for _, ntfn := range clients {
 						spendDetails := &chainntnfs.SpendDetail{
 							SpentOutPoint: ntfn.targetOutpoint,
@ -361,14 +362,14 @@ func (b *BtcdNotifier) attemptHistoricalDispatch(msg *confirmationsNotification,
 	// If the transaction already has some or all of the confirmations,
 	// then we may be able to dispatch it immediately.
 	tx, err := b.chainConn.GetRawTransactionVerbose(msg.txid)
-	if err != nil || tx == nil {
+	if err != nil || tx == nil || tx.BlockHash == "" {
 		return false
 	}

 	// As we need to fully populate the returned TxConfirmation struct,
 	// grab the block in which the transaction was confirmed so we can
 	// locate its exact index within the block.
-	blockHash, err := wire.NewShaHashFromStr(tx.BlockHash)
+	blockHash, err := chainhash.NewHashFromStr(tx.BlockHash)
 	if err != nil {
 		chainntnfs.Log.Errorf("unable to get block hash %v for "+
 			"historical dispatch: %v", tx.BlockHash, err)
@ -380,7 +381,7 @@ func (b *BtcdNotifier) attemptHistoricalDispatch(msg *confirmationsNotification,
 		return false
 	}

-	txHash, err := wire.NewShaHashFromStr(tx.Hash)
+	txHash, err := chainhash.NewHashFromStr(tx.Hash)
 	if err != nil {
 		chainntnfs.Log.Errorf("unable to convert to hash: %v", err)
 		return false
@ -390,7 +391,7 @@ func (b *BtcdNotifier) attemptHistoricalDispatch(msg *confirmationsNotification,
 	// block so we can give the subscriber full confirmation details.
 	var txIndex uint32
 	for i, t := range block.Transactions {
-		h := t.TxSha()
+		h := t.TxHash()
 		if txHash.IsEqual(&h) {
 			txIndex = uint32(i)
 		}
@ -426,7 +427,7 @@ func (b *BtcdNotifier) attemptHistoricalDispatch(msg *confirmationsNotification,

 // notifyBlockEpochs notifies all registered block epoch clients of the newly
 // connected block to the main chain.
-func (b *BtcdNotifier) notifyBlockEpochs(newHeight int32, newSha *wire.ShaHash) {
+func (b *BtcdNotifier) notifyBlockEpochs(newHeight int32, newSha *chainhash.Hash) {
 	epoch := &chainntnfs.BlockEpoch{
 		Height: newHeight,
 		Hash:   newSha,
@ -479,7 +480,7 @@ func (b *BtcdNotifier) notifyConfs(newBlockHeight int32) {
 // matches, yet needs additional confirmations, it is added to the confirmation
 // heap to be triggered at a later time.
 // TODO(roasbeef): perhaps lookup, then track by inputs instead?
-func (b *BtcdNotifier) checkConfirmationTrigger(txSha *wire.ShaHash,
+func (b *BtcdNotifier) checkConfirmationTrigger(txSha *chainhash.Hash,
 	newTip *chainUpdate, txIndex int) {

 	// If a confirmation notification has been registered
@ -573,7 +574,7 @@ func (b *BtcdNotifier) RegisterSpendNtfn(outpoint *wire.OutPoint) (*chainntnfs.S
 			return nil, err
 		}

-		blockhash, err := wire.NewShaHashFromStr(transaction.BlockHash)
+		blockhash, err := chainhash.NewHashFromStr(transaction.BlockHash)
 		if err != nil {
 			return nil, err
 		}
@ -591,7 +592,7 @@ func (b *BtcdNotifier) RegisterSpendNtfn(outpoint *wire.OutPoint) (*chainntnfs.S
 // confirmationNotification represents a client's intent to receive a
 // notification once the target txid reaches numConfirmations confirmations.
 type confirmationsNotification struct {
-	txid *wire.ShaHash
+	txid *chainhash.Hash

 	initialConfirmHeight uint32
 	numConfirmations     uint32
@ -603,7 +604,7 @@ type confirmationsNotification struct {
 // RegisterConfirmationsNotification registers a notification with BtcdNotifier
 // which will be triggered once the txid reaches numConfs number of
 // confirmations.
-func (b *BtcdNotifier) RegisterConfirmationsNtfn(txid *wire.ShaHash,
+func (b *BtcdNotifier) RegisterConfirmationsNtfn(txid *chainhash.Hash,
 	numConfs uint32) (*chainntnfs.ConfirmationEvent, error) {

 	ntfn := &confirmationsNotification{
--- a/chainntnfs/interface.go
+++ b/chainntnfs/interface.go
@ -4,6 +4,7 @@ import (
 	"fmt"
 	"sync"

+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/wire"
 )

@ -26,7 +27,7 @@ type ChainNotifier interface {
 	//
 	// NOTE: Dispatching notifications to multiple clients subscribed to
 	// the same (txid, numConfs) tuple MUST be supported.
-	RegisterConfirmationsNtfn(txid *wire.ShaHash, numConfs uint32) (*ConfirmationEvent, error)
+	RegisterConfirmationsNtfn(txid *chainhash.Hash, numConfs uint32) (*ConfirmationEvent, error)

 	// RegisterSpendNtfn registers an intent to be notified once the target
 	// outpoint is succesfully spent within a confirmed transaction. The
@ -62,7 +63,7 @@ type ChainNotifier interface {
 type TxConfirmation struct {
 	// BlockHash is the hash of the block that confirmed the original
 	// transition.
-	BlockHash *wire.ShaHash
+	BlockHash *chainhash.Hash

 	// BlockHeight is the height of the block in which the transaction was
 	// confirmed within.
@ -105,7 +106,7 @@ type ConfirmationEvent struct {
 // target output.
 type SpendDetail struct {
 	SpentOutPoint     *wire.OutPoint
-	SpenderTxHash     *wire.ShaHash
+	SpenderTxHash     *chainhash.Hash
 	SpendingTx        *wire.MsgTx
 	SpenderInputIndex uint32
 	SpendingHeight    int32
@ -122,7 +123,7 @@ type SpendEvent struct {
 // main chain.
 type BlockEpoch struct {
 	Height int32
-	Hash   *wire.ShaHash
+	Hash   *chainhash.Hash
 }

 // BlockEpochEvent encapsulates an on-going stream of block epoch
--- a/chainntnfs/interface_test.go
+++ b/chainntnfs/interface_test.go
@ -9,6 +9,7 @@ import (

 	"github.com/lightningnetwork/lnd/chainntnfs"
 	_ "github.com/lightningnetwork/lnd/chainntnfs/btcdnotify"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"

 	"github.com/roasbeef/btcd/btcec"
 	"github.com/roasbeef/btcd/chaincfg"
@ -33,14 +34,14 @@ var (
 	testAddr = addrPk.AddressPubKeyHash()
 )

-func getTestTxId(miner *rpctest.Harness) (*wire.ShaHash, error) {
+func getTestTxId(miner *rpctest.Harness) (*chainhash.Hash, error) {
 	script, err := txscript.PayToAddrScript(testAddr)
 	if err != nil {
 		return nil, err
 	}

 	outputs := []*wire.TxOut{&wire.TxOut{2e8, script}}
-	return miner.CoinbaseSpend(outputs)
+	return miner.SendOutputs(outputs, 10)
 }

 func testSingleConfirmationNotification(miner *rpctest.Harness,
@ -246,7 +247,7 @@ func testSpendNotification(miner *rpctest.Harness,
 	}

 	// Next, create a new transaction spending that output.
-	spendingTx := wire.NewMsgTx()
+	spendingTx := wire.NewMsgTx(1)
 	spendingTx.AddTxIn(&wire.TxIn{
 		PreviousOutPoint: *outpoint,
 	})
@ -293,10 +294,10 @@ func testSpendNotification(miner *rpctest.Harness,
 					"%v instead of %v",
 					ntfn.SpentOutPoint, outpoint)
 			}
-			if !bytes.Equal(ntfn.SpenderTxHash.Bytes(), spenderSha.Bytes()) {
+			if !bytes.Equal(ntfn.SpenderTxHash[:], spenderSha[:]) {
 				t.Fatalf("ntfn includes wrong spender tx sha, "+
 					"reports %v intead of %v",
-					ntfn.SpenderTxHash.Bytes(), spenderSha.Bytes())
+					ntfn.SpenderTxHash[:], spenderSha[:])
 			}
 			if ntfn.SpenderInputIndex != 0 {
 				t.Fatalf("ntfn includes wrong spending input "+
@ -549,7 +550,7 @@ func testSpendBeforeNtfnRegistration(miner *rpctest.Harness,
 	outpoint := wire.NewOutPoint(txid, uint32(outIndex))

 	// Next, create a new transaction spending that output.
-	spendingTx := wire.NewMsgTx()
+	spendingTx := wire.NewMsgTx(1)
 	spendingTx.AddTxIn(&wire.TxIn{
 		PreviousOutPoint: *outpoint,
 	})
@ -596,9 +597,9 @@ func testSpendBeforeNtfnRegistration(miner *rpctest.Harness,
 			t.Fatalf("ntfn includes wrong output, reports %v instead of %v",
 				ntfn.SpentOutPoint, outpoint)
 		}
-		if !bytes.Equal(ntfn.SpenderTxHash.Bytes(), spenderSha.Bytes()) {
+		if !bytes.Equal(ntfn.SpenderTxHash[:], spenderSha[:]) {
 			t.Fatalf("ntfn includes wrong spender tx sha, reports %v intead of %v",
-				ntfn.SpenderTxHash.Bytes(), spenderSha.Bytes())
+				ntfn.SpenderTxHash[:], spenderSha[:])
 		}
 		if ntfn.SpenderInputIndex != 0 {
 			t.Fatalf("ntfn includes wrong spending input index, reports %v, should be %v",
--- a/channeldb/channel.go
+++ b/channeldb/channel.go
@ -11,6 +11,7 @@ import (
 	"github.com/boltdb/bolt"
 	"github.com/lightningnetwork/lnd/elkrem"
 	"github.com/roasbeef/btcd/btcec"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
 )
@ -1274,7 +1275,7 @@ func fetchChanCommitTxns(nodeChanBucket *bolt.Bucket, channel *OpenChannel) erro

 	txnBytes := bytes.NewReader(nodeChanBucket.Get(txnsKey))

-	channel.OurCommitTx = wire.NewMsgTx()
+	channel.OurCommitTx = wire.NewMsgTx(2)
 	if err = channel.OurCommitTx.Deserialize(txnBytes); err != nil {
 		return err
 	}
@ -1502,7 +1503,7 @@ func fetchChanElkremState(nodeChanBucket *bolt.Bucket, channel *OpenChannel) err
 	if err != nil {
 		return err
 	}
-	elkremRoot, err := wire.NewShaHash(senderBytes)
+	elkremRoot, err := chainhash.NewHash(senderBytes)
 	if err != nil {
 		return err
 	}
--- a/channeldb/channel_test.go
+++ b/channeldb/channel_test.go
@ -12,6 +12,7 @@ import (
 	"github.com/lightningnetwork/lnd/elkrem"
 	"github.com/roasbeef/btcd/btcec"
 	"github.com/roasbeef/btcd/chaincfg"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/txscript"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
@ -19,16 +20,16 @@ import (
 )

 var (
-	netParams = &chaincfg.SegNet4Params
+	netParams = &chaincfg.TestNet3Params

-	key = [wire.HashSize]byte{
+	key = [chainhash.HashSize]byte{
 		0x81, 0xb6, 0x37, 0xd8, 0xfc, 0xd2, 0xc6, 0xda,
 		0x68, 0x59, 0xe6, 0x96, 0x31, 0x13, 0xa1, 0x17,
 		0xd, 0xe7, 0x93, 0xe4, 0xb7, 0x25, 0xb8, 0x4d,
 		0x1e, 0xb, 0x4c, 0xf9, 0x9e, 0xc5, 0x8c, 0xe9,
 	}
 	id = &wire.OutPoint{
-		Hash: [wire.HashSize]byte{
+		Hash: [chainhash.HashSize]byte{
 			0x51, 0xb6, 0x37, 0xd8, 0xfc, 0xd2, 0xc6, 0xda,
 			0x48, 0x59, 0xe6, 0x96, 0x31, 0x13, 0xa1, 0x17,
 			0x2d, 0xe7, 0x93, 0xe4, 0xb7, 0x25, 0xb8, 0x4d,
@ -36,7 +37,7 @@ var (
 		},
 		Index: 9,
 	}
-	rev = [wire.HashSize]byte{
+	rev = [chainhash.HashSize]byte{
 		0x51, 0xb6, 0x37, 0xd8, 0xfc, 0xd2, 0xc6, 0xda,
 		0x48, 0x59, 0xe6, 0x96, 0x31, 0x13, 0xa1, 0x17,
 		0x2d, 0xe7, 0x93, 0xe4,
@ -46,7 +47,7 @@ var (
 		TxIn: []*wire.TxIn{
 			&wire.TxIn{
 				PreviousOutPoint: wire.OutPoint{
-					Hash:  wire.ShaHash{},
+					Hash:  chainhash.Hash{},
 					Index: 0xffffffff,
 				},
 				SignatureScript: []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62},
--- a/channeldb/graph.go
+++ b/channeldb/graph.go
@ -10,6 +10,7 @@ import (

 	"github.com/boltdb/bolt"
 	"github.com/roasbeef/btcd/btcec"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
 )
@ -505,7 +506,7 @@ const (
 // with the current UTXO state. An integer is returned which reflects the
 // number of channels pruned due to the new incoming block.
 func (c *ChannelGraph) PruneGraph(spentOutputs []*wire.OutPoint,
-	blockHash *wire.ShaHash, blockHeight uint32) (uint32, error) {
+	blockHash *chainhash.Hash, blockHeight uint32) (uint32, error) {

 	var numChans uint32

@ -572,10 +573,10 @@ func (c *ChannelGraph) PruneGraph(spentOutputs []*wire.OutPoint,
 // used to prune channels in the graph. Knowing the "prune tip" allows callers
 // to tell if the graph is currently in sync with the current best known UTXO
 // state.
-func (c *ChannelGraph) PruneTip() (*wire.ShaHash, uint32, error) {
+func (c *ChannelGraph) PruneTip() (*chainhash.Hash, uint32, error) {
 	var (
 		currentTip [pruneTipBytes]byte
-		tipHash    wire.ShaHash
+		tipHash    chainhash.Hash
 		tipHeight  uint32
 	)

--- a/channeldb/graph_test.go
+++ b/channeldb/graph_test.go
@ -13,6 +13,7 @@ import (

 	"github.com/btcsuite/fastsha256"
 	"github.com/roasbeef/btcd/btcec"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
 )
@ -524,7 +525,7 @@ func TestGraphTraversal(t *testing.T) {
 	}
 }

-func assertPruneTip(t *testing.T, graph *ChannelGraph, blockHash *wire.ShaHash,
+func assertPruneTip(t *testing.T, graph *ChannelGraph, blockHash *chainhash.Hash,
 	blockHeight uint32) {

 	pruneHash, pruneHeight, err := graph.PruneTip()
@ -629,7 +630,7 @@ func TestGraphPruning(t *testing.T) {

 	// First we create a mock block that ends up closing the first two
 	// channels.
-	var blockHash wire.ShaHash
+	var blockHash chainhash.Hash
 	copy(blockHash[:], bytes.Repeat([]byte{1}, 32))
 	blockHeight := uint32(1)
 	block := channelPoints[:2]
--- a/cmd/lncli/commands.go
+++ b/cmd/lncli/commands.go
@ -10,7 +10,7 @@ import (
 	"strings"

 	"github.com/lightningnetwork/lnd/lnrpc"
-	"github.com/roasbeef/btcd/wire"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/urfave/cli"
 	"golang.org/x/net/context"
 )
@ -250,7 +250,7 @@ func openChannel(ctx *cli.Context) error {
 		switch update := resp.Update.(type) {
 		case *lnrpc.OpenStatusUpdate_ChanOpen:
 			channelPoint := update.ChanOpen.ChannelPoint
-			txid, err := wire.NewShaHash(channelPoint.FundingTxid)
+			txid, err := chainhash.NewHash(channelPoint.FundingTxid)
 			if err != nil {
 				return err
 			}
@ -306,7 +306,7 @@ func closeChannel(ctx *cli.Context) error {
 	ctxb := context.Background()
 	client := getClient(ctx)

-	txid, err := wire.NewShaHashFromStr(ctx.String("funding_txid"))
+	txid, err := chainhash.NewHashFromStr(ctx.String("funding_txid"))
 	if err != nil {
 		return err
 	}
@ -340,7 +340,7 @@ func closeChannel(ctx *cli.Context) error {
 		switch update := resp.Update.(type) {
 		case *lnrpc.CloseStatusUpdate_ChanClose:
 			closingHash := update.ChanClose.ClosingTxid
-			txid, err := wire.NewShaHash(closingHash)
+			txid, err := chainhash.NewHash(closingHash)
 			if err != nil {
 				return err
 			}
--- a/elkrem/elkrem.go
+++ b/elkrem/elkrem.go
@ -3,7 +3,7 @@ package elkrem
 import (
 	"fmt"

-	"github.com/roasbeef/btcd/wire"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 )

 /* elkrem is a simpler alternative to the 64 dimensional sha-chain.
@ -41,25 +41,25 @@ const maxHeight = uint8(47)
 type ElkremNode struct {
 	h   uint8           // height of this node
 	i   uint64          // index (i'th node)
-	sha *wire.ShaHash // hash
+	sha *chainhash.Hash // hash
 }
 type ElkremSender struct {
-	root *wire.ShaHash // root hash of the tree
+	root *chainhash.Hash // root hash of the tree
 }
 type ElkremReceiver struct {
 	s []ElkremNode // store of received hashes
 }

-func LeftSha(in wire.ShaHash) wire.ShaHash {
-	return wire.DoubleSha256SH(in.Bytes()) // left is sha(sha(in))
+func LeftSha(in chainhash.Hash) chainhash.Hash {
+	return chainhash.DoubleHashH(in[:]) // left is sha(sha(in))
 }
-func RightSha(in wire.ShaHash) wire.ShaHash {
-	return wire.DoubleSha256SH(append(in.Bytes(), 0x01)) // sha(sha(in, 1))
+func RightSha(in chainhash.Hash) chainhash.Hash {
+	return chainhash.DoubleHashH(append(in[:], 0x01)) // sha(sha(in, 1))
 }

 // iterative descent of sub-tree. w = hash number you want. i = input index
 // h = height of input index. sha = input hash
-func descend(w, i uint64, h uint8, sha wire.ShaHash) (wire.ShaHash, error) {
+func descend(w, i uint64, h uint8, sha chainhash.Hash) (chainhash.Hash, error) {
 	for w < i {
 		if w <= i-(1<<h) { // left
 			sha = LeftSha(sha)
@ -80,7 +80,7 @@ func descend(w, i uint64, h uint8, sha wire.ShaHash) (wire.ShaHash, error) {
 }

 // Creates an Elkrem Sender from a root hash.
-func NewElkremSender(r wire.ShaHash) *ElkremSender {
+func NewElkremSender(r chainhash.Hash) *ElkremSender {
 	var e ElkremSender
 	e.root = &r
 	return &e
@ -88,14 +88,14 @@ func NewElkremSender(r wire.ShaHash) *ElkremSender {

 // AtIndex skips to the requested index
 // should never error; remove error..?
-func (e *ElkremSender) AtIndex(w uint64) (*wire.ShaHash, error) {
+func (e *ElkremSender) AtIndex(w uint64) (*chainhash.Hash, error) {
 	out, err := descend(w, maxIndex, maxHeight, *e.root)
 	return &out, err
 }

 // AddNext inserts the next hash in the tree.  Returns an error if
 // the incoming hash doesn't fit.
-func (e *ElkremReceiver) AddNext(sha *wire.ShaHash) error {
+func (e *ElkremReceiver) AddNext(sha *chainhash.Hash) error {
 	// note: careful about atomicity / disk writes here
 	var n ElkremNode
 	n.sha = sha
@ -123,7 +123,7 @@ func (e *ElkremReceiver) AddNext(sha *wire.ShaHash) error {
 }

 // AtIndex returns the w'th hash in the receiver.
-func (e *ElkremReceiver) AtIndex(w uint64) (*wire.ShaHash, error) {
+func (e *ElkremReceiver) AtIndex(w uint64) (*chainhash.Hash, error) {
 	if e == nil || e.s == nil {
 		return nil, fmt.Errorf("nil elkrem receiver")
 	}
--- a/elkrem/elkrem_test.go
+++ b/elkrem/elkrem_test.go
@ -3,14 +3,14 @@ package elkrem
 import (
 	"testing"

-	"github.com/roasbeef/btcd/wire"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 )

 // TestElkremBig tries 10K hashes
 func TestElkremBig(t *testing.T) {
 	var rcv ElkremReceiver

-	sndr := NewElkremSender(wire.DoubleSha256SH([]byte("elktest")))
+	sndr := NewElkremSender(chainhash.DoubleHashH([]byte("elktest")))

 	for n := uint64(0); n < 10000; n++ {
 		sha, err := sndr.AtIndex(n)
@ -36,7 +36,7 @@ func TestElkremBig(t *testing.T) {
 func TestElkremLess(t *testing.T) {
 	var rcv ElkremReceiver

-	sndr := NewElkremSender(wire.DoubleSha256SH([]byte("elktest2")))
+	sndr := NewElkremSender(chainhash.DoubleHashH([]byte("elktest2")))

 	for n := uint64(0); n < 5000; n++ {
 		sha, err := sndr.AtIndex(n)
--- a/elkrem/serdes.go
+++ b/elkrem/serdes.go
@ -5,7 +5,7 @@ import (
 	"encoding/binary"
 	"fmt"

-	"github.com/roasbeef/btcd/wire"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 )

 /* Serialization and Deserialization methods for the Elkrem structs.
@ -49,7 +49,7 @@ func (e *ElkremReceiver) ToBytes() ([]byte, error) {
 			return nil, fmt.Errorf("node %d has nil hash", node.i)
 		}
 		// write 32 byte sha hash
-		n, err := buf.Write(node.sha.Bytes())
+		n, err := buf.Write(node.sha[:])
 		if err != nil {
 			return nil, err
 		}
@ -86,7 +86,7 @@ func ElkremReceiverFromBytes(b []byte) (*ElkremReceiver, error) {
 	e.s = make([]ElkremNode, numOfNodes)

 	for j, _ := range e.s {
-		e.s[j].sha = new(wire.ShaHash)
+		e.s[j].sha = new(chainhash.Hash)
 		// read 1 byte height
 		err := binary.Read(buf, binary.BigEndian, &e.s[j].h)
 		if err != nil {
--- a/fundingmanager.go
+++ b/fundingmanager.go
@ -12,6 +12,7 @@ import (
 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/roasbeef/btcd/btcec"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/txscript"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
@ -331,7 +332,7 @@ func (f *fundingManager) handleFundingRequest(fmsg *fundingRequestMsg) {
 	if len(f.activeReservations[fmsg.peer.id]) >= cfg.MaxPendingChannels {
 		errMsg := &lnwire.ErrorGeneric{
 			ChannelPoint: &wire.OutPoint{
-				Hash:  wire.ShaHash{},
+				Hash:  chainhash.Hash{},
 				Index: 0,
 			},
 			Problem:          "Number of pending channels exceed maximum",
--- a/htlcswitch.go
+++ b/htlcswitch.go
@ -14,6 +14,7 @@ import (
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/roasbeef/btcd/btcec"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
 	"golang.org/x/crypto/ripemd160"
@ -48,7 +49,7 @@ type link struct {
 type htlcPacket struct {
 	sync.RWMutex

-	dest wire.ShaHash
+	dest chainhash.Hash

 	index   uint32
 	srcLink wire.OutPoint
@ -120,7 +121,7 @@ type htlcSwitch struct {
 	// currently have open with that peer.
 	// TODO(roasbeef): combine w/ onionIndex?
 	interfaceMtx sync.RWMutex
-	interfaces   map[wire.ShaHash][]*link
+	interfaces   map[chainhash.Hash][]*link

 	// onionIndex is an index used to properly forward a message
 	// to the next hop within a Sphinx circuit. Within the sphinx packets,
@ -159,7 +160,7 @@ type htlcSwitch struct {
 func newHtlcSwitch() *htlcSwitch {
 	return &htlcSwitch{
 		chanIndex:        make(map[wire.OutPoint]*link),
-		interfaces:       make(map[wire.ShaHash][]*link),
+		interfaces:       make(map[chainhash.Hash][]*link),
 		onionIndex:       make(map[[ripemd160.Size]byte][]*link),
 		paymentCircuits:  make(map[circuitKey]*paymentCircuit),
 		linkControl:      make(chan interface{}),
--- a/invoiceregistry.go
+++ b/invoiceregistry.go
@ -8,7 +8,7 @@ import (
 	"github.com/btcsuite/fastsha256"
 	"github.com/davecgh/go-spew/spew"
 	"github.com/lightningnetwork/lnd/channeldb"
-	"github.com/roasbeef/btcd/wire"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcutil"
 )

@ -18,9 +18,9 @@ var (
 	// All nodes initialize with the flag active will immediately settle
 	// any incoming HTLC whose rHash is corresponds with the debug
 	// preimage.
-	debugPre, _ = wire.NewShaHash(bytes.Repeat([]byte{1}, 32))
+	debugPre, _ = chainhash.NewHash(bytes.Repeat([]byte{1}, 32))

-	debugHash = wire.ShaHash(fastsha256.Sum256(debugPre[:]))
+	debugHash = chainhash.Hash(fastsha256.Sum256(debugPre[:]))
 )

 // invoiceRegistry is a central registry of all the outstanding invoices
@ -38,7 +38,7 @@ type invoiceRegistry struct {
 	// debugInvoices is a mp which stores special "debug" invoices which
 	// should be only created/used when manual tests require an invoice
 	// that *all* nodes are able to fully settle.
-	debugInvoices map[wire.ShaHash]*channeldb.Invoice
+	debugInvoices map[chainhash.Hash]*channeldb.Invoice
 }

 // newInvoiceRegistry creates a new invoice registry. The invoice registry
@ -48,7 +48,7 @@ type invoiceRegistry struct {
 func newInvoiceRegistry(cdb *channeldb.DB) *invoiceRegistry {
 	return &invoiceRegistry{
 		cdb:                 cdb,
-		debugInvoices:       make(map[wire.ShaHash]*channeldb.Invoice),
+		debugInvoices:       make(map[chainhash.Hash]*channeldb.Invoice),
 		notificationClients: make(map[uint32]*invoiceSubscription),
 	}
 }
@ -57,8 +57,8 @@ func newInvoiceRegistry(cdb *channeldb.DB) *invoiceRegistry {
 // by the passed preimage. Once this invoice is added, sub-systems within the
 // daemon add/forward HTLC's are able to obtain the proper preimage required
 // for redemption in the case that we're the final destination.
-func (i *invoiceRegistry) AddDebugInvoice(amt btcutil.Amount, preimage wire.ShaHash) {
-	paymentHash := wire.ShaHash(fastsha256.Sum256(preimage[:]))
+func (i *invoiceRegistry) AddDebugInvoice(amt btcutil.Amount, preimage chainhash.Hash) {
+	paymentHash := chainhash.Hash(fastsha256.Sum256(preimage[:]))

 	invoice := &channeldb.Invoice{
 		CreationDate: time.Now(),
@ -101,7 +101,7 @@ func (i *invoiceRegistry) AddInvoice(invoice *channeldb.Invoice) error {
 // lookupInvoice looks up an invoice by it's payment hash (R-Hash), if found
 // then we're able to pull the funds pending within an HTLC.
 // TODO(roasbeef): ignore if settled?
-func (i *invoiceRegistry) LookupInvoice(rHash wire.ShaHash) (*channeldb.Invoice, error) {
+func (i *invoiceRegistry) LookupInvoice(rHash chainhash.Hash) (*channeldb.Invoice, error) {
 	// First check the in-memory debug invoice index to see if this is an
 	// existing invoice added for debugging.
 	i.RLock()
@ -121,7 +121,7 @@ func (i *invoiceRegistry) LookupInvoice(rHash wire.ShaHash) (*channeldb.Invoice,
 // SettleInvoice attempts to mark an invoice as settled. If the invoice is a
 // dbueg invoice, then this method is a nooop as debug invoices are never fully
 // settled.
-func (i *invoiceRegistry) SettleInvoice(rHash wire.ShaHash) error {
+func (i *invoiceRegistry) SettleInvoice(rHash chainhash.Hash) error {
 	ltndLog.Debugf("Settling invoice %x", rHash[:])

 	// First check the in-memory debug invoice index to see if this is an
--- a/lnd_test.go
+++ b/lnd_test.go
@ -20,6 +20,8 @@ import (
 	"github.com/go-errors/errors"
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/roasbeef/btcd/chaincfg"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/rpctest"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcrpcclient"
@ -89,9 +91,9 @@ func (h *harnessTest) Log(args ...interface{}) {
 	h.t.Log(args...)
 }

-func assertTxInBlock(t *harnessTest, block *wire.MsgBlock, txid *wire.ShaHash) {
+func assertTxInBlock(t *harnessTest, block *wire.MsgBlock, txid *chainhash.Hash) {
 	for _, tx := range block.Transactions {
-		sha := tx.TxSha()
+		sha := tx.TxHash()
 		if bytes.Equal(txid[:], sha[:]) {
 			return
 		}
@ -144,7 +146,7 @@ func openChannelAndAssert(t *harnessTest, net *networkHarness, ctx context.Conte
 	if err != nil {
 		t.Fatalf("error while waiting for channel open: %v", err)
 	}
-	fundingTxID, err := wire.NewShaHash(fundingChanPoint.FundingTxid)
+	fundingTxID, err := chainhash.NewHash(fundingChanPoint.FundingTxid)
 	if err != nil {
 		t.Fatalf("unable to create sha hash: %v", err)
 	}
@ -170,7 +172,7 @@ func openChannelAndAssert(t *harnessTest, net *networkHarness, ctx context.Conte
 // detected as closed, an assertion checks that the transaction is found within
 // a block.
 func closeChannelAndAssert(t *harnessTest, net *networkHarness, ctx context.Context,
-	node *lightningNode, fundingChanPoint *lnrpc.ChannelPoint, force bool) *wire.ShaHash {
+	node *lightningNode, fundingChanPoint *lnrpc.ChannelPoint, force bool) *chainhash.Hash {

 	closeUpdates, _, err := net.CloseChannel(ctx, node, fundingChanPoint, force)
 	if err != nil {
@ -371,8 +373,8 @@ func testChannelForceClosure(net *networkHarness, t *harnessTest) {
 	// At this point, the sweeping transaction should now be broadcast. So
 	// we fetch the node's mempool to ensure it has been properly
 	// broadcast.
-	var sweepingTXID *wire.ShaHash
-	var mempool []*wire.ShaHash
+	var sweepingTXID *chainhash.Hash
+	var mempool []*chainhash.Hash
 	mempoolTimeout := time.After(3 * time.Second)
 	checkMempoolTick := time.Tick(100 * time.Millisecond)
 mempoolPoll:
@ -427,7 +429,7 @@ mempoolPoll:
 		t.Fatalf("unable to get block: %v", err)
 	}

-	assertTxInBlock(t, block, sweepTx.Sha())
+	assertTxInBlock(t, block, sweepTx.Hash())
 }

 func testSingleHopInvoice(net *networkHarness, t *harnessTest) {
@ -672,7 +674,7 @@ func testMultiHopPayments(net *networkHarness, t *harnessTest) {
 	chanPointAlice := openChannelAndAssert(t, net, ctxt, net.Alice,
 		net.Bob, chanAmt)

-	aliceChanTXID, err := wire.NewShaHash(chanPointAlice.FundingTxid)
+	aliceChanTXID, err := chainhash.NewHash(chanPointAlice.FundingTxid)
 	if err != nil {
 		t.Fatalf("unable to create sha hash: %v", err)
 	}
@ -701,7 +703,7 @@ func testMultiHopPayments(net *networkHarness, t *harnessTest) {
 	chanPointCarol := openChannelAndAssert(t, net, ctxt, carol,
 		net.Alice, chanAmt)

-	carolChanTXID, err := wire.NewShaHash(chanPointCarol.FundingTxid)
+	carolChanTXID, err := chainhash.NewHash(chanPointCarol.FundingTxid)
 	if err != nil {
 		t.Fatalf("unable to create sha hash: %v", err)
 	}
@ -1079,7 +1081,7 @@ func testMaxPendingChannels(net *networkHarness, t *harnessTest) {
 			t.Fatalf("error while waiting for channel open: %v", err)
 		}

-		fundingTxID, err := wire.NewShaHash(fundingChanPoint.FundingTxid)
+		fundingTxID, err := chainhash.NewHash(fundingChanPoint.FundingTxid)
 		if err != nil {
 			t.Fatalf("unable to create sha hash: %v", err)
 		}
@ -1282,7 +1284,7 @@ func testRevokedCloseRetribution(net *networkHarness, t *harnessTest) {
 	// Query the mempool for Alice's justice transaction, this should be
 	// broadcast as Bob's contract breaching transaction gets confirmed
 	// above.
-	var justiceTXID *wire.ShaHash
+	var justiceTXID *chainhash.Hash
 	breakTimeout := time.After(time.Second * 5)
 poll:
 	for {
@ -1328,8 +1330,8 @@ poll:
 	if len(block.Transactions) != 2 {
 		t.Fatalf("transaction wasn't mined")
 	}
-	justiceSha := block.Transactions[1].TxSha()
-	if !bytes.Equal(justiceTx.Sha()[:], justiceSha[:]) {
+	justiceSha := block.Transactions[1].TxHash()
+	if !bytes.Equal(justiceTx.Hash()[:], justiceSha[:]) {
 		t.Fatalf("justice tx wasn't mined")
 	}

--- a/lnwallet/btcwallet/blockchain.go
+++ b/lnwallet/btcwallet/blockchain.go
@ -5,6 +5,7 @@ import (
 	"errors"

 	"github.com/lightningnetwork/lnd/lnwallet"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/wire"
 )

@ -18,14 +19,14 @@ var (
 // within the main chain.
 //
 // This method is a part of the lnwallet.BlockChainIO interface.
-func (b *BtcWallet) GetBestBlock() (*wire.ShaHash, int32, error) {
+func (b *BtcWallet) GetBestBlock() (*chainhash.Hash, int32, error) {
 	return b.rpc.GetBestBlock()
 }

 // GetTxOut returns the original output referenced by the passed outpoint.
 //
 // This method is a part of the lnwallet.BlockChainIO interface.
-func (b *BtcWallet) GetUtxo(txid *wire.ShaHash, index uint32) (*wire.TxOut, error) {
+func (b *BtcWallet) GetUtxo(txid *chainhash.Hash, index uint32) (*wire.TxOut, error) {
 	txout, err := b.rpc.GetTxOut(txid, index, false)
 	if err != nil {
 		return nil, err
@ -50,7 +51,7 @@ func (b *BtcWallet) GetUtxo(txid *wire.ShaHash, index uint32) (*wire.TxOut, erro
 // transaction ID.
 //
 // This method is a part of the lnwallet.BlockChainIO interface.
-func (b *BtcWallet) GetTransaction(txid *wire.ShaHash) (*wire.MsgTx, error) {
+func (b *BtcWallet) GetTransaction(txid *chainhash.Hash) (*wire.MsgTx, error) {
 	tx, err := b.rpc.GetRawTransaction(txid)
 	if err != nil {
 		return nil, err
@ -62,7 +63,7 @@ func (b *BtcWallet) GetTransaction(txid *wire.ShaHash) (*wire.MsgTx, error) {
 // GetBlock returns a raw block from the server given its hash.
 //
 // This method is a part of the lnwallet.BlockChainIO interface.
-func (b *BtcWallet) GetBlock(blockHash *wire.ShaHash) (*wire.MsgBlock, error) {
+func (b *BtcWallet) GetBlock(blockHash *chainhash.Hash) (*wire.MsgBlock, error) {
 	block, err := b.rpc.GetBlock(blockHash)
 	if err != nil {
 		return nil, err
@ -75,7 +76,7 @@ func (b *BtcWallet) GetBlock(blockHash *wire.ShaHash) (*wire.MsgBlock, error) {
 // given height.
 //
 // This method is a part of the lnwallet.BlockChainIO interface.
-func (b *BtcWallet) GetBlockHash(blockHeight int64) (*wire.ShaHash, error) {
+func (b *BtcWallet) GetBlockHash(blockHeight int64) (*chainhash.Hash, error) {
 	blockHash, err := b.rpc.GetBlockHash(blockHeight)
 	if err != nil {
 		return nil, err
--- a/lnwallet/btcwallet/btcwallet.go
+++ b/lnwallet/btcwallet/btcwallet.go
@ -11,6 +11,7 @@ import (
 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/roasbeef/btcd/btcec"
 	"github.com/roasbeef/btcd/chaincfg"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/txscript"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
@ -308,7 +309,7 @@ func (b *BtcWallet) FetchRootKey() (*btcec.PrivateKey, error) {
 // outputs are non-standard, a non-nil error will be be returned.
 //
 // This is a part of the WalletController interface.
-func (b *BtcWallet) SendOutputs(outputs []*wire.TxOut) (*wire.ShaHash, error) {
+func (b *BtcWallet) SendOutputs(outputs []*wire.TxOut) (*chainhash.Hash, error) {
 	return b.wallet.SendOutputs(outputs, defaultAccount, 1)
 }

@ -355,7 +356,7 @@ func (b *BtcWallet) ListUnspentWitness(minConfs int32) ([]*lnwallet.Utxo, error)
 		// the wallet are nested p2sh...
 		if txscript.IsPayToWitnessPubKeyHash(pkScript) ||
 			txscript.IsPayToScriptHash(pkScript) {
-			txid, err := wire.NewShaHashFromStr(output.TxID)
+			txid, err := chainhash.NewHashFromStr(output.TxID)
 			if err != nil {
 				return nil, err
 			}
@ -384,7 +385,7 @@ func (b *BtcWallet) PublishTransaction(tx *wire.MsgTx) error {
 // extractBalanceDelta extracts the net balance delta from the PoV of the
 // wallet given a TransactionSummary.
 func extractBalanceDelta(txSummary base.TransactionSummary) (btcutil.Amount, error) {
-	tx := wire.NewMsgTx()
+	tx := wire.NewMsgTx(1)
 	txReader := bytes.NewReader(txSummary.Transaction)
 	if err := tx.Deserialize(txReader); err != nil {
 		return -1, nil
--- a/lnwallet/channel.go
+++ b/lnwallet/channel.go
@ -11,6 +11,7 @@ import (
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"

 	"github.com/roasbeef/btcd/btcec"
 	"github.com/roasbeef/btcd/txscript"
@ -19,7 +20,7 @@ import (
 	"github.com/roasbeef/btcutil/txsort"
 )

-var zeroHash wire.ShaHash
+var zeroHash chainhash.Hash

 var (
 	ErrChanClosing = fmt.Errorf("channel is being closed, operation disallowed")
@ -584,7 +585,7 @@ type BreachRetribution struct {
 func newBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 	broadcastCommitment *wire.MsgTx) (*BreachRetribution, error) {

-	commitHash := broadcastCommitment.TxSha()
+	commitHash := broadcastCommitment.TxHash()

 	// Query the on-disk revocation log for the snapshot which was recorded
 	// at this particular state num.
@ -1408,7 +1409,7 @@ func (lc *LightningChannel) ReceiveRevocation(revMsg *lnwire.CommitRevocation) (

 	ourCommitKey := lc.channelState.OurCommitKey
 	currentRevocationKey := lc.channelState.TheirCurrentRevocation
-	pendingRevocation := wire.ShaHash(revMsg.Revocation)
+	pendingRevocation := chainhash.Hash(revMsg.Revocation)

 	// Ensure the new pre-image fits in properly within the elkrem receiver
 	// tree. If this fails, then all other checks are skipped.
@ -1929,7 +1930,7 @@ func (lc *LightningChannel) ForceClose() (*ForceCloseSummary, error) {
 	return &ForceCloseSummary{
 		CloseTx: commitTx,
 		SelfOutpoint: wire.OutPoint{
-			Hash:  commitTx.TxSha(),
+			Hash:  commitTx.TxHash(),
 			Index: delayIndex,
 		},
 		SelfOutputMaturity: csvTimeout,
@ -1951,7 +1952,7 @@ func (lc *LightningChannel) ForceClose() (*ForceCloseSummary, error) {
 //
 // TODO(roasbeef): caller should initiate signal to reject all incoming HTLCs,
 // settle any inflight.
-func (lc *LightningChannel) InitCooperativeClose() ([]byte, *wire.ShaHash, error) {
+func (lc *LightningChannel) InitCooperativeClose() ([]byte, *chainhash.Hash, error) {
 	lc.Lock()
 	defer lc.Unlock()

@ -1969,7 +1970,7 @@ func (lc *LightningChannel) InitCooperativeClose() ([]byte, *wire.ShaHash, error
 		lc.channelState.OurBalance, lc.channelState.TheirBalance,
 		lc.channelState.OurDeliveryScript, lc.channelState.TheirDeliveryScript,
 		lc.channelState.IsInitiator)
-	closeTxSha := closeTx.TxSha()
+	closeTxSha := closeTx.TxHash()

 	// Finally, sign the completed cooperative closure transaction. As the
 	// initiator we'll simply send our signature over the the remote party,
@ -2095,8 +2096,7 @@ func CreateCommitTx(fundingOutput *wire.TxIn, selfKey, theirKey *btcec.PublicKey
 	// Now that both output scripts have been created, we can finally create
 	// the transaction itself. We use a transaction version of 2 since CSV
 	// will fail unless the tx version is >= 2.
-	commitTx := wire.NewMsgTx()
-	commitTx.Version = 2
+	commitTx := wire.NewMsgTx(2)
 	commitTx.AddTxIn(fundingOutput)

 	// Avoid creating zero value outputs within the commitment transaction.
@ -2125,7 +2125,7 @@ func CreateCooperativeCloseTx(fundingTxIn *wire.TxIn,
 	// channel. In the event that one side doesn't have any settled funds
 	// within the channel then a refund output for that particular side can
 	// be omitted.
-	closeTx := wire.NewMsgTx()
+	closeTx := wire.NewMsgTx(2)
 	closeTx.AddTxIn(fundingTxIn)

 	// The initiator the a cooperative closure pays the fee in entirety.
--- a/lnwallet/channel_test.go
+++ b/lnwallet/channel_test.go
@ -16,6 +16,7 @@ import (
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/roasbeef/btcd/blockchain"
 	"github.com/roasbeef/btcd/btcec"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/txscript"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
@ -87,7 +88,7 @@ func (m *mockSigner) ComputeInputScript(tx *wire.MsgTx, signDesc *SignDescriptor
 type mockNotfier struct {
 }

-func (m *mockNotfier) RegisterConfirmationsNtfn(txid *wire.ShaHash, numConfs uint32) (*chainntnfs.ConfirmationEvent, error) {
+func (m *mockNotfier) RegisterConfirmationsNtfn(txid *chainhash.Hash, numConfs uint32) (*chainntnfs.ConfirmationEvent, error) {
 	return nil, nil
 }
 func (m *mockNotfier) RegisterBlockEpochNtfn() (*chainntnfs.BlockEpochEvent, error) {
@ -199,7 +200,7 @@ func createTestChannels(revocationWindow int) (*LightningChannel, *LightningChan
 	}

 	prevOut := &wire.OutPoint{
-		Hash:  wire.ShaHash(testHdSeed),
+		Hash:  chainhash.Hash(testHdSeed),
 		Index: 0,
 	}
 	fundingTxIn := wire.NewTxIn(prevOut, nil, nil)
@ -614,7 +615,7 @@ func TestCheckCommitTxSize(t *testing.T) {
 			t.Fatalf("unable to initiate alice force close: %v", err)
 		}

-		actualCost := blockchain.GetMsgTxCost(commitTx)
+		actualCost := blockchain.GetTransactionWeight(btcutil.NewTx(commitTx))
 		estimatedCost := estimateCommitTxCost(count, false)

 		diff := int(estimatedCost - actualCost)
@ -709,7 +710,7 @@ func TestCooperativeChannelClosure(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unable to complete alice cooperative close: %v", err)
 	}
-	bobCloseSha := closeTx.TxSha()
+	bobCloseSha := closeTx.TxHash()
 	if !bobCloseSha.IsEqual(txid) {
 		t.Fatalf("alice's transactions doesn't match: %x vs %x",
 			bobCloseSha[:], txid[:])
@ -729,7 +730,7 @@ func TestCooperativeChannelClosure(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unable to complete bob cooperative close: %v", err)
 	}
-	aliceCloseSha := closeTx.TxSha()
+	aliceCloseSha := closeTx.TxHash()
 	if !aliceCloseSha.IsEqual(txid) {
 		t.Fatalf("bob's closure transactions don't match: %x vs %x",
 			aliceCloseSha[:], txid[:])
--- a/lnwallet/interface.go
+++ b/lnwallet/interface.go
@ -6,6 +6,7 @@ import (
 	"sync"

 	"github.com/roasbeef/btcd/btcec"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/txscript"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
@ -42,7 +43,7 @@ type Utxo struct {
 // the wallet, or has outputs that pay to the wallet.
 type TransactionDetail struct {
 	// Hash is the transaction hash of the transaction.
-	Hash wire.ShaHash
+	Hash chainhash.Hash

 	// Value is the net value of this transaction (in satoshis) from the
 	// PoV of the wallet. If this transaction purely spends from the
@ -58,7 +59,7 @@ type TransactionDetail struct {
 	// BlockHeight is the hash of the block which includes this
 	// transaction. Unconfirmed transactions will have a nil value for this
 	// field.
-	BlockHash *wire.ShaHash
+	BlockHash *chainhash.Hash

 	// BlockHeight is the height of the block including this transaction.
 	// Unconfirmed transaction will show a height of zero.
@ -142,7 +143,7 @@ type WalletController interface {
 	// paying out to the specified outputs. In the case the wallet has
 	// insufficient funds, or the outputs are non-standard, an error
 	// should be returned.
-	SendOutputs(outputs []*wire.TxOut) (*wire.ShaHash, error)
+	SendOutputs(outputs []*wire.TxOut) (*chainhash.Hash, error)

 	// ListUnspentWitness returns all unspent outputs which are version 0
 	// witness programs. The 'confirms' parameter indicates the minimum
@ -203,23 +204,23 @@ type WalletController interface {
 type BlockChainIO interface {
 	// GetBestBlock returns the current height and block hash of the valid
 	// most-work chain the implementation is aware of.
-	GetBestBlock() (*wire.ShaHash, int32, error)
+	GetBestBlock() (*chainhash.Hash, int32, error)

 	// GetTxOut returns the original output referenced by the passed
 	// outpoint.
-	GetUtxo(txid *wire.ShaHash, index uint32) (*wire.TxOut, error)
+	GetUtxo(txid *chainhash.Hash, index uint32) (*wire.TxOut, error)

 	// GetTransaction returns the full transaction identified by the passed
 	// transaction ID.
-	GetTransaction(txid *wire.ShaHash) (*wire.MsgTx, error)
+	GetTransaction(txid *chainhash.Hash) (*wire.MsgTx, error)

 	// GetBlockHash returns the hash of the block in the best block chain
 	// at the given height.
-	GetBlockHash(blockHeight int64) (*wire.ShaHash, error)
+	GetBlockHash(blockHeight int64) (*chainhash.Hash, error)

 	// GetBlock returns the block in the main chain identified by the given
 	// hash.
-	GetBlock(blockHash *wire.ShaHash) (*wire.MsgBlock, error)
+	GetBlock(blockHash *chainhash.Hash) (*wire.MsgBlock, error)
 }

 // SignDescriptor houses the necessary information required to successfully sign
--- a/lnwallet/interface_test.go
+++ b/lnwallet/interface_test.go
@ -18,6 +18,7 @@ import (
 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/lnwallet/btcwallet"
 	"github.com/roasbeef/btcd/chaincfg"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcutil/txsort"
 	_ "github.com/roasbeef/btcwallet/walletdb/bdb"

@ -209,7 +210,7 @@ func newBobNode(miner *rpctest.Harness, amt btcutil.Amount) (*bobNode, error) {

 	// Give bobNode one 7 BTC output for use in creating channels.
 	output := &wire.TxOut{7e8, bobAddrScript}
-	mainTxid, err := miner.CoinbaseSpend([]*wire.TxOut{output})
+	mainTxid, err := miner.SendOutputs([]*wire.TxOut{output}, 10)
 	if err != nil {
 		return nil, err
 	}
@ -247,7 +248,7 @@ func newBobNode(miner *rpctest.Harness, amt btcutil.Amount) (*bobNode, error) {
 	copy(obsfucator[:], revocation[:])

 	// His ID is just as creative...
-	var id [wire.HashSize]byte
+	var id [chainhash.HashSize]byte
 	id[0] = 0xff

 	return &bobNode{
@ -283,7 +284,7 @@ func loadTestCredits(miner *rpctest.Harness, w *lnwallet.LightningWallet, numOut
 		addrs = append(addrs, walletAddr)

 		output := &wire.TxOut{satoshiPerOutput, script}
-		if _, err := miner.CoinbaseSpend([]*wire.TxOut{output}); err != nil {
+		if _, err := miner.SendOutputs([]*wire.TxOut{output}, 10); err != nil {
 			return err
 		}
 	}
@ -466,7 +467,7 @@ func testDualFundingReservationWorkflow(miner *rpctest.Harness, wallet *lnwallet
 	// txn hits a "comfortable" depth.

 	// The resulting active channel state should have been persisted to the DB.
-	fundingSha := fundingTx.TxSha()
+	fundingSha := fundingTx.TxHash()
 	channels, err := wallet.ChannelDB.FetchOpenChannels(bobNode.id)
 	if err != nil {
 		t.Fatalf("unable to retrieve channel from DB: %v", err)
@ -732,7 +733,7 @@ func testSingleFunderReservationWorkflowInitiator(miner *rpctest.Harness,
 	// The resulting active channel state should have been persisted to the DB.
 	// TODO(roasbeef): de-duplicate
 	fundingTx := chanReservation.FinalFundingTx()
-	fundingSha := fundingTx.TxSha()
+	fundingSha := fundingTx.TxHash()
 	channels, err := wallet.ChannelDB.FetchOpenChannels(bobNode.id)
 	if err != nil {
 		t.Fatalf("unable to retrieve channel from DB: %v", err)
@ -854,7 +855,7 @@ func testSingleFunderReservationWorkflowResponder(miner *rpctest.Harness,
 	// At this point, we send Bob our contribution, allowing him to
 	// construct the funding transaction, and sign our version of the
 	// commitment transaction.
-	fundingTx := wire.NewMsgTx()
+	fundingTx := wire.NewMsgTx(1)
 	fundingTx.AddTxIn(bobNode.availableOutputs[0])
 	fundingTx.AddTxOut(bobNode.changeOutputs[0])
 	fundingTx.AddTxOut(multiOut)
@ -866,7 +867,7 @@ func testSingleFunderReservationWorkflowResponder(miner *rpctest.Harness,
 	// Locate the output index of the 2-of-2 in order to send back to the
 	// wallet so it can finalize the transaction by signing bob's commitment
 	// transaction.
-	fundingTxID := fundingTx.TxSha()
+	fundingTxID := fundingTx.TxHash()
 	_, multiSigIndex := lnwallet.FindScriptOutputIndex(fundingTx, multiOut.PkScript)
 	fundingOutpoint := wire.NewOutPoint(&fundingTxID, multiSigIndex)
 	bobObsfucator := bobNode.obsfucator
@ -923,7 +924,7 @@ func testListTransactionDetails(miner *rpctest.Harness, wallet *lnwallet.Lightni
 	// Create 5 new outputs spendable by the wallet.
 	const numTxns = 5
 	const outputAmt = btcutil.SatoshiPerBitcoin
-	txids := make(map[wire.ShaHash]struct{})
+	txids := make(map[chainhash.Hash]struct{})
 	for i := 0; i < numTxns; i++ {
 		addr, err := wallet.NewAddress(lnwallet.WitnessPubKey, false)
 		if err != nil {
@ -935,7 +936,7 @@ func testListTransactionDetails(miner *rpctest.Harness, wallet *lnwallet.Lightni
 		}

 		output := &wire.TxOut{outputAmt, script}
-		txid, err := miner.CoinbaseSpend([]*wire.TxOut{output})
+		txid, err := miner.SendOutputs([]*wire.TxOut{output}, 10)
 		if err != nil {
 			t.Fatalf("unable to send coinbase: %v", err)
 		}
@ -1083,7 +1084,7 @@ func testTransactionSubscriptions(miner *rpctest.Harness, w *lnwallet.LightningW
 		}

 		output := &wire.TxOut{outputAmt, script}
-		if _, err := miner.CoinbaseSpend([]*wire.TxOut{output}); err != nil {
+		if _, err := miner.SendOutputs([]*wire.TxOut{output}, 10); err != nil {
 			t.Fatalf("unable to send coinbase: %v", err)
 		}
 	}
@ -1183,10 +1184,10 @@ func testSignOutputPrivateTweak(r *rpctest.Harness, w *lnwallet.LightningWallet,

 	/// WIth the index located, we can create a transaction spending the
 	//referenced output.
-	sweepTx := wire.NewMsgTx()
+	sweepTx := wire.NewMsgTx(2)
 	sweepTx.AddTxIn(&wire.TxIn{
 		PreviousOutPoint: wire.OutPoint{
-			Hash:  tx.TxSha(),
+			Hash:  tx.TxHash(),
 			Index: outputIndex,
 		},
 	})
--- a/lnwallet/script_utils.go
+++ b/lnwallet/script_utils.go
@ -11,6 +11,7 @@ import (

 	"github.com/btcsuite/fastsha256"
 	"github.com/roasbeef/btcd/btcec"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/txscript"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
@ -749,7 +750,7 @@ func DeriveRevocationPrivKey(commitPrivKey *btcec.PrivateKey,
 // [2]: https://tools.ietf.org/html/rfc5869
 func deriveElkremRoot(elkremDerivationRoot *btcec.PrivateKey,
 	localMultiSigKey *btcec.PublicKey,
-	remoteMultiSigKey *btcec.PublicKey) wire.ShaHash {
+	remoteMultiSigKey *btcec.PublicKey) chainhash.Hash {

 	secret := elkremDerivationRoot.Serialize()
 	salt := localMultiSigKey.SerializeCompressed()
@ -760,7 +761,7 @@ func deriveElkremRoot(elkremDerivationRoot *btcec.PrivateKey,
 	// It's safe to ignore the error her as we know for sure that we won't
 	// be draining the HKDF past its available entropy horizon.
 	// TODO(roasbeef): revisit...
-	var elkremRoot wire.ShaHash
+	var elkremRoot chainhash.Hash
 	rootReader.Read(elkremRoot[:])

 	return elkremRoot
--- a/lnwallet/script_utils_test.go
+++ b/lnwallet/script_utils_test.go
@ -67,9 +67,8 @@ func TestCommitmentSpendValidation(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unable to create target output: %v")
 	}
-	sweepTx := wire.NewMsgTx()
-	sweepTx.Version = 2
-	sweepTx.AddTxIn(wire.NewTxIn(&wire.OutPoint{commitmentTx.TxSha(), 0}, nil, nil))
+	sweepTx := wire.NewMsgTx(2)
+	sweepTx.AddTxIn(wire.NewTxIn(&wire.OutPoint{commitmentTx.TxHash(), 0}, nil, nil))
 	sweepTx.AddTxOut(&wire.TxOut{
 		PkScript: targetOutput,
 		Value:    0.5 * 10e8,
@ -267,7 +266,7 @@ func TestHTLCSenderSpendValidation(t *testing.T) {
 	// This will be Alice's commitment transaction. In this scenario Alice
 	// is sending an HTLC to a node she has a a path to (could be Bob,
 	// could be multiple hops down, it doesn't really matter).
-	senderCommitTx := wire.NewMsgTx()
+	senderCommitTx := wire.NewMsgTx(2)
 	senderCommitTx.AddTxIn(fakeFundingTxIn)
 	senderCommitTx.AddTxOut(&wire.TxOut{
 		Value:    int64(paymentAmt),
@ -275,11 +274,11 @@ func TestHTLCSenderSpendValidation(t *testing.T) {
 	})

 	prevOut := &wire.OutPoint{
-		Hash:  senderCommitTx.TxSha(),
+		Hash:  senderCommitTx.TxHash(),
 		Index: 0,
 	}

-	sweepTx := wire.NewMsgTx()
+	sweepTx := wire.NewMsgTx(2)
 	sweepTx.AddTxIn(wire.NewTxIn(prevOut, nil, nil))
 	sweepTx.AddTxOut(
 		&wire.TxOut{
@ -439,7 +438,7 @@ func TestHTLCReceiverSpendValidation(t *testing.T) {
 	// This will be Bob's commitment transaction. In this scenario Alice
 	// is sending an HTLC to a node she has a a path to (could be Bob,
 	// could be multiple hops down, it doesn't really matter).
-	recieverCommitTx := wire.NewMsgTx()
+	recieverCommitTx := wire.NewMsgTx(2)
 	recieverCommitTx.AddTxIn(fakeFundingTxIn)
 	recieverCommitTx.AddTxOut(&wire.TxOut{
 		Value:    int64(paymentAmt),
@ -447,11 +446,11 @@ func TestHTLCReceiverSpendValidation(t *testing.T) {
 	})

 	prevOut := &wire.OutPoint{
-		Hash:  recieverCommitTx.TxSha(),
+		Hash:  recieverCommitTx.TxHash(),
 		Index: 0,
 	}

-	sweepTx := wire.NewMsgTx()
+	sweepTx := wire.NewMsgTx(2)
 	sweepTx.AddTxIn(wire.NewTxIn(prevOut, nil, nil))
 	sweepTx.AddTxOut(
 		&wire.TxOut{
@ -559,7 +558,7 @@ func TestHTLCReceiverSpendValidation(t *testing.T) {
 }

 func TestCommitTxStateHint(t *testing.T) {
-	commitTx := wire.NewMsgTx()
+	commitTx := wire.NewMsgTx(2)
 	commitTx.AddTxIn(&wire.TxIn{})

 	var obsfucator [StateHintSize]byte
--- a/lnwallet/size.go
+++ b/lnwallet/size.go
@ -6,7 +6,7 @@ import (

 const (
 	WitnessFactor              = blockchain.WitnessScaleFactor
-	MaxTransactionWeightPolicy = blockchain.MaxBlockCost / 10
+	MaxTransactionWeightPolicy = blockchain.MaxBlockWeight / 10

 	// The weight(cost), which is different from the !size! (see BIP-141),
 	// is calculated as:
--- a/lnwallet/wallet.go
+++ b/lnwallet/wallet.go
@ -661,7 +661,7 @@ func (l *LightningWallet) handleContributionMsg(req *addContributionMsg) {

 	// Create a blank, fresh transaction. Soon to be a complete funding
 	// transaction which will allow opening a lightning channel.
-	pendingReservation.fundingTx = wire.NewMsgTx()
+	pendingReservation.fundingTx = wire.NewMsgTx(1)
 	fundingTx := pendingReservation.fundingTx

 	// Some temporary variables to cut down on the resolution verbosity.
@ -739,7 +739,7 @@ func (l *LightningWallet) handleContributionMsg(req *addContributionMsg) {
 	// Locate the index of the multi-sig outpoint in order to record it
 	// since the outputs are canonically sorted. If this is a single funder
 	// workflow, then we'll also need to send this to the remote node.
-	fundingTxID := fundingTx.TxSha()
+	fundingTxID := fundingTx.TxHash()
 	_, multiSigIndex := FindScriptOutputIndex(fundingTx, multiSigOut.PkScript)
 	fundingOutpoint := wire.NewOutPoint(&fundingTxID, multiSigIndex)
 	pendingReservation.partialState.FundingOutpoint = fundingOutpoint
@ -1235,7 +1235,7 @@ func (l *LightningWallet) handleChannelOpen(req *channelOpenMsg) {
 func (l *LightningWallet) openChannelAfterConfirmations(res *ChannelReservation) {
 	// Register with the ChainNotifier for a notification once the funding
 	// transaction reaches `numConfs` confirmations.
-	txid := res.fundingTx.TxSha()
+	txid := res.fundingTx.TxHash()
 	numConfs := uint32(res.numConfsToOpen)
 	confNtfn, _ := l.chainNotifier.RegisterConfirmationsNtfn(&txid, numConfs)

--- a/lnwire/channel_announcement.go
+++ b/lnwire/channel_announcement.go
@ -7,7 +7,7 @@ import (

 	"github.com/go-errors/errors"
 	"github.com/roasbeef/btcd/btcec"
-	"github.com/roasbeef/btcd/wire"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 )

 // ChannelAnnouncement message is used to announce the existence of a channel
@ -56,12 +56,12 @@ func (a *ChannelAnnouncement) Validate() error {

 	var sigHash []byte

-	sigHash = wire.DoubleSha256(a.FirstNodeID.SerializeCompressed())
+	sigHash = chainhash.DoubleHashB(a.FirstNodeID.SerializeCompressed())
 	if !a.FirstBitcoinSig.Verify(sigHash, a.FirstBitcoinKey) {
 		return errors.New("can't verify first bitcoin signature")
 	}

-	sigHash = wire.DoubleSha256(a.SecondNodeID.SerializeCompressed())
+	sigHash = chainhash.DoubleHashB(a.SecondNodeID.SerializeCompressed())
 	if !a.SecondBitcoinSig.Verify(sigHash, a.SecondBitcoinKey) {
 		return errors.New("can't verify second bitcoin signature")
 	}
@ -70,7 +70,7 @@ func (a *ChannelAnnouncement) Validate() error {
 	if err != nil {
 		return err
 	}
-	dataHash := wire.DoubleSha256(data)
+	dataHash := chainhash.DoubleHashB(data)

 	if !a.FirstNodeSig.Verify(dataHash, a.FirstNodeID) {
 		return errors.New("can't verify data in first node signature")
--- a/lnwire/channel_announcement_test.go
+++ b/lnwire/channel_announcement_test.go
@ -6,7 +6,7 @@ import (
 	"testing"

 	"github.com/roasbeef/btcd/btcec"
-	"github.com/roasbeef/btcd/wire"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 )

 func TestChannelAnnoucementEncodeDecode(t *testing.T) {
@ -60,10 +60,10 @@ func TestChannelAnnoucementValidation(t *testing.T) {

 	var hash []byte

-	hash = wire.DoubleSha256(firstNodePubKey.SerializeCompressed())
+	hash = chainhash.DoubleHashB(firstNodePubKey.SerializeCompressed())
 	firstBitcoinSig, _ := firstBitcoinPrivKey.Sign(hash)

-	hash = wire.DoubleSha256(secondNodePubKey.SerializeCompressed())
+	hash = chainhash.DoubleHashB(secondNodePubKey.SerializeCompressed())
 	secondBitcoinSig, _ := secondBitcoinPrivKey.Sign(hash)

 	ca := &ChannelAnnouncement{
@ -77,7 +77,7 @@ func TestChannelAnnoucementValidation(t *testing.T) {
 	}

 	dataToSign, _ := ca.DataToSign()
-	hash = wire.DoubleSha256(dataToSign)
+	hash = chainhash.DoubleHashB(dataToSign)

 	firstNodeSign, _ := firstNodePrivKey.Sign(hash)
 	ca.FirstNodeSig = firstNodeSign
--- a/lnwire/lnwire.go
+++ b/lnwire/lnwire.go
@ -10,6 +10,7 @@ import (

 	"github.com/go-errors/errors"
 	"github.com/roasbeef/btcd/btcec"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/txscript"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
@ -175,7 +176,7 @@ func writeElement(w io.Writer, element interface{}) error {
 		if _, err = w.Write(b[:]); err != nil {
 			return err
 		}
-	case *wire.ShaHash:
+	case *chainhash.Hash:
 		if _, err := w.Write(e[:]); err != nil {
 			return err
 		}
@ -425,8 +426,8 @@ func readElement(r io.Reader, element interface{}) error {
 			return err
 		}
 		*e = btcutil.Amount(int64(binary.BigEndian.Uint64(b[:])))
-	case **wire.ShaHash:
-		var b wire.ShaHash
+	case **chainhash.Hash:
+		var b chainhash.Hash
 		if _, err := io.ReadFull(r, b[:]); err != nil {
 			return err
 		}
@ -576,7 +577,7 @@ func readElement(r io.Reader, element interface{}) error {
 		if _, err = io.ReadFull(r, h[:]); err != nil {
 			return err
 		}
-		hash, err := wire.NewShaHash(h[:])
+		hash, err := chainhash.NewHash(h[:])
 		if err != nil {
 			return err
 		}
@ -596,7 +597,7 @@ func readElement(r io.Reader, element interface{}) error {
 		if _, err = io.ReadFull(r, h[:]); err != nil {
 			return err
 		}
-		hash, err := wire.NewShaHash(h[:])
+		hash, err := chainhash.NewHash(h[:])
 		if err != nil {
 			return err
 		}
--- a/lnwire/lnwire_test.go
+++ b/lnwire/lnwire_test.go
@ -10,6 +10,7 @@ import (
 	"net"

 	"github.com/roasbeef/btcd/btcec"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/txscript"
 	"github.com/roasbeef/btcd/wire"
 )
@ -63,18 +64,18 @@ var (
 	// echo -n | openssl sha256
 	// This stuff gets reversed!!!
 	shaHash1Bytes, _ = hex.DecodeString("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
-	shaHash1, _      = wire.NewShaHash(shaHash1Bytes)
+	shaHash1, _      = chainhash.NewHash(shaHash1Bytes)
 	outpoint1        = wire.NewOutPoint(shaHash1, 0)
 	// echo | openssl sha256
 	// This stuff gets reversed!!!
 	shaHash2Bytes, _ = hex.DecodeString("01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b")
-	shaHash2, _      = wire.NewShaHash(shaHash2Bytes)
+	shaHash2, _      = chainhash.NewHash(shaHash2Bytes)
 	outpoint2        = wire.NewOutPoint(shaHash2, 1)
 	// create inputs from outpoint1 and outpoint2
 	inputs = []*wire.TxIn{wire.NewTxIn(outpoint1, nil, nil), wire.NewTxIn(outpoint2, nil, nil)}

 	// Commitment Signature
-	tx           = wire.NewMsgTx()
+	tx           = wire.NewMsgTx(1)
 	emptybytes   = new([]byte)
 	sigStr, _    = txscript.RawTxInSignature(tx, 0, *emptybytes, txscript.SigHashAll, privKey)
 	commitSig, _ = btcec.ParseSignature(sigStr, btcec.S256())
@ -93,7 +94,7 @@ var (
 	ptrFundingTXSigs = append(*new([]*btcec.Signature), commitSig1, commitSig2)

 	// TxID
-	txid = new(wire.ShaHash)
+	txid = new(chainhash.Hash)
 	// Reversed when displayed
 	txidBytes, _ = hex.DecodeString("fd95c6e5c9d5bcf9cfc7231b6a438e46c518c724d0b04b75cc8fddf84a254e3a")
 	_            = copy(txid[:], txidBytes)
--- a/lnwire/node_announcement.go
+++ b/lnwire/node_announcement.go
@ -8,7 +8,7 @@ import (

 	"github.com/go-errors/errors"
 	"github.com/roasbeef/btcd/btcec"
-	"github.com/roasbeef/btcd/wire"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 )

 var (
@ -119,7 +119,7 @@ func (a *NodeAnnouncement) Validate() error {
 		return err
 	}

-	dataHash := wire.DoubleSha256(data)
+	dataHash := chainhash.DoubleHashB(data)
 	if !a.Signature.Verify(dataHash, a.NodeID) {
 		return errors.New("can't check the node annoucement signature")
 	}
--- a/lnwire/node_announcement_test.go
+++ b/lnwire/node_announcement_test.go
@ -6,7 +6,7 @@ import (
 	"testing"

 	"github.com/roasbeef/btcd/btcec"
-	"github.com/roasbeef/btcd/wire"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 )

 func TestNodeAnnouncementEncodeDecode(t *testing.T) {
@ -58,7 +58,7 @@ func TestNodeAnnoucementValidation(t *testing.T) {
 	}

 	dataToSign, _ := na.DataToSign()
-	hash = wire.DoubleSha256(dataToSign)
+	hash = chainhash.DoubleHashB(dataToSign)

 	signature, _ := nodePrivKey.Sign(hash)
 	na.Signature = signature
--- a/networktest.go
+++ b/networktest.go
@ -24,6 +24,7 @@ import (
 	"github.com/go-errors/errors"
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/roasbeef/btcd/chaincfg"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/rpctest"
 	"github.com/roasbeef/btcd/txscript"
 	"github.com/roasbeef/btcd/wire"
@ -314,7 +315,7 @@ type networkHarness struct {
 	Alice *lightningNode
 	Bob   *lightningNode

-	seenTxns      chan wire.ShaHash
+	seenTxns      chan chainhash.Hash
 	watchRequests chan *watchRequest

 	// Channel for transmitting stderr output from failed lightning node
@ -331,7 +332,7 @@ type networkHarness struct {
 func newNetworkHarness() (*networkHarness, error) {
 	return &networkHarness{
 		activeNodes:   make(map[int]*lightningNode),
-		seenTxns:      make(chan wire.ShaHash),
+		seenTxns:      make(chan chainhash.Hash),
 		watchRequests: make(chan *watchRequest),
 		lndErrorChan:  make(chan error),
 	}, nil
@ -442,7 +443,7 @@ func (n *networkHarness) SetUp() error {
 				PkScript: addrScript,
 				Value:    btcutil.SatoshiPerBitcoin,
 			}
-			if _, err := n.Miner.CoinbaseSpend([]*wire.TxOut{output}); err != nil {
+			if _, err := n.Miner.SendOutputs([]*wire.TxOut{output}, 30); err != nil {
 				return err
 			}
 		}
@ -568,7 +569,7 @@ func (n *networkHarness) RestartNode(node *lightningNode, callback func() error)
 // dispatch a notification once a transaction with the target txid is seen
 // within the test network.
 type watchRequest struct {
-	txid      wire.ShaHash
+	txid      chainhash.Hash
 	eventChan chan struct{}
 }

@ -576,8 +577,8 @@ type watchRequest struct {
 // the broadcast of a target transaction, and then dispatches the transaction
 // once its seen on the network.
 func (n *networkHarness) networkWatcher() {
-	seenTxns := make(map[wire.ShaHash]struct{})
-	clients := make(map[wire.ShaHash][]chan struct{})
+	seenTxns := make(map[chainhash.Hash]struct{})
+	clients := make(map[chainhash.Hash][]chan struct{})

 	for {

@ -618,7 +619,7 @@ func (n *networkHarness) networkWatcher() {

 // OnTxAccepted is a callback to be called each time a new transaction has been
 // broadcast on the network.
-func (n *networkHarness) OnTxAccepted(hash *wire.ShaHash, amt btcutil.Amount) {
+func (n *networkHarness) OnTxAccepted(hash *chainhash.Hash, amt btcutil.Amount) {
 	go func() {
 		n.seenTxns <- *hash
 	}()
@ -628,7 +629,7 @@ func (n *networkHarness) OnTxAccepted(hash *wire.ShaHash, amt btcutil.Amount) {
 // the transaction isn't seen within the network before the passed timeout,
 // then an error is returned.
 // TODO(roasbeef): add another method which creates queue of all seen transactions
-func (n *networkHarness) WaitForTxBroadcast(ctx context.Context, txid wire.ShaHash) error {
+func (n *networkHarness) WaitForTxBroadcast(ctx context.Context, txid chainhash.Hash) error {
 	eventChan := make(chan struct{})

 	n.watchRequests <- &watchRequest{txid, eventChan}
@ -734,7 +735,7 @@ func (n *networkHarness) WaitForChannelOpen(ctx context.Context,
 // pending, then an error is returned.
 func (n *networkHarness) CloseChannel(ctx context.Context,
 	lnNode *lightningNode, cp *lnrpc.ChannelPoint,
-	force bool) (lnrpc.Lightning_CloseChannelClient, *wire.ShaHash, error) {
+	force bool) (lnrpc.Lightning_CloseChannelClient, *chainhash.Hash, error) {

 	closeReq := &lnrpc.CloseChannelRequest{
 		ChannelPoint: cp,
@ -746,7 +747,7 @@ func (n *networkHarness) CloseChannel(ctx context.Context,
 	}

 	errChan := make(chan error)
-	fin := make(chan *wire.ShaHash)
+	fin := make(chan *chainhash.Hash)
 	go func() {
 		// Consume the "channel close" update in order to wait for the closing
 		// transaction to be broadcast, then wait for the closing tx to be seen
@ -763,7 +764,7 @@ func (n *networkHarness) CloseChannel(ctx context.Context,
 			return
 		}

-		closeTxid, err := wire.NewShaHash(pendingClose.ClosePending.Txid)
+		closeTxid, err := chainhash.NewHash(pendingClose.ClosePending.Txid)
 		if err != nil {
 			errChan <- err
 			return
@ -793,7 +794,7 @@ func (n *networkHarness) CloseChannel(ctx context.Context,
 // passed context has a timeout, then if the timeout is reached before the
 // notification is received then an error is returned.
 func (n *networkHarness) WaitForChannelClose(ctx context.Context,
-	closeChanStream lnrpc.Lightning_CloseChannelClient) (*wire.ShaHash, error) {
+	closeChanStream lnrpc.Lightning_CloseChannelClient) (*chainhash.Hash, error) {

 	errChan := make(chan error)
 	updateChan := make(chan *lnrpc.CloseStatusUpdate_ChanClose)
@ -822,7 +823,7 @@ func (n *networkHarness) WaitForChannelClose(ctx context.Context,
 	case err := <-errChan:
 		return nil, err
 	case update := <-updateChan:
-		return wire.NewShaHash(update.ChanClose.ClosingTxid)
+		return chainhash.NewHash(update.ChanClose.ClosingTxid)
 	}
 }

@ -898,7 +899,7 @@ func (n *networkHarness) SendCoins(ctx context.Context, amt btcutil.Amount,
 		PkScript: addrScript,
 		Value:    int64(amt),
 	}
-	if _, err := n.Miner.CoinbaseSpend([]*wire.TxOut{output}); err != nil {
+	if _, err := n.Miner.SendOutputs([]*wire.TxOut{output}, 30); err != nil {
 		return err
 	}

--- a/peer.go
+++ b/peer.go
@ -20,6 +20,7 @@ import (
 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/roasbeef/btcd/btcec"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/txscript"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
@ -69,7 +70,7 @@ type peer struct {
 	conn    net.Conn

 	addr        *lnwire.NetAddress
-	lightningID wire.ShaHash
+	lightningID chainhash.Hash

 	inbound bool
 	id      int32
@ -157,7 +158,7 @@ func newPeer(conn net.Conn, server *server, addr *lnwire.NetAddress,

 	p := &peer{
 		conn:        conn,
-		lightningID: wire.ShaHash(fastsha256.Sum256(nodePub.SerializeCompressed())),
+		lightningID: chainhash.Hash(fastsha256.Sum256(nodePub.SerializeCompressed())),
 		addr:        addr,

 		id:      atomic.AddInt32(&numNodes, 1),
@ -694,7 +695,7 @@ out:
 // cooperative channel close. The channel state machine is transitioned to the
 // closing phase, then our half of the closing witness is sent over to the
 // remote peer.
-func (p *peer) executeCooperativeClose(channel *lnwallet.LightningChannel) (*wire.ShaHash, error) {
+func (p *peer) executeCooperativeClose(channel *lnwallet.LightningChannel) (*chainhash.Hash, error) {
 	// Shift the channel state machine into a 'closing' state. This
 	// generates a signature for the closing tx, as well as a txid of the
 	// closing tx itself, allowing us to watch the network to determine
@ -730,7 +731,7 @@ func (p *peer) executeCooperativeClose(channel *lnwallet.LightningChannel) (*wir
 func (p *peer) handleLocalClose(req *closeLinkReq) {
 	var (
 		err         error
-		closingTxid *wire.ShaHash
+		closingTxid *chainhash.Hash
 	)

 	p.activeChanMtx.RLock()
@ -1417,7 +1418,7 @@ func (p *peer) handleUpstreamMsg(state *commitmentState, msg lnwire.Message) {
 		// with this latest commitment update.
 		// TODO(roasbeef): wait until next transition?
 		for invoice, _ := range settledPayments {
-			err := p.server.invoices.SettleInvoice(wire.ShaHash(invoice))
+			err := p.server.invoices.SettleInvoice(chainhash.Hash(invoice))
 			if err != nil {
 				peerLog.Errorf("unable to settle invoice: %v", err)
 			}
--- a/routing/pathfind_test.go
+++ b/routing/pathfind_test.go
@ -14,6 +14,7 @@ import (

 	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/roasbeef/btcd/btcec"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
 )
@ -201,7 +202,7 @@ func parseTestGraph(path string) (*channeldb.ChannelGraph, func(), aliasMap, err
 		}

 		fundingTXID := strings.Split(edge.ChannelPoint, ":")[0]
-		txidBytes, err := wire.NewShaHashFromStr(fundingTXID)
+		txidBytes, err := chainhash.NewHashFromStr(fundingTXID)
 		if err != nil {
 			return nil, nil, nil, err
 		}
--- a/routing/router.go
+++ b/routing/router.go
@ -752,7 +752,7 @@ func (r *ChannelRouter) fetchChanPoint(chanID *lnwire.ChannelID) (*wire.OutPoint
 	// transaction index to obtain the funding output and txid.
 	fundingTx := fundingBlock.Transactions[chanID.TxIndex]
 	return &wire.OutPoint{
-		Hash:  fundingTx.TxSha(),
+		Hash:  fundingTx.TxHash(),
 		Index: uint32(chanID.TxPosition),
 	}, nil
 }
--- a/rpcserver.go
+++ b/rpcserver.go
@ -24,6 +24,7 @@ import (
 	"github.com/lightningnetwork/lnd/zpay32"
 	"github.com/roasbeef/btcd/btcec"
 	"github.com/roasbeef/btcd/chaincfg"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/txscript"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
@ -104,7 +105,7 @@ func addrPairsToOutputs(addrPairs map[string]int64) ([]*wire.TxOut, error) {
 // sendCoinsOnChain makes an on-chain transaction in or to send coins to one or
 // more addresses specified in the passed payment map. The payment map maps an
 // address to a specified output value to be sent to that address.
-func (r *rpcServer) sendCoinsOnChain(paymentMap map[string]int64) (*wire.ShaHash, error) {
+func (r *rpcServer) sendCoinsOnChain(paymentMap map[string]int64) (*chainhash.Hash, error) {
 	outputs, err := addrPairsToOutputs(paymentMap)
 	if err != nil {
 		return nil, err
@ -271,7 +272,7 @@ out:
 			switch update := fundingUpdate.Update.(type) {
 			case *lnrpc.OpenStatusUpdate_ChanOpen:
 				chanPoint := update.ChanOpen.ChannelPoint
-				h, _ := wire.NewShaHash(chanPoint.FundingTxid)
+				h, _ := chainhash.NewHash(chanPoint.FundingTxid)
 				outpoint = wire.OutPoint{
 					Hash:  *h,
 					Index: chanPoint.OutputIndex,
@ -354,7 +355,7 @@ func (r *rpcServer) CloseChannel(in *lnrpc.CloseChannelRequest,

 	force := in.Force
 	index := in.ChannelPoint.OutputIndex
-	txid, err := wire.NewShaHash(in.ChannelPoint.FundingTxid)
+	txid, err := chainhash.NewHash(in.ChannelPoint.FundingTxid)
 	if err != nil {
 		rpcsLog.Errorf("[closechannel] invalid txid: %v", err)
 		return err
@ -472,7 +473,7 @@ out:
 			// longer need to process any further updates.
 			switch closeUpdate := closingUpdate.Update.(type) {
 			case *lnrpc.CloseStatusUpdate_ChanClose:
-				h, _ := wire.NewShaHash(closeUpdate.ChanClose.ClosingTxid)
+				h, _ := chainhash.NewHash(closeUpdate.ChanClose.ClosingTxid)
 				rpcsLog.Infof("[closechannel] close completed: "+
 					"txid(%v)", h)
 				break out
@ -520,7 +521,7 @@ func (r *rpcServer) fetchActiveChannel(chanPoint wire.OutPoint) (*lnwallet.Light
 // commitment transaction has been broadcast, a struct describing the final
 // state of the channel is sent to the utxoNursery in order to ultimately sweep
 // the immature outputs.
-func (r *rpcServer) forceCloseChan(channel *lnwallet.LightningChannel) (*wire.ShaHash, error) {
+func (r *rpcServer) forceCloseChan(channel *lnwallet.LightningChannel) (*chainhash.Hash, error) {
 	// Execute a unilateral close shutting down all further channel
 	// operation.
 	closeSummary, err := channel.ForceClose()
@ -529,7 +530,7 @@ func (r *rpcServer) forceCloseChan(channel *lnwallet.LightningChannel) (*wire.Sh
 	}

 	closeTx := closeSummary.CloseTx
-	txid := closeTx.TxSha()
+	txid := closeTx.TxHash()

 	// With the close transaction in hand, broadcast the transaction to the
 	// network, thereby entering the psot channel resolution state.
@ -1014,7 +1015,7 @@ func (r *rpcServer) constructPaymentRoute(destNode *btcec.PublicKey,
 	}

 	firstHopPub := route.Hops[0].Channel.Node.PubKey.SerializeCompressed()
-	destInterface := wire.ShaHash(fastsha256.Sum256(firstHopPub))
+	destInterface := chainhash.Hash(fastsha256.Sum256(firstHopPub))

 	return &htlcPacket{
 		dest: destInterface,
--- a/shachain/shachain.go
+++ b/shachain/shachain.go
@ -8,7 +8,7 @@ import (
 	"io"
 	"sync"

-	"github.com/roasbeef/btcd/wire"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcutil"
 )

@ -32,7 +32,7 @@ type HyperShaChain struct {

 	chainBranches [64]chainBranch

-	lastHash wire.ShaHash
+	lastHash chainhash.Hash
 }

 // NewHyperShaChain
@ -145,14 +145,14 @@ func (h *HyperShaChain) AddNextHash(hash [32]byte) error {
 }

 // CurrentPreImage...
-func (h *HyperShaChain) CurrentPreImage() *wire.ShaHash {
+func (h *HyperShaChain) CurrentPreImage() *chainhash.Hash {
 	h.RLock()
 	defer h.RUnlock()
 	return &h.lastHash
 }

 // CurrentRevocationHash...
-// TODO(roasbeef): *wire.ShaHash vs [wire.HashSize]byte ?
+// TODO(roasbeef): *chainhash.Hash vs [wire.HashSize]byte ?
 func (h *HyperShaChain) CurrentRevocationHash() []byte {
 	h.RLock()
 	defer h.RUnlock()
--- a/utxonursery.go
+++ b/utxonursery.go
@ -581,8 +581,7 @@ func createSweepTx(wallet *lnwallet.LightningWallet, matureOutputs []*kidOutput)
 		totalSum += o.amt
 	}

-	sweepTx := wire.NewMsgTx()
-	sweepTx.Version = 2
+	sweepTx := wire.NewMsgTx(2)
 	sweepTx.AddTxOut(&wire.TxOut{
 		PkScript: pkScript,
 		Value:    int64(totalSum - 5000),
--- a/utxonursery_test.go
+++ b/utxonursery_test.go
@ -8,6 +8,7 @@ import (

 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/roasbeef/btcd/btcec"
+	"github.com/roasbeef/btcd/chaincfg/chainhash"
 	"github.com/roasbeef/btcd/txscript"
 	"github.com/roasbeef/btcd/wire"
 	"github.com/roasbeef/btcutil"
@ -16,7 +17,7 @@ import (
 var (
 	outPoints = []wire.OutPoint{
 		wire.OutPoint{
-			Hash: [wire.HashSize]byte{
+			Hash: [chainhash.HashSize]byte{
 				0x51, 0xb6, 0x37, 0xd8, 0xfc, 0xd2, 0xc6, 0xda,
 				0x48, 0x59, 0xe6, 0x96, 0x31, 0x13, 0xa1, 0x17,
 				0x2d, 0xe7, 0x93, 0xe4, 0xb7, 0x25, 0xb8, 0x4d,
@ -25,7 +26,7 @@ var (
 			Index: 9,
 		},
 		wire.OutPoint{
-			Hash: [wire.HashSize]byte{
+			Hash: [chainhash.HashSize]byte{
 				0xb7, 0x94, 0x38, 0x5f, 0x2d, 0x1e, 0xf7, 0xab,
 				0x4d, 0x92, 0x73, 0xd1, 0x90, 0x63, 0x81, 0xb4,
 				0x4f, 0x2f, 0x6f, 0x25, 0x88, 0xa3, 0xef, 0xb9,
@ -34,7 +35,7 @@ var (
 			Index: 49,
 		},
 		wire.OutPoint{
-			Hash: [wire.HashSize]byte{
+			Hash: [chainhash.HashSize]byte{
 				0x81, 0xb6, 0x37, 0xd8, 0xfc, 0xd2, 0xc6, 0xda,
 				0x63, 0x59, 0xe6, 0x96, 0x31, 0x13, 0xa1, 0x17,
 				0xd, 0xe7, 0x95, 0xe4, 0xb7, 0x25, 0xb8, 0x4d,