BitWasp\Bitcoin\Serializer\Key\ScriptedHierarchicalKey\NetworkHdKeyPrefixConfig

Complexity

Total Complexity

17

Size/Duplication

Total Lines	132
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

50%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	3
A	setupConfig()	0	8	1
A	checkForOverwriting()	0	14	4
A	rejectConflictPrefix()	0	10	2
A	rejectConflictScriptType()	0	7	1
A	getNetwork()	0	4	1
A	getPrefixList()	0	4	1
A	getConfigForPrefix()	0	8	2
A	getConfigForScriptType()	0	8	2

<?php

namespace BitWasp\Bitcoin\Serializer\Key\ScriptedHierarchicalKey;

use BitWasp\Bitcoin\Network\Network;
use BitWasp\Bitcoin\Network\NetworkInterface;

class NetworkHdKeyPrefixConfig
{
    /**
     * @var Network
     */
    private $network;

    /**
     * @var NetworkScriptPrefix[]
     */
    private $scriptPrefixMap = [];

    /**
     * @var NetworkScriptPrefix[]
     */
    private $scriptTypeMap = [];

    /**
     * NetworkHdKeyPrefixConfig constructor.
     * @param NetworkInterface $network
     * @param NetworkScriptPrefix[] $prefixConfigList
     */
    public function __construct(NetworkInterface $network, array $prefixConfigList)
    {
        foreach ($prefixConfigList as $config) {
            if (!($config instanceof NetworkScriptPrefix)) {
                throw new \InvalidArgumentException();
            }
            $this->setupConfig($config);
        }

        $this->network = $network;

$network is of type object<BitWasp\Bitcoin\Network\NetworkInterface>, but the property $network was declared to be of type object<BitWasp\Bitcoin\Network\Network>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

    }

    /**
     * @param NetworkScriptPrefix $config
     */
    private function setupConfig(NetworkScriptPrefix $config)
    {
        $this->checkForOverwriting($config);

        $this->scriptPrefixMap[$config->getPrivatePrefix()] = $config;
        $this->scriptPrefixMap[$config->getPublicPrefix()] = $config;
        $this->scriptTypeMap[$config->getScriptDataFactory()->getScriptType()] = $config;
    }

    /**
     * @param NetworkScriptPrefix $config
     */
    private function checkForOverwriting(NetworkScriptPrefix $config)
    {
        if (array_key_exists($config->getPublicPrefix(), $this->scriptPrefixMap)) {
            $this->rejectConflictPrefix($config, $config->getPublicPrefix());
        }

        if (array_key_exists($config->getPrivatePrefix(), $this->scriptPrefixMap)) {
            $this->rejectConflictPrefix($config, $config->getPrivatePrefix());
        }

        if (array_key_exists($config->getScriptDataFactory()->getScriptType(), $this->scriptTypeMap)) {
            $this->rejectConflictScriptType($config);
        }
    }

    /**
     * @param NetworkScriptPrefix $config
     * @param string $prefix
     */
    private function rejectConflictPrefix(NetworkScriptPrefix $config, $prefix)
    {
        $conflict = $this->scriptPrefixMap[$prefix];
        throw new \RuntimeException(sprintf(
            "A BIP32 prefix for %s conflicts with the %s BIP32 prefix of %s",
            $config->getScriptDataFactory()->getScriptType(),
            $prefix === $config->getPublicPrefix() ? "public" : "private",
            $conflict->getScriptDataFactory()->getScriptType()
        ));
    }

    /**
     * @param NetworkScriptPrefix $config
     */
    private function rejectConflictScriptType(NetworkScriptPrefix $config)
    {
        throw new \RuntimeException(sprintf(
            "The script type %s conflicts with another",
            $config->getScriptDataFactory()->getScriptType()
        ));
    }

    /**
     * @return Network
     */
    public function getNetwork()
    {
        return $this->network;
    }

    /**
     * @return NetworkScriptPrefix[]
     */
    public function getPrefixList()
    {
        return $this->scriptPrefixMap;
    }

    /**
     * @param string $prefix
     * @return NetworkScriptPrefix
     */
    public function getConfigForPrefix($prefix)
    {
        if (!array_key_exists($prefix, $this->scriptPrefixMap)) {
            throw new \InvalidArgumentException("Prefix not configured for network");
        }

        return $this->scriptPrefixMap[$prefix];
    }

    /**
     * @param string $scriptType
     * @return NetworkScriptPrefix
     */
    public function getConfigForScriptType($scriptType)
    {
        if (!array_key_exists($scriptType, $this->scriptTypeMap)) {
            throw new \InvalidArgumentException("Script type not configured for network");
        }

        return $this->scriptTypeMap[$scriptType];
    }
}