block.go

// Package bc is a bitcoin blockchain library bc = block chain.
package bc

import (
	"encoding/hex"

	"github.com/bsv-blockchain/go-bt/v2"
)

/*
| Field        | Purpose                                                    | Size (Bytes) |
|--------------|------------------------------------------------------------|--------------|
| block_header | Block Header                                               | 80           |
| txn_count    | Total number of txs in this block, including coinbase tx   | VarInt       |
| txs          | Every tx in this block, one after another, in raw tx format| -            |
*/

// A Block in the Bitcoin blockchain.
type Block struct {
	BlockHeader *BlockHeader
	Txs         []*bt.Tx
}

// String returns the Block Header encoded as hex string.
func (b *Block) String() string {
	return hex.EncodeToString(b.Bytes())
}

// Bytes will decode a bitcoin block struct into a byte slice.
//
// See https://btcinformation.org/en/developer-reference#serialized-blocks
func (b *Block) Bytes() []byte {
	// Preallocate: 80 (header) + 9 (max varint) + estimated tx bytes
	bytes := make([]byte, 0, 80+9+len(b.Txs)*250)

	bytes = append(bytes, b.BlockHeader.Bytes()...)

	txCount := uint64(len(b.Txs))
	bytes = append(bytes, bt.VarInt(txCount).Bytes()...)

	for _, tx := range b.Txs {
		bytes = append(bytes, tx.Bytes()...)
	}

	return bytes
}

// NewBlockFromStr will encode a block header hash
// into the bitcoin block header structure.
//
// See https://btcinformation.org/en/developer-reference#serialized-blocks
func NewBlockFromStr(blockStr string) (*Block, error) {
	blockBytes, err := hex.DecodeString(blockStr)
	if err != nil {
		return nil, err
	}

	return NewBlockFromBytes(blockBytes)
}

// NewBlockFromBytes will encode a block header byte slice
// into the bitcoin block header structure.
//
// See https://btcinformation.org/en/developer-reference#serialized-blocks
func NewBlockFromBytes(b []byte) (*Block, error) {
	if len(b) == 0 {
		return nil, ErrBlockEmpty
	}

	var offset int
	bh, err := NewBlockHeaderFromBytes(b[:80])
	if err != nil {
		return nil, err
	}
	offset += 80

	txCount, size := bt.NewVarIntFromBytes(b[offset:])
	offset += size

	var txs []*bt.Tx
	// Safe conversion: txCount should never exceed reasonable transaction count
	txCountInt := int(txCount) //nolint:gosec // G115: Safe conversion - txCount is bounded by block size limits
	for i := 0; i < txCountInt; i++ {
		tx, size, err := bt.NewTxFromStream(b[offset:])
		if err != nil {
			return nil, err
		}
		txs = append(txs, tx)
		offset += size
	}

	return &Block{
		BlockHeader: bh,
		Txs:         txs,
	}, nil
}