BitWasp\Bitcoin\Key\Deterministic\HierarchicalKeySequence

Complexity

Total Complexity

21

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

98%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	binaryMath()	0	4	1
A	isHardened()	0	4	1
A	fromNode()	0	15	3
A	getHardened()	0	9	2
A	getNode()	0	9	2
B	decodePath()	0	15	5
A	encodePath()	0	11	2
A	validateListType()	0	7	4

<?php

namespace BitWasp\Bitcoin\Key\Deterministic;

use BitWasp\Bitcoin\Math\Math;

/**
 * NB: Paths returned by this library omit m/M. This is because
 * some knowledge is lost during derivations, so the full path
 * is already considered 'meta-data'. It also allows the library
 * to assume derivations are relative to the current instance.
 */
class HierarchicalKeySequence
{
    /**
     * @var Math
     */
    private $math;

    const START_HARDENED = 2147483648; // 2^31

    /**
     * @param Math $math
     */
    public function __construct(Math $math)
    {
        $this->math = $math;
    }

    /**
     * @return \BitWasp\Bitcoin\Math\BinaryMath
     */
    private function binaryMath()
    {
        return $this->math->getBinaryMath();
    }

    /**
     * @param $sequence
     * @return bool
     */
    public function isHardened($sequence)
    {
        return $this->binaryMath()->isNegative(gmp_init($sequence, 10), 32);
    }

    /**
     * @param $sequence
     * @return int|string
     */
    public function getHardened($sequence)
    {
        if ($this->isHardened($sequence)) {
            throw new \LogicException('Sequence is already for a hardened key');
        }

        $prime = $this->binaryMath()->makeNegative(gmp_init($sequence, 10), 32);
        return gmp_strval($prime, 10);
    }

    /**
     * Convert a human readable path node (eg, "0", "0'", or "0h") into the correct sequence (0, 0x80000000, 0x80000000)
     *
     * @param $node
     * @return int|string
     */
    public function fromNode($node)
    {
        $hardened = false;
        if (in_array(substr(strtolower($node), -1), array('h', "'"), true) === true) {
            $intEnd = strlen($node) - 1;
            $node = substr($node, 0, $intEnd);
            $hardened = true;
        }

        if ($hardened) {
            $node = $this->getHardened($node);
        }

        return $node;
    }

    /**
     * Given a sequence, get the human readable node. Ie, 0 -> 0, 0x80000000 -> 0h
     *
     * @param $sequence
     * @return string
     */
    public function getNode($sequence)
    {
        if ($this->isHardened($sequence)) {
            $sequence = $this->math->sub(gmp_init($sequence), gmp_init(self::START_HARDENED));
            $sequence = gmp_strval($sequence, 10) . 'h';
        }

        return $sequence;
    }

    /**
     * Decodes a human-readable path, into an array of integers (sequences)
     *
     * @param string $path
     * @return array
     */
    public function decodePath($path)
    {
        if ($path === '') {
            throw new \InvalidArgumentException('Invalid path passed to decodePath()');
        }

        $list = [];
        foreach (explode('/', $path) as $segment) {
            if ($segment !== 'm' && $segment !== 'M') {
                $list[] = $this->fromNode($segment);
            }
        }

        return $list;
    }

    /**
     * Encodes a list of sequences to the human-readable path.
     *
     * @param array|\stdClass|\Traversable $list
     * @return string
     */
    public function encodePath($list)
    {
        self::validateListType($list);

        $path = [];
        foreach ($list as $sequence) {

The expression $list of type array|object<stdClass>|object<Traversable> is not guaranteed to be traversable. How about adding an additional type check?

            $path[] = $this->getNode($sequence);
        }

        return implode('/', $path);
    }

    /**
     * Check the list, mainly that it works for foreach()
     *
     * @param \stdClass|array|\Traversable $list
     */
    public static function validateListType($list)
    {
        if (!is_array($list) && !$list instanceof \Traversable && !$list instanceof \stdClass) {
            throw new \InvalidArgumentException('Sequence list must be an array or \Traversable');
        }

    }
}