Blocktrail\SDK\WalletScript

Complexity

Total Complexity

33

Size/Duplication

Total Lines	195
Duplicated Lines	0 %

Coupling/Cohesion

Components	4
Dependencies	8

Test Coverage

Coverage

0%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	enforceScriptChecks()	0	3	1
B	__construct()	0	23	6
A	checkP2shScript()	0	14	4
B	checkWitnessScript()	0	21	9
A	checkScript()	0	18	4
A	getScriptPubKey()	0	3	1
A	isP2SH()	0	3	1
A	isP2WSH()	0	3	1
A	getWitnessScript()	0	6	2
A	getRedeemScript()	0	6	2
A	getAddress()	0	6	2

<?php

namespace Blocktrail\SDK;

use BitWasp\Bitcoin\Address\AddressInterface;
use BitWasp\Bitcoin\Script\Classifier\OutputClassifier;
use BitWasp\Bitcoin\Script\P2shScript;
use BitWasp\Bitcoin\Script\ScriptInterface;
use BitWasp\Bitcoin\Script\ScriptType;
use BitWasp\Bitcoin\Script\WitnessProgram;
use BitWasp\Bitcoin\Script\WitnessScript;
use BitWasp\Buffertools\BufferInterface;
use Blocktrail\SDK\Bitcoin\BIP32Path;
use Blocktrail\SDK\Exceptions\BlocktrailSDKException;

class WalletScript
{
    const DEFAULT_SHOULD_CHECK = false;

    /**
     * @var null|bool
     */
    protected static $checkScripts;

    /**
     * @var \BitWasp\Bitcoin\Address\AddressInterface|null
     */
    private $address;

    /**
     * @var ScriptInterface
     */
    private $spk;

    /**
     * @var P2shScript|null
     */
    private $redeemScript;

    /**
     * @var WitnessScript|null
     */
    private $witnessScript;

    /**
     * @var BIP32Path
     */
    private $path;

    /**
     * Disables script checking (procedure includes some hashing)
     * @param bool $setting
     */
    public static function enforceScriptChecks($setting) {
        static::$checkScripts = (bool) $setting;
    }

    /**
     * WalletScript constructor.
     * @param BIP32Path $path
     * @param ScriptInterface $spk
     * @param P2shScript|null $redeemScript
     * @param WitnessScript|null $witnessScript
     */
    public function __construct(
        BIP32Path $path,
        ScriptInterface $spk,
        P2shScript $redeemScript = null,
        WitnessScript $witnessScript = null,
        AddressInterface $address = null
    ) {
        if (static::$checkScripts || null === static::$checkScripts && self::DEFAULT_SHOULD_CHECK) {
            $this->checkScript($path[2], $spk, $redeemScript, $witnessScript);
        }

        $this->path = $path;
        $this->spk = $spk;
        $this->redeemScript = $redeemScript;
        $this->witnessScript = $witnessScript;

        if ($address) {
            if (!$address->getScriptPubKey()->equals($this->getScriptPubKey())) {
                throw new BlocktrailSDKException("Mismatch between scriptPubKey and address");
            }
            $this->address = $address;
        }
    }

    /**
     * @param OutputClassifier $classifier
     * @param ScriptInterface $script
     * @param P2shScript|null $redeemScript
     */
    protected function checkP2shScript(OutputClassifier $classifier, ScriptInterface $script, P2shScript $redeemScript = null) {
        $scriptHash = null;
        if (!($classifier->classify($script, $scriptHash) === ScriptType::P2SH)) {
            throw new \RuntimeException("scriptPubKey should be script-hash");
        }
        /** @var BufferInterface $scriptHash */
        if (null === $redeemScript) {
            throw new \RuntimeException("Missing redeemScript");
        }

        if (!$redeemScript->getScriptHash()->equals($scriptHash)) {
            throw new \RuntimeException("Invalid redeemScript for scriptPubKey");
        }
    }

    /**
     * @param ScriptInterface $script
     * @param WitnessScript|null $witnessScript
     */
    protected function checkWitnessScript(ScriptInterface $script, WitnessScript $witnessScript = null) {
        if (!$script->isWitness($wp)) {
            $errSuffix = $script instanceof P2shScript ? "P2SH script" : "Script";
            throw new \RuntimeException("$errSuffix should be v0_scripthash");
        }

        /** @var WitnessProgram $wp */
        if ($wp->getProgram()->getSize() !== 32) {
            $errSuffix = $script instanceof P2shScript ? "P2SH script" : "Script";
            throw new \RuntimeException("$errSuffix should be v0_scripthash");
        }

        if (null === $witnessScript) {
            $errSuffix = $script instanceof P2shScript ? "P2SH script" : "script";
            throw new \RuntimeException("Missing witnessScript for $errSuffix");
        }

        if (null === $witnessScript || !$wp->getProgram()->equals($witnessScript->getScriptHash())) {
            throw new \RuntimeException("Invalid witnessScript for p2sh v0_scripthash");
        }
    }

    /**
     * @param int $scriptId
     * @param ScriptInterface $script
     * @param P2shScript|null $redeemScript
     * @param WitnessScript|null $witnessScript
     */
    protected function checkScript($scriptId, ScriptInterface $script, P2shScript $redeemScript = null, WitnessScript $witnessScript = null) {
        $classifier = new OutputClassifier();
        switch ($scriptId) {
            case 2:
                $this->checkP2shScript($classifier, $script, $redeemScript);
                $this->checkWitnessScript($redeemScript, $witnessScript);

It seems like $redeemScript defined by parameter $redeemScript on line 141 can be null; however, Blocktrail\SDK\WalletScript::checkWitnessScript() does not accept null, maybe add an additional type check?

                if (!$classifier->isMultisig($witnessScript)) {

It seems like $witnessScript defined by parameter $witnessScript on line 141 can be null; however, BitWasp\Bitcoin\Script\Classifier\OutputClassifier::isMultisig() does not accept null, maybe add an additional type check?

                    throw new \RuntimeException("Expected multisig as witnessScript");
                }
                break;
            default:
                $this->checkP2shScript($classifier, $script, $redeemScript);
                if (!$classifier->isMultisig($redeemScript)) {

It seems like $redeemScript defined by parameter $redeemScript on line 141 can be null; however, BitWasp\Bitcoin\Script\Classifier\OutputClassifier::isMultisig() does not accept null, maybe add an additional type check?

                    throw new \RuntimeException("Expected multisig as redeemScript");
                }
                break;
        }
    }

    /**
     * @return ScriptInterface
     */
    public function getScriptPubKey() {
        return $this->spk;
    }

    /**
     * @return bool
     */
    public function isP2SH() {
        return $this->redeemScript instanceof P2shScript;
    }

    /**
     * @return bool
     */
    public function isP2WSH() {
        return $this->witnessScript instanceof WitnessScript;
    }

    /**
     * @return WitnessScript|null
     */
    public function getWitnessScript() {
        if (null === $this->witnessScript) {
            throw new \RuntimeException("WitnessScript not set");
        }
        return $this->witnessScript;
    }

    /**
     * @return P2shScript|null
     */
    public function getRedeemScript() {
        if (null === $this->redeemScript) {
            throw new \RuntimeException("RedeemScript not set");
        }
        return $this->redeemScript;
    }

    /**
     * @return AddressInterface|null
     */
    public function getAddress() {
        if (null === $this->address) {
            throw new \RuntimeException("This script has no address");
        }
        return $this->address;
    }
}