eth 0.5.10 → 0.5.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fd0b420dd7b4641fe8e87f57f13fdb74b3a23a2c11e7c2e23355f1cc5f6b4a3
-  data.tar.gz: e0c219b1c827ec4fcd4d730bfbb7d7e819a9d3049df6f01271cb79d7a81191ea
+  metadata.gz: a6da48b3e3128860af79efba95ded96258dfe87a8bf0a374a44bff060fc2f9c3
+  data.tar.gz: 9ad4cbabd4d5b31419d02b9363cdff915c4e1c61ba95197b42cf2a61ed31ac50
 SHA512:
-  metadata.gz: cdfa9a6cc91db7fba7e6ffe02dba0c4ec5a3e93a4948c5080f461f20415a9803b566dbf8049a63951e82c85007b31202d1826bc2261fc0e6d806bc4af0caade9
-  data.tar.gz: 97d962828b3c98387127ba69505a1170ef43ac8a40ba8aa70dc017cdc9ed91ca790b331fca7ca22eea3ba4d25158fcf3fb9e214bd195472a5b27b4bbc22ad790
+  metadata.gz: bbc07ab8bb0fc56f89619037ee16da5eeadb7d0fcde714572bd9b678e8c4da18b70e3fa042207c57195dd7e6e2700ebf5650bf5ca6ddf848da78661a2b8eda16
+  data.tar.gz: 51206666cc4a84bd05d0995ab6b7476699b17cc8bb37d3d78f789cf93116844dd3cd0f4e24360b59d7758d3588cc9fbebbe0504cdf1bd7b8a00a67e3600ac0ad

data/.github/workflows/codeql.yml

@@ -24,18 +24,18 @@ jobs:
           - ruby
     steps:
       - name: "Checkout repository"
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: "Initialize CodeQL"
-        uses: github/codeql-action/init@v2
+        uses: github/codeql-action/init@v3
         with:
           languages: "${{ matrix.language }}"
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v2
+        uses: github/codeql-action/autobuild@v3
       - name: "Perform CodeQL Analysis"
-        uses: github/codeql-action/analyze@v2
+        uses: github/codeql-action/analyze@v3
       - uses: ruby/setup-ruby@v1
         with:
-          ruby-version: '3.0'
+          ruby-version: '3.3'
           bundler-cache: true
       - name: "Run rufo code formatting checks"
         run: |

data/.github/workflows/docs.yml

@@ -10,17 +10,17 @@ jobs:
   docs:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - uses: ruby/setup-ruby@v1
       with:
-        ruby-version: '3.0'
+        ruby-version: '3.3'
         bundler-cache: true
     - name: Run Yard Doc
       run: |
         gem install yard
         yard doc
     - name: Deploy GH Pages
-      uses: JamesIves/github-pages-deploy-action@v4.4.1
+      uses: JamesIves/github-pages-deploy-action@v4.6.1
       with:
           branch: gh-pages
           folder: doc/

data/.github/workflows/spec.yml

@@ -18,10 +18,10 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-22.04, macos-12]
-        ruby: ['3.0', '3.1']
+        os: [ubuntu-latest, macos-latest]
+        ruby: ['3.1', '3.2', '3.3']
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}
@@ -49,5 +49,9 @@ jobs:
       run: |
         bundle exec rspec
       env:
-        COVERAGE: true
         INFURA_TOKEN: ${{ secrets.INFURA_TOKEN }}
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v4
+      with:
+        fail_ci_if_error: false
+        token: ${{ secrets.CODECOV_TOKEN }}

data/CHANGELOG.md

@@ -1,6 +1,58 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## [0.5.12]
+### Added
+### Changed
+
+## [0.5.11]
+### Added
+* Eth/abi: allow encoding address types [#242](https://github.com/q9f/eth.rb/pull/242)
+* Eth/solidity: enable --via-ir [#232](https://github.com/q9f/eth.rb/pull/232)
+* Checking userinfo with the uri method [#233](https://github.com/q9f/eth.rb/pull/233)
+* Eth/abi: add abicoder gem tests collection [#218](https://github.com/q9f/eth.rb/pull/218)
+* Manual default_account [#215](https://github.com/q9f/eth.rb/pull/215)
+* Add moonbeam networks in [#209](https://github.com/q9f/eth.rb/pull/209)
+
+### Changed
+* Spec: run rufo [#245](https://github.com/q9f/eth.rb/pull/245)
+* Fix the decoding of unsigned transactions [#243](https://github.com/q9f/eth.rb/pull/243)
+* Build(deps): bump JamesIves/github-pages-deploy-action from 4.4.2 to 4.4.3 [#244](https://github.com/q9f/eth.rb/pull/244)
+* Build(deps): bump JamesIves/github-pages-deploy-action from 4.4.1 to 4.4.2 [#240](https://github.com/q9f/eth.rb/pull/240)
+* Eth/tx: update tx initcode cost for shanghai [#237](https://github.com/q9f/eth.rb/pull/237)
+* Eth/client: remove default gas limit attribute [#235](https://github.com/q9f/eth.rb/pull/235)
+* Docs: minor fixups [#229](https://github.com/q9f/eth.rb/pull/229)
+* Eth/contract: ensure contract name is title case [#228](https://github.com/q9f/eth.rb/pull/228)
+* Deps: require forwardable for contracts [#227](https://github.com/q9f/eth.rb/pull/227)
+* Ens/resolver: remove pending for etc coin type [#219](https://github.com/q9f/eth.rb/pull/219)
+* Deps: update secp256k1 to 6 [#214](https://github.com/q9f/eth.rb/pull/214)
+* Eth/solidity: add docs for solc path override [#213](https://github.com/q9f/eth.rb/pull/213)
+* Manually overwrite solc path [#212](https://github.com/q9f/eth.rb/pull/212)
+* Abi.decoder handles arrays of string and bytes [#207](https://github.com/q9f/eth.rb/pull/207)
+* Eth/util: fix compressed public key to address in [#206](https://github.com/q9f/eth.rb/pull/206)
+* Eth/api: update execution apis to latest spec [#204](https://github.com/q9f/eth.rb/pull/204)
+* Eth/abi: split abi class into encoder and decoder [#203](https://github.com/q9f/eth.rb/pull/203)
+* Eth/client: deduplicate code [#202](https://github.com/q9f/eth.rb/pull/202)
+* Eth/client: rewrite send to send_request [#201](https://github.com/q9f/eth.rb/pull/201)
+* Docs: update changelog for 0.5.10 [#200](https://github.com/q9f/eth.rb/pull/200)
+* Tested with Ruby 3.2 [#199](https://github.com/q9f/eth.rb/pull/199)
+
+## [0.5.10]
+### Added
+* Eth/client: add transfer_erc20 function [#197](https://github.com/q9f/eth.rb/pull/197)
+* Eth/client: add resolve_ens function [#192](https://github.com/q9f/eth.rb/pull/192)
+
+### Changed
+* Eth/ens: restore docs for normalize [#198](https://github.com/q9f/eth.rb/pull/198)
+* Docs: update readme [#195](https://github.com/q9f/eth.rb/pull/195)
+* Eth/contract: ensure address arrays support [#194](https://github.com/q9f/eth.rb/pull/194)
+* Eth/client: do not allow accessing local accounts on remote connections [#193](https://github.com/q9f/eth.rb/pull/193)
+* Eth/client: correctly select functions [#191](https://github.com/q9f/eth.rb/pull/191)
+* Docs: create security policy [#190](https://github.com/q9f/eth.rb/pull/190)
+* Docs: add contribution guidelines [#189](https://github.com/q9f/eth.rb/pull/189)
+* Docs: add coc [#188](https://github.com/q9f/eth.rb/pull/188)
+* Docs: update changelog for 0.5.9 [#187](https://github.com/q9f/eth.rb/pull/187)
+
 ## [0.5.9]
 ### Added
 * Eth/abi: dynamic struct encoding (#135) [#185](https://github.com/q9f/eth.rb/pull/185)

data/eth.gemspec

@@ -34,6 +34,9 @@ Gem::Specification.new do |spec|
   spec.platform = Gem::Platform::RUBY
   spec.required_ruby_version = ">= 2.7", "< 4.0"
 
+  # forwardable for contracts meta programming
+  spec.add_dependency "forwardable", "~> 1.3"
+
   # keccak for hashing everything in ethereum
   spec.add_dependency "keccak", "~> 1.3"
 
@@ -41,7 +44,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "konstructor", "~> 1.0"
 
   # rbsecp256k1 for key-pairs and signatures
-  spec.add_dependency "rbsecp256k1", "~> 5.1"
+  spec.add_dependency "rbsecp256k1", "~> 6.0"
 
   # openssl for encrypted key derivation
   spec.add_dependency "openssl", ">= 2.2", "< 4.0"

data/lib/eth/abi/decoder.rb

@@ -0,0 +1,154 @@
+# Copyright (c) 2016-2023 The Ruby-Eth Contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -*- encoding : ascii-8bit -*-
+
+# Provides the {Eth} module.
+module Eth
+
+  # Provides a Ruby implementation of the Ethereum Application Binary Interface (ABI).
+  module Abi
+
+    # Provides a utility module to assist decoding ABIs.
+    module Decoder
+      extend self
+
+      # Decodes a specific value, either static or dynamic.
+      #
+      # @param type [Eth::Abi::Type] type to be decoded.
+      # @param arg [String] encoded type data string.
+      # @return [String] the decoded data for the type.
+      # @raise [DecodingError] if decoding fails for type.
+      def type(type, arg)
+        if %w(string bytes).include?(type.base_type) and type.sub_type.empty?
+          # Case: decoding a string/bytes
+          if type.dimensions.empty?
+            l = Util.deserialize_big_endian_to_int arg[0, 32]
+            data = arg[32..-1]
+            raise DecodingError, "Wrong data size for string/bytes object" unless data.size == Util.ceil32(l)
+
+            # decoded strings and bytes
+            data[0, l]
+            # Case: decoding array of string/bytes
+          else
+            l = Util.deserialize_big_endian_to_int arg[0, 32]
+
+            # Decode each element of the array
+            (1..l).map do |i|
+              pointer = Util.deserialize_big_endian_to_int arg[i * 32, 32] # Pointer to the size of the array's element
+              data_l = Util.deserialize_big_endian_to_int arg[32 + pointer, 32] # length of the element
+              type(Type.parse(type.base_type), arg[pointer + 32, Util.ceil32(data_l) + 32])
+            end
+          end
+        elsif type.base_type == "tuple"
+          offset = 0
+          data = {}
+          type.components.each do |c|
+            if c.dynamic?
+              pointer = Util.deserialize_big_endian_to_int arg[offset, 32] # Pointer to the size of the array's element
+              data_len = Util.deserialize_big_endian_to_int arg[pointer, 32] # length of the element
+
+              data[c.name] = type(c, arg[pointer, Util.ceil32(data_len) + 32])
+              # puts data
+              offset += 32
+            else
+              size = c.size
+              data[c.name] = type(c, arg[offset, size])
+              offset += size
+              # puts data
+            end
+          end
+          data
+        elsif type.dynamic?
+          l = Util.deserialize_big_endian_to_int arg[0, 32]
+          nested_sub = type.nested_sub
+
+          # ref https://github.com/ethereum/tests/issues/691
+          raise NotImplementedError, "Decoding dynamic arrays with nested dynamic sub-types is not implemented for ABI." if nested_sub.dynamic?
+
+          # decoded dynamic-sized arrays
+          (0...l).map { |i| type(nested_sub, arg[32 + nested_sub.size * i, nested_sub.size]) }
+        elsif !type.dimensions.empty?
+          l = type.dimensions.first
+          nested_sub = type.nested_sub
+
+          # decoded static-size arrays
+          (0...l).map { |i| type(nested_sub, arg[nested_sub.size * i, nested_sub.size]) }
+        else
+
+          # decoded primitive types
+          primitive_type type, arg
+        end
+      end
+
+      # Decodes primitive types.
+      #
+      # @param type [Eth::Abi::Type] type to be decoded.
+      # @param data [String] encoded primitive type data string.
+      # @return [String] the decoded data for the type.
+      # @raise [DecodingError] if decoding fails for type.
+      def primitive_type(type, data)
+        case type.base_type
+        when "address"
+
+          # decoded address with 0x-prefix
+          "0x#{Util.bin_to_hex data[12..-1]}"
+        when "string", "bytes"
+          if type.sub_type.empty?
+            size = Util.deserialize_big_endian_to_int data[0, 32]
+
+            # decoded dynamic-sized array
+            data[32..-1][0, size]
+          else
+
+            # decoded static-sized array
+            data[0, type.sub_type.to_i]
+          end
+        when "hash"
+
+          # decoded hash
+          data[(32 - type.sub_type.to_i), type.sub_type.to_i]
+        when "uint"
+
+          # decoded unsigned integer
+          Util.deserialize_big_endian_to_int data
+        when "int"
+          u = Util.deserialize_big_endian_to_int data
+          i = u >= 2 ** (type.sub_type.to_i - 1) ? (u - 2 ** 256) : u
+
+          # decoded integer
+          i
+        when "ureal", "ufixed"
+          high, low = type.sub_type.split("x").map(&:to_i)
+
+          # decoded unsigned fixed point numeric
+          Util.deserialize_big_endian_to_int(data) * 1.0 / 2 ** low
+        when "real", "fixed"
+          high, low = type.sub_type.split("x").map(&:to_i)
+          u = Util.deserialize_big_endian_to_int data
+          i = u >= 2 ** (high + low - 1) ? (u - 2 ** (high + low)) : u
+
+          # decoded fixed point numeric
+          i * 1.0 / 2 ** low
+        when "bool"
+
+          # decoded boolean
+          data[-1] == Constant::BYTE_ONE
+        else
+          raise DecodingError, "Unknown primitive type: #{type.base_type}"
+        end
+      end
+    end
+  end
+end

data/lib/eth/abi/encoder.rb

@@ -0,0 +1,304 @@
+# Copyright (c) 2016-2023 The Ruby-Eth Contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -*- encoding : ascii-8bit -*-
+
+# Provides the {Eth} module.
+module Eth
+
+  # Provides a Ruby implementation of the Ethereum Application Binary Interface (ABI).
+  module Abi
+
+    # Provides a utility module to assist encoding ABIs.
+    module Encoder
+      extend self
+
+      # Encodes a specific value, either static or dynamic.
+      #
+      # @param type [Eth::Abi::Type] type to be encoded.
+      # @param arg [String|Number] value to be encoded.
+      # @return [String] the encoded type.
+      # @raise [EncodingError] if value does not match type.
+      def type(type, arg)
+        if %w(string bytes).include? type.base_type and type.sub_type.empty? and type.dimensions.empty?
+          raise EncodingError, "Argument must be a String" unless arg.instance_of? String
+
+          # encodes strings and bytes
+          size = type Type.size_type, arg.size
+          padding = Constant::BYTE_ZERO * (Util.ceil32(arg.size) - arg.size)
+          "#{size}#{arg}#{padding}"
+        elsif type.base_type == "tuple" && type.dimensions.size == 1 && type.dimensions[0] != 0
+          result = ""
+          result += struct_offsets(type.nested_sub, arg)
+          result += arg.map { |x| type(type.nested_sub, x) }.join
+          result
+        elsif type.dynamic? && arg.is_a?(Array)
+
+          # encodes dynamic-sized arrays
+          head, tail = "", ""
+          head += type(Type.size_type, arg.size)
+          nested_sub = type.nested_sub
+          nested_sub_size = type.nested_sub.size
+
+          # calculate offsets
+          if %w(string bytes).include?(type.base_type) && type.sub_type.empty?
+            offset = 0
+            arg.size.times do |i|
+              if i == 0
+                offset = arg.size * 32
+              else
+                number_of_words = ((arg[i - 1].size + 32 - 1) / 32).floor
+                total_bytes_length = number_of_words * 32
+                offset += total_bytes_length + 32
+              end
+
+              head += type(Type.size_type, offset)
+            end
+          elsif nested_sub.base_type == "tuple" && nested_sub.dynamic?
+            head += struct_offsets(nested_sub, arg)
+          end
+
+          arg.size.times do |i|
+            head += type nested_sub, arg[i]
+          end
+          "#{head}#{tail}"
+        else
+          if type.dimensions.empty?
+
+            # encode a primitive type
+            primitive_type type, arg
+          else
+
+            # encode static-size arrays
+            arg.map { |x| type(type.nested_sub, x) }.join
+          end
+        end
+      end
+
+      # Encodes primitive types.
+      #
+      # @param type [Eth::Abi::Type] type to be encoded.
+      # @param arg [String|Number] value to be encoded.
+      # @return [String] the encoded primitive type.
+      # @raise [EncodingError] if value does not match type.
+      # @raise [ValueOutOfBounds] if value is out of bounds for type.
+      # @raise [EncodingError] if encoding fails for type.
+      def primitive_type(type, arg)
+        case type.base_type
+        when "uint"
+          uint arg, type
+        when "bool"
+          bool arg
+        when "int"
+          int arg, type
+        when "ureal", "ufixed"
+          ufixed arg, type
+        when "real", "fixed"
+          fixed arg, type
+        when "string", "bytes"
+          bytes arg, type
+        when "tuple"
+          tuple arg, type
+        when "hash"
+          hash arg, type
+        when "address"
+          address arg
+        else
+          raise EncodingError, "Unhandled type: #{type.base_type} #{type.sub_type}"
+        end
+      end
+
+      private
+
+      # Properly encodes unsigned integers.
+      def uint(arg, type)
+        raise ArgumentError, "Don't know how to handle this input." unless arg.is_a? Numeric
+        raise ValueOutOfBounds, "Number out of range: #{arg}" if arg > Constant::UINT_MAX or arg < Constant::UINT_MIN
+        real_size = type.sub_type.to_i
+        i = arg.to_i
+        raise ValueOutOfBounds, arg unless i >= 0 and i < 2 ** real_size
+        Util.zpad_int i
+      end
+
+      # Properly encodes signed integers.
+      def int(arg, type)
+        raise ArgumentError, "Don't know how to handle this input." unless arg.is_a? Numeric
+        raise ValueOutOfBounds, "Number out of range: #{arg}" if arg > Constant::INT_MAX or arg < Constant::INT_MIN
+        real_size = type.sub_type.to_i
+        i = arg.to_i
+        raise ValueOutOfBounds, arg unless i >= -2 ** (real_size - 1) and i < 2 ** (real_size - 1)
+        Util.zpad_int(i % 2 ** 256)
+      end
+
+      # Properly encodes booleans.
+      def bool(arg)
+        raise EncodingError, "Argument is not bool: #{arg}" unless arg.instance_of? TrueClass or arg.instance_of? FalseClass
+        Util.zpad_int(arg ? 1 : 0)
+      end
+
+      # Properly encodes unsigned fixed-point numbers.
+      def ufixed(arg, type)
+        raise ArgumentError, "Don't know how to handle this input." unless arg.is_a? Numeric
+        high, low = type.sub_type.split("x").map(&:to_i)
+        raise ValueOutOfBounds, arg unless arg >= 0 and arg < 2 ** high
+        Util.zpad_int((arg * 2 ** low).to_i)
+      end
+
+      # Properly encodes signed fixed-point numbers.
+      def fixed(arg, type)
+        raise ArgumentError, "Don't know how to handle this input." unless arg.is_a? Numeric
+        high, low = type.sub_type.split("x").map(&:to_i)
+        raise ValueOutOfBounds, arg unless arg >= -2 ** (high - 1) and arg < 2 ** (high - 1)
+        i = (arg * 2 ** low).to_i
+        Util.zpad_int(i % 2 ** (high + low))
+      end
+
+      # Properly encodes byte-strings.
+      def bytes(arg, type)
+        raise EncodingError, "Expecting String: #{arg}" unless arg.instance_of? String
+        arg = handle_hex_string arg, type
+
+        if type.sub_type.empty?
+          size = Util.zpad_int arg.size
+          padding = Constant::BYTE_ZERO * (Util.ceil32(arg.size) - arg.size)
+
+          # variable length string/bytes
+          "#{size}#{arg}#{padding}"
+        else
+          raise ValueOutOfBounds, arg unless arg.size <= type.sub_type.to_i
+          padding = Constant::BYTE_ZERO * (32 - arg.size)
+
+          # fixed length string/bytes
+          "#{arg}#{padding}"
+        end
+      end
+
+      # Properly encodes tuples.
+      def tuple(arg, type)
+        raise EncodingError, "Expecting Hash: #{arg}" unless arg.instance_of? Hash
+        raise EncodingError, "Expecting #{type.components.size} elements: #{arg}" unless arg.size == type.components.size
+
+        static_size = 0
+        type.components.each_with_index do |component, i|
+          if type.components[i].dynamic?
+            static_size += 32
+          else
+            static_size += Util.ceil32(type.components[i].size || 0)
+          end
+        end
+
+        dynamic_offset = static_size
+        offsets_and_static_values = []
+        dynamic_values = []
+
+        type.components.each_with_index do |component, i|
+          component_type = type.components[i]
+          if component_type.dynamic?
+            offsets_and_static_values << type(Type.size_type, dynamic_offset)
+            dynamic_value = type(component_type, arg.is_a?(Array) ? arg[i] : arg[component_type.name])
+            dynamic_values << dynamic_value
+            dynamic_offset += dynamic_value.size
+          else
+            offsets_and_static_values << type(component_type, arg.is_a?(Array) ? arg[i] : arg[component_type.name])
+          end
+        end
+
+        offsets_and_static_values.join + dynamic_values.join
+      end
+
+      # Properly encode struct offsets.
+      def struct_offsets(type, arg)
+        result = ""
+        offset = arg.size
+        tails_encoding = arg.map { |a| type(type, a) }
+        arg.size.times do |i|
+          if i == 0
+            offset *= 32
+          else
+            offset += tails_encoding[i - 1].size
+          end
+          offset_string = type(Type.size_type, offset)
+          result += offset_string
+        end
+        result
+      end
+
+      # Properly encodes hash-strings.
+      def hash(arg, type)
+        size = type.sub_type.to_i
+        raise EncodingError, "Argument too long: #{arg}" unless size > 0 and size <= 32
+        if arg.is_a? Integer
+
+          # hash from integer
+          Util.zpad_int arg
+        elsif arg.size == size
+
+          # hash from encoded hash
+          Util.zpad arg, 32
+        elsif arg.size == size * 2
+
+          # hash from hexadecimal hash
+          Util.zpad_hex arg
+        else
+          raise EncodingError, "Could not parse hash: #{arg}"
+        end
+      end
+
+      # Properly encodes addresses.
+      def address(arg)
+        if arg.is_a? Address
+
+          # from checksummed address with 0x prefix
+          Util.zpad_hex arg.to_s[2..-1]
+        elsif arg.is_a? Integer
+
+          # address from integer
+          Util.zpad_int arg
+        elsif arg.size == 20
+
+          # address from encoded address
+          Util.zpad arg, 32
+        elsif arg.size == 40
+
+          # address from hexadecimal address
+          Util.zpad_hex arg
+        elsif arg.size == 42 and arg[0, 2] == "0x"
+
+          # address from hexadecimal address with 0x prefix
+          Util.zpad_hex arg[2..-1]
+        else
+          raise EncodingError, "Could not parse address: #{arg}"
+        end
+      end
+
+      # The ABI encoder needs to be able to determine between a hex `"123"`
+      # and a binary `"123"` string.
+      def handle_hex_string(arg, type)
+        if Util.prefixed? arg or
+           (arg.size === type.sub_type.to_i * 2 and Util.hex? arg)
+
+          # There is no way telling whether a string is hex or binary with certainty
+          # in Ruby. Therefore, we assume a `0x` prefix to indicate a hex string.
+          # Additionally, if the string size is exactly the double of the expected
+          # binary size, we can assume a hex value.
+          Util.hex_to_bin arg
+        else
+
+          # Everything else will be assumed binary or raw string.
+          arg.b
+        end
+      end
+    end
+  end
+end

data/lib/eth/abi/event.rb

@@ -29,10 +29,31 @@ module Eth
       # @param interface [Hash] ABI event interface.
       # @return [String] a hex-string topic.
       def compute_topic(interface)
-        sig = Abi.signature(interface)
+        sig = signature(interface)
         Util.prefix_hex(Util.bin_to_hex(Util.keccak256(sig)))
       end
 
+      # Build event signature string from ABI interface.
+      #
+      # @param interface [Hash] ABI event interface.
+      # @return [String] interface signature string.
+      def signature(interface)
+        name = interface.fetch("name")
+        inputs = interface.fetch("inputs", [])
+        types = inputs.map { |i| type(i) }
+        "#{name}(#{types.join(",")})"
+      end
+
+      def type(input)
+        if input["type"] == "tuple"
+          "(#{input["components"].map { |c| type(c) }.join(",")})"
+        elsif input["type"] == "enum"
+          "uint8"
+        else
+          input["type"]
+        end
+      end
+
       # A decoded event log.
       class LogDescription
         # The event ABI interface used to decode the log.
@@ -70,7 +91,7 @@ module Eth
 
         # The event signature. (e.g. Transfer(address,address,uint256))
         def signature
-          @signature ||= Abi.signature(event_interface)
+          @signature ||= Abi::Event.signature(event_interface)
         end
       end
 
@@ -105,9 +126,20 @@ module Eth
       def decode_log(inputs, data, topics, anonymous = false)
         topic_inputs, data_inputs = inputs.partition { |i| i["indexed"] }
 
-        topic_types = topic_inputs.map { |i| i["type"] }
-        data_types = data_inputs.map { |i| i["type"] }
-
+        topic_types = topic_inputs.map do |i|
+          if i["type"] == "tuple"
+            Type.parse(i["type"], i["components"], i["name"])
+          else
+            i["type"]
+          end
+        end
+        data_types = data_inputs.map do |i|
+          if i["type"] == "tuple"
+            Type.parse(i["type"], i["components"], i["name"])
+          else
+            i["type"]
+          end
+        end
         # If event is anonymous, all topics are arguments. Otherwise, the first
         # topic will be the event signature.
         if anonymous == false