Transaction::getLockTime() - Code Metrics - Inspection of "TransactionInterface: add getBaseSerialization & g..." - Bit-Wasp/bitcoin-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#446)

by thomas

created 2017-01-20 08:43 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	3
CRAP Score	1

Importance

Changes

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

<?php

namespace BitWasp\Bitcoin\Transaction;

use BitWasp\Bitcoin\Bitcoin;
use BitWasp\Bitcoin\Crypto\Hash;
use BitWasp\Bitcoin\Script\ScriptWitnessInterface;
use BitWasp\Bitcoin\Serializable;
use BitWasp\Bitcoin\Serializer\Transaction\TransactionSerializer;
use BitWasp\Bitcoin\Util\IntRange;
use BitWasp\Bitcoin\Utxo\Utxo;
use BitWasp\Buffertools\BufferInterface;

class Transaction extends Serializable implements TransactionInterface
{
    /**
     * @var int
     */
    private $version;

    /**
     * @var TransactionInputInterface[]
     */
    private $inputs;

    /**
     * @var TransactionOutputInterface[]
     */
    private $outputs;

    /**
     * @var ScriptWitnessInterface[]
     */
    private $witness;

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

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

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

    /**
     * Transaction constructor.
     *
     * @param int $nVersion
     * @param TransactionInputInterface[] $vin
     * @param TransactionOutputInterface[] $vout
     * @param ScriptWitnessInterface[] $vwit
     * @param int $nLockTime
     */
    public function __construct(
        $nVersion = TransactionInterface::DEFAULT_VERSION,
        array $vin = [],
        array $vout = [],
        array $vwit = [],
        $nLockTime = 0
    ) {
        if ($nVersion < IntRange::I32_MIN || $nVersion > IntRange::I32_MAX) {
            throw new \InvalidArgumentException('Transaction version is outside valid range');
        }

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

        $this->version = $nVersion;
        $this->lockTime = $nLockTime;

        $this->inputs = array_map(function (TransactionInputInterface $input) {
            return $input;
        }, $vin);
        $this->outputs = array_map(function (TransactionOutputInterface $output) {
            return $output;
        }, $vout);
        $this->witness = array_map(function (ScriptWitnessInterface $scriptWitness) {
            return $scriptWitness;
        }, $vwit);
    }

    /**
     * @return BufferInterface
     */
    public function getTxHash()
    {
        if (null === $this->hash) {
            $this->hash = Hash::sha256d($this->getBaseSerialization());
        }
        return $this->hash;
    }

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

    /**
     * @return BufferInterface
     */
    public function getWitnessTxId()
    {
        if (null === $this->wtxid) {
            $this->wtxid = Hash::sha256d($this->getBuffer())->flip();
        }

        return $this->wtxid;
    }

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

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

    /**
     * @param int $index
     * @return TransactionInputInterface
     */
    public function getInput($index)
    {
        if (!isset($this->inputs[$index])) {
            throw new \RuntimeException('No input at this index');
        }
        return $this->inputs[$index];
    }

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

    /**
     * @param int $vout
     * @return TransactionOutputInterface
     */
    public function getOutput($vout)
    {
        if (!isset($this->outputs[$vout])) {
            throw new \RuntimeException('No output at this index');
        }
        return $this->outputs[$vout];
    }

    /**
     * @return bool
     */
    public function hasWitness()
    {
        for ($l = count($this->inputs), $i = 0; $i < $l; $i++) {
            if (isset($this->witness[$i]) && count($this->witness[$i]) > 0) {
                return true;
            }
        }

        return false;
    }

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

    /**
     * @param int $index
     * @return ScriptWitnessInterface
     */
    public function getWitness($index)
    {
        if (!isset($this->witness[$index])) {
            throw new \RuntimeException('No witness at this index');
        }
        return $this->witness[$index];
    }

    /**
     * @param int $vout
     * @return OutPointInterface
     */
    public function makeOutpoint($vout)
    {
        $this->getOutput($vout);
        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 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);

        // Check the length of each field is equal
        if ($nIn !== count($tx->getInputs()) || $nOut !== count($tx->getOutputs()) || $nWit !== count($tx->getWitnesses())) {
            return false;
        }

        // Check each field
        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 BufferInterface
     */
    public function getBuffer()
    {
        return (new TransactionSerializer())->serialize($this);
    }

    /**
     * @return BufferInterface
     */
    public function getBaseSerialization()
    {
        return (new TransactionSerializer())->serialize($this, TransactionSerializer::NO_WITNESS);
    }

    /**
     * @return BufferInterface
     */
    public function getWitnessSerialization()
    {
        if (!$this->hasWitness()) {
            throw new \RuntimeException('Cannot get witness serialization for transaction without witnesses');
        }

        return $this->getBuffer();
    }

    /**
     * {@inheritdoc}
     * @see TransactionInterface::getWitnessBuffer()
     * @see TransactionInterface::getWitnessSerialization()
     * @deprecated
     */
    public function getWitnessBuffer()
    {
        return $this->getWitnessSerialization();
    }
}


1		<?php
2
3		namespace BitWasp\Bitcoin\Transaction;
4
5		use BitWasp\Bitcoin\Bitcoin;
6		use BitWasp\Bitcoin\Crypto\Hash;
7		use BitWasp\Bitcoin\Script\ScriptWitnessInterface;
8		use BitWasp\Bitcoin\Serializable;
9		use BitWasp\Bitcoin\Serializer\Transaction\TransactionSerializer;
10		use BitWasp\Bitcoin\Util\IntRange;
11		use BitWasp\Bitcoin\Utxo\Utxo;
12		use BitWasp\Buffertools\BufferInterface;
13
14		class Transaction extends Serializable implements TransactionInterface
15		{
16		/**
17		* @var int
18		*/
19		private $version;
20
21		/**
22		* @var TransactionInputInterface[]
23		*/
24		private $inputs;
25
26		/**
27		* @var TransactionOutputInterface[]
28		*/
29		private $outputs;
30
31		/**
32		* @var ScriptWitnessInterface[]
33		*/
34		private $witness;
35
36		/**
37		* @var int
38		*/
39		private $lockTime;
40
41		/**
42		* @var BufferInterface
43		*/
44		private $wtxid;
45
46		/**
47		* @var BufferInterface
48		*/
49		private $hash;
50	2914
51		/**
52		* Transaction constructor.
53		*
54		* @param int $nVersion
55		* @param TransactionInputInterface[] $vin
56		* @param TransactionOutputInterface[] $vout
57	2914	* @param ScriptWitnessInterface[] $vwit
58	6	* @param int $nLockTime
59		*/
60		public function __construct(
61	2908	$nVersion = TransactionInterface::DEFAULT_VERSION,
62	6	array $vin = [],
63		array $vout = [],
64		array $vwit = [],
65	2902	$nLockTime = 0
66	2902	) {
67		if ($nVersion < IntRange::I32_MIN \|\| $nVersion > IntRange::I32_MAX) {
68		throw new \InvalidArgumentException('Transaction version is outside valid range');
69	2698	}
70	2902
71		if ($nLockTime < 0 \|\| $nLockTime > TransactionInterface::MAX_LOCKTIME) {
72	2710	throw new \InvalidArgumentException('Locktime must be positive and less than ' . TransactionInterface::MAX_LOCKTIME);
73	2902	}
74	2902
75	2452	$this->version = $nVersion;
76	2902	$this->lockTime = $nLockTime;
77	2902
78		$this->inputs = array_map(function (TransactionInputInterface $input) {
79		return $input;
80		}, $vin);
81		$this->outputs = array_map(function (TransactionOutputInterface $output) {
82	304	return $output;
83		}, $vout);
84		$this->witness = array_map(function (ScriptWitnessInterface $scriptWitness) {
85		return $scriptWitness;
86	304	}, $vwit);
87		}
88
89		/**
90		* @return BufferInterface
91	2380	*/
92		public function getTxHash()
93	2380	{
94		if (null === $this->hash) {
95		$this->hash = Hash::sha256d($this->getBaseSerialization());
96		}
97		return $this->hash;
98		}
99	2380
100		/**
101	2380	* @return BufferInterface
102		*/
103		public function getTxId()
104		{
105		return $this->getTxHash()->flip();
106		}
107
108		/**
109		* @return BufferInterface
110		*/
111		public function getWitnessTxId()
112		{
113		if (null === $this->wtxid) {
114		$this->wtxid = Hash::sha256d($this->getBuffer())->flip();
115	2644	}
116
117	2644	return $this->wtxid;
118		}
119
120		/**
121		* @return int
122		*/
123		public function getVersion()
124		{
125	2698	return $this->version;
126		}
127	2698
128		/**
129		* Get the array of inputs in the transaction
130		*
131		* @return TransactionInputInterface[]
132		*/
133		public function getInputs()
134	262	{
135		return $this->inputs;
136	262	}
137	6
138		/**
139	256	* @param int $index
140		* @return TransactionInputInterface
141		*/
142		public function getInput($index)
143		{
144		if (!isset($this->inputs[$index])) {
145		throw new \RuntimeException('No input at this index');
146		}
147	2674	return $this->inputs[$index];
148		}
149	2674
150		/**
151		* Get Outputs
152		*
153		* @return TransactionOutputInterface[]
154		*/
155		public function getOutputs()
156	2368	{
157		return $this->outputs;
158	2368	}
159	6
160		/**
161	2362	* @param int $vout
162		* @return TransactionOutputInterface
163		*/
164		public function getOutput($vout)
165		{
166		if (!isset($this->outputs[$vout])) {
167		throw new \RuntimeException('No output at this index');
168		}
169		return $this->outputs[$vout];
170		}
171
172		/**
173		* @return bool
174		*/
175		public function hasWitness()
176		{
177		for ($l = count($this->inputs), $i = 0; $i < $l; $i++) {
178		if (isset($this->witness[$i]) && count($this->witness[$i]) > 0) {
179		return true;
180		}
181	322	}
182
183	322	return false;
184		}
185
186		/**
187		* @return ScriptWitnessInterface[]
188		*/
189		public function getWitnesses()
190	50	{
191		return $this->witness;
192	50	}
193
194		/**
195	50	* @param int $index
196		* @return ScriptWitnessInterface
197		*/
198		public function getWitness($index)
199		{
200		if (!isset($this->witness[$index])) {
201		throw new \RuntimeException('No witness at this index');
202	2296	}
203		return $this->witness[$index];
204	2296	}
205	2296
206		/**
207		* @param int $vout
208		* @return OutPointInterface
209		*/
210		public function makeOutpoint($vout)
211		{
212		$this->getOutput($vout);
213		return new OutPoint($this->getTxId(), $vout);
214		}
215
216		/**
217		* @param int $vout
218		* @return Utxo
219		*/
220		public function makeUtxo($vout)
221		{
222	2650	return new Utxo(new OutPoint($this->getTxId(), $vout), $this->getOutput($vout));
223		}
224	2650
225		/**
226		* Get Lock Time
227		*
228		* @return int
229		*/
230	6	public function getLockTime()
231		{
232	6	return $this->lockTime;
233	6	}
234	6
235	6	/**
236	3	* @return int\|string
237		*/
238	6	public function getValueOut()
239		{
240		$math = Bitcoin::getMath();
241		$value = gmp_init(0);
242		foreach ($this->outputs as $output) {
243		$value = $math->add($value, gmp_init($output->getValue()));
244	6	}
245
246	6	return gmp_strval($value, 10);
247		}
248
249		/**
250		* @return bool
251		*/
252		public function isCoinbase()
253	6	{
254		return count($this->inputs) === 1 && $this->getInput(0)->isCoinBase();
255	6	}
256	6
257	6	/**
258		* @param TransactionInterface $tx
259		* @return bool
260	6	*/
261	6	public function equals(TransactionInterface $tx)
262	6	{
263		$version = gmp_cmp($this->version, $tx->getVersion());
264		if ($version !== 0) {
265	6	return false;
266	6	}
267
268		$nIn = count($this->inputs);
269		$nOut = count($this->outputs);
270	6	$nWit = count($this->witness);
271	6
272	6	// Check the length of each field is equal
273		if ($nIn !== count($tx->getInputs()) \|\| $nOut !== count($tx->getOutputs()) \|\| $nWit !== count($tx->getWitnesses())) {
274	3	return false;
275		}
276	6
277	6	// Check each field
278	6	for ($i = 0; $i < $nIn; $i++) {
279		if (false === $this->getInput($i)->equals($tx->getInput($i))) {
280	3	return false;
281		}
282	6	}
283
284		for ($i = 0; $i < $nOut; $i++) {
285		if (false === $this->getOutput($i)->equals($tx->getOutput($i))) {
286		return false;
287		}
288	6	}
289
290		for ($i = 0; $i < $nWit; $i++) {
291		if (false === $this->getWitness($i)->equals($tx->getWitness($i))) {
292		return false;
293		}
294	2590	}
295
296	2590	return gmp_cmp($this->lockTime, $tx->getLockTime()) === 0;
297		}
298
299		/**
300		* @return BufferInterface
301		*/
302	66	public function getBuffer()
303		{
304	66	return (new TransactionSerializer())->serialize($this);
305		}
306
307		/**
308		* @return BufferInterface
309		*/
310		public function getBaseSerialization()
311		{
312		return (new TransactionSerializer())->serialize($this, TransactionSerializer::NO_WITNESS);
313		}
314
315		/**
316		* @return BufferInterface
317		*/
318		public function getWitnessSerialization()
319		{
320		if (!$this->hasWitness()) {
321		throw new \RuntimeException('Cannot get witness serialization for transaction without witnesses');
322		}
323
324		return $this->getBuffer();
325		}
326
327		/**
328		* {@inheritdoc}
329		* @see TransactionInterface::getWitnessBuffer()
330		* @see TransactionInterface::getWitnessSerialization()
331		* @deprecated
332		*/
333		public function getWitnessBuffer()
334		{
335		return $this->getWitnessSerialization();
336		}
337		}
338

Bit-Wasp / bitcoin-php

Pull Request — master (#446)

Transaction::getLockTime() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like