BitWasp\Bitcoin\Transaction\SignatureHash\V1Hasher

Complexity

Total Complexity

16

Size/Duplication

Total Lines	125
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

90%

Importance

Changes	4
Bugs	0	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	hashPrevOuts()	0	12	3
B	hashSequences()	0	12	5
B	hashOutputs()	0	14	6
A	calculate()	0	23	1

<?php

namespace BitWasp\Bitcoin\Transaction\SignatureHash;

use BitWasp\Bitcoin\Crypto\Hash;
use BitWasp\Bitcoin\Script\ScriptFactory;
use BitWasp\Bitcoin\Transaction\TransactionInterface;
use BitWasp\Buffertools\Buffer;
use BitWasp\Buffertools\BufferInterface;
use BitWasp\Bitcoin\Script\ScriptInterface;

class V1Hasher
{
    /**
     * @var TransactionInterface
     */
    private $transaction;

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

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

    /**
     * @var int|string
     */
    private $amount;

    /**
     * V1Hasher constructor.
     * @param TransactionInterface $transaction
     * @param int|string $amount
     */
    public function __construct(TransactionInterface $transaction, $amount)
    {
        $this->transaction = $transaction;
        $this->nInputs = count($this->transaction->getInputs());
        $this->nOutputs = count($this->transaction->getOutputs());
        $this->amount = $amount;
    }

    /**
     * @param int $sighashType
     * @return Buffer|BufferInterface
     */
    public function hashPrevOuts($sighashType)
    {
        if (!($sighashType & SigHash::ANYONECANPAY)) {
            $binary = '';
            foreach ($this->transaction->getInputs() as $input) {
                $binary .= $input->getOutPoint()->getBinary();
            }
            return Hash::sha256d(new Buffer($binary));
        }

        return new Buffer('', 32);
    }

    /**
     * @param int $sighashType
     * @return Buffer|BufferInterface
     */
    public function hashSequences($sighashType)
    {
        if (!($sighashType & SigHash::ANYONECANPAY) && ($sighashType & 0x1f) != SigHash::SINGLE && ($sighashType & 0x1f) != SigHash::NONE) {
            $binary = '';
            foreach ($this->transaction->getInputs() as $input) {
                $binary .= Buffer::int($input->getSequence())->flip()->getBinary();
            }
            return Hash::sha256d(new Buffer($binary));
        }

        return new Buffer('', 32);
    }

    /**
     * @param int $sighashType
     * @param int $inputToSign
     * @return Buffer|BufferInterface
     */
    public function hashOutputs($sighashType, $inputToSign)
    {
        if (($sighashType & 0x1f) !== SigHash::SINGLE && ($sighashType & 0x1f) != SigHash::NONE) {
            $binary = '';
            foreach ($this->transaction->getOutputs() as $output) {
                $binary .= $output->getBinary();
            }
            return Hash::sha256d(new Buffer($binary));
        } elseif (($sighashType & 0x1f) == SigHash::SINGLE && $inputToSign < count($this->transaction->getOutputs())) {
            return Hash::sha256($this->transaction->getOutput($inputToSign)->getBuffer());
        }

        return new Buffer('', 32);
    }

    /**
     * Calculate the hash of the current transaction, when you are looking to
     * spend $txOut, and are signing $inputToSign. The SigHashType defaults to
     * SIGHASH_ALL, though SIGHASH_SINGLE, SIGHASH_NONE, SIGHASH_ANYONECANPAY
     * can be used.
     *
     * @param ScriptInterface $txOutScript
     * @param int $inputToSign
     * @param int $sighashType
     * @return BufferInterface
     * @throws \Exception
     */
    public function calculate(ScriptInterface $txOutScript, $inputToSign, $sighashType = SigHash::ALL)
    {
        $sighashType = (int) $sighashType;

        $hashPrevOuts = $this->hashPrevOuts($sighashType);
        $hashSequence = $this->hashSequences($sighashType);
        $hashOutputs = $this->hashOutputs($sighashType, $inputToSign);

        $input = $this->transaction->getInput($inputToSign);

        return Hash::sha256d(new Buffer(
            pack("V", $this->transaction->getVersion()) .
            $hashPrevOuts->getBinary() .
            $hashSequence->getBinary() .
            $input->getOutPoint()->getBinary() .
            ScriptFactory::create()->push($txOutScript->getBuffer())->getScript()->getBinary() .
            Buffer::int($this->amount, 8)->flip()->getBinary() .
            pack("V", $input->getSequence()) .
            $hashOutputs->getBinary() .
            pack("V", $this->transaction->getLockTime()) .
            pack("V", $sighashType)
        ));
    }
}