Transaction::getLockTime() - Code Metrics - Inspection of "phpdoc fixes" - Bit-Wasp/bitcoin-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#320)

by thomas

created 2016-06-17 23:14 UTC

Transaction::getLockTime() A

↳ Parent: Transaction

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

<?php

namespace BitWasp\Bitcoin\Transaction;

use BitWasp\Bitcoin\Bitcoin;
use BitWasp\Bitcoin\Collection\Transaction\TransactionInputCollection;
use BitWasp\Bitcoin\Collection\Transaction\TransactionOutputCollection;
use BitWasp\Bitcoin\Collection\Transaction\TransactionWitnessCollection;
use BitWasp\Bitcoin\Crypto\Hash;
use BitWasp\Bitcoin\Script\ScriptWitnessInterface;
use BitWasp\Bitcoin\Serializable;
use BitWasp\Bitcoin\Serializer\Transaction\OldTransactionSerializer;
use BitWasp\Bitcoin\Serializer\Transaction\TransactionSerializer;
use BitWasp\Bitcoin\Transaction\SignatureHash\Hasher;
use BitWasp\Bitcoin\Utxo\Utxo;
use BitWasp\Buffertools\BufferInterface;
use BitWasp\CommonTrait\FunctionAliasArrayAccess;

class Transaction extends Serializable implements TransactionInterface
{
    use FunctionAliasArrayAccess;

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

    /**
     * @var TransactionInputCollection
     */
    private $inputs;

    /**
     * @var TransactionOutputCollection
     */
    private $outputs;

    /**
     * @var TransactionWitnessCollection
     */
    private $witness;

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

    /**
     * Transaction constructor.
     *
     * @param int $nVersion
     * @param TransactionInputCollection|null $inputs
     * @param TransactionOutputCollection|null $outputs
     * @param TransactionWitnessCollection|null $witness
     * @param int $nLockTime
     */
    public function __construct(
        $nVersion = TransactionInterface::DEFAULT_VERSION,
        TransactionInputCollection $inputs = null,
        TransactionOutputCollection $outputs = null,
        TransactionWitnessCollection $witness = null,
        $nLockTime = 0
    ) {
        if ($nVersion > TransactionInterface::MAX_VERSION) {
            throw new \InvalidArgumentException('Version must be less than ' . TransactionInterface::MAX_VERSION);
        }

        if ($nLockTime < 0 || $nLockTime > TransactionInterface::MAX_LOCKTIME) {
            throw new \InvalidArgumentException('Locktime must be positive and less than ' . TransactionInterface::MAX_LOCKTIME);
        }

        $this->version = $nVersion;
        $this->inputs = $inputs ?: new TransactionInputCollection();
        $this->outputs = $outputs ?: new TransactionOutputCollection();
        $this->witness = $witness ?: new TransactionWitnessCollection();
        $this->lockTime = $nLockTime;

        $this
            ->initFunctionAlias('version', 'getVersion')
            ->initFunctionAlias('inputs', 'getInputs')
            ->initFunctionAlias('outputs', 'getOutputs')
            ->initFunctionAlias('locktime', 'getLockTime');
    }

    /**
     * @return Transaction
     */
    public function __clone()
    {
        $this->inputs = clone $this->inputs;
        $this->outputs = clone $this->outputs;
    }

    /**
     * @return BufferInterface
     */
    public function getTxHash()
    {
        return Hash::sha256d($this->getBuffer());
    }

    /**
     * @return BufferInterface
     */
    public function getTxId()
    {
        return $this->getTxHash()->flip();
    }

    /**
     * @return BufferInterface
     */
    public function getWitnessTxId()
    {
        return Hash::sha256d($this->getWitnessBuffer())->flip();
    }

    /**
     * @return int
     */
    public function getVersion()
    {
        return $this->version;
    }

    /**
     * Get the array of inputs in the transaction
     *
     * @return TransactionInputCollection
     */
    public function getInputs()
    {
        return $this->inputs;
    }

    /**
     * @param int $index
     * @return TransactionInputInterface
     */
    public function getInput($index)
    {
        return $this->inputs[$index];
    }

    /**
     * Get Outputs
     *
     * @return TransactionOutputCollection
     */
    public function getOutputs()
    {
        return $this->outputs;
    }

    /**
     * @param int $vout
     * @return TransactionOutputInterface
     */
    public function getOutput($vout)
    {
        return $this->outputs[$vout];
    }

    /**
     * @return TransactionWitnessCollection
     */
    public function getWitnesses()
    {
        return $this->witness;
    }

    /**
     * @return ScriptWitnessInterface
     */
    public function getWitness($index)
    {
        return $this->witness[$index];
    }

    /**
     * @param int $vout
     * @return OutPointInterface
     */
    public function makeOutpoint($vout)
    {
        $this->getOutput($vout);
class User
{
    private $email;

    public function getEmail()
    {
        return $this->email;
    }

    public function setEmail($email)
    {
        $this->email = $email;
    }
}
        return new OutPoint($this->getTxId(), $vout);
    }

    /**
     * @param int $vout
     * @return Utxo
     */
    public function makeUtxo($vout)
    {
        return new Utxo(new OutPoint($this->getTxId(), $vout), $this->getOutput($vout));
    }

    /**
     * Get Lock Time
     *
     * @return int
     */
    public function getLockTime()
    {
        return $this->lockTime;
    }

    /**
     * @return Hasher
     */
    public function getSignatureHash()
    {
        return new Hasher($this);
    }

    /**
     * @return int|string
     */
    public function getValueOut()
    {
        $math = Bitcoin::getMath();
        $value = gmp_init(0);
        foreach ($this->outputs as $output) {
            $value = $math->add($value, gmp_init($output->getValue()));
        }

        return gmp_strval($value, 10);
    }

    /**
     * @return bool
     */
    public function isCoinbase()
    {
        return count($this->inputs) === 1 && $this->getInput(0)->isCoinBase();
    }

    /**
     * @param TransactionInterface $tx
     * @return bool
     */
    public function equals(TransactionInterface $tx)
    {
        $version = gmp_cmp($this->version, $tx->getVersion());
        if ($version !== 0) {
            return false;
        }

        $nIn = count($this->inputs);
        $nOut = count($this->outputs);
        $nWit = count($this->witness);
        if ($nIn !== count($tx->getInputs()) || $nOut !== count($tx->getOutputs()) || $nWit !== count($tx->getWitnesses())) {
            return false;
        }

        for ($i = 0; $i < $nIn; $i++) {
            if (false === $this->getInput($i)->equals($tx->getInput($i))) {
                return false;
            }
        }

        for ($i = 0; $i < $nOut; $i++) {
            if (false === $this->getOutput($i)->equals($tx->getOutput($i))) {
                return false;
            }
        }

        for ($i = 0; $i < $nWit; $i++) {
            if (false === $this->getWitness($i)->equals($tx->getWitness($i))) {
                return false;
            }
        }

        return gmp_cmp($this->lockTime, $tx->getLockTime()) === 0;
    }

    /**
     * @return Validator
     */
    public function validator()
    {
        return new Validator($this);
    }

    /**
     * @return BufferInterface
     */
    public function getBuffer()
    {
        return (new OldTransactionSerializer())->serialize($this);
    }

    /**
     * @return BufferInterface
     */
    public function getWitnessBuffer()
    {
        return (new TransactionSerializer())->serialize($this);
    }
}


1		<?php
2
3		namespace BitWasp\Bitcoin\Transaction;
4
5		use BitWasp\Bitcoin\Bitcoin;
6		use BitWasp\Bitcoin\Collection\Transaction\TransactionInputCollection;
7		use BitWasp\Bitcoin\Collection\Transaction\TransactionOutputCollection;
8		use BitWasp\Bitcoin\Collection\Transaction\TransactionWitnessCollection;
9		use BitWasp\Bitcoin\Crypto\Hash;
10		use BitWasp\Bitcoin\Script\ScriptWitnessInterface;
11		use BitWasp\Bitcoin\Serializable;
12		use BitWasp\Bitcoin\Serializer\Transaction\OldTransactionSerializer;
13		use BitWasp\Bitcoin\Serializer\Transaction\TransactionSerializer;
14		use BitWasp\Bitcoin\Transaction\SignatureHash\Hasher;
15		use BitWasp\Bitcoin\Utxo\Utxo;
16		use BitWasp\Buffertools\BufferInterface;
17		use BitWasp\CommonTrait\FunctionAliasArrayAccess;
18
19		class Transaction extends Serializable implements TransactionInterface
20		{
21		use FunctionAliasArrayAccess;
22
23		/**
24		* @var int
25		*/
26		private $version;
27
28		/**
29		* @var TransactionInputCollection
30		*/
31		private $inputs;
32
33		/**
34		* @var TransactionOutputCollection
35		*/
36		private $outputs;
37
38		/**
39		* @var TransactionWitnessCollection
40		*/
41		private $witness;
42
43		/**
44		* @var int
45		*/
46		private $lockTime;
47
48		/**
49		* Transaction constructor.
50		*
51		* @param int $nVersion
52		* @param TransactionInputCollection\|null $inputs
53		* @param TransactionOutputCollection\|null $outputs
54		* @param TransactionWitnessCollection\|null $witness
55		* @param int $nLockTime
56		*/
57	636	public function __construct(
58		$nVersion = TransactionInterface::DEFAULT_VERSION,
59		TransactionInputCollection $inputs = null,
60		TransactionOutputCollection $outputs = null,
61		TransactionWitnessCollection $witness = null,
62		$nLockTime = 0
63		) {
64	636	if ($nVersion > TransactionInterface::MAX_VERSION) {
65	3	throw new \InvalidArgumentException('Version must be less than ' . TransactionInterface::MAX_VERSION);
66		}
67
68	633	if ($nLockTime < 0 \|\| $nLockTime > TransactionInterface::MAX_LOCKTIME) {
69	3	throw new \InvalidArgumentException('Locktime must be positive and less than ' . TransactionInterface::MAX_LOCKTIME);
70		}
71
72	630	$this->version = $nVersion;
73	630	$this->inputs = $inputs ?: new TransactionInputCollection();
74	630	$this->outputs = $outputs ?: new TransactionOutputCollection();
75	630	$this->witness = $witness ?: new TransactionWitnessCollection();
76	630	$this->lockTime = $nLockTime;
77
78	420	$this
79	630	->initFunctionAlias('version', 'getVersion')
80	630	->initFunctionAlias('inputs', 'getInputs')
81	630	->initFunctionAlias('outputs', 'getOutputs')
82	630	->initFunctionAlias('locktime', 'getLockTime');
83	630	}
84
85		/**
86		* @return Transaction
87		*/
88	63	public function __clone()
89		{
90	63	$this->inputs = clone $this->inputs;
91	63	$this->outputs = clone $this->outputs;
92	63	}
93
94		/**
95		* @return BufferInterface
96		*/
97	60	public function getTxHash()
98		{
99	60	return Hash::sha256d($this->getBuffer());
100		}
101
102		/**
103		* @return BufferInterface
104		*/
105	60	public function getTxId()
106		{
107	60	return $this->getTxHash()->flip();
108		}
109
110		/**
111		* @return BufferInterface
112		*/
113		public function getWitnessTxId()
114		{
115		return Hash::sha256d($this->getWitnessBuffer())->flip();
116		}
117
118		/**
119		* @return int
120		*/
121	141	public function getVersion()
122		{
123	141	return $this->version;
124		}
125
126		/**
127		* Get the array of inputs in the transaction
128		*
129		* @return TransactionInputCollection
130		*/
131	486	public function getInputs()
132		{
133	486	return $this->inputs;
134		}
135
136		/**
137		* @param int $index
138		* @return TransactionInputInterface
139		*/
140	57	public function getInput($index)
141		{
142	57	return $this->inputs[$index];
143		}
144
145		/**
146		* Get Outputs
147		*
148		* @return TransactionOutputCollection
149		*/
150	159	public function getOutputs()
151	18	{
152	159	return $this->outputs;
153		}
154
155		/**
156		* @param int $vout
157		* @return TransactionOutputInterface
158		*/
159	51	public function getOutput($vout)
160		{
161	51	return $this->outputs[$vout];
162		}
163
164		/**
165		* @return TransactionWitnessCollection
166		*/
167	54	public function getWitnesses()
168		{
169	54	return $this->witness;
170		}
171
172		/**
173		* @return ScriptWitnessInterface
174		*/
175		public function getWitness($index)
176		{
177		return $this->witness[$index];
178		}
179
180		/**
181		* @param int $vout
182		* @return OutPointInterface
183		*/
184	12	public function makeOutpoint($vout)
185		{
186	12	$this->getOutput($vout);
		0 ignored issues – show Unused Code introduced 2015-12-16 03:40 UTC by Report Bug Copy Issue Report The call to the method `BitWasp\Bitcoin\Transact...ransaction::getOutput()` seems un-needed as the method has no side-effects. PHP Analyzer performs a side-effects analysis of your code. A side-effect is basically anything that might be visible after the scope of the method is left. Let’s take a look at an example: class User { private $email; public function getEmail() { return $this->email; } public function setEmail($email) { $this->email = $email; } } If we look at the `getEmail()` method, we can see that it has no side-effect. Whether you call this method or not, no future calls to other methods are affected by this. As such code as the following is useless: $user = new User(); $user->getEmail(); // This line could safely be removed as it has no effect. On the hand, if we look at the `setEmail()`, this method _has_ side-effects. In the following case, we could not remove the method call: $user = new User(); $user->setEmail('email@domain'); // This line has a side-effect (it changes an // instance variable). Loading history...
187	12	return new OutPoint($this->getTxId(), $vout);
188		}
189
190		/**
191		* @param int $vout
192		* @return Utxo
193		*/
194		public function makeUtxo($vout)
195		{
196		return new Utxo(new OutPoint($this->getTxId(), $vout), $this->getOutput($vout));
197		}
198
199		/**
200		* Get Lock Time
201		*
202		* @return int
203		*/
204	144	public function getLockTime()
205		{
206	144	return $this->lockTime;
207		}
208
209		/**
210		* @return Hasher
211		*/
212		public function getSignatureHash()
213		{
214		return new Hasher($this);
215		}
216
217		/**
218		* @return int\|string
219		*/
220	3	public function getValueOut()
221		{
222	3	$math = Bitcoin::getMath();
223	3	$value = gmp_init(0);
224	3	foreach ($this->outputs as $output) {
225	3	$value = $math->add($value, gmp_init($output->getValue()));
226	2	}
227
228	3	return gmp_strval($value, 10);
229		}
230
231		/**
232		* @return bool
233		*/
234	3	public function isCoinbase()
235		{
236	3	return count($this->inputs) === 1 && $this->getInput(0)->isCoinBase();
237		}
238
239		/**
240		* @param TransactionInterface $tx
241		* @return bool
242		*/
243	3	public function equals(TransactionInterface $tx)
244		{
245	3	$version = gmp_cmp($this->version, $tx->getVersion());
246	3	if ($version !== 0) {
247	3	return false;
248		}
249
250	3	$nIn = count($this->inputs);
251	3	$nOut = count($this->outputs);
252	3	$nWit = count($this->witness);
253	3	if ($nIn !== count($tx->getInputs()) \|\| $nOut !== count($tx->getOutputs()) \|\| $nWit !== count($tx->getWitnesses())) {
254	3	return false;
255		}
256
257	3	for ($i = 0; $i < $nIn; $i++) {
258	3	if (false === $this->getInput($i)->equals($tx->getInput($i))) {
259	3	return false;
260		}
261	2	}
262
263	3	for ($i = 0; $i < $nOut; $i++) {
264	3	if (false === $this->getOutput($i)->equals($tx->getOutput($i))) {
265	3	return false;
266		}
267	2	}
268
269	3	for ($i = 0; $i < $nWit; $i++) {
270		if (false === $this->getWitness($i)->equals($tx->getWitness($i))) {
271		return false;
272		}
273		}
274
275	3	return gmp_cmp($this->lockTime, $tx->getLockTime()) === 0;
276		}
277
278		/**
279		* @return Validator
280		*/
281	27	public function validator()
282		{
283	27	return new Validator($this);
284		}
285
286		/**
287		* @return BufferInterface
288		*/
289	105	public function getBuffer()
290		{
291	105	return (new OldTransactionSerializer())->serialize($this);
292		}
293
294		/**
295		* @return BufferInterface
296		*/
297	27	public function getWitnessBuffer()
298		{
299	27	return (new TransactionSerializer())->serialize($this);
300		}
301		}
302

Bit-Wasp / bitcoin-php

Pull Request — master (#320)

Transaction::getLockTime() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like