ethlite 0.1.0 → 0.2.1

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,227 @@
+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)
+      Digest::Keccak256.digest( x )
+    end
+
+=begin
+  ## check where required / in use - what for?
+    def keccak512(x)
+      # Digest::SHA3.new(512).digest(x)
+      Digest::Keccak.digest(x, 512)
+    end
+=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,8 +2,8 @@
 
 module Ethlite
   MAJOR = 0
-  MINOR = 1
-  PATCH = 0
+  MINOR = 2
+  PATCH = 1
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/lib/ethlite.rb

@@ -1,9 +1,40 @@
 require 'cocos'
 
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'json'
+
+
+require 'openssl'
+require 'digest'
+
+## 3rd party gems
+require 'rlp'               ## gem rlp    - see https://rubygems.org/gems/rlp
+
+##  bundled require 'digest/keccak'     ## gem keccak - see https://rubygems.org/gems/keccak
+require 'digest/keccak256'
+
+
+
+
 ## 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.1
 platform: ruby
 authors:
 - Gerald Bauer
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !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
@@ -72,7 +86,17 @@ files:
 - Manifest.txt
 - README.md
 - Rakefile
+- lib/digest/keccak256.rb
+- lib/digest/sha3.rb
 - 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: