SizeEstimation - Code Metrics - Inspection of "wip: test refactoring" - blocktrail/blocktrail-sdk-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#125)

by thomas

created 2018-10-04 17:43 UTC

SizeEstimation B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	315
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

Importance

Changes

Metric	Value
dl	0
loc	315
ccs	0
cts	143
cp	0
rs	7.92
c	0
b	0
f	0
wmc	51
lcom	1
cbo	11

15 Methods

Rating	Name	Size	Complexity
A	estimateP2PKStackSize()	7	1
A	getPublicKeySize()	3	2
A	getLengthOfScriptLengthElement()	13	5
A	getLengthOfVarInt()	14	5
A	getLengthOfVector()	7	2
A	estimateMultisigStackSize()	15	3
A	estimateP2PKHStackSize()	7	1
B	estimateSizeForStack()	39	7
A	estimateInputFromScripts()	16	5
A	estimateUtxo()	3	1
B	estimateUtxoFromScripts()	39	7
A	estimateInputsSize()	19	5
A	estimateOutputsSize()	25	5
A	estimateVsize()	3	1
A	estimateWeight()	14	1

How to fix Complexity

<?php

namespace Blocktrail\SDK;

use BitWasp\Bitcoin\Script\ScriptFactory;
use BitWasp\Bitcoin\Script\ScriptType;
use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PublicKeyInterface;
use \BitWasp\Bitcoin\Script\ScriptInfo\Multisig;
use \BitWasp\Bitcoin\Script\ScriptInfo\PayToPubKey;
use \BitWasp\Bitcoin\Script\Classifier\OutputClassifier;
use BitWasp\Bitcoin\Script\ScriptInterface;
use BitWasp\Bitcoin\Transaction\TransactionOutputInterface;

class SizeEstimation
{
    const SIZE_DER_SIGNATURE = 72;
    const SIZE_V0_P2WSH = 36;

    /**
     * @param bool $compressed
     * @return int
     */
    public static function getPublicKeySize($compressed = true) {
        return $compressed ? PublicKeyInterface::LENGTH_COMPRESSED : PublicKeyInterface::LENGTH_UNCOMPRESSED;
    }

    /**
     * @param int $length
     * @return int
     */
    public static function getLengthOfScriptLengthElement($length) {
        if ($length < 75) {
            return 1;
        } else if ($length <= 0xff) {
            return 2;
        } else if ($length <= 0xffff) {
            return 3;
        } else if ($length <= 0xffffffff) {
            return 5;
        } else {
            throw new \RuntimeException('Size of pushdata too large');
        }
    }

    /**
     * @param int $length
     * @return int
     */
    public static function getLengthOfVarInt($length) {
        if ($length < 253) {
            return 1;
        } else if ($length < 65535) {
            $num_bytes = 2;
        } else if ($length < 4294967295) {
            $num_bytes = 4;
        } else if ($length < 18446744073709551615) {
            $num_bytes = 8;
        } else {
            throw new \InvalidArgumentException("Invalid decimal");
        }
        return 1 + $num_bytes;
    }

    /**
     * @param array $vectorSizes
     * @return int|mixed
     */
    public static function getLengthOfVector(array $vectorSizes) {
        $vectorSize = self::getLengthOfVarInt(count($vectorSizes));
        foreach ($vectorSizes as $size) {
            $vectorSize += self::getLengthOfVarInt($size) + $size;
        }
        return $vectorSize;
    }

    /**
     * @param Multisig $multisig
     * @return array - first is array of stack sizes, second is script len
     */
    public static function estimateMultisigStackSize(Multisig $multisig) {
        $stackSizes = [0];
        for ($i = 0; $i < $multisig->getRequiredSigCount(); $i++) {
// count() is called on each iteration
for ($i=0; $i < count($collection); $i++) { }

// count() is only called once
for ($i=0, $c=count($collection); $i<$c; $i++) { }
            $stackSizes[] = self::SIZE_DER_SIGNATURE;
        }

        $scriptSize = 1; // OP_$m
        $keys = $multisig->getKeyBuffers();
        for ($i = 0, $n = $multisig->getKeyCount(); $i < $n; $i++) {
            $scriptSize += 1 + $keys[$i]->getSize();
        }

        $scriptSize += 1 + 1; // OP_$n OP_CHECKMULTISIG
        return [$stackSizes, $scriptSize];
    }

    /**
     * @param PayToPubKey $info
     * @return array - first is array of stack sizes, second is script len
     */
    public static function estimateP2PKStackSize(PayToPubKey $info) {
        $stackSizes = [self::SIZE_DER_SIGNATURE];

        $scriptSize = 1 + $info->getKeyBuffer()->getSize(); // PUSHDATA[<75] PUBLICKEY
        $scriptSize += 1; // OP_CHECKSIG
        return [$stackSizes, $scriptSize];
    }

    /**
     * @param bool $isCompressed
     * @return array - first is array of stack sizes, second is script len
     */
    public static function estimateP2PKHStackSize($isCompressed = true) {
        $pubKeySize = self::getPublicKeySize($isCompressed);
        $stackSizes = [self::SIZE_DER_SIGNATURE, $pubKeySize];

        $scriptSize = 1 + 1 + 1 + 20 + 1 + 1;
        return [$stackSizes, $scriptSize];
    }

    /**
     * @param array $stackSizes - array of integer size of a value (for scriptSig or witness)
     * @param bool $isWitness
     * @param ScriptInterface $redeemScript
     * @param ScriptInterface $witnessScript
     * @return array
     */
    public static function estimateSizeForStack(array $stackSizes, $isWitness, ScriptInterface $redeemScript = null, ScriptInterface $witnessScript = null) {
        assert(($witnessScript === null) || $isWitness);

        if ($isWitness) {
            $scriptSigSizes = [];
            $witnessSizes = $stackSizes;
            if ($witnessScript instanceof ScriptInterface) {
                $witnessSizes[] = $witnessScript->getBuffer()->getSize();
            }
        } else {
            $scriptSigSizes = $stackSizes;
            $witnessSizes = [];
        }

        if ($redeemScript instanceof ScriptInterface) {
            $scriptSigSizes[] = $redeemScript->getBuffer()->getSize();
        }

        $scriptSigSize = 0;
        foreach ($scriptSigSizes as $size) {
            $len = self::getLengthOfScriptLengthElement($size);
            $scriptSigSize += $len;
            $scriptSigSize += $size;
        }

        // Make sure to count the CScriptBase length prefix..
        $scriptSigSize += self::getLengthOfVarInt($scriptSigSize);

        // make sure this is set to 0 when not used.
        // Summing WitnessSize is used in addition to $withWitness
        // because a tx without witnesses _cannot_ use witness serialization
        // total witnessSize = 0 means don't use that format
        $witnessSize = 0;
        if (count($witnessSizes) > 0) {
            // witness has a prefix indicating `n` elements in vector
            $witnessSize = self::getLengthOfVector($witnessSizes);
        }
        return [$scriptSigSize, $witnessSize];
    }

    /**
     * @param ScriptInterface $script - not the scriptPubKey, might be SPK,RS,WS
     * @param ScriptInterface|null $redeemScript
     * @param ScriptInterface $witnessScript
     * @param bool $isWitness
     * @return array
     */
    public static function estimateInputFromScripts(ScriptInterface $script, ScriptInterface $redeemScript = null, ScriptInterface $witnessScript = null, $isWitness) {
        assert($witnessScript === null || $isWitness);
        $classifier = new OutputClassifier();
        if ($classifier->isMultisig($script)) {
            list ($stackSizes, ) = SizeEstimation::estimateMultisigStackSize(new Multisig($script));
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        } else if ($classifier->isPayToPublicKey($script)) {
            list ($stackSizes, ) = SizeEstimation::estimateP2PKStackSize(new PayToPubKey($script));
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        } else if ($classifier->isPayToPublicKeyHash($script)) {
            // defaults to compressed, tough luck
            list ($stackSizes, ) = SizeEstimation::estimateP2PKHStackSize();
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        } else {
            throw new \InvalidArgumentException("Unsupported script type");
        }

        return self::estimateSizeForStack($stackSizes, $isWitness, $redeemScript, $witnessScript);
    }

    /**
     * @param UTXO $utxo
     * @return array
     */
    public static function estimateUtxo(UTXO $utxo) {
        return self::estimateUtxoFromScripts($utxo->scriptPubKey, $utxo->redeemScript, $utxo->witnessScript);
    }

    /**
     * @param ScriptInterface $scriptPubKey
     * @param ScriptInterface $redeemScript
     * @param ScriptInterface $witnessScript
     * @return array
     */
    public static function estimateUtxoFromScripts(
        ScriptInterface $scriptPubKey,
        ScriptInterface $redeemScript = null,
        ScriptInterface $witnessScript = null
    ) {
        $classifier = new OutputClassifier();
        $decodePK = $classifier->decode($scriptPubKey);
        $witness = false;
        if ($decodePK->getType() === ScriptType::P2SH) {
            if (null === $redeemScript) {
                throw new \RuntimeException("Can't estimate, missing redeem script");
            }
            $decodePK = $classifier->decode($redeemScript);
        }

        if ($decodePK->getType() === ScriptType::P2WKH) {
            $scriptSitu = ScriptFactory::scriptPubKey()->p2pkh($decodePK->getSolution());
            $decodePK = $classifier->decode($scriptSitu);
            $witness = true;
        } else if ($decodePK->getType() === ScriptType::P2WSH) {
            if (null === $witnessScript) {
                throw new \RuntimeException("Can't estimate, missing witness script");
            }
            $decodePK = $classifier->decode($witnessScript);
            $witness = true;
        }

        if (!in_array($decodePK->getType(), [ScriptType::MULTISIG, ScriptType::P2PKH, ScriptType::P2PK])) {
            throw new \RuntimeException("Unsupported script type");
        }

        $script = $decodePK->getScript();
        list ($scriptSig, $witness) = SizeEstimation::estimateInputFromScripts($script, $redeemScript, $witnessScript, $witness);
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}

        return [
            "scriptSig" => $scriptSig,
            "witness" => $witness,
        ];
    }

    /**
     * @param UTXO[] $utxos
     * @param bool $withWitness
     * @return integer
     */
    public static function estimateInputsSize(array $utxos, $withWitness) {
        $inputSize = 0;
        $witnessSize = 0;
        foreach ($utxos as $utxo) {
            $estimate = SizeEstimation::estimateUtxo($utxo);
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            $inputSize += 32 + 4 + 4;
            $inputSize += $estimate['scriptSig'];
            if ($withWitness) {
                $witnessSize += $estimate['witness'];
            }
        }

        if ($withWitness && $witnessSize != 0) {
            $inputSize += $witnessSize;
            $inputSize += 2; // flag bytes
        }

        return $inputSize;
    }

    /**
     * @param array $outputs
     * @return int
     */
    public static function estimateOutputsSize(array $outputs) {
        $outputSize = 0;
        foreach ($outputs as $output) {
            $size = 8;

            $scriptSize = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            if ($output instanceof TransactionOutputInterface) {
                $scriptSize = $output->getScript()->getBuffer()->getSize();
            } else {
                if (isset($output['scriptPubKey'])) {
                    if ($output['scriptPubKey'] instanceof ScriptInterface) {
                        $scriptSize = $output['scriptPubKey']->getBuffer()->getSize();
                    } else {
                        $scriptSize = strlen($output['scriptPubKey']) / 2;
                    }
                } else {
                    $scriptSize = 25;
                }
            }

            $size += SizeEstimation::getLengthOfVarInt($scriptSize) + $scriptSize;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            $outputSize += $size;
        }
        return $outputSize;
    }

    /**
     * @param UTXO[] $utxos
     * @param array $outputs
     * @return int
     */
    public static function estimateVsize(array $utxos, array $outputs) {
        return (int)ceil(self::estimateWeight($utxos, $outputs) / 4);
    }

    /**
     * @param UTXO[] $utxos
     * @param array $outputs
     * @return int
     */
    public static function estimateWeight(array $utxos, array $outputs) {
        $outputsSize = SizeEstimation::estimateOutputsSize($outputs);
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        $outputsSize += SizeEstimation::getLengthOfVarInt(count($outputs));
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}

        $baseSize = 4 +
            SizeEstimation::getLengthOfVarInt(count($utxos)) + SizeEstimation::estimateInputsSize($utxos, false) +
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            $outputsSize + 4;

        $witnessSize = 4 +
            SizeEstimation::getLengthOfVarInt(count($utxos)) + SizeEstimation::estimateInputsSize($utxos, true) +
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            $outputsSize + 4;

        return ($baseSize * 3) + $witnessSize;
    }
}


1			<?php
2
3			namespace Blocktrail\SDK;
4
5			use BitWasp\Bitcoin\Script\ScriptFactory;
6			use BitWasp\Bitcoin\Script\ScriptType;
7			use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PublicKeyInterface;
8			use \BitWasp\Bitcoin\Script\ScriptInfo\Multisig;
9			use \BitWasp\Bitcoin\Script\ScriptInfo\PayToPubKey;
10			use \BitWasp\Bitcoin\Script\Classifier\OutputClassifier;
11			use BitWasp\Bitcoin\Script\ScriptInterface;
12			use BitWasp\Bitcoin\Transaction\TransactionOutputInterface;
13
14			class SizeEstimation
15			{
16			const SIZE_DER_SIGNATURE = 72;
17			const SIZE_V0_P2WSH = 36;
18
19			/**
20			* @param bool $compressed
21			* @return int
22			*/
23			public static function getPublicKeySize($compressed = true) {
24			return $compressed ? PublicKeyInterface::LENGTH_COMPRESSED : PublicKeyInterface::LENGTH_UNCOMPRESSED;
25			}
26
27			/**
28			* @param int $length
29			* @return int
30			*/
31			public static function getLengthOfScriptLengthElement($length) {
32			if ($length < 75) {
33			return 1;
34			} else if ($length <= 0xff) {
35			return 2;
36			} else if ($length <= 0xffff) {
37			return 3;
38			} else if ($length <= 0xffffffff) {
39			return 5;
40			} else {
41			throw new \RuntimeException('Size of pushdata too large');
42			}
43			}
44
45			/**
46			* @param int $length
47			* @return int
48			*/
49			public static function getLengthOfVarInt($length) {
50			if ($length < 253) {
51			return 1;
52			} else if ($length < 65535) {
53			$num_bytes = 2;
54			} else if ($length < 4294967295) {
55			$num_bytes = 4;
56			} else if ($length < 18446744073709551615) {
57			$num_bytes = 8;
58			} else {
59			throw new \InvalidArgumentException("Invalid decimal");
60			}
61			return 1 + $num_bytes;
62			}
63
64			/**
65			* @param array $vectorSizes
66			* @return int\|mixed
67			*/
68			public static function getLengthOfVector(array $vectorSizes) {
69			$vectorSize = self::getLengthOfVarInt(count($vectorSizes));
70			foreach ($vectorSizes as $size) {
71			$vectorSize += self::getLengthOfVarInt($size) + $size;
72			}
73			return $vectorSize;
74			}
75
76			/**
77			* @param Multisig $multisig
78			* @return array - first is array of stack sizes, second is script len
79			*/
80			public static function estimateMultisigStackSize(Multisig $multisig) {
81			$stackSizes = [0];
82			for ($i = 0; $i < $multisig->getRequiredSigCount(); $i++) {
			0 ignored issues – show Performance Best Practice introduced 2018-09-24 13:59 UTC by Report Bug Copy Issue Report Consider avoiding function calls on each iteration of the `for` loop. If you have a function call in the test part of a `for` loop, this function is executed on each iteration. Often such a function, can be moved to the initialization part and be cached. // count() is called on each iteration for ($i=0; $i < count($collection); $i++) { } // count() is only called once for ($i=0, $c=count($collection); $i<$c; $i++) { } Loading history...
83			$stackSizes[] = self::SIZE_DER_SIGNATURE;
84			}
85
86			$scriptSize = 1; // OP_$m
87			$keys = $multisig->getKeyBuffers();
88			for ($i = 0, $n = $multisig->getKeyCount(); $i < $n; $i++) {
89			$scriptSize += 1 + $keys[$i]->getSize();
90			}
91
92			$scriptSize += 1 + 1; // OP_$n OP_CHECKMULTISIG
93			return [$stackSizes, $scriptSize];
94			}
95
96			/**
97			* @param PayToPubKey $info
98			* @return array - first is array of stack sizes, second is script len
99			*/
100			public static function estimateP2PKStackSize(PayToPubKey $info) {
101			$stackSizes = [self::SIZE_DER_SIGNATURE];
102
103			$scriptSize = 1 + $info->getKeyBuffer()->getSize(); // PUSHDATA[<75] PUBLICKEY
104			$scriptSize += 1; // OP_CHECKSIG
105			return [$stackSizes, $scriptSize];
106			}
107
108			/**
109			* @param bool $isCompressed
110			* @return array - first is array of stack sizes, second is script len
111			*/
112			public static function estimateP2PKHStackSize($isCompressed = true) {
113			$pubKeySize = self::getPublicKeySize($isCompressed);
114			$stackSizes = [self::SIZE_DER_SIGNATURE, $pubKeySize];
115
116			$scriptSize = 1 + 1 + 1 + 20 + 1 + 1;
117			return [$stackSizes, $scriptSize];
118			}
119
120			/**
121			* @param array $stackSizes - array of integer size of a value (for scriptSig or witness)
122			* @param bool $isWitness
123			* @param ScriptInterface $redeemScript
124			* @param ScriptInterface $witnessScript
125			* @return array
126			*/
127			public static function estimateSizeForStack(array $stackSizes, $isWitness, ScriptInterface $redeemScript = null, ScriptInterface $witnessScript = null) {
128			assert(($witnessScript === null) \|\| $isWitness);
129
130			if ($isWitness) {
131			$scriptSigSizes = [];
132			$witnessSizes = $stackSizes;
133			if ($witnessScript instanceof ScriptInterface) {
134			$witnessSizes[] = $witnessScript->getBuffer()->getSize();
135			}
136			} else {
137			$scriptSigSizes = $stackSizes;
138			$witnessSizes = [];
139			}
140
141			if ($redeemScript instanceof ScriptInterface) {
142			$scriptSigSizes[] = $redeemScript->getBuffer()->getSize();
143			}
144
145			$scriptSigSize = 0;
146			foreach ($scriptSigSizes as $size) {
147			$len = self::getLengthOfScriptLengthElement($size);
148			$scriptSigSize += $len;
149			$scriptSigSize += $size;
150			}
151
152			// Make sure to count the CScriptBase length prefix..
153			$scriptSigSize += self::getLengthOfVarInt($scriptSigSize);
154
155			// make sure this is set to 0 when not used.
156			// Summing WitnessSize is used in addition to $withWitness
157			// because a tx without witnesses _cannot_ use witness serialization
158			// total witnessSize = 0 means don't use that format
159			$witnessSize = 0;
160			if (count($witnessSizes) > 0) {
161			// witness has a prefix indicating `n` elements in vector
162			$witnessSize = self::getLengthOfVector($witnessSizes);
163			}
164			return [$scriptSigSize, $witnessSize];
165			}
166
167			/**
168			* @param ScriptInterface $script - not the scriptPubKey, might be SPK,RS,WS
169			* @param ScriptInterface\|null $redeemScript
170			* @param ScriptInterface $witnessScript
171			* @param bool $isWitness
172			* @return array
173			*/
174			public static function estimateInputFromScripts(ScriptInterface $script, ScriptInterface $redeemScript = null, ScriptInterface $witnessScript = null, $isWitness) {
175			assert($witnessScript === null \|\| $isWitness);
176			$classifier = new OutputClassifier();
177			if ($classifier->isMultisig($script)) {
178			list ($stackSizes, ) = SizeEstimation::estimateMultisigStackSize(new Multisig($script));
			0 ignored issues – show Coding Style introduced 2018-09-24 13:59 UTC by Report Bug Copy Issue Report As per coding style, `self` should be used for accessing local static members. This check looks for accesses to local static members using the fully qualified name instead of `self::`. <?php class Certificate { const TRIPLEDES_CBC = 'ASDFGHJKL'; private $key; public function __construct() { $this->key = Certificate::TRIPLEDES_CBC; } } While this is perfectly valid, the fully qualified name of `Certificate::TRIPLEDES_CBC` could just as well be replaced by `self::TRIPLEDES_CBC`. Referencing local members with `self::` assured the access will still work when the class is renamed, makes it perfectly clear that the member is in fact local and will usually be shorter. Loading history...
179			} else if ($classifier->isPayToPublicKey($script)) {
180			list ($stackSizes, ) = SizeEstimation::estimateP2PKStackSize(new PayToPubKey($script));
			0 ignored issues – show Coding Style introduced 2018-09-24 13:59 UTC by Report Bug Copy Issue Report As per coding style, `self` should be used for accessing local static members. This check looks for accesses to local static members using the fully qualified name instead of `self::`. <?php class Certificate { const TRIPLEDES_CBC = 'ASDFGHJKL'; private $key; public function __construct() { $this->key = Certificate::TRIPLEDES_CBC; } } While this is perfectly valid, the fully qualified name of `Certificate::TRIPLEDES_CBC` could just as well be replaced by `self::TRIPLEDES_CBC`. Referencing local members with `self::` assured the access will still work when the class is renamed, makes it perfectly clear that the member is in fact local and will usually be shorter. Loading history...
181			} else if ($classifier->isPayToPublicKeyHash($script)) {
182			// defaults to compressed, tough luck
183			list ($stackSizes, ) = SizeEstimation::estimateP2PKHStackSize();
			0 ignored issues – show Coding Style introduced 2018-09-24 13:59 UTC by Report Bug Copy Issue Report As per coding style, `self` should be used for accessing local static members. This check looks for accesses to local static members using the fully qualified name instead of `self::`. <?php class Certificate { const TRIPLEDES_CBC = 'ASDFGHJKL'; private $key; public function __construct() { $this->key = Certificate::TRIPLEDES_CBC; } } While this is perfectly valid, the fully qualified name of `Certificate::TRIPLEDES_CBC` could just as well be replaced by `self::TRIPLEDES_CBC`. Referencing local members with `self::` assured the access will still work when the class is renamed, makes it perfectly clear that the member is in fact local and will usually be shorter. Loading history...
184			} else {
185			throw new \InvalidArgumentException("Unsupported script type");
186			}
187
188			return self::estimateSizeForStack($stackSizes, $isWitness, $redeemScript, $witnessScript);
189			}
190
191			/**
192			* @param UTXO $utxo
193			* @return array
194			*/
195			public static function estimateUtxo(UTXO $utxo) {
196			return self::estimateUtxoFromScripts($utxo->scriptPubKey, $utxo->redeemScript, $utxo->witnessScript);
197			}
198
199			/**
200			* @param ScriptInterface $scriptPubKey
201			* @param ScriptInterface $redeemScript
202			* @param ScriptInterface $witnessScript
203			* @return array
204			*/
205			public static function estimateUtxoFromScripts(
206			ScriptInterface $scriptPubKey,
207			ScriptInterface $redeemScript = null,
208			ScriptInterface $witnessScript = null
209			) {
210			$classifier = new OutputClassifier();
211			$decodePK = $classifier->decode($scriptPubKey);
212			$witness = false;
213			if ($decodePK->getType() === ScriptType::P2SH) {
214			if (null === $redeemScript) {
215			throw new \RuntimeException("Can't estimate, missing redeem script");
216			}
217			$decodePK = $classifier->decode($redeemScript);
218			}
219
220			if ($decodePK->getType() === ScriptType::P2WKH) {
221			$scriptSitu = ScriptFactory::scriptPubKey()->p2pkh($decodePK->getSolution());
222			$decodePK = $classifier->decode($scriptSitu);
223			$witness = true;
224			} else if ($decodePK->getType() === ScriptType::P2WSH) {
225			if (null === $witnessScript) {
226			throw new \RuntimeException("Can't estimate, missing witness script");
227			}
228			$decodePK = $classifier->decode($witnessScript);
229			$witness = true;
230			}
231
232			if (!in_array($decodePK->getType(), [ScriptType::MULTISIG, ScriptType::P2PKH, ScriptType::P2PK])) {
233			throw new \RuntimeException("Unsupported script type");
234			}
235
236			$script = $decodePK->getScript();
237			list ($scriptSig, $witness) = SizeEstimation::estimateInputFromScripts($script, $redeemScript, $witnessScript, $witness);
			0 ignored issues – show Coding Style introduced 2018-09-24 13:59 UTC by Report Bug Copy Issue Report As per coding style, `self` should be used for accessing local static members. This check looks for accesses to local static members using the fully qualified name instead of `self::`. <?php class Certificate { const TRIPLEDES_CBC = 'ASDFGHJKL'; private $key; public function __construct() { $this->key = Certificate::TRIPLEDES_CBC; } } While this is perfectly valid, the fully qualified name of `Certificate::TRIPLEDES_CBC` could just as well be replaced by `self::TRIPLEDES_CBC`. Referencing local members with `self::` assured the access will still work when the class is renamed, makes it perfectly clear that the member is in fact local and will usually be shorter. Loading history...
238
239			return [
240			"scriptSig" => $scriptSig,
241			"witness" => $witness,
242			];
243			}
244
245			/**
246			* @param UTXO[] $utxos
247			* @param bool $withWitness
248			* @return integer
249			*/
250			public static function estimateInputsSize(array $utxos, $withWitness) {
251			$inputSize = 0;
252			$witnessSize = 0;
253			foreach ($utxos as $utxo) {
254			$estimate = SizeEstimation::estimateUtxo($utxo);
			0 ignored issues – show Coding Style introduced 2018-09-24 13:59 UTC by Report Bug Copy Issue Report As per coding style, `self` should be used for accessing local static members. This check looks for accesses to local static members using the fully qualified name instead of `self::`. <?php class Certificate { const TRIPLEDES_CBC = 'ASDFGHJKL'; private $key; public function __construct() { $this->key = Certificate::TRIPLEDES_CBC; } } While this is perfectly valid, the fully qualified name of `Certificate::TRIPLEDES_CBC` could just as well be replaced by `self::TRIPLEDES_CBC`. Referencing local members with `self::` assured the access will still work when the class is renamed, makes it perfectly clear that the member is in fact local and will usually be shorter. Loading history...
255			$inputSize += 32 + 4 + 4;
256			$inputSize += $estimate['scriptSig'];
257			if ($withWitness) {
258			$witnessSize += $estimate['witness'];
259			}
260			}
261
262			if ($withWitness && $witnessSize != 0) {
263			$inputSize += $witnessSize;
264			$inputSize += 2; // flag bytes
265			}
266
267			return $inputSize;
268			}
269
270			/**
271			* @param array $outputs
272			* @return int
273			*/
274			public static function estimateOutputsSize(array $outputs) {
275			$outputSize = 0;
276			foreach ($outputs as $output) {
277			$size = 8;
278
279			$scriptSize = null;
			0 ignored issues – show Unused Code introduced 2018-01-03 13:29 UTC by Report Bug Copy Issue Report `$scriptSize` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
280			if ($output instanceof TransactionOutputInterface) {
281			$scriptSize = $output->getScript()->getBuffer()->getSize();
282			} else {
283			if (isset($output['scriptPubKey'])) {
284			if ($output['scriptPubKey'] instanceof ScriptInterface) {
285			$scriptSize = $output['scriptPubKey']->getBuffer()->getSize();
286			} else {
287			$scriptSize = strlen($output['scriptPubKey']) / 2;
288			}
289			} else {
290			$scriptSize = 25;
291			}
292			}
293
294			$size += SizeEstimation::getLengthOfVarInt($scriptSize) + $scriptSize;
			0 ignored issues – show Coding Style introduced 2018-09-24 13:59 UTC by Report Bug Copy Issue Report As per coding style, `self` should be used for accessing local static members. This check looks for accesses to local static members using the fully qualified name instead of `self::`. <?php class Certificate { const TRIPLEDES_CBC = 'ASDFGHJKL'; private $key; public function __construct() { $this->key = Certificate::TRIPLEDES_CBC; } } While this is perfectly valid, the fully qualified name of `Certificate::TRIPLEDES_CBC` could just as well be replaced by `self::TRIPLEDES_CBC`. Referencing local members with `self::` assured the access will still work when the class is renamed, makes it perfectly clear that the member is in fact local and will usually be shorter. Loading history...
295			$outputSize += $size;
296			}
297			return $outputSize;
298			}
299
300			/**
301			* @param UTXO[] $utxos
302			* @param array $outputs
303			* @return int
304			*/
305			public static function estimateVsize(array $utxos, array $outputs) {
306			return (int)ceil(self::estimateWeight($utxos, $outputs) / 4);
307			}
308
309			/**
310			* @param UTXO[] $utxos
311			* @param array $outputs
312			* @return int
313			*/
314			public static function estimateWeight(array $utxos, array $outputs) {
315			$outputsSize = SizeEstimation::estimateOutputsSize($outputs);
			0 ignored issues – show Coding Style introduced 2018-09-24 13:59 UTC by Report Bug Copy Issue Report As per coding style, `self` should be used for accessing local static members. This check looks for accesses to local static members using the fully qualified name instead of `self::`. <?php class Certificate { const TRIPLEDES_CBC = 'ASDFGHJKL'; private $key; public function __construct() { $this->key = Certificate::TRIPLEDES_CBC; } } While this is perfectly valid, the fully qualified name of `Certificate::TRIPLEDES_CBC` could just as well be replaced by `self::TRIPLEDES_CBC`. Referencing local members with `self::` assured the access will still work when the class is renamed, makes it perfectly clear that the member is in fact local and will usually be shorter. Loading history...
316			$outputsSize += SizeEstimation::getLengthOfVarInt(count($outputs));
			0 ignored issues – show Coding Style introduced 2018-09-24 13:59 UTC by Report Bug Copy Issue Report As per coding style, `self` should be used for accessing local static members. This check looks for accesses to local static members using the fully qualified name instead of `self::`. <?php class Certificate { const TRIPLEDES_CBC = 'ASDFGHJKL'; private $key; public function __construct() { $this->key = Certificate::TRIPLEDES_CBC; } } While this is perfectly valid, the fully qualified name of `Certificate::TRIPLEDES_CBC` could just as well be replaced by `self::TRIPLEDES_CBC`. Referencing local members with `self::` assured the access will still work when the class is renamed, makes it perfectly clear that the member is in fact local and will usually be shorter. Loading history...
317
318			$baseSize = 4 +
319			SizeEstimation::getLengthOfVarInt(count($utxos)) + SizeEstimation::estimateInputsSize($utxos, false) +
			0 ignored issues – show Coding Style introduced 2018-09-24 13:59 UTC by Report Bug Copy Issue Report As per coding style, `self` should be used for accessing local static members. This check looks for accesses to local static members using the fully qualified name instead of `self::`. <?php class Certificate { const TRIPLEDES_CBC = 'ASDFGHJKL'; private $key; public function __construct() { $this->key = Certificate::TRIPLEDES_CBC; } } While this is perfectly valid, the fully qualified name of `Certificate::TRIPLEDES_CBC` could just as well be replaced by `self::TRIPLEDES_CBC`. Referencing local members with `self::` assured the access will still work when the class is renamed, makes it perfectly clear that the member is in fact local and will usually be shorter. Loading history...
320			$outputsSize + 4;
321
322			$witnessSize = 4 +
323			SizeEstimation::getLengthOfVarInt(count($utxos)) + SizeEstimation::estimateInputsSize($utxos, true) +
			0 ignored issues – show Coding Style introduced 2018-09-24 13:59 UTC by Report Bug Copy Issue Report As per coding style, `self` should be used for accessing local static members. This check looks for accesses to local static members using the fully qualified name instead of `self::`. <?php class Certificate { const TRIPLEDES_CBC = 'ASDFGHJKL'; private $key; public function __construct() { $this->key = Certificate::TRIPLEDES_CBC; } } While this is perfectly valid, the fully qualified name of `Certificate::TRIPLEDES_CBC` could just as well be replaced by `self::TRIPLEDES_CBC`. Referencing local members with `self::` assured the access will still work when the class is renamed, makes it perfectly clear that the member is in fact local and will usually be shorter. Loading history...
324			$outputsSize + 4;
325
326			return ($baseSize * 3) + $witnessSize;
327			}
328			}
329

blocktrail / blocktrail-sdk-php

Pull Request — master (#125)

SizeEstimation B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

15 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like