eth 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16b9900b6e0bd1a0bb51d055b545980685416a1e079590196fa9637e1c3e758e
-  data.tar.gz: db3a4a72a0b14458dee3f4af836ac32bfc6ccf987b22e9f965551ddacecb09de
+  metadata.gz: 0375271f13b257337cbc0ab138c2cdf972de8f8e03cf60bb9b672b2221ac988d
+  data.tar.gz: 19e85a6be34904b5544d9c6845ae19231616d65f27a8146c747f66068f2c23db
 SHA512:
-  metadata.gz: 90a00773ef20cdf765c19da284b09f20577fbaf26707d7b425f68109be9d559805603eabfd699c7ff68a56ac8d7619ecdaa841233a0d6af9bbd14521238a18e0
-  data.tar.gz: 80127ab21325d386fbef1e57b13a1a5e769882d174114255b938babfd35c9e84ae3515ae28ace04300dfa38eb2059cb4eb529699378e9c354c5ed73d2ae0c6ce
+  metadata.gz: d5cc31684e8dfbff08b7250436a0bd4a94fa90942fd27b03292806cf2ac190673f1e507d8bcabd80b968a7206401a5210298c75c1ecc7c1d94765a7e94654d0d
+  data.tar.gz: 11b5a667d5cb333848aee384f4276fb3982a69104ae43c9650aec572ec3d093601c44b1b33167029b3ea37bcba6d8fd46da795ada67f6ad50fc39550fd092434

data/AUTHORS.txt

@@ -2,6 +2,8 @@ The Ruby-Eth Contributors are:
 * Steve Ellis @se3000
 * Afri Schoedon @q9f
 * John Omar @chainoperator
+* Joshua Peek @josh
+* Yuta Kurotaki @kurotaky
 
 See also:
 * https://github.com/q9f/eth.rb/graphs/contributors

data/README.md

@@ -46,6 +46,7 @@ Contents:
   - [2.6. Ethereum RLP Encoder and Decoder](#26-ethereum-rlp-encoder-and-decoder)
   - [2.7. Ethereum RPC-Client](#27-ethereum-rpc-client)
   - [2.8 Solidity Compiler Bindings](#28-solidity-compiler-bindings)
+  - [2.9 Interact with Smart Contract](#29-interact-with-smart-contract)
 - [3. Documentation](#3-documentation)
 - [4. Testing](#4-testing)
 - [5. Contributing](#5-contributing)
@@ -253,6 +254,23 @@ contract = solc.compile "spec/fixtures/contracts/greeter.sol"
 
 The `contract["Greeter"]["bin"]` could be directly used to deploy the contract as `Eth::Tx` payload. Check out the [Documentation](https://q9f.github.io/eth.rb/) for more details.
 
+### 2.9 Interact with Smart Contract
+
+Functions to interact with smart contract.
+
+```ruby
+contract = Eth::Contract.create(file: 'spec/fixtures/contracts/dummy.sol')
+# => #<Eth::Contract::Dummy:0x00007fbeee936598>
+cli = Eth::Client.create "/tmp/geth.ipc"
+# => #<Eth::Client::Ipc:0x00007fbeee946128 @gas_limit=21000, @id=0, @max_fee_per_gas=0.2e11, @max_priority_fee_per_gas=0, @path="/tmp/geth.ipc">
+address = cli.deploy_and_wait(contract)
+# => "0x2f2faa160420cee087ded96bad52475147136bd8"
+cli.transact_and_wait(contract, "set", 1234)
+# => "0x49ca4c0a5729da19a1d2574de9a444a9cd3219bdad81745b54f9cf3bb83b6a06"
+cli.call(contract, "get")
+# => 1234
+```
+
 ## 3. Documentation
 The documentation can be found at: https://q9f.github.io/eth.rb
 

data/lib/eth/abi/event.rb

@@ -0,0 +1,137 @@
+# Copyright (c) 2016-2022 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 Applicatoin Binary Interface (ABI).
+  module Abi
+
+    # Provides a module to decode transaction log events.
+    module Event
+      extend self
+
+      # Compute topic for ABI event interface.
+      #
+      # @param interface [Hash] ABI event interface.
+      # @return [String] a hex-string topic.
+      def compute_topic(interface)
+        sig = Abi.signature(interface)
+        Util.prefix_hex(Util.bin_to_hex(Util.keccak256(sig)))
+      end
+
+      # A decoded event log.
+      class LogDescription
+        # The event ABI interface used to decode the log.
+        attr_accessor :event_interface
+
+        # The the input argument of the event.
+        attr_accessor :args
+
+        # The named input argument of the event.
+        attr_accessor :kwargs
+
+        # The topic hash.
+        attr_accessor :topic
+
+        # Decodes event log argument values.
+        #
+        # @param event_interface [Hash] event ABI type.
+        # @param log [Hash] transaction receipt log
+        def initialize(event_interface, log)
+          @event_interface = event_interface
+
+          inputs = event_interface.fetch("inputs")
+          data = log.fetch("data")
+          topics = log.fetch("topics", [])
+          anonymous = event_interface.fetch("anonymous", false)
+
+          @topic = topics[0] if !anonymous
+          @args, @kwargs = Event.decode_log(inputs, data, topics, anonymous)
+        end
+
+        # The event name. (e.g. Transfer)
+        def name
+          @name ||= event_interface.fetch("name")
+        end
+
+        # The event signature. (e.g. Transfer(address,address,uint256))
+        def signature
+          @signature ||= Abi.signature(event_interface)
+        end
+      end
+
+      # Decodes a stream of receipt logs with a set of ABI interfaces.
+      #
+      # @param interfaces [Array] event ABI types.
+      # @param logs [Array] transaction receipt logs
+      # @return [Hash] an enumerator of LogDescription objects.
+      def decode_logs(interfaces, logs)
+        Enumerator.new do |y|
+          topic_to_interfaces = Hash[interfaces.map { |i| [compute_topic(i), i] }]
+
+          logs.each do |log|
+            topic = log.fetch("topics", [])[0]
+            if topic && interface = topic_to_interfaces[topic]
+              y << [log, LogDescription.new(interface, log)]
+            else
+              y << [log, nil]
+            end
+          end
+        end
+      end
+
+      # Decodes event log argument values.
+      #
+      # @param inputs [Array] event ABI types.
+      # @param data [String] ABI event data to be decoded.
+      # @param topics [Array] ABI event topics to be decoded.
+      # @param anonymous [Boolean] If event signature is excluded from topics.
+      # @return [[Array, Hash]] decoded positional arguments and decoded keyword arguments.
+      # @raise [DecodingError] if decoding fails for type.
+      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"] }
+
+        # If event is anonymous, all topics are arguments. Otherwise, the first
+        # topic will be the event signature.
+        if anonymous == false
+          topics = topics[1..-1]
+        end
+
+        decoded_topics = topics.map.with_index { |t, i| Abi.decode([topic_types[i]], t)[0] }
+        decoded_data = Abi.decode(data_types, data)
+
+        args = []
+        kwargs = {}
+
+        inputs.each_with_index do |input, index|
+          if input["indexed"]
+            value = decoded_topics[topic_inputs.index(input)]
+          else
+            value = decoded_data[data_inputs.index(input)]
+          end
+          args[index] = value
+          kwargs[input["name"].to_sym] = value
+        end
+
+        return args, kwargs
+      end
+    end
+  end
+end

data/lib/eth/abi.rb

@@ -16,6 +16,7 @@
 
 require "konstructor"
 
+require "eth/abi/event"
 require "eth/abi/type"
 
 # Provides the {Eth} module.
@@ -290,6 +291,17 @@ module Eth
       end
     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| i.fetch("type") }
+      "#{name}(#{types.join(",")})"
+    end
+
     private
 
     # Properly encodes unsigned integers.

data/lib/eth/client.rb

@@ -149,6 +149,242 @@ module Eth
       end
     end
 
+    # Deploy contract and waits for it to be mined.
+    # Uses `eth_coinbase` or external signer
+    # if no sender key is provided.
+    #
+    # @overload deploy(contract)
+    #   @param contract [Eth::Contract] contracts to deploy.
+    # @overload deploy(contract, sender_key)
+    #   @param contract [Eth::Contract] contracts to deploy.
+    #   @param sender_key [Eth::Key] the sender private key.
+    # @overload deploy(contract, sender_key, legacy)
+    #   @param contract [Eth::Contract] contracts to deploy.
+    #   @param sender_key [Eth::Key] the sender private key.
+    #   @param legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    # @return [String] the contract address.
+    def deploy_and_wait(contract, sender_key: nil, legacy: false)
+      hash = wait_for_tx(deploy(contract, sender_key: sender_key, legacy: legacy))
+      contract.address = eth_get_transaction_receipt(hash)["result"]["contractAddress"]
+    end
+
+    # Deploy contract. Uses `eth_coinbase` or external signer
+    # if no sender key is provided.
+    #
+    # @overload deploy(contract)
+    #   @param contract [Eth::Contract] contracts to deploy.
+    # @overload deploy(contract, sender_key)
+    #   @param contract [Eth::Contract] contracts to deploy.
+    #   @param sender_key [Eth::Key] the sender private key.
+    # @overload deploy(contract, sender_key, legacy)
+    #   @param contract [Eth::Contract] contracts to deploy.
+    #   @param sender_key [Eth::Key] the sender private key.
+    #   @param legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    # @return [String] the transaction hash.
+    def deploy(contract, sender_key: nil, legacy: false)
+      gas_limit = Tx.estimate_intrinsic_gas(contract.bin) + Tx::CREATE_GAS
+      params = {
+        value: 0,
+        gas_limit: gas_limit,
+        chain_id: chain_id,
+        data: contract.bin,
+      }
+      if legacy
+        params.merge!({
+          gas_price: max_fee_per_gas,
+        })
+      else
+        params.merge!({
+          priority_fee: max_priority_fee_per_gas,
+          max_gas_fee: max_fee_per_gas,
+        })
+      end
+      unless sender_key.nil?
+        # use the provided key as sender and signer
+        params.merge!({
+          from: sender_key.address,
+          nonce: get_nonce(sender_key.address),
+        })
+        tx = Eth::Tx.new(params)
+        tx.sign sender_key
+        return eth_send_raw_transaction(tx.hex)["result"]
+      else
+        # use the default account as sender and external signer
+        params.merge!({
+          from: default_account,
+          nonce: get_nonce(default_account),
+        })
+        return eth_send_transaction(params)["result"]
+      end
+    end
+
+    # Encoding for function calls.
+    def call_payload(fun, args)
+      types = fun.inputs.map { |i| i.type }
+      encoded_str = Util.bin_to_hex(Eth::Abi.encode(types, args))
+      "0x" + fun.signature + (encoded_str.empty? ? "0" * 64 : encoded_str)
+    end
+
+    # Non-transactional function call called from call().
+    #
+    # @overload call_raw(contract, func)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param func [Eth::Contract::Function] method name to be called.
+    # @overload call_raw(contract, func, value)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param func [Eth::Contract::Function] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    # @overload call_raw(contract, func, value, sender_key, legacy)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param func [Eth::Contract::Function] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    #   @param sender_key [Eth::Key] the sender private key.
+    #   @param legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    # @return [Object] returns the result of the call.
+    def call_raw(contract, func, *args, **kwargs)
+      gas_limit = Tx.estimate_intrinsic_gas(contract.bin) + Tx::CREATE_GAS
+      params = {
+        gas_limit: gas_limit,
+        chain_id: chain_id,
+        data: call_payload(func, args),
+      }
+      if kwargs[:address] || contract.address
+        params.merge!({ to: kwargs[:address] || contract.address })
+      end
+      if kwargs[:legacy]
+        params.merge!({
+          gas_price: max_fee_per_gas,
+        })
+      else
+        params.merge!({
+          priority_fee: max_priority_fee_per_gas,
+          max_gas_fee: max_fee_per_gas,
+        })
+      end
+      unless kwargs[:sender_key].nil?
+        # use the provided key as sender and signer
+        params.merge!({
+          from: kwargs[:sender_key].address,
+          nonce: get_nonce(kwargs[:sender_key].address),
+        })
+        tx = Eth::Tx.new(params)
+        tx.sign kwargs[:sender_key]
+      else
+        # use the default account as sender and external signer
+        params.merge!({
+          from: default_account,
+          nonce: get_nonce(default_account),
+        })
+      end
+      raw_result = eth_call(params)["result"]
+      types = func.outputs.map { |i| i.type }
+      Eth::Abi.decode(types, raw_result)
+    end
+
+    # Non-transactional function calls.
+    #
+    # @overload call(contract, function_name)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    # @overload call(contract, function_name, value)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    # @overload call(contract, function_name, value, sender_key, legacy)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    #   @param sender_key [Eth::Key] the sender private key.
+    #   @param legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    # @return [Object] returns the result of the call.
+    def call(contract, function_name, *args, **kwargs)
+      func = contract.functions.select { |func| func.name == function_name }[0]
+      raise ArgumentError, "function_name does not exist!" if func.nil?
+      output = call_raw(contract, func, *args, **kwargs)
+      if output.length == 1
+        return output[0]
+      else
+        return output
+      end
+    end
+
+    # Function call with transaction.
+    #
+    # @overload transact(contract, function_name)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    # @overload transact(contract, function_name, value)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    # @overload transact(contract, function_name, value, sender_key, legacy, address)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    #   @param sender_key [Eth::Key] the sender private key.
+    #   @param legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    #   @param address [String] contract address.
+    # @return [Object] returns the result of the call.
+    def transact(contract, function_name, *args, **kwargs)
+      gas_limit = Tx.estimate_intrinsic_gas(contract.bin) + Tx::CREATE_GAS
+      fun = contract.functions.select { |func| func.name == function_name }[0]
+      params = {
+        value: 0,
+        gas_limit: gas_limit,
+        chain_id: chain_id,
+        to: kwargs[:address] || contract.address,
+        data: call_payload(fun, args),
+      }
+      if kwargs[:legacy]
+        params.merge!({
+          gas_price: max_fee_per_gas,
+        })
+      else
+        params.merge!({
+          priority_fee: max_priority_fee_per_gas,
+          max_gas_fee: max_fee_per_gas,
+        })
+      end
+      unless kwargs[:sender_key].nil?
+        # use the provided key as sender and signer
+        params.merge!({
+          from: kwargs[:sender_key].address,
+          nonce: get_nonce(kwargs[:sender_key].address),
+        })
+        tx = Eth::Tx.new(params)
+        tx.sign kwargs[:sender_key]
+        return eth_send_raw_transaction(tx.hex)["result"]
+      else
+        # use the default account as sender and external signer
+        params.merge!({
+          from: default_account,
+          nonce: get_nonce(default_account),
+        })
+        return eth_send_transaction(params)["result"]
+      end
+    end
+
+    # Function call with transaction and waits for it to be mined.
+    #
+    # @overload transact_and_wait(contract, function_name)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    # @overload transact_and_wait(contract, function_name, value)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    # @overload transact_and_wait(contract, function_name, value, sender_key, legacy, address)
+    #   @param contract [Eth::Contract] subject contract to call.
+    #   @param function_name [String] method name to be called.
+    #   @param value [Integer|String] function arguments.
+    #   @param sender_key [Eth::Key] the sender private key.
+    #   @param legacy [Boolean] enables legacy transactions (pre-EIP-1559).
+    #   @param address [String] contract address.
+    # @return [Object] returns the result of the call.
+    def transact_and_wait(contract, function_name, *args, **kwargs)
+      wait_for_tx(transact(contract, function_name, *args, **kwargs))
+    end
+
     # Gives control over resetting the RPC request ID back to zero.
     # Usually not needed.
     #

data/lib/eth/contract/event.rb

@@ -0,0 +1,41 @@
+# Copyright (c) 2016-2022 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
+  # Provide classes for contract event.
+  class Contract::Event
+    attr_accessor :name, :signature, :input_types, :inputs, :event_string, :address
+
+    # Constructor of the {Eth::Contract::Event} class.
+    #
+    # @param data [Hash] contract event data.
+    def initialize(data)
+      @name = data["name"]
+      @input_types = data["inputs"].collect { |x| x["type"] }
+      @inputs = data["inputs"].collect { |x| x["name"] }
+      @event_string = "#{@name}(#{@input_types.join(",")})"
+      @signature = Digest::Keccak.hexdigest(@event_string, 256)
+    end
+
+    # Set the address of the smart contract
+    #
+    # @param address [String] contract address.
+    def set_address(address)
+      @address = address.nil? ? nil : Eth::Address.new(address).address
+    end
+  end
+end

data/lib/eth/contract/function.rb

@@ -0,0 +1,56 @@
+# Copyright (c) 2016-2022 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 the methods for smart contract function.
+  class Contract::Function
+    attr_accessor :name, :inputs, :outputs, :signature, :constant, :function_string
+
+    # Constructor of the {Eth::Function} class.
+    #
+    # @param data [Hash] function input and output data.
+    def initialize(data)
+      @name = data["name"]
+      @constant = data["constant"]
+      @inputs = data["inputs"].map do |input|
+        Eth::Contract::FunctionInput.new(input)
+      end
+      @outputs = data["outputs"].collect do |output|
+        Eth::Contract::FunctionOutput.new(output)
+      end
+      @function_string = self.class.calc_signature(@name, @inputs)
+      @signature = self.class.encoded_function_signature(@function_string)
+    end
+
+    # Create function strings.
+    #
+    # @param name [String] function name.
+    # @param inputs [Array<Eth::Contract::FunctionInput>] function input class list.
+    # @return [String] function string.
+    def self.calc_signature(name, inputs)
+      "#{name}(#{inputs.collect { |x| x.type }.join(",")})"
+    end
+
+    # encode function signature.
+    #
+    # @param signature [String] function signature.
+    # @return [String] encoded function signature string.
+    def self.encoded_function_signature(signature)
+      Digest::Keccak.hexdigest(signature, 256)[0..7]
+    end
+  end
+end

data/lib/eth/contract/function_input.rb

@@ -0,0 +1,36 @@
+# Copyright (c) 2016-2022 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
+  # Provide classes for contract function input.
+  class Contract::FunctionInput
+    attr_accessor :type, :name
+
+    # Constructor of the {Eth::Contract::FunctionInput} class.
+    #
+    # @param data [Hash] contract abi data.
+    def initialize(data)
+      @type = Eth::Abi::Type.parse(data["type"])
+      @name = data["name"]
+    end
+
+    # Returns types like uint256
+    def type
+      @type.base_type + @type.sub_type
+    end
+  end
+end

data/lib/eth/contract/function_output.rb

@@ -0,0 +1,32 @@
+# Copyright (c) 2016-2022 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
+  # Provide classes for contract function output.
+  class Contract::FunctionOutput
+    attr_accessor :type, :name
+
+    def initialize(data)
+      @type = Eth::Abi::Type.parse(data["type"])
+      @name = data["name"]
+    end
+
+    def type
+      @type.base_type + @type.sub_type
+    end
+  end
+end

data/lib/eth/contract/initializer.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2016-2022 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
+  # Provide classes for contract initializer.
+  class Contract::Initializer
+    attr_accessor :contracts, :file
+
+    # Constructor of the {Eth::Contract::Initializer} class.
+    #
+    # @param file [String] file path to solidity code.
+    def initialize(file)
+      sol_output = Eth::Solidity.new.compile(file)
+      contracts = sol_output.keys
+
+      @contracts = []
+      contracts.each do |contract|
+        abi = sol_output[contract]["abi"]
+        name = contract
+        code = sol_output[contract]["bin"]
+        @contracts << Contract.new(name, code, abi)
+      end
+    end
+
+    # Build and return all contracts.
+    def build_all
+      @contracts.each do |contract|
+        contract.build
+      end
+    end
+  end
+end

data/lib/eth/contract.rb

@@ -0,0 +1,120 @@
+# Copyright (c) 2016-2022 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 classes to access smart contracts
+  class Contract
+    attr_reader :address
+    attr_accessor :key
+    attr_accessor :gas_limit, :gas_price, :max_fee_per_gas, :max_priority_fee_per_gas, :nonce
+    attr_accessor :bin, :name, :abi, :class_object
+    attr_accessor :events, :functions, :constructor_inputs
+
+    # Constructor of the {Eth::Contract} class.
+    #
+    # @param name [String] contract name.
+    # @param bin [String] contract bin string.
+    # @param abi [String] contract abi string.
+    def initialize(name, bin, abi)
+      @name = name
+      @bin = bin
+      @abi = abi
+      @constructor_inputs, @functions, @events = parse_abi(abi)
+    end
+
+    # Creates a contract wrapper.
+    #
+    # @param file [String] solidity file path.
+    # @param bin [String] contract bin string.
+    # @param abi [String] contract abi string.
+    # @param address [String] contract address.
+    # @param name [String] name of contract.
+    # @param contract_index [Number] specify contract.
+    # @return [Eth::Contract::Object] Returns the class of the smart contract.
+    # @raise [JSON::ParserError] if the json format is wrong.
+    # @raise [ArgumentError] if argument is incorrect.
+    def self.create(file: nil, bin: nil, abi: nil, address: nil, name: nil, contract_index: nil)
+      if File.exist?(file.to_s)
+        contracts = Eth::Contract::Initializer.new(file).build_all
+        raise "No contracts compiled" if contracts.empty?
+        if contract_index
+          contract = contracts[contract_index].class_object.new
+        else
+          contract = contracts.first.class_object.new
+        end
+      elsif ![name, bin, abi].include? nil
+        begin
+          abi = abi.is_a?(Array) ? abi : JSON.parse(abi)
+        rescue JSON::ParserError => e
+          raise e
+        end
+        contract = Eth::Contract.new(name, bin, abi)
+        contract.build
+        contract = contract.class_object.new
+      else
+        raise ArgumentError, "The argument is incorrect."
+      end
+      contract.address = address
+      contract
+    end
+
+    # Set the address of the smart contract
+    def address=(addr)
+      @address = addr.nil? ? nil : Eth::Address.new(addr).address
+      @events.each do |event|
+        event.set_address(@address)
+      end
+    end
+
+    # Create classes for smart contracts
+    def build
+      class_name = @name
+      parent = self
+      class_methods = Class.new do
+        extend Forwardable
+        def_delegators :parent, :key, :key=
+        def_delegators :parent, :name, :abi, :bin
+        def_delegators :parent, :gas_limit, :gas_price, :gas_limit=, :gas_price=, :nonce, :nonce=
+        def_delegators :parent, :max_fee_per_gas, :max_fee_per_gas=, :max_priority_fee_per_gas, :max_priority_fee_per_gas=
+        def_delegators :parent, :events
+        def_delegators :parent, :address, :address=
+        def_delegator :parent, :functions
+        define_method :parent do
+          parent
+        end
+      end
+      Eth::Contract.send(:remove_const, class_name) if Eth::Contract.const_defined?(class_name, false)
+      Eth::Contract.const_set(class_name, class_methods)
+      @class_object = class_methods
+    end
+
+    private
+
+    def parse_abi(abi)
+      constructor = abi.detect { |x| x["type"] == "constructor" }
+      if !constructor.nil?
+        constructor_inputs = constructor["inputs"].map { |input| Eth::Contract::FunctionInput.new(input) }
+      else
+        constructor_inputs = []
+      end
+      functions = abi.select { |x| x["type"] == "function" }.map { |fun| Eth::Contract::Function.new(fun) }
+      events = abi.select { |x| x["type"] == "event" }.map { |evt| Eth::Contract::Event.new(evt) }
+      [constructor_inputs, functions, events]
+    end
+  end
+end

data/lib/eth/tx.rb

@@ -69,6 +69,9 @@ module Eth
     # The zero byte is 0x00.
     ZERO_BYTE = "\x00".freeze
 
+    # Smart contract transaction gas cost
+    CREATE_GAS = 32_000.freeze
+
     # Creates a new transaction of any type for given parameters and chain ID.
     # Required parameters are (optional in brackets):
     # - EIP-1559: chain_id, nonce, priority_fee, max_gas_fee, gas_limit(, from, to,

data/lib/eth/version.rb

@@ -16,5 +16,5 @@
 module Eth
 
   # Defines the version of the {Eth} module.
-  VERSION = "0.5.2".freeze
+  VERSION = "0.5.3".freeze
 end

data/lib/eth.rb

@@ -22,6 +22,12 @@ require "eth/api"
 require "eth/address"
 require "eth/chain"
 require "eth/constant"
+require "eth/contract"
+require "eth/contract/event"
+require "eth/contract/function"
+require "eth/contract/function_input"
+require "eth/contract/function_output"
+require "eth/contract/initializer"
 require "eth/client"
 require "eth/client/http"
 require "eth/client/ipc"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eth
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors:
 - Steve Ellis
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-28 00:00:00.000000000 Z
+date: 2022-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: keccak
@@ -108,6 +108,7 @@ files:
 - eth.gemspec
 - lib/eth.rb
 - lib/eth/abi.rb
+- lib/eth/abi/event.rb
 - lib/eth/abi/type.rb
 - lib/eth/address.rb
 - lib/eth/api.rb
@@ -116,6 +117,12 @@ files:
 - lib/eth/client/http.rb
 - lib/eth/client/ipc.rb
 - lib/eth/constant.rb
+- lib/eth/contract.rb
+- lib/eth/contract/event.rb
+- lib/eth/contract/function.rb
+- lib/eth/contract/function_input.rb
+- lib/eth/contract/function_output.rb
+- lib/eth/contract/initializer.rb
 - lib/eth/eip712.rb
 - lib/eth/key.rb
 - lib/eth/key/decrypter.rb