ethereum-contract-abi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: be70442c2225b17ac53a7d627051bba9388a2ff7ef3f6f9163c05ece75ec792a
+  data.tar.gz: e476f57e5107298dda5ea8a3dbf0fe9c30b593145b13fac1cc014dedf0b4a5df
+SHA512:
+  metadata.gz: 521f0496cb783a54a79090ff6b1fd7536fcd325cede0a6a46ed732646e2969679e0f49d53d2733f66067524f359f4efcc5eb32707511d88f347d24fedcaf7670
+  data.tar.gz: '09c33f3ede2778e8fe8ceeb9379f5084884c2094c04ebb9fe065554699ca832b921283d1a40df78d3f825fd2e35be789190df6b74bdc87da794de62560387b08'

data/.gitignore

@@ -0,0 +1 @@
+.idea/

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem 'rake'
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gem "rspec", "~> 3.10"
+
+gem "json", "~> 2.5"
+
+git 'https://github.com/evtaylor/sha3-pure-ruby.git' do
+  gem 'sha3-pure-ruby'
+end

data/Gemfile.lock

@@ -0,0 +1,37 @@
+GIT
+  remote: https://github.com/evtaylor/sha3-pure-ruby.git
+  revision: c3e764863f4926db33308d42e0fe7ec8ce3b72ce
+  specs:
+    sha3-pure-ruby (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.4.4)
+    json (2.5.1)
+    rake (13.0.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+
+PLATFORMS
+  x64-mingw32
+
+DEPENDENCIES
+  json (~> 2.5)
+  rake
+  rspec (~> 3.10)
+  sha3-pure-ruby!
+
+BUNDLED WITH
+   2.2.3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Evan Taylor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,27 @@
+# ethereum-contract-abi
+
+A library for interacting with Ethereum smart contracts via the Contract Application Binary Interface (ABI).
+
+For more info see: https://docs.soliditylang.org/en/latest/abi-spec.html
+
+Can encode function calls with types:
+- ✅ `address`
+- ✅ `bool`
+- ✅ `bytes`
+- ✅ `fixed`
+- ✅ `int`
+- ✅ `uint`
+- ✅ `string`
+- ❌ `<type>[]`
+- ❌ `tuple`
+
+Can decode function calls with types:
+- ❌ `address`
+- ❌ `bool`
+- ❌ `bytes`
+- ❌ `fixed`
+- ✅ `int`
+- ✅ `uint`
+- ✅ `string`
+- ❌ `<type>[]`
+- ❌ `tuple`

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+RSpec::Core::RakeTask.new(:test) do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+task default: %w[test]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "ethereum-contract-abi"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/ethereum_contract_abi.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name        = 'ethereum-contract-abi'
+  s.version     = '0.1.0'
+  s.summary     = "Ethereum contract ABI encoder and decoder"
+  s.description = "A library for interacting with Ethereum smart contracts via the Contract Application Binary Interface (ABI)"
+  s.authors     = ["Evan Taylor"]
+  s.email       = 'evan@evantaylor.ca'
+  s.homepage    = "https://evantaylor.ca"
+  s.license     = 'MIT'
+
+  s.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  s.require_paths = ["lib"]
+end

data/lib/ethereum-contract-abi.rb

@@ -0,0 +1,24 @@
+require 'bundler/setup'
+require 'ethereum-contract-abi/contract/parsers/contract_parser'
+require 'ethereum-contract-abi/contract/eip/erc165_interface'
+require 'ethereum-contract-abi/contract/eip/erc721_metadata_interface'
+require 'ethereum-contract-abi/contract/eip/erc1155_metadata_interface'
+
+module EthereumContractABI
+  def self.contract_from_json(json_string)
+    ContractParser.from_json(json_string)
+  end
+
+  def self.get_interface(interface_id)
+    case interface_id
+    when EIP::ERC721_METADATA_ID
+      EIP::ERC721MetadataInterface
+    when EIP::ERC1155_METADATA_ID
+      EIP::ERC1155MetadataInterface
+    when EIP::ERC165_ID
+      EIP::ERC165Interface
+    else
+      raise ArgumentError.new('Unknown interface identifier')
+    end
+  end
+end

data/lib/ethereum-contract-abi/constants.rb

@@ -0,0 +1,6 @@
+module EthereumContractABI
+  module Constants
+    BYTE_ZERO = "\x00".force_encoding(Encoding::ASCII_8BIT).freeze
+    BYTE_ONE = "\xFF".force_encoding(Encoding::ASCII_8BIT).freeze
+  end
+end

data/lib/ethereum-contract-abi/contract.rb

@@ -0,0 +1,59 @@
+require 'ethereum-contract-abi/contract/eip/constants'
+require 'ethereum-contract-abi/contract/eip/erc721_metadata_interface'
+require 'ethereum-contract-abi/contract/eip/erc721_enumerable_interface'
+require 'ethereum-contract-abi/contract/eip/erc1155_metadata_interface'
+
+include EthereumContractABI::ContractInterface
+
+module EthereumContractABI
+  class Contract
+    def initialize(functions, events)
+      @functions = functions.to_h { |func| [func.name, func]}
+      @events = events
+
+      functions.each do |f|
+        self.class.send(:define_method, f.name) { function(f.name) }
+      end
+    end
+
+    def functions
+      @functions.values
+    end
+
+    def function(name)
+      @functions.dig(name)
+    end
+
+    def function_exists?(name)
+      @functions.key? name
+    end
+
+    def implements_interface(identifier)
+      case identifier
+      when EIP::ERC721_METADATA_ID
+        EIP::ERC721MetadataInterface.is_implemented_by?(self)
+      when EIP::ERC721_ENUMERABLE_ID
+        EIP::ERC721EnumerableInterface.is_implemented_by?(self)
+      when EIP::ERC1155_METADATA_ID
+        EIP::ERC1155MetadataInterface.is_implemented_by?(self)
+      else
+        raise ArgumentError.new('Unknown interface identifier')
+      end
+    end
+
+    def has_function?(func)
+      return false unless function_exists?(func.name)
+      contract_func = function(func.name)
+      return false unless contract_func.inputs.size == func.inputs.size
+      return false unless contract_func.outputs.size == func.outputs.size
+
+      input_type_strings = contract_func.inputs.map {|i| i.type.to_s }
+      expected_input_type_strings = func.inputs.map {|i| i.type.to_s }
+      output_type_string = contract_func.outputs.map {|i| i.type.to_s }
+      expected_output_type_string = func.outputs.map {|i| i.type.to_s }
+
+      Set.new(expected_input_type_strings) == Set.new(input_type_strings) &&
+        Set.new(expected_output_type_string) == Set.new(output_type_string)
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/abi_types/address.rb

@@ -0,0 +1,29 @@
+require 'ethereum-contract-abi/encoders/int_encoder'
+require 'ethereum-contract-abi/contract/abi_types/uint'
+
+include EthereumContractABI::Encoders
+include EthereumContractABI::ContractInterface::AbiTypes
+
+module EthereumContractABI
+  module ContractInterface
+    module AbiTypes
+      class Address < Uint
+        def initialize
+          super(160)
+        end
+
+        def is_dynamic
+          false
+        end
+
+        def to_s
+          "address"
+        end
+
+        def self.from_string(string_type)
+          string_type === 'address' ? self.new : nil
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/abi_types/base_type.rb

@@ -0,0 +1,35 @@
+module EthereumContractABI
+  module ContractInterface
+    module AbiTypes
+      class BaseType
+        def to_s
+          raise NotImplementedError.new('to_s not implemented on type')
+        end
+
+        def is_dynamic
+          true
+        end
+
+        def bytesize
+          32
+        end
+
+        def encode_value(value)
+          raise NotImplementedError.new('encode_value not implemented on type')
+        end
+
+        def decode_value(value)
+          raise NotImplementedError.new('decode_value not implemented on type')
+        end
+
+        def self.from_string(string_type)
+          raise NotImplementedError.new('from_string not implemented on type')
+        end
+
+        def is_type_equal(type)
+          to_s == type.to_s
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/abi_types/bool.rb

@@ -0,0 +1,33 @@
+require 'ethereum-contract-abi/encoders/int_encoder'
+require 'ethereum-contract-abi/contract/abi_types/base_type'
+
+include EthereumContractABI::Encoders
+
+module EthereumContractABI
+  module ContractInterface
+    module AbiTypes
+      class Bool < BaseType
+        def to_s
+          "bool"
+        end
+
+        def is_dynamic
+          false
+        end
+
+        def valid_value?(bool)
+          [true, false].include? bool
+        end
+
+        def encode_value(bool)
+          raise ArgumentError unless valid_value?(bool)
+          IntEncoder.encode(bool ? 1 : 0)
+        end
+
+        def self.from_string(string_type)
+          string_type === 'bool' ? self.new : nil
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/abi_types/bytes.rb

@@ -0,0 +1,42 @@
+require 'ethereum-contract-abi/encoders/bytes_encoder'
+require 'ethereum-contract-abi/contract/abi_types/base_type'
+
+include EthereumContractABI::Encoders
+
+module EthereumContractABI
+  module ContractInterface
+    module AbiTypes
+      class Bytes < BaseType
+        def initialize(num_bytes = nil)
+          @num_bytes = num_bytes
+        end
+
+        def is_dynamic
+          @num_bytes.nil?
+        end
+
+        def bytesize
+          @num_bytes.nil? ? nil : (@num_bytes.to_f/32.0).ceil
+        end
+
+        def to_s
+          "bytes#{@num_bytes}"
+        end
+
+        def valid_value?(value)
+          true
+        end
+
+        def encode_value(bytes)
+          BytesEncoder.encode(bytes, @num_bytes)
+        end
+
+        def self.from_string(string_type)
+          /(?<is_bytes>bytes)(?<bytes>\d+)?/ =~ string_type
+          return nil unless is_bytes
+          bytes ? self.new(bytes.to_i) : self.new
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/abi_types/fixed.rb

@@ -0,0 +1,46 @@
+require 'ethereum-contract-abi/encoders/decimal_encoder'
+require 'ethereum-contract-abi/contract/abi_types/base_type'
+
+include EthereumContractABI::Encoders
+
+module EthereumContractABI
+  module ContractInterface
+    module AbiTypes
+      class Fixed < BaseType
+        def initialize(bits = 128, precision = 18)
+          raise ArgumentError.new("8 must be a factor of bits") unless bits % 8 === 0
+          raise ArgumentError.new("bits must be: 8 <= bits <= 256") unless 8 <= bits && bits <= 256
+          raise ArgumentError.new("precision must be: 0 < precision <= 80") unless 0 < precision && precision <= 80
+          @bits = bits
+          @precision = precision
+        end
+
+        def is_dynamic
+          false
+        end
+
+        def to_s
+          "fixed#{@bits}x#{@precision}"
+        end
+
+        def valid_value?(number)
+          return false unless number.is_a? Numeric
+          return false unless number.round(0).bit_length <= @bits
+          true
+        end
+
+        def encode_value(number)
+          raise ArgumentError unless valid_value?(number)
+          DecimalEncoder.encode_value(number, @precision)
+        end
+
+        def self.from_string(string_type)
+          /(?<type>fixed)((?<bits>\d+)x(?<precision>\d+))?/ =~ string_type
+          return nil unless type
+
+          bits && precision ? self.new(bits.to_i, precision.to_i) : self.new
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/abi_types/int.rb

@@ -0,0 +1,48 @@
+require 'ethereum-contract-abi/encoders/int_encoder'
+require 'ethereum-contract-abi/decoders/int_decoder'
+require 'ethereum-contract-abi/contract/abi_types/base_type'
+
+include EthereumContractABI::Encoders
+include EthereumContractABI::Decoders
+
+module EthereumContractABI
+  module ContractInterface
+    module AbiTypes
+      class Int < BaseType
+        def initialize(bits = 256)
+          raise ArgumentError.new("8 must be a factor of bits") unless bits % 8 === 0
+          @bits = bits
+        end
+
+        def is_dynamic
+          false
+        end
+
+        def to_s
+          "int#{@bits}"
+        end
+
+        def valid_value?(number)
+          return false unless number.is_a? Numeric
+          return false unless number.bit_length <= @bits
+          true
+        end
+
+        def encode_value(number)
+          raise ArgumentError unless valid_value?(number)
+          IntEncoder.encode(number)
+        end
+
+        def decode_value(value)
+          IntDecoder.decode(value)
+        end
+
+        def self.from_string(string_type)
+          /(?<is_int>^int)(?<bits>\d+)?/ =~ string_type
+          return nil unless is_int
+          bits ? self.new(bits.to_i) : self.new
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/abi_types/string.rb

@@ -0,0 +1,44 @@
+require 'ethereum-contract-abi/encoders/bytes_encoder'
+require 'ethereum-contract-abi/decoders/string_decoder'
+require 'ethereum-contract-abi/contract/abi_types/base_type'
+
+include EthereumContractABI::Encoders
+include EthereumContractABI::Decoders
+
+module EthereumContractABI
+  module ContractInterface
+    module AbiTypes
+      class String < BaseType
+        def to_s
+          "string"
+        end
+
+        def is_dynamic
+          true
+        end
+
+        def bytesize
+          nil
+        end
+
+        def valid_value?(value)
+          return false unless value.is_a? String
+          true
+        end
+
+        def encode_value(value)
+          raise ArgumentError unless valid_value?(value)
+          BytesEncoder.encode(value)
+        end
+
+        def decode_value(value)
+          StringDecoder.decode(value)
+        end
+
+        def self.from_string(string_type)
+          string_type === 'string' ? self.new : nil
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/abi_types/uint.rb

@@ -0,0 +1,30 @@
+require 'ethereum-contract-abi/encoders/int_encoder'
+require 'ethereum-contract-abi/contract/abi_types/int'
+
+include EthereumContractABI::Encoders
+
+module EthereumContractABI
+  module ContractInterface
+    module AbiTypes
+      class Uint < Int
+        def to_s
+          "uint#{@bits}"
+        end
+
+        def is_dynamic
+          false
+        end
+
+        def valid_value?(number)
+          super(number) && number >= 0
+        end
+
+        def self.from_string(string_type)
+          /(?<is_uint>uint)(?<bits>\d+)?/ =~ string_type
+          return nil unless is_uint
+          bits ? self.new(bits.to_i) : self.new
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/eip/constants.rb

@@ -0,0 +1,10 @@
+module EthereumContractABI
+  module ContractInterface
+    module EIP
+      ERC721_METADATA_ID = '0x5b5e139f'
+      ERC721_ENUMERABLE_ID = '0x780e9d63'
+      ERC1155_METADATA_ID = '0x0e89341c'
+      ERC165_ID = 'ERC165'
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/eip/erc1155_metadata_interface.rb

@@ -0,0 +1,30 @@
+require 'ethereum-contract-abi/contract/abi_types/string'
+require 'ethereum-contract-abi/contract/abi_types/uint'
+require 'ethereum-contract-abi/contract/output'
+require 'ethereum-contract-abi/contract/function'
+
+include EthereumContractABI::ContractInterface
+
+module EthereumContractABI
+  module ContractInterface
+    module EIP
+      class ERC1155MetadataInterface
+
+        def self.is_implemented_by?(contract)
+          contract.has_function?(self.uri)
+        end
+
+        def self.functions
+          [self.uri]
+        end
+
+        def self.uri
+          function_name = 'uri'
+          inputs = [Input.new('_id', AbiTypes::Uint.new)]
+          outputs = [Output.new(AbiTypes::String.new)]
+          Function.new(function_name, inputs, outputs)
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/eip/erc165_interface.rb

@@ -0,0 +1,30 @@
+require 'ethereum-contract-abi/contract/abi_types/bytes'
+require 'ethereum-contract-abi/contract/abi_types/bool'
+require 'ethereum-contract-abi/contract/output'
+require 'ethereum-contract-abi/contract/function'
+
+include EthereumContractABI::ContractInterface
+
+module EthereumContractABI
+  module ContractInterface
+    module EIP
+      class ERC165Interface
+
+        def self.is_implemented_by?(contract)
+          contract.has_function?(self.supportsInterface)
+        end
+
+        def self.functions
+          [self.supportsInterface]
+        end
+
+        def self.supportsInterface
+          function_name = 'supportsInterface'
+          inputs = [Input.new( 'interfaceID', AbiTypes::Bytes.new(4))]
+          outputs = [Output.new(AbiTypes::Bool.new)]
+          Function.new(function_name, inputs, outputs)
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/eip/erc721_enumerable_interface.rb

@@ -0,0 +1,46 @@
+require 'ethereum-contract-abi/contract/abi_types/address'
+require 'ethereum-contract-abi/contract/abi_types/uint'
+require 'ethereum-contract-abi/contract/output'
+require 'ethereum-contract-abi/contract/function'
+
+include EthereumContractABI::ContractInterface
+
+module EthereumContractABI
+  module ContractInterface
+    module EIP
+      class ERC721EnumerableInterface
+
+        def self.is_implemented_by?(contract)
+          contract.has_function?(self.totalSupply) &&
+            contract.has_function?(self.tokenByIndex) &&
+            contract.has_function?(self.tokenOfOwnerByIndex)
+        end
+
+        def self.totalSupply
+          function_name = 'totalSupply'
+          inputs = []
+          outputs = [Output.new(AbiTypes::Uint.new)]
+          Function.new(function_name, inputs, outputs)
+        end
+
+        def self.tokenByIndex
+          function_name = 'tokenByIndex'
+          inputs = [Input.new('_index', AbiTypes::Uint.new)]
+          outputs = [Output.new(AbiTypes::Uint.new)]
+          Function.new(function_name, inputs, outputs)
+        end
+
+        def self.tokenOfOwnerByIndex
+          function_name = 'tokenOfOwnerByIndex'
+          inputs = [Input.new('_owner', AbiTypes::Address.new), Input.new('_index', AbiTypes::Uint.new)]
+          outputs = [Output.new(AbiTypes::Uint.new)]
+          Function.new(function_name, inputs, outputs)
+        end
+
+        def self.functions
+          [self.totalSupply, self.tokenByIndex, self.tokenOfOwnerByIndex]
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/eip/erc721_metadata_interface.rb

@@ -0,0 +1,46 @@
+require 'ethereum-contract-abi/contract/abi_types/string'
+require 'ethereum-contract-abi/contract/abi_types/uint'
+require 'ethereum-contract-abi/contract/output'
+require 'ethereum-contract-abi/contract/function'
+
+include EthereumContractABI::ContractInterface
+
+module EthereumContractABI
+  module ContractInterface
+    module EIP
+      class ERC721MetadataInterface
+
+        def self.is_implemented_by?(contract)
+          contract.has_function?(self.name) &&
+            contract.has_function?(self.symbol) &&
+            contract.has_function?(self.tokenURI)
+        end
+
+        def self.name
+          function_name = 'name'
+          inputs = []
+          outputs = [Output.new(AbiTypes::String.new, '_name')]
+          Function.new(function_name, inputs, outputs)
+        end
+
+        def self.symbol
+          function_name = 'symbol'
+          inputs = []
+          outputs = [Output.new(AbiTypes::String.new, '_symbol')]
+          Function.new(function_name, inputs, outputs)
+        end
+
+        def self.tokenURI
+          function_name = 'tokenURI'
+          inputs = [Input.new('_tokenId', AbiTypes::Uint.new)]
+          outputs = [Output.new(AbiTypes::String.new)]
+          Function.new(function_name, inputs, outputs)
+        end
+
+        def self.functions
+          [self.name, self.symbol, self.tokenURI]
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/function.rb

@@ -0,0 +1,60 @@
+require 'digest'
+require 'openssl'
+require 'sha3-pure-ruby'
+require 'ethereum-contract-abi/util'
+require 'ethereum-contract-abi/decoders/function_decoder'
+
+include EthereumContractABI::Decoders
+
+module EthereumContractABI
+  module ContractInterface
+    class Function
+      attr_reader :name, :inputs, :outputs
+
+      def initialize(name, inputs, outputs)
+        @name = name
+        @inputs = inputs
+        @outputs = outputs
+        @decoder = FunctionDecoder.new(outputs)
+      end
+
+      def signature
+        params = @inputs.map { |i| i.type.to_s }
+        "#{@name}(#{params.join(",")})"
+      end
+
+      def method_id
+        hash = [Digest::SHA3.new(256, true).hexdigest(signature)].pack("H*")
+        hash.slice(0..3)
+      end
+
+      def valid_args?(args)
+        return false unless args.size === @inputs.size
+        true
+      end
+
+      def encode_call(*args)
+        raise ArgumentError.new("Invalid function arguments") unless valid_args?(args)
+        encoded_args = @inputs.zip(args).map do |input, arg|
+          input.encode_value(arg)
+        end
+        EthereumContractABI::Util.fromHexByteString(method_id + encoded_args.join(''))
+      end
+
+      def decode_output(output_string)
+        output_hex_string = EthereumContractABI::Util.remove_hex_prefix(output_string)
+        if has_any_dynamic_outputs
+          @decoder.decode_dynamic_output(output_hex_string)
+        else
+          @decoder.decode_static_output(output_hex_string)
+        end
+      end
+
+      private
+
+      def has_any_dynamic_outputs
+        @outputs.find { |o| o.type.is_dynamic }
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/input.rb

@@ -0,0 +1,16 @@
+module EthereumContractABI
+  module ContractInterface
+    class Input
+      attr_reader :type
+
+      def initialize(name, type)
+        @name = name
+        @type = type
+      end
+
+      def encode_value(value)
+        @type.encode_value(value)
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/output.rb

@@ -0,0 +1,16 @@
+module EthereumContractABI
+  module ContractInterface
+    class Output
+      attr_reader :type
+
+      def initialize(type, name = nil)
+        @name = name
+        @type = type
+      end
+
+      def decode_value(value)
+        @type.decode_value(value)
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/parsers/abi_type_parser.rb

@@ -0,0 +1,40 @@
+require 'json'
+require 'ethereum-contract-abi/contract'
+require 'ethereum-contract-abi/contract/abi_types/uint'
+require 'ethereum-contract-abi/contract/abi_types/bool'
+require 'ethereum-contract-abi/contract/abi_types/string'
+require 'ethereum-contract-abi/contract/abi_types/fixed'
+require 'ethereum-contract-abi/contract/abi_types/bytes'
+require 'ethereum-contract-abi/contract/abi_types/address'
+
+include EthereumContractABI::ContractInterface::AbiTypes
+
+module EthereumContractABI
+  module ContractInterface
+    module Parsers
+      class AbiTypeParser
+        def self.from_string(string_type)
+          uint = Uint.from_string(string_type)
+          return uint unless uint.nil?
+
+          bool = Bool.from_string(string_type)
+          return bool unless bool.nil?
+
+          decimal = Fixed.from_string(string_type)
+          return decimal unless decimal.nil?
+
+          str = EthereumContractABI::ContractInterface::AbiTypes::String.from_string(string_type)
+          return str unless str.nil?
+
+          bytes = Bytes.from_string(string_type)
+          return bytes unless bytes.nil?
+
+          address = Address.from_string(string_type)
+          return address unless address.nil?
+
+          raise ArgumentError.new('Unknown type')
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/parsers/contract_parser.rb

@@ -0,0 +1,29 @@
+require 'json'
+require 'ethereum-contract-abi/contract'
+require 'ethereum-contract-abi/contract/parsers/function_parser'
+
+include EthereumContractABI::ContractInterface::Parsers
+
+module EthereumContractABI
+  module ContractInterface
+    module Parsers
+      class ContractParser
+        def self.from_json(json_string)
+          parsed = JSON.parse(json_string)
+          functions = parsed.select { |interface| interface["type"] === "function"}
+            .map { |f_hash| f_hash.transform_keys(&:to_sym) }
+            .filter_map do |f_hash|
+              begin
+                FunctionParser.from_hash(f_hash)
+              rescue ArgumentError
+                # Error parsing contract function, all ABI types are not yet implemented
+                nil
+              end
+            end
+          events = parsed.select { |interface| interface["type"] === "event"}
+          EthereumContractABI::Contract.new(functions, events)
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/contract/parsers/function_parser.rb

@@ -0,0 +1,42 @@
+require 'json'
+require 'ethereum-contract-abi/contract'
+require 'ethereum-contract-abi/contract/input'
+require 'ethereum-contract-abi/contract/output'
+require 'ethereum-contract-abi/contract/parsers/abi_type_parser'
+require 'ethereum-contract-abi/contract/function'
+
+include EthereumContractABI::ContractInterface
+
+module EthereumContractABI
+  module ContractInterface
+    module Parsers
+      class FunctionParser
+        def self.from_hash(function_hash)
+          function_hash = function_hash.transform_keys(&:to_sym)
+          name = function_hash[:name]
+          inputs = self.get_inputs(function_hash[:inputs])
+          outputs = self.get_inputs(function_hash[:outputs])
+          Function.new(name, inputs, outputs)
+        end
+
+        private
+
+        def self.get_inputs(inputs)
+          inputs.map do |input_hash|
+            hash = input_hash.transform_keys(&:to_sym)
+            type = AbiTypeParser.from_string(hash[:type])
+            Input.new(name, type)
+          end
+        end
+
+        def self.get_outputs(outputs)
+          outputs.map do |input_hash|
+            hash = input_hash.transform_keys(&:to_sym)
+            type = AbiTypeParser.from_string(hash[:type])
+            Output.new(name, type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/decoders/function_decoder.rb

@@ -0,0 +1,37 @@
+require 'ethereum-contract-abi/util'
+require 'ethereum-contract-abi/decoders/int_decoder'
+require 'ethereum-contract-abi/decoders/string_decoder'
+
+module EthereumContractABI
+  module Decoders
+    class FunctionDecoder
+      def initialize(function_outputs)
+        @function_outputs = function_outputs
+      end
+
+      def decode_dynamic_output(encoded_output)
+        hex = Util.toHexByteString(encoded_output)
+        @function_outputs.map.with_index  do |output, index|
+          head = get_head_by_index(encoded_output, index)
+          head_offset = IntDecoder.decode(head)
+          output_bytes = hex.byteslice(head_offset, hex.bytesize)
+          output.type.decode_value(Util.fromHexByteString(output_bytes, with_prefix: false))
+        end
+      end
+
+      def decode_static_output(encoded_output)
+        @function_outputs.map.with_index  do |output, index|
+          bytes = encoded_output.slice!(0, output.type.bytesize * 2)
+          output.type.decode_value(bytes)
+        end
+      end
+
+      private
+
+      def get_head_by_index(encoded_output, index)
+        first_byte = index * 64
+        encoded_output.byteslice(first_byte, 64)
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/decoders/int_decoder.rb

@@ -0,0 +1,11 @@
+require 'ethereum-contract-abi/util'
+
+module EthereumContractABI
+  module Decoders
+    class IntDecoder
+      def self.decode(encoded_value)
+        encoded_value.slice(0, 64).to_i(16)
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/decoders/string_decoder.rb

@@ -0,0 +1,16 @@
+require 'ethereum-contract-abi/util'
+require 'ethereum-contract-abi/decoders/int_decoder'
+
+include EthereumContractABI::Decoders
+
+module EthereumContractABI
+  module Decoders
+    class StringDecoder
+      def self.decode(string, num_bytes = nil)
+        hex = [string].pack('H*')
+        length = IntDecoder.decode(hex.byteslice(0, 32).unpack("H*").first)
+        hex.byteslice(32..hex.bytesize).byteslice(0, length).strip
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/encoders/bytes_encoder.rb

@@ -0,0 +1,31 @@
+require 'ethereum-contract-abi/constants'
+require 'ethereum-contract-abi/encoders/int_encoder'
+
+include EthereumContractABI::Encoders
+
+module EthereumContractABI
+  module Encoders
+    class BytesEncoder
+      def self.encode(bytes_to_encode, num_bytes = nil)
+        if bytes_to_encode.methods.include?(:start_with?) && bytes_to_encode.start_with?("0x")
+          bytes_to_encode = Util.toHexByteString(bytes_to_encode.slice(2, bytes_to_encode.length))
+        end
+
+        unless num_bytes.nil?
+          raise ArgumentError.new("Too many bytes to encode") unless bytes_to_encode.bytesize <= num_bytes
+          return self.encode_bytes(bytes_to_encode)
+        end
+
+        num_bytes_encoded = IntEncoder.encode(bytes_to_encode.bytesize)
+        num_bytes_encoded + self.encode_bytes(bytes_to_encode)
+      end
+
+      private
+
+      def self.encode_bytes(bytes_to_encode)
+        final_length = (bytes_to_encode.bytesize / 32.to_f).ceil * 32
+        bytes_to_encode + Constants::BYTE_ZERO * (final_length - bytes_to_encode.bytesize)
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/encoders/decimal_encoder.rb

@@ -0,0 +1,14 @@
+require 'ethereum-contract-abi/constants'
+require 'ethereum-contract-abi/encoders/int_encoder'
+
+include EthereumContractABI::Encoders
+
+module EthereumContractABI
+  module Encoders
+    class DecimalEncoder
+      def self.encode_value(decimal_number, precision)
+        IntEncoder.encode((decimal_number * 10**precision).to_i)
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/encoders/int_encoder.rb

@@ -0,0 +1,16 @@
+require 'ethereum-contract-abi/constants'
+
+module EthereumContractABI
+  module Encoders
+    class IntEncoder
+      def self.encode(int)
+        hex = int < 0 ? (int & 0xffff).to_s(16).rjust(2, "0") : int.to_s(16).rjust(2, "0")
+        # converting to byte string requires each byte is represented by exactly 2 hex characters
+        adjusted_hex = hex.length % 2 != 0 ? "0" + hex : hex
+        int_hex_bytes = Util.toHexByteString(adjusted_hex)
+        pad_byte = int < 0 ? Constants::BYTE_ONE : Constants::BYTE_ZERO
+        pad_byte * (32 - int_hex_bytes.bytesize) + int_hex_bytes
+      end
+    end
+  end
+end

data/lib/ethereum-contract-abi/util.rb

@@ -0,0 +1,24 @@
+module EthereumContractABI
+  class Util
+
+    def self.toHexByteString(str)
+      if str.start_with?("0x")
+        return [str.slice(2, str.length)].pack("H*")
+      end
+      [str].pack("H*")
+    end
+
+    def self.fromHexByteString(str, with_prefix: true)
+      prefix = with_prefix ? "0x" : ""
+      prefix + str.unpack("H*").first
+    end
+
+    def self.remove_hex_prefix(str)
+      str.slice(2, str.length)
+    end
+    
+    def self. keccak_hash(str)
+      [Digest::SHA3.new(256, true ).hexdigest(signature)].pack("H*")
+    end
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: ethereum-contract-abi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Evan Taylor
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-06-05 00:00:00.000000000 Z
+dependencies: []
+description: A library for interacting with Ethereum smart contracts via the Contract
+  Application Binary Interface (ABI)
+email: evan@evantaylor.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- '3.0'
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- ethereum_contract_abi.gemspec
+- lib/ethereum-contract-abi.rb
+- lib/ethereum-contract-abi/constants.rb
+- lib/ethereum-contract-abi/contract.rb
+- lib/ethereum-contract-abi/contract/abi_types/address.rb
+- lib/ethereum-contract-abi/contract/abi_types/base_type.rb
+- lib/ethereum-contract-abi/contract/abi_types/bool.rb
+- lib/ethereum-contract-abi/contract/abi_types/bytes.rb
+- lib/ethereum-contract-abi/contract/abi_types/fixed.rb
+- lib/ethereum-contract-abi/contract/abi_types/int.rb
+- lib/ethereum-contract-abi/contract/abi_types/string.rb
+- lib/ethereum-contract-abi/contract/abi_types/uint.rb
+- lib/ethereum-contract-abi/contract/eip/constants.rb
+- lib/ethereum-contract-abi/contract/eip/erc1155_metadata_interface.rb
+- lib/ethereum-contract-abi/contract/eip/erc165_interface.rb
+- lib/ethereum-contract-abi/contract/eip/erc721_enumerable_interface.rb
+- lib/ethereum-contract-abi/contract/eip/erc721_metadata_interface.rb
+- lib/ethereum-contract-abi/contract/function.rb
+- lib/ethereum-contract-abi/contract/input.rb
+- lib/ethereum-contract-abi/contract/output.rb
+- lib/ethereum-contract-abi/contract/parsers/abi_type_parser.rb
+- lib/ethereum-contract-abi/contract/parsers/contract_parser.rb
+- lib/ethereum-contract-abi/contract/parsers/function_parser.rb
+- lib/ethereum-contract-abi/decoders/function_decoder.rb
+- lib/ethereum-contract-abi/decoders/int_decoder.rb
+- lib/ethereum-contract-abi/decoders/string_decoder.rb
+- lib/ethereum-contract-abi/encoders/bytes_encoder.rb
+- lib/ethereum-contract-abi/encoders/decimal_encoder.rb
+- lib/ethereum-contract-abi/encoders/int_encoder.rb
+- lib/ethereum-contract-abi/util.rb
+homepage: https://evantaylor.ca
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Ethereum contract ABI encoder and decoder
+test_files: []