Release v0.3.0

vendor/github.com/ltcsuite/ltcd/LICENSE

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

vendor/github.com/ltcsuite/ltcd/chaincfg/README.md

@@ -0,0 +1,87 @@
+chaincfg
+========
+
+[![Build Status](http://img.shields.io/travis/ltcsuite/ltcd.svg)]
+(https://travis-ci.org/ltcsuite/ltcd) [![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/ltcsuite/ltcd/chaincfg)
+
+Package chaincfg defines chain configuration parameters for the three standard
+Bitcoin networks and provides the ability for callers to define their own custom
+Bitcoin networks.
+
+Although this package was primarily written for ltcd, it has intentionally been
+designed so it can be used as a standalone package for any projects needing to
+use parameters for the standard Bitcoin networks or for projects needing to
+define their own network.
+
+## Sample Use
+
+```Go
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+
+	"github.com/ltcsuite/ltcutil"
+	"github.com/ltcsuite/ltcd/chaincfg"
+)
+
+var testnet = flag.Bool("testnet", false, "operate on the testnet Bitcoin network")
+
+// By default (without -testnet), use mainnet.
+var chainParams = &chaincfg.MainNetParams
+
+func main() {
+	flag.Parse()
+
+	// Modify active network parameters if operating on testnet.
+	if *testnet {
+		chainParams = &chaincfg.TestNet4Params
+	}
+
+	// later...
+
+	// Create and print new payment address, specific to the active network.
+	pubKeyHash := make([]byte, 20)
+	addr, err := ltcutil.NewAddressPubKeyHash(pubKeyHash, chainParams)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(addr)
+}
+```
+
+## Installation and Updating
+
+```bash
+$ go get -u github.com/ltcsuite/ltcd/chaincfg
+```
+
+## 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 chaincfg is licensed under the [copyfree](http://copyfree.org) ISC
+License.

vendor/github.com/ltcsuite/ltcd/chaincfg/chainhash/README.md

@@ -0,0 +1,41 @@
+chainhash
+=========
+
+[![Build Status](http://img.shields.io/travis/btcsuite/ltcd.svg)](https://travis-ci.org/ltcsuite/ltcd)
+[![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/ltcsuite/ltcd/chaincfg/chainhash)
+=======
+
+chainhash provides a generic hash type and associated functions that allows the
+specific hash algorithm to be abstracted.
+
+## Installation and Updating
+
+```bash
+$ go get -u github.com/ltcsuite/ltcd/chaincfg/chainhash
+```
+
+## 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 chainhash is licensed under the [copyfree](http://copyfree.org) ISC
+License.

vendor/github.com/ltcsuite/ltcd/chaincfg/chainhash/doc.go

@@ -0,0 +1,5 @@
+// Package chainhash provides abstracted hash functionality.
+//
+// This package provides a generic hash type and associated functions that
+// allows the specific hash algorithm to be abstracted.
+package chainhash

vendor/github.com/ltcsuite/ltcd/chaincfg/chainhash/hash.go

@@ -0,0 +1,128 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Copyright (c) 2015 The Decred developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package chainhash
+
+import (
+	"encoding/hex"
+	"fmt"
+)
+
+// HashSize of array used to store hashes.  See Hash.
+const HashSize = 32
+
+// MaxHashStringSize is the maximum length of a Hash hash string.
+const MaxHashStringSize = HashSize * 2
+
+// ErrHashStrSize describes an error that indicates the caller specified a hash
+// string that has too many characters.
+var ErrHashStrSize = fmt.Errorf("max hash string length is %v bytes", MaxHashStringSize)
+
+// Hash is used in several of the bitcoin messages and common structures.  It
+// typically represents the double sha256 of data.
+type Hash [HashSize]byte
+
+// String returns the Hash as the hexadecimal string of the byte-reversed
+// hash.
+func (hash Hash) String() string {
+	for i := 0; i < HashSize/2; i++ {
+		hash[i], hash[HashSize-1-i] = hash[HashSize-1-i], hash[i]
+	}
+	return hex.EncodeToString(hash[:])
+}
+
+// CloneBytes returns a copy of the bytes which represent the hash as a byte
+// slice.
+//
+// NOTE: It is generally cheaper to just slice the hash directly thereby reusing
+// the same bytes rather than calling this method.
+func (hash *Hash) CloneBytes() []byte {
+	newHash := make([]byte, HashSize)
+	copy(newHash, hash[:])
+
+	return newHash
+}
+
+// SetBytes sets the bytes which represent the hash.  An error is returned if
+// the number of bytes passed in is not HashSize.
+func (hash *Hash) SetBytes(newHash []byte) error {
+	nhlen := len(newHash)
+	if nhlen != HashSize {
+		return fmt.Errorf("invalid hash length of %v, want %v", nhlen,
+			HashSize)
+	}
+	copy(hash[:], newHash)
+
+	return nil
+}
+
+// IsEqual returns true if target is the same as hash.
+func (hash *Hash) IsEqual(target *Hash) bool {
+	if hash == nil && target == nil {
+		return true
+	}
+	if hash == nil || target == nil {
+		return false
+	}
+	return *hash == *target
+}
+
+// NewHash returns a new Hash from a byte slice.  An error is returned if
+// the number of bytes passed in is not HashSize.
+func NewHash(newHash []byte) (*Hash, error) {
+	var sh Hash
+	err := sh.SetBytes(newHash)
+	if err != nil {
+		return nil, err
+	}
+	return &sh, err
+}
+
+// NewHashFromStr creates a Hash from a hash string.  The string should be
+// the hexadecimal string of a byte-reversed hash, but any missing characters
+// result in zero padding at the end of the Hash.
+func NewHashFromStr(hash string) (*Hash, error) {
+	ret := new(Hash)
+	err := Decode(ret, hash)
+	if err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// Decode decodes the byte-reversed hexadecimal string encoding of a Hash to a
+// destination.
+func Decode(dst *Hash, src string) error {
+	// Return error if hash string is too long.
+	if len(src) > MaxHashStringSize {
+		return ErrHashStrSize
+	}
+
+	// Hex decoder expects the hash to be a multiple of two.  When not, pad
+	// with a leading zero.
+	var srcBytes []byte
+	if len(src)%2 == 0 {
+		srcBytes = []byte(src)
+	} else {
+		srcBytes = make([]byte, 1+len(src))
+		srcBytes[0] = '0'
+		copy(srcBytes[1:], src)
+	}
+
+	// Hex decode the source bytes to a temporary destination.
+	var reversedHash Hash
+	_, err := hex.Decode(reversedHash[HashSize-hex.DecodedLen(len(srcBytes)):], srcBytes)
+	if err != nil {
+		return err
+	}
+
+	// Reverse copy from the temporary hash to destination.  Because the
+	// temporary was zeroed, the written result will be correctly padded.
+	for i, b := range reversedHash[:HashSize/2] {
+		dst[i], dst[HashSize-1-i] = reversedHash[HashSize-1-i], b
+	}
+
+	return nil
+}

vendor/github.com/ltcsuite/ltcd/chaincfg/chainhash/hashfuncs.go

@@ -0,0 +1,33 @@
+// Copyright (c) 2015 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 chainhash
+
+import "crypto/sha256"
+
+// HashB calculates hash(b) and returns the resulting bytes.
+func HashB(b []byte) []byte {
+	hash := sha256.Sum256(b)
+	return hash[:]
+}
+
+// HashH calculates hash(b) and returns the resulting bytes as a Hash.
+func HashH(b []byte) Hash {
+	return Hash(sha256.Sum256(b))
+}
+
+// DoubleHashB calculates hash(hash(b)) and returns the resulting bytes.
+func DoubleHashB(b []byte) []byte {
+	first := sha256.Sum256(b)
+	second := sha256.Sum256(first[:])
+	return second[:]
+}
+
+// DoubleHashH calculates hash(hash(b)) and returns the resulting bytes as a
+// Hash.
+func DoubleHashH(b []byte) Hash {
+	first := sha256.Sum256(b)
+	return Hash(sha256.Sum256(first[:]))
+}

vendor/github.com/ltcsuite/ltcd/chaincfg/doc.go

@@ -0,0 +1,61 @@
+// Package chaincfg defines chain configuration parameters.
+//
+// In addition to the main Bitcoin network, which is intended for the transfer
+// of monetary value, there also exists two currently active standard networks:
+// regression test and testnet (version 3).  These networks are incompatible
+// with each other (each sharing a different genesis block) and software should
+// handle errors where input intended for one network is used on an application
+// instance running on a different network.
+//
+// For library packages, chaincfg provides the ability to lookup chain
+// parameters and encoding magics when passed a *Params.  Older APIs not updated
+// to the new convention of passing a *Params may lookup the parameters for a
+// wire.BitcoinNet using ParamsForNet, but be aware that this usage is
+// deprecated and will be removed from chaincfg in the future.
+//
+// For main packages, a (typically global) var may be assigned the address of
+// one of the standard Param vars for use as the application's "active" network.
+// When a network parameter is needed, it may then be looked up through this
+// variable (either directly, or hidden in a library call).
+//
+//  package main
+//
+//  import (
+//          "flag"
+//          "fmt"
+//          "log"
+//
+//          "github.com/ltcsuite/ltcutil"
+//          "github.com/ltcsuite/ltcd/chaincfg"
+//  )
+//
+//  var testnet = flag.Bool("testnet", false, "operate on the testnet Bitcoin network")
+//
+//  // By default (without -testnet), use mainnet.
+//  var chainParams = &chaincfg.MainNetParams
+//
+//  func main() {
+//          flag.Parse()
+//
+//          // Modify active network parameters if operating on testnet.
+//          if *testnet {
+//                  chainParams = &chaincfg.TestNet4Params
+//          }
+//
+//          // later...
+//
+//          // Create and print new payment address, specific to the active network.
+//          pubKeyHash := make([]byte, 20)
+//          addr, err := ltcutil.NewAddressPubKeyHash(pubKeyHash, chainParams)
+//          if err != nil {
+//                  log.Fatal(err)
+//          }
+//          fmt.Println(addr)
+//  }
+//
+// If an application does not use one of the three standard Bitcoin networks,
+// a new Params struct may be created which defines the parameters for the
+// non-standard network.  As a general rule of thumb, all network parameters
+// should be unique to the network, but parameter collisions can still occur
+// (unfortunately, this is the case with regtest and testnet sharing magics).
+package chaincfg

vendor/github.com/ltcsuite/ltcd/chaincfg/genesis.go

@@ -0,0 +1,178 @@
+// 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 chaincfg
+
+import (
+	"time"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+	"github.com/ltcsuite/ltcd/wire"
+)
+
+// genesisCoinbaseTx is the coinbase transaction for the genesis blocks for
+// the main network, regression test network, and test network (version 3).
+var genesisCoinbaseTx = wire.MsgTx{
+	Version: 1,
+	TxIn: []*wire.TxIn{
+		{
+			PreviousOutPoint: wire.OutPoint{
+				Hash:  chainhash.Hash{},
+				Index: 0xffffffff,
+			},
+			SignatureScript: []byte{
+				0x04, 0xff, 0xff, 0x00, 0x1d, 0x01, 0x04, 0x40, 0x4e, 0x59, 0x20, 0x54, 0x69, 0x6d, 0x65, 0x73, // |.......@NY Times|
+				0x20, 0x30, 0x35, 0x2f, 0x4f, 0x63, 0x74, 0x2f, 0x32, 0x30, 0x31, 0x31, 0x20, 0x53, 0x74, 0x65, // | 05/Oct/2011 Ste|
+				0x76, 0x65, 0x20, 0x4a, 0x6f, 0x62, 0x73, 0x2c, 0x20, 0x41, 0x70, 0x70, 0x6c, 0x65, 0xe2, 0x80, // |ve Jobs, Apple..|
+				0x99, 0x73, 0x20, 0x56, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x72, 0x79, 0x2c, 0x20, 0x44, 0x69, // |.s Visionary, Di|
+				0x65, 0x73, 0x20, 0x61, 0x74, 0x20, 0x35, 0x36, // |es at 56|
+
+			},
+			Sequence: 0xffffffff,
+		},
+	},
+	TxOut: []*wire.TxOut{
+		{
+			Value: 0x12a05f200,
+			PkScript: []byte{
+				0x41, 0x4, 0x1, 0x84, 0x71, 0xf, 0xa6, 0x89,
+				0xad, 0x50, 0x23, 0x69, 0xc, 0x80, 0xf3, 0xa4,
+				0x9c, 0x8f, 0x13, 0xf8, 0xd4, 0x5b, 0x8c, 0x85,
+				0x7f, 0xbc, 0xbc, 0x8b, 0xc4, 0xa8, 0xe4, 0xd3,
+				0xeb, 0x4b, 0x10, 0xf4, 0xd4, 0x60, 0x4f, 0xa0,
+				0x8d, 0xce, 0x60, 0x1a, 0xaf, 0xf, 0x47, 0x2,
+				0x16, 0xfe, 0x1b, 0x51, 0x85, 0xb, 0x4a, 0xcf,
+				0x21, 0xb1, 0x79, 0xc4, 0x50, 0x70, 0xac, 0x7b,
+				0x3, 0xa9, 0xac,
+			},
+		},
+	},
+	LockTime: 0,
+}
+
+// genesisHash is the hash of the first block in the block chain for the main
+// network (genesis block).
+var genesisHash = chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
+	0xe2, 0xbf, 0x04, 0x7e, 0x7e, 0x5a, 0x19, 0x1a,
+	0xa4, 0xef, 0x34, 0xd3, 0x14, 0x97, 0x9d, 0xc9,
+	0x98, 0x6e, 0x0f, 0x19, 0x25, 0x1e, 0xda, 0xba,
+	0x59, 0x40, 0xfd, 0x1f, 0xe3, 0x65, 0xa7, 0x12,
+ })
+
+// genesisMerkleRoot is the hash of the first transaction in the genesis block
+// for the main network.
+var genesisMerkleRoot = chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
+	0xd9, 0xce, 0xd4, 0xed, 0x11, 0x30, 0xf7, 0xb7,
+	0xfa, 0xad, 0x9b, 0xe2, 0x53, 0x23, 0xff, 0xaf,
+	0xa3, 0x32, 0x32, 0xa1, 0x7c, 0x3e, 0xdf, 0x6c,
+	0xfd, 0x97, 0xbe, 0xe6, 0xba, 0xfb, 0xdd, 0x97,
+ })
+
+// genesisBlock defines the genesis block of the block chain which serves as the
+// public transaction ledger for the main network.
+var genesisBlock = wire.MsgBlock{
+	Header: wire.BlockHeader{
+		Version:    1,
+		PrevBlock:  chainhash.Hash{},         // 0000000000000000000000000000000000000000000000000000000000000000
+		MerkleRoot: genesisMerkleRoot,        // 97ddfbbae6be97fd6cdf3e7ca13232a3afff2353e29badfab7f73011edd4ced9
+		Timestamp:  time.Unix(1317972665, 0),
+		Bits:       0x1e0ffff0,
+		Nonce:      2084524493,
+	},
+	Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
+}
+
+// regTestGenesisHash is the hash of the first block in the block chain for the
+// regression test network (genesis block).
+var regTestGenesisHash = chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
+	0xf9, 0x16, 0xc4, 0x56, 0xfc, 0x51, 0xdf, 0x62,
+	0x78, 0x85, 0xd7, 0xd6, 0x74, 0xed, 0x02, 0xdc,
+	0x88, 0xa2, 0x25, 0xad, 0xb3, 0xf0, 0x2a, 0xd1,
+	0x3e, 0xb4, 0x93, 0x8f, 0xf3, 0x27, 0x08, 0x53,
+})
+
+// regTestGenesisMerkleRoot is the hash of the first transaction in the genesis
+// block for the regression test network.  It is the same as the merkle root for
+// the main network.
+var regTestGenesisMerkleRoot = genesisMerkleRoot
+
+// regTestGenesisBlock defines the genesis block of the block chain which serves
+// as the public transaction ledger for the regression test network.
+var regTestGenesisBlock = wire.MsgBlock{
+	Header: wire.BlockHeader{
+		Version:    1,
+		PrevBlock:  chainhash.Hash{},         // 0000000000000000000000000000000000000000000000000000000000000000
+		MerkleRoot: regTestGenesisMerkleRoot, // 97ddfbbae6be97fd6cdf3e7ca13232a3afff2353e29badfab7f73011edd4ced9
+		Timestamp:  time.Unix(1296688602, 0), // 2011-02-02 23:16:42 +0000 UTC
+		Bits:       0x207fffff,               // 545259519 [7fffff0000000000000000000000000000000000000000000000000000000000]
+		Nonce:      0,
+	},
+	Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
+}
+
+// testNet4GenesisHash is the hash of the first block in the block chain for the
+// test network (version 4).
+var testNet4GenesisHash = chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
+	0xa0, 0x29, 0x3e, 0x4e, 0xeb, 0x3d, 0xa6, 0xe6,
+	0xf5, 0x6f, 0x81, 0xed, 0x59, 0x5f, 0x57, 0x88,
+	0xd, 0x1a, 0x21, 0x56, 0x9e, 0x13, 0xee, 0xfd,
+	0xd9, 0x51, 0x28, 0x4b, 0x5a, 0x62, 0x66, 0x49,
+})
+
+// testNet3GenesisMerkleRoot is the hash of the first transaction in the genesis
+// block for the test network (version 3).  It is the same as the merkle root
+// for the main network.
+var testNet3GenesisMerkleRoot = genesisMerkleRoot
+
+// testNet4GenesisMerkleRoot is the hash of the first transaction in the genesis
+// block for the test network (version 4).  It is the same as the merkle root
+// for the main network.
+var testNet4GenesisMerkleRoot = chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
+	0xd9, 0xce, 0xd4, 0xed, 0x11, 0x30, 0xf7, 0xb7,
+	0xfa, 0xad, 0x9b, 0xe2, 0x53, 0x23, 0xff, 0xaf,
+	0xa3, 0x32, 0x32, 0xa1, 0x7c, 0x3e, 0xdf, 0x6c,
+	0xfd, 0x97, 0xbe, 0xe6, 0xba, 0xfb, 0xdd, 0x97,
+})
+
+// testNet4GenesisBlock defines the genesis block of the block chain which
+// serves as the public transaction ledger for the test network (version 4).
+var testNet4GenesisBlock = wire.MsgBlock{
+	Header: wire.BlockHeader{
+		Version:    1,
+		PrevBlock:  chainhash.Hash{},          // 0000000000000000000000000000000000000000000000000000000000000000
+		MerkleRoot: testNet4GenesisMerkleRoot, // 97ddfbbae6be97fd6cdf3e7ca13232a3afff2353e29badfab7f73011edd4ced9
+		Timestamp:  time.Unix(1486949366, 0),
+		Bits:       0x1e0ffff0,
+		Nonce:      293345,
+	},
+	Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
+}
+
+// simNetGenesisHash is the hash of the first block in the block chain for the
+// simulation test network.
+var simNetGenesisHash = chainhash.Hash([chainhash.HashSize]byte{ // Make go vet happy.
+	0xbe, 0xa4, 0x3b, 0x3a, 0xb4, 0xbc, 0x9d, 0x86,
+	0x2b, 0xfa, 0xbc, 0x0d, 0x45, 0xa3, 0xc5, 0xc9,
+	0xd0, 0x9f, 0x66, 0x20, 0xce, 0x7d, 0xb6, 0x78,
+	0xb5, 0xdc, 0x1d, 0xb8, 0x19, 0xc9, 0x35, 0x12,
+})
+
+// simNetGenesisMerkleRoot is the hash of the first transaction in the genesis
+// block for the simulation test network.  It is the same as the merkle root for
+// the main network.
+var simNetGenesisMerkleRoot = genesisMerkleRoot
+
+// simNetGenesisBlock defines the genesis block of the block chain which serves
+// as the public transaction ledger for the simulation test network.
+var simNetGenesisBlock = wire.MsgBlock{
+	Header: wire.BlockHeader{
+		Version:    1,
+		PrevBlock:  chainhash.Hash{},         // 0000000000000000000000000000000000000000000000000000000000000000
+		MerkleRoot: simNetGenesisMerkleRoot,  // 4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b
+		Timestamp:  time.Unix(1401292357, 0), // 2014-05-28 15:52:37 +0000 UTC
+		Bits:       0x207fffff,               // 545259519 [7fffff0000000000000000000000000000000000000000000000000000000000]
+		Nonce:      2,
+	},
+	Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
+}

vendor/github.com/ltcsuite/ltcd/chaincfg/params.go

@@ -0,0 +1,696 @@
+// 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 chaincfg
+
+import (
+	"errors"
+	"math"
+	"math/big"
+	"strings"
+	"time"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+	"github.com/ltcsuite/ltcd/wire"
+)
+
+// These variables are the chain proof-of-work limit parameters for each default
+// network.
+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)
+
+	// mainPowLimit is the highest proof of work value a Litecoin block can
+	// have for the main network.
+	mainPowLimit, _ = new(big.Int).SetString("0x0fffff000000000000000000000000000000000000000000000000000000", 0)
+
+	// regressionPowLimit is the highest proof of work value a Litecoin 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)
+
+	// testNet3PowLimit is the highest proof of work value a Litecoin block
+	// can have for the test network (version 3).  It is the value
+	// 2^224 - 1.
+	testNet3PowLimit = new(big.Int).Sub(new(big.Int).Lsh(bigOne, 224), bigOne)
+
+	// testNet4PowLimit is the highest proof of work value a Litecoin block
+	// can have for the test network (version 4).
+	testNet4PowLimit, _ = new(big.Int).SetString("0x0fffff000000000000000000000000000000000000000000000000000000", 0)
+
+	// simNetPowLimit is the highest proof of work value a Litecoin block
+	// can have for the simulation test network.  It is the value 2^255 - 1.
+	simNetPowLimit = new(big.Int).Sub(new(big.Int).Lsh(bigOne, 255), bigOne)
+)
+
+// Checkpoint identifies a known good point in the block chain.  Using
+// checkpoints allows a few optimizations for old blocks during initial download
+// and also prevents forks from old blocks.
+//
+// Each checkpoint is selected based upon several factors.  See the
+// documentation for blockchain.IsCheckpointCandidate for details on the
+// selection criteria.
+type Checkpoint struct {
+	Height int32
+	Hash   *chainhash.Hash
+}
+
+// DNSSeed identifies a DNS seed.
+type DNSSeed struct {
+	// Host defines the hostname of the seed.
+	Host string
+
+	// HasFiltering defines whether the seed supports filtering
+	// by service flags (wire.ServiceFlag).
+	HasFiltering bool
+}
+
+// ConsensusDeployment defines details related to a specific consensus rule
+// change that is voted in.  This is part of BIP0009.
+type ConsensusDeployment struct {
+	// BitNumber defines the specific bit number within the block version
+	// this particular soft-fork deployment refers to.
+	BitNumber uint8
+
+	// StartTime is the median block time after which voting on the
+	// deployment starts.
+	StartTime uint64
+
+	// ExpireTime is the median block time after which the attempted
+	// deployment expires.
+	ExpireTime uint64
+}
+
+// Constants that define the deployment offset in the deployments field of the
+// parameters for each deployment.  This is useful to be able to get the details
+// of a specific deployment by name.
+const (
+	// DeploymentTestDummy defines the rule change deployment ID for testing
+	// purposes.
+	DeploymentTestDummy = iota
+
+	// DeploymentCSV defines the rule change deployment ID for the CSV
+	// soft-fork package. The CSV package includes the deployment of BIPS
+	// 68, 112, and 113.
+	DeploymentCSV
+
+	// DeploymentSegwit defines the rule change deployment ID for the
+	// Segregated Witness (segwit) soft-fork package. The segwit package
+	// includes the deployment of BIPS 141, 142, 144, 145, 147 and 173.
+	DeploymentSegwit
+
+	// NOTE: DefinedDeployments must always come last since it is used to
+	// determine how many defined deployments there currently are.
+
+	// DefinedDeployments is the number of currently defined deployments.
+	DefinedDeployments
+)
+
+// Params defines a Litecoin network by its parameters.  These parameters may be
+// used by Litecoin applications to differentiate networks as well as addresses
+// and keys for one network from those intended for use on another network.
+type Params struct {
+	// Name defines a human-readable identifier for the network.
+	Name string
+
+	// Net defines the magic bytes used to identify the network.
+	Net wire.BitcoinNet
+
+	// DefaultPort defines the default peer-to-peer port for the network.
+	DefaultPort string
+
+	// DNSSeeds defines a list of DNS seeds for the network that are used
+	// as one method to discover peers.
+	DNSSeeds []DNSSeed
+
+	// GenesisBlock defines the first block of the chain.
+	GenesisBlock *wire.MsgBlock
+
+	// GenesisHash is the starting block hash.
+	GenesisHash *chainhash.Hash
+
+	// PowLimit defines the highest allowed proof of work value for a block
+	// as a uint256.
+	PowLimit *big.Int
+
+	// PowLimitBits defines the highest allowed proof of work value for a
+	// block in compact form.
+	PowLimitBits uint32
+
+	// These fields define the block heights at which the specified softfork
+	// BIP became active.
+	BIP0034Height int32
+	BIP0065Height int32
+	BIP0066Height int32
+
+	// CoinbaseMaturity is the number of blocks required before newly mined
+	// coins (coinbase transactions) can be spent.
+	CoinbaseMaturity uint16
+
+	// SubsidyReductionInterval is the interval of blocks before the subsidy
+	// is reduced.
+	SubsidyReductionInterval int32
+
+	// TargetTimespan is the desired amount of time that should elapse
+	// before the block difficulty requirement is examined to determine how
+	// it should be changed in order to maintain the desired block
+	// generation rate.
+	TargetTimespan time.Duration
+
+	// TargetTimePerBlock is the desired amount of time to generate each
+	// block.
+	TargetTimePerBlock time.Duration
+
+	// RetargetAdjustmentFactor is the adjustment factor used to limit
+	// the minimum and maximum amount of adjustment that can occur between
+	// difficulty retargets.
+	RetargetAdjustmentFactor int64
+
+	// ReduceMinDifficulty defines whether the network should reduce the
+	// minimum required difficulty after a long enough period of time has
+	// passed without finding a block.  This is really only useful for test
+	// networks and should not be set on a main network.
+	ReduceMinDifficulty bool
+
+	// MinDiffReductionTime is the amount of time after which the minimum
+	// required difficulty should be reduced when a block hasn't been found.
+	//
+	// NOTE: This only applies if ReduceMinDifficulty is true.
+	MinDiffReductionTime time.Duration
+
+	// GenerateSupported specifies whether or not CPU mining is allowed.
+	GenerateSupported bool
+
+	// Checkpoints ordered from oldest to newest.
+	Checkpoints []Checkpoint
+
+	// These fields are related to voting on consensus rule changes as
+	// defined by BIP0009.
+	//
+	// RuleChangeActivationThreshold is the number of blocks in a threshold
+	// state retarget window for which a positive vote for a rule change
+	// must be cast in order to lock in a rule change. It should typically
+	// be 95% for the main network and 75% for test networks.
+	//
+	// MinerConfirmationWindow is the number of blocks in each threshold
+	// state retarget window.
+	//
+	// Deployments define the specific consensus rule changes to be voted
+	// on.
+	RuleChangeActivationThreshold uint32
+	MinerConfirmationWindow       uint32
+	Deployments                   [DefinedDeployments]ConsensusDeployment
+
+	// Mempool parameters
+	RelayNonStdTxs bool
+
+	// Human-readable part for Bech32 encoded segwit addresses, as defined
+	// in BIP 173.
+	Bech32HRPSegwit string
+
+	// Address encoding magics
+	PubKeyHashAddrID        byte // First byte of a P2PKH address
+	ScriptHashAddrID        byte // First byte of a P2SH address
+	PrivateKeyID            byte // First byte of a WIF private key
+	WitnessPubKeyHashAddrID byte // First byte of a P2WPKH address
+	WitnessScriptHashAddrID byte // First byte of a P2WSH address
+
+	// BIP32 hierarchical deterministic extended key magics
+	HDPrivateKeyID [4]byte
+	HDPublicKeyID  [4]byte
+
+	// BIP44 coin type used in the hierarchical deterministic path for
+	// address generation.
+	HDCoinType uint32
+}
+
+// MainNetParams defines the network parameters for the main Litecoin network.
+var MainNetParams = Params{
+	Name:        "mainnet",
+	Net:         wire.MainNet,
+	DefaultPort: "9333",
+	DNSSeeds: []DNSSeed{
+		{"seed-a.litecoin.loshan.co.uk", true},
+		{"dnsseed.thrasher.io", true},
+		{"dnsseed.litecointools.com", false},
+		{"dnsseed.litecoinpool.org", false},
+		{"dnsseed.koin-project.com", false},
+	},
+
+	// Chain parameters
+	GenesisBlock:             &genesisBlock,
+	GenesisHash:              &genesisHash,
+	PowLimit:                 mainPowLimit,
+	PowLimitBits:             504365055,
+	BIP0034Height:            710000,
+	BIP0065Height:            918684,
+	BIP0066Height:            811879,
+	CoinbaseMaturity:         100,
+	SubsidyReductionInterval: 840000,
+	TargetTimespan:           (time.Hour * 24 * 3) + (time.Hour * 12), // 3.5 days
+	TargetTimePerBlock:       (time.Minute * 2) + (time.Second * 30),  // 2.5 minutes
+	RetargetAdjustmentFactor: 4,                                       // 25% less, 400% more
+	ReduceMinDifficulty:      false,
+	MinDiffReductionTime:     0,
+	GenerateSupported:        false,
+
+	// Checkpoints ordered from oldest to newest.
+	Checkpoints: []Checkpoint{
+		{1500, newHashFromStr("841a2965955dd288cfa707a755d05a54e45f8bd476835ec9af4402a2b59a2967")},
+		{4032, newHashFromStr("9ce90e427198fc0ef05e5905ce3503725b80e26afd35a987965fd7e3d9cf0846")},
+		{8064, newHashFromStr("eb984353fc5190f210651f150c40b8a4bab9eeeff0b729fcb3987da694430d70")},
+		{16128, newHashFromStr("602edf1859b7f9a6af809f1d9b0e6cb66fdc1d4d9dcd7a4bec03e12a1ccd153d")},
+		{23420, newHashFromStr("d80fdf9ca81afd0bd2b2a90ac3a9fe547da58f2530ec874e978fce0b5101b507")},
+		{50000, newHashFromStr("69dc37eb029b68f075a5012dcc0419c127672adb4f3a32882b2b3e71d07a20a6")},
+		{80000, newHashFromStr("4fcb7c02f676a300503f49c764a89955a8f920b46a8cbecb4867182ecdb2e90a")},
+		{120000, newHashFromStr("bd9d26924f05f6daa7f0155f32828ec89e8e29cee9e7121b026a7a3552ac6131")},
+		{161500, newHashFromStr("dbe89880474f4bb4f75c227c77ba1cdc024991123b28b8418dbbf7798471ff43")},
+		{179620, newHashFromStr("2ad9c65c990ac00426d18e446e0fd7be2ffa69e9a7dcb28358a50b2b78b9f709")},
+		{240000, newHashFromStr("7140d1c4b4c2157ca217ee7636f24c9c73db39c4590c4e6eab2e3ea1555088aa")},
+		{383640, newHashFromStr("2b6809f094a9215bafc65eb3f110a35127a34be94b7d0590a096c3f126c6f364")},
+		{409004, newHashFromStr("487518d663d9f1fa08611d9395ad74d982b667fbdc0e77e9cf39b4f1355908a3")},
+		{456000, newHashFromStr("bf34f71cc6366cd487930d06be22f897e34ca6a40501ac7d401be32456372004")},
+		{638902, newHashFromStr("15238656e8ec63d28de29a8c75fcf3a5819afc953dcd9cc45cecc53baec74f38")},
+		{721000, newHashFromStr("198a7b4de1df9478e2463bd99d75b714eab235a2e63e741641dc8a759a9840e5")},
+	},
+
+	// Consensus rule change deployments.
+	//
+	// The miner confirmation window is defined as:
+	//   target proof of work timespan / target proof of work spacing
+	RuleChangeActivationThreshold: 6048, // 75% of MinerConfirmationWindow
+	MinerConfirmationWindow:       8064, //
+	Deployments: [DefinedDeployments]ConsensusDeployment{
+		DeploymentTestDummy: {
+			BitNumber:  28,
+			StartTime:  1199145601, // January 1, 2008 UTC
+			ExpireTime: 1230767999, // December 31, 2008 UTC
+		},
+		DeploymentCSV: {
+			BitNumber:  0,
+			StartTime:  1485561600, // January 28, 2017 UTC
+			ExpireTime: 1517356801, // January 31st, 2018 UTC
+		},
+		DeploymentSegwit: {
+			BitNumber:  1,
+			StartTime:  1485561600, // January 28, 2017 UTC
+			ExpireTime: 1517356801, // January 31st, 2018 UTC.
+		},
+	},
+
+	// Mempool parameters
+	RelayNonStdTxs: false,
+
+	// Human-readable part for Bech32 encoded segwit addresses, as defined in
+	// BIP 173.
+	Bech32HRPSegwit: "ltc", // always ltc for main net
+
+	// Address encoding magics
+	PubKeyHashAddrID:        0x30, // starts with L
+	ScriptHashAddrID:        0x32, // starts with M
+	PrivateKeyID:            0xB0, // starts with 6 (uncompressed) or T (compressed)
+	WitnessPubKeyHashAddrID: 0x06, // starts with p2
+	WitnessScriptHashAddrID: 0x0A, // starts with 7Xh
+
+	// BIP32 hierarchical deterministic extended key magics
+	HDPrivateKeyID: [4]byte{0x04, 0x88, 0xad, 0xe4}, // starts with xprv
+	HDPublicKeyID:  [4]byte{0x04, 0x88, 0xb2, 0x1e}, // starts with xpub
+
+	// BIP44 coin type used in the hierarchical deterministic path for
+	// address generation.
+	HDCoinType: 2,
+}
+
+// RegressionNetParams defines the network parameters for the regression test
+// Litecoin network.  Not to be confused with the test Litecoin network (version
+// 3), this network is sometimes simply called "testnet".
+var RegressionNetParams = Params{
+	Name:        "regtest",
+	Net:         wire.TestNet,
+	DefaultPort: "18444",
+	DNSSeeds:    []DNSSeed{},
+
+	// Chain parameters
+	GenesisBlock:             &regTestGenesisBlock,
+	GenesisHash:              &regTestGenesisHash,
+	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,
+
+	// Consensus rule change deployments.
+	//
+	// The miner confirmation window is defined as:
+	//   target proof of work timespan / target proof of work spacing
+	RuleChangeActivationThreshold: 108, // 75%  of MinerConfirmationWindow
+	MinerConfirmationWindow:       144,
+	Deployments: [DefinedDeployments]ConsensusDeployment{
+		DeploymentTestDummy: {
+			BitNumber:  28,
+			StartTime:  0,             // Always available for vote
+			ExpireTime: math.MaxInt64, // Never expires
+		},
+		DeploymentCSV: {
+			BitNumber:  0,
+			StartTime:  0,             // Always available for vote
+			ExpireTime: math.MaxInt64, // Never expires
+		},
+		DeploymentSegwit: {
+			BitNumber:  1,
+			StartTime:  0,             // Always available for vote
+			ExpireTime: math.MaxInt64, // Never expires.
+		},
+	},
+
+	// Mempool parameters
+	RelayNonStdTxs: true,
+
+	// Human-readable part for Bech32 encoded segwit addresses, as defined in
+	// BIP 173.
+	Bech32HRPSegwit: "bcrt", // always bcrt for reg test net
+
+	// 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,
+}
+
+// TestNet4Params defines the network parameters for the test Litecoin network
+// (version 4).  Not to be confused with the regression test network, this
+// network is sometimes simply called "testnet".
+var TestNet4Params = Params{
+	Name:        "testnet4",
+	Net:         wire.TestNet4,
+	DefaultPort: "19335",
+	DNSSeeds: []DNSSeed{
+		{"testnet-seed.litecointools.com", false},
+		{"seed-b.litecoin.loshan.co.uk", true},
+		{"dnsseed-testnet.thrasher.io", true},
+	},
+
+	// Chain parameters
+	GenesisBlock:             &testNet4GenesisBlock,
+	GenesisHash:              &testNet4GenesisHash,
+	PowLimit:                 testNet4PowLimit,
+	PowLimitBits:             504365055,
+	BIP0034Height:            76,
+	BIP0065Height:            76,
+	BIP0066Height:            76,
+	CoinbaseMaturity:         100,
+	SubsidyReductionInterval: 840000,
+	TargetTimespan:           (time.Hour * 24 * 3) + (time.Hour * 12), // 3.5 days
+	TargetTimePerBlock:       (time.Minute * 2) + (time.Second * 30),  // 2.5 minutes
+	RetargetAdjustmentFactor: 4,                                       // 25% less, 400% more
+	ReduceMinDifficulty:      true,
+	MinDiffReductionTime:     time.Minute * 5, // TargetTimePerBlock * 2
+	GenerateSupported:        false,
+
+	// Checkpoints ordered from oldest to newest.
+	Checkpoints: []Checkpoint{
+		{26115, newHashFromStr("817d5b509e91ab5e439652eee2f59271bbc7ba85021d720cdb6da6565b43c14f")},
+		{43928, newHashFromStr("7d86614c153f5ef6ad878483118ae523e248cd0dd0345330cb148e812493cbb4")},
+		{69296, newHashFromStr("66c2f58da3cfd282093b55eb09c1f5287d7a18801a8ff441830e67e8771010df")},
+		{99949, newHashFromStr("8dd471cb5aecf5ead91e7e4b1e932c79a0763060f8d93671b6801d115bfc6cde")},
+		{159256, newHashFromStr("ab5b0b9968842f5414804591119d6db829af606864b1959a25d6f5c114afb2b7")},
+	},
+
+	// Consensus rule change deployments.
+	//
+	// The miner confirmation window is defined as:
+	//   target proof of work timespan / target proof of work spacing
+	RuleChangeActivationThreshold: 1512, // 75% of MinerConfirmationWindow
+	MinerConfirmationWindow:       2016,
+	Deployments: [DefinedDeployments]ConsensusDeployment{
+		DeploymentTestDummy: {
+			BitNumber:  28,
+			StartTime:  1199145601, // January 1, 2008 UTC
+			ExpireTime: 1230767999, // December 31, 2008 UTC
+		},
+		DeploymentCSV: {
+			BitNumber:  0,
+			StartTime:  1483228800, // January 1, 2017
+			ExpireTime: 1517356801, // January 31st, 2018
+		},
+		DeploymentSegwit: {
+			BitNumber:  1,
+			StartTime:  1483228800, // January 1, 2017
+			ExpireTime: 1517356801, // January 31st, 2018
+		},
+	},
+
+	// Mempool parameters
+	RelayNonStdTxs: true,
+
+	// Human-readable part for Bech32 encoded segwit addresses, as defined in
+	// BIP 173.
+	Bech32HRPSegwit: "tltc", // always tltc for test net
+
+	// Address encoding magics
+	PubKeyHashAddrID:        0x6f, // starts with m or n
+	ScriptHashAddrID:        0x3a, // starts with Q
+	WitnessPubKeyHashAddrID: 0x52, // starts with QW
+	WitnessScriptHashAddrID: 0x31, // starts with T7n
+	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,
+}
+
+// SimNetParams defines the network parameters for the simulation test Litecoin
+// network.  This network is similar to the normal test network except it is
+// intended for private use within a group of individuals doing simulation
+// testing.  The functionality is intended to differ in that the only nodes
+// which are specifically specified are used to create the network rather than
+// following normal discovery rules.  This is important as otherwise it would
+// just turn into another public testnet.
+var SimNetParams = Params{
+	Name:        "simnet",
+	Net:         wire.SimNet,
+	DefaultPort: "18555",
+	DNSSeeds:    []DNSSeed{}, // NOTE: There must NOT be any seeds.
+
+	// Chain parameters
+	GenesisBlock:             &simNetGenesisBlock,
+	GenesisHash:              &simNetGenesisHash,
+	PowLimit:                 simNetPowLimit,
+	PowLimitBits:             0x207fffff,
+	BIP0034Height:            0, // Always active on simnet
+	BIP0065Height:            0, // Always active on simnet
+	BIP0066Height:            0, // Always active on simnet
+	CoinbaseMaturity:         100,
+	SubsidyReductionInterval: 210000,
+	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,
+
+	// Consensus rule change deployments.
+	//
+	// The miner confirmation window is defined as:
+	//   target proof of work timespan / target proof of work spacing
+	RuleChangeActivationThreshold: 75, // 75% of MinerConfirmationWindow
+	MinerConfirmationWindow:       100,
+	Deployments: [DefinedDeployments]ConsensusDeployment{
+		DeploymentTestDummy: {
+			BitNumber:  28,
+			StartTime:  0,             // Always available for vote
+			ExpireTime: math.MaxInt64, // Never expires
+		},
+		DeploymentCSV: {
+			BitNumber:  0,
+			StartTime:  0,             // Always available for vote
+			ExpireTime: math.MaxInt64, // Never expires
+		},
+		DeploymentSegwit: {
+			BitNumber:  1,
+			StartTime:  0,             // Always available for vote
+			ExpireTime: math.MaxInt64, // Never expires.
+		},
+	},
+
+	// Mempool parameters
+	RelayNonStdTxs: true,
+
+	// Human-readable part for Bech32 encoded segwit addresses, as defined in
+	// BIP 173.
+	Bech32HRPSegwit: "sltc", // always lsb for sim net
+
+	// Address encoding magics
+	PubKeyHashAddrID:        0x3f, // starts with S
+	ScriptHashAddrID:        0x7b, // starts with s
+	PrivateKeyID:            0x64, // starts with 4 (uncompressed) or F (compressed)
+	WitnessPubKeyHashAddrID: 0x19, // starts with Gg
+	WitnessScriptHashAddrID: 0x28, // starts with ?
+
+	// BIP32 hierarchical deterministic extended key magics
+	HDPrivateKeyID: [4]byte{0x04, 0x20, 0xb9, 0x00}, // starts with sprv
+	HDPublicKeyID:  [4]byte{0x04, 0x20, 0xbd, 0x3a}, // starts with spub
+
+	// BIP44 coin type used in the hierarchical deterministic path for
+	// address generation.
+	HDCoinType: 115, // ASCII for s
+}
+
+var (
+	// ErrDuplicateNet describes an error where the parameters for a Litecoin
+	// network could not be set due to the network already being a standard
+	// network or previously-registered into this package.
+	ErrDuplicateNet = errors.New("duplicate Litecoin network")
+
+	// ErrUnknownHDKeyID describes an error where the provided id which
+	// is intended to identify the network for a hierarchical deterministic
+	// private extended key is not registered.
+	ErrUnknownHDKeyID = errors.New("unknown hd private extended key bytes")
+)
+
+var (
+	registeredNets       = make(map[wire.BitcoinNet]struct{})
+	pubKeyHashAddrIDs    = make(map[byte]struct{})
+	scriptHashAddrIDs    = make(map[byte]struct{})
+	bech32SegwitPrefixes = make(map[string]struct{})
+	hdPrivToPubKeyIDs    = make(map[[4]byte][]byte)
+)
+
+// String returns the hostname of the DNS seed in human-readable form.
+func (d DNSSeed) String() string {
+	return d.Host
+}
+
+// Register registers the network parameters for a Litecoin network.  This may
+// error with ErrDuplicateNet if the network is already registered (either
+// due to a previous Register call, or the network being one of the default
+// networks).
+//
+// Network parameters should be registered into this package by a main package
+// as early as possible.  Then, library packages may lookup networks or network
+// parameters based on inputs and work regardless of the network being standard
+// or not.
+func Register(params *Params) error {
+	if _, ok := registeredNets[params.Net]; ok {
+		return ErrDuplicateNet
+	}
+	registeredNets[params.Net] = struct{}{}
+	pubKeyHashAddrIDs[params.PubKeyHashAddrID] = struct{}{}
+	scriptHashAddrIDs[params.ScriptHashAddrID] = struct{}{}
+	hdPrivToPubKeyIDs[params.HDPrivateKeyID] = params.HDPublicKeyID[:]
+
+	// A valid Bech32 encoded segwit address always has as prefix the
+	// human-readable part for the given net followed by '1'.
+	bech32SegwitPrefixes[params.Bech32HRPSegwit+"1"] = struct{}{}
+	return nil
+}
+
+// mustRegister performs the same function as Register except it panics if there
+// is an error.  This should only be called from package init functions.
+func mustRegister(params *Params) {
+	if err := Register(params); err != nil {
+		panic("failed to register network: " + err.Error())
+	}
+}
+
+// IsPubKeyHashAddrID returns whether the id is an identifier known to prefix a
+// pay-to-pubkey-hash address on any default or registered network.  This is
+// used when decoding an address string into a specific address type.  It is up
+// to the caller to check both this and IsScriptHashAddrID and decide whether an
+// address is a pubkey hash address, script hash address, neither, or
+// undeterminable (if both return true).
+func IsPubKeyHashAddrID(id byte) bool {
+	_, ok := pubKeyHashAddrIDs[id]
+	return ok
+}
+
+// IsScriptHashAddrID returns whether the id is an identifier known to prefix a
+// pay-to-script-hash address on any default or registered network.  This is
+// used when decoding an address string into a specific address type.  It is up
+// to the caller to check both this and IsPubKeyHashAddrID and decide whether an
+// address is a pubkey hash address, script hash address, neither, or
+// undeterminable (if both return true).
+func IsScriptHashAddrID(id byte) bool {
+	_, ok := scriptHashAddrIDs[id]
+	return ok
+}
+
+// IsBech32SegwitPrefix returns whether the prefix is a known prefix for segwit
+// addresses on any default or registered network.  This is used when decoding
+// an address string into a specific address type.
+func IsBech32SegwitPrefix(prefix string) bool {
+	prefix = strings.ToLower(prefix)
+	_, ok := bech32SegwitPrefixes[prefix]
+	return ok
+}
+
+// HDPrivateKeyToPublicKeyID accepts a private hierarchical deterministic
+// extended key id and returns the associated public key id.  When the provided
+// id is not registered, the ErrUnknownHDKeyID error will be returned.
+func HDPrivateKeyToPublicKeyID(id []byte) ([]byte, error) {
+	if len(id) != 4 {
+		return nil, ErrUnknownHDKeyID
+	}
+
+	var key [4]byte
+	copy(key[:], id)
+	pubBytes, ok := hdPrivToPubKeyIDs[key]
+	if !ok {
+		return nil, ErrUnknownHDKeyID
+	}
+
+	return pubBytes, nil
+}
+
+// newHashFromStr converts the passed big-endian hex string into a
+// chainhash.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 {
+		// Ordinarily I don't like panics in library code since it
+		// can take applications down without them having a chance to
+		// recover which is extremely annoying, however an exception is
+		// being made in this case because the only way this can panic
+		// is if there is an error in the hard-coded hashes.  Thus it
+		// will only ever potentially panic on init and therefore is
+		// 100% predictable.
+		panic(err)
+	}
+	return hash
+}
+
+func init() {
+	// Register all default networks when the package is initialized.
+	mustRegister(&MainNetParams)
+	mustRegister(&TestNet4Params)
+	mustRegister(&RegressionNetParams)
+	mustRegister(&SimNetParams)
+}

vendor/github.com/ltcsuite/ltcd/wire/README.md

@@ -0,0 +1,113 @@
+wire
+====
+
+[![Build Status](http://img.shields.io/travis/ltcsuite/ltcd.svg)](https://travis-ci.org/ltcsuite/ltcd)
+[![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/ltcsuite/ltcd/wire)
+=======
+
+Package wire implements the bitcoin wire protocol.  A comprehensive suite of
+tests with 100% test coverage is provided to ensure proper functionality.
+
+There is an associated blog post about the release of this package
+[here](https://blog.conformal.com/btcwire-the-bitcoin-wire-protocol-package-from-ltcd/).
+
+This package has intentionally been designed so it can be used as a standalone
+package for any projects needing to interface with bitcoin peers at the wire
+protocol level.
+
+## Installation and Updating
+
+```bash
+$ go get -u github.com/ltcsuite/ltcd/wire
+```
+
+## Bitcoin Message Overview
+
+The bitcoin protocol consists of exchanging messages between peers. Each message
+is preceded by a header which identifies information about it such as which
+bitcoin network it is a part of, its type, how big it is, and a checksum to
+verify validity. All encoding and decoding of message headers is handled by this
+package.
+
+To accomplish this, there is a generic interface for bitcoin messages named
+`Message` which allows messages of any type to be read, written, or passed
+around through channels, functions, etc. In addition, concrete implementations
+of most of the currently supported bitcoin messages are provided. For these
+supported messages, all of the details of marshalling and unmarshalling to and
+from the wire using bitcoin encoding are handled so the caller doesn't have to
+concern themselves with the specifics.
+
+## Reading Messages Example
+
+In order to unmarshal bitcoin messages from the wire, use the `ReadMessage`
+function. It accepts any `io.Reader`, but typically this will be a `net.Conn`
+to a remote node running a bitcoin peer.  Example syntax is:
+
+```Go
+	// Use the most recent protocol version supported by the package and the
+	// main bitcoin network.
+	pver := wire.ProtocolVersion
+	btcnet := wire.MainNet
+
+	// Reads and validates the next bitcoin message from conn using the
+	// protocol version pver and the bitcoin network btcnet.  The returns
+	// are a wire.Message, a []byte which contains the unmarshalled
+	// raw payload, and a possible error.
+	msg, rawPayload, err := wire.ReadMessage(conn, pver, btcnet)
+	if err != nil {
+		// Log and handle the error
+	}
+```
+
+See the package documentation for details on determining the message type.
+
+## Writing Messages Example
+
+In order to marshal bitcoin messages to the wire, use the `WriteMessage`
+function. It accepts any `io.Writer`, but typically this will be a `net.Conn`
+to a remote node running a bitcoin peer. Example syntax to request addresses
+from a remote peer is:
+
+```Go
+	// Use the most recent protocol version supported by the package and the
+	// main bitcoin network.
+	pver := wire.ProtocolVersion
+	btcnet := wire.MainNet
+
+	// Create a new getaddr bitcoin message.
+	msg := wire.NewMsgGetAddr()
+
+	// Writes a bitcoin message msg to conn using the protocol version
+	// pver, and the bitcoin network btcnet.  The return is a possible
+	// error.
+	err := wire.WriteMessage(conn, msg, pver, btcnet)
+	if err != nil {
+		// Log and handle the error
+	}
+```
+
+## 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 wire is licensed under the [copyfree](http://copyfree.org) ISC
+License.

vendor/github.com/ltcsuite/ltcd/wire/blockheader.go

@@ -0,0 +1,147 @@
+// 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 wire
+
+import (
+	"bytes"
+	"io"
+	"time"
+
+	"golang.org/x/crypto/scrypt"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+// MaxBlockHeaderPayload is the maximum number of bytes a block header can be.
+// Version 4 bytes + Timestamp 4 bytes + Bits 4 bytes + Nonce 4 bytes +
+// PrevBlock and MerkleRoot hashes.
+const MaxBlockHeaderPayload = 16 + (chainhash.HashSize * 2)
+
+// BlockHeader defines information about a block and is used in the bitcoin
+// block (MsgBlock) and headers (MsgHeaders) messages.
+type BlockHeader struct {
+	// Version of the block.  This is not the same as the protocol version.
+	Version int32
+
+	// Hash of the previous block header in the block chain.
+	PrevBlock chainhash.Hash
+
+	// Merkle tree reference to hash of all transactions for the block.
+	MerkleRoot chainhash.Hash
+
+	// Time the block was created.  This is, unfortunately, encoded as a
+	// uint32 on the wire and therefore is limited to 2106.
+	Timestamp time.Time
+
+	// Difficulty target for the block.
+	Bits uint32
+
+	// Nonce used to generate the block.
+	Nonce uint32
+}
+
+// blockHeaderLen is a constant that represents the number of bytes for a block
+// header.
+const blockHeaderLen = 80
+
+// BlockHash computes the block identifier hash for the given block header.
+func (h *BlockHeader) BlockHash() chainhash.Hash {
+	// Encode the header and double sha256 everything prior to the number of
+	// transactions.  Ignore the error returns since there is no way the
+	// encode could fail except being out of memory which would cause a
+	// run-time panic.
+	buf := bytes.NewBuffer(make([]byte, 0, MaxBlockHeaderPayload))
+	_ = writeBlockHeader(buf, 0, h)
+
+	return chainhash.DoubleHashH(buf.Bytes())
+}
+
+// PowHash returns the litecoin scrypt hash of this block header. This value is
+// used to check the PoW on blocks advertised on the network.
+func (h *BlockHeader) PowHash() (*chainhash.Hash, error) {
+	var powHash chainhash.Hash
+
+	buf := bytes.NewBuffer(make([]byte, 0, MaxBlockHeaderPayload))
+	_ = writeBlockHeader(buf, 0, h)
+
+	scryptHash, err := scrypt.Key(buf.Bytes(), buf.Bytes(), 1024, 1, 1, 32)
+	if err != nil {
+		return nil, err
+	}
+	copy(powHash[:], scryptHash)
+
+	return &powHash, nil
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+// See Deserialize for decoding block headers stored to disk, such as in a
+// database, as opposed to decoding block headers from the wire.
+func (h *BlockHeader) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	return readBlockHeader(r, pver, h)
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+// See Serialize for encoding block headers to be stored to disk, such as in a
+// database, as opposed to encoding block headers for the wire.
+func (h *BlockHeader) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	return writeBlockHeader(w, pver, h)
+}
+
+// Deserialize decodes a block header from r into the receiver using a format
+// that is suitable for long-term storage such as a database while respecting
+// the Version field.
+func (h *BlockHeader) Deserialize(r io.Reader) error {
+	// At the current time, there is no difference between the wire encoding
+	// at protocol version 0 and the stable long-term storage format.  As
+	// a result, make use of readBlockHeader.
+	return readBlockHeader(r, 0, h)
+}
+
+// Serialize encodes a block header from r into the receiver using a format
+// that is suitable for long-term storage such as a database while respecting
+// the Version field.
+func (h *BlockHeader) Serialize(w io.Writer) error {
+	// At the current time, there is no difference between the wire encoding
+	// at protocol version 0 and the stable long-term storage format.  As
+	// a result, make use of writeBlockHeader.
+	return writeBlockHeader(w, 0, h)
+}
+
+// NewBlockHeader returns a new BlockHeader using the provided version, previous
+// block hash, merkle root hash, difficulty bits, and nonce used to generate the
+// block with defaults for the remaining fields.
+func NewBlockHeader(version int32, prevHash, merkleRootHash *chainhash.Hash,
+	bits uint32, nonce uint32) *BlockHeader {
+
+	// Limit the timestamp to one second precision since the protocol
+	// doesn't support better.
+	return &BlockHeader{
+		Version:    version,
+		PrevBlock:  *prevHash,
+		MerkleRoot: *merkleRootHash,
+		Timestamp:  time.Unix(time.Now().Unix(), 0),
+		Bits:       bits,
+		Nonce:      nonce,
+	}
+}
+
+// readBlockHeader reads a bitcoin block header from r.  See Deserialize for
+// decoding block headers stored to disk, such as in a database, as opposed to
+// decoding from the wire.
+func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
+	return readElements(r, &bh.Version, &bh.PrevBlock, &bh.MerkleRoot,
+		(*uint32Time)(&bh.Timestamp), &bh.Bits, &bh.Nonce)
+}
+
+// writeBlockHeader writes a bitcoin block header to w.  See Serialize for
+// encoding block headers to be stored to disk, such as in a database, as
+// opposed to encoding for the wire.
+func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error {
+	sec := uint32(bh.Timestamp.Unix())
+	return writeElements(w, bh.Version, &bh.PrevBlock, &bh.MerkleRoot,
+		sec, bh.Bits, bh.Nonce)
+}

vendor/github.com/ltcsuite/ltcd/wire/common.go

@@ -0,0 +1,689 @@
+// 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 wire
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"math"
+	"time"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+const (
+	// MaxVarIntPayload is the maximum payload size for a variable length integer.
+	MaxVarIntPayload = 9
+
+	// binaryFreeListMaxItems is the number of buffers to keep in the free
+	// list to use for binary serialization and deserialization.
+	binaryFreeListMaxItems = 1024
+)
+
+var (
+	// littleEndian is a convenience variable since binary.LittleEndian is
+	// quite long.
+	littleEndian = binary.LittleEndian
+
+	// bigEndian is a convenience variable since binary.BigEndian is quite
+	// long.
+	bigEndian = binary.BigEndian
+)
+
+// binaryFreeList defines a concurrent safe free list of byte slices (up to the
+// maximum number defined by the binaryFreeListMaxItems constant) that have a
+// cap of 8 (thus it supports up to a uint64).  It is used to provide temporary
+// buffers for serializing and deserializing primitive numbers to and from their
+// binary encoding in order to greatly reduce the number of allocations
+// required.
+//
+// For convenience, functions are provided for each of the primitive unsigned
+// integers that automatically obtain a buffer from the free list, perform the
+// necessary binary conversion, read from or write to the given io.Reader or
+// io.Writer, and return the buffer to the free list.
+type binaryFreeList chan []byte
+
+// Borrow returns a byte slice from the free list with a length of 8.  A new
+// buffer is allocated if there are not any available on the free list.
+func (l binaryFreeList) Borrow() []byte {
+	var buf []byte
+	select {
+	case buf = <-l:
+	default:
+		buf = make([]byte, 8)
+	}
+	return buf[:8]
+}
+
+// Return puts the provided byte slice back on the free list.  The buffer MUST
+// have been obtained via the Borrow function and therefore have a cap of 8.
+func (l binaryFreeList) Return(buf []byte) {
+	select {
+	case l <- buf:
+	default:
+		// Let it go to the garbage collector.
+	}
+}
+
+// Uint8 reads a single byte from the provided reader using a buffer from the
+// free list and returns it as a uint8.
+func (l binaryFreeList) Uint8(r io.Reader) (uint8, error) {
+	buf := l.Borrow()[:1]
+	if _, err := io.ReadFull(r, buf); err != nil {
+		l.Return(buf)
+		return 0, err
+	}
+	rv := buf[0]
+	l.Return(buf)
+	return rv, nil
+}
+
+// Uint16 reads two bytes from the provided reader using a buffer from the
+// free list, converts it to a number using the provided byte order, and returns
+// the resulting uint16.
+func (l binaryFreeList) Uint16(r io.Reader, byteOrder binary.ByteOrder) (uint16, error) {
+	buf := l.Borrow()[:2]
+	if _, err := io.ReadFull(r, buf); err != nil {
+		l.Return(buf)
+		return 0, err
+	}
+	rv := byteOrder.Uint16(buf)
+	l.Return(buf)
+	return rv, nil
+}
+
+// Uint32 reads four bytes from the provided reader using a buffer from the
+// free list, converts it to a number using the provided byte order, and returns
+// the resulting uint32.
+func (l binaryFreeList) Uint32(r io.Reader, byteOrder binary.ByteOrder) (uint32, error) {
+	buf := l.Borrow()[:4]
+	if _, err := io.ReadFull(r, buf); err != nil {
+		l.Return(buf)
+		return 0, err
+	}
+	rv := byteOrder.Uint32(buf)
+	l.Return(buf)
+	return rv, nil
+}
+
+// Uint64 reads eight bytes from the provided reader using a buffer from the
+// free list, converts it to a number using the provided byte order, and returns
+// the resulting uint64.
+func (l binaryFreeList) Uint64(r io.Reader, byteOrder binary.ByteOrder) (uint64, error) {
+	buf := l.Borrow()[:8]
+	if _, err := io.ReadFull(r, buf); err != nil {
+		l.Return(buf)
+		return 0, err
+	}
+	rv := byteOrder.Uint64(buf)
+	l.Return(buf)
+	return rv, nil
+}
+
+// PutUint8 copies the provided uint8 into a buffer from the free list and
+// writes the resulting byte to the given writer.
+func (l binaryFreeList) PutUint8(w io.Writer, val uint8) error {
+	buf := l.Borrow()[:1]
+	buf[0] = val
+	_, err := w.Write(buf)
+	l.Return(buf)
+	return err
+}
+
+// PutUint16 serializes the provided uint16 using the given byte order into a
+// buffer from the free list and writes the resulting two bytes to the given
+// writer.
+func (l binaryFreeList) PutUint16(w io.Writer, byteOrder binary.ByteOrder, val uint16) error {
+	buf := l.Borrow()[:2]
+	byteOrder.PutUint16(buf, val)
+	_, err := w.Write(buf)
+	l.Return(buf)
+	return err
+}
+
+// PutUint32 serializes the provided uint32 using the given byte order into a
+// buffer from the free list and writes the resulting four bytes to the given
+// writer.
+func (l binaryFreeList) PutUint32(w io.Writer, byteOrder binary.ByteOrder, val uint32) error {
+	buf := l.Borrow()[:4]
+	byteOrder.PutUint32(buf, val)
+	_, err := w.Write(buf)
+	l.Return(buf)
+	return err
+}
+
+// PutUint64 serializes the provided uint64 using the given byte order into a
+// buffer from the free list and writes the resulting eight bytes to the given
+// writer.
+func (l binaryFreeList) PutUint64(w io.Writer, byteOrder binary.ByteOrder, val uint64) error {
+	buf := l.Borrow()[:8]
+	byteOrder.PutUint64(buf, val)
+	_, err := w.Write(buf)
+	l.Return(buf)
+	return err
+}
+
+// binarySerializer provides a free list of buffers to use for serializing and
+// deserializing primitive integer values to and from io.Readers and io.Writers.
+var binarySerializer binaryFreeList = make(chan []byte, binaryFreeListMaxItems)
+
+// errNonCanonicalVarInt is the common format string used for non-canonically
+// encoded variable length integer errors.
+var errNonCanonicalVarInt = "non-canonical varint %x - discriminant %x must " +
+	"encode a value greater than %x"
+
+// uint32Time represents a unix timestamp encoded with a uint32.  It is used as
+// a way to signal the readElement function how to decode a timestamp into a Go
+// time.Time since it is otherwise ambiguous.
+type uint32Time time.Time
+
+// int64Time represents a unix timestamp encoded with an int64.  It is used as
+// a way to signal the readElement function how to decode a timestamp into a Go
+// time.Time since it is otherwise ambiguous.
+type int64Time time.Time
+
+// readElement reads the next sequence of bytes from r using little endian
+// depending on the concrete type of element pointed to.
+func readElement(r io.Reader, element interface{}) error {
+	// Attempt to read the element based on the concrete type via fast
+	// type assertions first.
+	switch e := element.(type) {
+	case *int32:
+		rv, err := binarySerializer.Uint32(r, littleEndian)
+		if err != nil {
+			return err
+		}
+		*e = int32(rv)
+		return nil
+
+	case *uint32:
+		rv, err := binarySerializer.Uint32(r, littleEndian)
+		if err != nil {
+			return err
+		}
+		*e = rv
+		return nil
+
+	case *int64:
+		rv, err := binarySerializer.Uint64(r, littleEndian)
+		if err != nil {
+			return err
+		}
+		*e = int64(rv)
+		return nil
+
+	case *uint64:
+		rv, err := binarySerializer.Uint64(r, littleEndian)
+		if err != nil {
+			return err
+		}
+		*e = rv
+		return nil
+
+	case *bool:
+		rv, err := binarySerializer.Uint8(r)
+		if err != nil {
+			return err
+		}
+		if rv == 0x00 {
+			*e = false
+		} else {
+			*e = true
+		}
+		return nil
+
+	// Unix timestamp encoded as a uint32.
+	case *uint32Time:
+		rv, err := binarySerializer.Uint32(r, binary.LittleEndian)
+		if err != nil {
+			return err
+		}
+		*e = uint32Time(time.Unix(int64(rv), 0))
+		return nil
+
+	// Unix timestamp encoded as an int64.
+	case *int64Time:
+		rv, err := binarySerializer.Uint64(r, binary.LittleEndian)
+		if err != nil {
+			return err
+		}
+		*e = int64Time(time.Unix(int64(rv), 0))
+		return nil
+
+	// Message header checksum.
+	case *[4]byte:
+		_, err := io.ReadFull(r, e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	// Message header command.
+	case *[CommandSize]uint8:
+		_, err := io.ReadFull(r, e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	// IP address.
+	case *[16]byte:
+		_, err := io.ReadFull(r, e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case *chainhash.Hash:
+		_, err := io.ReadFull(r, e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case *ServiceFlag:
+		rv, err := binarySerializer.Uint64(r, littleEndian)
+		if err != nil {
+			return err
+		}
+		*e = ServiceFlag(rv)
+		return nil
+
+	case *InvType:
+		rv, err := binarySerializer.Uint32(r, littleEndian)
+		if err != nil {
+			return err
+		}
+		*e = InvType(rv)
+		return nil
+
+	case *BitcoinNet:
+		rv, err := binarySerializer.Uint32(r, littleEndian)
+		if err != nil {
+			return err
+		}
+		*e = BitcoinNet(rv)
+		return nil
+
+	case *BloomUpdateType:
+		rv, err := binarySerializer.Uint8(r)
+		if err != nil {
+			return err
+		}
+		*e = BloomUpdateType(rv)
+		return nil
+
+	case *RejectCode:
+		rv, err := binarySerializer.Uint8(r)
+		if err != nil {
+			return err
+		}
+		*e = RejectCode(rv)
+		return nil
+	}
+
+	// Fall back to the slower binary.Read if a fast path was not available
+	// above.
+	return binary.Read(r, littleEndian, element)
+}
+
+// readElements reads multiple items from r.  It is equivalent to multiple
+// calls to readElement.
+func readElements(r io.Reader, elements ...interface{}) error {
+	for _, element := range elements {
+		err := readElement(r, element)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// writeElement writes the little endian representation of element to w.
+func writeElement(w io.Writer, element interface{}) error {
+	// Attempt to write the element based on the concrete type via fast
+	// type assertions first.
+	switch e := element.(type) {
+	case int32:
+		err := binarySerializer.PutUint32(w, littleEndian, uint32(e))
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case uint32:
+		err := binarySerializer.PutUint32(w, littleEndian, e)
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case int64:
+		err := binarySerializer.PutUint64(w, littleEndian, uint64(e))
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case uint64:
+		err := binarySerializer.PutUint64(w, littleEndian, e)
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case bool:
+		var err error
+		if e {
+			err = binarySerializer.PutUint8(w, 0x01)
+		} else {
+			err = binarySerializer.PutUint8(w, 0x00)
+		}
+		if err != nil {
+			return err
+		}
+		return nil
+
+	// Message header checksum.
+	case [4]byte:
+		_, err := w.Write(e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	// Message header command.
+	case [CommandSize]uint8:
+		_, err := w.Write(e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	// IP address.
+	case [16]byte:
+		_, err := w.Write(e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case *chainhash.Hash:
+		_, err := w.Write(e[:])
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case ServiceFlag:
+		err := binarySerializer.PutUint64(w, littleEndian, uint64(e))
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case InvType:
+		err := binarySerializer.PutUint32(w, littleEndian, uint32(e))
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case BitcoinNet:
+		err := binarySerializer.PutUint32(w, littleEndian, uint32(e))
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case BloomUpdateType:
+		err := binarySerializer.PutUint8(w, uint8(e))
+		if err != nil {
+			return err
+		}
+		return nil
+
+	case RejectCode:
+		err := binarySerializer.PutUint8(w, uint8(e))
+		if err != nil {
+			return err
+		}
+		return nil
+	}
+
+	// Fall back to the slower binary.Write if a fast path was not available
+	// above.
+	return binary.Write(w, littleEndian, element)
+}
+
+// writeElements writes multiple items to w.  It is equivalent to multiple
+// calls to writeElement.
+func writeElements(w io.Writer, elements ...interface{}) error {
+	for _, element := range elements {
+		err := writeElement(w, element)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ReadVarInt reads a variable length integer from r and returns it as a uint64.
+func ReadVarInt(r io.Reader, pver uint32) (uint64, error) {
+	discriminant, err := binarySerializer.Uint8(r)
+	if err != nil {
+		return 0, err
+	}
+
+	var rv uint64
+	switch discriminant {
+	case 0xff:
+		sv, err := binarySerializer.Uint64(r, littleEndian)
+		if err != nil {
+			return 0, err
+		}
+		rv = sv
+
+		// The encoding is not canonical if the value could have been
+		// encoded using fewer bytes.
+		min := uint64(0x100000000)
+		if rv < min {
+			return 0, messageError("ReadVarInt", fmt.Sprintf(
+				errNonCanonicalVarInt, rv, discriminant, min))
+		}
+
+	case 0xfe:
+		sv, err := binarySerializer.Uint32(r, littleEndian)
+		if err != nil {
+			return 0, err
+		}
+		rv = uint64(sv)
+
+		// The encoding is not canonical if the value could have been
+		// encoded using fewer bytes.
+		min := uint64(0x10000)
+		if rv < min {
+			return 0, messageError("ReadVarInt", fmt.Sprintf(
+				errNonCanonicalVarInt, rv, discriminant, min))
+		}
+
+	case 0xfd:
+		sv, err := binarySerializer.Uint16(r, littleEndian)
+		if err != nil {
+			return 0, err
+		}
+		rv = uint64(sv)
+
+		// The encoding is not canonical if the value could have been
+		// encoded using fewer bytes.
+		min := uint64(0xfd)
+		if rv < min {
+			return 0, messageError("ReadVarInt", fmt.Sprintf(
+				errNonCanonicalVarInt, rv, discriminant, min))
+		}
+
+	default:
+		rv = uint64(discriminant)
+	}
+
+	return rv, nil
+}
+
+// WriteVarInt serializes val to w using a variable number of bytes depending
+// on its value.
+func WriteVarInt(w io.Writer, pver uint32, val uint64) error {
+	if val < 0xfd {
+		return binarySerializer.PutUint8(w, uint8(val))
+	}
+
+	if val <= math.MaxUint16 {
+		err := binarySerializer.PutUint8(w, 0xfd)
+		if err != nil {
+			return err
+		}
+		return binarySerializer.PutUint16(w, littleEndian, uint16(val))
+	}
+
+	if val <= math.MaxUint32 {
+		err := binarySerializer.PutUint8(w, 0xfe)
+		if err != nil {
+			return err
+		}
+		return binarySerializer.PutUint32(w, littleEndian, uint32(val))
+	}
+
+	err := binarySerializer.PutUint8(w, 0xff)
+	if err != nil {
+		return err
+	}
+	return binarySerializer.PutUint64(w, littleEndian, val)
+}
+
+// VarIntSerializeSize returns the number of bytes it would take to serialize
+// val as a variable length integer.
+func VarIntSerializeSize(val uint64) int {
+	// The value is small enough to be represented by itself, so it's
+	// just 1 byte.
+	if val < 0xfd {
+		return 1
+	}
+
+	// Discriminant 1 byte plus 2 bytes for the uint16.
+	if val <= math.MaxUint16 {
+		return 3
+	}
+
+	// Discriminant 1 byte plus 4 bytes for the uint32.
+	if val <= math.MaxUint32 {
+		return 5
+	}
+
+	// Discriminant 1 byte plus 8 bytes for the uint64.
+	return 9
+}
+
+// ReadVarString reads a variable length string from r and returns it as a Go
+// string.  A variable length string is encoded as a variable length integer
+// containing the length of the string followed by the bytes that represent the
+// string itself.  An error is returned if the length is greater than the
+// maximum block payload size since it helps protect against memory exhaustion
+// attacks and forced panics through malformed messages.
+func ReadVarString(r io.Reader, pver uint32) (string, error) {
+	count, err := ReadVarInt(r, pver)
+	if err != nil {
+		return "", err
+	}
+
+	// Prevent variable length strings that are larger than the maximum
+	// message size.  It would be possible to cause memory exhaustion and
+	// panics without a sane upper bound on this count.
+	if count > MaxMessagePayload {
+		str := fmt.Sprintf("variable length string is too long "+
+			"[count %d, max %d]", count, MaxMessagePayload)
+		return "", messageError("ReadVarString", str)
+	}
+
+	buf := make([]byte, count)
+	_, err = io.ReadFull(r, buf)
+	if err != nil {
+		return "", err
+	}
+	return string(buf), nil
+}
+
+// WriteVarString serializes str to w as a variable length integer containing
+// the length of the string followed by the bytes that represent the string
+// itself.
+func WriteVarString(w io.Writer, pver uint32, str string) error {
+	err := WriteVarInt(w, pver, uint64(len(str)))
+	if err != nil {
+		return err
+	}
+	_, err = w.Write([]byte(str))
+	return err
+}
+
+// ReadVarBytes reads a variable length byte array.  A byte array is encoded
+// as a varInt containing the length of the array followed by the bytes
+// themselves.  An error is returned if the length is greater than the
+// passed maxAllowed parameter which helps protect against memory exhaustion
+// attacks and forced panics through malformed messages.  The fieldName
+// parameter is only used for the error message so it provides more context in
+// the error.
+func ReadVarBytes(r io.Reader, pver uint32, maxAllowed uint32,
+	fieldName string) ([]byte, error) {
+
+	count, err := ReadVarInt(r, pver)
+	if err != nil {
+		return nil, err
+	}
+
+	// Prevent byte array larger than the max message size.  It would
+	// be possible to cause memory exhaustion and panics without a sane
+	// upper bound on this count.
+	if count > uint64(maxAllowed) {
+		str := fmt.Sprintf("%s is larger than the max allowed size "+
+			"[count %d, max %d]", fieldName, count, maxAllowed)
+		return nil, messageError("ReadVarBytes", str)
+	}
+
+	b := make([]byte, count)
+	_, err = io.ReadFull(r, b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
+
+// WriteVarBytes serializes a variable length byte array to w as a varInt
+// containing the number of bytes, followed by the bytes themselves.
+func WriteVarBytes(w io.Writer, pver uint32, bytes []byte) error {
+	slen := uint64(len(bytes))
+	err := WriteVarInt(w, pver, slen)
+	if err != nil {
+		return err
+	}
+
+	_, err = w.Write(bytes)
+	return err
+}
+
+// randomUint64 returns a cryptographically random uint64 value.  This
+// unexported version takes a reader primarily to ensure the error paths
+// can be properly tested by passing a fake reader in the tests.
+func randomUint64(r io.Reader) (uint64, error) {
+	rv, err := binarySerializer.Uint64(r, bigEndian)
+	if err != nil {
+		return 0, err
+	}
+	return rv, nil
+}
+
+// RandomUint64 returns a cryptographically random uint64 value.
+func RandomUint64() (uint64, error) {
+	return randomUint64(rand.Reader)
+}

vendor/github.com/ltcsuite/ltcd/wire/doc.go

@@ -0,0 +1,162 @@
+// 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 wire implements the bitcoin wire protocol.
+
+For the complete details of the bitcoin protocol, see the official wiki entry
+at https://en.bitcoin.it/wiki/Protocol_specification.  The following only serves
+as a quick overview to provide information on how to use the package.
+
+At a high level, this package provides support for marshalling and unmarshalling
+supported bitcoin messages to and from the wire.  This package does not deal
+with the specifics of message handling such as what to do when a message is
+received.  This provides the caller with a high level of flexibility.
+
+Bitcoin Message Overview
+
+The bitcoin protocol consists of exchanging messages between peers.  Each
+message is preceded by a header which identifies information about it such as
+which bitcoin network it is a part of, its type, how big it is, and a checksum
+to verify validity.  All encoding and decoding of message headers is handled by
+this package.
+
+To accomplish this, there is a generic interface for bitcoin messages named
+Message which allows messages of any type to be read, written, or passed around
+through channels, functions, etc.  In addition, concrete implementations of most
+of the currently supported bitcoin messages are provided.  For these supported
+messages, all of the details of marshalling and unmarshalling to and from the
+wire using bitcoin encoding are handled so the caller doesn't have to concern
+themselves with the specifics.
+
+Message Interaction
+
+The following provides a quick summary of how the bitcoin messages are intended
+to interact with one another.  As stated above, these interactions are not
+directly handled by this package.  For more in-depth details about the
+appropriate interactions, see the official bitcoin protocol wiki entry at
+https://en.bitcoin.it/wiki/Protocol_specification.
+
+The initial handshake consists of two peers sending each other a version message
+(MsgVersion) followed by responding with a verack message (MsgVerAck).  Both
+peers use the information in the version message (MsgVersion) to negotiate
+things such as protocol version and supported services with each other.  Once
+the initial handshake is complete, the following chart indicates message
+interactions in no particular order.
+
+	Peer A Sends                          Peer B Responds
+	----------------------------------------------------------------------------
+	getaddr message (MsgGetAddr)          addr message (MsgAddr)
+	getblocks message (MsgGetBlocks)      inv message (MsgInv)
+	inv message (MsgInv)                  getdata message (MsgGetData)
+	getdata message (MsgGetData)          block message (MsgBlock) -or-
+	                                      tx message (MsgTx) -or-
+	                                      notfound message (MsgNotFound)
+	getheaders message (MsgGetHeaders)    headers message (MsgHeaders)
+	ping message (MsgPing)                pong message (MsgHeaders)* -or-
+	                                      (none -- Ability to send message is enough)
+
+	NOTES:
+	* The pong message was not added until later protocol versions as defined
+	  in BIP0031.  The BIP0031Version constant can be used to detect a recent
+	  enough protocol version for this purpose (version > BIP0031Version).
+
+Common Parameters
+
+There are several common parameters that arise when using this package to read
+and write bitcoin messages.  The following sections provide a quick overview of
+these parameters so the next sections can build on them.
+
+Protocol Version
+
+The protocol version should be negotiated with the remote peer at a higher
+level than this package via the version (MsgVersion) message exchange, however,
+this package provides the wire.ProtocolVersion constant which indicates the
+latest protocol version this package supports and is typically the value to use
+for all outbound connections before a potentially lower protocol version is
+negotiated.
+
+Litecoin Network
+
+The bitcoin network is a magic number which is used to identify the start of a
+message and which bitcoin network the message applies to.  This package provides
+the following constants:
+
+	wire.MainNet
+	wire.TestNet  (Regression test network)
+	wire.TestNet4 (Test network version 4)
+	wire.SimNet   (Simulation test network)
+
+Determining Message Type
+
+As discussed in the bitcoin message overview section, this package reads
+and writes bitcoin messages using a generic interface named Message.  In
+order to determine the actual concrete type of the message, use a type
+switch or type assertion.  An example of a type switch follows:
+
+	// Assumes msg is already a valid concrete message such as one created
+	// via NewMsgVersion or read via ReadMessage.
+	switch msg := msg.(type) {
+	case *wire.MsgVersion:
+		// The message is a pointer to a MsgVersion struct.
+		fmt.Printf("Protocol version: %v", msg.ProtocolVersion)
+	case *wire.MsgBlock:
+		// The message is a pointer to a MsgBlock struct.
+		fmt.Printf("Number of tx in block: %v", msg.Header.TxnCount)
+	}
+
+Reading Messages
+
+In order to unmarshall bitcoin messages from the wire, use the ReadMessage
+function.  It accepts any io.Reader, but typically this will be a net.Conn to
+a remote node running a bitcoin peer.  Example syntax is:
+
+	// Reads and validates the next bitcoin message from conn using the
+	// protocol version pver and the bitcoin network btcnet.  The returns
+	// are a wire.Message, a []byte which contains the unmarshalled
+	// raw payload, and a possible error.
+	msg, rawPayload, err := wire.ReadMessage(conn, pver, btcnet)
+	if err != nil {
+		// Log and handle the error
+	}
+
+Writing Messages
+
+In order to marshall bitcoin messages to the wire, use the WriteMessage
+function.  It accepts any io.Writer, but typically this will be a net.Conn to
+a remote node running a bitcoin peer.  Example syntax to request addresses
+from a remote peer is:
+
+	// Create a new getaddr bitcoin message.
+	msg := wire.NewMsgGetAddr()
+
+	// Writes a bitcoin message msg to conn using the protocol version
+	// pver, and the bitcoin network btcnet.  The return is a possible
+	// error.
+	err := wire.WriteMessage(conn, msg, pver, btcnet)
+	if err != nil {
+		// Log and handle the error
+	}
+
+Errors
+
+Errors returned by this package are either the raw errors provided by underlying
+calls to read/write from streams such as io.EOF, io.ErrUnexpectedEOF, and
+io.ErrShortWrite, or of type wire.MessageError.  This allows the caller to
+differentiate between general IO errors and malformed messages through type
+assertions.
+
+Bitcoin Improvement Proposals
+
+This package includes spec changes outlined by the following BIPs:
+
+	BIP0014 (https://github.com/bitcoin/bips/blob/master/bip-0014.mediawiki)
+	BIP0031 (https://github.com/bitcoin/bips/blob/master/bip-0031.mediawiki)
+	BIP0035 (https://github.com/bitcoin/bips/blob/master/bip-0035.mediawiki)
+	BIP0037 (https://github.com/bitcoin/bips/blob/master/bip-0037.mediawiki)
+	BIP0111	(https://github.com/bitcoin/bips/blob/master/bip-0111.mediawiki)
+	BIP0130 (https://github.com/bitcoin/bips/blob/master/bip-0130.mediawiki)
+	BIP0133 (https://github.com/bitcoin/bips/blob/master/bip-0133.mediawiki)
+*/
+package wire

vendor/github.com/ltcsuite/ltcd/wire/error.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"fmt"
+)
+
+// MessageError describes an issue with a message.
+// An example of some potential issues are messages from the wrong bitcoin
+// network, invalid commands, mismatched checksums, and exceeding max payloads.
+//
+// This provides a mechanism for the caller to type assert the error to
+// differentiate between general io errors such as io.EOF and issues that
+// resulted from malformed messages.
+type MessageError struct {
+	Func        string // Function name
+	Description string // Human readable description of the issue
+}
+
+// Error satisfies the error interface and prints human-readable errors.
+func (e *MessageError) Error() string {
+	if e.Func != "" {
+		return fmt.Sprintf("%v: %v", e.Func, e.Description)
+	}
+	return e.Description
+}
+
+// messageError creates an error for the given function and description.
+func messageError(f string, desc string) *MessageError {
+	return &MessageError{Func: f, Description: desc}
+}

vendor/github.com/ltcsuite/ltcd/wire/invvect.go

@@ -0,0 +1,86 @@
+// 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 wire
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+const (
+	// MaxInvPerMsg is the maximum number of inventory vectors that can be in a
+	// single bitcoin inv message.
+	MaxInvPerMsg = 50000
+
+	// Maximum payload size for an inventory vector.
+	maxInvVectPayload = 4 + chainhash.HashSize
+
+	// InvWitnessFlag denotes that the inventory vector type is requesting,
+	// or sending a version which includes witness data.
+	InvWitnessFlag = 1 << 30
+)
+
+// InvType represents the allowed types of inventory vectors.  See InvVect.
+type InvType uint32
+
+// These constants define the various supported inventory vector types.
+const (
+	InvTypeError                InvType = 0
+	InvTypeTx                   InvType = 1
+	InvTypeBlock                InvType = 2
+	InvTypeFilteredBlock        InvType = 3
+	InvTypeWitnessBlock         InvType = InvTypeBlock | InvWitnessFlag
+	InvTypeWitnessTx            InvType = InvTypeTx | InvWitnessFlag
+	InvTypeFilteredWitnessBlock InvType = InvTypeFilteredBlock | InvWitnessFlag
+)
+
+// Map of service flags back to their constant names for pretty printing.
+var ivStrings = map[InvType]string{
+	InvTypeError:                "ERROR",
+	InvTypeTx:                   "MSG_TX",
+	InvTypeBlock:                "MSG_BLOCK",
+	InvTypeFilteredBlock:        "MSG_FILTERED_BLOCK",
+	InvTypeWitnessBlock:         "MSG_WITNESS_BLOCK",
+	InvTypeWitnessTx:            "MSG_WITNESS_TX",
+	InvTypeFilteredWitnessBlock: "MSG_FILTERED_WITNESS_BLOCK",
+}
+
+// String returns the InvType in human-readable form.
+func (invtype InvType) String() string {
+	if s, ok := ivStrings[invtype]; ok {
+		return s
+	}
+
+	return fmt.Sprintf("Unknown InvType (%d)", uint32(invtype))
+}
+
+// InvVect defines a bitcoin inventory vector which is used to describe data,
+// as specified by the Type field, that a peer wants, has, or does not have to
+// another peer.
+type InvVect struct {
+	Type InvType        // Type of data
+	Hash chainhash.Hash // Hash of the data
+}
+
+// NewInvVect returns a new InvVect using the provided type and hash.
+func NewInvVect(typ InvType, hash *chainhash.Hash) *InvVect {
+	return &InvVect{
+		Type: typ,
+		Hash: *hash,
+	}
+}
+
+// readInvVect reads an encoded InvVect from r depending on the protocol
+// version.
+func readInvVect(r io.Reader, pver uint32, iv *InvVect) error {
+	return readElements(r, &iv.Type, &iv.Hash)
+}
+
+// writeInvVect serializes an InvVect to w depending on the protocol version.
+func writeInvVect(w io.Writer, pver uint32, iv *InvVect) error {
+	return writeElements(w, iv.Type, &iv.Hash)
+}

vendor/github.com/ltcsuite/ltcd/wire/message.go

@@ -0,0 +1,436 @@
+// 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 wire
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"unicode/utf8"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+// MessageHeaderSize is the number of bytes in a bitcoin message header.
+// Bitcoin network (magic) 4 bytes + command 12 bytes + payload length 4 bytes +
+// checksum 4 bytes.
+const MessageHeaderSize = 24
+
+// CommandSize is the fixed size of all commands in the common bitcoin message
+// header.  Shorter commands must be zero padded.
+const CommandSize = 12
+
+// MaxMessagePayload is the maximum bytes a message can be regardless of other
+// individual limits imposed by messages themselves.
+const MaxMessagePayload = (1024 * 1024 * 32) // 32MB
+
+// Commands used in bitcoin message headers which describe the type of message.
+const (
+	CmdVersion      = "version"
+	CmdVerAck       = "verack"
+	CmdGetAddr      = "getaddr"
+	CmdAddr         = "addr"
+	CmdGetBlocks    = "getblocks"
+	CmdInv          = "inv"
+	CmdGetData      = "getdata"
+	CmdNotFound     = "notfound"
+	CmdBlock        = "block"
+	CmdTx           = "tx"
+	CmdGetHeaders   = "getheaders"
+	CmdHeaders      = "headers"
+	CmdPing         = "ping"
+	CmdPong         = "pong"
+	CmdAlert        = "alert"
+	CmdMemPool      = "mempool"
+	CmdFilterAdd    = "filteradd"
+	CmdFilterClear  = "filterclear"
+	CmdFilterLoad   = "filterload"
+	CmdMerkleBlock  = "merkleblock"
+	CmdReject       = "reject"
+	CmdSendHeaders  = "sendheaders"
+	CmdFeeFilter    = "feefilter"
+	CmdGetCFilters  = "getcfilters"
+	CmdGetCFHeaders = "getcfheaders"
+	CmdGetCFCheckpt = "getcfcheckpt"
+	CmdCFilter      = "cfilter"
+	CmdCFHeaders    = "cfheaders"
+	CmdCFCheckpt    = "cfcheckpt"
+)
+
+// MessageEncoding represents the wire message encoding format to be used.
+type MessageEncoding uint32
+
+const (
+	// BaseEncoding encodes all messages in the default format specified
+	// for the Bitcoin wire protocol.
+	BaseEncoding MessageEncoding = 1 << iota
+
+	// WitnessEncoding encodes all messages other than transaction messages
+	// using the default Bitcoin wire protocol specification. For transaction
+	// messages, the new encoding format detailed in BIP0144 will be used.
+	WitnessEncoding
+)
+
+// LatestEncoding is the most recently specified encoding for the Bitcoin wire
+// protocol.
+var LatestEncoding = WitnessEncoding
+
+// Message is an interface that describes a bitcoin message.  A type that
+// implements Message has complete control over the representation of its data
+// and may therefore contain additional or fewer fields than those which
+// are used directly in the protocol encoded message.
+type Message interface {
+	BtcDecode(io.Reader, uint32, MessageEncoding) error
+	BtcEncode(io.Writer, uint32, MessageEncoding) error
+	Command() string
+	MaxPayloadLength(uint32) uint32
+}
+
+// makeEmptyMessage creates a message of the appropriate concrete type based
+// on the command.
+func makeEmptyMessage(command string) (Message, error) {
+	var msg Message
+	switch command {
+	case CmdVersion:
+		msg = &MsgVersion{}
+
+	case CmdVerAck:
+		msg = &MsgVerAck{}
+
+	case CmdGetAddr:
+		msg = &MsgGetAddr{}
+
+	case CmdAddr:
+		msg = &MsgAddr{}
+
+	case CmdGetBlocks:
+		msg = &MsgGetBlocks{}
+
+	case CmdBlock:
+		msg = &MsgBlock{}
+
+	case CmdInv:
+		msg = &MsgInv{}
+
+	case CmdGetData:
+		msg = &MsgGetData{}
+
+	case CmdNotFound:
+		msg = &MsgNotFound{}
+
+	case CmdTx:
+		msg = &MsgTx{}
+
+	case CmdPing:
+		msg = &MsgPing{}
+
+	case CmdPong:
+		msg = &MsgPong{}
+
+	case CmdGetHeaders:
+		msg = &MsgGetHeaders{}
+
+	case CmdHeaders:
+		msg = &MsgHeaders{}
+
+	case CmdAlert:
+		msg = &MsgAlert{}
+
+	case CmdMemPool:
+		msg = &MsgMemPool{}
+
+	case CmdFilterAdd:
+		msg = &MsgFilterAdd{}
+
+	case CmdFilterClear:
+		msg = &MsgFilterClear{}
+
+	case CmdFilterLoad:
+		msg = &MsgFilterLoad{}
+
+	case CmdMerkleBlock:
+		msg = &MsgMerkleBlock{}
+
+	case CmdReject:
+		msg = &MsgReject{}
+
+	case CmdSendHeaders:
+		msg = &MsgSendHeaders{}
+
+	case CmdFeeFilter:
+		msg = &MsgFeeFilter{}
+
+	case CmdGetCFilters:
+		msg = &MsgGetCFilters{}
+
+	case CmdGetCFHeaders:
+		msg = &MsgGetCFHeaders{}
+
+	case CmdGetCFCheckpt:
+		msg = &MsgGetCFCheckpt{}
+
+	case CmdCFilter:
+		msg = &MsgCFilter{}
+
+	case CmdCFHeaders:
+		msg = &MsgCFHeaders{}
+
+	case CmdCFCheckpt:
+		msg = &MsgCFCheckpt{}
+
+	default:
+		return nil, fmt.Errorf("unhandled command [%s]", command)
+	}
+	return msg, nil
+}
+
+// messageHeader defines the header structure for all bitcoin protocol messages.
+type messageHeader struct {
+	magic    BitcoinNet // 4 bytes
+	command  string     // 12 bytes
+	length   uint32     // 4 bytes
+	checksum [4]byte    // 4 bytes
+}
+
+// readMessageHeader reads a bitcoin message header from r.
+func readMessageHeader(r io.Reader) (int, *messageHeader, error) {
+	// Since readElements doesn't return the amount of bytes read, attempt
+	// to read the entire header into a buffer first in case there is a
+	// short read so the proper amount of read bytes are known.  This works
+	// since the header is a fixed size.
+	var headerBytes [MessageHeaderSize]byte
+	n, err := io.ReadFull(r, headerBytes[:])
+	if err != nil {
+		return n, nil, err
+	}
+	hr := bytes.NewReader(headerBytes[:])
+
+	// Create and populate a messageHeader struct from the raw header bytes.
+	hdr := messageHeader{}
+	var command [CommandSize]byte
+	readElements(hr, &hdr.magic, &command, &hdr.length, &hdr.checksum)
+
+	// Strip trailing zeros from command string.
+	hdr.command = string(bytes.TrimRight(command[:], string(0)))
+
+	return n, &hdr, nil
+}
+
+// discardInput reads n bytes from reader r in chunks and discards the read
+// bytes.  This is used to skip payloads when various errors occur and helps
+// prevent rogue nodes from causing massive memory allocation through forging
+// header length.
+func discardInput(r io.Reader, n uint32) {
+	maxSize := uint32(10 * 1024) // 10k at a time
+	numReads := n / maxSize
+	bytesRemaining := n % maxSize
+	if n > 0 {
+		buf := make([]byte, maxSize)
+		for i := uint32(0); i < numReads; i++ {
+			io.ReadFull(r, buf)
+		}
+	}
+	if bytesRemaining > 0 {
+		buf := make([]byte, bytesRemaining)
+		io.ReadFull(r, buf)
+	}
+}
+
+// WriteMessageN writes a bitcoin Message to w including the necessary header
+// information and returns the number of bytes written.    This function is the
+// same as WriteMessage except it also returns the number of bytes written.
+func WriteMessageN(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) (int, error) {
+	return WriteMessageWithEncodingN(w, msg, pver, btcnet, BaseEncoding)
+}
+
+// WriteMessage writes a bitcoin Message to w including the necessary header
+// information.  This function is the same as WriteMessageN except it doesn't
+// doesn't return the number of bytes written.  This function is mainly provided
+// for backwards compatibility with the original API, but it's also useful for
+// callers that don't care about byte counts.
+func WriteMessage(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) error {
+	_, err := WriteMessageN(w, msg, pver, btcnet)
+	return err
+}
+
+// WriteMessageWithEncodingN writes a bitcoin Message to w including the
+// necessary header information and returns the number of bytes written.
+// This function is the same as WriteMessageN except it also allows the caller
+// to specify the message encoding format to be used when serializing wire
+// messages.
+func WriteMessageWithEncodingN(w io.Writer, msg Message, pver uint32,
+	btcnet BitcoinNet, encoding MessageEncoding) (int, error) {
+
+	totalBytes := 0
+
+	// Enforce max command size.
+	var command [CommandSize]byte
+	cmd := msg.Command()
+	if len(cmd) > CommandSize {
+		str := fmt.Sprintf("command [%s] is too long [max %v]",
+			cmd, CommandSize)
+		return totalBytes, messageError("WriteMessage", str)
+	}
+	copy(command[:], []byte(cmd))
+
+	// Encode the message payload.
+	var bw bytes.Buffer
+	err := msg.BtcEncode(&bw, pver, encoding)
+	if err != nil {
+		return totalBytes, err
+	}
+	payload := bw.Bytes()
+	lenp := len(payload)
+
+	// Enforce maximum overall message payload.
+	if lenp > MaxMessagePayload {
+		str := fmt.Sprintf("message payload is too large - encoded "+
+			"%d bytes, but maximum message payload is %d bytes",
+			lenp, MaxMessagePayload)
+		return totalBytes, messageError("WriteMessage", str)
+	}
+
+	// Enforce maximum message payload based on the message type.
+	mpl := msg.MaxPayloadLength(pver)
+	if uint32(lenp) > mpl {
+		str := fmt.Sprintf("message payload is too large - encoded "+
+			"%d bytes, but maximum message payload size for "+
+			"messages of type [%s] is %d.", lenp, cmd, mpl)
+		return totalBytes, messageError("WriteMessage", str)
+	}
+
+	// Create header for the message.
+	hdr := messageHeader{}
+	hdr.magic = btcnet
+	hdr.command = cmd
+	hdr.length = uint32(lenp)
+	copy(hdr.checksum[:], chainhash.DoubleHashB(payload)[0:4])
+
+	// Encode the header for the message.  This is done to a buffer
+	// rather than directly to the writer since writeElements doesn't
+	// return the number of bytes written.
+	hw := bytes.NewBuffer(make([]byte, 0, MessageHeaderSize))
+	writeElements(hw, hdr.magic, command, hdr.length, hdr.checksum)
+
+	// Write header.
+	n, err := w.Write(hw.Bytes())
+	totalBytes += n
+	if err != nil {
+		return totalBytes, err
+	}
+
+	// Write payload.
+	n, err = w.Write(payload)
+	totalBytes += n
+	return totalBytes, err
+}
+
+// ReadMessageWithEncodingN reads, validates, and parses the next bitcoin Message
+// from r for the provided protocol version and bitcoin network.  It returns the
+// number of bytes read in addition to the parsed Message and raw bytes which
+// comprise the message.  This function is the same as ReadMessageN except it
+// allows the caller to specify which message encoding is to to consult when
+// decoding wire messages.
+func ReadMessageWithEncodingN(r io.Reader, pver uint32, btcnet BitcoinNet,
+	enc MessageEncoding) (int, Message, []byte, error) {
+
+	totalBytes := 0
+	n, hdr, err := readMessageHeader(r)
+	totalBytes += n
+	if err != nil {
+		return totalBytes, nil, nil, err
+	}
+
+	// Enforce maximum message payload.
+	if hdr.length > MaxMessagePayload {
+		str := fmt.Sprintf("message payload is too large - header "+
+			"indicates %d bytes, but max message payload is %d "+
+			"bytes.", hdr.length, MaxMessagePayload)
+		return totalBytes, nil, nil, messageError("ReadMessage", str)
+
+	}
+
+	// Check for messages from the wrong bitcoin network.
+	if hdr.magic != btcnet {
+		discardInput(r, hdr.length)
+		str := fmt.Sprintf("message from other network [%v]", hdr.magic)
+		return totalBytes, nil, nil, messageError("ReadMessage", str)
+	}
+
+	// Check for malformed commands.
+	command := hdr.command
+	if !utf8.ValidString(command) {
+		discardInput(r, hdr.length)
+		str := fmt.Sprintf("invalid command %v", []byte(command))
+		return totalBytes, nil, nil, messageError("ReadMessage", str)
+	}
+
+	// Create struct of appropriate message type based on the command.
+	msg, err := makeEmptyMessage(command)
+	if err != nil {
+		discardInput(r, hdr.length)
+		return totalBytes, nil, nil, messageError("ReadMessage",
+			err.Error())
+	}
+
+	// Check for maximum length based on the message type as a malicious client
+	// could otherwise create a well-formed header and set the length to max
+	// numbers in order to exhaust the machine's memory.
+	mpl := msg.MaxPayloadLength(pver)
+	if hdr.length > mpl {
+		discardInput(r, hdr.length)
+		str := fmt.Sprintf("payload exceeds max length - header "+
+			"indicates %v bytes, but max payload size for "+
+			"messages of type [%v] is %v.", hdr.length, command, mpl)
+		return totalBytes, nil, nil, messageError("ReadMessage", str)
+	}
+
+	// Read payload.
+	payload := make([]byte, hdr.length)
+	n, err = io.ReadFull(r, payload)
+	totalBytes += n
+	if err != nil {
+		return totalBytes, nil, nil, err
+	}
+
+	// Test checksum.
+	checksum := chainhash.DoubleHashB(payload)[0:4]
+	if !bytes.Equal(checksum[:], hdr.checksum[:]) {
+		str := fmt.Sprintf("payload checksum failed - header "+
+			"indicates %v, but actual checksum is %v.",
+			hdr.checksum, checksum)
+		return totalBytes, nil, nil, messageError("ReadMessage", str)
+	}
+
+	// Unmarshal message.  NOTE: This must be a *bytes.Buffer since the
+	// MsgVersion BtcDecode function requires it.
+	pr := bytes.NewBuffer(payload)
+	err = msg.BtcDecode(pr, pver, enc)
+	if err != nil {
+		return totalBytes, nil, nil, err
+	}
+
+	return totalBytes, msg, payload, nil
+}
+
+// ReadMessageN reads, validates, and parses the next bitcoin Message from r for
+// the provided protocol version and bitcoin network.  It returns the number of
+// bytes read in addition to the parsed Message and raw bytes which comprise the
+// message.  This function is the same as ReadMessage except it also returns the
+// number of bytes read.
+func ReadMessageN(r io.Reader, pver uint32, btcnet BitcoinNet) (int, Message, []byte, error) {
+	return ReadMessageWithEncodingN(r, pver, btcnet, BaseEncoding)
+}
+
+// ReadMessage reads, validates, and parses the next bitcoin Message from r for
+// the provided protocol version and bitcoin network.  It returns the parsed
+// Message and raw bytes which comprise the message.  This function only differs
+// from ReadMessageN in that it doesn't return the number of bytes read.  This
+// function is mainly provided for backwards compatibility with the original
+// API, but it's also useful for callers that don't care about byte counts.
+func ReadMessage(r io.Reader, pver uint32, btcnet BitcoinNet) (Message, []byte, error) {
+	_, msg, buf, err := ReadMessageN(r, pver, btcnet)
+	return msg, buf, err
+}

vendor/github.com/ltcsuite/ltcd/wire/msgaddr.go

@@ -0,0 +1,143 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"fmt"
+	"io"
+)
+
+// MaxAddrPerMsg is the maximum number of addresses that can be in a single
+// bitcoin addr message (MsgAddr).
+const MaxAddrPerMsg = 1000
+
+// MsgAddr implements the Message interface and represents a bitcoin
+// addr message.  It is used to provide a list of known active peers on the
+// network.  An active peer is considered one that has transmitted a message
+// within the last 3 hours.  Nodes which have not transmitted in that time
+// frame should be forgotten.  Each message is limited to a maximum number of
+// addresses, which is currently 1000.  As a result, multiple messages must
+// be used to relay the full list.
+//
+// Use the AddAddress function to build up the list of known addresses when
+// sending an addr message to another peer.
+type MsgAddr struct {
+	AddrList []*NetAddress
+}
+
+// AddAddress adds a known active peer to the message.
+func (msg *MsgAddr) AddAddress(na *NetAddress) error {
+	if len(msg.AddrList)+1 > MaxAddrPerMsg {
+		str := fmt.Sprintf("too many addresses in message [max %v]",
+			MaxAddrPerMsg)
+		return messageError("MsgAddr.AddAddress", str)
+	}
+
+	msg.AddrList = append(msg.AddrList, na)
+	return nil
+}
+
+// AddAddresses adds multiple known active peers to the message.
+func (msg *MsgAddr) AddAddresses(netAddrs ...*NetAddress) error {
+	for _, na := range netAddrs {
+		err := msg.AddAddress(na)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ClearAddresses removes all addresses from the message.
+func (msg *MsgAddr) ClearAddresses() {
+	msg.AddrList = []*NetAddress{}
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgAddr) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	count, err := ReadVarInt(r, pver)
+	if err != nil {
+		return err
+	}
+
+	// Limit to max addresses per message.
+	if count > MaxAddrPerMsg {
+		str := fmt.Sprintf("too many addresses for message "+
+			"[count %v, max %v]", count, MaxAddrPerMsg)
+		return messageError("MsgAddr.BtcDecode", str)
+	}
+
+	addrList := make([]NetAddress, count)
+	msg.AddrList = make([]*NetAddress, 0, count)
+	for i := uint64(0); i < count; i++ {
+		na := &addrList[i]
+		err := readNetAddress(r, pver, na, true)
+		if err != nil {
+			return err
+		}
+		msg.AddAddress(na)
+	}
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgAddr) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	// Protocol versions before MultipleAddressVersion only allowed 1 address
+	// per message.
+	count := len(msg.AddrList)
+	if pver < MultipleAddressVersion && count > 1 {
+		str := fmt.Sprintf("too many addresses for message of "+
+			"protocol version %v [count %v, max 1]", pver, count)
+		return messageError("MsgAddr.BtcEncode", str)
+
+	}
+	if count > MaxAddrPerMsg {
+		str := fmt.Sprintf("too many addresses for message "+
+			"[count %v, max %v]", count, MaxAddrPerMsg)
+		return messageError("MsgAddr.BtcEncode", str)
+	}
+
+	err := WriteVarInt(w, pver, uint64(count))
+	if err != nil {
+		return err
+	}
+
+	for _, na := range msg.AddrList {
+		err = writeNetAddress(w, pver, na, true)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgAddr) Command() string {
+	return CmdAddr
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgAddr) MaxPayloadLength(pver uint32) uint32 {
+	if pver < MultipleAddressVersion {
+		// Num addresses (varInt) + a single net addresses.
+		return MaxVarIntPayload + maxNetAddressPayload(pver)
+	}
+
+	// Num addresses (varInt) + max allowed addresses.
+	return MaxVarIntPayload + (MaxAddrPerMsg * maxNetAddressPayload(pver))
+}
+
+// NewMsgAddr returns a new bitcoin addr message that conforms to the
+// Message interface.  See MsgAddr for details.
+func NewMsgAddr() *MsgAddr {
+	return &MsgAddr{
+		AddrList: make([]*NetAddress, 0, MaxAddrPerMsg),
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgalert.go

@@ -0,0 +1,407 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+)
+
+// MsgAlert contains a payload and a signature:
+//
+//        ===============================================
+//        |   Field         |   Data Type   |   Size    |
+//        ===============================================
+//        |   payload       |   []uchar     |   ?       |
+//        -----------------------------------------------
+//        |   signature     |   []uchar     |   ?       |
+//        -----------------------------------------------
+//
+// Here payload is an Alert serialized into a byte array to ensure that
+// versions using incompatible alert formats can still relay
+// alerts among one another.
+//
+// An Alert is the payload deserialized as follows:
+//
+//        ===============================================
+//        |   Field         |   Data Type   |   Size    |
+//        ===============================================
+//        |   Version       |   int32       |   4       |
+//        -----------------------------------------------
+//        |   RelayUntil    |   int64       |   8       |
+//        -----------------------------------------------
+//        |   Expiration    |   int64       |   8       |
+//        -----------------------------------------------
+//        |   ID            |   int32       |   4       |
+//        -----------------------------------------------
+//        |   Cancel        |   int32       |   4       |
+//        -----------------------------------------------
+//        |   SetCancel     |   set<int32>  |   ?       |
+//        -----------------------------------------------
+//        |   MinVer        |   int32       |   4       |
+//        -----------------------------------------------
+//        |   MaxVer        |   int32       |   4       |
+//        -----------------------------------------------
+//        |   SetSubVer     |   set<string> |   ?       |
+//        -----------------------------------------------
+//        |   Priority      |   int32       |   4       |
+//        -----------------------------------------------
+//        |   Comment       |   string      |   ?       |
+//        -----------------------------------------------
+//        |   StatusBar     |   string      |   ?       |
+//        -----------------------------------------------
+//        |   Reserved      |   string      |   ?       |
+//        -----------------------------------------------
+//        |   Total  (Fixed)                |   45      |
+//        -----------------------------------------------
+//
+// NOTE:
+//      * string is a VarString i.e VarInt length followed by the string itself
+//      * set<string> is a VarInt followed by as many number of strings
+//      * set<int32> is a VarInt followed by as many number of ints
+//      * fixedAlertSize = 40 + 5*min(VarInt)  = 40 + 5*1 = 45
+//
+// Now we can define bounds on Alert size, SetCancel and SetSubVer
+
+// Fixed size of the alert payload
+const fixedAlertSize = 45
+
+// maxSignatureSize is the max size of an ECDSA signature.
+// NOTE: Since this size is fixed and < 255, the size of VarInt required = 1.
+const maxSignatureSize = 72
+
+// maxAlertSize is the maximum size an alert.
+//
+// MessagePayload = VarInt(Alert) + Alert + VarInt(Signature) + Signature
+// MaxMessagePayload = maxAlertSize + max(VarInt) + maxSignatureSize + 1
+const maxAlertSize = MaxMessagePayload - maxSignatureSize - MaxVarIntPayload - 1
+
+// maxCountSetCancel is the maximum number of cancel IDs that could possibly
+// fit into a maximum size alert.
+//
+// maxAlertSize = fixedAlertSize + max(SetCancel) + max(SetSubVer) + 3*(string)
+// for caculating maximum number of cancel IDs, set all other var  sizes to 0
+// maxAlertSize = fixedAlertSize + (MaxVarIntPayload-1) + x*sizeOf(int32)
+// x = (maxAlertSize - fixedAlertSize - MaxVarIntPayload + 1) / 4
+const maxCountSetCancel = (maxAlertSize - fixedAlertSize - MaxVarIntPayload + 1) / 4
+
+// maxCountSetSubVer is the maximum number of subversions that could possibly
+// fit into a maximum size alert.
+//
+// maxAlertSize = fixedAlertSize + max(SetCancel) + max(SetSubVer) + 3*(string)
+// for caculating maximum number of subversions, set all other var sizes to 0
+// maxAlertSize = fixedAlertSize + (MaxVarIntPayload-1) + x*sizeOf(string)
+// x = (maxAlertSize - fixedAlertSize - MaxVarIntPayload + 1) / sizeOf(string)
+// subversion would typically be something like "/Satoshi:0.7.2/" (15 bytes)
+// so assuming < 255 bytes, sizeOf(string) = sizeOf(uint8) + 255 = 256
+const maxCountSetSubVer = (maxAlertSize - fixedAlertSize - MaxVarIntPayload + 1) / 256
+
+// Alert contains the data deserialized from the MsgAlert payload.
+type Alert struct {
+	// Alert format version
+	Version int32
+
+	// Timestamp beyond which nodes should stop relaying this alert
+	RelayUntil int64
+
+	// Timestamp beyond which this alert is no longer in effect and
+	// should be ignored
+	Expiration int64
+
+	// A unique ID number for this alert
+	ID int32
+
+	// All alerts with an ID less than or equal to this number should
+	// cancelled, deleted and not accepted in the future
+	Cancel int32
+
+	// All alert IDs contained in this set should be cancelled as above
+	SetCancel []int32
+
+	// This alert only applies to versions greater than or equal to this
+	// version. Other versions should still relay it.
+	MinVer int32
+
+	// This alert only applies to versions less than or equal to this version.
+	// Other versions should still relay it.
+	MaxVer int32
+
+	// If this set contains any elements, then only nodes that have their
+	// subVer contained in this set are affected by the alert. Other versions
+	// should still relay it.
+	SetSubVer []string
+
+	// Relative priority compared to other alerts
+	Priority int32
+
+	// A comment on the alert that is not displayed
+	Comment string
+
+	// The alert message that is displayed to the user
+	StatusBar string
+
+	// Reserved
+	Reserved string
+}
+
+// Serialize encodes the alert to w using the alert protocol encoding format.
+func (alert *Alert) Serialize(w io.Writer, pver uint32) error {
+	err := writeElements(w, alert.Version, alert.RelayUntil,
+		alert.Expiration, alert.ID, alert.Cancel)
+	if err != nil {
+		return err
+	}
+
+	count := len(alert.SetCancel)
+	if count > maxCountSetCancel {
+		str := fmt.Sprintf("too many cancel alert IDs for alert "+
+			"[count %v, max %v]", count, maxCountSetCancel)
+		return messageError("Alert.Serialize", str)
+	}
+	err = WriteVarInt(w, pver, uint64(count))
+	if err != nil {
+		return err
+	}
+	for i := 0; i < count; i++ {
+		err = writeElement(w, alert.SetCancel[i])
+		if err != nil {
+			return err
+		}
+	}
+
+	err = writeElements(w, alert.MinVer, alert.MaxVer)
+	if err != nil {
+		return err
+	}
+
+	count = len(alert.SetSubVer)
+	if count > maxCountSetSubVer {
+		str := fmt.Sprintf("too many sub versions for alert "+
+			"[count %v, max %v]", count, maxCountSetSubVer)
+		return messageError("Alert.Serialize", str)
+	}
+	err = WriteVarInt(w, pver, uint64(count))
+	if err != nil {
+		return err
+	}
+	for i := 0; i < count; i++ {
+		err = WriteVarString(w, pver, alert.SetSubVer[i])
+		if err != nil {
+			return err
+		}
+	}
+
+	err = writeElement(w, alert.Priority)
+	if err != nil {
+		return err
+	}
+	err = WriteVarString(w, pver, alert.Comment)
+	if err != nil {
+		return err
+	}
+	err = WriteVarString(w, pver, alert.StatusBar)
+	if err != nil {
+		return err
+	}
+	return WriteVarString(w, pver, alert.Reserved)
+}
+
+// Deserialize decodes from r into the receiver using the alert protocol
+// encoding format.
+func (alert *Alert) Deserialize(r io.Reader, pver uint32) error {
+	err := readElements(r, &alert.Version, &alert.RelayUntil,
+		&alert.Expiration, &alert.ID, &alert.Cancel)
+	if err != nil {
+		return err
+	}
+
+	// SetCancel: first read a VarInt that contains
+	// count - the number of Cancel IDs, then
+	// iterate count times and read them
+	count, err := ReadVarInt(r, pver)
+	if err != nil {
+		return err
+	}
+	if count > maxCountSetCancel {
+		str := fmt.Sprintf("too many cancel alert IDs for alert "+
+			"[count %v, max %v]", count, maxCountSetCancel)
+		return messageError("Alert.Deserialize", str)
+	}
+	alert.SetCancel = make([]int32, count)
+	for i := 0; i < int(count); i++ {
+		err := readElement(r, &alert.SetCancel[i])
+		if err != nil {
+			return err
+		}
+	}
+
+	err = readElements(r, &alert.MinVer, &alert.MaxVer)
+	if err != nil {
+		return err
+	}
+
+	// SetSubVer: similar to SetCancel
+	// but read count number of sub-version strings
+	count, err = ReadVarInt(r, pver)
+	if err != nil {
+		return err
+	}
+	if count > maxCountSetSubVer {
+		str := fmt.Sprintf("too many sub versions for alert "+
+			"[count %v, max %v]", count, maxCountSetSubVer)
+		return messageError("Alert.Deserialize", str)
+	}
+	alert.SetSubVer = make([]string, count)
+	for i := 0; i < int(count); i++ {
+		alert.SetSubVer[i], err = ReadVarString(r, pver)
+		if err != nil {
+			return err
+		}
+	}
+
+	err = readElement(r, &alert.Priority)
+	if err != nil {
+		return err
+	}
+	alert.Comment, err = ReadVarString(r, pver)
+	if err != nil {
+		return err
+	}
+	alert.StatusBar, err = ReadVarString(r, pver)
+	if err != nil {
+		return err
+	}
+	alert.Reserved, err = ReadVarString(r, pver)
+	return err
+}
+
+// NewAlert returns an new Alert with values provided.
+func NewAlert(version int32, relayUntil int64, expiration int64,
+	id int32, cancel int32, setCancel []int32, minVer int32,
+	maxVer int32, setSubVer []string, priority int32, comment string,
+	statusBar string) *Alert {
+	return &Alert{
+		Version:    version,
+		RelayUntil: relayUntil,
+		Expiration: expiration,
+		ID:         id,
+		Cancel:     cancel,
+		SetCancel:  setCancel,
+		MinVer:     minVer,
+		MaxVer:     maxVer,
+		SetSubVer:  setSubVer,
+		Priority:   priority,
+		Comment:    comment,
+		StatusBar:  statusBar,
+		Reserved:   "",
+	}
+}
+
+// NewAlertFromPayload returns an Alert with values deserialized from the
+// serialized payload.
+func NewAlertFromPayload(serializedPayload []byte, pver uint32) (*Alert, error) {
+	var alert Alert
+	r := bytes.NewReader(serializedPayload)
+	err := alert.Deserialize(r, pver)
+	if err != nil {
+		return nil, err
+	}
+	return &alert, nil
+}
+
+// MsgAlert  implements the Message interface and defines a bitcoin alert
+// message.
+//
+// This is a signed message that provides notifications that the client should
+// display if the signature matches the key.  bitcoind/bitcoin-qt only checks
+// against a signature from the core developers.
+type MsgAlert struct {
+	// SerializedPayload is the alert payload serialized as a string so that the
+	// version can change but the Alert can still be passed on by older
+	// clients.
+	SerializedPayload []byte
+
+	// Signature is the ECDSA signature of the message.
+	Signature []byte
+
+	// Deserialized Payload
+	Payload *Alert
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgAlert) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	var err error
+
+	msg.SerializedPayload, err = ReadVarBytes(r, pver, MaxMessagePayload,
+		"alert serialized payload")
+	if err != nil {
+		return err
+	}
+
+	msg.Payload, err = NewAlertFromPayload(msg.SerializedPayload, pver)
+	if err != nil {
+		msg.Payload = nil
+	}
+
+	msg.Signature, err = ReadVarBytes(r, pver, MaxMessagePayload,
+		"alert signature")
+	return err
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgAlert) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	var err error
+	var serializedpayload []byte
+	if msg.Payload != nil {
+		// try to Serialize Payload if possible
+		r := new(bytes.Buffer)
+		err = msg.Payload.Serialize(r, pver)
+		if err != nil {
+			// Serialize failed - ignore & fallback
+			// to SerializedPayload
+			serializedpayload = msg.SerializedPayload
+		} else {
+			serializedpayload = r.Bytes()
+		}
+	} else {
+		serializedpayload = msg.SerializedPayload
+	}
+	slen := uint64(len(serializedpayload))
+	if slen == 0 {
+		return messageError("MsgAlert.BtcEncode", "empty serialized payload")
+	}
+	err = WriteVarBytes(w, pver, serializedpayload)
+	if err != nil {
+		return err
+	}
+	return WriteVarBytes(w, pver, msg.Signature)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgAlert) Command() string {
+	return CmdAlert
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgAlert) MaxPayloadLength(pver uint32) uint32 {
+	// Since this can vary depending on the message, make it the max
+	// size allowed.
+	return MaxMessagePayload
+}
+
+// NewMsgAlert returns a new bitcoin alert message that conforms to the Message
+// interface.  See MsgAlert for details.
+func NewMsgAlert(serializedPayload []byte, signature []byte) *MsgAlert {
+	return &MsgAlert{
+		SerializedPayload: serializedPayload,
+		Signature:         signature,
+		Payload:           nil,
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgblock.go

@@ -0,0 +1,290 @@
+// 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 wire
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+// defaultTransactionAlloc is the default size used for the backing array
+// for transactions.  The transaction array will dynamically grow as needed, but
+// this figure is intended to provide enough space for the number of
+// transactions in the vast majority of blocks without needing to grow the
+// backing array multiple times.
+const defaultTransactionAlloc = 2048
+
+// MaxBlocksPerMsg is the maximum number of blocks allowed per message.
+const MaxBlocksPerMsg = 500
+
+// MaxBlockPayload is the maximum bytes a block message can be in bytes.
+// After Segregated Witness, the max block payload has been raised to 4MB.
+const MaxBlockPayload = 4000000
+
+// maxTxPerBlock is the maximum number of transactions that could
+// possibly fit into a block.
+const maxTxPerBlock = (MaxBlockPayload / minTxPayload) + 1
+
+// TxLoc holds locator data for the offset and length of where a transaction is
+// located within a MsgBlock data buffer.
+type TxLoc struct {
+	TxStart int
+	TxLen   int
+}
+
+// MsgBlock implements the Message interface and represents a bitcoin
+// block message.  It is used to deliver block and transaction information in
+// response to a getdata message (MsgGetData) for a given block hash.
+type MsgBlock struct {
+	Header       BlockHeader
+	Transactions []*MsgTx
+}
+
+// AddTransaction adds a transaction to the message.
+func (msg *MsgBlock) AddTransaction(tx *MsgTx) error {
+	msg.Transactions = append(msg.Transactions, tx)
+	return nil
+
+}
+
+// ClearTransactions removes all transactions from the message.
+func (msg *MsgBlock) ClearTransactions() {
+	msg.Transactions = make([]*MsgTx, 0, defaultTransactionAlloc)
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+// See Deserialize for decoding blocks stored to disk, such as in a database, as
+// opposed to decoding blocks from the wire.
+func (msg *MsgBlock) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	err := readBlockHeader(r, pver, &msg.Header)
+	if err != nil {
+		return err
+	}
+
+	txCount, err := ReadVarInt(r, pver)
+	if err != nil {
+		return err
+	}
+
+	// Prevent more transactions than could possibly fit into a block.
+	// It would be possible to cause memory exhaustion and panics without
+	// a sane upper bound on this count.
+	if txCount > maxTxPerBlock {
+		str := fmt.Sprintf("too many transactions to fit into a block "+
+			"[count %d, max %d]", txCount, maxTxPerBlock)
+		return messageError("MsgBlock.BtcDecode", str)
+	}
+
+	msg.Transactions = make([]*MsgTx, 0, txCount)
+	for i := uint64(0); i < txCount; i++ {
+		tx := MsgTx{}
+		err := tx.BtcDecode(r, pver, enc)
+		if err != nil {
+			return err
+		}
+		msg.Transactions = append(msg.Transactions, &tx)
+	}
+
+	return nil
+}
+
+// Deserialize decodes a block from r into the receiver using a format that is
+// suitable for long-term storage such as a database while respecting the
+// Version field in the block.  This function differs from BtcDecode in that
+// BtcDecode decodes from the bitcoin wire protocol as it was sent across the
+// network.  The wire encoding can technically differ depending on the protocol
+// version and doesn't even really need to match the format of a stored block at
+// all.  As of the time this comment was written, the encoded block is the same
+// in both instances, but there is a distinct difference and separating the two
+// allows the API to be flexible enough to deal with changes.
+func (msg *MsgBlock) Deserialize(r io.Reader) error {
+	// At the current time, there is no difference between the wire encoding
+	// at protocol version 0 and the stable long-term storage format.  As
+	// a result, make use of BtcDecode.
+	//
+	// Passing an encoding type of WitnessEncoding to BtcEncode for the
+	// MessageEncoding parameter indicates that the transactions within the
+	// block are expected to be serialized according to the new
+	// serialization structure defined in BIP0141.
+	return msg.BtcDecode(r, 0, WitnessEncoding)
+}
+
+// DeserializeNoWitness decodes a block from r into the receiver similar to
+// Deserialize, however DeserializeWitness strips all (if any) witness data
+// from the transactions within the block before encoding them.
+func (msg *MsgBlock) DeserializeNoWitness(r io.Reader) error {
+	return msg.BtcDecode(r, 0, BaseEncoding)
+}
+
+// DeserializeTxLoc decodes r in the same manner Deserialize does, but it takes
+// a byte buffer instead of a generic reader and returns a slice containing the
+// start and length of each transaction within the raw data that is being
+// deserialized.
+func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
+	fullLen := r.Len()
+
+	// At the current time, there is no difference between the wire encoding
+	// at protocol version 0 and the stable long-term storage format.  As
+	// a result, make use of existing wire protocol functions.
+	err := readBlockHeader(r, 0, &msg.Header)
+	if err != nil {
+		return nil, err
+	}
+
+	txCount, err := ReadVarInt(r, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	// Prevent more transactions than could possibly fit into a block.
+	// It would be possible to cause memory exhaustion and panics without
+	// a sane upper bound on this count.
+	if txCount > maxTxPerBlock {
+		str := fmt.Sprintf("too many transactions to fit into a block "+
+			"[count %d, max %d]", txCount, maxTxPerBlock)
+		return nil, messageError("MsgBlock.DeserializeTxLoc", str)
+	}
+
+	// Deserialize each transaction while keeping track of its location
+	// within the byte stream.
+	msg.Transactions = make([]*MsgTx, 0, txCount)
+	txLocs := make([]TxLoc, txCount)
+	for i := uint64(0); i < txCount; i++ {
+		txLocs[i].TxStart = fullLen - r.Len()
+		tx := MsgTx{}
+		err := tx.Deserialize(r)
+		if err != nil {
+			return nil, err
+		}
+		msg.Transactions = append(msg.Transactions, &tx)
+		txLocs[i].TxLen = (fullLen - r.Len()) - txLocs[i].TxStart
+	}
+
+	return txLocs, nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+// See Serialize for encoding blocks to be stored to disk, such as in a
+// database, as opposed to encoding blocks for the wire.
+func (msg *MsgBlock) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	err := writeBlockHeader(w, pver, &msg.Header)
+	if err != nil {
+		return err
+	}
+
+	err = WriteVarInt(w, pver, uint64(len(msg.Transactions)))
+	if err != nil {
+		return err
+	}
+
+	for _, tx := range msg.Transactions {
+		err = tx.BtcEncode(w, pver, enc)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Serialize encodes the block to w using a format that suitable for long-term
+// storage such as a database while respecting the Version field in the block.
+// This function differs from BtcEncode in that BtcEncode encodes the block to
+// the bitcoin wire protocol in order to be sent across the network.  The wire
+// encoding can technically differ depending on the protocol version and doesn't
+// even really need to match the format of a stored block at all.  As of the
+// time this comment was written, the encoded block is the same in both
+// instances, but there is a distinct difference and separating the two allows
+// the API to be flexible enough to deal with changes.
+func (msg *MsgBlock) Serialize(w io.Writer) error {
+	// At the current time, there is no difference between the wire encoding
+	// at protocol version 0 and the stable long-term storage format.  As
+	// a result, make use of BtcEncode.
+	//
+	// Passing WitnessEncoding as the encoding type here indicates that
+	// each of the transactions should be serialized using the witness
+	// serialization structure defined in BIP0141.
+	return msg.BtcEncode(w, 0, WitnessEncoding)
+}
+
+// SerializeNoWitness encodes a block to w using an identical format to
+// Serialize, with all (if any) witness data stripped from all transactions.
+// This method is provided in additon to the regular Serialize, in order to
+// allow one to selectively encode transaction witness data to non-upgraded
+// peers which are unaware of the new encoding.
+func (msg *MsgBlock) SerializeNoWitness(w io.Writer) error {
+	return msg.BtcEncode(w, 0, BaseEncoding)
+}
+
+// SerializeSize returns the number of bytes it would take to serialize the
+// block, factoring in any witness data within transaction.
+func (msg *MsgBlock) SerializeSize() int {
+	// Block header bytes + Serialized varint size for the number of
+	// transactions.
+	n := blockHeaderLen + VarIntSerializeSize(uint64(len(msg.Transactions)))
+
+	for _, tx := range msg.Transactions {
+		n += tx.SerializeSize()
+	}
+
+	return n
+}
+
+// SerializeSizeStripped returns the number of bytes it would take to serialize
+// the block, excluding any witness data (if any).
+func (msg *MsgBlock) SerializeSizeStripped() int {
+	// Block header bytes + Serialized varint size for the number of
+	// transactions.
+	n := blockHeaderLen + VarIntSerializeSize(uint64(len(msg.Transactions)))
+
+	for _, tx := range msg.Transactions {
+		n += tx.SerializeSizeStripped()
+	}
+
+	return n
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgBlock) Command() string {
+	return CmdBlock
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgBlock) MaxPayloadLength(pver uint32) uint32 {
+	// Block header at 80 bytes + transaction count + max transactions
+	// which can vary up to the MaxBlockPayload (including the block header
+	// and transaction count).
+	return MaxBlockPayload
+}
+
+// BlockHash computes the block identifier hash for this block.
+func (msg *MsgBlock) BlockHash() chainhash.Hash {
+	return msg.Header.BlockHash()
+}
+
+// TxHashes returns a slice of hashes of all of transactions in this block.
+func (msg *MsgBlock) TxHashes() ([]chainhash.Hash, error) {
+	hashList := make([]chainhash.Hash, 0, len(msg.Transactions))
+	for _, tx := range msg.Transactions {
+		hashList = append(hashList, tx.TxHash())
+	}
+	return hashList, nil
+}
+
+// NewMsgBlock returns a new bitcoin block message that conforms to the
+// Message interface.  See MsgBlock for details.
+func NewMsgBlock(blockHeader *BlockHeader) *MsgBlock {
+	return &MsgBlock{
+		Header:       *blockHeader,
+		Transactions: make([]*MsgTx, 0, defaultTransactionAlloc),
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgcfcheckpt.go

@@ -0,0 +1,164 @@
+// Copyright (c) 2018 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+const (
+	// CFCheckptInterval is the gap (in number of blocks) between each
+	// filter header checkpoint.
+	CFCheckptInterval = 1000
+
+	// maxCFHeadersLen is the max number of filter headers we will attempt
+	// to decode.
+	maxCFHeadersLen = 100000
+)
+
+// ErrInsaneCFHeaderCount signals that we were asked to decode an
+// unreasonable number of cfilter headers.
+var ErrInsaneCFHeaderCount = errors.New(
+	"refusing to decode unreasonable number of filter headers")
+
+// MsgCFCheckpt implements the Message interface and represents a bitcoin
+// cfcheckpt message.  It is used to deliver committed filter header information
+// in response to a getcfcheckpt message (MsgGetCFCheckpt). See MsgGetCFCheckpt
+// for details on requesting the headers.
+type MsgCFCheckpt struct {
+	FilterType    FilterType
+	StopHash      chainhash.Hash
+	FilterHeaders []*chainhash.Hash
+}
+
+// AddCFHeader adds a new committed filter header to the message.
+func (msg *MsgCFCheckpt) AddCFHeader(header *chainhash.Hash) error {
+	if len(msg.FilterHeaders) == cap(msg.FilterHeaders) {
+		str := fmt.Sprintf("FilterHeaders has insufficient capacity for "+
+			"additional header: len = %d", len(msg.FilterHeaders))
+		return messageError("MsgCFCheckpt.AddCFHeader", str)
+	}
+
+	msg.FilterHeaders = append(msg.FilterHeaders, header)
+	return nil
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgCFCheckpt) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
+	// Read filter type
+	err := readElement(r, &msg.FilterType)
+	if err != nil {
+		return err
+	}
+
+	// Read stop hash
+	err = readElement(r, &msg.StopHash)
+	if err != nil {
+		return err
+	}
+
+	// Read number of filter headers
+	count, err := ReadVarInt(r, pver)
+	if err != nil {
+		return err
+	}
+
+	// Refuse to decode an insane number of cfheaders.
+	if count > maxCFHeadersLen {
+		return ErrInsaneCFHeaderCount
+	}
+
+	// Create a contiguous slice of hashes to deserialize into in order to
+	// reduce the number of allocations.
+	msg.FilterHeaders = make([]*chainhash.Hash, count)
+	for i := uint64(0); i < count; i++ {
+		var cfh chainhash.Hash
+		err := readElement(r, &cfh)
+		if err != nil {
+			return err
+		}
+		msg.FilterHeaders[i] = &cfh
+	}
+
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgCFCheckpt) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
+	// Write filter type
+	err := writeElement(w, msg.FilterType)
+	if err != nil {
+		return err
+	}
+
+	// Write stop hash
+	err = writeElement(w, msg.StopHash)
+	if err != nil {
+		return err
+	}
+
+	// Write length of FilterHeaders slice
+	count := len(msg.FilterHeaders)
+	err = WriteVarInt(w, pver, uint64(count))
+	if err != nil {
+		return err
+	}
+
+	for _, cfh := range msg.FilterHeaders {
+		err := writeElement(w, cfh)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Deserialize decodes a filter header from r into the receiver using a format
+// that is suitable for long-term storage such as a database. This function
+// differs from BtcDecode in that BtcDecode decodes from the bitcoin wire
+// protocol as it was sent across the network.  The wire encoding can
+// technically differ depending on the protocol version and doesn't even really
+// need to match the format of a stored filter header at all. As of the time
+// this comment was written, the encoded filter header is the same in both
+// instances, but there is a distinct difference and separating the two allows
+// the API to be flexible enough to deal with changes.
+func (msg *MsgCFCheckpt) Deserialize(r io.Reader) error {
+	// At the current time, there is no difference between the wire encoding
+	// and the stable long-term storage format.  As a result, make use of
+	// BtcDecode.
+	return msg.BtcDecode(r, 0, BaseEncoding)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgCFCheckpt) Command() string {
+	return CmdCFCheckpt
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver. This is part of the Message interface implementation.
+func (msg *MsgCFCheckpt) MaxPayloadLength(pver uint32) uint32 {
+	// Message size depends on the blockchain height, so return general limit
+	// for all messages.
+	return MaxMessagePayload
+}
+
+// NewMsgCFCheckpt returns a new bitcoin cfheaders message that conforms to
+// the Message interface. See MsgCFCheckpt for details.
+func NewMsgCFCheckpt(filterType FilterType, stopHash *chainhash.Hash,
+	headersCount int) *MsgCFCheckpt {
+	return &MsgCFCheckpt{
+		FilterType:    filterType,
+		StopHash:      *stopHash,
+		FilterHeaders: make([]*chainhash.Hash, 0, headersCount),
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgcfheaders.go

@@ -0,0 +1,180 @@
+// 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 wire
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+const (
+	// MaxCFHeaderPayload is the maximum byte size of a committed
+	// filter header.
+	MaxCFHeaderPayload = chainhash.HashSize
+
+	// MaxCFHeadersPerMsg is the maximum number of committed filter headers
+	// that can be in a single bitcoin cfheaders message.
+	MaxCFHeadersPerMsg = 2000
+)
+
+// MsgCFHeaders implements the Message interface and represents a bitcoin
+// cfheaders message.  It is used to deliver committed filter header information
+// in response to a getcfheaders message (MsgGetCFHeaders). The maximum number
+// of committed filter headers per message is currently 2000. See
+// MsgGetCFHeaders for details on requesting the headers.
+type MsgCFHeaders struct {
+	FilterType       FilterType
+	StopHash         chainhash.Hash
+	PrevFilterHeader chainhash.Hash
+	FilterHashes     []*chainhash.Hash
+}
+
+// AddCFHash adds a new filter hash to the message.
+func (msg *MsgCFHeaders) AddCFHash(hash *chainhash.Hash) error {
+	if len(msg.FilterHashes)+1 > MaxCFHeadersPerMsg {
+		str := fmt.Sprintf("too many block headers in message [max %v]",
+			MaxBlockHeadersPerMsg)
+		return messageError("MsgCFHeaders.AddCFHash", str)
+	}
+
+	msg.FilterHashes = append(msg.FilterHashes, hash)
+	return nil
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgCFHeaders) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
+	// Read filter type
+	err := readElement(r, &msg.FilterType)
+	if err != nil {
+		return err
+	}
+
+	// Read stop hash
+	err = readElement(r, &msg.StopHash)
+	if err != nil {
+		return err
+	}
+
+	// Read prev filter header
+	err = readElement(r, &msg.PrevFilterHeader)
+	if err != nil {
+		return err
+	}
+
+	// Read number of filter headers
+	count, err := ReadVarInt(r, pver)
+	if err != nil {
+		return err
+	}
+
+	// Limit to max committed filter headers per message.
+	if count > MaxCFHeadersPerMsg {
+		str := fmt.Sprintf("too many committed filter headers for "+
+			"message [count %v, max %v]", count,
+			MaxBlockHeadersPerMsg)
+		return messageError("MsgCFHeaders.BtcDecode", str)
+	}
+
+	// Create a contiguous slice of hashes to deserialize into in order to
+	// reduce the number of allocations.
+	msg.FilterHashes = make([]*chainhash.Hash, 0, count)
+	for i := uint64(0); i < count; i++ {
+		var cfh chainhash.Hash
+		err := readElement(r, &cfh)
+		if err != nil {
+			return err
+		}
+		msg.AddCFHash(&cfh)
+	}
+
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgCFHeaders) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
+	// Write filter type
+	err := writeElement(w, msg.FilterType)
+	if err != nil {
+		return err
+	}
+
+	// Write stop hash
+	err = writeElement(w, msg.StopHash)
+	if err != nil {
+		return err
+	}
+
+	// Write prev filter header
+	err = writeElement(w, msg.PrevFilterHeader)
+	if err != nil {
+		return err
+	}
+
+	// Limit to max committed headers per message.
+	count := len(msg.FilterHashes)
+	if count > MaxCFHeadersPerMsg {
+		str := fmt.Sprintf("too many committed filter headers for "+
+			"message [count %v, max %v]", count,
+			MaxBlockHeadersPerMsg)
+		return messageError("MsgCFHeaders.BtcEncode", str)
+	}
+
+	err = WriteVarInt(w, pver, uint64(count))
+	if err != nil {
+		return err
+	}
+
+	for _, cfh := range msg.FilterHashes {
+		err := writeElement(w, cfh)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Deserialize decodes a filter header from r into the receiver using a format
+// that is suitable for long-term storage such as a database. This function
+// differs from BtcDecode in that BtcDecode decodes from the bitcoin wire
+// protocol as it was sent across the network.  The wire encoding can
+// technically differ depending on the protocol version and doesn't even really
+// need to match the format of a stored filter header at all. As of the time
+// this comment was written, the encoded filter header is the same in both
+// instances, but there is a distinct difference and separating the two allows
+// the API to be flexible enough to deal with changes.
+func (msg *MsgCFHeaders) Deserialize(r io.Reader) error {
+	// At the current time, there is no difference between the wire encoding
+	// and the stable long-term storage format.  As a result, make use of
+	// BtcDecode.
+	return msg.BtcDecode(r, 0, BaseEncoding)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgCFHeaders) Command() string {
+	return CmdCFHeaders
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver. This is part of the Message interface implementation.
+func (msg *MsgCFHeaders) MaxPayloadLength(pver uint32) uint32 {
+	// Hash size + filter type + num headers (varInt) +
+	// (header size * max headers).
+	return 1 + chainhash.HashSize + chainhash.HashSize + MaxVarIntPayload +
+		(MaxCFHeaderPayload * MaxCFHeadersPerMsg)
+}
+
+// NewMsgCFHeaders returns a new bitcoin cfheaders message that conforms to
+// the Message interface. See MsgCFHeaders for details.
+func NewMsgCFHeaders() *MsgCFHeaders {
+	return &MsgCFHeaders{
+		FilterHashes: make([]*chainhash.Hash, 0, MaxCFHeadersPerMsg),
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgcfilter.go

@@ -0,0 +1,119 @@
+// 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 wire
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+// FilterType is used to represent a filter type.
+type FilterType uint8
+
+const (
+	// GCSFilterRegular is the regular filter type.
+	GCSFilterRegular FilterType = iota
+)
+
+const (
+	// MaxCFilterDataSize is the maximum byte size of a committed filter.
+	// The maximum size is currently defined as 256KiB.
+	MaxCFilterDataSize = 256 * 1024
+)
+
+// MsgCFilter implements the Message interface and represents a bitcoin cfilter
+// message. It is used to deliver a committed filter in response to a
+// getcfilters (MsgGetCFilters) message.
+type MsgCFilter struct {
+	FilterType FilterType
+	BlockHash  chainhash.Hash
+	Data       []byte
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgCFilter) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
+	// Read filter type
+	err := readElement(r, &msg.FilterType)
+	if err != nil {
+		return err
+	}
+
+	// Read the hash of the filter's block
+	err = readElement(r, &msg.BlockHash)
+	if err != nil {
+		return err
+	}
+
+	// Read filter data
+	msg.Data, err = ReadVarBytes(r, pver, MaxCFilterDataSize,
+		"cfilter data")
+	return err
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgCFilter) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
+	size := len(msg.Data)
+	if size > MaxCFilterDataSize {
+		str := fmt.Sprintf("cfilter size too large for message "+
+			"[size %v, max %v]", size, MaxCFilterDataSize)
+		return messageError("MsgCFilter.BtcEncode", str)
+	}
+
+	err := writeElement(w, msg.FilterType)
+	if err != nil {
+		return err
+	}
+
+	err = writeElement(w, msg.BlockHash)
+	if err != nil {
+		return err
+	}
+
+	return WriteVarBytes(w, pver, msg.Data)
+}
+
+// Deserialize decodes a filter from r into the receiver using a format that is
+// suitable for long-term storage such as a database. This function differs
+// from BtcDecode in that BtcDecode decodes from the bitcoin wire protocol as
+// it was sent across the network.  The wire encoding can technically differ
+// depending on the protocol version and doesn't even really need to match the
+// format of a stored filter at all. As of the time this comment was written,
+// the encoded filter is the same in both instances, but there is a distinct
+// difference and separating the two allows the API to be flexible enough to
+// deal with changes.
+func (msg *MsgCFilter) Deserialize(r io.Reader) error {
+	// At the current time, there is no difference between the wire encoding
+	// and the stable long-term storage format.  As a result, make use of
+	// BtcDecode.
+	return msg.BtcDecode(r, 0, BaseEncoding)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgCFilter) Command() string {
+	return CmdCFilter
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgCFilter) MaxPayloadLength(pver uint32) uint32 {
+	return uint32(VarIntSerializeSize(MaxCFilterDataSize)) +
+		MaxCFilterDataSize + chainhash.HashSize + 1
+}
+
+// NewMsgCFilter returns a new bitcoin cfilter message that conforms to the
+// Message interface. See MsgCFilter for details.
+func NewMsgCFilter(filterType FilterType, blockHash *chainhash.Hash,
+	data []byte) *MsgCFilter {
+	return &MsgCFilter{
+		FilterType: filterType,
+		BlockHash:  *blockHash,
+		Data:       data,
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgfeefilter.go

@@ -0,0 +1,64 @@
+// 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 wire
+
+import (
+	"fmt"
+	"io"
+)
+
+// MsgFeeFilter implements the Message interface and represents a bitcoin
+// feefilter message.  It is used to request the receiving peer does not
+// announce any transactions below the specified minimum fee rate.
+//
+// This message was not added until protocol versions starting with
+// FeeFilterVersion.
+type MsgFeeFilter struct {
+	MinFee int64
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgFeeFilter) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	if pver < FeeFilterVersion {
+		str := fmt.Sprintf("feefilter message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgFeeFilter.BtcDecode", str)
+	}
+
+	return readElement(r, &msg.MinFee)
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgFeeFilter) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	if pver < FeeFilterVersion {
+		str := fmt.Sprintf("feefilter message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgFeeFilter.BtcEncode", str)
+	}
+
+	return writeElement(w, msg.MinFee)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgFeeFilter) Command() string {
+	return CmdFeeFilter
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgFeeFilter) MaxPayloadLength(pver uint32) uint32 {
+	return 8
+}
+
+// NewMsgFeeFilter returns a new bitcoin feefilter message that conforms to
+// the Message interface.  See MsgFeeFilter for details.
+func NewMsgFeeFilter(minfee int64) *MsgFeeFilter {
+	return &MsgFeeFilter{
+		MinFee: minfee,
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgfilteradd.go

@@ -0,0 +1,81 @@
+// Copyright (c) 2014-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"fmt"
+	"io"
+)
+
+const (
+	// MaxFilterAddDataSize is the maximum byte size of a data
+	// element to add to the Bloom filter.  It is equal to the
+	// maximum element size of a script.
+	MaxFilterAddDataSize = 520
+)
+
+// MsgFilterAdd implements the Message interface and represents a bitcoin
+// filteradd message.  It is used to add a data element to an existing Bloom
+// filter.
+//
+// This message was not added until protocol version BIP0037Version.
+type MsgFilterAdd struct {
+	Data []byte
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgFilterAdd) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	if pver < BIP0037Version {
+		str := fmt.Sprintf("filteradd message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgFilterAdd.BtcDecode", str)
+	}
+
+	var err error
+	msg.Data, err = ReadVarBytes(r, pver, MaxFilterAddDataSize,
+		"filteradd data")
+	return err
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgFilterAdd) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	if pver < BIP0037Version {
+		str := fmt.Sprintf("filteradd message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgFilterAdd.BtcEncode", str)
+	}
+
+	size := len(msg.Data)
+	if size > MaxFilterAddDataSize {
+		str := fmt.Sprintf("filteradd size too large for message "+
+			"[size %v, max %v]", size, MaxFilterAddDataSize)
+		return messageError("MsgFilterAdd.BtcEncode", str)
+	}
+
+	return WriteVarBytes(w, pver, msg.Data)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgFilterAdd) Command() string {
+	return CmdFilterAdd
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgFilterAdd) MaxPayloadLength(pver uint32) uint32 {
+	return uint32(VarIntSerializeSize(MaxFilterAddDataSize)) +
+		MaxFilterAddDataSize
+}
+
+// NewMsgFilterAdd returns a new bitcoin filteradd message that conforms to the
+// Message interface.  See MsgFilterAdd for details.
+func NewMsgFilterAdd(data []byte) *MsgFilterAdd {
+	return &MsgFilterAdd{
+		Data: data,
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgfilterclear.go

@@ -0,0 +1,59 @@
+// Copyright (c) 2014-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"fmt"
+	"io"
+)
+
+// MsgFilterClear implements the Message interface and represents a bitcoin
+// filterclear message which is used to reset a Bloom filter.
+//
+// This message was not added until protocol version BIP0037Version and has
+// no payload.
+type MsgFilterClear struct{}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgFilterClear) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	if pver < BIP0037Version {
+		str := fmt.Sprintf("filterclear message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgFilterClear.BtcDecode", str)
+	}
+
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgFilterClear) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	if pver < BIP0037Version {
+		str := fmt.Sprintf("filterclear message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgFilterClear.BtcEncode", str)
+	}
+
+	return nil
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgFilterClear) Command() string {
+	return CmdFilterClear
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgFilterClear) MaxPayloadLength(pver uint32) uint32 {
+	return 0
+}
+
+// NewMsgFilterClear returns a new bitcoin filterclear message that conforms to the Message
+// interface.  See MsgFilterClear for details.
+func NewMsgFilterClear() *MsgFilterClear {
+	return &MsgFilterClear{}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgfilterload.go

@@ -0,0 +1,136 @@
+// Copyright (c) 2014-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"fmt"
+	"io"
+)
+
+// BloomUpdateType specifies how the filter is updated when a match is found
+type BloomUpdateType uint8
+
+const (
+	// BloomUpdateNone indicates the filter is not adjusted when a match is
+	// found.
+	BloomUpdateNone BloomUpdateType = 0
+
+	// BloomUpdateAll indicates if the filter matches any data element in a
+	// public key script, the outpoint is serialized and inserted into the
+	// filter.
+	BloomUpdateAll BloomUpdateType = 1
+
+	// BloomUpdateP2PubkeyOnly indicates if the filter matches a data
+	// element in a public key script and the script is of the standard
+	// pay-to-pubkey or multisig, the outpoint is serialized and inserted
+	// into the filter.
+	BloomUpdateP2PubkeyOnly BloomUpdateType = 2
+)
+
+const (
+	// MaxFilterLoadHashFuncs is the maximum number of hash functions to
+	// load into the Bloom filter.
+	MaxFilterLoadHashFuncs = 50
+
+	// MaxFilterLoadFilterSize is the maximum size in bytes a filter may be.
+	MaxFilterLoadFilterSize = 36000
+)
+
+// MsgFilterLoad implements the Message interface and represents a bitcoin
+// filterload message which is used to reset a Bloom filter.
+//
+// This message was not added until protocol version BIP0037Version.
+type MsgFilterLoad struct {
+	Filter    []byte
+	HashFuncs uint32
+	Tweak     uint32
+	Flags     BloomUpdateType
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgFilterLoad) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	if pver < BIP0037Version {
+		str := fmt.Sprintf("filterload message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgFilterLoad.BtcDecode", str)
+	}
+
+	var err error
+	msg.Filter, err = ReadVarBytes(r, pver, MaxFilterLoadFilterSize,
+		"filterload filter size")
+	if err != nil {
+		return err
+	}
+
+	err = readElements(r, &msg.HashFuncs, &msg.Tweak, &msg.Flags)
+	if err != nil {
+		return err
+	}
+
+	if msg.HashFuncs > MaxFilterLoadHashFuncs {
+		str := fmt.Sprintf("too many filter hash functions for message "+
+			"[count %v, max %v]", msg.HashFuncs, MaxFilterLoadHashFuncs)
+		return messageError("MsgFilterLoad.BtcDecode", str)
+	}
+
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgFilterLoad) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	if pver < BIP0037Version {
+		str := fmt.Sprintf("filterload message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgFilterLoad.BtcEncode", str)
+	}
+
+	size := len(msg.Filter)
+	if size > MaxFilterLoadFilterSize {
+		str := fmt.Sprintf("filterload filter size too large for message "+
+			"[size %v, max %v]", size, MaxFilterLoadFilterSize)
+		return messageError("MsgFilterLoad.BtcEncode", str)
+	}
+
+	if msg.HashFuncs > MaxFilterLoadHashFuncs {
+		str := fmt.Sprintf("too many filter hash functions for message "+
+			"[count %v, max %v]", msg.HashFuncs, MaxFilterLoadHashFuncs)
+		return messageError("MsgFilterLoad.BtcEncode", str)
+	}
+
+	err := WriteVarBytes(w, pver, msg.Filter)
+	if err != nil {
+		return err
+	}
+
+	return writeElements(w, msg.HashFuncs, msg.Tweak, msg.Flags)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgFilterLoad) Command() string {
+	return CmdFilterLoad
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgFilterLoad) MaxPayloadLength(pver uint32) uint32 {
+	// Num filter bytes (varInt) + filter + 4 bytes hash funcs +
+	// 4 bytes tweak + 1 byte flags.
+	return uint32(VarIntSerializeSize(MaxFilterLoadFilterSize)) +
+		MaxFilterLoadFilterSize + 9
+}
+
+// NewMsgFilterLoad returns a new bitcoin filterload message that conforms to
+// the Message interface.  See MsgFilterLoad for details.
+func NewMsgFilterLoad(filter []byte, hashFuncs uint32, tweak uint32, flags BloomUpdateType) *MsgFilterLoad {
+	return &MsgFilterLoad{
+		Filter:    filter,
+		HashFuncs: hashFuncs,
+		Tweak:     tweak,
+		Flags:     flags,
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msggetaddr.go

@@ -0,0 +1,47 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"io"
+)
+
+// MsgGetAddr implements the Message interface and represents a bitcoin
+// getaddr message.  It is used to request a list of known active peers on the
+// network from a peer to help identify potential nodes.  The list is returned
+// via one or more addr messages (MsgAddr).
+//
+// This message has no payload.
+type MsgGetAddr struct{}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgGetAddr) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgGetAddr) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	return nil
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgGetAddr) Command() string {
+	return CmdGetAddr
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgGetAddr) MaxPayloadLength(pver uint32) uint32 {
+	return 0
+}
+
+// NewMsgGetAddr returns a new bitcoin getaddr message that conforms to the
+// Message interface.  See MsgGetAddr for details.
+func NewMsgGetAddr() *MsgGetAddr {
+	return &MsgGetAddr{}
+}

vendor/github.com/ltcsuite/ltcd/wire/msggetblocks.go

@@ -0,0 +1,139 @@
+// 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 wire
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+// MaxBlockLocatorsPerMsg is the maximum number of block locator hashes allowed
+// per message.
+const MaxBlockLocatorsPerMsg = 500
+
+// MsgGetBlocks implements the Message interface and represents a bitcoin
+// getblocks message.  It is used to request a list of blocks starting after the
+// last known hash in the slice of block locator hashes.  The list is returned
+// via an inv message (MsgInv) and is limited by a specific hash to stop at or
+// the maximum number of blocks per message, which is currently 500.
+//
+// Set the HashStop field to the hash at which to stop and use
+// AddBlockLocatorHash to build up the list of block locator hashes.
+//
+// The algorithm for building the block locator hashes should be to add the
+// hashes in reverse order until you reach the genesis block.  In order to keep
+// the list of locator hashes to a reasonable number of entries, first add the
+// most recent 10 block hashes, then double the step each loop iteration to
+// exponentially decrease the number of hashes the further away from head and
+// closer to the genesis block you get.
+type MsgGetBlocks struct {
+	ProtocolVersion    uint32
+	BlockLocatorHashes []*chainhash.Hash
+	HashStop           chainhash.Hash
+}
+
+// AddBlockLocatorHash adds a new block locator hash to the message.
+func (msg *MsgGetBlocks) AddBlockLocatorHash(hash *chainhash.Hash) error {
+	if len(msg.BlockLocatorHashes)+1 > MaxBlockLocatorsPerMsg {
+		str := fmt.Sprintf("too many block locator hashes for message [max %v]",
+			MaxBlockLocatorsPerMsg)
+		return messageError("MsgGetBlocks.AddBlockLocatorHash", str)
+	}
+
+	msg.BlockLocatorHashes = append(msg.BlockLocatorHashes, hash)
+	return nil
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgGetBlocks) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	err := readElement(r, &msg.ProtocolVersion)
+	if err != nil {
+		return err
+	}
+
+	// Read num block locator hashes and limit to max.
+	count, err := ReadVarInt(r, pver)
+	if err != nil {
+		return err
+	}
+	if count > MaxBlockLocatorsPerMsg {
+		str := fmt.Sprintf("too many block locator hashes for message "+
+			"[count %v, max %v]", count, MaxBlockLocatorsPerMsg)
+		return messageError("MsgGetBlocks.BtcDecode", str)
+	}
+
+	// Create a contiguous slice of hashes to deserialize into in order to
+	// reduce the number of allocations.
+	locatorHashes := make([]chainhash.Hash, count)
+	msg.BlockLocatorHashes = make([]*chainhash.Hash, 0, count)
+	for i := uint64(0); i < count; i++ {
+		hash := &locatorHashes[i]
+		err := readElement(r, hash)
+		if err != nil {
+			return err
+		}
+		msg.AddBlockLocatorHash(hash)
+	}
+
+	return readElement(r, &msg.HashStop)
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgGetBlocks) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	count := len(msg.BlockLocatorHashes)
+	if count > MaxBlockLocatorsPerMsg {
+		str := fmt.Sprintf("too many block locator hashes for message "+
+			"[count %v, max %v]", count, MaxBlockLocatorsPerMsg)
+		return messageError("MsgGetBlocks.BtcEncode", str)
+	}
+
+	err := writeElement(w, msg.ProtocolVersion)
+	if err != nil {
+		return err
+	}
+
+	err = WriteVarInt(w, pver, uint64(count))
+	if err != nil {
+		return err
+	}
+
+	for _, hash := range msg.BlockLocatorHashes {
+		err = writeElement(w, hash)
+		if err != nil {
+			return err
+		}
+	}
+
+	return writeElement(w, &msg.HashStop)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgGetBlocks) Command() string {
+	return CmdGetBlocks
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgGetBlocks) MaxPayloadLength(pver uint32) uint32 {
+	// Protocol version 4 bytes + num hashes (varInt) + max block locator
+	// hashes + hash stop.
+	return 4 + MaxVarIntPayload + (MaxBlockLocatorsPerMsg * chainhash.HashSize) + chainhash.HashSize
+}
+
+// NewMsgGetBlocks returns a new bitcoin getblocks message that conforms to the
+// Message interface using the passed parameters and defaults for the remaining
+// fields.
+func NewMsgGetBlocks(hashStop *chainhash.Hash) *MsgGetBlocks {
+	return &MsgGetBlocks{
+		ProtocolVersion:    ProtocolVersion,
+		BlockLocatorHashes: make([]*chainhash.Hash, 0, MaxBlockLocatorsPerMsg),
+		HashStop:           *hashStop,
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msggetcfcheckpt.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2018 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"io"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+// MsgGetCFCheckpt is a request for filter headers at evenly spaced intervals
+// throughout the blockchain history. It allows to set the FilterType field to
+// get headers in the chain of basic (0x00) or extended (0x01) headers.
+type MsgGetCFCheckpt struct {
+	FilterType FilterType
+	StopHash   chainhash.Hash
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgGetCFCheckpt) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
+	err := readElement(r, &msg.FilterType)
+	if err != nil {
+		return err
+	}
+
+	return readElement(r, &msg.StopHash)
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgGetCFCheckpt) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
+	err := writeElement(w, msg.FilterType)
+	if err != nil {
+		return err
+	}
+
+	return writeElement(w, &msg.StopHash)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgGetCFCheckpt) Command() string {
+	return CmdGetCFCheckpt
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgGetCFCheckpt) MaxPayloadLength(pver uint32) uint32 {
+	// Filter type + uint32 + block hash
+	return 1 + chainhash.HashSize
+}
+
+// NewMsgGetCFCheckpt returns a new bitcoin getcfcheckpt message that conforms
+// to the Message interface using the passed parameters and defaults for the
+// remaining fields.
+func NewMsgGetCFCheckpt(filterType FilterType, stopHash *chainhash.Hash) *MsgGetCFCheckpt {
+	return &MsgGetCFCheckpt{
+		FilterType: filterType,
+		StopHash:   *stopHash,
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msggetcfheaders.go

@@ -0,0 +1,77 @@
+// 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 wire
+
+import (
+	"io"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+// MsgGetCFHeaders is a message similar to MsgGetHeaders, but for committed
+// filter headers. It allows to set the FilterType field to get headers in the
+// chain of basic (0x00) or extended (0x01) headers.
+type MsgGetCFHeaders struct {
+	FilterType  FilterType
+	StartHeight uint32
+	StopHash    chainhash.Hash
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgGetCFHeaders) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
+	err := readElement(r, &msg.FilterType)
+	if err != nil {
+		return err
+	}
+
+	err = readElement(r, &msg.StartHeight)
+	if err != nil {
+		return err
+	}
+
+	return readElement(r, &msg.StopHash)
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgGetCFHeaders) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
+	err := writeElement(w, msg.FilterType)
+	if err != nil {
+		return err
+	}
+
+	err = writeElement(w, &msg.StartHeight)
+	if err != nil {
+		return err
+	}
+
+	return writeElement(w, &msg.StopHash)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgGetCFHeaders) Command() string {
+	return CmdGetCFHeaders
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgGetCFHeaders) MaxPayloadLength(pver uint32) uint32 {
+	// Filter type + uint32 + block hash
+	return 1 + 4 + chainhash.HashSize
+}
+
+// NewMsgGetCFHeaders returns a new bitcoin getcfheader message that conforms to
+// the Message interface using the passed parameters and defaults for the
+// remaining fields.
+func NewMsgGetCFHeaders(filterType FilterType, startHeight uint32,
+	stopHash *chainhash.Hash) *MsgGetCFHeaders {
+	return &MsgGetCFHeaders{
+		FilterType:  filterType,
+		StartHeight: startHeight,
+		StopHash:    *stopHash,
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msggetcfilters.go

@@ -0,0 +1,81 @@
+// 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 wire
+
+import (
+	"io"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+// MaxGetCFiltersReqRange the maximum number of filters that may be requested in
+// a getcfheaders message.
+const MaxGetCFiltersReqRange = 1000
+
+// MsgGetCFilters implements the Message interface and represents a bitcoin
+// getcfilters message. It is used to request committed filters for a range of
+// blocks.
+type MsgGetCFilters struct {
+	FilterType  FilterType
+	StartHeight uint32
+	StopHash    chainhash.Hash
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgGetCFilters) BtcDecode(r io.Reader, pver uint32, _ MessageEncoding) error {
+	err := readElement(r, &msg.FilterType)
+	if err != nil {
+		return err
+	}
+
+	err = readElement(r, &msg.StartHeight)
+	if err != nil {
+		return err
+	}
+
+	return readElement(r, &msg.StopHash)
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgGetCFilters) BtcEncode(w io.Writer, pver uint32, _ MessageEncoding) error {
+	err := writeElement(w, msg.FilterType)
+	if err != nil {
+		return err
+	}
+
+	err = writeElement(w, &msg.StartHeight)
+	if err != nil {
+		return err
+	}
+
+	return writeElement(w, &msg.StopHash)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgGetCFilters) Command() string {
+	return CmdGetCFilters
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgGetCFilters) MaxPayloadLength(pver uint32) uint32 {
+	// Filter type + uint32 + block hash
+	return 1 + 4 + chainhash.HashSize
+}
+
+// NewMsgGetCFilters returns a new bitcoin getcfilters message that conforms to
+// the Message interface using the passed parameters and defaults for the
+// remaining fields.
+func NewMsgGetCFilters(filterType FilterType, startHeight uint32,
+	stopHash *chainhash.Hash) *MsgGetCFilters {
+	return &MsgGetCFilters{
+		FilterType:  filterType,
+		StartHeight: startHeight,
+		StopHash:    *stopHash,
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msggetdata.go

@@ -0,0 +1,133 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"fmt"
+	"io"
+)
+
+// MsgGetData implements the Message interface and represents a bitcoin
+// getdata message.  It is used to request data such as blocks and transactions
+// from another peer.  It should be used in response to the inv (MsgInv) message
+// to request the actual data referenced by each inventory vector the receiving
+// peer doesn't already have.  Each message is limited to a maximum number of
+// inventory vectors, which is currently 50,000.  As a result, multiple messages
+// must be used to request larger amounts of data.
+//
+// Use the AddInvVect function to build up the list of inventory vectors when
+// sending a getdata message to another peer.
+type MsgGetData struct {
+	InvList []*InvVect
+}
+
+// AddInvVect adds an inventory vector to the message.
+func (msg *MsgGetData) AddInvVect(iv *InvVect) error {
+	if len(msg.InvList)+1 > MaxInvPerMsg {
+		str := fmt.Sprintf("too many invvect in message [max %v]",
+			MaxInvPerMsg)
+		return messageError("MsgGetData.AddInvVect", str)
+	}
+
+	msg.InvList = append(msg.InvList, iv)
+	return nil
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgGetData) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	count, err := ReadVarInt(r, pver)
+	if err != nil {
+		return err
+	}
+
+	// Limit to max inventory vectors per message.
+	if count > MaxInvPerMsg {
+		str := fmt.Sprintf("too many invvect in message [%v]", count)
+		return messageError("MsgGetData.BtcDecode", str)
+	}
+
+	// Create a contiguous slice of inventory vectors to deserialize into in
+	// order to reduce the number of allocations.
+	invList := make([]InvVect, count)
+	msg.InvList = make([]*InvVect, 0, count)
+	for i := uint64(0); i < count; i++ {
+		iv := &invList[i]
+		err := readInvVect(r, pver, iv)
+		if err != nil {
+			return err
+		}
+		msg.AddInvVect(iv)
+	}
+
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgGetData) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	// Limit to max inventory vectors per message.
+	count := len(msg.InvList)
+	if count > MaxInvPerMsg {
+		str := fmt.Sprintf("too many invvect in message [%v]", count)
+		return messageError("MsgGetData.BtcEncode", str)
+	}
+
+	err := WriteVarInt(w, pver, uint64(count))
+	if err != nil {
+		return err
+	}
+
+	for _, iv := range msg.InvList {
+		err := writeInvVect(w, pver, iv)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgGetData) Command() string {
+	return CmdGetData
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgGetData) MaxPayloadLength(pver uint32) uint32 {
+	// Num inventory vectors (varInt) + max allowed inventory vectors.
+	return MaxVarIntPayload + (MaxInvPerMsg * maxInvVectPayload)
+}
+
+// NewMsgGetData returns a new bitcoin getdata message that conforms to the
+// Message interface.  See MsgGetData for details.
+func NewMsgGetData() *MsgGetData {
+	return &MsgGetData{
+		InvList: make([]*InvVect, 0, defaultInvListAlloc),
+	}
+}
+
+// NewMsgGetDataSizeHint returns a new bitcoin getdata message that conforms to
+// the Message interface.  See MsgGetData for details.  This function differs
+// from NewMsgGetData in that it allows a default allocation size for the
+// backing array which houses the inventory vector list.  This allows callers
+// who know in advance how large the inventory list will grow to avoid the
+// overhead of growing the internal backing array several times when appending
+// large amounts of inventory vectors with AddInvVect.  Note that the specified
+// hint is just that - a hint that is used for the default allocation size.
+// Adding more (or less) inventory vectors will still work properly.  The size
+// hint is limited to MaxInvPerMsg.
+func NewMsgGetDataSizeHint(sizeHint uint) *MsgGetData {
+	// Limit the specified hint to the maximum allow per message.
+	if sizeHint > MaxInvPerMsg {
+		sizeHint = MaxInvPerMsg
+	}
+
+	return &MsgGetData{
+		InvList: make([]*InvVect, 0, sizeHint),
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msggetheaders.go

@@ -0,0 +1,136 @@
+// 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 wire
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+// MsgGetHeaders implements the Message interface and represents a bitcoin
+// getheaders message.  It is used to request a list of block headers for
+// blocks starting after the last known hash in the slice of block locator
+// hashes.  The list is returned via a headers message (MsgHeaders) and is
+// limited by a specific hash to stop at or the maximum number of block headers
+// per message, which is currently 2000.
+//
+// Set the HashStop field to the hash at which to stop and use
+// AddBlockLocatorHash to build up the list of block locator hashes.
+//
+// The algorithm for building the block locator hashes should be to add the
+// hashes in reverse order until you reach the genesis block.  In order to keep
+// the list of locator hashes to a resonable number of entries, first add the
+// most recent 10 block hashes, then double the step each loop iteration to
+// exponentially decrease the number of hashes the further away from head and
+// closer to the genesis block you get.
+type MsgGetHeaders struct {
+	ProtocolVersion    uint32
+	BlockLocatorHashes []*chainhash.Hash
+	HashStop           chainhash.Hash
+}
+
+// AddBlockLocatorHash adds a new block locator hash to the message.
+func (msg *MsgGetHeaders) AddBlockLocatorHash(hash *chainhash.Hash) error {
+	if len(msg.BlockLocatorHashes)+1 > MaxBlockLocatorsPerMsg {
+		str := fmt.Sprintf("too many block locator hashes for message [max %v]",
+			MaxBlockLocatorsPerMsg)
+		return messageError("MsgGetHeaders.AddBlockLocatorHash", str)
+	}
+
+	msg.BlockLocatorHashes = append(msg.BlockLocatorHashes, hash)
+	return nil
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgGetHeaders) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	err := readElement(r, &msg.ProtocolVersion)
+	if err != nil {
+		return err
+	}
+
+	// Read num block locator hashes and limit to max.
+	count, err := ReadVarInt(r, pver)
+	if err != nil {
+		return err
+	}
+	if count > MaxBlockLocatorsPerMsg {
+		str := fmt.Sprintf("too many block locator hashes for message "+
+			"[count %v, max %v]", count, MaxBlockLocatorsPerMsg)
+		return messageError("MsgGetHeaders.BtcDecode", str)
+	}
+
+	// Create a contiguous slice of hashes to deserialize into in order to
+	// reduce the number of allocations.
+	locatorHashes := make([]chainhash.Hash, count)
+	msg.BlockLocatorHashes = make([]*chainhash.Hash, 0, count)
+	for i := uint64(0); i < count; i++ {
+		hash := &locatorHashes[i]
+		err := readElement(r, hash)
+		if err != nil {
+			return err
+		}
+		msg.AddBlockLocatorHash(hash)
+	}
+
+	return readElement(r, &msg.HashStop)
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgGetHeaders) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	// Limit to max block locator hashes per message.
+	count := len(msg.BlockLocatorHashes)
+	if count > MaxBlockLocatorsPerMsg {
+		str := fmt.Sprintf("too many block locator hashes for message "+
+			"[count %v, max %v]", count, MaxBlockLocatorsPerMsg)
+		return messageError("MsgGetHeaders.BtcEncode", str)
+	}
+
+	err := writeElement(w, msg.ProtocolVersion)
+	if err != nil {
+		return err
+	}
+
+	err = WriteVarInt(w, pver, uint64(count))
+	if err != nil {
+		return err
+	}
+
+	for _, hash := range msg.BlockLocatorHashes {
+		err := writeElement(w, hash)
+		if err != nil {
+			return err
+		}
+	}
+
+	return writeElement(w, &msg.HashStop)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgGetHeaders) Command() string {
+	return CmdGetHeaders
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgGetHeaders) MaxPayloadLength(pver uint32) uint32 {
+	// Version 4 bytes + num block locator hashes (varInt) + max allowed block
+	// locators + hash stop.
+	return 4 + MaxVarIntPayload + (MaxBlockLocatorsPerMsg *
+		chainhash.HashSize) + chainhash.HashSize
+}
+
+// NewMsgGetHeaders returns a new bitcoin getheaders message that conforms to
+// the Message interface.  See MsgGetHeaders for details.
+func NewMsgGetHeaders() *MsgGetHeaders {
+	return &MsgGetHeaders{
+		BlockLocatorHashes: make([]*chainhash.Hash, 0,
+			MaxBlockLocatorsPerMsg),
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgheaders.go

@@ -0,0 +1,136 @@
+// 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 wire
+
+import (
+	"fmt"
+	"io"
+)
+
+// MaxBlockHeadersPerMsg is the maximum number of block headers that can be in
+// a single bitcoin headers message.
+const MaxBlockHeadersPerMsg = 2000
+
+// MsgHeaders implements the Message interface and represents a bitcoin headers
+// message.  It is used to deliver block header information in response
+// to a getheaders message (MsgGetHeaders).  The maximum number of block headers
+// per message is currently 2000.  See MsgGetHeaders for details on requesting
+// the headers.
+type MsgHeaders struct {
+	Headers []*BlockHeader
+}
+
+// AddBlockHeader adds a new block header to the message.
+func (msg *MsgHeaders) AddBlockHeader(bh *BlockHeader) error {
+	if len(msg.Headers)+1 > MaxBlockHeadersPerMsg {
+		str := fmt.Sprintf("too many block headers in message [max %v]",
+			MaxBlockHeadersPerMsg)
+		return messageError("MsgHeaders.AddBlockHeader", str)
+	}
+
+	msg.Headers = append(msg.Headers, bh)
+	return nil
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgHeaders) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	count, err := ReadVarInt(r, pver)
+	if err != nil {
+		return err
+	}
+
+	// Limit to max block headers per message.
+	if count > MaxBlockHeadersPerMsg {
+		str := fmt.Sprintf("too many block headers for message "+
+			"[count %v, max %v]", count, MaxBlockHeadersPerMsg)
+		return messageError("MsgHeaders.BtcDecode", str)
+	}
+
+	// Create a contiguous slice of headers to deserialize into in order to
+	// reduce the number of allocations.
+	headers := make([]BlockHeader, count)
+	msg.Headers = make([]*BlockHeader, 0, count)
+	for i := uint64(0); i < count; i++ {
+		bh := &headers[i]
+		err := readBlockHeader(r, pver, bh)
+		if err != nil {
+			return err
+		}
+
+		txCount, err := ReadVarInt(r, pver)
+		if err != nil {
+			return err
+		}
+
+		// Ensure the transaction count is zero for headers.
+		if txCount > 0 {
+			str := fmt.Sprintf("block headers may not contain "+
+				"transactions [count %v]", txCount)
+			return messageError("MsgHeaders.BtcDecode", str)
+		}
+		msg.AddBlockHeader(bh)
+	}
+
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgHeaders) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	// Limit to max block headers per message.
+	count := len(msg.Headers)
+	if count > MaxBlockHeadersPerMsg {
+		str := fmt.Sprintf("too many block headers for message "+
+			"[count %v, max %v]", count, MaxBlockHeadersPerMsg)
+		return messageError("MsgHeaders.BtcEncode", str)
+	}
+
+	err := WriteVarInt(w, pver, uint64(count))
+	if err != nil {
+		return err
+	}
+
+	for _, bh := range msg.Headers {
+		err := writeBlockHeader(w, pver, bh)
+		if err != nil {
+			return err
+		}
+
+		// The wire protocol encoding always includes a 0 for the number
+		// of transactions on header messages.  This is really just an
+		// artifact of the way the original implementation serializes
+		// block headers, but it is required.
+		err = WriteVarInt(w, pver, 0)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgHeaders) Command() string {
+	return CmdHeaders
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgHeaders) MaxPayloadLength(pver uint32) uint32 {
+	// Num headers (varInt) + max allowed headers (header length + 1 byte
+	// for the number of transactions which is always 0).
+	return MaxVarIntPayload + ((MaxBlockHeaderPayload + 1) *
+		MaxBlockHeadersPerMsg)
+}
+
+// NewMsgHeaders returns a new bitcoin headers message that conforms to the
+// Message interface.  See MsgHeaders for details.
+func NewMsgHeaders() *MsgHeaders {
+	return &MsgHeaders{
+		Headers: make([]*BlockHeader, 0, MaxBlockHeadersPerMsg),
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msginv.go

@@ -0,0 +1,141 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"fmt"
+	"io"
+)
+
+// defaultInvListAlloc is the default size used for the backing array for an
+// inventory list.  The array will dynamically grow as needed, but this
+// figure is intended to provide enough space for the max number of inventory
+// vectors in a *typical* inventory message without needing to grow the backing
+// array multiple times.  Technically, the list can grow to MaxInvPerMsg, but
+// rather than using that large figure, this figure more accurately reflects the
+// typical case.
+const defaultInvListAlloc = 1000
+
+// MsgInv implements the Message interface and represents a bitcoin inv message.
+// It is used to advertise a peer's known data such as blocks and transactions
+// through inventory vectors.  It may be sent unsolicited to inform other peers
+// of the data or in response to a getblocks message (MsgGetBlocks).  Each
+// message is limited to a maximum number of inventory vectors, which is
+// currently 50,000.
+//
+// Use the AddInvVect function to build up the list of inventory vectors when
+// sending an inv message to another peer.
+type MsgInv struct {
+	InvList []*InvVect
+}
+
+// AddInvVect adds an inventory vector to the message.
+func (msg *MsgInv) AddInvVect(iv *InvVect) error {
+	if len(msg.InvList)+1 > MaxInvPerMsg {
+		str := fmt.Sprintf("too many invvect in message [max %v]",
+			MaxInvPerMsg)
+		return messageError("MsgInv.AddInvVect", str)
+	}
+
+	msg.InvList = append(msg.InvList, iv)
+	return nil
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgInv) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	count, err := ReadVarInt(r, pver)
+	if err != nil {
+		return err
+	}
+
+	// Limit to max inventory vectors per message.
+	if count > MaxInvPerMsg {
+		str := fmt.Sprintf("too many invvect in message [%v]", count)
+		return messageError("MsgInv.BtcDecode", str)
+	}
+
+	// Create a contiguous slice of inventory vectors to deserialize into in
+	// order to reduce the number of allocations.
+	invList := make([]InvVect, count)
+	msg.InvList = make([]*InvVect, 0, count)
+	for i := uint64(0); i < count; i++ {
+		iv := &invList[i]
+		err := readInvVect(r, pver, iv)
+		if err != nil {
+			return err
+		}
+		msg.AddInvVect(iv)
+	}
+
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgInv) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	// Limit to max inventory vectors per message.
+	count := len(msg.InvList)
+	if count > MaxInvPerMsg {
+		str := fmt.Sprintf("too many invvect in message [%v]", count)
+		return messageError("MsgInv.BtcEncode", str)
+	}
+
+	err := WriteVarInt(w, pver, uint64(count))
+	if err != nil {
+		return err
+	}
+
+	for _, iv := range msg.InvList {
+		err := writeInvVect(w, pver, iv)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgInv) Command() string {
+	return CmdInv
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgInv) MaxPayloadLength(pver uint32) uint32 {
+	// Num inventory vectors (varInt) + max allowed inventory vectors.
+	return MaxVarIntPayload + (MaxInvPerMsg * maxInvVectPayload)
+}
+
+// NewMsgInv returns a new bitcoin inv message that conforms to the Message
+// interface.  See MsgInv for details.
+func NewMsgInv() *MsgInv {
+	return &MsgInv{
+		InvList: make([]*InvVect, 0, defaultInvListAlloc),
+	}
+}
+
+// NewMsgInvSizeHint returns a new bitcoin inv message that conforms to the
+// Message interface.  See MsgInv for details.  This function differs from
+// NewMsgInv in that it allows a default allocation size for the backing array
+// which houses the inventory vector list.  This allows callers who know in
+// advance how large the inventory list will grow to avoid the overhead of
+// growing the internal backing array several times when appending large amounts
+// of inventory vectors with AddInvVect.  Note that the specified hint is just
+// that - a hint that is used for the default allocation size.  Adding more
+// (or less) inventory vectors will still work properly.  The size hint is
+// limited to MaxInvPerMsg.
+func NewMsgInvSizeHint(sizeHint uint) *MsgInv {
+	// Limit the specified hint to the maximum allow per message.
+	if sizeHint > MaxInvPerMsg {
+		sizeHint = MaxInvPerMsg
+	}
+
+	return &MsgInv{
+		InvList: make([]*InvVect, 0, sizeHint),
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgmempool.go

@@ -0,0 +1,60 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"fmt"
+	"io"
+)
+
+// MsgMemPool implements the Message interface and represents a bitcoin mempool
+// message.  It is used to request a list of transactions still in the active
+// memory pool of a relay.
+//
+// This message has no payload and was not added until protocol versions
+// starting with BIP0035Version.
+type MsgMemPool struct{}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgMemPool) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	if pver < BIP0035Version {
+		str := fmt.Sprintf("mempool message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgMemPool.BtcDecode", str)
+	}
+
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgMemPool) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	if pver < BIP0035Version {
+		str := fmt.Sprintf("mempool message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgMemPool.BtcEncode", str)
+	}
+
+	return nil
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgMemPool) Command() string {
+	return CmdMemPool
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgMemPool) MaxPayloadLength(pver uint32) uint32 {
+	return 0
+}
+
+// NewMsgMemPool returns a new bitcoin pong message that conforms to the Message
+// interface.  See MsgPong for details.
+func NewMsgMemPool() *MsgMemPool {
+	return &MsgMemPool{}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgmerkleblock.go

@@ -0,0 +1,159 @@
+// 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 wire
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+// maxFlagsPerMerkleBlock is the maximum number of flag bytes that could
+// possibly fit into a merkle block.  Since each transaction is represented by
+// a single bit, this is the max number of transactions per block divided by
+// 8 bits per byte.  Then an extra one to cover partials.
+const maxFlagsPerMerkleBlock = maxTxPerBlock / 8
+
+// MsgMerkleBlock implements the Message interface and represents a bitcoin
+// merkleblock message which is used to reset a Bloom filter.
+//
+// This message was not added until protocol version BIP0037Version.
+type MsgMerkleBlock struct {
+	Header       BlockHeader
+	Transactions uint32
+	Hashes       []*chainhash.Hash
+	Flags        []byte
+}
+
+// AddTxHash adds a new transaction hash to the message.
+func (msg *MsgMerkleBlock) AddTxHash(hash *chainhash.Hash) error {
+	if len(msg.Hashes)+1 > maxTxPerBlock {
+		str := fmt.Sprintf("too many tx hashes for message [max %v]",
+			maxTxPerBlock)
+		return messageError("MsgMerkleBlock.AddTxHash", str)
+	}
+
+	msg.Hashes = append(msg.Hashes, hash)
+	return nil
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgMerkleBlock) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	if pver < BIP0037Version {
+		str := fmt.Sprintf("merkleblock message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgMerkleBlock.BtcDecode", str)
+	}
+
+	err := readBlockHeader(r, pver, &msg.Header)
+	if err != nil {
+		return err
+	}
+
+	err = readElement(r, &msg.Transactions)
+	if err != nil {
+		return err
+	}
+
+	// Read num block locator hashes and limit to max.
+	count, err := ReadVarInt(r, pver)
+	if err != nil {
+		return err
+	}
+	if count > maxTxPerBlock {
+		str := fmt.Sprintf("too many transaction hashes for message "+
+			"[count %v, max %v]", count, maxTxPerBlock)
+		return messageError("MsgMerkleBlock.BtcDecode", str)
+	}
+
+	// Create a contiguous slice of hashes to deserialize into in order to
+	// reduce the number of allocations.
+	hashes := make([]chainhash.Hash, count)
+	msg.Hashes = make([]*chainhash.Hash, 0, count)
+	for i := uint64(0); i < count; i++ {
+		hash := &hashes[i]
+		err := readElement(r, hash)
+		if err != nil {
+			return err
+		}
+		msg.AddTxHash(hash)
+	}
+
+	msg.Flags, err = ReadVarBytes(r, pver, maxFlagsPerMerkleBlock,
+		"merkle block flags size")
+	return err
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgMerkleBlock) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	if pver < BIP0037Version {
+		str := fmt.Sprintf("merkleblock message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgMerkleBlock.BtcEncode", str)
+	}
+
+	// Read num transaction hashes and limit to max.
+	numHashes := len(msg.Hashes)
+	if numHashes > maxTxPerBlock {
+		str := fmt.Sprintf("too many transaction hashes for message "+
+			"[count %v, max %v]", numHashes, maxTxPerBlock)
+		return messageError("MsgMerkleBlock.BtcDecode", str)
+	}
+	numFlagBytes := len(msg.Flags)
+	if numFlagBytes > maxFlagsPerMerkleBlock {
+		str := fmt.Sprintf("too many flag bytes for message [count %v, "+
+			"max %v]", numFlagBytes, maxFlagsPerMerkleBlock)
+		return messageError("MsgMerkleBlock.BtcDecode", str)
+	}
+
+	err := writeBlockHeader(w, pver, &msg.Header)
+	if err != nil {
+		return err
+	}
+
+	err = writeElement(w, msg.Transactions)
+	if err != nil {
+		return err
+	}
+
+	err = WriteVarInt(w, pver, uint64(numHashes))
+	if err != nil {
+		return err
+	}
+	for _, hash := range msg.Hashes {
+		err = writeElement(w, hash)
+		if err != nil {
+			return err
+		}
+	}
+
+	return WriteVarBytes(w, pver, msg.Flags)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgMerkleBlock) Command() string {
+	return CmdMerkleBlock
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgMerkleBlock) MaxPayloadLength(pver uint32) uint32 {
+	return MaxBlockPayload
+}
+
+// NewMsgMerkleBlock returns a new bitcoin merkleblock message that conforms to
+// the Message interface.  See MsgMerkleBlock for details.
+func NewMsgMerkleBlock(bh *BlockHeader) *MsgMerkleBlock {
+	return &MsgMerkleBlock{
+		Header:       *bh,
+		Transactions: 0,
+		Hashes:       make([]*chainhash.Hash, 0),
+		Flags:        make([]byte, 0),
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgnotfound.go

@@ -0,0 +1,110 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"fmt"
+	"io"
+)
+
+// MsgNotFound defines a bitcoin notfound message which is sent in response to
+// a getdata message if any of the requested data in not available on the peer.
+// Each message is limited to a maximum number of inventory vectors, which is
+// currently 50,000.
+//
+// Use the AddInvVect function to build up the list of inventory vectors when
+// sending a notfound message to another peer.
+type MsgNotFound struct {
+	InvList []*InvVect
+}
+
+// AddInvVect adds an inventory vector to the message.
+func (msg *MsgNotFound) AddInvVect(iv *InvVect) error {
+	if len(msg.InvList)+1 > MaxInvPerMsg {
+		str := fmt.Sprintf("too many invvect in message [max %v]",
+			MaxInvPerMsg)
+		return messageError("MsgNotFound.AddInvVect", str)
+	}
+
+	msg.InvList = append(msg.InvList, iv)
+	return nil
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgNotFound) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	count, err := ReadVarInt(r, pver)
+	if err != nil {
+		return err
+	}
+
+	// Limit to max inventory vectors per message.
+	if count > MaxInvPerMsg {
+		str := fmt.Sprintf("too many invvect in message [%v]", count)
+		return messageError("MsgNotFound.BtcDecode", str)
+	}
+
+	// Create a contiguous slice of inventory vectors to deserialize into in
+	// order to reduce the number of allocations.
+	invList := make([]InvVect, count)
+	msg.InvList = make([]*InvVect, 0, count)
+	for i := uint64(0); i < count; i++ {
+		iv := &invList[i]
+		err := readInvVect(r, pver, iv)
+		if err != nil {
+			return err
+		}
+		msg.AddInvVect(iv)
+	}
+
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgNotFound) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	// Limit to max inventory vectors per message.
+	count := len(msg.InvList)
+	if count > MaxInvPerMsg {
+		str := fmt.Sprintf("too many invvect in message [%v]", count)
+		return messageError("MsgNotFound.BtcEncode", str)
+	}
+
+	err := WriteVarInt(w, pver, uint64(count))
+	if err != nil {
+		return err
+	}
+
+	for _, iv := range msg.InvList {
+		err := writeInvVect(w, pver, iv)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgNotFound) Command() string {
+	return CmdNotFound
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgNotFound) MaxPayloadLength(pver uint32) uint32 {
+	// Max var int 9 bytes + max InvVects at 36 bytes each.
+	// Num inventory vectors (varInt) + max allowed inventory vectors.
+	return MaxVarIntPayload + (MaxInvPerMsg * maxInvVectPayload)
+}
+
+// NewMsgNotFound returns a new bitcoin notfound message that conforms to the
+// Message interface.  See MsgNotFound for details.
+func NewMsgNotFound() *MsgNotFound {
+	return &MsgNotFound{
+		InvList: make([]*InvVect, 0, defaultInvListAlloc),
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgping.go

@@ -0,0 +1,87 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"io"
+)
+
+// MsgPing implements the Message interface and represents a bitcoin ping
+// message.
+//
+// For versions BIP0031Version and earlier, it is used primarily to confirm
+// that a connection is still valid.  A transmission error is typically
+// interpreted as a closed connection and that the peer should be removed.
+// For versions AFTER BIP0031Version it contains an identifier which can be
+// returned in the pong message to determine network timing.
+//
+// The payload for this message just consists of a nonce used for identifying
+// it later.
+type MsgPing struct {
+	// Unique value associated with message that is used to identify
+	// specific ping message.
+	Nonce uint64
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgPing) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	// There was no nonce for BIP0031Version and earlier.
+	// NOTE: > is not a mistake here.  The BIP0031 was defined as AFTER
+	// the version unlike most others.
+	if pver > BIP0031Version {
+		err := readElement(r, &msg.Nonce)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgPing) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	// There was no nonce for BIP0031Version and earlier.
+	// NOTE: > is not a mistake here.  The BIP0031 was defined as AFTER
+	// the version unlike most others.
+	if pver > BIP0031Version {
+		err := writeElement(w, msg.Nonce)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgPing) Command() string {
+	return CmdPing
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgPing) MaxPayloadLength(pver uint32) uint32 {
+	plen := uint32(0)
+	// There was no nonce for BIP0031Version and earlier.
+	// NOTE: > is not a mistake here.  The BIP0031 was defined as AFTER
+	// the version unlike most others.
+	if pver > BIP0031Version {
+		// Nonce 8 bytes.
+		plen += 8
+	}
+
+	return plen
+}
+
+// NewMsgPing returns a new bitcoin ping message that conforms to the Message
+// interface.  See MsgPing for details.
+func NewMsgPing(nonce uint64) *MsgPing {
+	return &MsgPing{
+		Nonce: nonce,
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgpong.go

@@ -0,0 +1,78 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"fmt"
+	"io"
+)
+
+// MsgPong implements the Message interface and represents a bitcoin pong
+// message which is used primarily to confirm that a connection is still valid
+// in response to a bitcoin ping message (MsgPing).
+//
+// This message was not added until protocol versions AFTER BIP0031Version.
+type MsgPong struct {
+	// Unique value associated with message that is used to identify
+	// specific ping message.
+	Nonce uint64
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgPong) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	// NOTE: <= is not a mistake here.  The BIP0031 was defined as AFTER
+	// the version unlike most others.
+	if pver <= BIP0031Version {
+		str := fmt.Sprintf("pong message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgPong.BtcDecode", str)
+	}
+
+	return readElement(r, &msg.Nonce)
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgPong) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	// NOTE: <= is not a mistake here.  The BIP0031 was defined as AFTER
+	// the version unlike most others.
+	if pver <= BIP0031Version {
+		str := fmt.Sprintf("pong message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgPong.BtcEncode", str)
+	}
+
+	return writeElement(w, msg.Nonce)
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgPong) Command() string {
+	return CmdPong
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgPong) MaxPayloadLength(pver uint32) uint32 {
+	plen := uint32(0)
+	// The pong message did not exist for BIP0031Version and earlier.
+	// NOTE: > is not a mistake here.  The BIP0031 was defined as AFTER
+	// the version unlike most others.
+	if pver > BIP0031Version {
+		// Nonce 8 bytes.
+		plen += 8
+	}
+
+	return plen
+}
+
+// NewMsgPong returns a new bitcoin pong message that conforms to the Message
+// interface.  See MsgPong for details.
+func NewMsgPong(nonce uint64) *MsgPong {
+	return &MsgPong{
+		Nonce: nonce,
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgreject.go

@@ -0,0 +1,186 @@
+// 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 wire
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
+)
+
+// RejectCode represents a numeric value by which a remote peer indicates
+// why a message was rejected.
+type RejectCode uint8
+
+// These constants define the various supported reject codes.
+const (
+	RejectMalformed       RejectCode = 0x01
+	RejectInvalid         RejectCode = 0x10
+	RejectObsolete        RejectCode = 0x11
+	RejectDuplicate       RejectCode = 0x12
+	RejectNonstandard     RejectCode = 0x40
+	RejectDust            RejectCode = 0x41
+	RejectInsufficientFee RejectCode = 0x42
+	RejectCheckpoint      RejectCode = 0x43
+)
+
+// Map of reject codes back strings for pretty printing.
+var rejectCodeStrings = map[RejectCode]string{
+	RejectMalformed:       "REJECT_MALFORMED",
+	RejectInvalid:         "REJECT_INVALID",
+	RejectObsolete:        "REJECT_OBSOLETE",
+	RejectDuplicate:       "REJECT_DUPLICATE",
+	RejectNonstandard:     "REJECT_NONSTANDARD",
+	RejectDust:            "REJECT_DUST",
+	RejectInsufficientFee: "REJECT_INSUFFICIENTFEE",
+	RejectCheckpoint:      "REJECT_CHECKPOINT",
+}
+
+// String returns the RejectCode in human-readable form.
+func (code RejectCode) String() string {
+	if s, ok := rejectCodeStrings[code]; ok {
+		return s
+	}
+
+	return fmt.Sprintf("Unknown RejectCode (%d)", uint8(code))
+}
+
+// MsgReject implements the Message interface and represents a bitcoin reject
+// message.
+//
+// This message was not added until protocol version RejectVersion.
+type MsgReject struct {
+	// Cmd is the command for the message which was rejected such as
+	// as CmdBlock or CmdTx.  This can be obtained from the Command function
+	// of a Message.
+	Cmd string
+
+	// RejectCode is a code indicating why the command was rejected.  It
+	// is encoded as a uint8 on the wire.
+	Code RejectCode
+
+	// Reason is a human-readable string with specific details (over and
+	// above the reject code) about why the command was rejected.
+	Reason string
+
+	// Hash identifies a specific block or transaction that was rejected
+	// and therefore only applies the MsgBlock and MsgTx messages.
+	Hash chainhash.Hash
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgReject) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	if pver < RejectVersion {
+		str := fmt.Sprintf("reject message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgReject.BtcDecode", str)
+	}
+
+	// Command that was rejected.
+	cmd, err := ReadVarString(r, pver)
+	if err != nil {
+		return err
+	}
+	msg.Cmd = cmd
+
+	// Code indicating why the command was rejected.
+	err = readElement(r, &msg.Code)
+	if err != nil {
+		return err
+	}
+
+	// Human readable string with specific details (over and above the
+	// reject code above) about why the command was rejected.
+	reason, err := ReadVarString(r, pver)
+	if err != nil {
+		return err
+	}
+	msg.Reason = reason
+
+	// CmdBlock and CmdTx messages have an additional hash field that
+	// identifies the specific block or transaction.
+	if msg.Cmd == CmdBlock || msg.Cmd == CmdTx {
+		err := readElement(r, &msg.Hash)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgReject) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	if pver < RejectVersion {
+		str := fmt.Sprintf("reject message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgReject.BtcEncode", str)
+	}
+
+	// Command that was rejected.
+	err := WriteVarString(w, pver, msg.Cmd)
+	if err != nil {
+		return err
+	}
+
+	// Code indicating why the command was rejected.
+	err = writeElement(w, msg.Code)
+	if err != nil {
+		return err
+	}
+
+	// Human readable string with specific details (over and above the
+	// reject code above) about why the command was rejected.
+	err = WriteVarString(w, pver, msg.Reason)
+	if err != nil {
+		return err
+	}
+
+	// CmdBlock and CmdTx messages have an additional hash field that
+	// identifies the specific block or transaction.
+	if msg.Cmd == CmdBlock || msg.Cmd == CmdTx {
+		err := writeElement(w, &msg.Hash)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgReject) Command() string {
+	return CmdReject
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgReject) MaxPayloadLength(pver uint32) uint32 {
+	plen := uint32(0)
+	// The reject message did not exist before protocol version
+	// RejectVersion.
+	if pver >= RejectVersion {
+		// Unfortunately the bitcoin protocol does not enforce a sane
+		// limit on the length of the reason, so the max payload is the
+		// overall maximum message payload.
+		plen = MaxMessagePayload
+	}
+
+	return plen
+}
+
+// NewMsgReject returns a new bitcoin reject message that conforms to the
+// Message interface.  See MsgReject for details.
+func NewMsgReject(command string, code RejectCode, reason string) *MsgReject {
+	return &MsgReject{
+		Cmd:    command,
+		Code:   code,
+		Reason: reason,
+	}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgsendheaders.go

@@ -0,0 +1,60 @@
+// 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 wire
+
+import (
+	"fmt"
+	"io"
+)
+
+// MsgSendHeaders implements the Message interface and represents a bitcoin
+// sendheaders message.  It is used to request the peer send block headers
+// rather than inventory vectors.
+//
+// This message has no payload and was not added until protocol versions
+// starting with SendHeadersVersion.
+type MsgSendHeaders struct{}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgSendHeaders) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	if pver < SendHeadersVersion {
+		str := fmt.Sprintf("sendheaders message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgSendHeaders.BtcDecode", str)
+	}
+
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgSendHeaders) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	if pver < SendHeadersVersion {
+		str := fmt.Sprintf("sendheaders message invalid for protocol "+
+			"version %d", pver)
+		return messageError("MsgSendHeaders.BtcEncode", str)
+	}
+
+	return nil
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgSendHeaders) Command() string {
+	return CmdSendHeaders
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgSendHeaders) MaxPayloadLength(pver uint32) uint32 {
+	return 0
+}
+
+// NewMsgSendHeaders returns a new bitcoin sendheaders message that conforms to
+// the Message interface.  See MsgSendHeaders for details.
+func NewMsgSendHeaders() *MsgSendHeaders {
+	return &MsgSendHeaders{}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgverack.go

@@ -0,0 +1,46 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"io"
+)
+
+// MsgVerAck defines a bitcoin verack message which is used for a peer to
+// acknowledge a version message (MsgVersion) after it has used the information
+// to negotiate parameters.  It implements the Message interface.
+//
+// This message has no payload.
+type MsgVerAck struct{}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// This is part of the Message interface implementation.
+func (msg *MsgVerAck) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgVerAck) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	return nil
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgVerAck) Command() string {
+	return CmdVerAck
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgVerAck) MaxPayloadLength(pver uint32) uint32 {
+	return 0
+}
+
+// NewMsgVerAck returns a new bitcoin verack message that conforms to the
+// Message interface.
+func NewMsgVerAck() *MsgVerAck {
+	return &MsgVerAck{}
+}

vendor/github.com/ltcsuite/ltcd/wire/msgversion.go

@@ -0,0 +1,269 @@
+// 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 wire
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"strings"
+	"time"
+)
+
+// MaxUserAgentLen is the maximum allowed length for the user agent field in a
+// version message (MsgVersion).
+const MaxUserAgentLen = 256
+
+// DefaultUserAgent for wire in the stack
+const DefaultUserAgent = "/btcwire:0.5.0/"
+
+// MsgVersion implements the Message interface and represents a bitcoin version
+// message.  It is used for a peer to advertise itself as soon as an outbound
+// connection is made.  The remote peer then uses this information along with
+// its own to negotiate.  The remote peer must then respond with a version
+// message of its own containing the negotiated values followed by a verack
+// message (MsgVerAck).  This exchange must take place before any further
+// communication is allowed to proceed.
+type MsgVersion struct {
+	// Version of the protocol the node is using.
+	ProtocolVersion int32
+
+	// Bitfield which identifies the enabled services.
+	Services ServiceFlag
+
+	// Time the message was generated.  This is encoded as an int64 on the wire.
+	Timestamp time.Time
+
+	// Address of the remote peer.
+	AddrYou NetAddress
+
+	// Address of the local peer.
+	AddrMe NetAddress
+
+	// Unique value associated with message that is used to detect self
+	// connections.
+	Nonce uint64
+
+	// The user agent that generated messsage.  This is a encoded as a varString
+	// on the wire.  This has a max length of MaxUserAgentLen.
+	UserAgent string
+
+	// Last block seen by the generator of the version message.
+	LastBlock int32
+
+	// Don't announce transactions to peer.
+	DisableRelayTx bool
+}
+
+// HasService returns whether the specified service is supported by the peer
+// that generated the message.
+func (msg *MsgVersion) HasService(service ServiceFlag) bool {
+	return msg.Services&service == service
+}
+
+// AddService adds service as a supported service by the peer generating the
+// message.
+func (msg *MsgVersion) AddService(service ServiceFlag) {
+	msg.Services |= service
+}
+
+// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// The version message is special in that the protocol version hasn't been
+// negotiated yet.  As a result, the pver field is ignored and any fields which
+// are added in new versions are optional.  This also mean that r must be a
+// *bytes.Buffer so the number of remaining bytes can be ascertained.
+//
+// This is part of the Message interface implementation.
+func (msg *MsgVersion) BtcDecode(r io.Reader, pver uint32, enc MessageEncoding) error {
+	buf, ok := r.(*bytes.Buffer)
+	if !ok {
+		return fmt.Errorf("MsgVersion.BtcDecode reader is not a " +
+			"*bytes.Buffer")
+	}
+
+	err := readElements(buf, &msg.ProtocolVersion, &msg.Services,
+		(*int64Time)(&msg.Timestamp))
+	if err != nil {
+		return err
+	}
+
+	err = readNetAddress(buf, pver, &msg.AddrYou, false)
+	if err != nil {
+		return err
+	}
+
+	// Protocol versions >= 106 added a from address, nonce, and user agent
+	// field and they are only considered present if there are bytes
+	// remaining in the message.
+	if buf.Len() > 0 {
+		err = readNetAddress(buf, pver, &msg.AddrMe, false)
+		if err != nil {
+			return err
+		}
+	}
+	if buf.Len() > 0 {
+		err = readElement(buf, &msg.Nonce)
+		if err != nil {
+			return err
+		}
+	}
+	if buf.Len() > 0 {
+		userAgent, err := ReadVarString(buf, pver)
+		if err != nil {
+			return err
+		}
+		err = validateUserAgent(userAgent)
+		if err != nil {
+			return err
+		}
+		msg.UserAgent = userAgent
+	}
+
+	// Protocol versions >= 209 added a last known block field.  It is only
+	// considered present if there are bytes remaining in the message.
+	if buf.Len() > 0 {
+		err = readElement(buf, &msg.LastBlock)
+		if err != nil {
+			return err
+		}
+	}
+
+	// There was no relay transactions field before BIP0037Version, but
+	// the default behavior prior to the addition of the field was to always
+	// relay transactions.
+	if buf.Len() > 0 {
+		// It's safe to ignore the error here since the buffer has at
+		// least one byte and that byte will result in a boolean value
+		// regardless of its value.  Also, the wire encoding for the
+		// field is true when transactions should be relayed, so reverse
+		// it for the DisableRelayTx field.
+		var relayTx bool
+		readElement(r, &relayTx)
+		msg.DisableRelayTx = !relayTx
+	}
+
+	return nil
+}
+
+// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// This is part of the Message interface implementation.
+func (msg *MsgVersion) BtcEncode(w io.Writer, pver uint32, enc MessageEncoding) error {
+	err := validateUserAgent(msg.UserAgent)
+	if err != nil {
+		return err
+	}
+
+	err = writeElements(w, msg.ProtocolVersion, msg.Services,
+		msg.Timestamp.Unix())
+	if err != nil {
+		return err
+	}
+
+	err = writeNetAddress(w, pver, &msg.AddrYou, false)
+	if err != nil {
+		return err
+	}
+
+	err = writeNetAddress(w, pver, &msg.AddrMe, false)
+	if err != nil {
+		return err
+	}
+
+	err = writeElement(w, msg.Nonce)
+	if err != nil {
+		return err
+	}
+
+	err = WriteVarString(w, pver, msg.UserAgent)
+	if err != nil {
+		return err
+	}
+
+	err = writeElement(w, msg.LastBlock)
+	if err != nil {
+		return err
+	}
+
+	// There was no relay transactions field before BIP0037Version.  Also,
+	// the wire encoding for the field is true when transactions should be
+	// relayed, so reverse it from the DisableRelayTx field.
+	if pver >= BIP0037Version {
+		err = writeElement(w, !msg.DisableRelayTx)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Command returns the protocol command string for the message.  This is part
+// of the Message interface implementation.
+func (msg *MsgVersion) Command() string {
+	return CmdVersion
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver.  This is part of the Message interface implementation.
+func (msg *MsgVersion) MaxPayloadLength(pver uint32) uint32 {
+	// XXX: <= 106 different
+
+	// Protocol version 4 bytes + services 8 bytes + timestamp 8 bytes +
+	// remote and local net addresses + nonce 8 bytes + length of user
+	// agent (varInt) + max allowed useragent length + last block 4 bytes +
+	// relay transactions flag 1 byte.
+	return 33 + (maxNetAddressPayload(pver) * 2) + MaxVarIntPayload +
+		MaxUserAgentLen
+}
+
+// NewMsgVersion returns a new bitcoin version message that conforms to the
+// Message interface using the passed parameters and defaults for the remaining
+// fields.
+func NewMsgVersion(me *NetAddress, you *NetAddress, nonce uint64,
+	lastBlock int32) *MsgVersion {
+
+	// Limit the timestamp to one second precision since the protocol
+	// doesn't support better.
+	return &MsgVersion{
+		ProtocolVersion: int32(ProtocolVersion),
+		Services:        0,
+		Timestamp:       time.Unix(time.Now().Unix(), 0),
+		AddrYou:         *you,
+		AddrMe:          *me,
+		Nonce:           nonce,
+		UserAgent:       DefaultUserAgent,
+		LastBlock:       lastBlock,
+		DisableRelayTx:  false,
+	}
+}
+
+// validateUserAgent checks userAgent length against MaxUserAgentLen
+func validateUserAgent(userAgent string) error {
+	if len(userAgent) > MaxUserAgentLen {
+		str := fmt.Sprintf("user agent too long [len %v, max %v]",
+			len(userAgent), MaxUserAgentLen)
+		return messageError("MsgVersion", str)
+	}
+	return nil
+}
+
+// AddUserAgent adds a user agent to the user agent string for the version
+// message.  The version string is not defined to any strict format, although
+// it is recommended to use the form "major.minor.revision" e.g. "2.6.41".
+func (msg *MsgVersion) AddUserAgent(name string, version string,
+	comments ...string) error {
+
+	newUserAgent := fmt.Sprintf("%s:%s", name, version)
+	if len(comments) != 0 {
+		newUserAgent = fmt.Sprintf("%s(%s)", newUserAgent,
+			strings.Join(comments, "; "))
+	}
+	newUserAgent = fmt.Sprintf("%s%s/", msg.UserAgent, newUserAgent)
+	err := validateUserAgent(newUserAgent)
+	if err != nil {
+		return err
+	}
+	msg.UserAgent = newUserAgent
+	return nil
+}

vendor/github.com/ltcsuite/ltcd/wire/netaddress.go

@@ -0,0 +1,149 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package wire
+
+import (
+	"encoding/binary"
+	"io"
+	"net"
+	"time"
+)
+
+// maxNetAddressPayload returns the max payload size for a bitcoin NetAddress
+// based on the protocol version.
+func maxNetAddressPayload(pver uint32) uint32 {
+	// Services 8 bytes + ip 16 bytes + port 2 bytes.
+	plen := uint32(26)
+
+	// NetAddressTimeVersion added a timestamp field.
+	if pver >= NetAddressTimeVersion {
+		// Timestamp 4 bytes.
+		plen += 4
+	}
+
+	return plen
+}
+
+// NetAddress defines information about a peer on the network including the time
+// it was last seen, the services it supports, its IP address, and port.
+type NetAddress struct {
+	// Last time the address was seen.  This is, unfortunately, encoded as a
+	// uint32 on the wire and therefore is limited to 2106.  This field is
+	// not present in the bitcoin version message (MsgVersion) nor was it
+	// added until protocol version >= NetAddressTimeVersion.
+	Timestamp time.Time
+
+	// Bitfield which identifies the services supported by the address.
+	Services ServiceFlag
+
+	// IP address of the peer.
+	IP net.IP
+
+	// Port the peer is using.  This is encoded in big endian on the wire
+	// which differs from most everything else.
+	Port uint16
+}
+
+// HasService returns whether the specified service is supported by the address.
+func (na *NetAddress) HasService(service ServiceFlag) bool {
+	return na.Services&service == service
+}
+
+// AddService adds service as a supported service by the peer generating the
+// message.
+func (na *NetAddress) AddService(service ServiceFlag) {
+	na.Services |= service
+}
+
+// NewNetAddressIPPort returns a new NetAddress using the provided IP, port, and
+// supported services with defaults for the remaining fields.
+func NewNetAddressIPPort(ip net.IP, port uint16, services ServiceFlag) *NetAddress {
+	return NewNetAddressTimestamp(time.Now(), services, ip, port)
+}
+
+// NewNetAddressTimestamp returns a new NetAddress using the provided
+// timestamp, IP, port, and supported services. The timestamp is rounded to
+// single second precision.
+func NewNetAddressTimestamp(
+	timestamp time.Time, services ServiceFlag, ip net.IP, port uint16) *NetAddress {
+	// Limit the timestamp to one second precision since the protocol
+	// doesn't support better.
+	na := NetAddress{
+		Timestamp: time.Unix(timestamp.Unix(), 0),
+		Services:  services,
+		IP:        ip,
+		Port:      port,
+	}
+	return &na
+}
+
+// NewNetAddress returns a new NetAddress using the provided TCP address and
+// supported services with defaults for the remaining fields.
+func NewNetAddress(addr *net.TCPAddr, services ServiceFlag) *NetAddress {
+	return NewNetAddressIPPort(addr.IP, uint16(addr.Port), services)
+}
+
+// readNetAddress reads an encoded NetAddress from r depending on the protocol
+// version and whether or not the timestamp is included per ts.  Some messages
+// like version do not include the timestamp.
+func readNetAddress(r io.Reader, pver uint32, na *NetAddress, ts bool) error {
+	var ip [16]byte
+
+	// NOTE: The bitcoin protocol uses a uint32 for the timestamp so it will
+	// stop working somewhere around 2106.  Also timestamp wasn't added until
+	// protocol version >= NetAddressTimeVersion
+	if ts && pver >= NetAddressTimeVersion {
+		err := readElement(r, (*uint32Time)(&na.Timestamp))
+		if err != nil {
+			return err
+		}
+	}
+
+	err := readElements(r, &na.Services, &ip)
+	if err != nil {
+		return err
+	}
+	// Sigh.  Bitcoin protocol mixes little and big endian.
+	port, err := binarySerializer.Uint16(r, bigEndian)
+	if err != nil {
+		return err
+	}
+
+	*na = NetAddress{
+		Timestamp: na.Timestamp,
+		Services:  na.Services,
+		IP:        net.IP(ip[:]),
+		Port:      port,
+	}
+	return nil
+}
+
+// writeNetAddress serializes a NetAddress to w depending on the protocol
+// version and whether or not the timestamp is included per ts.  Some messages
+// like version do not include the timestamp.
+func writeNetAddress(w io.Writer, pver uint32, na *NetAddress, ts bool) error {
+	// NOTE: The bitcoin protocol uses a uint32 for the timestamp so it will
+	// stop working somewhere around 2106.  Also timestamp wasn't added until
+	// until protocol version >= NetAddressTimeVersion.
+	if ts && pver >= NetAddressTimeVersion {
+		err := writeElement(w, uint32(na.Timestamp.Unix()))
+		if err != nil {
+			return err
+		}
+	}
+
+	// Ensure to always write 16 bytes even if the ip is nil.
+	var ip [16]byte
+	if na.IP != nil {
+		copy(ip[:], na.IP.To16())
+	}
+	err := writeElements(w, na.Services, ip)
+	if err != nil {
+		return err
+	}
+
+	// Sigh.  Bitcoin protocol mixes little and big endian.
+	return binary.Write(w, bigEndian, na.Port)
+}

vendor/github.com/ltcsuite/ltcd/wire/protocol.go

@@ -0,0 +1,182 @@
+// 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 wire
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// XXX pedro: we will probably need to bump this.
+const (
+	// ProtocolVersion is the latest protocol version this package supports.
+	ProtocolVersion uint32 = 70015
+
+	// MultipleAddressVersion is the protocol version which added multiple
+	// addresses per message (pver >= MultipleAddressVersion).
+	MultipleAddressVersion uint32 = 209
+
+	// NetAddressTimeVersion is the protocol version which added the
+	// timestamp field (pver >= NetAddressTimeVersion).
+	NetAddressTimeVersion uint32 = 31402
+
+	// BIP0031Version is the protocol version AFTER which a pong message
+	// and nonce field in ping were added (pver > BIP0031Version).
+	BIP0031Version uint32 = 60000
+
+	// BIP0035Version is the protocol version which added the mempool
+	// message (pver >= BIP0035Version).
+	BIP0035Version uint32 = 60002
+
+	// BIP0037Version is the protocol version which added new connection
+	// bloom filtering related messages and extended the version message
+	// with a relay flag (pver >= BIP0037Version).
+	BIP0037Version uint32 = 70001
+
+	// RejectVersion is the protocol version which added a new reject
+	// message.
+	RejectVersion uint32 = 70002
+
+	// BIP0111Version is the protocol version which added the SFNodeBloom
+	// service flag.
+	BIP0111Version uint32 = 70011
+
+	// SendHeadersVersion is the protocol version which added a new
+	// sendheaders message.
+	SendHeadersVersion uint32 = 70012
+
+	// FeeFilterVersion is the protocol version which added a new
+	// feefilter message.
+	FeeFilterVersion uint32 = 70013
+)
+
+// ServiceFlag identifies services supported by a bitcoin peer.
+type ServiceFlag uint64
+
+const (
+	// SFNodeNetwork is a flag used to indicate a peer is a full node.
+	SFNodeNetwork ServiceFlag = 1 << iota
+
+	// SFNodeGetUTXO is a flag used to indicate a peer supports the
+	// getutxos and utxos commands (BIP0064).
+	SFNodeGetUTXO
+
+	// SFNodeBloom is a flag used to indicate a peer supports bloom
+	// filtering.
+	SFNodeBloom
+
+	// SFNodeWitness is a flag used to indicate a peer supports blocks
+	// and transactions including witness data (BIP0144).
+	SFNodeWitness
+
+	// SFNodeXthin is a flag used to indicate a peer supports xthin blocks.
+	SFNodeXthin
+
+	// SFNodeBit5 is a flag used to indicate a peer supports a service
+	// defined by bit 5.
+	SFNodeBit5
+
+	// SFNodeCF is a flag used to indicate a peer supports committed
+	// filters (CFs).
+	SFNodeCF
+
+	// SFNode2X is a flag used to indicate a peer is running the Segwit2X
+	// software.
+	SFNode2X
+)
+
+// Map of service flags back to their constant names for pretty printing.
+var sfStrings = map[ServiceFlag]string{
+	SFNodeNetwork: "SFNodeNetwork",
+	SFNodeGetUTXO: "SFNodeGetUTXO",
+	SFNodeBloom:   "SFNodeBloom",
+	SFNodeWitness: "SFNodeWitness",
+	SFNodeXthin:   "SFNodeXthin",
+	SFNodeBit5:    "SFNodeBit5",
+	SFNodeCF:      "SFNodeCF",
+	SFNode2X:      "SFNode2X",
+}
+
+// orderedSFStrings is an ordered list of service flags from highest to
+// lowest.
+var orderedSFStrings = []ServiceFlag{
+	SFNodeNetwork,
+	SFNodeGetUTXO,
+	SFNodeBloom,
+	SFNodeWitness,
+	SFNodeXthin,
+	SFNodeBit5,
+	SFNodeCF,
+	SFNode2X,
+}
+
+// String returns the ServiceFlag in human-readable form.
+func (f ServiceFlag) String() string {
+	// No flags are set.
+	if f == 0 {
+		return "0x0"
+	}
+
+	// Add individual bit flags.
+	s := ""
+	for _, flag := range orderedSFStrings {
+		if f&flag == flag {
+			s += sfStrings[flag] + "|"
+			f -= flag
+		}
+	}
+
+	// Add any remaining flags which aren't accounted for as hex.
+	s = strings.TrimRight(s, "|")
+	if f != 0 {
+		s += "|0x" + strconv.FormatUint(uint64(f), 16)
+	}
+	s = strings.TrimLeft(s, "|")
+	return s
+}
+
+// BitcoinNet represents which bitcoin network a message belongs to.
+type BitcoinNet uint32
+
+// Constants used to indicate the message bitcoin network.  They can also be
+// used to seek to the next message when a stream's state is unknown, but
+// this package does not provide that functionality since it's generally a
+// better idea to simply disconnect clients that are misbehaving over TCP.
+const (
+	// MainNet represents the main litecoin network.
+	MainNet BitcoinNet = 0xdbb6c0fb
+
+	// TestNet represents the regression test network.
+	TestNet BitcoinNet = 0xdab5bffa
+
+	// TestNet3 represents the test network (version 3).
+	TestNet3 BitcoinNet = 0x0709110b
+
+	// TestNet4 represents the test network (version 4).
+	TestNet4 BitcoinNet = 0xf1c8d2fd
+
+	// SimNet represents the simulation test network.
+	SimNet BitcoinNet = 0x12141c16
+)
+
+// bnStrings is a map of bitcoin networks back to their constant names for
+// pretty printing.
+var bnStrings = map[BitcoinNet]string{
+	MainNet:  "MainNet",
+	TestNet:  "TestNet",
+	TestNet3: "TestNet3",
+	TestNet4: "TestNet4",
+	SimNet:   "SimNet",
+}
+
+// String returns the BitcoinNet in human-readable form.
+func (n BitcoinNet) String() string {
+	if s, ok := bnStrings[n]; ok {
+		return s
+	}
+
+	return fmt.Sprintf("Unknown BitcoinNet (%d)", uint32(n))
+}