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