TxSigCreator::makeScript() - Code Metrics - Inspection of "Segwit h2" - Bit-Wasp/bitcoin-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#240)

by thomas

created 2016-02-03 14:17 UTC

TxSigCreator::makeScript() B

↳ Parent: TxSigCreator

Complexity

Conditions	6
Paths	5

Size

Total Lines	26
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	26
rs	8.439
cc	6
eloc	18
nc	5
nop	1

<?php

namespace BitWasp\Bitcoin\Transaction\Factory;

use BitWasp\Bitcoin\Crypto\EcAdapter\Adapter\EcAdapterInterface;
use BitWasp\Bitcoin\Crypto\Random\Rfc6979;
use BitWasp\Bitcoin\Key\PublicKeyFactory;
use BitWasp\Bitcoin\Script\Classifier\OutputClassifier;
use BitWasp\Bitcoin\Script\Opcodes;
use BitWasp\Bitcoin\Script\Parser\Operation;
use BitWasp\Bitcoin\Script\Script;
use BitWasp\Bitcoin\Script\ScriptFactory;
use BitWasp\Bitcoin\Script\ScriptInfo\Multisig;
use BitWasp\Bitcoin\Script\ScriptInterface;
use BitWasp\Bitcoin\Script\ScriptWitness;
use BitWasp\Bitcoin\Signature\SignatureSort;
use BitWasp\Bitcoin\Signature\TransactionSignature;
use BitWasp\Bitcoin\Signature\TransactionSignatureFactory;
use BitWasp\Bitcoin\Transaction\SignatureHash\Hasher;
use BitWasp\Bitcoin\Transaction\SignatureHash\V1Hasher;
use BitWasp\Bitcoin\Transaction\TransactionInterface;
use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PrivateKeyInterface;
use BitWasp\Buffertools\Buffer;
use BitWasp\Buffertools\BufferInterface;

class TxSigCreator
{

    /**
     * @var EcAdapterInterface
     */
    private $ecAdapter;

    /**
     * @var TransactionInterface
     */
    private $tx;

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

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

    /**
     * @var int
     */
    private $requiredSigs = 1;

    /**
     * TxSigCreator constructor.
     * @param EcAdapterInterface $adapter
     * @param TransactionInterface $tx
     * @param int $inputToSign
     * @param int $amount
     */
    public function __construct(EcAdapterInterface $adapter, TransactionInterface $tx, $inputToSign, $amount)
    {
        if (!isset($tx->getInputs()[$inputToSign])) {
            throw new \InvalidArgumentException('Input does not exist in transaction');
        }

        $this->ecAdapter = $adapter;
        $this->tx = $tx;
        $this->nInput = $inputToSign;
        $this->amount = $amount;
    }

    /**
     * @param PrivateKeyInterface $privKey
     * @param ScriptInterface $scriptPubKey
     * @param int $sigHashType
     * @param int $sigVersion
     * @return TransactionSignature
     */
    public function makeSignature(PrivateKeyInterface $privKey, ScriptInterface $scriptPubKey, $sigHashType, $sigVersion)
    {
        if ($sigVersion == 1) {
            $hasher = new V1Hasher($this->tx, $this->amount);
        } else {
            $hasher = new Hasher($this->tx);
        }

        $hash = $hasher->calculate($scriptPubKey, $this->nInput, $sigHashType);
        return new TransactionSignature(
            $this->ecAdapter,
            $this->ecAdapter->sign(
                $hash,
                $privKey,
                new Rfc6979(
                    $this->ecAdapter,
                    $privKey,
                    $hash,
                    'sha256'
                )
            ),
            $sigHashType
        );

    }

    /**
     * @param SignatureData $sigData
     * @param ScriptInterface $scriptSig
     * @param ScriptInterface|null $redeemScript
     * @return $this
     */
    public function extractSignatures(SignatureData $sigData, ScriptInterface $scriptSig, ScriptInterface $redeemScript = null)
    {
        $parsed = $scriptSig->getScriptParser()->decode();
        $size = count($parsed);
        $witnessCount = isset($this->tx->getWitnesses()[$this->nInput]) ? count($this->tx->getWitnesses()[$this->nInput]) : 0;

        $sigData->signatures = [];
        switch ($sigData->innerScriptType) {
            case OutputClassifier::PAYTOPUBKEYHASH:
                // Supply signature and public key in scriptSig
                if ($size === 2) {
                    $sigData->signatures = [TransactionSignatureFactory::fromHex($parsed[0]->getData(), $this->ecAdapter)->getBuffer()];
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    $sigData->publicKeys = [PublicKeyFactory::fromHex($parsed[1]->getData(), $this->ecAdapter)];
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                }
                break;
            case OutputClassifier::PAYTOPUBKEY:
                // Only has a signature in the scriptSig
                if ($size === 1) {
                    $sigData->signatures = [TransactionSignatureFactory::fromHex($parsed[0]->getData(), $this->ecAdapter)->getBuffer()];
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                }

                break;
            case OutputClassifier::MULTISIG:
                $info = new Multisig($redeemScript);
function notNullable(stdClass $x) { }

// Unsafe
function withoutCheck(stdClass $x = null) {
    notNullable($x);
}

// Safe - Alternative 1: Adding Additional Type-Check
function withCheck(stdClass $x = null) {
    if ($x instanceof stdClass) {
        notNullable($x);
    }
}

// Safe - Alternative 2: Changing Parameter
function withNonNullableParam(stdClass $x) {
    notNullable($x);
}
                $keyCount = $info->getKeyCount();
                $this->requiredSigs = $info->getRequiredSigCount();
                $sigData->publicKeys = $info->getKeys();
                $sigData->p2shScript = $redeemScript;
                if ($size > 2 && $size <= $keyCount + 2) {
                    $sigHash = $this->tx->getSignatureHash();
                    $sigSort = new SignatureSort($this->ecAdapter);
                    $sigs = new \SplObjectStorage;

                    foreach (array_slice($parsed, 1, -1) as $item) {
                        /** @var \BitWasp\Bitcoin\Script\Parser\Operation $item */
                        if ($item->isPush()) {
                            $txSig = TransactionSignatureFactory::fromHex($item->getData(), $this->ecAdapter);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                            $hash = $sigHash->calculate($redeemScript, $this->nInput, $txSig->getHashType());
function notNullable(stdClass $x) { }

// Unsafe
function withoutCheck(stdClass $x = null) {
    notNullable($x);
}

// Safe - Alternative 1: Adding Additional Type-Check
function withCheck(stdClass $x = null) {
    if ($x instanceof stdClass) {
        notNullable($x);
    }
}

// Safe - Alternative 2: Changing Parameter
function withNonNullableParam(stdClass $x) {
    notNullable($x);
}
                            $linked = $sigSort->link([$txSig->getSignature()], $sigData->publicKeys, $hash);

                            foreach ($sigData->publicKeys as $key) {
                                if ($linked->contains($key)) {
                                    $sigs[$key] = $txSig->getBuffer();
                                }
                            }
                        }
                    }

                    // We have all the signatures from the input now. array_shift the sigs for a public key, as it's encountered.
                    foreach ($sigData->publicKeys as $idx => $key) {
                        $sigData->signatures[$idx] = isset($sigs[$key]) ? $sigs[$key]->getBuffer() : null;
                    }
                }

                break;
            case OutputClassifier::WITNESS_V0_KEYHASH:
                if ($witnessCount === 2) {
                    $witness = $this->tx->getWitness($this->nInput);
                    $sigData->signatures = [TransactionSignatureFactory::fromHex($witness[0]->getData(), $this->ecAdapter)->getBuffer()];
                    $sigData->publicKeys = [PublicKeyFactory::fromHex($witness[1]->getData(), $this->ecAdapter)];
                    $sigData->p2shScript = $redeemScript;
                }
        }

        return $this;
    }

    private function signStep($txoType, SignatureData $sigData, PrivateKeyInterface $privateKey, ScriptInterface $scriptPubKey, $sigVersion, $sigHashType)
    {
        if (count($sigData->signatures) < $this->requiredSigs) {
            if ($txoType === OutputClassifier::MULTISIG) {
                foreach ($sigData->publicKeys as $keyIdx => $publicKey) {
                    if ($publicKey->getBinary() == $privateKey->getPublicKey()->getBinary()) {
                        $sigData->signatures[$keyIdx] = $this->makeSignature($privateKey, $scriptPubKey, $sigHashType, $sigVersion);
                    }
                }

                return true;
            }

            if ($txoType === OutputClassifier::PAYTOPUBKEY) {
                $publicKey = PublicKeyFactory::fromHex($sigData->solution[0]);
                if ($publicKey !== $privateKey->getPublicKey()) {
                    return false;
                }
            }

            if ($txoType === OutputClassifier::PAYTOPUBKEYHASH) {
                $publicKey = $privateKey->getPublicKey();
                if ($publicKey->getPubKeyHash()->getBinary() != $sigData->solution->getBinary()) {
                    return false;
                }

                $sigData->publicKeys[0] = $publicKey;
            }

            if ($sigData->scriptType === OutputClassifier::WITNESS_V0_KEYHASH) {
                $publicKey = $privateKey->getPublicKey();
                if ($publicKey->getPubKeyHash()->getBinary() !== $sigData->solution->getBinary()) {
                    return false;
                }

                $scriptPubKey = ScriptFactory::sequence([Opcodes::OP_DUP, Opcodes::OP_HASH160, $sigData->solution, Opcodes::OP_EQUALVERIFY, Opcodes::OP_CHECKSIG]);
                $sigData->publicKeys[0] = $publicKey;
            }

            $sigData->signatures[0] = $this->makeSignature($privateKey, $scriptPubKey, $sigHashType, $sigVersion)->getBuffer();
        }

        return true;
    }

    /**
     * @param SignatureData $sigData
     * @param PrivateKeyInterface $privateKey
     * @param ScriptInterface $scriptPubKey
     * @param int $sigHashType
     * @return $this|bool
     */
    public function signInput(SignatureData $sigData, PrivateKeyInterface $privateKey, ScriptInterface $scriptPubKey, $sigHashType)
    {
        if ($sigData->scriptType !== OutputClassifier::UNKNOWN) {
            $scriptType = $sigData->scriptType;
            $sigVersion = 0;
            if ($scriptType === OutputClassifier::PAYTOSCRIPTHASH) {
                $scriptType = $sigData->innerScriptType;
            }

            if ($scriptType === OutputClassifier::WITNESS_V0_SCRIPTHASH || $scriptType === OutputClassifier::WITNESS_V0_KEYHASH) {
                $sigVersion = 1;
            }

            if ($scriptType === OutputClassifier::MULTISIG ||
                $scriptType === OutputClassifier::PAYTOPUBKEY ||
                $scriptType === OutputClassifier::PAYTOPUBKEYHASH ||
                $scriptType === OutputClassifier::WITNESS_V0_KEYHASH) {

                $this->signStep($scriptType, $sigData, $privateKey, $scriptPubKey, $sigHashType, $sigVersion);
            }
        }

        return true;
    }

    /**
     * @param SignatureData $sigData
     * @return ScriptInterface
     */
    private function makeScript(SignatureData $sigData)
    {
        $script = ScriptFactory::create();

        if (count($sigData->signatures) === $this->requiredSigs) {
            echo 'signed';
            switch ($sigData->innerScriptType) {
                case OutputClassifier::PAYTOPUBKEY:
                    $script->push($sigData->signatures[0]);
                    break;
                case OutputClassifier::PAYTOPUBKEYHASH:
                    $script->sequence([$sigData->signatures[0], $sigData->publicKeys[0]->getBuffer()]);
                    break;
                case OutputClassifier::MULTISIG:
                    $sequence = [Opcodes::OP_0];
                    foreach ($sigData->signatures as $sig) {
                        $sequence[] = $sig->getBuffer();

                    }

                    $script->sequence($sequence);
                    break;
            }
        }

        return $script->getScript();
    }

    public function serializeSig(SignatureData $sigData, & $scriptWitness = null)
    {
        $script = $this->makeScript($sigData);

        if ($sigData->scriptType === OutputClassifier::PAYTOSCRIPTHASH) {
            $sig = $script->getBuffer();
            $pushScript = $sigData->p2shScript;
            if ($sigData->innerScriptType === OutputClassifier::WITNESS_V0_KEYHASH) {
                $sig = new Buffer();
            }

            if ($sigData->innerScriptType === OutputClassifier::WITNESS_V0_SCRIPTHASH) {
                $sig = new Buffer();
            }

            $script = ScriptFactory::create($sig)
                ->push($pushScript->getBuffer())
                ->getScript();
        }

        if ($sigData->innerScriptType === OutputClassifier::WITNESS_V0_KEYHASH) {
            $script = new Script(); // Required, otherwise we introduce malleability.
            $values = $sigData->signatures;
            $values[] = $sigData->publicKeys[0]->getBuffer();
            $scriptWitness = new ScriptWitness($values);
        }

        return $script;
    }
}


1			<?php
2
3			namespace BitWasp\Bitcoin\Transaction\Factory;
4
5			use BitWasp\Bitcoin\Crypto\EcAdapter\Adapter\EcAdapterInterface;
6			use BitWasp\Bitcoin\Crypto\Random\Rfc6979;
7			use BitWasp\Bitcoin\Key\PublicKeyFactory;
8			use BitWasp\Bitcoin\Script\Classifier\OutputClassifier;
9			use BitWasp\Bitcoin\Script\Opcodes;
10			use BitWasp\Bitcoin\Script\Parser\Operation;
11			use BitWasp\Bitcoin\Script\Script;
12			use BitWasp\Bitcoin\Script\ScriptFactory;
13			use BitWasp\Bitcoin\Script\ScriptInfo\Multisig;
14			use BitWasp\Bitcoin\Script\ScriptInterface;
15			use BitWasp\Bitcoin\Script\ScriptWitness;
16			use BitWasp\Bitcoin\Signature\SignatureSort;
17			use BitWasp\Bitcoin\Signature\TransactionSignature;
18			use BitWasp\Bitcoin\Signature\TransactionSignatureFactory;
19			use BitWasp\Bitcoin\Transaction\SignatureHash\Hasher;
20			use BitWasp\Bitcoin\Transaction\SignatureHash\V1Hasher;
21			use BitWasp\Bitcoin\Transaction\TransactionInterface;
22			use BitWasp\Bitcoin\Crypto\EcAdapter\Key\PrivateKeyInterface;
23			use BitWasp\Buffertools\Buffer;
24			use BitWasp\Buffertools\BufferInterface;
25
26			class TxSigCreator
27			{
28
29			/**
30			* @var EcAdapterInterface
31			*/
32			private $ecAdapter;
33
34			/**
35			* @var TransactionInterface
36			*/
37			private $tx;
38
39			/**
40			* @var int
41			*/
42			private $nInput;
43
44			/**
45			* @var int
46			*/
47			private $amount;
48
49			/**
50			* @var int
51			*/
52			private $requiredSigs = 1;
53
54			/**
55			* TxSigCreator constructor.
56			* @param EcAdapterInterface $adapter
57			* @param TransactionInterface $tx
58			* @param int $inputToSign
59			* @param int $amount
60			*/
61			public function __construct(EcAdapterInterface $adapter, TransactionInterface $tx, $inputToSign, $amount)
62			{
63			if (!isset($tx->getInputs()[$inputToSign])) {
64			throw new \InvalidArgumentException('Input does not exist in transaction');
65			}
66
67			$this->ecAdapter = $adapter;
68			$this->tx = $tx;
69			$this->nInput = $inputToSign;
70			$this->amount = $amount;
71			}
72
73			/**
74			* @param PrivateKeyInterface $privKey
75			* @param ScriptInterface $scriptPubKey
76			* @param int $sigHashType
77			* @param int $sigVersion
78			* @return TransactionSignature
79			*/
80			public function makeSignature(PrivateKeyInterface $privKey, ScriptInterface $scriptPubKey, $sigHashType, $sigVersion)
81			{
82			if ($sigVersion == 1) {
83			$hasher = new V1Hasher($this->tx, $this->amount);
84			} else {
85			$hasher = new Hasher($this->tx);
86			}
87
88			$hash = $hasher->calculate($scriptPubKey, $this->nInput, $sigHashType);
89			return new TransactionSignature(
90			$this->ecAdapter,
91			$this->ecAdapter->sign(
92			$hash,
93			$privKey,
94			new Rfc6979(
95			$this->ecAdapter,
96			$privKey,
97			$hash,
98			'sha256'
99			)
100			),
101			$sigHashType
102			);
103
104			}
105
106			/**
107			* @param SignatureData $sigData
108			* @param ScriptInterface $scriptSig
109			* @param ScriptInterface\|null $redeemScript
110			* @return $this
111			*/
112			public function extractSignatures(SignatureData $sigData, ScriptInterface $scriptSig, ScriptInterface $redeemScript = null)
113			{
114			$parsed = $scriptSig->getScriptParser()->decode();
115			$size = count($parsed);
116			$witnessCount = isset($this->tx->getWitnesses()[$this->nInput]) ? count($this->tx->getWitnesses()[$this->nInput]) : 0;
117
118			$sigData->signatures = [];
119			switch ($sigData->innerScriptType) {
120			case OutputClassifier::PAYTOPUBKEYHASH:
121			// Supply signature and public key in scriptSig
122			if ($size === 2) {
123			$sigData->signatures = [TransactionSignatureFactory::fromHex($parsed[0]->getData(), $this->ecAdapter)->getBuffer()];
			0 ignored issues – show Documentation introduced 2016-02-03 15:30 UTC by Report Bug Copy Issue Report `$parsed[0]->getData()` is of type `object<BitWasp\Buffertools\BufferInterface>`, but the function expects a `object<BitWasp\Buffertools\Buffer>\|string`. 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...
124			$sigData->publicKeys = [PublicKeyFactory::fromHex($parsed[1]->getData(), $this->ecAdapter)];
			0 ignored issues – show Documentation introduced 2016-02-03 15:30 UTC by Report Bug Copy Issue Report `$parsed[1]->getData()` is of type `object<BitWasp\Buffertools\BufferInterface>`, but the function expects a `object<BitWasp\Buffertools\Buffer>\|string`. 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...
125			}
126			break;
127			case OutputClassifier::PAYTOPUBKEY:
128			// Only has a signature in the scriptSig
129			if ($size === 1) {
130			$sigData->signatures = [TransactionSignatureFactory::fromHex($parsed[0]->getData(), $this->ecAdapter)->getBuffer()];
			0 ignored issues – show Documentation introduced 2016-02-03 15:30 UTC by Report Bug Copy Issue Report `$parsed[0]->getData()` is of type `object<BitWasp\Buffertools\BufferInterface>`, but the function expects a `object<BitWasp\Buffertools\Buffer>\|string`. 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...
131			}
132
133			break;
134			case OutputClassifier::MULTISIG:
135			$info = new Multisig($redeemScript);
			0 ignored issues – show Bug introduced 2016-02-03 15:30 UTC by Report Bug Copy Issue Report It seems like `$redeemScript` defined by parameter `$redeemScript` on line `112` can be `null`; however, `BitWasp\Bitcoin\Script\S...Multisig::__construct()` does not accept `null`, maybe add an additional type check? It seems like you allow that null is being passed for a parameter, however the function which is called does not seem to accept null. We recommend to add an additional type check (or disallow null for the parameter): function notNullable(stdClass $x) { } // Unsafe function withoutCheck(stdClass $x = null) { notNullable($x); } // Safe - Alternative 1: Adding Additional Type-Check function withCheck(stdClass $x = null) { if ($x instanceof stdClass) { notNullable($x); } } // Safe - Alternative 2: Changing Parameter function withNonNullableParam(stdClass $x) { notNullable($x); } Loading history...
136			$keyCount = $info->getKeyCount();
137			$this->requiredSigs = $info->getRequiredSigCount();
138			$sigData->publicKeys = $info->getKeys();
139			$sigData->p2shScript = $redeemScript;
140			if ($size > 2 && $size <= $keyCount + 2) {
141			$sigHash = $this->tx->getSignatureHash();
142			$sigSort = new SignatureSort($this->ecAdapter);
143			$sigs = new \SplObjectStorage;
144
145			foreach (array_slice($parsed, 1, -1) as $item) {
146			/** @var \BitWasp\Bitcoin\Script\Parser\Operation $item */
147			if ($item->isPush()) {
148			$txSig = TransactionSignatureFactory::fromHex($item->getData(), $this->ecAdapter);
			0 ignored issues – show Documentation introduced 2016-02-03 15:30 UTC by Report Bug Copy Issue Report `$item->getData()` is of type `object<BitWasp\Buffertools\BufferInterface>`, but the function expects a `object<BitWasp\Buffertools\Buffer>\|string`. 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...
149			$hash = $sigHash->calculate($redeemScript, $this->nInput, $txSig->getHashType());
			0 ignored issues – show Bug introduced 2016-02-03 15:30 UTC by Report Bug Copy Issue Report It seems like `$redeemScript` defined by parameter `$redeemScript` on line `112` can be `null`; however, `BitWasp\Bitcoin\Transact...sh\SigHash::calculate()` does not accept `null`, maybe add an additional type check? It seems like you allow that null is being passed for a parameter, however the function which is called does not seem to accept null. We recommend to add an additional type check (or disallow null for the parameter): function notNullable(stdClass $x) { } // Unsafe function withoutCheck(stdClass $x = null) { notNullable($x); } // Safe - Alternative 1: Adding Additional Type-Check function withCheck(stdClass $x = null) { if ($x instanceof stdClass) { notNullable($x); } } // Safe - Alternative 2: Changing Parameter function withNonNullableParam(stdClass $x) { notNullable($x); } Loading history...
150			$linked = $sigSort->link([$txSig->getSignature()], $sigData->publicKeys, $hash);
151
152			foreach ($sigData->publicKeys as $key) {
153			if ($linked->contains($key)) {
154			$sigs[$key] = $txSig->getBuffer();
155			}
156			}
157			}
158			}
159
160			// We have all the signatures from the input now. array_shift the sigs for a public key, as it's encountered.
161			foreach ($sigData->publicKeys as $idx => $key) {
162			$sigData->signatures[$idx] = isset($sigs[$key]) ? $sigs[$key]->getBuffer() : null;
163			}
164			}
165
166			break;
167			case OutputClassifier::WITNESS_V0_KEYHASH:
168			if ($witnessCount === 2) {
169			$witness = $this->tx->getWitness($this->nInput);
170			$sigData->signatures = [TransactionSignatureFactory::fromHex($witness[0]->getData(), $this->ecAdapter)->getBuffer()];
171			$sigData->publicKeys = [PublicKeyFactory::fromHex($witness[1]->getData(), $this->ecAdapter)];
172			$sigData->p2shScript = $redeemScript;
173			}
174			}
175
176			return $this;
177			}
178
179			private function signStep($txoType, SignatureData $sigData, PrivateKeyInterface $privateKey, ScriptInterface $scriptPubKey, $sigVersion, $sigHashType)
180			{
181			if (count($sigData->signatures) < $this->requiredSigs) {
182			if ($txoType === OutputClassifier::MULTISIG) {
183			foreach ($sigData->publicKeys as $keyIdx => $publicKey) {
184			if ($publicKey->getBinary() == $privateKey->getPublicKey()->getBinary()) {
185			$sigData->signatures[$keyIdx] = $this->makeSignature($privateKey, $scriptPubKey, $sigHashType, $sigVersion);
186			}
187			}
188
189			return true;
190			}
191
192			if ($txoType === OutputClassifier::PAYTOPUBKEY) {
193			$publicKey = PublicKeyFactory::fromHex($sigData->solution[0]);
194			if ($publicKey !== $privateKey->getPublicKey()) {
195			return false;
196			}
197			}
198
199			if ($txoType === OutputClassifier::PAYTOPUBKEYHASH) {
200			$publicKey = $privateKey->getPublicKey();
201			if ($publicKey->getPubKeyHash()->getBinary() != $sigData->solution->getBinary()) {
202			return false;
203			}
204
205			$sigData->publicKeys[0] = $publicKey;
206			}
207
208			if ($sigData->scriptType === OutputClassifier::WITNESS_V0_KEYHASH) {
209			$publicKey = $privateKey->getPublicKey();
210			if ($publicKey->getPubKeyHash()->getBinary() !== $sigData->solution->getBinary()) {
211			return false;
212			}
213
214			$scriptPubKey = ScriptFactory::sequence([Opcodes::OP_DUP, Opcodes::OP_HASH160, $sigData->solution, Opcodes::OP_EQUALVERIFY, Opcodes::OP_CHECKSIG]);
215			$sigData->publicKeys[0] = $publicKey;
216			}
217
218			$sigData->signatures[0] = $this->makeSignature($privateKey, $scriptPubKey, $sigHashType, $sigVersion)->getBuffer();
219			}
220
221			return true;
222			}
223
224			/**
225			* @param SignatureData $sigData
226			* @param PrivateKeyInterface $privateKey
227			* @param ScriptInterface $scriptPubKey
228			* @param int $sigHashType
229			* @return $this\|bool
230			*/
231			public function signInput(SignatureData $sigData, PrivateKeyInterface $privateKey, ScriptInterface $scriptPubKey, $sigHashType)
232			{
233			if ($sigData->scriptType !== OutputClassifier::UNKNOWN) {
234			$scriptType = $sigData->scriptType;
235			$sigVersion = 0;
236			if ($scriptType === OutputClassifier::PAYTOSCRIPTHASH) {
237			$scriptType = $sigData->innerScriptType;
238			}
239
240			if ($scriptType === OutputClassifier::WITNESS_V0_SCRIPTHASH \|\| $scriptType === OutputClassifier::WITNESS_V0_KEYHASH) {
241			$sigVersion = 1;
242			}
243
244			if ($scriptType === OutputClassifier::MULTISIG \|\|
245			$scriptType === OutputClassifier::PAYTOPUBKEY \|\|
246			$scriptType === OutputClassifier::PAYTOPUBKEYHASH \|\|
247			$scriptType === OutputClassifier::WITNESS_V0_KEYHASH) {
248
249			$this->signStep($scriptType, $sigData, $privateKey, $scriptPubKey, $sigHashType, $sigVersion);
250			}
251			}
252
253			return true;
254			}
255
256			/**
257			* @param SignatureData $sigData
258			* @return ScriptInterface
259			*/
260			private function makeScript(SignatureData $sigData)
261			{
262			$script = ScriptFactory::create();
263
264			if (count($sigData->signatures) === $this->requiredSigs) {
265			echo 'signed';
266			switch ($sigData->innerScriptType) {
267			case OutputClassifier::PAYTOPUBKEY:
268			$script->push($sigData->signatures[0]);
269			break;
270			case OutputClassifier::PAYTOPUBKEYHASH:
271			$script->sequence([$sigData->signatures[0], $sigData->publicKeys[0]->getBuffer()]);
272			break;
273			case OutputClassifier::MULTISIG:
274			$sequence = [Opcodes::OP_0];
275			foreach ($sigData->signatures as $sig) {
276			$sequence[] = $sig->getBuffer();
			0 ignored issues – show Bug introduced 2016-02-03 15:30 UTC by Report Bug Copy Issue Report The method `getBuffer()` does not seem to exist on `object<BitWasp\Buffertools\BufferInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
277			}
278
279			$script->sequence($sequence);
280			break;
281			}
282			}
283
284			return $script->getScript();
285			}
286
287			public function serializeSig(SignatureData $sigData, & $scriptWitness = null)
288			{
289			$script = $this->makeScript($sigData);
290
291			if ($sigData->scriptType === OutputClassifier::PAYTOSCRIPTHASH) {
292			$sig = $script->getBuffer();
293			$pushScript = $sigData->p2shScript;
294			if ($sigData->innerScriptType === OutputClassifier::WITNESS_V0_KEYHASH) {
295			$sig = new Buffer();
296			}
297
298			if ($sigData->innerScriptType === OutputClassifier::WITNESS_V0_SCRIPTHASH) {
299			$sig = new Buffer();
300			}
301
302			$script = ScriptFactory::create($sig)
303			->push($pushScript->getBuffer())
304			->getScript();
305			}
306
307			if ($sigData->innerScriptType === OutputClassifier::WITNESS_V0_KEYHASH) {
308			$script = new Script(); // Required, otherwise we introduce malleability.
309			$values = $sigData->signatures;
310			$values[] = $sigData->publicKeys[0]->getBuffer();
311			$scriptWitness = new ScriptWitness($values);
312			}
313
314			return $script;
315			}
316			}
317

Bit-Wasp / bitcoin-php

Pull Request — master (#240)

TxSigCreator::makeScript() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like