EthQ.php

Go to the documentation of this file.

<?php

namespace Ethereum\DataType;

/* @see https://pear.php.net/package/Math_BigInteger/docs/latest/Math_BigInteger/Math_BigInteger.html Math_BigInteger documentation */
use Math_BigInteger;


class EthQ extends EthD
{
    // Validation properties.
    private $intTypes = ['int', 'uint'];

    // @var $value Math_BigInteger Math big integer pear library.
    public $value;

    protected $abi;

    // Non not RLP encoded values have a hex padding length of 64 (strlen).
    // See:https://github.com/ethereum/wiki/wiki/RLP
    const HEXPADDING = 64;

    public function __construct($val, array $params = [])
    {
        parent::__construct($val, $params);
    }

    public function validate($val, array $params)
    {
        $big_int = null;
        $abi = isset($params['abi']) ? $params['abi'] : null;

        if ($this->hasHexPrefix($val)) {

            // All Hex strings are lowercase.
            $val = strtolower($val);

            // Some positive values are unprefixed. Enforcing left pad.
            if (strlen(self::removeHexPrefix($val)) < self::HEXPADDING) {
              $val = $this->padLeft($val);
            }

            // A negative base will encode using two's compliment.
            if ($val[2] === 'f') {
                $big_int = new Math_BigInteger($val, -16);
                $big_int->is_negative = true;
            }
            else {
                // defaults to unsigned int if no abi is given.
                $big_int = new Math_BigInteger($val, 16);
            }
        }
        elseif (is_numeric($val)) {
            if ($val < 0) {
                $big_int = new Math_BigInteger($val);
                $big_int->is_negative = true;
            }
            else {
                $big_int = new Math_BigInteger($val);
            }
        }
        if ($big_int && is_a($big_int, 'Math_BigInteger')) {

            $this->abi = $this->getAbiFromNumber($big_int);
            if ($abi) {
                // Will throw if ABI param is formally incorrect.
                $this->validateAbi($abi);

                if ($this->abi !== $abi) {

                    // Check if calculated ABI is a subset of the given API Param.
                    if ($this->getLength($this->abi) < $this->getLength($abi)) {
                        $this->abi = $abi;
                    }
                    else {
                        throw new \InvalidArgumentException(
                          'Given ABI (' . $abi . ') does not match number given number: ' . $val);
                    }
                }
            }
            return $big_int;
        }
        else {
            throw new \InvalidArgumentException('Can not decode Hex number: ' . $val);
        }
    }


    private static function padLeft(string $val)
    {
      $unprefixed = self::removeHexPrefix($val);
      $fillUp = self::HEXPADDING - (strlen($unprefixed) % self::HEXPADDING);
      return self::ensureHexPrefix(str_repeat("0", $fillUp) . $unprefixed);
    }

    protected function getAbiFromNumber(Math_BigInteger $number)
    {
        $abi_l = null;
        $negative = $number->is_negative;

        if ($negative) {
            $number = $number->multiply(new Math_BigInteger(-1));
        }

        foreach ($this->getValidLengths() as $exp) {

            $max_for_exp = new Math_BigInteger(2);
            $max_for_exp = $max_for_exp->bitwise_leftShift($exp - 1);

            // Prevent overflow See: http://ethereum.stackexchange.com/a/7294/852.
            $max_for_exp = $max_for_exp->subtract(new Math_BigInteger(1));

            if ($number->compare($max_for_exp) <= 0) {
                $abi_l = $exp;
                break;
            }
        }
        if (!$abi_l) {
            throw new \InvalidArgumentException('NOT IN RANGE: ' . $number->toString() . ' > (u)int256');
        }
        if ($negative) {
            return 'int' . $abi_l;
        }
        else {
            // Default to unsigned integer.
            return 'uint' . $abi_l;
        }
    }

    protected function validateAbi($abi)
    {
        $abiObj = $this->splitAbi($this->abiAliases($abi));
        $valid_length = in_array($abiObj->intLength, $this->getValidLengths());
        $valid_type = in_array($abiObj->intType, $this->intTypes);
        if (!($valid_length || $valid_type)) {
            throw new \InvalidArgumentException('Can not validate ABI: ' . $abi);
        }
        return true;
    }

    private static function abiAliases($abi)
    {
        // uint, int: synonyms for uint256, int256 respectively.
        if ($abi === 'int') {
            $abi = 'int256';
        }
        if ($abi === 'uint') {
            $abi = 'uint256';
        }
        return $abi;
    }

    protected static function splitAbi($abi)
    {
        $matches = [];
        $valid = null;
        // See: https://regex101.com/r/3XYumB/1
        if (preg_match('/^(u?int)(\d{1,3})$/', self::abiAliases($abi),
          $matches)) {
            return (object)[
              'abi' => $abi,
              'intType' => $matches[1],
              'intLength' => $matches[2],
            ];
        }
        else {
            throw new \InvalidArgumentException('Could not decode ABI for: ' . $abi);
        }
    }

    public function hexVal()
    {

        // Ethereum requires two's complement.
        // Math_BigInteger->toHex( [Boolean $twos_compliment = false])
        $value = $this->value->toHex($this->value->is_negative);

        if (strlen($value) > self::HEXPADDING) {
            throw new \Exception('Values > (u)int32 not supported yet: ' . $value);
        }

        // Calc padding.
        $pad = self::HEXPADDING - strlen($value);

        $fill = $this->value->is_negative ? 'f' : '0';
        $ret = '0x' . str_repeat($fill, $pad) . $value;

        return $ret;
    }

    public function hexValUnpadded()
    {
        return '0x' . $this->value->toHex($this->value->is_negative);
    }

    public function getLength($abi)
    {
        $type = $this->splitAbi($abi);

        return $type->intLength;
    }

    public function isNegative($abi = false)
    {
        if (!$abi) {
            $type = $this->splitAbi($this->abi);
        }
        else {
            $type = $abi;
        }

        if ($type->abi === 'uint') {
            return false;
        }
        else {
            return true;
        }
    }

    public function isLargeNumber(Math_BigInteger $val)
    {
        return !((string)((int)$val->toString()) === $val->toString());
    }

    public function val()
    {
        if ($this->isLargeNumber($this->value)) {
            return $this->value->toString();
        }
        else {
            return (int)$this->value->toString();
        }
    }

    public function encodedHexVal()
    {
        return $this->hexVal();
    }

    public function isNotNull()
    {
        $null = new Math_BigInteger();
        return ($this->value->compare($null) > 0 || $this->value->compare($null) < 0);
    }

    public function getAbi()
    {
        return $this->abi;
    }

    public static function getValidLengths()
    {
        $valid_lengths = "8;16;24;32;40;48;56;64;72;80;88;96;104;112;120;128;136;144;152;160;168;176;184;192;200;208;216;224;232;240;248;256";
        return explode(';', $valid_lengths);
    }

    public static function getDataLengthType()
    {
        return 'static';
    }
}