BitWasp\Bitcoin\Networking\Peer\ConnectionParams

Complexity

Total Complexity

24

Size/Duplication

Total Lines	219
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

95%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	getRequiredServices()	0	4	1
A	requestTxRelay()	0	9	2
A	setBestBlockHeight()	0	5	1
A	setBestBlockHeightCallback()	0	5	1
A	setProtocolVersion()	0	5	1
A	setLocalIp()	0	5	1
A	setLocalPort()	0	5	1
A	setLocalServices()	0	5	1
A	setLocalNetAddr()	0	7	1
A	setTimestamp()	0	5	1
A	setRequiredServices()	0	5	1
A	setUserAgent()	0	9	2
D	produceVersion()	0	26	10

<?php

namespace BitWasp\Bitcoin\Networking\Peer;

use BitWasp\Bitcoin\Networking\Ip\IpInterface;
use BitWasp\Bitcoin\Networking\Ip\Ipv4;
use BitWasp\Bitcoin\Networking\Messages\Factory as MsgFactory;
use BitWasp\Bitcoin\Networking\Messages\Version;
use BitWasp\Bitcoin\Networking\Services;
use BitWasp\Bitcoin\Networking\Structure\NetworkAddress;
use BitWasp\Bitcoin\Networking\Structure\NetworkAddressInterface;
use BitWasp\Buffertools\Buffer;

class ConnectionParams
{
    protected $defaultUserAgent = 'bitcoin-php';
    protected $defaultProtocolVersion = '70000';
    protected $defaultTxRelay = false;
    protected $defaultBlockHeight = '0';
    protected $defaultLocalIp = '0.0.0.0';
    protected $defaultLocalPort = '0';

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

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

    /**
     * @var bool
     */
    private $txRelay;

    /**
     * @var callable
     */
    private $bestBlockHeightCallback;

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

    /**
     * @var string
     */
    private $localIp;

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

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

    /**
     * @var string
     */
    private $userAgent;

    /**
     * @var int
     */
    private $requiredServices = 0;

    /**
     * @param bool $optRelay
     * @return $this
     */
    public function requestTxRelay($optRelay = true)
    {
        if (!is_bool($optRelay)) {
            throw new \InvalidArgumentException('Invalid txrelay setting, must be a boolean');
        }

        $this->txRelay = $optRelay;
        return $this;
    }

    /**
     * @param int $blockHeight
     * @return $this
     */
    public function setBestBlockHeight($blockHeight)
    {
        $this->bestBlockHeight = $blockHeight;
        return $this;
    }

    /**
     * @param callable $callable
     * @return $this
     */
    public function setBestBlockHeightCallback(callable $callable)
    {
        $this->bestBlockHeightCallback = $callable;
        return $this;
    }

    /**
     * @param int $version
     * @return $this
     */
    public function setProtocolVersion($version)
    {
        $this->protocolVersion = $version;
        return $this;
    }

    /**
     * @param IpInterface $ip
     * @return $this
     */
    public function setLocalIp(IpInterface $ip)
    {
        $this->localIp = $ip;

It seems like $ip of type object<BitWasp\Bitcoin\Networking\Ip\IpInterface> is incompatible with the declared type string of property $localIp.

        return $this;
    }

    /**
     * @param int $port
     * @return $this
     */
    public function setLocalPort($port)
    {
        $this->localPort = $port;
        return $this;
    }

    /**
     * @param int $services
     * @return $this
     */
    public function setLocalServices($services)
    {
        $this->localServices = $services;
        return $this;
    }

    /**
     * @param NetworkAddressInterface $networkAddress
     * @return $this
     */
    public function setLocalNetAddr(NetworkAddressInterface $networkAddress)
    {
        return $this
            ->setLocalIp($networkAddress->getIp())
            ->setLocalPort($networkAddress->getPort())
            ->setLocalServices($networkAddress->getServices());
    }

    /**
     * @param int $timestamp
     * @return $this
     */
    public function setTimestamp($timestamp)
    {
        $this->timestamp = $timestamp;
        return $this;
    }

    /**
     * @param int $services
     * @return $this
     */
    public function setRequiredServices($services)
    {
        $this->requiredServices = $services;
        return $this;
    }

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

    /**
     * @param string $string
     * @return $this
     */
    public function setUserAgent($string)
    {
        if (!is_string($string)) {
            throw new \InvalidArgumentException('User agent must be a string');
        }

        $this->userAgent = new Buffer($string);

It seems like new \BitWasp\Buffertools\Buffer($string) of type object<BitWasp\Buffertools\Buffer> is incompatible with the declared type string of property $userAgent.

        return $this;
    }

    /**
     * @param MsgFactory $messageFactory
     * @param NetworkAddressInterface $remoteAddress
     * @return Version
     */
    public function produceVersion(MsgFactory $messageFactory, NetworkAddressInterface $remoteAddress)
    {
        $protocolVersion = is_null($this->protocolVersion) ? $this->defaultProtocolVersion : $this->protocolVersion;
        $localServices = is_null($this->localServices) ? Services::NONE : $this->localServices;
        $timestamp = is_null($this->timestamp) ? time() : $this->timestamp;
        $localAddr = new NetworkAddress(
            $localServices,
            is_null($this->localIp) ? new Ipv4($this->defaultLocalIp) : $this->localIp,

It seems like is_null($this->localIp) ? new \BitWasp\Bitcoin\Networking\Ip\Ipv4($this->defaultLocalIp) : $this->localIp can also be of type string; however, BitWasp\Bitcoin\Networking\Structure\NetworkAddress::__construct() does only seem to accept object<BitWasp\Bitcoin\Networking\Ip\IpInterface>, maybe add an additional type check?

            is_null($this->localPort) ? $this->defaultLocalPort : $this->localPort
        );

        $userAgent = is_null($this->userAgent) ? new Buffer($this->defaultUserAgent) : $this->userAgent;

        if (is_callable($this->bestBlockHeightCallback)) {
            $cb = $this->bestBlockHeightCallback;
            $bestHeight = $cb();
        } elseif (!is_null($this->bestBlockHeight)) {
            $bestHeight = $this->bestBlockHeight;
        } else {
            $bestHeight = $this->defaultBlockHeight;
        }

        $relay = is_null($this->txRelay) ? $this->defaultTxRelay : $this->txRelay;

        return $messageFactory->version($protocolVersion, $localServices, $timestamp, $remoteAddress, $localAddr, $userAgent, $bestHeight, $relay);

It seems like $userAgent defined by is_null($this->userAgent) ? new \BitWasp\Buffertools\Buffer($this->defaultUserAgent) : $this->userAgent on line 217 can also be of type string; however, BitWasp\Bitcoin\Networking\Messages\Factory::version() does only seem to accept object<BitWasp\Buffertools\BufferInterface>, maybe add an additional type check?

    }
}