Checksig::__construct() - Code Metrics - Inspection of "ditch reimplementations of Bech32 / SegwitAddress..." - Bit-Wasp/bitcoin-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c780c0...f2b04e )

by thomas

created 2018-07-09 20:47 UTC

Checksig::__construct() A

↳ Parent: Checksig

Complexity

Conditions	5
Paths	5

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	18
CRAP Score	5.025

Importance

Changes

Metric	Value
cc	5
nc	5
nop	1
dl	0
loc	32
ccs	18
cts	20
cp	0.9
crap	5.025
rs	9.0968
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace BitWasp\Bitcoin\Transaction\Factory;

use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PublicKeyInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Serializer\Key\PublicKeySerializerInterface;
use BitWasp\Bitcoin\Script\ScriptInfo\Multisig;
use BitWasp\Bitcoin\Script\ScriptInfo\PayToPubkey;
use BitWasp\Bitcoin\Script\ScriptInfo\PayToPubkeyHash;
use BitWasp\Bitcoin\Script\ScriptType;
use BitWasp\Bitcoin\Serializer\Signature\TransactionSignatureSerializer;
use BitWasp\Bitcoin\Signature\TransactionSignatureInterface;
use BitWasp\Buffertools\Buffer;
use BitWasp\Buffertools\BufferInterface;

class Checksig
{
    /**
     * @var string
     */
    private $scriptType;

    /**
     * @var bool
     */
    private $required = true;

    /**
     * @var PayToPubkeyHash|PayToPubkey|Multisig
     */
    private $info;

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

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

    /**
     * @var TransactionSignatureInterface[]
     */
    protected $signatures = [];

    /**
     * @var PublicKeyInterface[]|null[]
     */
    protected $publicKeys = [];

    /**
     * Checksig constructor.
     * @param Multisig|PayToPubkeyHash|PayToPubkey $info
     */
    public function __construct($info)
    {
        if (!is_object($info)) {
            throw new \RuntimeException("First value to checksig must be an object");
        }

        $infoClass = get_class($info);
        switch ($infoClass) {
            case PayToPubkey::class:
                /** @var PayToPubkey $info */
                $this->scriptType = $info->getType();
                $this->requiredSigs = $info->getRequiredSigCount();
                $this->keyCount = 1;
                break;
            case PayToPubkeyHash::class:
                /** @var PayToPubkeyHash $info */
                $this->scriptType = ScriptType::P2PKH;
                $this->requiredSigs = $info->getRequiredSigCount();
                $this->keyCount = 1;
                break;
            case Multisig::class:
                /** @var Multisig $info */
                $this->scriptType = ScriptType::MULTISIG;
                $this->requiredSigs = $info->getRequiredSigCount();
                $this->keyCount = $info->getKeyCount();
                break;
            default:
                throw new \RuntimeException("Unsupported class passed to Checksig");
        }

        $this->info = $info;
    }

    /**
     * Mark this Checksig operation as not required. Will use OP_0
     * in place of all values (satisfying MINIMALDATA / MINIMALIF)
     *
     * @param bool $setting
     * @return $this
     */
    public function setRequired(bool $setting)
    {
        $this->required = $setting;
        return $this;
    }

    /**
     * Returns whether this opcodes successful completion is
     * necessary for the overall successful operation of the
     * script
     *
     * @return bool
     */
    public function isRequired(): bool
    {
        return $this->required;
    }

    /**
     * Returns the underlying script info class
     *
     * @return Multisig|PayToPubkey|PayToPubkeyHash
     */
    public function getInfo()
    {
        return $this->info;
    }

    /**
     * Return the script type
     * NB: Checksig overloads the various templates, returning 'multisig'
     * even if the opcode was multisigverify. Check the getInfo() result,
     * or isVerify() result, if this is important.
     *
     * @return string
     */
    public function getType(): string
    {
        return $this->scriptType;
    }

    /**
     * @return array|BufferInterface|BufferInterface[]
     */
    public function getSolution()
    {
        if ($this->info instanceof Multisig) {
            return $this->info->getKeyBuffers();
        } else if ($this->info instanceof PayToPubkey) {
            return $this->info->getKeyBuffer();
        } else {
            return $this->info->getPubKeyHash();
        }
    }

    /**
     * @return int
     */
    public function getRequiredSigs(): int
    {
        return $this->requiredSigs;
    }

    /**
     * @return bool
     */
    public function isFullySigned(): bool
    {
        if ($this->required) {
            return $this->requiredSigs === count($this->signatures);
        } else {
            return true;
        }
    }

    /**
     * @param int $idx
     * @return bool
     */
    public function hasSignature(int $idx): bool
    {
        if ($idx > $this->requiredSigs) {
            throw new \RuntimeException("Out of range signature queried");
        }

        return array_key_exists($idx, $this->signatures);
    }

    /**
     * @param int $idx
     * @param TransactionSignatureInterface $signature
     * @return $this
     */
    public function setSignature(int $idx, TransactionSignatureInterface $signature)
    {
        if ($idx < 0 || $idx > $this->keyCount) {
            throw new \RuntimeException("Out of range signature for operation");
        }

        $this->signatures[$idx] = $signature;
        return $this;
    }

    /**
     * @param int $idx
     * @return TransactionSignatureInterface|null
     */
    public function getSignature(int $idx)
    {
        if (!$this->hasSignature($idx)) {
            return null;
        }

        return $this->signatures[$idx];
    }

    /**
     * @return array
     */
    public function getSignatures(): array
    {
        return $this->signatures;
    }

    /**
     * @param int $idx
     * @return bool
     */
    public function hasKey(int $idx): bool
    {
        return array_key_exists($idx, $this->publicKeys);
    }

    /**
     * @param int $idx
     * @return PublicKeyInterface|null
     */
    public function getKey(int $idx)
    {
        if (!$this->hasKey($idx)) {
            return null;
        }

        return $this->publicKeys[$idx];
    }

    /**
     * @param $idx
     * @param PublicKeyInterface|null $key
     * @return $this
     */
    public function setKey(int $idx, PublicKeyInterface $key = null)
    {
        if ($idx < 0 || $idx > $this->keyCount) {
            throw new \RuntimeException("Out of range index for public key");
        }

        $this->publicKeys[$idx] = $key;
        return $this;
    }

    /**
     * @return PublicKeyInterface[]
     */
    public function getKeys(): array
    {
        return $this->publicKeys;
    }

    /**
     * @return bool
     */
    public function isVerify(): bool
    {
        return $this->info->isChecksigVerify();
    }

    /**
     * @param TransactionSignatureSerializer $txSigSerializer
     * @param PublicKeySerializerInterface $pubKeySerializer
     * @return BufferInterface[]
     */
    public function serialize(
        TransactionSignatureSerializer $txSigSerializer,
        PublicKeySerializerInterface $pubKeySerializer
    ): array {
        $outputType = $this->getType();
        $result = [];

        if (ScriptType::P2PK === $outputType) {
            if (!$this->required) {
                $result[0] = new Buffer();
            } else {
                if ($this->hasSignature(0)) {
                    $result[0] = $txSigSerializer->serialize($this->getSignature(0));
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                }
            }
        } else if (ScriptType::P2PKH === $outputType) {
            if (!$this->required && $this->hasKey(0)) {
                $result[0] = new Buffer();
                $result[1] = $pubKeySerializer->serialize($this->getKey(0));
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            } else {
                if ($this->hasSignature(0) && $this->hasKey(0)) {
                    $result[0] = $txSigSerializer->serialize($this->getSignature(0));
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                    $result[1] = $pubKeySerializer->serialize($this->getKey(0));
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                }
            }
        } else if (ScriptType::MULTISIG === $outputType) {
            if (!$this->required) {
                $result = array_fill(0, 1 + $this->getRequiredSigs(), new Buffer());
            } else {
                $result[] = new Buffer();
                for ($i = 0, $nPubKeys = count($this->getKeys()); $i < $nPubKeys; $i++) {
                    if ($this->hasSignature($i)) {
                        $result[] = $txSigSerializer->serialize($this->getSignature($i));
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                    }
                }
            }
        } else {
            throw new \RuntimeException('Parameter 0 for serializeSolution was a non-standard input type');
        }

        return $result;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace BitWasp\Bitcoin\Transaction\Factory;
6
7		use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PublicKeyInterface;
8		use BitWasp\Bitcoin\Crypto\EcAdapter\Serializer\Key\PublicKeySerializerInterface;
9		use BitWasp\Bitcoin\Script\ScriptInfo\Multisig;
10		use BitWasp\Bitcoin\Script\ScriptInfo\PayToPubkey;
11		use BitWasp\Bitcoin\Script\ScriptInfo\PayToPubkeyHash;
12		use BitWasp\Bitcoin\Script\ScriptType;
13		use BitWasp\Bitcoin\Serializer\Signature\TransactionSignatureSerializer;
14		use BitWasp\Bitcoin\Signature\TransactionSignatureInterface;
15		use BitWasp\Buffertools\Buffer;
16		use BitWasp\Buffertools\BufferInterface;
17
18		class Checksig
19		{
20		/**
21		* @var string
22		*/
23		private $scriptType;
24
25		/**
26		* @var bool
27		*/
28		private $required = true;
29
30		/**
31		* @var PayToPubkeyHash\|PayToPubkey\|Multisig
32		*/
33		private $info;
34
35		/**
36		* @var int
37		*/
38		protected $requiredSigs;
39
40		/**
41		* @var int
42		*/
43		protected $keyCount;
44
45		/**
46		* @var TransactionSignatureInterface[]
47		*/
48		protected $signatures = [];
49
50		/**
51		* @var PublicKeyInterface[]\|null[]
52		*/
53		protected $publicKeys = [];
54
55		/**
56		* Checksig constructor.
57		* @param Multisig\|PayToPubkeyHash\|PayToPubkey $info
58		*/
59	118	public function __construct($info)
60		{
61	118	if (!is_object($info)) {
62		throw new \RuntimeException("First value to checksig must be an object");
63		}
64
65	118	$infoClass = get_class($info);
66	118	switch ($infoClass) {
67		case PayToPubkey::class:
68		/** @var PayToPubkey $info */
69	47	$this->scriptType = $info->getType();
70	47	$this->requiredSigs = $info->getRequiredSigCount();
71	47	$this->keyCount = 1;
72	47	break;
73		case PayToPubkeyHash::class:
74		/** @var PayToPubkeyHash $info */
75	44	$this->scriptType = ScriptType::P2PKH;
76	44	$this->requiredSigs = $info->getRequiredSigCount();
77	44	$this->keyCount = 1;
78	44	break;
79		case Multisig::class:
80		/** @var Multisig $info */
81	38	$this->scriptType = ScriptType::MULTISIG;
82	38	$this->requiredSigs = $info->getRequiredSigCount();
83	38	$this->keyCount = $info->getKeyCount();
84	38	break;
85		default:
86		throw new \RuntimeException("Unsupported class passed to Checksig");
87		}
88
89	118	$this->info = $info;
90	118	}
91
92		/**
93		* Mark this Checksig operation as not required. Will use OP_0
94		* in place of all values (satisfying MINIMALDATA / MINIMALIF)
95		*
96		* @param bool $setting
97		* @return $this
98		*/
99	2	public function setRequired(bool $setting)
100		{
101	2	$this->required = $setting;
102	2	return $this;
103		}
104
105		/**
106		* Returns whether this opcodes successful completion is
107		* necessary for the overall successful operation of the
108		* script
109		*
110		* @return bool
111		*/
112	95	public function isRequired(): bool
113		{
114	95	return $this->required;
115		}
116
117		/**
118		* Returns the underlying script info class
119		*
120		* @return Multisig\|PayToPubkey\|PayToPubkeyHash
121		*/
122	48	public function getInfo()
123		{
124	48	return $this->info;
125		}
126
127		/**
128		* Return the script type
129		* NB: Checksig overloads the various templates, returning 'multisig'
130		* even if the opcode was multisigverify. Check the getInfo() result,
131		* or isVerify() result, if this is important.
132		*
133		* @return string
134		*/
135	108	public function getType(): string
136		{
137	108	return $this->scriptType;
138		}
139
140		/**
141		* @return array\|BufferInterface\|BufferInterface[]
142		*/
143	75	public function getSolution()
144		{
145	75	if ($this->info instanceof Multisig) {
146		return $this->info->getKeyBuffers();
147	75	} else if ($this->info instanceof PayToPubkey) {
148	37	return $this->info->getKeyBuffer();
149		} else {
150	42	return $this->info->getPubKeyHash();
151		}
152		}
153
154		/**
155		* @return int
156		*/
157	86	public function getRequiredSigs(): int
158		{
159	86	return $this->requiredSigs;
160		}
161
162		/**
163		* @return bool
164		*/
165	101	public function isFullySigned(): bool
166		{
167	101	if ($this->required) {
168	101	return $this->requiredSigs === count($this->signatures);
169		} else {
170	2	return true;
171		}
172		}
173
174		/**
175		* @param int $idx
176		* @return bool
177		*/
178	97	public function hasSignature(int $idx): bool
179		{
180	97	if ($idx > $this->requiredSigs) {
181		throw new \RuntimeException("Out of range signature queried");
182		}
183
184	97	return array_key_exists($idx, $this->signatures);
185		}
186
187		/**
188		* @param int $idx
189		* @param TransactionSignatureInterface $signature
190		* @return $this
191		*/
192	95	public function setSignature(int $idx, TransactionSignatureInterface $signature)
193		{
194	95	if ($idx < 0 \|\| $idx > $this->keyCount) {
195		throw new \RuntimeException("Out of range signature for operation");
196		}
197
198	95	$this->signatures[$idx] = $signature;
199	95	return $this;
200		}
201
202		/**
203		* @param int $idx
204		* @return TransactionSignatureInterface\|null
205		*/
206	95	public function getSignature(int $idx)
207		{
208	95	if (!$this->hasSignature($idx)) {
209		return null;
210		}
211
212	95	return $this->signatures[$idx];
213		}
214
215		/**
216		* @return array
217		*/
218	95	public function getSignatures(): array
219		{
220	95	return $this->signatures;
221		}
222
223		/**
224		* @param int $idx
225		* @return bool
226		*/
227	56	public function hasKey(int $idx): bool
228		{
229	56	return array_key_exists($idx, $this->publicKeys);
230		}
231
232		/**
233		* @param int $idx
234		* @return PublicKeyInterface\|null
235		*/
236	56	public function getKey(int $idx)
237		{
238	56	if (!$this->hasKey($idx)) {
239		return null;
240		}
241
242	56	return $this->publicKeys[$idx];
243		}
244
245		/**
246		* @param $idx
247		* @param PublicKeyInterface\|null $key
248		* @return $this
249		*/
250	103	public function setKey(int $idx, PublicKeyInterface $key = null)
251		{
252	103	if ($idx < 0 \|\| $idx > $this->keyCount) {
253		throw new \RuntimeException("Out of range index for public key");
254		}
255
256	103	$this->publicKeys[$idx] = $key;
257	103	return $this;
258		}
259
260		/**
261		* @return PublicKeyInterface[]
262		*/
263	85	public function getKeys(): array
264		{
265	85	return $this->publicKeys;
266		}
267
268		/**
269		* @return bool
270		*/
271	85	public function isVerify(): bool
272		{
273	85	return $this->info->isChecksigVerify();
274		}
275
276		/**
277		* @param TransactionSignatureSerializer $txSigSerializer
278		* @param PublicKeySerializerInterface $pubKeySerializer
279		* @return BufferInterface[]
280		*/
281	95	public function serialize(
282		TransactionSignatureSerializer $txSigSerializer,
283		PublicKeySerializerInterface $pubKeySerializer
284		): array {
285	95	$outputType = $this->getType();
286	95	$result = [];
287
288	95	if (ScriptType::P2PK === $outputType) {
289	34	if (!$this->required) {
290	1	$result[0] = new Buffer();
291		} else {
292	34	if ($this->hasSignature(0)) {
293	34	$result[0] = $txSigSerializer->serialize($this->getSignature(0));
		0 ignored issues – show Bug introduced 2017-09-06 08:20 UTC by Report Bug Copy Issue Report It seems like `$this->getSignature(0)` can be `null`; however, `serialize()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
294		}
295		}
296	70	} else if (ScriptType::P2PKH === $outputType) {
297	40	if (!$this->required && $this->hasKey(0)) {
298		$result[0] = new Buffer();
299		$result[1] = $pubKeySerializer->serialize($this->getKey(0));
		0 ignored issues – show Bug introduced 2017-09-06 08:20 UTC by Report Bug Copy Issue Report It seems like `$this->getKey(0)` can be `null`; however, `serialize()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
300		} else {
301	40	if ($this->hasSignature(0) && $this->hasKey(0)) {
302	40	$result[0] = $txSigSerializer->serialize($this->getSignature(0));
		0 ignored issues – show Bug introduced 2017-09-06 08:20 UTC by Report Bug Copy Issue Report It seems like `$this->getSignature(0)` can be `null`; however, `serialize()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
303	40	$result[1] = $pubKeySerializer->serialize($this->getKey(0));
		0 ignored issues – show Bug introduced 2017-09-06 08:20 UTC by Report Bug Copy Issue Report It seems like `$this->getKey(0)` can be `null`; however, `serialize()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
304		}
305		}
306	32	} else if (ScriptType::MULTISIG === $outputType) {
307	32	if (!$this->required) {
308	1	$result = array_fill(0, 1 + $this->getRequiredSigs(), new Buffer());
309		} else {
310	31	$result[] = new Buffer();
311	32	for ($i = 0, $nPubKeys = count($this->getKeys()); $i < $nPubKeys; $i++) {
312	31	if ($this->hasSignature($i)) {
313	31	$result[] = $txSigSerializer->serialize($this->getSignature($i));
		0 ignored issues – show Bug introduced 2017-09-06 08:20 UTC by Report Bug Copy Issue Report It seems like `$this->getSignature($i)` can be `null`; however, `serialize()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
314		}
315		}
316		}
317		} else {
318		throw new \RuntimeException('Parameter 0 for serializeSolution was a non-standard input type');
319		}
320
321	95	return $result;
322		}
323		}
324

Bit-Wasp / bitcoin-php

Push — master ( c780c0...f2b04e )

Checksig::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like