Documentation ¶
Overview ¶
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 cash 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 cash 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 cash messages are intended to interact with one another. As stated above, these interactions are not indirectly handled by this package. For more in-depth details about the appropriate interactions, see the official bitcoin cash 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 cash 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.
Bitcoin Cash Network ¶
The bitcoin cash network is a magic number which is used to identify the start of a message and which bitcoin cash network the message applies to. This package provides the following constants:
wire.MainNet wire.TestNet (Regression test network) wire.TestNet3 (Test network version 3) wire.SimNet (Simulation test network)
Determining Message Type ¶
As discussed in the bitcoin cash message overview section, this package reads and writes bitcoin cash 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 cash 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 cash peer. Example syntax is:
// Reads and validates the next bitcoin cash message from conn using the // protocol version pver and the bitcoin cash network bchnet. 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, bchnet) if err != nil { // Log and handle the error }
Writing Messages ¶
In order to marshall bitcoin cash 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 cash peer. Example syntax to request addresses from a remote peer is:
// Create a new getaddr bitcoin cash message. msg := wire.NewMsgGetAddr() // Writes a bitcoin cash message msg to conn using the protocol version // pver, and the bitcoin cash network bchnet. The return is a possible // error. err := wire.WriteMessage(conn, msg, pver, bchnet) 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)
Index ¶
- Constants
- Variables
- func MaxBlockPayload() uint32
- func RandomUint64() (uint64, error)
- func ReadVarBytes(r io.Reader, pver uint32, maxAllowed uint32, fieldName string) ([]byte, error)
- func ReadVarInt(r io.Reader, pver uint32) (uint64, error)
- func ReadVarString(r io.Reader, pver uint32) (string, error)
- func SetLimits(excessiveBlockSize uint32)
- func VarIntSerializeSize(val uint64) int
- func WriteMessage(w io.Writer, msg Message, pver uint32, bchnet BitcoinNet) error
- func WriteMessageN(w io.Writer, msg Message, pver uint32, bchnet BitcoinNet) (int, error)
- func WriteMessageWithEncodingN(w io.Writer, msg Message, pver uint32, bchnet BitcoinNet, ...) (int, error)
- func WriteTxOut(w io.Writer, pver uint32, version int32, to *TxOut) error
- func WriteVarBytes(w io.Writer, pver uint32, bytes []byte) error
- func WriteVarInt(w io.Writer, pver uint32, val uint64) error
- func WriteVarString(w io.Writer, pver uint32, str string) error
- type BitcoinNet
- type BlockHeader
- func (h *BlockHeader) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (h *BlockHeader) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (h *BlockHeader) BlockHash() chainhash.Hash
- func (h *BlockHeader) Deserialize(r io.Reader) error
- func (h *BlockHeader) Serialize(w io.Writer) error
- type BloomUpdateType
- type FilterType
- type InvType
- type InvVect
- type Message
- func ReadMessage(r io.Reader, pver uint32, bchnet BitcoinNet) (Message, []byte, error)
- func ReadMessageN(r io.Reader, pver uint32, bchnet BitcoinNet) (int, Message, []byte, error)
- func ReadMessageWithEncodingN(r io.Reader, pver uint32, bchnet BitcoinNet, enc MessageEncoding) (int, Message, []byte, error)
- type MessageEncoding
- type MessageError
- type MsgAddr
- func (msg *MsgAddr) AddAddress(na *NetAddress) error
- func (msg *MsgAddr) AddAddresses(netAddrs ...*NetAddress) error
- func (msg *MsgAddr) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgAddr) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgAddr) ClearAddresses()
- func (msg *MsgAddr) Command() string
- func (msg *MsgAddr) MaxPayloadLength(pver uint32) uint32
- type MsgBlock
- func (msg *MsgBlock) AddTransaction(tx *MsgTx) error
- func (msg *MsgBlock) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgBlock) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgBlock) BlockHash() chainhash.Hash
- func (msg *MsgBlock) ClearTransactions()
- func (msg *MsgBlock) Command() string
- func (msg *MsgBlock) Deserialize(r io.Reader) error
- func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error)
- func (msg *MsgBlock) MaxPayloadLength(pver uint32) uint32
- func (msg *MsgBlock) Serialize(w io.Writer) error
- func (msg *MsgBlock) SerializeSize() int
- func (msg *MsgBlock) TxHashes() ([]chainhash.Hash, error)
- type MsgBlockTxns
- func (msg *MsgBlockTxns) AbsoluteIndexes(requestedDiffIndexes []uint32) (map[uint32]*MsgTx, error)
- func (msg *MsgBlockTxns) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgBlockTxns) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgBlockTxns) Command() string
- func (msg *MsgBlockTxns) MaxPayloadLength(pver uint32) uint32
- type MsgCFCheckpt
- func (msg *MsgCFCheckpt) AddCFHeader(header *chainhash.Hash) error
- func (msg *MsgCFCheckpt) BchDecode(r io.Reader, pver uint32, _ MessageEncoding) error
- func (msg *MsgCFCheckpt) BchEncode(w io.Writer, pver uint32, _ MessageEncoding) error
- func (msg *MsgCFCheckpt) Command() string
- func (msg *MsgCFCheckpt) Deserialize(r io.Reader) error
- func (msg *MsgCFCheckpt) MaxPayloadLength(pver uint32) uint32
- type MsgCFHeaders
- func (msg *MsgCFHeaders) AddCFHash(hash *chainhash.Hash) error
- func (msg *MsgCFHeaders) BchDecode(r io.Reader, pver uint32, _ MessageEncoding) error
- func (msg *MsgCFHeaders) BchEncode(w io.Writer, pver uint32, _ MessageEncoding) error
- func (msg *MsgCFHeaders) Command() string
- func (msg *MsgCFHeaders) Deserialize(r io.Reader) error
- func (msg *MsgCFHeaders) MaxPayloadLength(pver uint32) uint32
- type MsgCFilter
- func (msg *MsgCFilter) BchDecode(r io.Reader, pver uint32, _ MessageEncoding) error
- func (msg *MsgCFilter) BchEncode(w io.Writer, pver uint32, _ MessageEncoding) error
- func (msg *MsgCFilter) Command() string
- func (msg *MsgCFilter) Deserialize(r io.Reader) error
- func (msg *MsgCFilter) MaxPayloadLength(pver uint32) uint32
- type MsgCmpctBlock
- func (msg *MsgCmpctBlock) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgCmpctBlock) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgCmpctBlock) BlockHash() chainhash.Hash
- func (msg *MsgCmpctBlock) Command() string
- func (msg *MsgCmpctBlock) MaxPayloadLength(pver uint32) uint32
- func (msg *MsgCmpctBlock) TotalTransactions() int
- type MsgFeeFilter
- type MsgFilterAdd
- type MsgFilterClear
- type MsgFilterLoad
- type MsgGetAddr
- type MsgGetBlockTxns
- func (msg *MsgGetBlockTxns) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgGetBlockTxns) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgGetBlockTxns) Command() string
- func (msg *MsgGetBlockTxns) MaxPayloadLength(pver uint32) uint32
- func (msg *MsgGetBlockTxns) RequestedTransactions(block *MsgBlock) ([]*MsgTx, error)
- type MsgGetBlocks
- func (msg *MsgGetBlocks) AddBlockLocatorHash(hash *chainhash.Hash) error
- func (msg *MsgGetBlocks) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgGetBlocks) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgGetBlocks) Command() string
- func (msg *MsgGetBlocks) MaxPayloadLength(pver uint32) uint32
- type MsgGetCFCheckpt
- type MsgGetCFHeaders
- type MsgGetCFMempool
- type MsgGetCFilters
- type MsgGetData
- func (msg *MsgGetData) AddInvVect(iv *InvVect) error
- func (msg *MsgGetData) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgGetData) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgGetData) Command() string
- func (msg *MsgGetData) MaxPayloadLength(pver uint32) uint32
- type MsgGetHeaders
- func (msg *MsgGetHeaders) AddBlockLocatorHash(hash *chainhash.Hash) error
- func (msg *MsgGetHeaders) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgGetHeaders) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgGetHeaders) Command() string
- func (msg *MsgGetHeaders) MaxPayloadLength(pver uint32) uint32
- type MsgHeaders
- func (msg *MsgHeaders) AddBlockHeader(bh *BlockHeader) error
- func (msg *MsgHeaders) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgHeaders) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgHeaders) Command() string
- func (msg *MsgHeaders) MaxPayloadLength(pver uint32) uint32
- type MsgInv
- func (msg *MsgInv) AddInvVect(iv *InvVect) error
- func (msg *MsgInv) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgInv) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgInv) Command() string
- func (msg *MsgInv) MaxPayloadLength(pver uint32) uint32
- type MsgMemPool
- type MsgMerkleBlock
- func (msg *MsgMerkleBlock) AddTxHash(hash *chainhash.Hash) error
- func (msg *MsgMerkleBlock) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgMerkleBlock) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgMerkleBlock) Command() string
- func (msg *MsgMerkleBlock) MaxPayloadLength(pver uint32) uint32
- type MsgNotFound
- func (msg *MsgNotFound) AddInvVect(iv *InvVect) error
- func (msg *MsgNotFound) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgNotFound) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgNotFound) Command() string
- func (msg *MsgNotFound) MaxPayloadLength(pver uint32) uint32
- type MsgPing
- type MsgPong
- type MsgReject
- type MsgSendCmpct
- type MsgSendHeaders
- type MsgTx
- func (msg *MsgTx) AddTxIn(ti *TxIn)
- func (msg *MsgTx) AddTxOut(to *TxOut)
- func (msg *MsgTx) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgTx) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgTx) Command() string
- func (msg *MsgTx) Copy() *MsgTx
- func (msg *MsgTx) Deserialize(r io.Reader) error
- func (msg *MsgTx) MaxPayloadLength(pver uint32) uint32
- func (msg *MsgTx) PkScriptLocs() []int
- func (msg *MsgTx) Serialize(w io.Writer) error
- func (msg *MsgTx) SerializeSize() int
- func (msg *MsgTx) TxHash() chainhash.Hash
- type MsgVerAck
- type MsgVersion
- func (msg *MsgVersion) AddService(service ServiceFlag)
- func (msg *MsgVersion) AddUserAgent(name string, version string, comments ...string) error
- func (msg *MsgVersion) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
- func (msg *MsgVersion) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
- func (msg *MsgVersion) Command() string
- func (msg *MsgVersion) HasService(service ServiceFlag) bool
- func (msg *MsgVersion) MaxPayloadLength(pver uint32) uint32
- type MsgXVerAck
- type MsgXVersion
- type NetAddress
- type OutPoint
- type PrefilledTx
- type RejectCode
- type ServiceFlag
- type TxIn
- type TxLoc
- type TxOut
Constants ¶
const ( CmdVersion = "version" CmdXVersion = "xversion" CmdVerAck = "verack" CmdXVerAck = "xverack" CmdGetAddr = "getaddr" CmdAddr = "addr" CmdGetBlocks = "getblocks" CmdInv = "inv" CmdGetData = "getdata" CmdNotFound = "notfound" CmdBlock = "block" CmdTx = "tx" CmdGetHeaders = "getheaders" CmdHeaders = "headers" CmdPing = "ping" CmdPong = "pong" CmdMemPool = "mempool" CmdFilterAdd = "filteradd" CmdFilterClear = "filterclear" CmdFilterLoad = "filterload" CmdMerkleBlock = "merkleblock" CmdReject = "reject" CmdSendHeaders = "sendheaders" CmdFeeFilter = "feefilter" CmdGetCFilters = "getcfilters" CmdGetCFHeaders = "getcfheaders" CmdGetCFCheckpt = "getcfcheckpt" CmdGetCFMempool = "getcfmempool" CmdCFilter = "cfilter" CmdCFHeaders = "cfheaders" CmdCFCheckpt = "cfcheckpt" CmdSendCmpct = "sendcmpct" CmdCmpctBlock = "cmpctblock" CmdGetBlockTxns = "getblocktxn" CmdBlockTxns = "blocktxn" )
Commands used in bitcoin message headers which describe the type of message.
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 )
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 )
const ( // TxVersion is the current latest supported transaction version. TxVersion = 1 // MaxTxInSequenceNum is the maximum sequence number the sequence field // of a transaction input can be. MaxTxInSequenceNum uint32 = 0xffffffff // MaxPrevOutIndex is the maximum index the index field of a previous // outpoint can be. MaxPrevOutIndex uint32 = 0xffffffff // SequenceLockTimeDisabled is a flag that if set on a transaction // input's sequence number, the sequence number will not be interpreted // as a relative locktime. SequenceLockTimeDisabled = 1 << 31 // SequenceLockTimeIsSeconds is a flag that if set on a transaction // input's sequence number, the relative locktime has units of 512 // seconds. SequenceLockTimeIsSeconds = 1 << 22 // SequenceLockTimeMask is a mask that extracts the relative locktime // when masked against the transaction input sequence number. SequenceLockTimeMask = 0x0000ffff // SequenceLockTimeGranularity is the defined time based granularity // for seconds-based relative time locks. When converting from seconds // to a sequence number, the value is right shifted by this amount, // therefore the granularity of relative time locks in 512 or 2^9 // seconds. Enforced relative lock times are multiples of 512 seconds. SequenceLockTimeGranularity = 9 // MinTxOutPayload is the minimum payload size for a transaction output. // Value 8 bytes + Varint for PkScript length 1 byte. MinTxOutPayload = 9 )
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 // BIP0152Version is the protocol version which added the compact // block relaying. BIP0152Version uint32 = 70014 // NoValidationRelayVersion is the other version number defined // by BIP0152. Nodes using this protocol version or higher also // accept compact block relay but pledge not to ban nodes which // relay blocks without validating them first. NoValidationRelayVersion uint32 = 70015 )
XXX pedro: we will probably need to bump this.
const ( // CFCheckptInterval is the gap (in number of blocks) between each // filter header checkpoint. CFCheckptInterval = 1000 )
const CommandSize = 12
CommandSize is the fixed size of all commands in the common bitcoin message header. Shorter commands must be zero padded.
const CompactBlocksProtocolVersion = 1
CompactBlocksProtocolVersion is the current version of the compact blocks protocol
const DefaultUserAgent = "/bchwire:0.5.0/"
DefaultUserAgent for wire in the stack
const MaxAddrPerMsg = 1000
MaxAddrPerMsg is the maximum number of addresses that can be in a single bitcoin addr message (MsgAddr).
const MaxBlockHeaderPayload = 16 + (chainhash.HashSize * 2)
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 MaxBlockHeadersPerMsg = 2000
MaxBlockHeadersPerMsg is the maximum number of block headers that can be in a single bitcoin headers message.
const MaxBlockLocatorsPerMsg = 500
MaxBlockLocatorsPerMsg is the maximum number of block locator hashes allowed per message.
const MaxBlocksPerMsg = 500
MaxBlocksPerMsg is the maximum number of blocks allowed per message.
const ( // MaxCFilterDataSize is the maximum byte size of a committed filter. // The maximum size is currently defined as 4MiB. This allows it to // accomodate a large mempool. MaxCFilterDataSize = 4 * 1024 * 1024 )
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 )
const MaxGetCFiltersReqRange = 1000
MaxGetCFiltersReqRange the maximum number of filters that may be requested in a getcfheaders message.
const ( // MaxInvPerMsg is the maximum number of inventory vectors that can be in a // single bitcoin inv message. MaxInvPerMsg = 50000 )
const MaxUserAgentLen = 256
MaxUserAgentLen is the maximum allowed length for the user agent field in a version message (MsgVersion).
const (
// MaxVarIntPayload is the maximum payload size for a variable length integer.
MaxVarIntPayload = 9
)
const MessageHeaderSize = 24
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 ShortIDSize = 6
ShortIDSize is the number of bytes in a short ID.
Variables ¶
var ErrInsaneCFHeaderCount = errors.New(
"refusing to decode unreasonable number of filter headers")
ErrInsaneCFHeaderCount signals that we were asked to decode an unreasonable number of cfilter headers.
var LatestEncoding = BaseEncoding
LatestEncoding is the most recently specified encoding for the Bitcoin wire protocol.
Functions ¶
func MaxBlockPayload ¶
func MaxBlockPayload() uint32
MaxBlockPayload returns the maximum bytes a block message can be in bytes.
func RandomUint64 ¶
RandomUint64 returns a cryptographically random uint64 value.
func ReadVarBytes ¶
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 ReadVarInt ¶
ReadVarInt reads a variable length integer from r and returns it as a uint64.
func ReadVarString ¶
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 SetLimits ¶
func SetLimits(excessiveBlockSize uint32)
SetLimits adjusts various message limits based on max block size configuration.
func VarIntSerializeSize ¶
VarIntSerializeSize returns the number of bytes it would take to serialize val as a variable length integer.
func WriteMessage ¶
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 WriteMessageN ¶
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 WriteMessageWithEncodingN ¶
func WriteMessageWithEncodingN(w io.Writer, msg Message, pver uint32, bchnet BitcoinNet, encoding MessageEncoding) (int, error)
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 WriteTxOut ¶
WriteTxOut encodes to into the bitcoin protocol encoding for a transaction output (TxOut) to w.
NOTE: This function is exported in order to allow txscript to compute the new sighashes for witness transactions (BIP0143).
func WriteVarBytes ¶
WriteVarBytes serializes a variable length byte array to w as a varInt containing the number of bytes, followed by the bytes themselves.
func WriteVarInt ¶
WriteVarInt serializes val to w using a variable number of bytes depending on its value.
Types ¶
type BitcoinNet ¶
type BitcoinNet uint32
BitcoinNet represents which bitcoin network a message belongs to.
const ( // MainNet represents the main bitcoin network. MainNet BitcoinNet = 0xe8f3e1e3 // TestNet represents the regression test network. TestNet BitcoinNet = 0xfabfb5da // TestNet3 represents the test network (version 3). TestNet3 BitcoinNet = 0xf4f3e5f4 // TestNet4 represents the test network (version 4). TestNet4 BitcoinNet = 0xafdab7e2 // SimNet represents the simulation test network. SimNet BitcoinNet = 0x12141c16 )
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.
func (BitcoinNet) String ¶
func (n BitcoinNet) String() string
String returns the BitcoinNet in human-readable form.
type BlockHeader ¶
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 }
BlockHeader defines information about a block and is used in the bitcoin block (MsgBlock) and headers (MsgHeaders) messages.
func NewBlockHeader ¶
func NewBlockHeader(version int32, prevHash, merkleRootHash *chainhash.Hash, bits uint32, nonce uint32) *BlockHeader
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 (*BlockHeader) BchDecode ¶
func (h *BlockHeader) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode 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 (*BlockHeader) BchEncode ¶
func (h *BlockHeader) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode 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 (*BlockHeader) BlockHash ¶
func (h *BlockHeader) BlockHash() chainhash.Hash
BlockHash computes the block identifier hash for the given block header.
func (*BlockHeader) Deserialize ¶
func (h *BlockHeader) Deserialize(r io.Reader) error
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.
type BloomUpdateType ¶
type BloomUpdateType uint8
BloomUpdateType specifies how the filter is updated when a match is found
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 )
type FilterType ¶
type FilterType uint8
FilterType is used to represent a filter type.
const ( // GCSFilterRegular is the regular filter type. GCSFilterRegular FilterType = iota )
type InvType ¶
type InvType uint32
InvType represents the allowed types of inventory vectors. See InvVect.
type InvVect ¶
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 Message ¶
type Message interface { BchDecode(io.Reader, uint32, MessageEncoding) error BchEncode(io.Writer, uint32, MessageEncoding) error Command() string MaxPayloadLength(uint32) uint32 }
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.
func ReadMessage ¶
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 ReadMessageN ¶
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 ReadMessageWithEncodingN ¶
func ReadMessageWithEncodingN(r io.Reader, pver uint32, bchnet BitcoinNet, enc MessageEncoding) (int, Message, []byte, error)
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.
type MessageEncoding ¶
type MessageEncoding uint32
MessageEncoding represents the wire message encoding format to be used.
const ( // BaseEncoding encodes all messages in the default format specified // for the Bitcoin wire protocol. BaseEncoding MessageEncoding = 1 << iota )
type MessageError ¶
type MessageError struct { Func string // Function name Description string // Human readable description of the issue }
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.
func (*MessageError) Error ¶
func (e *MessageError) Error() string
Error satisfies the error interface and prints human-readable errors.
type MsgAddr ¶
type MsgAddr struct {
AddrList []*NetAddress
}
MsgAddr implements the Message interface and represents a bitcoin cash 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.
func NewMsgAddr ¶
func NewMsgAddr() *MsgAddr
NewMsgAddr returns a new bitcoin addr message that conforms to the Message interface. See MsgAddr for details.
func (*MsgAddr) AddAddress ¶
func (msg *MsgAddr) AddAddress(na *NetAddress) error
AddAddress adds a known active peer to the message.
func (*MsgAddr) AddAddresses ¶
func (msg *MsgAddr) AddAddresses(netAddrs ...*NetAddress) error
AddAddresses adds multiple known active peers to the message.
func (*MsgAddr) BchDecode ¶
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgAddr) BchEncode ¶
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgAddr) ClearAddresses ¶
func (msg *MsgAddr) ClearAddresses()
ClearAddresses removes all addresses from the message.
func (*MsgAddr) Command ¶
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgAddr) MaxPayloadLength ¶
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgBlock ¶
type MsgBlock struct { Header BlockHeader Transactions []*MsgTx }
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.
func NewMsgBlock ¶
func NewMsgBlock(blockHeader *BlockHeader) *MsgBlock
NewMsgBlock returns a new bitcoin block message that conforms to the Message interface. See MsgBlock for details.
func (*MsgBlock) AddTransaction ¶
AddTransaction adds a transaction to the message.
func (*MsgBlock) BchDecode ¶
BchDecode 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 (*MsgBlock) BchEncode ¶
BchEncode 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 (*MsgBlock) ClearTransactions ¶
func (msg *MsgBlock) ClearTransactions()
ClearTransactions removes all transactions from the message.
func (*MsgBlock) Command ¶
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgBlock) Deserialize ¶
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 BchDecode in that BchDecode 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 (*MsgBlock) DeserializeTxLoc ¶
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 (*MsgBlock) MaxPayloadLength ¶
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
func (*MsgBlock) Serialize ¶
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 BchEncode in that BchEncode 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 (*MsgBlock) SerializeSize ¶
SerializeSize returns the number of bytes it would take to serialize the block, factoring in any witness data within transaction.
type MsgBlockTxns ¶
MsgBlockTxns implements the Message interface and represents a Bitcoin blocktxn message. It is sent in response to the getblocktxn message.
func NewMsgBlockTxns ¶
func NewMsgBlockTxns(blockHash chainhash.Hash, txs []*MsgTx) *MsgBlockTxns
NewMsgBlockTxns returns a new bitcoin blocktxn message that conforms to the Message interface using the passed parameters and defaults for the remaining fields.
func (*MsgBlockTxns) AbsoluteIndexes ¶
func (msg *MsgBlockTxns) AbsoluteIndexes(requestedDiffIndexes []uint32) (map[uint32]*MsgTx, error)
AbsoluteIndexes takes in the requested differential indexes from a MsgGetBlockTxns message and returns a map of the absolution position of a tx in the block to the tx.
func (*MsgBlockTxns) BchDecode ¶
func (msg *MsgBlockTxns) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgBlockTxns) BchEncode ¶
func (msg *MsgBlockTxns) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgBlockTxns) Command ¶
func (msg *MsgBlockTxns) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgBlockTxns) MaxPayloadLength ¶
func (msg *MsgBlockTxns) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgCFCheckpt ¶
type MsgCFCheckpt struct { FilterType FilterType StopHash chainhash.Hash FilterHeaders []*chainhash.Hash }
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.
func NewMsgCFCheckpt ¶
func NewMsgCFCheckpt(filterType FilterType, stopHash *chainhash.Hash, headersCount int) *MsgCFCheckpt
NewMsgCFCheckpt returns a new bitcoin cfheaders message that conforms to the Message interface. See MsgCFCheckpt for details.
func (*MsgCFCheckpt) AddCFHeader ¶
func (msg *MsgCFCheckpt) AddCFHeader(header *chainhash.Hash) error
AddCFHeader adds a new committed filter header to the message.
func (*MsgCFCheckpt) BchDecode ¶
func (msg *MsgCFCheckpt) BchDecode(r io.Reader, pver uint32, _ MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgCFCheckpt) BchEncode ¶
func (msg *MsgCFCheckpt) BchEncode(w io.Writer, pver uint32, _ MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgCFCheckpt) Command ¶
func (msg *MsgCFCheckpt) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgCFCheckpt) Deserialize ¶
func (msg *MsgCFCheckpt) Deserialize(r io.Reader) error
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 BchDecode in that BchDecode 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 (*MsgCFCheckpt) MaxPayloadLength ¶
func (msg *MsgCFCheckpt) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgCFHeaders ¶
type MsgCFHeaders struct { FilterType FilterType StopHash chainhash.Hash PrevFilterHeader chainhash.Hash FilterHashes []*chainhash.Hash }
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.
func NewMsgCFHeaders ¶
func NewMsgCFHeaders() *MsgCFHeaders
NewMsgCFHeaders returns a new bitcoin cfheaders message that conforms to the Message interface. See MsgCFHeaders for details.
func (*MsgCFHeaders) AddCFHash ¶
func (msg *MsgCFHeaders) AddCFHash(hash *chainhash.Hash) error
AddCFHash adds a new filter hash to the message.
func (*MsgCFHeaders) BchDecode ¶
func (msg *MsgCFHeaders) BchDecode(r io.Reader, pver uint32, _ MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgCFHeaders) BchEncode ¶
func (msg *MsgCFHeaders) BchEncode(w io.Writer, pver uint32, _ MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgCFHeaders) Command ¶
func (msg *MsgCFHeaders) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgCFHeaders) Deserialize ¶
func (msg *MsgCFHeaders) Deserialize(r io.Reader) error
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 BchDecode in that BchDecode 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 (*MsgCFHeaders) MaxPayloadLength ¶
func (msg *MsgCFHeaders) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgCFilter ¶
type MsgCFilter struct { FilterType FilterType BlockHash chainhash.Hash Data []byte }
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.
func NewMsgCFilter ¶
func NewMsgCFilter(filterType FilterType, blockHash *chainhash.Hash, data []byte) *MsgCFilter
NewMsgCFilter returns a new bitcoin cfilter message that conforms to the Message interface. See MsgCFilter for details.
func (*MsgCFilter) BchDecode ¶
func (msg *MsgCFilter) BchDecode(r io.Reader, pver uint32, _ MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgCFilter) BchEncode ¶
func (msg *MsgCFilter) BchEncode(w io.Writer, pver uint32, _ MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgCFilter) Command ¶
func (msg *MsgCFilter) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgCFilter) Deserialize ¶
func (msg *MsgCFilter) Deserialize(r io.Reader) error
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 BchDecode in that BchDecode 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 (*MsgCFilter) MaxPayloadLength ¶
func (msg *MsgCFilter) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgCmpctBlock ¶
type MsgCmpctBlock struct { Header BlockHeader Nonce uint64 ShortIDs [][ShortIDSize]byte PrefilledTxs []*PrefilledTx }
MsgCmpctBlock implements the Message interface and represents a Bitcoin cmpctblock message. When using protocol versions equal to or greater than BIP0152Version we save bandwidth on the wire by sending a compact block rather than a full block.
func NewMsgCmpctBlock ¶
func NewMsgCmpctBlock(blockHeader *BlockHeader) *MsgCmpctBlock
NewMsgCmpctBlock returns a new bitcoin cmpctblock message that conforms to the Message interface using the passed parameters and defaults for the remaining fields.
func NewMsgCmpctBlockFromBlock ¶
func NewMsgCmpctBlockFromBlock(block *MsgBlock, knownInventory map[chainhash.Hash]bool) (*MsgCmpctBlock, error)
NewMsgCmpctBlockFromBlock builds a cmpctblock message from a block using a known inventory map. If a given transaction is not in the known inventory map, we will append it as a PrefilledTx. Otherwise we'll add the short ID of the transaction.
func (*MsgCmpctBlock) BchDecode ¶
func (msg *MsgCmpctBlock) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgCmpctBlock) BchEncode ¶
func (msg *MsgCmpctBlock) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgCmpctBlock) BlockHash ¶
func (msg *MsgCmpctBlock) BlockHash() chainhash.Hash
BlockHash computes the block identifier hash for this block.
func (*MsgCmpctBlock) Command ¶
func (msg *MsgCmpctBlock) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgCmpctBlock) MaxPayloadLength ¶
func (msg *MsgCmpctBlock) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
func (*MsgCmpctBlock) TotalTransactions ¶
func (msg *MsgCmpctBlock) TotalTransactions() int
TotalTransactions returns the total number of transactions in the block.
type MsgFeeFilter ¶
type MsgFeeFilter struct {
MinFee int64
}
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.
func NewMsgFeeFilter ¶
func NewMsgFeeFilter(minfee int64) *MsgFeeFilter
NewMsgFeeFilter returns a new bitcoin feefilter message that conforms to the Message interface. See MsgFeeFilter for details.
func (*MsgFeeFilter) BchDecode ¶
func (msg *MsgFeeFilter) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgFeeFilter) BchEncode ¶
func (msg *MsgFeeFilter) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgFeeFilter) Command ¶
func (msg *MsgFeeFilter) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgFeeFilter) MaxPayloadLength ¶
func (msg *MsgFeeFilter) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgFilterAdd ¶
type MsgFilterAdd struct {
Data []byte
}
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.
func NewMsgFilterAdd ¶
func NewMsgFilterAdd(data []byte) *MsgFilterAdd
NewMsgFilterAdd returns a new bitcoin filteradd message that conforms to the Message interface. See MsgFilterAdd for details.
func (*MsgFilterAdd) BchDecode ¶
func (msg *MsgFilterAdd) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgFilterAdd) BchEncode ¶
func (msg *MsgFilterAdd) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgFilterAdd) Command ¶
func (msg *MsgFilterAdd) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgFilterAdd) MaxPayloadLength ¶
func (msg *MsgFilterAdd) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgFilterClear ¶
type MsgFilterClear struct{}
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.
func NewMsgFilterClear ¶
func NewMsgFilterClear() *MsgFilterClear
NewMsgFilterClear returns a new bitcoin filterclear message that conforms to the Message interface. See MsgFilterClear for details.
func (*MsgFilterClear) BchDecode ¶
func (msg *MsgFilterClear) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgFilterClear) BchEncode ¶
func (msg *MsgFilterClear) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgFilterClear) Command ¶
func (msg *MsgFilterClear) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgFilterClear) MaxPayloadLength ¶
func (msg *MsgFilterClear) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgFilterLoad ¶
type MsgFilterLoad struct { Filter []byte HashFuncs uint32 Tweak uint32 Flags BloomUpdateType }
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.
func NewMsgFilterLoad ¶
func NewMsgFilterLoad(filter []byte, hashFuncs uint32, tweak uint32, flags BloomUpdateType) *MsgFilterLoad
NewMsgFilterLoad returns a new bitcoin filterload message that conforms to the Message interface. See MsgFilterLoad for details.
func (*MsgFilterLoad) BchDecode ¶
func (msg *MsgFilterLoad) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgFilterLoad) BchEncode ¶
func (msg *MsgFilterLoad) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgFilterLoad) Command ¶
func (msg *MsgFilterLoad) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgFilterLoad) MaxPayloadLength ¶
func (msg *MsgFilterLoad) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgGetAddr ¶
type MsgGetAddr struct{}
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.
func NewMsgGetAddr ¶
func NewMsgGetAddr() *MsgGetAddr
NewMsgGetAddr returns a new bitcoin getaddr message that conforms to the Message interface. See MsgGetAddr for details.
func (*MsgGetAddr) BchDecode ¶
func (msg *MsgGetAddr) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgGetAddr) BchEncode ¶
func (msg *MsgGetAddr) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgGetAddr) Command ¶
func (msg *MsgGetAddr) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgGetAddr) MaxPayloadLength ¶
func (msg *MsgGetAddr) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgGetBlockTxns ¶
MsgGetBlockTxns implements the Message interface and represents a Bitcoin getblocktxn message. It is used to request missing transactions as part of the compact block protocol.
func NewMsgGetBlockTxns ¶
func NewMsgGetBlockTxns(blockHash chainhash.Hash, indexes []uint32) *MsgGetBlockTxns
NewMsgGetBlockTxns returns a new bitcoin getblocktxn message that conforms to the Message interface using the passed parameters and defaults for the remaining fields.
func NewMsgGetBlockTxnsFromBlock ¶
func NewMsgGetBlockTxnsFromBlock(block *MsgBlock) *MsgGetBlockTxns
NewMsgGetBlockTxnsFromBlock parses a block and for each nil transasction ads a index to the getblocktxn message that is returned.
func (*MsgGetBlockTxns) BchDecode ¶
func (msg *MsgGetBlockTxns) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgGetBlockTxns) BchEncode ¶
func (msg *MsgGetBlockTxns) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgGetBlockTxns) Command ¶
func (msg *MsgGetBlockTxns) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgGetBlockTxns) MaxPayloadLength ¶
func (msg *MsgGetBlockTxns) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
func (*MsgGetBlockTxns) RequestedTransactions ¶
func (msg *MsgGetBlockTxns) RequestedTransactions(block *MsgBlock) ([]*MsgTx, error)
RequestedTransactions extracts the transactions that were requested by this message from the given block and returns them.
type MsgGetBlocks ¶
type MsgGetBlocks struct { ProtocolVersion uint32 BlockLocatorHashes []*chainhash.Hash HashStop chainhash.Hash }
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.
func NewMsgGetBlocks ¶
func NewMsgGetBlocks(hashStop *chainhash.Hash) *MsgGetBlocks
NewMsgGetBlocks returns a new bitcoin getblocks message that conforms to the Message interface using the passed parameters and defaults for the remaining fields.
func (*MsgGetBlocks) AddBlockLocatorHash ¶
func (msg *MsgGetBlocks) AddBlockLocatorHash(hash *chainhash.Hash) error
AddBlockLocatorHash adds a new block locator hash to the message.
func (*MsgGetBlocks) BchDecode ¶
func (msg *MsgGetBlocks) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgGetBlocks) BchEncode ¶
func (msg *MsgGetBlocks) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgGetBlocks) Command ¶
func (msg *MsgGetBlocks) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgGetBlocks) MaxPayloadLength ¶
func (msg *MsgGetBlocks) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgGetCFCheckpt ¶
type MsgGetCFCheckpt struct { FilterType FilterType StopHash chainhash.Hash }
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.
func NewMsgGetCFCheckpt ¶
func NewMsgGetCFCheckpt(filterType FilterType, stopHash *chainhash.Hash) *MsgGetCFCheckpt
NewMsgGetCFCheckpt returns a new bitcoin getcfcheckpt message that conforms to the Message interface using the passed parameters and defaults for the remaining fields.
func (*MsgGetCFCheckpt) BchDecode ¶
func (msg *MsgGetCFCheckpt) BchDecode(r io.Reader, pver uint32, _ MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgGetCFCheckpt) BchEncode ¶
func (msg *MsgGetCFCheckpt) BchEncode(w io.Writer, pver uint32, _ MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgGetCFCheckpt) Command ¶
func (msg *MsgGetCFCheckpt) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgGetCFCheckpt) MaxPayloadLength ¶
func (msg *MsgGetCFCheckpt) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgGetCFHeaders ¶
type MsgGetCFHeaders struct { FilterType FilterType StartHeight uint32 StopHash chainhash.Hash }
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.
func NewMsgGetCFHeaders ¶
func NewMsgGetCFHeaders(filterType FilterType, startHeight uint32, stopHash *chainhash.Hash) *MsgGetCFHeaders
NewMsgGetCFHeaders returns a new bitcoin getcfheader message that conforms to the Message interface using the passed parameters and defaults for the remaining fields.
func (*MsgGetCFHeaders) BchDecode ¶
func (msg *MsgGetCFHeaders) BchDecode(r io.Reader, pver uint32, _ MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgGetCFHeaders) BchEncode ¶
func (msg *MsgGetCFHeaders) BchEncode(w io.Writer, pver uint32, _ MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgGetCFHeaders) Command ¶
func (msg *MsgGetCFHeaders) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgGetCFHeaders) MaxPayloadLength ¶
func (msg *MsgGetCFHeaders) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgGetCFMempool ¶
type MsgGetCFMempool struct {
FilterType FilterType
}
MsgGetCFMempool is a request for a filter of the remote peer's mempool.
func NewMsgGetCFMempool ¶
func NewMsgGetCFMempool(filterType FilterType) *MsgGetCFMempool
NewMsgGetCFMempool returns a new bitcoin getcfmempool message that conforms to the Message interface using the passed parameters.
func (*MsgGetCFMempool) BchDecode ¶
func (msg *MsgGetCFMempool) BchDecode(r io.Reader, pver uint32, _ MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgGetCFMempool) BchEncode ¶
func (msg *MsgGetCFMempool) BchEncode(w io.Writer, pver uint32, _ MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgGetCFMempool) Command ¶
func (msg *MsgGetCFMempool) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgGetCFMempool) MaxPayloadLength ¶
func (msg *MsgGetCFMempool) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgGetCFilters ¶
type MsgGetCFilters struct { FilterType FilterType StartHeight uint32 StopHash chainhash.Hash }
MsgGetCFilters implements the Message interface and represents a bitcoin getcfilters message. It is used to request committed filters for a range of blocks.
func NewMsgGetCFilters ¶
func NewMsgGetCFilters(filterType FilterType, startHeight uint32, stopHash *chainhash.Hash) *MsgGetCFilters
NewMsgGetCFilters returns a new bitcoin getcfilters message that conforms to the Message interface using the passed parameters and defaults for the remaining fields.
func (*MsgGetCFilters) BchDecode ¶
func (msg *MsgGetCFilters) BchDecode(r io.Reader, pver uint32, _ MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgGetCFilters) BchEncode ¶
func (msg *MsgGetCFilters) BchEncode(w io.Writer, pver uint32, _ MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgGetCFilters) Command ¶
func (msg *MsgGetCFilters) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgGetCFilters) MaxPayloadLength ¶
func (msg *MsgGetCFilters) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgGetData ¶
type MsgGetData struct {
InvList []*InvVect
}
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.
func NewMsgGetData ¶
func NewMsgGetData() *MsgGetData
NewMsgGetData returns a new bitcoin getdata message that conforms to the Message interface. See MsgGetData for details.
func NewMsgGetDataSizeHint ¶
func NewMsgGetDataSizeHint(sizeHint uint) *MsgGetData
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 (*MsgGetData) AddInvVect ¶
func (msg *MsgGetData) AddInvVect(iv *InvVect) error
AddInvVect adds an inventory vector to the message.
func (*MsgGetData) BchDecode ¶
func (msg *MsgGetData) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgGetData) BchEncode ¶
func (msg *MsgGetData) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgGetData) Command ¶
func (msg *MsgGetData) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgGetData) MaxPayloadLength ¶
func (msg *MsgGetData) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgGetHeaders ¶
type MsgGetHeaders struct { ProtocolVersion uint32 BlockLocatorHashes []*chainhash.Hash HashStop chainhash.Hash }
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.
func NewMsgGetHeaders ¶
func NewMsgGetHeaders() *MsgGetHeaders
NewMsgGetHeaders returns a new bitcoin getheaders message that conforms to the Message interface. See MsgGetHeaders for details.
func (*MsgGetHeaders) AddBlockLocatorHash ¶
func (msg *MsgGetHeaders) AddBlockLocatorHash(hash *chainhash.Hash) error
AddBlockLocatorHash adds a new block locator hash to the message.
func (*MsgGetHeaders) BchDecode ¶
func (msg *MsgGetHeaders) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgGetHeaders) BchEncode ¶
func (msg *MsgGetHeaders) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgGetHeaders) Command ¶
func (msg *MsgGetHeaders) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgGetHeaders) MaxPayloadLength ¶
func (msg *MsgGetHeaders) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgHeaders ¶
type MsgHeaders struct {
Headers []*BlockHeader
}
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.
func NewMsgHeaders ¶
func NewMsgHeaders() *MsgHeaders
NewMsgHeaders returns a new bitcoin headers message that conforms to the Message interface. See MsgHeaders for details.
func (*MsgHeaders) AddBlockHeader ¶
func (msg *MsgHeaders) AddBlockHeader(bh *BlockHeader) error
AddBlockHeader adds a new block header to the message.
func (*MsgHeaders) BchDecode ¶
func (msg *MsgHeaders) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgHeaders) BchEncode ¶
func (msg *MsgHeaders) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgHeaders) Command ¶
func (msg *MsgHeaders) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgHeaders) MaxPayloadLength ¶
func (msg *MsgHeaders) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgInv ¶
type MsgInv struct {
InvList []*InvVect
}
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.
func NewMsgInv ¶
func NewMsgInv() *MsgInv
NewMsgInv returns a new bitcoin inv message that conforms to the Message interface. See MsgInv for details.
func NewMsgInvSizeHint ¶
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 (*MsgInv) AddInvVect ¶
AddInvVect adds an inventory vector to the message.
func (*MsgInv) BchDecode ¶
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgInv) BchEncode ¶
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgInv) Command ¶
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgInv) MaxPayloadLength ¶
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgMemPool ¶
type MsgMemPool struct{}
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.
func NewMsgMemPool ¶
func NewMsgMemPool() *MsgMemPool
NewMsgMemPool returns a new bitcoin pong message that conforms to the Message interface. See MsgPong for details.
func (*MsgMemPool) BchDecode ¶
func (msg *MsgMemPool) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgMemPool) BchEncode ¶
func (msg *MsgMemPool) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgMemPool) Command ¶
func (msg *MsgMemPool) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgMemPool) MaxPayloadLength ¶
func (msg *MsgMemPool) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgMerkleBlock ¶
type MsgMerkleBlock struct { Header BlockHeader Transactions uint32 Hashes []*chainhash.Hash Flags []byte }
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.
func NewMsgMerkleBlock ¶
func NewMsgMerkleBlock(bh *BlockHeader) *MsgMerkleBlock
NewMsgMerkleBlock returns a new bitcoin merkleblock message that conforms to the Message interface. See MsgMerkleBlock for details.
func (*MsgMerkleBlock) AddTxHash ¶
func (msg *MsgMerkleBlock) AddTxHash(hash *chainhash.Hash) error
AddTxHash adds a new transaction hash to the message.
func (*MsgMerkleBlock) BchDecode ¶
func (msg *MsgMerkleBlock) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgMerkleBlock) BchEncode ¶
func (msg *MsgMerkleBlock) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgMerkleBlock) Command ¶
func (msg *MsgMerkleBlock) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgMerkleBlock) MaxPayloadLength ¶
func (msg *MsgMerkleBlock) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgNotFound ¶
type MsgNotFound struct {
InvList []*InvVect
}
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.
func NewMsgNotFound ¶
func NewMsgNotFound() *MsgNotFound
NewMsgNotFound returns a new bitcoin notfound message that conforms to the Message interface. See MsgNotFound for details.
func (*MsgNotFound) AddInvVect ¶
func (msg *MsgNotFound) AddInvVect(iv *InvVect) error
AddInvVect adds an inventory vector to the message.
func (*MsgNotFound) BchDecode ¶
func (msg *MsgNotFound) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgNotFound) BchEncode ¶
func (msg *MsgNotFound) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgNotFound) Command ¶
func (msg *MsgNotFound) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgNotFound) MaxPayloadLength ¶
func (msg *MsgNotFound) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgPing ¶
type MsgPing struct { // Unique value associated with message that is used to identify // specific ping message. Nonce uint64 }
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.
func NewMsgPing ¶
NewMsgPing returns a new bitcoin ping message that conforms to the Message interface. See MsgPing for details.
func (*MsgPing) BchDecode ¶
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgPing) BchEncode ¶
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgPing) Command ¶
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgPing) MaxPayloadLength ¶
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgPong ¶
type MsgPong struct { // Unique value associated with message that is used to identify // specific ping message. Nonce uint64 }
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.
func NewMsgPong ¶
NewMsgPong returns a new bitcoin pong message that conforms to the Message interface. See MsgPong for details.
func (*MsgPong) BchDecode ¶
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgPong) BchEncode ¶
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgPong) Command ¶
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgPong) MaxPayloadLength ¶
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgReject ¶
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 }
MsgReject implements the Message interface and represents a bitcoin reject message.
This message was not added until protocol version RejectVersion.
func NewMsgReject ¶
func NewMsgReject(command string, code RejectCode, reason string) *MsgReject
NewMsgReject returns a new bitcoin reject message that conforms to the Message interface. See MsgReject for details.
func (*MsgReject) BchDecode ¶
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgReject) BchEncode ¶
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgReject) Command ¶
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgReject) MaxPayloadLength ¶
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgSendCmpct ¶
type MsgSendCmpct struct { // If announce is set to false the receive node must announce new blocks // via the standard inv relay. If announce is true, a new Compact Block // can be pushed directly to the peer. Announce bool // The version of this protocol is currently 1. Version uint64 }
MsgSendCmpct implements the Message interface and represents a Bitcoin sendcmpct message. It is sent to the remove peer immediately after receiving a a version message to signal that they wish to receive compact blocks.
func NewMsgSendCmpct ¶
func NewMsgSendCmpct(announce bool, version uint64) *MsgSendCmpct
NewMsgSendCmpct returns a new bitcoin sendcmpct message that conforms to the Message interface using the passed parameters and defaults for the remaining fields.
func (*MsgSendCmpct) BchDecode ¶
func (msg *MsgSendCmpct) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgSendCmpct) BchEncode ¶
func (msg *MsgSendCmpct) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgSendCmpct) Command ¶
func (msg *MsgSendCmpct) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgSendCmpct) MaxPayloadLength ¶
func (msg *MsgSendCmpct) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgSendHeaders ¶
type MsgSendHeaders struct{}
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.
func NewMsgSendHeaders ¶
func NewMsgSendHeaders() *MsgSendHeaders
NewMsgSendHeaders returns a new bitcoin sendheaders message that conforms to the Message interface. See MsgSendHeaders for details.
func (*MsgSendHeaders) BchDecode ¶
func (msg *MsgSendHeaders) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgSendHeaders) BchEncode ¶
func (msg *MsgSendHeaders) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgSendHeaders) Command ¶
func (msg *MsgSendHeaders) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgSendHeaders) MaxPayloadLength ¶
func (msg *MsgSendHeaders) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgTx ¶
MsgTx implements the Message interface and represents a bitcoin tx message. It is used to deliver transaction information in response to a getdata message (MsgGetData) for a given transaction.
Use the AddTxIn and AddTxOut functions to build up the list of transaction inputs and outputs.
func NewMsgTx ¶
NewMsgTx returns a new bitcoin tx message that conforms to the Message interface. The return instance has a default version of TxVersion and there are no transaction inputs or outputs. Also, the lock time is set to zero to indicate the transaction is valid immediately as opposed to some time in future.
func (*MsgTx) BchDecode ¶
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation. See Deserialize for decoding transactions stored to disk, such as in a database, as opposed to decoding transactions from the wire.
func (*MsgTx) BchEncode ¶
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation. See Serialize for encoding transactions to be stored to disk, such as in a database, as opposed to encoding transactions for the wire.
func (*MsgTx) Command ¶
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgTx) Copy ¶
Copy creates a deep copy of a transaction so that the original does not get modified when the copy is manipulated.
func (*MsgTx) Deserialize ¶
Deserialize decodes a transaction 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 transaction. This function differs from BchDecode in that BchDecode 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 transaction at all. As of the time this comment was written, the encoded transaction 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 (*MsgTx) MaxPayloadLength ¶
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
func (*MsgTx) PkScriptLocs ¶
PkScriptLocs returns a slice containing the start of each public key script within the raw serialized transaction. The caller can easily obtain the length of each script by using len on the script available via the appropriate transaction output entry.
func (*MsgTx) Serialize ¶
Serialize encodes the transaction to w using a format that suitable for long-term storage such as a database while respecting the Version field in the transaction. This function differs from BchEncode in that BchEncode encodes the transaction 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 transaction at all. As of the time this comment was written, the encoded transaction 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 (*MsgTx) SerializeSize ¶
SerializeSize returns the number of bytes it would take to serialize the the transaction.
type MsgVerAck ¶
type MsgVerAck struct{}
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.
func NewMsgVerAck ¶
func NewMsgVerAck() *MsgVerAck
NewMsgVerAck returns a new bitcoin verack message that conforms to the Message interface.
func (*MsgVerAck) BchDecode ¶
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgVerAck) BchEncode ¶
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgVerAck) Command ¶
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgVerAck) MaxPayloadLength ¶
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgVersion ¶
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 }
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.
func NewMsgVersion ¶
func NewMsgVersion(me *NetAddress, you *NetAddress, nonce uint64, lastBlock int32) *MsgVersion
NewMsgVersion returns a new bitcoin version message that conforms to the Message interface using the passed parameters and defaults for the remaining fields.
func (*MsgVersion) AddService ¶
func (msg *MsgVersion) AddService(service ServiceFlag)
AddService adds service as a supported service by the peer generating the message.
func (*MsgVersion) AddUserAgent ¶
func (msg *MsgVersion) AddUserAgent(name string, version string, comments ...string) error
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 (*MsgVersion) BchDecode ¶
func (msg *MsgVersion) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode 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 (*MsgVersion) BchEncode ¶
func (msg *MsgVersion) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgVersion) Command ¶
func (msg *MsgVersion) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgVersion) HasService ¶
func (msg *MsgVersion) HasService(service ServiceFlag) bool
HasService returns whether the specified service is supported by the peer that generated the message.
func (*MsgVersion) MaxPayloadLength ¶
func (msg *MsgVersion) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgXVerAck ¶
type MsgXVerAck struct{}
MsgXVerAck defines a bitcoin xverack message which is used for a peer to acknowledge an xversion message (MsgXVersion). It implements the Message interface.
This message has no payload.
func NewMsgXVerAck ¶
func NewMsgXVerAck() *MsgXVerAck
NewMsgXVerAck returns a new bitcoin verack message that conforms to the Message interface.
func (*MsgXVerAck) BchDecode ¶
func (msg *MsgXVerAck) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.
func (*MsgXVerAck) BchEncode ¶
func (msg *MsgXVerAck) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgXVerAck) Command ¶
func (msg *MsgXVerAck) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgXVerAck) MaxPayloadLength ¶
func (msg *MsgXVerAck) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type MsgXVersion ¶
type MsgXVersion struct { }
MsgXVersion implements the Message interface and represents a bitcoin xversion message. This is a stub used to support BU clients.
func NewMsgXVersion ¶
func NewMsgXVersion() *MsgXVersion
NewMsgXVersion returns a new bitcoin xversion message that conforms to the Message interface using the passed parameters and defaults for the remaining fields.
func (*MsgXVersion) BchDecode ¶
func (msg *MsgXVersion) BchDecode(r io.Reader, pver uint32, enc MessageEncoding) error
BchDecode decodes r using the bitcoin protocol encoding into the receiver.
This is part of the Message interface implementation.
func (*MsgXVersion) BchEncode ¶
func (msg *MsgXVersion) BchEncode(w io.Writer, pver uint32, enc MessageEncoding) error
BchEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.
func (*MsgXVersion) Command ¶
func (msg *MsgXVersion) Command() string
Command returns the protocol command string for the message. This is part of the Message interface implementation.
func (*MsgXVersion) MaxPayloadLength ¶
func (msg *MsgXVersion) MaxPayloadLength(pver uint32) uint32
MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.
type NetAddress ¶
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 }
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.
func NewNetAddress ¶
func NewNetAddress(addr *net.TCPAddr, services ServiceFlag) *NetAddress
NewNetAddress returns a new NetAddress using the provided TCP address and supported services with defaults for the remaining fields.
func NewNetAddressIPPort ¶
func NewNetAddressIPPort(ip net.IP, port uint16, services ServiceFlag) *NetAddress
NewNetAddressIPPort returns a new NetAddress using the provided IP, port, and supported services with defaults for the remaining fields.
func NewNetAddressTimestamp ¶
func NewNetAddressTimestamp( timestamp time.Time, services ServiceFlag, ip net.IP, port uint16) *NetAddress
NewNetAddressTimestamp returns a new NetAddress using the provided timestamp, IP, port, and supported services. The timestamp is rounded to single second precision.
func (*NetAddress) AddService ¶
func (na *NetAddress) AddService(service ServiceFlag)
AddService adds service as a supported service by the peer generating the message.
func (*NetAddress) HasService ¶
func (na *NetAddress) HasService(service ServiceFlag) bool
HasService returns whether the specified service is supported by the address.
type OutPoint ¶
OutPoint defines a bitcoin data type that is used to track previous transaction outputs.
func NewOutPoint ¶
NewOutPoint returns a new bitcoin transaction outpoint point with the provided hash and index.
func (*OutPoint) Deserialize ¶
Deserialize will read bytes from a reader and deserialize them into the associated outpoint.
type PrefilledTx ¶
PrefilledTx is a transaction that is sent along with the compact block. The index is included so we know where it the block it belongs.
type RejectCode ¶
type RejectCode uint8
RejectCode represents a numeric value by which a remote peer indicates why a message was rejected.
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 )
These constants define the various supported reject codes.
func (RejectCode) String ¶
func (code RejectCode) String() string
String returns the RejectCode in human-readable form.
type ServiceFlag ¶
type ServiceFlag uint64
ServiceFlag identifies services supported by a bitcoin peer.
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 // SFNodeBitcoinCash indicates a node is running on the Bitcoin Cash // network. Bitcoin Core peers should disconnect upon seeing this service bit. // Technically this is no longer needed as Bitcoin Cash has a different // network magic than Bitcoin Core so connections should not be possible. SFNodeBitcoinCash // SFNodeGraphene is a flag used to indicate a peer supports graphene block relay. SFNodeGraphene // SFNodeWeakBlocks is a flag used to indicate a peer supports the weak block protocol. SFNodeWeakBlocks // SFNodeCF is a flag used to indicate a peer supports committed // filters (CFs). SFNodeCF // SFNodeXThinner is a placeholder for the xthinner block compression protocol being // developed by Johnathan Toomim. SFNodeXThinner // SFNodeNetworkLimited is used to indicate the node is a pruned node and may only // be capable of limited services. In particular it is only guaranteed to be able // to serve the last 288 blocks though it will respond to requests for earlier blocks // if it has them. SFNodeNetworkLimited )
func (ServiceFlag) String ¶
func (f ServiceFlag) String() string
String returns the ServiceFlag in human-readable form.
type TxIn ¶
TxIn defines a bitcoin transaction input.
func NewTxIn ¶
NewTxIn returns a new bitcoin transaction input with the provided previous outpoint point and signature script with a default sequence of MaxTxInSequenceNum.
func (*TxIn) SerializeSize ¶
SerializeSize returns the number of bytes it would take to serialize the the transaction input.
type TxLoc ¶
TxLoc holds locator data for the offset and length of where a transaction is located within a MsgBlock data buffer.
type TxOut ¶
TxOut defines a bitcoin transaction output.
func NewTxOut ¶
NewTxOut returns a new bitcoin transaction output with the provided transaction value and public key script.
func (*TxOut) SerializeSize ¶
SerializeSize returns the number of bytes it would take to serialize the the transaction output.
Source Files ¶
- blockheader.go
- common.go
- doc.go
- error.go
- invvect.go
- message.go
- msgaddr.go
- msgblock.go
- msgblocktxns.go
- msgcfcheckpt.go
- msgcfheaders.go
- msgcfilter.go
- msgcmpctblock.go
- msgfeefilter.go
- msgfilteradd.go
- msgfilterclear.go
- msgfilterload.go
- msggetaddr.go
- msggetblocks.go
- msggetblocktxns.go
- msggetcfcheckpt.go
- msggetcfheaders.go
- msggetcfilters.go
- msggetcfmempool.go
- msggetdata.go
- msggetheaders.go
- msgheaders.go
- msginv.go
- msgmempool.go
- msgmerkleblock.go
- msgnotfound.go
- msgping.go
- msgpong.go
- msgreject.go
- msgsendcmpct.go
- msgsendheaders.go
- msgtx.go
- msgverack.go
- msgversion.go
- msgxverack.go
- msgxversion.go
- netaddress.go
- protocol.go