HierarchicalKey::deriveChild() - Code Metrics - Inspection of "remove HierarchicalKey::withScriptDataFactory" - Bit-Wasp/bitcoin-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( abcf31...a8a46d )

by thomas

created 2018-03-12 20:37 UTC

HierarchicalKey::deriveChild() B

↳ Parent: HierarchicalKey

Complexity

Conditions	4
Paths	4

Size

Total Lines	28
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	18
CRAP Score	4.0023

Importance

Changes

Metric	Value
cc	4
eloc	19
nc	4
nop	1
dl	0
loc	28
ccs	18
cts	19
cp	0.9474
crap	4.0023
rs	8.5806
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace BitWasp\Bitcoin\Key\Deterministic;

use BitWasp\Bitcoin\Address\BaseAddressCreator;
use BitWasp\Bitcoin\Bitcoin;
use BitWasp\Bitcoin\Crypto\EcAdapter\Adapter\EcAdapterInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Key\KeyInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PrivateKeyInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PublicKeyInterface;
use BitWasp\Bitcoin\Crypto\Hash;
use BitWasp\Bitcoin\Key\KeyToScript\ScriptAndSignData;
use BitWasp\Bitcoin\Key\KeyToScript\ScriptDataFactory;
use BitWasp\Bitcoin\Network\NetworkInterface;
use BitWasp\Bitcoin\Serializer\Key\HierarchicalKey\Base58ExtendedKeySerializer;
use BitWasp\Bitcoin\Serializer\Key\HierarchicalKey\ExtendedKeySerializer;
use BitWasp\Bitcoin\Util\IntRange;
use BitWasp\Buffertools\Buffer;
use BitWasp\Buffertools\BufferInterface;

class HierarchicalKey
{
    /**
     * @var EcAdapterInterface
     */
    protected $ecAdapter;

    /**
     * @var int
     */
    private $depth;

    /**
     * @var int
     */
    private $parentFingerprint;

    /**
     * @var int
     */
    private $sequence;

    /**
     * @var BufferInterface
     */
    private $chainCode;

    /**
     * @var KeyInterface
     */
    private $key;

    /**
     * @var ScriptDataFactory
     */
    private $scriptDataFactory;

    /**
     * @var ScriptAndSignData|null
     */
    private $scriptAndSignData;

    /**
     * @param EcAdapterInterface $ecAdapter
     * @param ScriptDataFactory $scriptDataFactory
     * @param int $depth
     * @param int $parentFingerprint
     * @param int $sequence
     * @param BufferInterface $chainCode
     * @param KeyInterface $key
     */
    public function __construct(EcAdapterInterface $ecAdapter, ScriptDataFactory $scriptDataFactory, int $depth, int $parentFingerprint, int $sequence, BufferInterface $chainCode, KeyInterface $key)
    {
        if ($depth < 0 || $depth > IntRange::U8_MAX) {
            throw new \InvalidArgumentException('Invalid depth for BIP32 key, must be in range [0 - 255] inclusive');
        }

        if ($parentFingerprint < 0 || $parentFingerprint > IntRange::U32_MAX) {
            throw new \InvalidArgumentException('Invalid fingerprint for BIP32 key, must be in range [0 - (2^31)-1] inclusive');
        }

        if ($sequence < 0 || $sequence > IntRange::U32_MAX) {
            throw new \InvalidArgumentException('Invalid sequence for BIP32 key, must be in range [0 - (2^31)-1] inclusive');
        }

        if ($chainCode->getSize() !== 32) {
            throw new \RuntimeException('Chaincode should be 32 bytes');
        }

        if (!$key->isCompressed()) {
            throw new \InvalidArgumentException('A HierarchicalKey must always be compressed');
        }

        $this->ecAdapter = $ecAdapter;
        $this->depth = $depth;
        $this->sequence = $sequence;
        $this->parentFingerprint = $parentFingerprint;
        $this->chainCode = $chainCode;
        $this->key = $key;
        $this->scriptDataFactory = $scriptDataFactory;
    }

    /**
     * Return the depth of this key. This is limited to 256 sequential derivations.
     *
     * @return int
     */
    public function getDepth(): int
    {
        return $this->depth;
    }

    /**
     * Get the sequence number for this address. Hardened keys are
     * created with sequence > 0x80000000. a sequence number lower
     * than this can be derived with the public key.
     *
     * @return int
     */
    public function getSequence(): int
    {
        return $this->sequence;
    }

    /**
     * Get the fingerprint of the parent key. For master keys, this is 00000000.
     *
     * @return int
     */
    public function getFingerprint(): int
    {
        if ($this->getDepth() === 0) {
            return 0;
        }

        return $this->parentFingerprint;
    }

    /**
     * Return the fingerprint to be used for child keys.
     * @return int
     */
    public function getChildFingerprint(): int
    {
        $pubKeyHash = $this->getPublicKey()->getPubKeyHash();
        return (int) $pubKeyHash->slice(0, 4)->getInt();
    }

    /**
     * Return the chain code - a deterministic 'salt' for HMAC-SHA512
     * in child derivations
     *
     * @return BufferInterface
     */
    public function getChainCode(): BufferInterface
    {
        return $this->chainCode;
    }

    /**
     * @return PrivateKeyInterface
     */
    public function getPrivateKey(): PrivateKeyInterface
    {
        if ($this->key->isPrivate()) {
            /** @var PrivateKeyInterface $key */
            $key = $this->key;
            return $key;
        }

        throw new \RuntimeException('Unable to get private key, not known');
    }

    /**
     * Get the public key the private key or public key.
     *
     * @return PublicKeyInterface
     */
    public function getPublicKey(): PublicKeyInterface
    {
        if ($this->isPrivate()) {
            return $this->getPrivateKey()->getPublicKey();
        } else {
            /** @var PublicKeyInterface $key */
            $key = $this->key;
            return $key;
        }
    }

    /**
     * @return HierarchicalKey
     */
    public function withoutPrivateKey(): HierarchicalKey
    {
        $clone = clone $this;
        $clone->key = $clone->getPublicKey();
        return $clone;
    }

    /**
     * @return ScriptDataFactory
     */
    public function getScriptDataFactory()
    {
        return $this->scriptDataFactory;
    }

    /**
     * @return \BitWasp\Bitcoin\Key\KeyToScript\ScriptAndSignData
     */
    public function getScriptAndSignData()
    {
        if (null === $this->scriptAndSignData) {
            $this->scriptAndSignData = $this->scriptDataFactory->convertKey($this->key);
        }

        return $this->scriptAndSignData;
    }

    /**
     * @param BaseAddressCreator $addressCreator
     * @return \BitWasp\Bitcoin\Address\Address
     */
    public function getAddress(BaseAddressCreator $addressCreator)
    {
        return $this->getScriptAndSignData()->getAddress($addressCreator);
    }

    /**
     * Return whether this is a private key
     *
     * @return bool
     */
    public function isPrivate(): bool
    {
        return $this->key->isPrivate();
    }

    /**
     * Return whether the key is hardened
     *
     * @return bool
     */
    public function isHardened(): bool
    {
        return ($this->sequence >> 31) === 1;
    }

    /**
     * Create a buffer containing data to be hashed hashed to yield the child offset
     *
     * @param int $sequence
     * @return BufferInterface
     * @throws \Exception
     */
    public function getHmacSeed(int $sequence): BufferInterface
    {
        if ($sequence < 0 || $sequence > IntRange::U32_MAX) {
            throw new \InvalidArgumentException("Sequence is outside valid range, must be >= 0 && <= (2^31)-1");
        }

        if (($sequence >> 31) === 1) {
            if ($this->isPrivate() === false) {
                throw new \Exception("Can't derive a hardened key without the private key");
            }

            $data = "\x00{$this->getPrivateKey()->getBinary()}";
        } else {
            $data = $this->getPublicKey()->getBinary();
        }

        return new Buffer($data . pack("N", $sequence));
    }

    /**
     * Derive a child key
     *
     * @param int $sequence
     * @return HierarchicalKey
     * @throws \Exception
     */
    public function deriveChild(int $sequence): HierarchicalKey
    {
        $nextDepth = $this->depth + 1;
        if ($nextDepth > 255) {
            throw new \InvalidArgumentException('Invalid depth for BIP32 key, cannot exceed 255');
        }

        $hash = Hash::hmac('sha512', $this->getHmacSeed($sequence), $this->chainCode);
        $offset = $hash->slice(0, 32);
        $chain = $hash->slice(32);

        if (false === $this->ecAdapter->validatePrivateKey($offset)) {
            return $this->deriveChild($sequence + 1);
        }

        $key = $this->isPrivate() ? $this->getPrivateKey() : $this->getPublicKey();
        $key = $key->tweakAdd($offset->getGmp());

        return new HierarchicalKey(
            $this->ecAdapter,
            $this->scriptDataFactory,
            $nextDepth,
            $this->getChildFingerprint(),
            $sequence,
            $chain,
            $key
        );
    }

    /**
     * @param array|\stdClass|\Traversable $list
     * @return HierarchicalKey
     * @throws \Exception
     */
    public function deriveFromList($list): HierarchicalKey
    {
        if (!is_array($list) && !$list instanceof \Traversable && !$list instanceof \stdClass) {
            throw new \InvalidArgumentException('List must be an array or \Traversable');
        }

        $key = $this;
        foreach ($list as $sequence) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            $key = $key->deriveChild((int) $sequence);
        }

        return $key;
    }

    /**
     * Decodes a BIP32 path into actual 32bit sequence numbers and derives the child key
     *
     * @param string $path
     * @return HierarchicalKey
     * @throws \Exception
     */
    public function derivePath(string $path): HierarchicalKey
    {
        $sequences = new HierarchicalKeySequence();
        return $this->deriveFromList($sequences->decodePath($path));
    }

    /**
     * Serializes the instance according to whether it wraps a private or public key.
     * @param NetworkInterface $network
     * @return string
     */
    public function toExtendedKey(NetworkInterface $network = null): string
    {
        $network = $network ?: Bitcoin::getNetwork();

        $extendedSerializer = new Base58ExtendedKeySerializer(new ExtendedKeySerializer($this->ecAdapter));
        $extended = $extendedSerializer->serialize($network, $this);
        return $extended;
    }

    /**
     * Explicitly serialize as a private key. Throws an exception if
     * the key isn't private.
     *
     * @param NetworkInterface $network
     * @return string
     */
    public function toExtendedPrivateKey(NetworkInterface $network = null): string
    {
        if (!$this->isPrivate()) {
            throw new \LogicException('Cannot create extended private key from public');
        }

        return $this->toExtendedKey($network);
    }

    /**
     * Explicitly serialize as a public key. This will always work.
     *
     * @param NetworkInterface $network
     * @return string
     */
    public function toExtendedPublicKey(NetworkInterface $network = null): string
    {
        return $this->withoutPrivateKey()->toExtendedKey($network);
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace BitWasp\Bitcoin\Key\Deterministic;
6
7		use BitWasp\Bitcoin\Address\BaseAddressCreator;
8		use BitWasp\Bitcoin\Bitcoin;
9		use BitWasp\Bitcoin\Crypto\EcAdapter\Adapter\EcAdapterInterface;
10		use BitWasp\Bitcoin\Crypto\EcAdapter\Key\KeyInterface;
11		use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PrivateKeyInterface;
12		use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PublicKeyInterface;
13		use BitWasp\Bitcoin\Crypto\Hash;
14		use BitWasp\Bitcoin\Key\KeyToScript\ScriptAndSignData;
15		use BitWasp\Bitcoin\Key\KeyToScript\ScriptDataFactory;
16		use BitWasp\Bitcoin\Network\NetworkInterface;
17		use BitWasp\Bitcoin\Serializer\Key\HierarchicalKey\Base58ExtendedKeySerializer;
18		use BitWasp\Bitcoin\Serializer\Key\HierarchicalKey\ExtendedKeySerializer;
19		use BitWasp\Bitcoin\Util\IntRange;
20		use BitWasp\Buffertools\Buffer;
21		use BitWasp\Buffertools\BufferInterface;
22
23		class HierarchicalKey
24		{
25		/**
26		* @var EcAdapterInterface
27		*/
28		protected $ecAdapter;
29
30		/**
31		* @var int
32		*/
33		private $depth;
34
35		/**
36		* @var int
37		*/
38		private $parentFingerprint;
39
40		/**
41		* @var int
42		*/
43		private $sequence;
44
45		/**
46		* @var BufferInterface
47		*/
48		private $chainCode;
49
50		/**
51		* @var KeyInterface
52		*/
53		private $key;
54
55		/**
56		* @var ScriptDataFactory
57		*/
58		private $scriptDataFactory;
59
60		/**
61		* @var ScriptAndSignData\|null
62		*/
63		private $scriptAndSignData;
64
65		/**
66		* @param EcAdapterInterface $ecAdapter
67		* @param ScriptDataFactory $scriptDataFactory
68		* @param int $depth
69		* @param int $parentFingerprint
70		* @param int $sequence
71		* @param BufferInterface $chainCode
72		* @param KeyInterface $key
73		*/
74	73	public function __construct(EcAdapterInterface $ecAdapter, ScriptDataFactory $scriptDataFactory, int $depth, int $parentFingerprint, int $sequence, BufferInterface $chainCode, KeyInterface $key)
75		{
76	73	if ($depth < 0 \|\| $depth > IntRange::U8_MAX) {
77		throw new \InvalidArgumentException('Invalid depth for BIP32 key, must be in range [0 - 255] inclusive');
78		}
79
80	73	if ($parentFingerprint < 0 \|\| $parentFingerprint > IntRange::U32_MAX) {
81		throw new \InvalidArgumentException('Invalid fingerprint for BIP32 key, must be in range [0 - (2^31)-1] inclusive');
82		}
83
84	73	if ($sequence < 0 \|\| $sequence > IntRange::U32_MAX) {
85		throw new \InvalidArgumentException('Invalid sequence for BIP32 key, must be in range [0 - (2^31)-1] inclusive');
86		}
87
88	73	if ($chainCode->getSize() !== 32) {
89		throw new \RuntimeException('Chaincode should be 32 bytes');
90		}
91
92	73	if (!$key->isCompressed()) {
93	1	throw new \InvalidArgumentException('A HierarchicalKey must always be compressed');
94		}
95
96	72	$this->ecAdapter = $ecAdapter;
97	72	$this->depth = $depth;
98	72	$this->sequence = $sequence;
99	72	$this->parentFingerprint = $parentFingerprint;
100	72	$this->chainCode = $chainCode;
101	72	$this->key = $key;
102	72	$this->scriptDataFactory = $scriptDataFactory;
103	72	}
104
105		/**
106		* Return the depth of this key. This is limited to 256 sequential derivations.
107		*
108		* @return int
109		*/
110	30	public function getDepth(): int
111		{
112	30	return $this->depth;
113		}
114
115		/**
116		* Get the sequence number for this address. Hardened keys are
117		* created with sequence > 0x80000000. a sequence number lower
118		* than this can be derived with the public key.
119		*
120		* @return int
121		*/
122	25	public function getSequence(): int
123		{
124	25	return $this->sequence;
125		}
126
127		/**
128		* Get the fingerprint of the parent key. For master keys, this is 00000000.
129		*
130		* @return int
131		*/
132	26	public function getFingerprint(): int
133		{
134	26	if ($this->getDepth() === 0) {
135	14	return 0;
136		}
137
138	22	return $this->parentFingerprint;
139		}
140
141		/**
142		* Return the fingerprint to be used for child keys.
143		* @return int
144		*/
145	33	public function getChildFingerprint(): int
146		{
147	33	$pubKeyHash = $this->getPublicKey()->getPubKeyHash();
148	33	return (int) $pubKeyHash->slice(0, 4)->getInt();
149		}
150
151		/**
152		* Return the chain code - a deterministic 'salt' for HMAC-SHA512
153		* in child derivations
154		*
155		* @return BufferInterface
156		*/
157	24	public function getChainCode(): BufferInterface
158		{
159	24	return $this->chainCode;
160		}
161
162		/**
163		* @return PrivateKeyInterface
164		*/
165	42	public function getPrivateKey(): PrivateKeyInterface
166		{
167	42	if ($this->key->isPrivate()) {
168		/** @var PrivateKeyInterface $key */
169	40	$key = $this->key;
170	40	return $key;
171		}
172
173	2	throw new \RuntimeException('Unable to get private key, not known');
174		}
175
176		/**
177		* Get the public key the private key or public key.
178		*
179		* @return PublicKeyInterface
180		*/
181	44	public function getPublicKey(): PublicKeyInterface
182		{
183	44	if ($this->isPrivate()) {
184	36	return $this->getPrivateKey()->getPublicKey();
185		} else {
186		/** @var PublicKeyInterface $key */
187	27	$key = $this->key;
188	27	return $key;
189		}
190		}
191
192		/**
193		* @return HierarchicalKey
194		*/
195	21	public function withoutPrivateKey(): HierarchicalKey
196		{
197	21	$clone = clone $this;
198	21	$clone->key = $clone->getPublicKey();
199	21	return $clone;
200		}
201
202		/**
203		* @return ScriptDataFactory
204		*/
205	26	public function getScriptDataFactory()
206		{
207	26	return $this->scriptDataFactory;
208		}
209
210		/**
211		* @return \BitWasp\Bitcoin\Key\KeyToScript\ScriptAndSignData
212		*/
213	22	public function getScriptAndSignData()
214		{
215	22	if (null === $this->scriptAndSignData) {
216	22	$this->scriptAndSignData = $this->scriptDataFactory->convertKey($this->key);
217		}
218
219	22	return $this->scriptAndSignData;
220		}
221
222		/**
223		* @param BaseAddressCreator $addressCreator
224		* @return \BitWasp\Bitcoin\Address\Address
225		*/
226	16	public function getAddress(BaseAddressCreator $addressCreator)
227		{
228	16	return $this->getScriptAndSignData()->getAddress($addressCreator);
229		}
230
231		/**
232		* Return whether this is a private key
233		*
234		* @return bool
235		*/
236	48	public function isPrivate(): bool
237		{
238	48	return $this->key->isPrivate();
239		}
240
241		/**
242		* Return whether the key is hardened
243		*
244		* @return bool
245		*/
246	2	public function isHardened(): bool
247		{
248	2	return ($this->sequence >> 31) === 1;
249		}
250
251		/**
252		* Create a buffer containing data to be hashed hashed to yield the child offset
253		*
254		* @param int $sequence
255		* @return BufferInterface
256		* @throws \Exception
257		*/
258	39	public function getHmacSeed(int $sequence): BufferInterface
259		{
260	39	if ($sequence < 0 \|\| $sequence > IntRange::U32_MAX) {
261	6	throw new \InvalidArgumentException("Sequence is outside valid range, must be >= 0 && <= (2^31)-1");
262		}
263
264	33	if (($sequence >> 31) === 1) {
265	30	if ($this->isPrivate() === false) {
266	2	throw new \Exception("Can't derive a hardened key without the private key");
267		}
268
269	28	$data = "\x00{$this->getPrivateKey()->getBinary()}";
270		} else {
271	31	$data = $this->getPublicKey()->getBinary();
272		}
273
274	31	return new Buffer($data . pack("N", $sequence));
275		}
276
277		/**
278		* Derive a child key
279		*
280		* @param int $sequence
281		* @return HierarchicalKey
282		* @throws \Exception
283		*/
284	36	public function deriveChild(int $sequence): HierarchicalKey
285		{
286	36	$nextDepth = $this->depth + 1;
287	36	if ($nextDepth > 255) {
288		throw new \InvalidArgumentException('Invalid depth for BIP32 key, cannot exceed 255');
289		}
290
291	36	$hash = Hash::hmac('sha512', $this->getHmacSeed($sequence), $this->chainCode);
292	31	$offset = $hash->slice(0, 32);
293	31	$chain = $hash->slice(32);
294
295	31	if (false === $this->ecAdapter->validatePrivateKey($offset)) {
296	1	return $this->deriveChild($sequence + 1);
297		}
298
299	31	$key = $this->isPrivate() ? $this->getPrivateKey() : $this->getPublicKey();
300	31	$key = $key->tweakAdd($offset->getGmp());
301
302	31	return new HierarchicalKey(
303	31	$this->ecAdapter,
304	31	$this->scriptDataFactory,
305	31	$nextDepth,
306	31	$this->getChildFingerprint(),
307	31	$sequence,
308	31	$chain,
309	31	$key
310		);
311		}
312
313		/**
314		* @param array\|\stdClass\|\Traversable $list
315		* @return HierarchicalKey
316		* @throws \Exception
317		*/
318	26	public function deriveFromList($list): HierarchicalKey
319		{
320	26	if (!is_array($list) && !$list instanceof \Traversable && !$list instanceof \stdClass) {
321		throw new \InvalidArgumentException('List must be an array or \Traversable');
322		}
323
324	26	$key = $this;
325	26	foreach ($list as $sequence) {
		0 ignored issues – show Bug introduced 2015-11-30 20:43 UTC by Report Bug Copy Issue Report The expression `$list` of type `array\|object<Traversable>\|object<stdClass>` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
326	26	$key = $key->deriveChild((int) $sequence);
327		}
328
329	26	return $key;
330		}
331
332		/**
333		* Decodes a BIP32 path into actual 32bit sequence numbers and derives the child key
334		*
335		* @param string $path
336		* @return HierarchicalKey
337		* @throws \Exception
338		*/
339	26	public function derivePath(string $path): HierarchicalKey
340		{
341	26	$sequences = new HierarchicalKeySequence();
342	26	return $this->deriveFromList($sequences->decodePath($path));
343		}
344
345		/**
346		* Serializes the instance according to whether it wraps a private or public key.
347		* @param NetworkInterface $network
348		* @return string
349		*/
350	16	public function toExtendedKey(NetworkInterface $network = null): string
351		{
352	16	$network = $network ?: Bitcoin::getNetwork();
353
354	16	$extendedSerializer = new Base58ExtendedKeySerializer(new ExtendedKeySerializer($this->ecAdapter));
355	16	$extended = $extendedSerializer->serialize($network, $this);
356	16	return $extended;
357		}
358
359		/**
360		* Explicitly serialize as a private key. Throws an exception if
361		* the key isn't private.
362		*
363		* @param NetworkInterface $network
364		* @return string
365		*/
366	16	public function toExtendedPrivateKey(NetworkInterface $network = null): string
367		{
368	16	if (!$this->isPrivate()) {
369	2	throw new \LogicException('Cannot create extended private key from public');
370		}
371
372	14	return $this->toExtendedKey($network);
373		}
374
375		/**
376		* Explicitly serialize as a public key. This will always work.
377		*
378		* @param NetworkInterface $network
379		* @return string
380		*/
381	13	public function toExtendedPublicKey(NetworkInterface $network = null): string
382		{
383	13	return $this->withoutPrivateKey()->toExtendedKey($network);
384		}
385		}
386

Bit-Wasp / bitcoin-php

Push — master ( abcf31...a8a46d )

HierarchicalKey::deriveChild() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like