blockrecord

Documentation

Overview

the structure of the block header

includes functions to pack/unpack []byte form

Index

• Constants
• type Header
  • func New() *Header
  • func (header *Header) Pack() PackedHeader
• type NonceType
  • func (nonce NonceType) MarshalText() ([]byte, error)
  • func (nonce *NonceType) UnmarshalText(b []byte) error
• type PackedBlock
• type PackedHeader
  • func (record PackedHeader) Digest() blockdigest.Digest
  • func (record PackedHeader) Unpack() (*Header, error)

Constants

const (
	VersionSize          = 2                   // Block version number
	TransactionCountSize = 2                   // Count of transactions
	NumberSize           = 8                   // This block's number
	PreviousBlockSize    = blockdigest.Length  // 256-bit Argon2d hash of the previous block header
	MerkleRootSize       = merkle.DigestLength // 256-bit SHA3 hash based on all of the transactions in the block
	TimestampSize        = 8                   // Current timestamp as seconds since 1970-01-01T00:00 UTC
	DifficultySize       = 8                   // Current target difficulty in compact format
	NonceSize            = 8                   // 64-bit number (starts at 0)
)

byte sizes for various fields

const (
	MaximumTransactions = 10000
)

maximum transactions in a block limited by uint16 field

const (

	// the total size is exported
	TotalBlockSize = nonceOffset + NonceSize // total bytes in the header
)

offsets of the fields

const (
	Version = 1
)

block version

Types

type Header

type Header struct {
	Version          uint16                 `json:"version"`
	TransactionCount uint16                 `json:"transactionCount"`
	Number           uint64                 `json:"number,string"`
	PreviousBlock    blockdigest.Digest     `json:"previousBlock"`
	MerkleRoot       merkle.Digest          `json:"merkleRoot"`
	Timestamp        uint64                 `json:"timestamp,string"`
	Difficulty       *difficulty.Difficulty `json:"difficulty"`
	Nonce            NonceType              `json:"nonce"`
}

the unpacked header structure the types here must match Bitcoin header types

func New

func New() *Header

create a new header with attached difficulty item

func (*Header) Pack

func (header *Header) Pack() PackedHeader

turn a record into an array of bytes

type NonceType

type NonceType uint64

type for nonce

func (NonceType) MarshalText

func (nonce NonceType) MarshalText() ([]byte, error)

convert a nonce to little endian hex for JSON

func (*NonceType) UnmarshalText

func (nonce *NonceType) UnmarshalText(b []byte) error

convert a nonce little endian hex string to nonce value

type PackedBlock

type PackedBlock []byte

type PackedHeader

type PackedHeader []byte

packed records are just a byte slice

func (PackedHeader) Digest

func (record PackedHeader) Digest() blockdigest.Digest

digest for a packed header make sure to truncate bytes to correct length

func (PackedHeader) Unpack

func (record PackedHeader) Unpack() (*Header, error)

turn a byte slice into a record