BitWasp\Bitcoin\Block\BlockHeader

Complexity

Total Complexity

19

Size/Duplication

Total Lines	167
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	getHash()	0	4	1
A	getVersion()	0	4	1
A	hasBip9Prefix()	0	4	1
A	getPrevBlock()	0	4	1
A	getMerkleRoot()	0	4	1
A	getBits()	0	4	1
A	getNonce()	0	4	1
A	getTimestamp()	0	4	1
B	equals()	0	9	6
A	getBuffer()	0	4	1
A	validate()	0	10	3

<?php

declare(strict_types=1);

namespace BitWasp\Bitcoin\Block;

use BitWasp\Bitcoin\Crypto\Hash;
use BitWasp\Bitcoin\Exceptions\InvalidHashLengthException;
use BitWasp\Bitcoin\Serializable;
use BitWasp\Bitcoin\Serializer\Block\BlockHeaderSerializer;
use BitWasp\Buffertools\BufferInterface;

class BlockHeader extends Serializable implements BlockHeaderInterface
{

    /**
     * @var int
     */
    protected $version;

    /**
     * @var BufferInterface
     */
    protected $prevBlock;

    /**
     * @var BufferInterface
     */
    protected $merkleRoot;

    /**
     * @var int
     */
    protected $timestamp;

    /**
     * @var int
     */
    protected $bits;

    /**
     * @var int
     */
    protected $nonce;

    const BIP9_PREFIX = 1 << 29;

    /**
     * @param int $version
     * @param BufferInterface $prevBlock
     * @param BufferInterface $merkleRoot
     * @param int $timestamp
     * @param int $bits
     * @param int $nonce
     * @throws InvalidHashLengthException
     */
    public function __construct(int $version, BufferInterface $prevBlock, BufferInterface $merkleRoot, int $timestamp, int $bits, int $nonce)
    {
        $this->version = $version;
        $this->prevBlock = $prevBlock;
        $this->merkleRoot = $merkleRoot;
        $this->timestamp = $timestamp;
        $this->bits = $bits;
        $this->nonce = $nonce;

        $this->validate();
    }

    /**
     * @return BufferInterface
     */
    public function getHash(): BufferInterface
    {
        return Hash::sha256d($this->getBuffer())->flip();
    }

    /**
     * Get the version for this block
     *
     * {@inheritdoc}
     * @see \BitWasp\Bitcoin\Block\BlockHeaderInterface::getVersion()
     */
    public function getVersion(): int
    {
        return $this->version;
    }

    /**
     * @return bool
     */
    public function hasBip9Prefix(): bool
    {
        return ($this->version & self::BIP9_PREFIX) != 0;
    }

    /**
     * {@inheritdoc}
     * @see \BitWasp\Bitcoin\Block\BlockHeaderInterface::getPrevBlock()
     */
    public function getPrevBlock(): BufferInterface
    {
        return $this->prevBlock;
    }

    /**
     * {@inheritdoc}
     * @see \BitWasp\Bitcoin\Block\BlockHeaderInterface::getMerkleRoot()
     */
    public function getMerkleRoot(): BufferInterface
    {
        return $this->merkleRoot;
    }

    /**
     * {@inheritdoc}
     * @see \BitWasp\Bitcoin\Block\BlockHeaderInterface::getBits()
     */
    public function getBits(): int
    {
        return $this->bits;
    }

    /**
     * {@inheritdoc}
     * @see \BitWasp\Bitcoin\Block\BlockHeaderInterface::getNonce()
     */
    public function getNonce(): int
    {
        return $this->nonce;
    }

    /**
     * Get the timestamp for this block
     *
     * {@inheritdoc}
     * @see \BitWasp\Bitcoin\Block\BlockHeaderInterface::getTimestamp()
     */
    public function getTimestamp(): int
    {
        return $this->timestamp;
    }

    /**
     * @param BlockHeaderInterface $other
     * @return bool
     */
    public function equals(BlockHeaderInterface $other): bool
    {
        return $this->version === $other->getVersion()
               && $this->prevBlock->equals($other->getPrevBlock())
               && $this->merkleRoot->equals($other->getMerkleRoot())
               && $this->timestamp === $other->getTimestamp()
               && $this->bits === $other->getBits()
               && $this->nonce === $other->getNonce();
    }

    /**
     * {@inheritdoc}
     * @see \BitWasp\Buffertools\SerializableInterface::getBuffer()
     */
    public function getBuffer(): BufferInterface
    {
        return (new BlockHeaderSerializer())->serialize($this);
    }

    /**
     * @throws InvalidHashLengthException
     */
    protected function validate()
    {
        if ($this->prevBlock->getSize() !== 32) {
            throw new InvalidHashLengthException('BlockHeader prevBlock must be a 32-byte Buffer');
        }

        if ($this->merkleRoot->getSize() !== 32) {
            throw new InvalidHashLengthException('BlockHeader merkleRoot must be a 32-byte Buffer');
        }
    }
}