ethlite 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 782c6115c725eaefb922c2486832197ddeb44473d21d74e9b8f27de9986aef63
-  data.tar.gz: 30db801b21cc0fb703ba78908470b5e6ea9b2741768b03caf7a01bd7a772734a
+  metadata.gz: 9ee22cabcf4a413047cd733de839213fefe59ea3a45ddc353f9dd7675f416e28
+  data.tar.gz: c16a6e278a4102061f6efbf7908171ab04653108b2abd4c9d8507ab7bba46324
 SHA512:
-  metadata.gz: 3babcd1abc28ba676df94e7afe53cf3ea7880a4b69e112c85ab12b6f6d226b63424e5cebe7678e91b0c34f2ed4da6bbcf3e88eb401d9e3ac7375ef38592f4bbf
-  data.tar.gz: 34c38f561121d5ad42070b2fbadc6899cc94b1e8ecf4a6f695f71a1a5166f98211fbe572a7a0b2d9d111407ef1b4fcf7058d2f58aca81d5e1e4662b834cd7f77
+  metadata.gz: 356dd2d7d825fe42d30e94d48b58d8a737ee0cd274e1329c9425341d953e0654ac1a34d789c5f98ca52706b3f1f0702a7d4a418d758a76856410ae72f1bc1b1a
+  data.tar.gz: 0512f202e3b4eefb7a2115158036cd4e11813ef37f0b4df3a9e8269b50f90d8c2fa8d6ae6cade9caf9a49a96b30556ef28e2afa5d8debfe8d2ebf95c221b64a0

data/Manifest.txt

@@ -3,4 +3,12 @@ Manifest.txt
 README.md
 Rakefile
 lib/ethlite.rb
+lib/ethlite/abi/abi_coder.rb
+lib/ethlite/abi/constant.rb
+lib/ethlite/abi/exceptions.rb
+lib/ethlite/abi/type.rb
+lib/ethlite/abi/utils.rb
+lib/ethlite/contract.rb
+lib/ethlite/rpc.rb
+lib/ethlite/utility.rb
 lib/ethlite/version.rb

data/Rakefile

@@ -20,6 +20,8 @@ Hoe.spec 'ethlite' do
 
   self.extra_deps = [
     ['cocos'],
+    ['keccak'],
+    ['rlp'],
   ]
 
   self.licenses = ['Public Domain']

data/lib/ethlite/abi/abi_coder.rb

@@ -0,0 +1,423 @@
+
+
+module Ethlite
+  module Abi
+
+  ##
+  # Contract ABI encoding and decoding.
+  #
+  # @see https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI
+  #
+  module AbiCoder
+
+    extend self
+
+    include Constant
+
+    class EncodingError < StandardError; end
+    class DecodingError < StandardError; end
+    class ValueOutOfBounds < ValueError; end
+
+    ##
+    # Encodes multiple arguments using the head/tail mechanism.
+    #
+    def encode_abi(types, args)
+      parsed_types = types.map {|t| Type.parse(t) }
+
+      head_size = (0...args.size)
+        .map {|i| parsed_types[i].size || 32 }
+        .reduce(0, &:+)
+
+      head, tail = '', ''
+      args.each_with_index do |arg, i|
+        if parsed_types[i].dynamic?
+          head += encode_type(Type.size_type, head_size + tail.size)
+          tail += encode_type(parsed_types[i], arg)
+        else
+          head += encode_type(parsed_types[i], arg)
+        end
+      end
+
+      "#{head}#{tail}"
+    end
+    alias :encode :encode_abi
+
+    ##
+    # Encodes a single value (static or dynamic).
+    #
+    # @param type [Ethereum::ABI::Type] value type
+    # @param arg [Object] value
+    #
+    # @return [String] encoded bytes
+    #
+    def encode_type(type, arg)
+      if %w(string bytes).include?(type.base) && type.sub.empty?
+        encode_primitive_type type, arg
+      elsif type.dynamic?
+        raise ArgumentError, "arg must be an array" unless arg.instance_of?(Array)
+
+        head, tail = '', ''
+        if type.dims.last == 0
+          head += encode_type(Type.size_type, arg.size)
+        else
+          raise ArgumentError, "Wrong array size: found #{arg.size}, expecting #{type.dims.last}" unless arg.size == type.dims.last
+        end
+
+        sub_type = type.subtype
+        sub_size = type.subtype.size
+        arg.size.times do |i|
+          if sub_size.nil?
+            head += encode_type(Type.size_type, 32*arg.size + tail.size)
+            tail += encode_type(sub_type, arg[i])
+          else
+            head += encode_type(sub_type, arg[i])
+          end
+        end
+
+        "#{head}#{tail}"
+      else # static type
+        if type.dims.empty?
+          encode_primitive_type type, arg
+        else
+          arg.map {|x| encode_type(type.subtype, x) }.join
+        end
+      end
+    end
+
+    def encode_primitive_type(type, arg)
+      case type.base
+      when 'uint'
+        begin
+          real_size = type.sub.to_i
+          i = get_uint arg
+
+          raise ValueOutOfBounds, arg unless i >= 0 && i < 2**real_size
+          Utils.zpad_int i
+        rescue EncodingError
+          raise ValueOutOfBounds, arg
+        end
+      when 'bool'
+        raise ArgumentError, "arg is not bool: #{arg}" unless arg.instance_of?(TrueClass) || arg.instance_of?(FalseClass)
+        Utils.zpad_int(arg ? 1 : 0)
+      when 'int'
+        begin
+          real_size = type.sub.to_i
+          i = get_int arg
+
+          raise ValueOutOfBounds, arg unless i >= -2**(real_size-1) && i < 2**(real_size-1)
+          Utils.zpad_int(i % 2**type.sub.to_i)
+        rescue EncodingError
+          raise ValueOutOfBounds, arg
+        end
+      when 'ufixed'
+        high, low = type.sub.split('x').map(&:to_i)
+
+        raise ValueOutOfBounds, arg unless arg >= 0 && arg < 2**high
+        Utils.zpad_int((arg * 2**low).to_i)
+      when 'fixed'
+        high, low = type.sub.split('x').map(&:to_i)
+
+        raise ValueOutOfBounds, arg unless arg >= -2**(high - 1) && arg < 2**(high - 1)
+
+        i = (arg * 2**low).to_i
+        Utils.zpad_int(i % 2**(high+low))
+      when 'string'
+        if arg.encoding.name == 'UTF-8'
+          arg = arg.b
+        else
+          begin
+            arg.unpack('U*')
+          rescue ArgumentError
+            raise ValueError, "string must be UTF-8 encoded"
+          end
+        end
+
+        if type.sub.empty? # variable length type
+          raise ValueOutOfBounds, "Integer invalid or out of range: #{arg.size}" if arg.size >= TT256
+          size = Utils.zpad_int arg.size
+          value = Utils.rpad arg, BYTE_ZERO, Utils.ceil32(arg.size)
+          "#{size}#{value}"
+        else # fixed length type
+          sub = type.sub.to_i
+          raise ValueOutOfBounds, "invalid string length #{sub}" if arg.size > sub
+          raise ValueOutOfBounds, "invalid string length #{sub}" if sub < 0 || sub > 32
+          Utils.rpad(arg, BYTE_ZERO, 32)
+        end
+      when 'bytes'
+        raise EncodingError, "Expecting string: #{arg}" unless arg.instance_of?(String)
+        arg = arg.b
+
+        if type.sub.empty? # variable length type
+          raise ValueOutOfBounds, "Integer invalid or out of range: #{arg.size}" if arg.size >= TT256
+          size = Utils.zpad_int arg.size
+          value = Utils.rpad arg, BYTE_ZERO, Utils.ceil32(arg.size)
+          "#{size}#{value}"
+        else # fixed length type
+          sub = type.sub.to_i
+          raise ValueOutOfBounds, "invalid bytes length #{sub}" if arg.size > sub
+          raise ValueOutOfBounds, "invalid bytes length #{sub}" if sub < 0 || sub > 32
+          Utils.rpad(arg, BYTE_ZERO, 32)
+        end
+      when 'hash'
+        size = type.sub.to_i
+        raise EncodingError, "too long: #{arg}" unless size > 0 && size <= 32
+
+        if arg.is_a?(Integer)
+          Utils.zpad_int(arg)
+        elsif arg.size == size
+          Utils.zpad arg, 32
+        elsif arg.size == size * 2
+          Utils.zpad_hex arg
+        else
+          raise EncodingError, "Could not parse hash: #{arg}"
+        end
+      when 'address'
+        if arg.is_a?(Integer)
+          Utils.zpad_int arg
+        elsif arg.size == 20
+          Utils.zpad arg, 32
+        elsif arg.size == 40
+          Utils.zpad_hex arg
+        elsif arg.size == 42 && arg[0,2] == '0x'
+          Utils.zpad_hex arg[2..-1]
+        else
+          raise EncodingError, "Could not parse address: #{arg}"
+        end
+      else
+        raise EncodingError, "Unhandled type: #{type.base} #{type.sub}"
+      end
+    end
+
+
+    def min_data_size types
+      types.size*32
+    end
+
+    ##
+    # Decodes multiple arguments using the head/tail mechanism.
+    #
+    def decode_abi types, data, raise_errors = false
+      parsed_types = types.map {|t| Type.parse(t) }
+
+      outputs = [nil] * types.size
+      start_positions = [nil] * types.size + [data.size]
+
+      # TODO: refactor, a reverse iteration will be better
+      pos = 0
+      parsed_types.each_with_index do |t, i|
+        # If a type is static, grab the data directly, otherwise record its
+        # start position
+        if t.dynamic?
+
+          if raise_errors && pos>data.size-1
+            raise DecodingError, "Position out of bounds #{pos}>#{data.size-1}"
+          end
+
+          start_positions[i] = Utils.big_endian_to_int(data[pos, 32])
+
+          if raise_errors && start_positions[i]>data.size-1
+            raise DecodingError, "Start position out of bounds #{start_positions[i]}>#{data.size-1}"
+          end
+
+          j = i - 1
+          while j >= 0 && start_positions[j].nil?
+            start_positions[j] = start_positions[i]
+            j -= 1
+          end
+
+          pos += 32
+        else
+          outputs[i] = zero_padding data, pos, t.size, start_positions
+          pos += t.size
+        end
+      end
+
+      # We add a start position equal to the length of the entire data for
+      # convenience.
+      j = types.size - 1
+      while j >= 0 && start_positions[j].nil?
+        start_positions[j] = start_positions[types.size]
+        j -= 1
+      end
+
+      if raise_errors && pos > data.size
+        raise DecodingError, "Not enough data for head"
+      end
+
+
+      parsed_types.each_with_index do |t, i|
+        if t.dynamic?
+          offset, next_offset = start_positions[i, 2]
+          if offset<=data.size && next_offset<=data.size
+            outputs[i] = data[offset...next_offset]
+          end
+        end
+      end
+
+      if raise_errors && outputs.include?(nil)
+        raise DecodingError, "Not all data can be parsed"
+      end
+
+      parsed_types.zip(outputs).map {|(type, out)| decode_type(type, out) }
+    end
+    alias :decode :decode_abi
+
+    def zero_padding data, pos, count, start_positions
+      if pos >= data.size
+        start_positions[start_positions.size-1] += count
+        "\x00"*count
+      elsif pos + count > data.size
+        start_positions[start_positions.size-1] += ( count - (data.size-pos))
+        data[pos,data.size-pos] + "\x00"*( count - (data.size-pos))
+      else
+        data[pos, count]
+      end
+    end
+
+    def decode_typed_data type_name, data
+      decode_primitive_type Type.parse(type_name), data
+    end
+
+    def decode_type(type, arg)
+      return nil if arg.nil? || arg.empty?
+      if type.kind_of?(Tuple) && type.dims.empty?
+        arg ? decode_abi(type.types, arg) : []
+      elsif %w(string bytes).include?(type.base) && type.sub.empty?
+        l = Utils.big_endian_to_int arg[0,32]
+        data = arg[32..-1]
+        data[0, l]
+      elsif !type.dims.empty? && (l = type.dims.last)>0 # static-sized arrays
+        subtype = type.subtype
+        if subtype.dynamic?
+          start_positions = (0...l).map {|i| Utils.big_endian_to_int(arg[32*i, 32]) }
+          start_positions.push arg.size
+
+          outputs = (0...l).map {|i| arg[start_positions[i]...start_positions[i+1]] }
+
+          outputs.map {|out| decode_type(subtype, out) }
+        else
+          (0...l).map {|i| decode_type(subtype, arg[subtype.size*i, subtype.size]) }
+        end
+
+      elsif type.dynamic?
+        l = Utils.big_endian_to_int arg[0,32]
+        raise DecodingError, "Too long length: #{l}" if l>100000
+        subtype = type.subtype
+
+        if subtype.dynamic?
+          raise DecodingError, "Not enough data for head" unless arg.size >= 32 + 32*l
+
+          start_positions = (1..l).map {|i| 32+Utils.big_endian_to_int(arg[32*i, 32]) }
+          start_positions.push arg.size
+
+          outputs = (0...l).map {|i| arg[start_positions[i]...start_positions[i+1]] }
+
+          outputs.map {|out| decode_type(subtype, out) }
+        else
+          (0...l).map {|i| decode_type(subtype, arg[32 + subtype.size*i, subtype.size]) }
+        end
+
+      else
+        decode_primitive_type type, arg
+      end
+    end
+
+    def decode_primitive_type(type, data)
+      case type.base
+      when 'address'
+        Utils.encode_hex data[12..-1]
+      when 'string', 'bytes'
+        if type.sub.empty? # dynamic
+          if data.length==32
+            data[0..32]
+          else
+            size = Utils.big_endian_to_int data[0,32]
+            data[32..-1][0,size]
+          end
+        else # fixed
+          data[0, type.sub.to_i]
+        end
+      when 'hash'
+        data[(32 - type.sub.to_i), type.sub.to_i]
+      when 'uint'
+        Utils.big_endian_to_int data
+      when 'int'
+        u = Utils.big_endian_to_int data
+        u >= 2**(type.sub.to_i-1) ? (u - 2**type.sub.to_i) : u
+      when 'ufixed'
+        high, low = type.sub.split('x').map(&:to_i)
+        Utils.big_endian_to_int(data) * 1.0 / 2**low
+      when 'fixed'
+        high, low = type.sub.split('x').map(&:to_i)
+        u = Utils.big_endian_to_int data
+        i = u >= 2**(high+low-1) ? (u - 2**(high+low)) : u
+        i * 1.0 / 2**low
+      when 'bool'
+        data[-1] == BYTE_ONE
+      else
+        raise DecodingError, "Unknown primitive type: #{type.base}"
+      end
+    end
+
+    private
+
+    def get_uint(n)
+      case n
+      when Integer
+        raise EncodingError, "Number out of range: #{n}" if n > UINT_MAX || n < UINT_MIN
+        n
+      when String
+        i = if n.size == 40
+              Utils.decode_hex(n)
+            elsif n.size <= 32
+              n
+            else
+              raise EncodingError, "String too long: #{n}"
+            end
+        i = Utils.big_endian_to_int i
+
+        raise EncodingError, "Number out of range: #{i}" if i > UINT_MAX || i < UINT_MIN
+        i
+      when true
+        1
+      when false, nil
+        0
+      else
+        raise EncodingError, "Cannot decode uint: #{n}"
+      end
+    end
+
+    def get_int(n)
+      case n
+      when Integer
+        raise EncodingError, "Number out of range: #{n}" if n > INT_MAX || n < INT_MIN
+        n
+      when String
+        i = if n.size == 40
+              Utils.decode_hex(n)
+            elsif n.size <= 32
+              n
+            else
+              raise EncodingError, "String too long: #{n}"
+            end
+        i = Utils.big_endian_to_int i
+
+        i = i > INT_MAX ? (i-TT256) : i
+        raise EncodingError, "Number out of range: #{i}" if i > INT_MAX || i < INT_MIN
+        i
+      when true
+        1
+      when false, nil
+        0
+      else
+        raise EncodingError, "Cannot decode int: #{n}"
+      end
+    end
+
+  end
+
+end  # module Abi
+end  # module Ethlite
+
+
+

data/lib/ethlite/abi/constant.rb

@@ -0,0 +1,32 @@
+
+module Ethlite
+  module 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  # module Abi
+end  # module Ethlite

data/lib/ethlite/abi/exceptions.rb

@@ -0,0 +1,29 @@
+
+module Ethlite
+  module 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  # module Abi
+end  # module Ethlite

data/lib/ethlite/abi/type.rb

@@ -0,0 +1,203 @@
+module Ethlite
+  module Abi
+  class Type
+
+    class ParseError < StandardError;
+    end
+
+    class <<self
+      ##
+      # Crazy regexp to seperate out base type component (eg. uint), size (eg.
+      # 256, 128x128, nil), array component (eg. [], [45], nil)
+      #
+      def parse(type)
+
+        return parse('uint256') if type=='trcToken'
+
+        if type =~ /^\((.*)\)((\[[0-9]*\])*)/
+          return Tuple.parse $1, $2.scan(/\[[0-9]*\]/)
+        end
+
+        _, 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 'bytes', 'string'
+            raise ParseError, "Maximum 32 bytes for fixed-length string or bytes" unless sub.empty? || sub.to_i <= 32
+          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 size must be multiple of 8" unless high % 8 == 0
+            raise ParseError, "Low sizes must be 0 to 80" unless low>0 && low<=80
+          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
+
+    ##
+    # @param base [String] base name of type, e.g. uint for uint256[4]
+    # @param sub  [String] subscript of type, e.g. 256 for uint256[4]
+    # @param dims [Array[Integer]] dimensions of array type, e.g. [1,2,0]
+    #   for uint256[1][2][], [] for non-array type
+    #
+    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
+
+    ##
+    # Get the static size of a type, or nil if dynamic.
+    #
+    # @return [Integer, NilClass]  size of static type, or nil for dynamic
+    #   type
+    #
+    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
+
+    ##
+    # Type with one dimension lesser.
+    #
+    # @example
+    #   Type.parse("uint256[2][]").subtype # => Type.new('uint', 256, [2])
+    #
+    # @return [Ethereum::ABI::Type]
+    #
+    def subtype
+      @subtype ||= self.class.new(base, sub, dims[0...-1])
+    end
+
+  end
+
+  class Tuple < Type
+
+    def self.parse types, dims
+
+      depth = 0
+      collected = []
+      current = ''
+
+      types.split('').each do |c|
+        case c
+          when ',' then
+            if depth==0
+              collected << current
+              current = ''
+            else
+              current += c
+            end
+          when '(' then
+            depth += 1
+            current += c
+          when ')' then
+            depth -= 1
+            current += c
+          else
+            current += c
+        end
+
+      end
+      collected << current unless current.empty?
+
+      Tuple.new collected, dims.map {|x| x[1...-1].to_i}
+
+    end
+
+    attr_reader :types, :parsed_types
+    def initialize types, dims
+      super('tuple', '', dims)
+      @types = types
+      @parsed_types = types.map{|t| Type.parse t}
+    end
+
+    def ==(another_type)
+      another_type.kind_of?(Tuple) &&
+          another_type.types == types &&
+          another_type.dims == dims
+    end
+
+    def size
+      @size ||= calculate_size
+    end
+
+    def calculate_size
+      if dims.empty?
+        s = 0
+        parsed_types.each do |type|
+          ts = type.size
+          return nil if ts.nil?
+          s += ts
+        end
+        s
+      else
+        if dims.last == 0 # 0 for dynamic array []
+          nil
+        else
+          subtype.dynamic? ? nil : dims.last * subtype.size
+        end
+      end
+
+
+    end
+
+    def subtype
+      @subtype ||= Tuple.new(types, dims[0...-1])
+    end
+
+  end
+
+
+end  # module Abi
+end  # module Ethlite

data/lib/ethlite/abi/utils.rb

@@ -0,0 +1,223 @@
+module Ethlite
+module 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)
+      Digest::Keccak.digest(x, 256)
+    end
+
+    def keccak512(x)
+      # Digest::SHA3.new(512).digest(x)
+      Digest::Keccak.digest(x, 512)
+    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  # module Abi
+end  # module Ethlite
+

data/lib/ethlite/contract.rb

@@ -0,0 +1,64 @@
+  module Ethlite
+      class ContractMethod
+        include Utility
+
+        attr_reader :abi,
+                    :signature,
+                    :name,
+                    :signature_hash,
+                    :input_types,
+                    :output_types,
+                    :constant
+
+        def initialize( abi )
+          ## convenience helper -  auto-convert to json if string passed in
+          abi = JSON.parse( abi ) if abi.is_a?( String )
+
+          @abi            = abi
+          @name           = abi['name']
+          @constant       = !!abi['constant'] || abi['stateMutability']=='view'
+          @input_types    = abi['inputs']  ? abi['inputs'].map{|a| parse_component_type a } : []
+          @output_types   = abi['outputs'] ? abi['outputs'].map{|a| parse_component_type a } : nil
+          @signature      = Abi::Utils.function_signature( @name, @input_types )
+          @signature_hash = Abi::Utils.signature_hash( @signature, abi['type']=='event' ? 64 : 8)
+        end
+
+        def parse_component_type( argument )
+          if argument['type'] =~ /^tuple((\[[0-9]*\])*)/
+            argument['components'] ? "(#{argument['components'].collect{|c| parse_component_type( c ) }.join(',')})#{$1}"
+                                   : "()#{$1}"
+          else
+            argument['type']
+          end
+        end
+
+
+        def do_call( rpc, contract_address, args )
+          data = '0x' + @signature_hash + Abi::Utils.encode_hex(
+                                           Abi::AbiCoder.encode_abi(@input_types, args) )
+
+          method = 'eth_call'
+          params = [{ to:   contract_address,
+                      data: data},
+                    'latest']
+          response = rpc.request( method, params )
+
+
+          puts "response:"
+          pp response
+
+          string_data = [remove_0x_head(response)].pack('H*')
+          return nil if string_data.empty?
+
+          result = Abi::AbiCoder.decode_abi( @output_types, string_data )
+          puts
+          puts "result decode_abi:"
+          pp result
+
+
+          result.length==1 ? result.first : result
+        end
+
+      end  # class ContractMethod
+end  # module Ethlite
+

data/lib/ethlite/rpc.rb

@@ -0,0 +1,48 @@
+  module Ethlite
+
+    class Rpc
+      def initialize( uri )
+        @client_id = Random.rand( 10000000 )
+
+        @uri = URI.parse( uri )
+      end
+
+      def request( method, params=[] )
+        opts = {}
+        if @uri.instance_of?( URI::HTTPS )
+          opts[:use_ssl]     = true
+          opts[:verify_mode] = OpenSSL::SSL::VERIFY_NONE
+        end
+
+        Net::HTTP.start( @uri.host, @uri.port, **opts ) do |http|
+          headers = {"Content-Type" => "application/json"}
+          request = Net::HTTP::Post.new( @uri.request_uri, headers )
+
+          json = { jsonrpc: '2.0',
+                   method:  method,
+                   params:  params,
+                   id: @client_id }.to_json
+
+          puts "json POST payload:"
+          puts json
+
+          request.body = json
+          response = http.request( request )
+
+          raise "Error code #{response.code} on request #{@uri.to_s} #{request.body}" unless response.kind_of?( Net::HTTPOK )
+
+          body = JSON.parse(response.body, max_nesting: 1500)
+
+          if body['result']
+            body['result']
+          elsif body['error']
+            raise "Error #{@uri.to_s} #{body['error']} on request #{@uri.to_s} #{request.body}"
+          else
+            raise "No response on request #{@uri.to_s} #{request.body}"
+          end
+        end
+      end
+    end  # class Rpc
+
+end # module Ethlite
+

data/lib/ethlite/utility.rb

@@ -0,0 +1,23 @@
+module Ethlite
+
+    module Utility
+
+      def hex( num )
+        '0x' + num.to_s(16)
+      end
+
+      def from_hex( h )
+        h.nil? ? 0 : (h.kind_of?(String) ? h.to_i(16) : h)
+      end
+
+      def remove_0x_head( s )
+        return s if !s || s.length<2
+        s[0,2] == '0x' ? s[2..-1] : s
+      end
+
+
+      def wei_to_ether( wei )
+        1.0 * wei / 10**18
+      end
+    end
+end    # module Ethlite

data/lib/ethlite/version.rb

@@ -2,7 +2,7 @@
 
 module Ethlite
   MAJOR = 0
-  MINOR = 1
+  MINOR = 2
   PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 

data/lib/ethlite.rb

@@ -1,9 +1,37 @@
 require 'cocos'
 
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'json'
+
+
+require 'openssl'
+require 'digest'
+
+## 3rd party gems
+require 'digest/keccak'     ## gem keccak - see https://rubygems.org/gems/keccak
+require 'rlp'               ## gem rlp    - see https://rubygems.org/gems/rlp
+
+
+
 ## our own code
 require_relative 'ethlite/version'    # note: let version always go first
 
 
+require_relative 'ethlite/abi/type'
+require_relative 'ethlite/abi/constant'
+require_relative 'ethlite/abi/exceptions'
+require_relative 'ethlite/abi/utils'
+require_relative 'ethlite/abi/abi_coder'
+
+
+require_relative 'ethlite/rpc'
+
+require_relative 'ethlite/utility'
+require_relative 'ethlite/contract'
+
+
 
 ## add convenience alternate spelling
 EthLite      = Ethlite

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ethlite
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Gerald Bauer
@@ -24,6 +24,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: keccak
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rlp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -73,6 +101,14 @@ files:
 - README.md
 - Rakefile
 - lib/ethlite.rb
+- lib/ethlite/abi/abi_coder.rb
+- lib/ethlite/abi/constant.rb
+- lib/ethlite/abi/exceptions.rb
+- lib/ethlite/abi/type.rb
+- lib/ethlite/abi/utils.rb
+- lib/ethlite/contract.rb
+- lib/ethlite/rpc.rb
+- lib/ethlite/utility.rb
 - lib/ethlite/version.rb
 homepage: https://github.com/pixelartexchange/artbase
 licenses: