web3-hpb 0.0.2

data/lib/web3/hpb/abi/constant.rb

@@ -0,0 +1,30 @@
+# -*- encoding : ascii-8bit -*-
+
+module Web3::Hpb::Abi
+  module Constant
+
+    BYTE_EMPTY = "".freeze
+    BYTE_ZERO  = "\x00".freeze
+    BYTE_ONE   = "\x01".freeze
+
+    TT32   = 2**32
+    TT40   = 2**40
+    TT160  = 2**160
+    TT256  = 2**256
+    TT64M1 = 2**64 - 1
+
+    UINT_MAX = 2**256 - 1
+    UINT_MIN = 0
+    INT_MAX  = 2**255 - 1
+    INT_MIN  = -2**255
+
+    HASH_ZERO = ("\x00"*32).freeze
+
+    PUBKEY_ZERO = ("\x00"*32).freeze
+    PRIVKEY_ZERO = ("\x00"*32).freeze
+    PRIVKEY_ZERO_HEX = ('0'*64).freeze
+
+    CONTRACT_CODE_SIZE_LIMIT = 0x6000
+
+  end
+end

data/lib/web3/hpb/abi/exceptions.rb

@@ -0,0 +1,28 @@
+# -*- encoding : ascii-8bit -*-
+
+module Web3::Hpb::Abi
+
+  class DeprecatedError < StandardError; end
+  class ChecksumError < StandardError; end
+  class FormatError < StandardError; end
+  class ValidationError < StandardError; end
+  class ValueError < StandardError; end
+  class AssertError < StandardError; end
+
+  class UnknownParentError < StandardError; end
+  class InvalidBlock < ValidationError; end
+  class InvalidUncles < ValidationError; end
+
+  class InvalidTransaction < ValidationError; end
+  class UnsignedTransactionError < InvalidTransaction; end
+  class InvalidNonce < InvalidTransaction; end
+  class InsufficientStartGas < InvalidTransaction; end
+  class InsufficientBalance < InvalidTransaction; end
+  class BlockGasLimitReached < InvalidTransaction; end
+
+  class InvalidSPVProof < ValidationError; end
+
+  class ContractCreationFailed < StandardError; end
+  class TransactionFailed < StandardError; end
+
+end

data/lib/web3/hpb/abi/type.rb

@@ -0,0 +1,90 @@
+# -*- encoding : ascii-8bit -*-
+
+module Web3::Hpb::Abi
+  class Type
+
+    class ParseError < StandardError;
+    end
+
+    class << self
+
+      def parse(type)
+        _, base, sub, dimension = /([a-z]*)([0-9]*x?[0-9]*)((\[[0-9]*\])*)/.match(type).to_a
+
+        dims = dimension.scan(/\[[0-9]*\]/)
+        raise ParseError, "Unknown characters found in array declaration" if dims.join != dimension
+
+        case base
+        when ''
+          return parse 'address'
+        when 'string'
+          raise ParseError, "String type must have no suffix or numerical suffix" unless sub.empty?
+        when 'uint', 'int'
+          raise ParseError, "Integer type must have numerical suffix" unless sub =~ /\A[0-9]+\z/
+
+          size = sub.to_i
+          raise ParseError, "Integer size out of bounds" unless size >= 8 && size <= 256
+          raise ParseError, "Integer size must be multiple of 8" unless size % 8 == 0
+        when 'fixed', 'ufixed'
+          raise ParseError, "Fixed type must have suffix of form <high>x<low>, e.g. 128x128" unless sub =~ /\A[0-9]+x[0-9]+\z/
+
+          high, low = sub.split('x').map(&:to_i)
+          total = high + low
+          raise ParseError, "Fixed size out of bounds (max 32 bytes)" unless total >= 8 && total <= 256
+          raise ParseError, "Fixed high/low sizes must be multiples of 8" unless high % 8 == 0 && low % 8 == 0
+        when 'hash'
+          raise ParseError, "Hash type must have numerical suffix" unless sub =~ /\A[0-9]+\z/
+        when 'address'
+          raise ParseError, "Address cannot have suffix" unless sub.empty?
+        when 'bool'
+          raise ParseError, "Bool cannot have suffix" unless sub.empty?
+        else
+          raise ParseError, "Unrecognized type base: #{base}"
+        end
+
+        new(base, sub, dims.map{ |x| x[1...-1].to_i })
+      end
+
+      def size_type
+        @size_type ||= new('uint', 256, [])
+      end
+    end
+
+    attr :base, :sub, :dims
+
+    def initialize(base, sub, dims)
+      @base = base
+      @sub = sub
+      @dims = dims
+    end
+
+    def ==(another_type)
+      base == another_type.base && sub == another_type.sub && dims == another_type.dims
+    end
+
+    def size
+      @size ||= if dims.empty?
+                  if %w(string bytes).include?(base) && sub.empty?
+                    nil
+                  else
+                    32
+                  end
+                else
+                  if dims.last == 0 # 0 for dynamic array []
+                    nil
+                  else
+                    subtype.dynamic? ? nil : dims.last * subtype.size
+                  end
+                end
+
+    end
+
+    def dynamic?
+      size.nil?
+    end
+
+    def subtype
+      @subtype ||= self.class.new(base, sub, dims[0...-1])
+    end
+  end
+end

data/lib/web3/hpb/abi/utils.rb

@@ -0,0 +1,224 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'digest'
+require 'digest/sha3'
+require 'openssl'
+require 'rlp'
+
+module Web3::Hpb::Abi
+  module Utils
+
+    extend self
+
+    include Constant
+
+    ##
+    # Not the keccak in sha3, although it's underlying lib named SHA3
+    #
+    def keccak256(x)
+      Digest::SHA3.new(256).digest(x)
+    end
+
+    def keccak512(x)
+      Digest::SHA3.new(512).digest(x)
+    end
+
+    def keccak256_rlp(x)
+      keccak256 RLP.encode(x)
+    end
+
+    def sha256(x)
+      Digest::SHA256.digest x
+    end
+
+    def double_sha256(x)
+      sha256 sha256(x)
+    end
+
+    def ripemd160(x)
+      Digest::RMD160.digest x
+    end
+
+    def hash160(x)
+      ripemd160 sha256(x)
+    end
+
+    def hash160_hex(x)
+      encode_hex hash160(x)
+    end
+
+    def mod_exp(x, y, n)
+      x.to_bn.mod_exp(y, n).to_i
+    end
+
+    def mod_mul(x, y, n)
+      x.to_bn.mod_mul(y, n).to_i
+    end
+
+    def to_signed(i)
+      i > Constant::INT_MAX ? (i-Constant::TT256) : i
+    end
+
+    def base58_check_to_bytes(s)
+      leadingzbytes = s.match(/\A1*/)[0]
+      data = Constant::BYTE_ZERO * leadingzbytes.size + BaseConvert.convert(s, 58, 256)
+
+      raise ChecksumError, "double sha256 checksum doesn't match" unless double_sha256(data[0...-4])[0,4] == data[-4..-1]
+      data[1...-4]
+    end
+
+    def bytes_to_base58_check(bytes, magicbyte=0)
+      bs = "#{magicbyte.chr}#{bytes}"
+      leadingzbytes = bs.match(/\A#{Constant::BYTE_ZERO}*/)[0]
+      checksum = double_sha256(bs)[0,4]
+      '1'*leadingzbytes.size + BaseConvert.convert("#{bs}#{checksum}", 256, 58)
+    end
+
+    def ceil32(x)
+      x % 32 == 0 ? x : (x + 32 - x%32)
+    end
+
+    def encode_hex(b)
+      RLP::Utils.encode_hex b
+    end
+
+    def decode_hex(s)
+      RLP::Utils.decode_hex s
+    end
+
+    def big_endian_to_int(s)
+      RLP::Sedes.big_endian_int.deserialize s.sub(/\A(\x00)+/, '')
+    end
+
+    def int_to_big_endian(n)
+      RLP::Sedes.big_endian_int.serialize n
+    end
+
+    def lpad(x, symbol, l)
+      return x if x.size >= l
+      symbol * (l - x.size) + x
+    end
+
+    def rpad(x, symbol, l)
+      return x if x.size >= l
+      x + symbol * (l - x.size)
+    end
+
+    def zpad(x, l)
+      lpad x, BYTE_ZERO, l
+    end
+
+    def zunpad(x)
+      x.sub /\A\x00+/, ''
+    end
+
+    def zpad_int(n, l=32)
+      zpad encode_int(n), l
+    end
+
+    def zpad_hex(s, l=32)
+      zpad decode_hex(s), l
+    end
+
+    def int_to_addr(x)
+      zpad_int x, 20
+    end
+
+    def encode_int(n)
+      raise ArgumentError, "Integer invalid or out of range: #{n}" unless n.is_a?(Integer) && n >= 0 && n <= UINT_MAX
+      int_to_big_endian n
+    end
+
+    def decode_int(v)
+      raise ArgumentError, "No leading zero bytes allowed for integers" if v.size > 0 && (v[0] == Constant::BYTE_ZERO || v[0] == 0)
+      big_endian_to_int v
+    end
+
+    def bytearray_to_int(arr)
+      o = 0
+      arr.each {|x| o = (o << 8) + x }
+      o
+    end
+
+    def int_array_to_bytes(arr)
+      arr.pack('C*')
+    end
+
+    def bytes_to_int_array(bytes)
+      bytes.unpack('C*')
+    end
+
+    def coerce_to_int(x)
+      if x.is_a?(Numeric)
+        x
+      elsif x.size == 40
+        big_endian_to_int decode_hex(x)
+      else
+        big_endian_to_int x
+      end
+    end
+
+    def coerce_to_bytes(x)
+      if x.is_a?(Numeric)
+        int_to_big_endian x
+      elsif x.size == 40
+        decode_hex(x)
+      else
+        x
+      end
+    end
+
+    def coerce_addr_to_hex(x)
+      if x.is_a?(Numeric)
+        encode_hex zpad(int_to_big_endian(x), 20)
+      elsif x.size == 40 || x.size == 0
+        x
+      else
+        encode_hex zpad(x, 20)[-20..-1]
+      end
+    end
+
+    def normalize_address(x, allow_blank: false)
+      address = Address.new(x)
+      raise ValueError, "address is blank" if !allow_blank && address.blank?
+      address.to_bytes
+    end
+
+    def mk_contract_address(sender, nonce)
+      keccak256_rlp([normalize_address(sender), nonce])[12..-1]
+    end
+
+    def mk_metropolis_contract_address(sender, initcode)
+      keccak256(normalize_address(sender) + initcode)[12..-1]
+    end
+
+
+    def parse_int_or_hex(s)
+      if s.is_a?(Numeric)
+        s
+      elsif s[0,2] == '0x'
+        big_endian_to_int decode_hex(normalize_hex_without_prefix(s))
+      else
+        s.to_i
+      end
+    end
+
+    def normalize_hex_without_prefix(s)
+      if s[0,2] == '0x'
+        (s.size % 2 == 1 ? '0' : '') + s[2..-1]
+      else
+        s
+      end
+    end
+
+    def function_signature method_name, arg_types
+      "#{method_name}(#{arg_types.join(',')})"
+    end
+
+    def signature_hash signature, length=64
+      encode_hex(keccak256(signature))[0...length]
+    end
+
+
+  end
+end

data/lib/web3/hpb/block.rb

@@ -0,0 +1,32 @@
+module Web3
+
+  module Hpb
+
+    class Block
+
+      include Web3::Hpb::Utility
+
+      attr_reader :raw_data
+
+      def initialize(block_data)
+        @raw_data =  block_data
+
+        block_data.each do |k, v|
+          self.instance_variable_set("@#{k}", v)
+          self.class.send(:define_method, k, proc {self.instance_variable_get("@#{k}")})
+        end
+
+        @transactions = @transactions.collect { |t| Web3::Hpb::Transaction.new(t)}
+      end
+
+      def timestamp_time
+        Time.at(from_hex timestamp )
+      end
+
+      def block_number
+        from_hex(number)
+      end
+
+    end
+  end
+end

data/lib/web3/hpb/call_trace.rb

@@ -0,0 +1,87 @@
+module Web3
+  module Hpb
+
+    class CallTrace
+
+      include Web3::Hpb::Utility
+
+      attr_reader :raw_data
+
+      def initialize trace_data
+        @raw_data = trace_data
+
+        trace_data.each do |k, v|
+          self.instance_variable_set("@#{k}", v)
+          self.class.send(:define_method, k, proc {self.instance_variable_get("@#{k}")})
+        end
+
+      end
+
+      def value_wei
+        from_hex action['value']
+      end
+
+      def value_hpb
+        wei_to_hpb from_hex action['value']
+      end
+
+      def from
+        action['from']
+      end
+
+      def to
+        action['to']
+      end
+
+      def input
+        action['input'] || action['init']
+      end
+
+      def output
+        result && result['output']
+      end
+
+      def gas_used
+        result && from_hex(result['gasUsed'])
+      end
+
+      def method_hash
+        if input && input.length>=10
+          input[2...10]
+        else
+          nil
+        end
+      end
+
+      def creates
+        action && result && action['init'] && result['address']
+      end
+
+      # suffix # 0xa1 0x65 'b' 'z' 'z' 'r' '0' 0x58 0x20 <32 bytes swarm hash> 0x00 0x29
+      # look http://solidity.readthedocs.io/en/latest/metadata.html for details
+      def call_input_data
+        if creates && input
+          input[/a165627a7a72305820\w{64}0029(\w*)/,1]
+        elsif input && input.length>10
+          input[10..input.length]
+        else
+          []
+        end
+      end
+
+
+      def suicide?
+        type=='suicide'
+      end
+
+      def balance_hpb
+        wei_to_hpb action['balance'].to_i(16)
+      end
+
+      def success?
+        !raw_data['error']
+      end
+
+    end
+  end
+end