ethlite 0.4.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a168744cd8aa2f76a80e7536064f8d831f3cbcef3e9148687c7f003403415d97
-  data.tar.gz: 711fa922a92492be4ef33317a552de466a3f4b9e32428d80e6a79d55fc1b3f6d
+  metadata.gz: 783bf5485da84a9532d36a9285b08b7ebc6e8266b4c431ce623d4720ffefbaf4
+  data.tar.gz: 71e360e28ee30b99ee44accb575c56a6c6b08eb349ec257576dfa4cbb79982f8
 SHA512:
-  metadata.gz: 9465a3704789b0c377e7dd7db33f7675bb2230b011f7792c9758bf4b72723b55516e18e594b897d015e4b5326f80359e0c7a5eecaaff1f957c5d9f354a2b827d
-  data.tar.gz: 0fb31c94e3810430d01573dbb951787e34a8824a2d0ba2bc4305ea306c5258260bd189ab8a84b817c1260a6b1d5b978bc99b48a543390eec586c59a56726c583
+  metadata.gz: 77e14ee4da005f731958fc5c889d71c59aff89c9a565dec0ea58c0bd56562ba4d8cdf696182a58051a0201b95254ce28a2e4281459976dc0e8c650beeb53b0d7
+  data.tar.gz: b3d9aadf29db07b1afdd53c780a59947d94d0667b070ba0edf45097c3c65f76a492289a2b9f21a20f8a0dc62ea3a0b630d686cdd15f795e18355f32956e78ad9

data/Manifest.txt

@@ -3,9 +3,6 @@ Manifest.txt
 README.md
 Rakefile
 lib/ethlite.rb
-lib/ethlite/abi/codec.rb
-lib/ethlite/abi/type.rb
-lib/ethlite/constant.rb
 lib/ethlite/contract.rb
 lib/ethlite/utils.rb
 lib/ethlite/version.rb

data/README.md

@@ -64,7 +64,7 @@ def eth_call( rpc,
   ## binary encode method sig(nature)
   signature      = "#{name}(#{inputs.join(',')})"
   signature_hash =  Ethlite::Utils.encode_hex(
-                        Ethlite::Utils.keccak256(signature))[0..7]
+                        Ethlite::Utils.keccak256(signature)[0,4])
 
   pp signature
   # => "tokenURI(uint256)"
@@ -73,7 +73,7 @@ def eth_call( rpc,
 
   ## binary encode method arg(ument)s
   args_encoded = Ethlite::Utils.encode_hex(
-                   Ethlite::Abi.encode_abi( inputs, args) )
+                   ABI.encode( inputs, args) )
 
   data = '0x' + signature_hash + args_encoded
 
@@ -90,10 +90,9 @@ def eth_call( rpc,
   puts "response:"
   pp response
 
-  ## decode binary result
-  string_data = Ethlite::Utils.decode_hex(
-                     Ethlite::Utils.remove_0x_head(response))
-  result = Ethlite::Abi.decode_abi( outputs, string_data )
+  ## decode binary result (returned as a hex string starting with 0x)
+  bin = Ethlite::Utils.decode_hex( response )
+  result =  ABI.decode( outputs, bin )
   result.length  == 1 ? result[0] : result
 end
 ```

data/Rakefile

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

data/lib/ethlite/contract.rb

@@ -1,31 +1,6 @@
   module Ethlite
       class ContractMethod
 
-       def self.parse_abi( abi )
-         ## convenience helper -  auto-convert to json if string passed in
-         abi = JSON.parse( abi ) if abi.is_a?( String )
-
-         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 ) } : []
-
-         new( name, inputs: input_types,
-                    outputs: output_types,
-                    constant: constant )
-       end
-
-       def self._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
-
-
-
 
         attr_reader :signature,
                     :name,
@@ -34,21 +9,25 @@
                     :output_types,
                     :constant
 
-        def initialize( name, inputs:,
+        def initialize( name, inputs:   [],
                               outputs:  [],
                               constant: true )
           @name         = name
           @constant     = constant
-          @input_types  = inputs
-          @output_types = outputs
-          @signature      = "#{@name}(#{@input_types.join(',')})"
-          @signature_hash = Utils.signature_hash( @signature, 8 )
+
+          ##  parse inputs & outputs into types
+          @input_types  = inputs.map { |str| ABI::Type.parse( str ) }
+          @output_types = outputs.map { |str| ABI::Type.parse( str ) }
+
+          types = @input_types.map {|type| type.format }.join(',')
+          @signature      = "#{@name}(#{types})"
+          @signature_hash = Utils.encode_hex( Utils.keccak256( @signature)[0,4] )
         end
 
 
         def do_call( rpc, contract_address, args )
           data = '0x' + @signature_hash + Utils.encode_hex(
-                                           Abi.encode_abi(@input_types, args) )
+                                           ABI.encode(@input_types, args) )
 
           method = 'eth_call'
           params = [{ to:   contract_address,
@@ -56,23 +35,30 @@
                     'latest']
           response = rpc.request( method, params )
 
+          if debug?
+            puts "response:"
+            pp response
+          end
 
-          puts "response:"
-          pp response
+          bin = Utils.decode_hex( response )
+          return nil    if bin.empty?
 
-          string_data = Utils.decode_hex(
-                           Utils.remove_0x_head(response))
-          return nil if string_data.empty?
+          result = ABI.decode( @output_types, bin )
 
-          result = Abi.decode_abi( @output_types, string_data )
-          puts
-          puts "result decode_abi:"
-          pp result
 
+          if debug?
+            puts
+            puts "result decode_abi:"
+            pp result
+          end
 
           result.length==1 ? result.first : result
         end
 
+        ####
+        # private helpers
+        def debug?()  Ethlite.debug?;  end   ## forward to global Ethlite config
       end  # class ContractMethod
+
 end  # module Ethlite
 

data/lib/ethlite/utils.rb

@@ -1,225 +1,36 @@
 module Ethlite
 
 
-module UtilHelper
-    ##
-    # Not the keccak in sha3, although it's underlying lib named SHA3
-    #
-    def keccak256(x)
+module Helpers
+    def keccak256( bin )
       # Digest::SHA3.new(256).digest(x)
       ## Digest::Keccak.digest(x, 256)
-      Digest::KeccakLite.new(256).digest( x )
+      Digest::KeccakLite.new(256).digest( bin )
     end
 
-    ## todo/check where required / in use - what for?
-    def keccak512(x)
-      # Digest::SHA3.new(512).digest(x)
-      # Digest::Keccak.digest(x, 512)
-      Digest::KeccakLite.new(512).digest( x )
+    def encode_hex( bin )   ## bin_to_hex
+      raise TypeError, "Value must be a string" unless bin.is_a?( String )
+      ## note: always return a hex string with default encoding e.g. utf-8 - why? why not?
+      bin.unpack("H*").first.force_encoding( Encoding::UTF_8 )
     end
+    alias_method :bin_to_hex, :encode_hex
 
+    def decode_hex( hex )   ## hex_to_bin
+      raise TypeError, "Value must be a string" unless hex.is_a?( String )
+      raise TypeError, 'Non-hexadecimal char found' unless hex.empty? || hex =~ /\A(0x)?[0-9a-fA-F]{2,}\z/
 
-    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 > INT_MAX ? (i-TT256) : i
-    end
-
-
-    def ceil32(x)
-      x % 32 == 0 ? x : (x + 32 - x%32)
-    end
-
-    def encode_hex(b)
-      raise TypeError, "Value must be an instance of String" unless b.instance_of?(String)
-      b.unpack("H*").first
-    end
-
-    def decode_hex(str)
-      raise TypeError, "Value must be an instance of string" unless str.instance_of?(String)
-      raise TypeError, 'Non-hexadecimal digit found' unless str =~ /\A[0-9a-fA-F]*\z/
-      [str].pack("H*")
-    end
-
-
-
-
-    def int_to_big_endian(n)
-      RLP::Sedes.big_endian_int.serialize n
-    end
-
-    def big_endian_to_int(s)
-      RLP::Sedes.big_endian_int.deserialize s.sub(/\A(\x00)+/, '')
-    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] == BYTE_ZERO || v[0] == 0)
-      big_endian_to_int v
-    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 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
+      ## allow optional starting 0x - why? why not?
+      hex = hex[2..-1]   if hex[0,2] == '0x'
 
-
-    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 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
-
-
-=begin
-  ## add? moved over from the old 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
-=end
-
-
-    def remove_0x_head( s )
-      return s if !s || s.length<2
-      s[0,2] == '0x' ? s[2..-1] : s
+      [hex].pack("H*")
     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 signature_hash( signature, length=8 )
-      encode_hex( keccak256(signature) )[0...length]
-    end
-
-end  # module UtilHelper
+    alias_method :hex_to_bin, :decode_hex
+end  # module Helpers
 
 
 
 module Utils
-   extend UtilHelper
+   extend Helpers
 end
 
 end  # module Ethlite

data/lib/ethlite/version.rb

@@ -1,9 +1,9 @@
 
 
 module Ethlite
-  MAJOR = 0
-  MINOR = 4
-  PATCH = 1
+  MAJOR = 1
+  MINOR = 0
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/lib/ethlite.rb

@@ -19,18 +19,14 @@ end
 load_env
 
 
-require 'uri'
-require 'net/http'
-require 'net/https'
-require 'json'
-
 
 require 'openssl'
 require 'digest'
 
+
 ## 3rd party gems
-require 'rlp-lite'
 require 'digest-lite'
+require 'abicoder'
 
 
 require_relative 'jsonrpc/jsonrpc'
@@ -38,15 +34,7 @@ require_relative 'jsonrpc/jsonrpc'
 
 ## our own code
 require_relative 'ethlite/version'    # note: let version always go first
-
-require_relative 'ethlite/constant'
 require_relative 'ethlite/utils'
-
-
-require_relative 'ethlite/abi/type'
-require_relative 'ethlite/abi/codec'
-
-
 require_relative 'ethlite/contract'
 
 
@@ -61,6 +49,10 @@ class Configuration
                 value
              end
   end
+
+  ## add "global" debug switch - why? why not?
+  def debug?()   (@debug || false) == true; end
+  def debug=(value)   @debug = value;  end
 end # class Configuration
 
 
@@ -70,6 +62,9 @@ end # class Configuration
 ##   end
 def self.configure() yield( config ); end
 def self.config()    @config ||= Configuration.new;  end
+
+## add debug convenience config shortcut - forwarding to config.debug? - why? why not?
+def self.debug?()  config.debug?;  end
 end  # module Ethlite
 
 

data/lib/jsonrpc/jsonrpc.rb

@@ -8,6 +8,16 @@
 
 
 class JsonRpc
+
+      ### add a global debug switch - why? why not?
+      def self.debug?()  (@debug || false) == true; end
+      def self.debug( value ) @debug = value; end
+      ####
+      # private helpers
+      def debug?()  self.class.debug?;  end
+
+
+
       def initialize( uri )
         @uri        = uri    ## assume uri always as string for now
         @request_id = 1
@@ -23,8 +33,10 @@ class JsonRpc
 
           @request_id += 1
 
-          puts "json_rpc POST payload:"
-          puts data.to_json
+          if debug?
+            puts "json_rpc POST payload:"
+            puts data.to_json
+          end
 
           response = Webclient.post( @uri, json: data )
 
@@ -33,8 +45,10 @@ class JsonRpc
             raise "Error code #{response.status.code} on request #{@uri} #{data}"
           end
 
-          puts "json_rpc response.body:"
-          puts response.body
+          if debug?
+            puts "json_rpc response.body:"
+            puts response.body
+          end
 
 
           body = JSON.parse( response.body, max_nesting: 1500 )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ethlite
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-12 00:00:00.000000000 Z
+date: 2023-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cocos
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rlp-lite
+  name: digest-lite
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: digest-lite
+  name: abicoder
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -101,9 +101,6 @@ files:
 - README.md
 - Rakefile
 - lib/ethlite.rb
-- lib/ethlite/abi/codec.rb
-- lib/ethlite/abi/type.rb
-- lib/ethlite/constant.rb
 - lib/ethlite/contract.rb
 - lib/ethlite/utils.rb
 - lib/ethlite/version.rb

data/lib/ethlite/abi/codec.rb

@@ -1,436 +0,0 @@
-
-
-module Ethlite
-  module Abi
-
-  ##
-  # Contract ABI encoding and decoding.
-  #
-  # @see https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI
-  #
-  class Codec
-    class EncodingError < StandardError; end
-    class DecodingError < StandardError; end
-    class ValueError < 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
-
-    ##
-    # 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
-
-
-    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 # class Codec
-
-
-
-
-
-
-def self.codec
-  @codec ||= Codec.new
-end
-
-def self.encode_abi(types, args)
-    codec.encode_abi( types, args )
-end
-
-def self.decode_abi(types, data, raise_errors = false)
-    codec.decode_abi( types, data, raise_errors )
-end
-
-
-end  # module Abi
-end  # module Ethlite
-
-
-

data/lib/ethlite/abi/type.rb

@@ -1,200 +0,0 @@
-module Ethlite
-  module Abi
-  class Type
-
-    class ParseError < StandardError; end
-
-
-      ##
-      # Crazy regexp to seperate out base type component (eg. uint), size (eg.
-      # 256, 128x128, nil), array component (eg. [], [45], nil)
-      #
-      def self.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 self.size_type
-        @size_type ||= new('uint', 256, [])
-      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 Type
-
-
-  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  # class Tuple
-
-
-end  # module Abi
-end  # module Ethlite

data/lib/ethlite/constant.rb

@@ -1,35 +0,0 @@
-
-module Ethlite
-
-
-    ## todo/check   - use encoding -ascii-8bit for source file or ? - why? why not?
-    ## use  #b/.b  to ensure binary encoding? - why? why not?
-
-    ## todo/check:  use auto-freeze string literals magic comment - why? why not?
-    BYTE_EMPTY = "".b.freeze
-    BYTE_ZERO  = "\x00".b.freeze
-    BYTE_ONE   = "\x01".b.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).b.freeze
-
-
-    PUBKEY_ZERO = ("\x00"*32).b.freeze
-    PRIVKEY_ZERO = ("\x00"*32).b.freeze
-
-    PRIVKEY_ZERO_HEX = ('0'*64).freeze
-
-    CONTRACT_CODE_SIZE_LIMIT = 0x6000
-
-end  # module Ethlite