OutputClassifier - Code Metrics - Inspection of "Refactor output classifier" - Bit-Wasp/bitcoin-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#286)

by thomas

created 2016-03-26 16:16 UTC

OutputClassifier B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	207
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

89%

Importance

Changes	5
Bugs	0	Features	1

Metric	Value
c	5
b	0
f	1
dl	0
loc	207
wmc	52
lcom	1
cbo	6
ccs	89
cts	100
cp	0.89
rs	7.9487

6 Methods

Rating	Name	Size	Complexity
B	isPayToPublicKey()	18	7
D	isPayToPublicKeyHash()	31	10
C	isPayToScriptHash()	25	8
C	isMultisig()	34	11
D	isWitness()	25	9
C	classify()	27	7

How to fix Complexity

<?php

namespace BitWasp\Bitcoin\Script\Classifier;

use BitWasp\Bitcoin\Script\Parser\Operation;
use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\PhpEcc\Key\PublicKey;
use BitWasp\Bitcoin\Script\Opcodes;
use BitWasp\Bitcoin\Script\ScriptInterface;
use BitWasp\Buffertools\BufferInterface;

class OutputClassifier
{
    const PAYTOPUBKEY = 'pubkey';
    const PAYTOPUBKEYHASH = 'pubkeyhash';
    const PAYTOSCRIPTHASH = 'scripthash';
    const WITNESS_V0_KEYHASH = 'witness_v0_keyhash';
    const WITNESS_V0_SCRIPTHASH = 'witness_v0_scripthash';
    const MULTISIG = 'multisig';
    const UNKNOWN = 'unknown';
    const NONSTANDARD = 'nonstandard';

    /**
     * @param ScriptInterface $script
     * @param BufferInterface $publicKey
     * @return bool
     */
    public function isPayToPublicKey(ScriptInterface $script, & $publicKey = null)
    {
        $decoded = $script->getScriptParser()->decode();
        if (count($decoded) !== 2 || $decoded[0]->isPush() === false || $decoded[1]->isPush() === true) {
            return false;
        }

        $size = $decoded[0]->getDataSize();
        if ($size === 33 || $size === 65) {
            $op = $decoded[1];
            if ($op->getOp() === Opcodes::OP_CHECKSIG) {
                $publicKey = $decoded[0]->getData();
                return true;
            }
        }

        return false;
    }

    /**
     * @param ScriptInterface $script
     * @param null $pubKeyHash
     * @return bool
     */
    public function isPayToPublicKeyHash(ScriptInterface $script, & $pubKeyHash = null)
    {
        $decoded = $script->getScriptParser()->decode();
        if (count($decoded) !== 5) {
            return false;
        }

        $dup = $decoded[0];
        $hash = $decoded[1];
        $buf = $decoded[2];
        $eq = $decoded[3];
        $checksig = $decoded[4];

        foreach ([$dup, $hash, $eq, $checksig] as $op) {
            /** @var Operation $op */
            if ($op->isPush()) {
                return false;
            }
        }

        if ($dup->getOp() === Opcodes::OP_DUP
        && $hash->getOp() === Opcodes::OP_HASH160
        && $buf->isPush() && $buf->getDataSize() === 20
        && $eq->getOp() === Opcodes::OP_EQUALVERIFY
        && $checksig->getOp() === Opcodes::OP_CHECKSIG) {
            $pubKeyHash = $decoded[2]->getData();
            return true;
        }

        return false;
    }

    /**
     * @param ScriptInterface $script
     * @param null $scriptHash
     * @return bool
     */
    public function isPayToScriptHash(ScriptInterface $script, & $scriptHash = null)
    {
        $decoded = $script->getScriptParser()->decode();
        if (count($decoded) !== 3) {
            return false;
        }

        $hash = $decoded[0];
        if ($hash->isPush() || !$hash->getOp() === Opcodes::OP_HASH160) {
            return false;
        }

        $buffer = $decoded[1];
        if (!$buffer->isPush() || $buffer->getDataSize() !== 20) {
            return false;
        }

        $eq = $decoded[2];
        if (!$eq->isPush() && $eq->getOp() === Opcodes::OP_EQUAL) {
            $scriptHash = $decoded[1]->getData();
            return true;
        }

        return false;
    }

    /**
     * @param ScriptInterface $script
     * @param array $keys
     * @return bool
     */
    public function isMultisig(ScriptInterface $script, & $keys = [])
    {
        $decoded = $script->getScriptParser()->decode();
        $count = count($decoded);
        if ($count <= 3) {
            return false;
        }

        $mOp = $decoded[0];
        $nOp = $decoded[$count - 2];
        $checksig = $decoded[$count - 1];
        if ($mOp->isPush() || $nOp->isPush() || $checksig->isPush()) {
            return false;
        }

        /** @var Operation[] $vKeys */
        $vKeys = array_slice($decoded, 1, -2);
        $solutions = [];
        foreach ($vKeys as $key) {
            if (!$key->isPush() || !PublicKey::isCompressedOrUncompressed($key->getData())) {
                return false;
            }
            $solutions[] = $key->getData();
        }

        if ($mOp->getOp() >= Opcodes::OP_0
            && $nOp->getOp() <= Opcodes::OP_16
            && $checksig->getOp() === Opcodes::OP_CHECKMULTISIG) {
            $keys = $solutions;
            return true;
        }

        return false;
    }

    /**
     * @param ScriptInterface $script
     * @param null $programHash
     * @return bool
     */
    public function isWitness(ScriptInterface $script, & $programHash = null)
    {
        $decoded = $script->getScriptParser()->decode();
        $size = $script->getBuffer()->getSize();
        if ($size < 4 || $size > 34) {
            return false;
        }

        if (count($decoded) !== 2 || !$decoded[1]->isPush()) {
            return false;
        }

        $version = $decoded[0]->getOp();
        if ($version != Opcodes::OP_0 && ($version < Opcodes::OP_1 || $version > Opcodes::OP_16)) {
            return false;
        }

        $witness = $decoded[1];
        if ($size === $witness->getDataSize() + 2) {
            $programHash = $witness->getData();
            return true;
        }

        return false;
    }

    /**
     * @param ScriptInterface $script
     * @param null $solution
     * @return string
     */
    public function classify(ScriptInterface $script, &$solution = null)
    {
        $type = self::UNKNOWN;
        $solution = null;
        if ($this->isPayToScriptHash($script, $solution)) {
            /** @var BufferInterface $solution */
            $type = self::PAYTOSCRIPTHASH;
        } elseif ($this->isWitness($script, $solution)) {
            /** @var BufferInterface $solution */
            if ($solution->getSize() == 20) {
                $type = self::WITNESS_V0_KEYHASH;
            } else {
                $type = self::WITNESS_V0_SCRIPTHASH;
            }
        } elseif ($this->isPayToPublicKey($script, $solution)) {
            /** @var BufferInterface $solution */
            $type = self::PAYTOPUBKEY;
        } elseif ($this->isPayToPublicKeyHash($script, $solution)) {
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            /** @var BufferInterface $solution */
            $type = self::PAYTOPUBKEYHASH;
        } elseif ($this->isMultisig($script, $solution)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            /** @var BufferInterface[] $solution */
            $type = self::MULTISIG;
        }

        return $type;
    }
}


1		<?php
2
3		namespace BitWasp\Bitcoin\Script\Classifier;
4
5		use BitWasp\Bitcoin\Script\Parser\Operation;
6		use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\PhpEcc\Key\PublicKey;
7		use BitWasp\Bitcoin\Script\Opcodes;
8		use BitWasp\Bitcoin\Script\ScriptInterface;
9		use BitWasp\Buffertools\BufferInterface;
10
11		class OutputClassifier
12		{
13		const PAYTOPUBKEY = 'pubkey';
14		const PAYTOPUBKEYHASH = 'pubkeyhash';
15		const PAYTOSCRIPTHASH = 'scripthash';
16		const WITNESS_V0_KEYHASH = 'witness_v0_keyhash';
17		const WITNESS_V0_SCRIPTHASH = 'witness_v0_scripthash';
18		const MULTISIG = 'multisig';
19		const UNKNOWN = 'unknown';
20		const NONSTANDARD = 'nonstandard';
21
22		/**
23		* @param ScriptInterface $script
24		* @param BufferInterface $publicKey
25		* @return bool
26		*/
27		public function isPayToPublicKey(ScriptInterface $script, & $publicKey = null)
28		{
29		$decoded = $script->getScriptParser()->decode();
30		if (count($decoded) !== 2 \|\| $decoded[0]->isPush() === false \|\| $decoded[1]->isPush() === true) {
31		return false;
32		}
33
34		$size = $decoded[0]->getDataSize();
35	198	if ($size === 33 \|\| $size === 65) {
36		$op = $decoded[1];
37	198	if ($op->getOp() === Opcodes::OP_CHECKSIG) {
38	198	$publicKey = $decoded[0]->getData();
39	198	return true;
40		}
41		}
42
43		return false;
44		}
45	144
46		/**
47	144	* @param ScriptInterface $script
48	120	* @param null $pubKeyHash
49		* @return bool
50		*/
51	42	public function isPayToPublicKeyHash(ScriptInterface $script, & $pubKeyHash = null)
52	42	{
53	30	$decoded = $script->getScriptParser()->decode();
54	30	if (count($decoded) !== 5) {
55	30	return false;
56	30	}
57
58		$dup = $decoded[0];
59		$hash = $decoded[1];
60	12	$buf = $decoded[2];
61		$eq = $decoded[3];
62		$checksig = $decoded[4];
63
64		foreach ([$dup, $hash, $eq, $checksig] as $op) {
65		/** @var Operation $op */
66		if ($op->isPush()) {
67	114	return false;
68		}
69	114	}
70	54
71		if ($dup->getOp() === Opcodes::OP_DUP
72		&& $hash->getOp() === Opcodes::OP_HASH160
73	66	&& $buf->isPush() && $buf->getDataSize() === 20
74	66	&& $eq->getOp() === Opcodes::OP_EQUALVERIFY
75	66	&& $checksig->getOp() === Opcodes::OP_CHECKSIG) {
76	66	$pubKeyHash = $decoded[2]->getData();
77	66	return true;
78		}
79	66
80		return false;
81	66	}
82
83		/**
84	66	* @param ScriptInterface $script
85		* @param null $scriptHash
86	66	* @return bool
87	66	*/
88	66	public function isPayToScriptHash(ScriptInterface $script, & $scriptHash = null)
89	66	{
90	66	$decoded = $script->getScriptParser()->decode();
91	66	if (count($decoded) !== 3) {
92	66	return false;
93		}
94
95		$hash = $decoded[0];
96		if ($hash->isPush() \|\| !$hash->getOp() === Opcodes::OP_HASH160) {
97		return false;
98		}
99
100		$buffer = $decoded[1];
101		if (!$buffer->isPush() \|\| $buffer->getDataSize() !== 20) {
102	168	return false;
103		}
104	168
105	138	$eq = $decoded[2];
106		if (!$eq->isPush() && $eq->getOp() === Opcodes::OP_EQUAL) {
107		$scriptHash = $decoded[1]->getData();
108	72	return true;
109	72	}
110
111		return false;
112		}
113	72
114	72	/**
115		* @param ScriptInterface $script
116		* @param array $keys
117		* @return bool
118		*/
119	72	public function isMultisig(ScriptInterface $script, & $keys = [])
120	72	{
121	72	$decoded = $script->getScriptParser()->decode();
122	72	$count = count($decoded);
123		if ($count <= 3) {
124		return false;
125		}
126
127		$mOp = $decoded[0];
128		$nOp = $decoded[$count - 2];
129		$checksig = $decoded[$count - 1];
130		if ($mOp->isPush() \|\| $nOp->isPush() \|\| $checksig->isPush()) {
131		return false;
132	78	}
133
134	78	/** @var Operation[] $vKeys */
135	78	$vKeys = array_slice($decoded, 1, -2);
136	30	$solutions = [];
137		foreach ($vKeys as $key) {
138		if (!$key->isPush() \|\| !PublicKey::isCompressedOrUncompressed($key->getData())) {
139	48	return false;
140	48	}
141	48	$solutions[] = $key->getData();
142	48	}
143
144		if ($mOp->getOp() >= Opcodes::OP_0
145		&& $nOp->getOp() <= Opcodes::OP_16
146		&& $checksig->getOp() === Opcodes::OP_CHECKMULTISIG) {
147	48	$keys = $solutions;
148	48	return true;
149	48	}
150	48
151		return false;
152		}
153	48
154	48	/**
155		* @param ScriptInterface $script
156	48	* @param null $programHash
157	48	* @return bool
158	48	*/
159	48	public function isWitness(ScriptInterface $script, & $programHash = null)
160	48	{
161		$decoded = $script->getScriptParser()->decode();
162		$size = $script->getBuffer()->getSize();
163		if ($size < 4 \|\| $size > 34) {
164		return false;
165		}
166
167		if (count($decoded) !== 2 \|\| !$decoded[1]->isPush()) {
168		return false;
169		}
170	198
171		$version = $decoded[0]->getOp();
172	132	if ($version != Opcodes::OP_0 && ($version < Opcodes::OP_1 \|\| $version > Opcodes::OP_16)) {
173	132	return false;
174		}
175	132
176	72	$witness = $decoded[1];
177		if ($size === $witness->getDataSize() + 2) {
178		$programHash = $witness->getData();
179	78	return true;
180	78	}
181	78
182	66	return false;
183		}
184
185	30	/**
186	30	* @param ScriptInterface $script
187		* @param null $solution
188		* @return string
189		*/
190	30	public function classify(ScriptInterface $script, &$solution = null)
191	30	{
192	30	$type = self::UNKNOWN;
193	30	$solution = null;
194	198	if ($this->isPayToScriptHash($script, $solution)) {
195		/** @var BufferInterface $solution */
196		$type = self::PAYTOSCRIPTHASH;
197		} elseif ($this->isWitness($script, $solution)) {
198		/** @var BufferInterface $solution */
199		if ($solution->getSize() == 20) {
200		$type = self::WITNESS_V0_KEYHASH;
201		} else {
202		$type = self::WITNESS_V0_SCRIPTHASH;
203	138	}
204		} elseif ($this->isPayToPublicKey($script, $solution)) {
205	138	/** @var BufferInterface $solution */
206	138	$type = self::PAYTOPUBKEY;
207	138	} elseif ($this->isPayToPublicKeyHash($script, $solution)) {
		0 ignored issues – show Bug introduced 2016-03-26 06:36 UTC by Report Bug Copy Issue Report It seems like `$solution` can also be of type `object<BitWasp\Buffertools\BufferInterface>`; however, `BitWasp\Bitcoin\Script\C...:isPayToPublicKeyHash()` does only seem to accept `null`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
208		/** @var BufferInterface $solution */
209	42	$type = self::PAYTOPUBKEYHASH;
210	138	} elseif ($this->isMultisig($script, $solution)) {
		0 ignored issues – show Documentation introduced 2016-03-26 06:36 UTC by Report Bug Copy Issue Report `$solution` is of type `null`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
211		/** @var BufferInterface[] $solution */
212	30	$type = self::MULTISIG;
213	12	}
214	12
215	18	return $type;
216		}
217		}
218

Bit-Wasp / bitcoin-php

Pull Request — master (#286)

OutputClassifier B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

6 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like