BitWasp\Bitcoin\Script\Interpreter\Number

Complexity

Total Complexity

24

Size/Duplication

Total Lines	144
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

80.65%

Importance

Changes	1
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	int()	0	7	2
B	buffer()	0	21	8
B	parseBuffer()	0	26	4
C	serialize()	0	26	7
A	getBuffer()	0	4	1
A	getInt()	0	4	1

<?php

namespace BitWasp\Bitcoin\Script\Interpreter;

use BitWasp\Bitcoin\Bitcoin;
use BitWasp\Bitcoin\Flags;
use BitWasp\Bitcoin\Math\Math;
use BitWasp\Bitcoin\Serializable;
use BitWasp\Buffertools\Buffer;

class Number extends Serializable
{
    const MAX_NUM_SIZE = 4;

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

    /**
     * @var Flags
     */
    protected $flags;

    /**
     * Number constructor.
     * @param int $number
     * @param Math $math
     */
    public function __construct($number, Math $math)
    {
        $this->number = $number;
        $this->math = $math;

The property math does not exist. Did you maybe forget to declare it?

    }

    /**
     * @param int $number
     * @param Math|null $math
     * @return self
     */
    public static function int($number, Math $math = null)
    {
        return new self(
            $number,
            $math ?: Bitcoin::getMath()
        );
    }

    /**
     * @param Buffer $vch
     * @param bool $fRequireMinimal
     * @param int $maxNumSize
     * @param Math|null $math
     * @return self
     */
    public static function buffer(Buffer $vch, $fRequireMinimal, $maxNumSize = self::MAX_NUM_SIZE, Math $math = null)
    {
        $size = $vch->getSize();
        if ($size > $maxNumSize) {
            throw new \RuntimeException('Script number overflow');
        }

        if ($fRequireMinimal && $size > 0) {
            $binary = $vch->getBinary();
            if (ord($binary[$size - 1]) & 0x7f === 0) {
                if ($size <= 1 || ord($binary[$size - 2]) & 0x80 === 0) {
                    throw new \RuntimeException('Non-minimally encoded script number');
                }
            }
        }

        $math = $math ?: Bitcoin::getMath();
        $number = new self(0, $math);
        $number->number = $number->parseBuffer($vch);

It seems like $number->parseBuffer($vch) can also be of type string. However, the property $number is declared as type integer. Maybe add an additional type check?

        return $number;
    }

    /**
     * @param Buffer $buffer
     * @return int|string
     */
    private function parseBuffer(Buffer $buffer)
    {
        $size = $buffer->getSize();
        if ($size === 0) {
            return '0';
        }

        $chars = array_map(function ($binary) {
            return ord($binary);

        }, str_split($buffer->flip()->getBinary(), 1));

        $result = 0;
        for ($i = 0; $i < $size; $i++) {
            $mul = $this->math->mul($i, 8);
            $byte = $this->math->leftShift($chars[$i], $mul);
            $result = $this->math->bitwiseOr($result, $byte);
        }

        if ($chars[0] & 0x80) {
            $mask = gmp_strval(gmp_com($this->math->leftShift(0x80, (8 * ($size - 1)))), 10);
            return $this->math->sub(0, $this->math->bitwiseAnd($result, $mask));
        }

        return $result;
    }

    /**
     * @return Buffer
     */
    private function serialize()
    {
        if ($this->math->cmp($this->number, '0') === 0) {
            return new Buffer('', 4);
        }

        // Using array of integers instead of bytes
        $result = [];
        $negative = $this->math->cmp($this->number, 0) < 0;
        $abs = $negative ? $this->math->sub(0, $this->number) : $this->number;
        while ($this->math->cmp($abs, 0) > 0) {
            array_unshift($result, (int)$this->math->bitwiseAnd($abs, 0xff));
            $abs = $this->math->rightShift($abs, 8);
        }

        if ($result[0] & 0x80) {
            array_unshift($result, $negative ? 0x80 : 0x00);
        } else if ($negative) {
            array_unshift($result, 0x80);
        }

        return new Buffer(array_reduce($result, function ($agg, $current) {
            return $agg . chr($current);
        }), 4, $this->math);

    }

    /**
     * @return Buffer
     */
    public function getBuffer()
    {
        return $this->serialize();
    }

    /**
     * @return int
     */
    public function getInt()
    {
        return $this->number;
    }
}