BIP32Key::bip32Path() - Code Metrics - Inspection of "WIP" - blocktrail/blocktrail-sdk-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#118)

by Ruben de

created 2018-04-19 10:36 UTC

BIP32Key::bip32Path() A

↳ Parent: BIP32Key

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	3
ccs	0
cts	2
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php

namespace Blocktrail\SDK\Bitcoin;

use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\PhpEcc\Key\PublicKey;
use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PublicKeyInterface;
use BitWasp\Bitcoin\Key\Deterministic\HierarchicalKey;

/**
 * Class BIP32Key
 *
 * Container for a BIP32 key and path
 */
class BIP32Key {
    /**
     * @var HierarchicalKey
     */
    private $key;

    /**
     * @var BIP32Path
     */
    private $path;

    /**
     * @var string|null
     */
    private $publicKeyHex = null;

    /**
     * @var BIP32Key[]
     */
    private $derivations = [];

    /**
     * @param HierarchicalKey $key
     * @param string|null     $path
     * @throws \Exception
     */
    public function __construct(HierarchicalKey $key, $path = null) {
        $this->key = $key;
        $this->path = BIP32Path::path($path);

        return;

        if (is_array($key) && count($key) == 2) {
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
            $this->key = $key[0];
            $this->path = BIP32Path::path($key[1]);
        } elseif (is_string($key) && is_string($path) && strlen($key) && strlen($path)) {
            $this->key = $key;

            $this->path = BIP32Path::path($path);
        } else {
            throw new \Exception("Bad input");
        }
    }

    /**
     * static method to initialize class
     *
     * @param HierarchicalKey $key
     * @param string|null     $path
     * @return BIP32Key
     */
    public static function create(HierarchicalKey $key, $path = null) {
        return new BIP32Key($key, $path);
    }

    /**
     * @return HierarchicalKey
     */
    public function key() {
        return $this->key;
    }

    /**
     * @return PublicKeyInterface
     */
    public function publicKey() {
        return $this->key->getPublicKey();
    }

    /**
     * get the HEX of the plain public key for the current BIP32 key
     *
     * @return string
     */
    public function publicKeyHex() {
        // if this is a BIP32 Private key then we first build the public key
        //  that way it will be cached nicely
        if (!$this->path->isPublicPath()) {
            return $this->buildKey($this->path->publicPath())->publicKey()->getHex();
        } else {
            if (is_null($this->publicKeyHex)) {
                $this->publicKeyHex = $this->key->getPublicKey()->getHex();
            }

            return $this->publicKeyHex;
        }
    }

    /**
     * @return BIP32Path
     */
    public function path() {
        return $this->path;
    }

    /**
     * @return BIP32Path
     */
    public function bip32Path() {
        return BIP32Path::path($this->path);
    }

    public function tuple() {
        return [$this->key->toExtendedKey(), (string)$this->path];
    }

    /**
     * build child key
     *
     * @param string|BIP32Path  $path
     * @return BIP32Key
     * @throws \Exception
     */
    public function buildKey($path) {
        $path = BIP32Path::path($path);
        $originalPath = (string)$path;

        if (!isset($this->derivations[$originalPath])) {
            $key = $this->key;

            $toPublic = $path[0] === "M" && $this->path[0] === "m";
            if ($toPublic) {
                $path = $path->privatePath();
            }

            assert(strpos(strtolower((string)$path), strtolower((string)$this->path)) === 0);

            $path = substr((string)$path, strlen((string)$this->path));

            if (substr($path, 0, 1) == "/") {
                $path = substr($path, 1);
            }

            if (strlen($path)) {
                $key = $key->derivePath($path);
            }

            if ($toPublic) {
                $key = $key->toPublic();
            }

            $this->derivations[$originalPath] = BIP32Key::create($key, $originalPath);
        }

        return $this->derivations[$originalPath];
    }
}


1		<?php
2
3		namespace Blocktrail\SDK\Bitcoin;
4
5		use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\PhpEcc\Key\PublicKey;
6		use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PublicKeyInterface;
7		use BitWasp\Bitcoin\Key\Deterministic\HierarchicalKey;
8
9		/**
10		* Class BIP32Key
11		*
12		* Container for a BIP32 key and path
13		*/
14		class BIP32Key {
15		/**
16		* @var HierarchicalKey
17		*/
18		private $key;
19
20		/**
21		* @var BIP32Path
22		*/
23		private $path;
24
25		/**
26		* @var string\|null
27		*/
28		private $publicKeyHex = null;
29
30		/**
31		* @var BIP32Key[]
32		*/
33		private $derivations = [];
34
35		/**
36		* @param HierarchicalKey $key
37		* @param string\|null $path
38		* @throws \Exception
39		*/
40	3	public function __construct(HierarchicalKey $key, $path = null) {
41	3	$this->key = $key;
42	3	$this->path = BIP32Path::path($path);
43
44	3	return;
45
46		if (is_array($key) && count($key) == 2) {
		0 ignored issues – show Unused Code introduced 2016-11-12 10:28 UTC by Report Bug Copy Issue Report `if (is_array($key) && co...ception('Bad input'); }` does not seem to be reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
47		$this->key = $key[0];
48		$this->path = BIP32Path::path($key[1]);
49		} elseif (is_string($key) && is_string($path) && strlen($key) && strlen($path)) {
50		$this->key = $key;
		0 ignored issues – show Documentation Bug introduced 2016-11-10 10:29 UTC by Report Bug Copy Issue Report It seems like `$key` of type `string` is incompatible with the declared type `object<BitWasp\Bitcoin\K...nistic\HierarchicalKey>` of property `$key`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
51		$this->path = BIP32Path::path($path);
52		} else {
53		throw new \Exception("Bad input");
54		}
55		}
56
57		/**
58		* static method to initialize class
59		*
60		* @param HierarchicalKey $key
61		* @param string\|null $path
62		* @return BIP32Key
63		*/
64	3	public static function create(HierarchicalKey $key, $path = null) {
65	3	return new BIP32Key($key, $path);
66		}
67
68		/**
69		* @return HierarchicalKey
70		*/
71	2	public function key() {
72	2	return $this->key;
73		}
74
75		/**
76		* @return PublicKeyInterface
77		*/
78	3	public function publicKey() {
79	3	return $this->key->getPublicKey();
80		}
81
82		/**
83		* get the HEX of the plain public key for the current BIP32 key
84		*
85		* @return string
86		*/
87		public function publicKeyHex() {
88		// if this is a BIP32 Private key then we first build the public key
89		// that way it will be cached nicely
90		if (!$this->path->isPublicPath()) {
91		return $this->buildKey($this->path->publicPath())->publicKey()->getHex();
92		} else {
93		if (is_null($this->publicKeyHex)) {
94		$this->publicKeyHex = $this->key->getPublicKey()->getHex();
95		}
96
97		return $this->publicKeyHex;
98		}
99		}
100
101		/**
102		* @return BIP32Path
103		*/
104	3	public function path() {
105	3	return $this->path;
106		}
107
108		/**
109		* @return BIP32Path
110		*/
111		public function bip32Path() {
112		return BIP32Path::path($this->path);
113		}
114
115	2	public function tuple() {
116	2	return [$this->key->toExtendedKey(), (string)$this->path];
117		}
118
119		/**
120		* build child key
121		*
122		* @param string\|BIP32Path $path
123		* @return BIP32Key
124		* @throws \Exception
125		*/
126	3	public function buildKey($path) {
127	3	$path = BIP32Path::path($path);
128	3	$originalPath = (string)$path;
129
130	3	if (!isset($this->derivations[$originalPath])) {
131	3	$key = $this->key;
132
133	3	$toPublic = $path[0] === "M" && $this->path[0] === "m";
134	3	if ($toPublic) {
135	1	$path = $path->privatePath();
136		}
137
138	3	assert(strpos(strtolower((string)$path), strtolower((string)$this->path)) === 0);
139
140	3	$path = substr((string)$path, strlen((string)$this->path));
141
142	3	if (substr($path, 0, 1) == "/") {
143	3	$path = substr($path, 1);
144		}
145
146	3	if (strlen($path)) {
147	3	$key = $key->derivePath($path);
148		}
149
150	3	if ($toPublic) {
151	1	$key = $key->toPublic();
152		}
153
154	3	$this->derivations[$originalPath] = BIP32Key::create($key, $originalPath);
155		}
156
157	3	return $this->derivations[$originalPath];
158		}
159		}
160

blocktrail / blocktrail-sdk-php

Pull Request — master (#118)

BIP32Key::bip32Path() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like