ethereum.rb 1.6.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 847343b8aaa240f07a46b58d0423fdc1ac3e368b
-  data.tar.gz: 8610cf63893eaf0686cd5230156bc6e29c020d1f
+  metadata.gz: c4bfce795e5c0ba5c86e8731f2f7c04504b53000
+  data.tar.gz: 52feb089966aabb77b7a1002d5a8aff8433049dd
 SHA512:
-  metadata.gz: a0b703025e50dacbf4448209709563e4075ff4176d6d01129925f975b9e9f3b68c1dcf1e6febe21bee10ef885814844273a593ac39533ce4561f0baad63e480e
-  data.tar.gz: 149a4faa03278bbed430632dba56ed4ef8d1b5ca84440244af1caadfe2cae17ecfc3f51f4fd8a69894eebee6f10c983946dfdeddd60d67d9d32fd4ab8cc52fcf
+  metadata.gz: 40ff1fe3ac72b9f4676eb5350c1ada0e31ebcf9778eeab3b5d80036f5d4a8c0cc854d3988f4a11d044788ffadee6482ca5d0bf2e7c31e600521de045f9d93902
+  data.tar.gz: 69eb7f4a2a31e04a883d0b266211fd13e411790afc9105e884494464e508db60fd4363e9f970aef9afb26b153501e1f35c89e4bf8dc456951c5f2da569d31b6b

data/.travis.yml

@@ -2,6 +2,12 @@ dist: trusty
 language: ruby
 rvm:
   - 2.3.1
+env:
+  - PARITY="1.4.8"
+  - PARITY="1.5.0"
+matrix:
+  allow_failures:
+  - env: PARITY="1.5.0"
 cache:
   bundler: true
   directories:
@@ -10,15 +16,15 @@ before_install:
   - sudo bin/install_parity
   - gem install bundler -v 1.11.2
 before_script:
-  - parity --chain ~/.parity/ropsten.json --warp --password ~/.parity/pass --unlock 21e72c12878136d9349c77c1645deef121ee8926 --author 21e72c12878136d9349c77c1645deef121ee8926 daemon ~/.parity.pid --log-file ~/.parity.log
+  - parity --chain ~/.parity/ropsten.json --warp --password ~/.parity/pass --unlock 3089630d06fD90Ef48a0c43f000971587c1F3247 --author 3089630d06fD90Ef48a0c43f000971587c1F3247 daemon ~/.parity.pid --log-file ~/.parity.log
+  - cat ~/.parity.log
   - sleep 5
   - parity --chain ~/.parity/ropsten.json account list
   - cat ~/.parity.log
   - bundle exec rake ethereum:node:waitforsync
   - bundle exec rake ethereum:test:setup
 script:
-  - bundle exec rspec --tag ~slow
-  - bundle exec rspec --tag slow
+  - bundle exec rspec --tag ~blockchain && bundle exec rspec --tag blockchain
 before_cache:
   - killall parity
   - sleep 3

data/README.md

@@ -1,8 +1,8 @@
-# Ethereum.rb
+# Ethereum Ruby library - Ethereum.rb
 
-[![Build Status](https://travis-ci.org/marekkirejczyk/ethereum.rb.svg?branch=master)](https://travis-ci.org/marekkirejczyk/ethereum.rb) [![security](https://hakiri.io/github/NullVoxPopuli/MetaHash/master.svg)](https://hakiri.io/github/NullVoxPopuli/MetaHash/master) [![Dependency Status](https://gemnasium.com/marekkirejczyk/ethereum.rb.svg)](https://gemnasium.com/marekkirejczyk/ethereum.rb)
+[![Build Status](https://travis-ci.org/marekkirejczyk/ethereum.rb.svg?branch=master)](https://travis-ci.org/marekkirejczyk/ethereum.rb) [![security](https://hakiri.io/github/NullVoxPopuli/MetaHash/master.svg)](https://hakiri.io/github/NullVoxPopuli/MetaHash/master) [![Dependency Status](https://gemnasium.com/marekkirejczyk/ethereum.rb.svg)](https://gemnasium.com/marekkirejczyk/ethereum.rb) [![Code Climate](https://codeclimate.com/github/marekkirejczyk/ethereum.rb/badges/gpa.svg)](https://codeclimate.com/github/marekkirejczyk/ethereum.rb)
 
-A simple library for Ethereum.
+A ruby gem for interacting with Ethereum.
 
 ## Highlights
 
@@ -36,7 +36,7 @@ To be able to compile [solidity](https://github.com/ethereum/solidity) contracts
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'ethereum'
+gem 'ethereum.rb'
 ```
 
 And then execute:
@@ -45,7 +45,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install ethereum
+    $ gem install ethereum.eb
 
 ## Basic Usage
 
@@ -72,44 +72,47 @@ By default logging is on and logs are saved in "/tmp/ethereum_ruby_http.log".
 You can create contract from solidity source and deploy it to the blockchain.
 
 ```ruby
-contract = Ethereum::Contract.from_file("mycontract.sol", client)
-contract_instance = contract.deploy_and_wait
+contract = Ethereum::Contract.create(file: "mycontract.sol", client: client)
+address = contract.deploy_and_wait
 ```
 
 Deployment may take up to couple minutes.
-Or with more complex syntax (might be useful if you want to complie multiple contracts at once):
+If you want to complie multiple contracts at once, you can create new instances using newly declared clasess:
 
 ```ruby
-init = Ethereum::Initializer.new("mycontract.sol", client)
-init.build_all
+Ethereum::Contract.create(file: "mycontract.sol", client: client)
 contract = MyContract.new
-contract_instance = contract.deploy_and_wait(60)
+contract = contract.deploy_and_wait
 ```
 
-Note that contract variable holds the reference to contract code, while contract_instance holds refernce to contract deployed to the blockchain. You can call contract functions on contract_instance as described in sections "Transacting and Calling Solidity Functions".
-
 All names used to name contract in solidity source will transalte to name of classes in ruby (camelized).
 If class of given name exist it will be undefined first to avoid name collision. 
 
 ### Get contract from blockchain
 
 The other way to obtain contract instance is get one form the blockchain. To do so you need a contract name, contract address and ABI definition.
+`client` parameter is optional.
 
 ```ruby
-contract_instance = Ethereum::Contract.from_blockchain("MyContract", "0x01a4d1A62F01ED966646acBfA8BB0b59960D06dd ", abi, client)
-
+contract = Ethereum::Contract.create(name: "MyContract", address: "0x01a4d1A62F01ED966646acBfA8BB0b59960D06dd ", abi: abi, client: client)
 ```
 
 Note that you need to specify contract name, that will be used to define new class in ruby, as it is not a part of ABI definition.
 
+If you want to create new contract, that is not yet deployed from ABI definition you need to supply binary code too:
+
+```ruby
+contract = Ethereum::Contract.create(name: "MyContract", address: "0x01a4d1A62F01ED966646acBfA8BB0b59960D06dd ", abi: abi, code: "...")
+```
+
 ### Transacting and Calling Solidity Functions
 
-Solidity functions are exposed using the following conventions: 
+Functions defined in a contract are exposed using the following conventions: 
 
 ```
-transact_[function_name](params) 
-transact_and_wait_[function_name](params)  
-call_[function_name](params)
+contract.transact.[function_name](params) 
+contract.transact_and_wait.[function_name](params)  
+contract.call.[function_name](params)
 ```
 
 **Example Contract in Solidity**
@@ -127,27 +130,23 @@ contract SimpleNameRegistry {
 }
 ```
 
-```ruby
-simple_name_registry_instance.transact_and_wait_register("0x5b6cb65d40b0e27fab87a2180abcab22174a2d45", "minter.contract.dgx")
-simple_name_registry_instance.transact_register("0x385acafdb80b71ae001f1dbd0d65e62ec2fff055", "anthony@eufemio.dgx")
-simple_name_registry_instance.call_get_some_value("0x385acafdb80b71ae001f1dbd0d65e62ec2fff055")
-simple_name_registry_instance.call_my_mapping("0x385acafdb80b71ae001f1dbd0d65e62ec2fff055")
-```
-
-### Run contracts using a different address
+And here is how to access it's methods:
 
 ```ruby
-simple_name_registry_instance.as("0x0c0d99d3608a2d1d38bb1b28025e970d3910b1e1")
+contract.transact_and_wait.register("0x5b6cb65d40b0e27fab87a2180abcab22174a2d45", "minter.contract.dgx")
+contract.transact.register("0x385acafdb80b71ae001f1dbd0d65e62ec2fff055", "anthony@eufemio.dgx")
+contract.call.get_some_value("0x385acafdb80b71ae001f1dbd0d65e62ec2fff055")
 ```
 
-### Point contract instance to a previously deployed contract
+Note that as `register` method will change contract state, so you need to use `transact` family of methods (or `transact_and_wait` for synchronous version) to call it.
+
+For method like `getSomeValue`, that does not affect state of the contract (and don't need to propagate change to blockchain therefore) you can use call method. It will retrive value from local copy of the blockchain.
 
-```ruby
-simple_name_registry_instance.at("0x734533083b5fc0cd14b7cb8c8eb6ed0c9bd184d3")
-```
 
 ## Utils rake tasks
 
+There is plenty of useful rake tasks for interacting with blockchain:
+
 ```ruby
 rake ethereum:contract:compile[path]            # Compile a contract / Compile and deploy contract
 rake ethereum:node:mine                         # Mine ethereum testing environment for ethereum node
@@ -160,7 +159,7 @@ rake ethereum:transaction:send[address,amount]  # Send [amount of] ether to an a
 ```
 
 ## Debbuging
-Logs from communication with node are available under following path:
+Logs from communication between ruby app and node are available under following path:
 ```
 /tmp/ethereum_ruby_http.log
 ```
@@ -171,13 +170,13 @@ After checking out the repo, run `bin/setup` to install dependencies.
 Make sure `rake ethereum:test:setup` passes before running tests.
 Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
+You need ethereum node up and running for tests to pass and it needs to be working on testnet (Ropsten).
+
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
-## Ethereum ruby
+## Acknowledgements and license
 
 This library has been forked from [ethereum-ruby](https://github.com/DigixGlobal/ethereum-ruby) by DigixGlobal Pte Ltd (https://dgx.io).
 
-## License
-
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
 

data/bin/install_parity

@@ -1,29 +1,21 @@
 #!/bin/bash
 
-install_parity () {
-  sudo add-apt-repository ppa:ethereum/ethereum -y
-  sudo apt-get update
-  sudo apt-get install solc
-  wget http://d1h4xl4cr1h0mo.cloudfront.net/v1.4.8/x86_64-unknown-linux-gnu/parity_1.4.8_amd64.deb
-  sudo dpkg -i parity_1.4.8_amd64.deb
-}
-
-
-
 echo "Installing parity..."
+sudo add-apt-repository ppa:ethereum/ethereum -y
+sudo apt-get update
+sudo apt-get install solc
+sudo apt-get -y install libssl-dev
+echo "Solc version"
+solc --version
+wget http://d1h4xl4cr1h0mo.cloudfront.net/v$PARITY\/x86_64-unknown-linux-gnu/parity_$PARITY\_amd64.deb
+sudo dpkg -i parity_$PARITY\_amd64.deb
 
-if [ `which parity` ]; then
-  echo "Parity cached, skipping"
-  install_parity
-else
-  echo "Settuping parity..."
-  install_parity
-  mkdir -p ~/.parity
-  wget https://raw.githubusercontent.com/ethcore/parity/master/ethcore/res/ethereum/ropsten.json --output-document ~/.parity/ropsten.json
-  echo $pass > ~/.parity/pass
-  mkdir -p ~/.parity/keys  
-  echo $wallet > ~/.parity/keys/10890ad6-5171-4945-be95-984d83394120
-  chown -R travis:travis ~/.parity
-fi
+echo "Setuping parity..."
+mkdir -p ~/.parity
+wget https://raw.githubusercontent.com/ethcore/parity/master/ethcore/res/ethereum/ropsten.json --output-document ~/.parity/ropsten.json
+echo $pass > ~/.parity/pass
+mkdir -p ~/.parity/keys
+echo $wallet > ~/.parity/keys/UTC--2017-01-08T21-02-29.039669388Z--3089630d06fd90ef48a0c43f000971587c1f3247
+chown -R travis:travis ~/.parity
 
 ls -la ~/.parity

data/lib/ethereum.rb

@@ -4,6 +4,7 @@ require 'active_support/core_ext'
 require 'digest/sha3'
 
 module Ethereum
+  require 'ethereum/abi'
   require 'ethereum/client'
   require 'ethereum/ipc_client'
   require 'ethereum/http_client'
@@ -15,6 +16,8 @@ module Ethereum
   require 'ethereum/function_input'
   require 'ethereum/function_output'
   require 'ethereum/contract_event'
+  require 'ethereum/encoder'
+  require 'ethereum/decoder'
   require 'ethereum/formatter'
   require 'ethereum/transaction'
   require 'ethereum/deployment'

data/lib/ethereum/abi.rb

@@ -0,0 +1,18 @@
+module Ethereum
+  class Abi
+
+    def self.parse_abi(abi)
+      constructor_inputs = abi.detect {|x| x["type"] == "constructor"}["inputs"] rescue nil
+      functions = abi.select {|x| x["type"] == "function" }.map { |fun| Ethereum::Function.new(fun) }
+      events = abi.select {|x| x["type"] == "event" }.map { |evt| Ethereum::ContractEvent.new(evt) }
+      [constructor_inputs, functions, events]
+    end
+
+    def self.parse_type(type)
+      raise NotImplementedError if type.ends_with?("]")
+      match = /(\D+)(\d.+)?/.match(type)
+      [match[1], match[2]]
+    end
+
+  end
+end

data/lib/ethereum/contract.rb

@@ -1,266 +1,211 @@
 module Ethereum
   class Contract
 
-    DEFAULT_GAS_PRICE = 60000000000
+    attr_reader :address
+    attr_accessor :code, :name, :abi, :class_object, :sender, :deployment, :client
+    attr_accessor :events, :functions, :constructor_inputs
+    attr_accessor :call_raw_proxy, :call_proxy, :transact_proxy, :transact_and_wait_proxy
+    attr_accessor :new_filter_proxy, :get_filter_logs_proxy, :get_filter_change_proxy
 
-    DEFAULT_GAS = 3000000
-
-    attr_accessor :code, :name, :functions, :abi, :constructor_inputs, :events, :class_object
-
-    def initialize(name, code, abi)
+    def initialize(name, code, abi, client = Ethereum::Singleton.instance)
       @name = name
       @code = code
       @abi = abi
-      @functions = []
-      @events = []
-      @constructor_inputs = @abi.detect {|x| x["type"] == "constructor"}["inputs"] rescue nil
-      @abi.select {|x| x["type"] == "function" }.each do |abifun|
-        @functions << Ethereum::Function.new(abifun) 
-      end
-      @abi.select {|x| x["type"] == "event" }.each do |abievt|
-        @events << Ethereum::ContractEvent.new(abievt)
-      end
+      @constructor_inputs, @functions, @events = Ethereum::Abi.parse_abi(abi)
+      @formatter = Ethereum::Formatter.new
+      @client = client
+      @sender = client.default_account
+      @encoder = Encoder.new
+      @decoder = Decoder.new
     end
 
-    def self.from_file(path, client = Ethereum::Singleton.instance)
-      @init = Ethereum::Initializer.new(path, client)
-      contracts = @init.build_all
-      raise "No contracts complied" if contracts.empty?
-      contracts.first.class_object.new
-    end
-
-    def self.from_blockchain(name, address, abi, client = Ethereum::Singleton.instance)
-      contract = Ethereum::Contract.new(name, nil, abi)
-      contract.build(client)
-      contract_instance = contract.class_object.new
-      contract_instance.at address
-      contract_instance
+    def self.create(file: nil, client: Ethereum::Singleton.instance, code: nil, abi: nil, address: nil, name: nil)
+      contract = nil
+      if file.present?
+        contracts = Ethereum::Initializer.new(file, client).build_all
+        raise "No contracts complied" if contracts.empty?
+        contract = contracts.first.class_object.new
+      else
+        abi = JSON.parse(abi) if abi.is_a? String
+        contract = Ethereum::Contract.new(name, code, abi, client)
+        contract.build
+        contract = contract.class_object.new
+      end
+      contract.address = address
+      contract
     end
 
-    def build(connection)
-      class_name = @name.camelize
-      functions = @functions
-      constructor_inputs = @constructor_inputs
-      binary = @code
-      events = @events
-      abi = @abi
-
-      class_methods = Class.new do
-
-        define_method "connection".to_sym do
-          connection
-        end
-
-        define_method :deploy do |*params|
-          formatter = Ethereum::Formatter.new
-          deploy_code = binary
-          deploy_arguments = ""
-          if constructor_inputs.present?
-            raise "Missing constructor parameter" and return if params.length != constructor_inputs.length
-            constructor_inputs.each_index do |i|
-              args = [constructor_inputs[i]["type"], params[i]]
-              deploy_arguments << formatter.to_payload(args)
-            end
-          end
-          deploy_payload = deploy_code + deploy_arguments
-          deploytx = connection.eth_send_transaction({from: self.sender, data: "0x" + deploy_payload})["result"]
-          raise "Failed to deploy, did you unlock #{self.sender} account? Transaction hash: #{deploytx}" if deploytx.nil? || deploytx == "0x0000000000000000000000000000000000000000000000000000000000000000"
-          instance_variable_set("@deployment", Ethereum::Deployment.new(deploytx, connection))
-        end
-
-        define_method :estimate do |*params|
-          formatter = Ethereum::Formatter.new
-          deploy_code = binary
-          deploy_arguments = ""
-          if constructor_inputs.present?
-            raise "Missing constructor parameter" and return if params.length != constructor_inputs.length
-            constructor_inputs.each_index do |i|
-              args = [constructor_inputs[i]["type"], params[i]]
-              deploy_arguments << formatter.to_payload(args)
-            end
-          end
-          deploy_payload = deploy_code + deploy_arguments
-          deploytx = connection.eth_estimate_gas({from: self.sender, data: "0x" + deploy_payload})["result"]
-        end
-
-        define_method :events do
-          return events
-        end
-
-        define_method :abi do
-          return abi
-        end
-
-        define_method :deployment do
-          instance_variable_get("@deployment")
-        end
-
-        define_method :deploy_and_wait do |time = 200.seconds, *params, **args, &block|
-          self.deploy(*params)
-          self.deployment.wait_for_deployment(time, **args, &block)
-          instance_variable_set("@address", self.deployment.contract_address)
-          self.events.each do |event|
-            event.set_address(self.deployment.contract_address)
-            event.set_client(connection)
-          end
-          self.deployment.contract_address
-        end
-
-        define_method :at do |addr|
-          instance_variable_set("@address", addr) 
-          self.events.each do |event|
-            event.set_address(addr)
-            event.set_client(connection)
-          end
-        end
 
-        define_method :address do
-          instance_variable_get("@address")
-        end
-
-        define_method :as do |addr|
-          instance_variable_set("@sender", addr)
-        end
-
-        define_method :sender do
-          instance_variable_get("@sender") || connection.default_account
-        end
-
-        define_method :set_gas_price do |gp|
-          instance_variable_set("@gas_price", gp)
-        end
+    def address=(addr)
+      @address = addr
+      @events.each do |event|
+        event.set_address(addr)
+        event.set_client(@client)
+      end
+    end
 
-        define_method :gas_price do
-          instance_variable_get("@gas_price") || DEFAULT_GAS_PRICE
-        end
+    def deploy(*params)
+      if @constructor_inputs.present?
+        raise "Missing constructor parameter" and return if params.length != @constructor_inputs.length
+      end
+      deploy_arguments = @formatter.construtor_params_to_payload(@constructor_inputs, params)
+      payload = "0x" + @code + deploy_arguments
+      tx = @client.eth_send_transaction({from: sender, data: payload})["result"]
+      raise "Failed to deploy, did you unlock #{sender} account? Transaction hash: #{deploytx}" if tx.nil? || tx == "0x0000000000000000000000000000000000000000000000000000000000000000"
+      @deployment = Ethereum::Deployment.new(tx, @client)
+    end
 
-        define_method :set_gas do |gas|
-          instance_variable_set("@gas", gas)
-        end
+    def deploy_and_wait(*params, **args, &block)
+      deploy(*params)
+      @deployment.wait_for_deployment(**args, &block)
+      self.events.each do |event|
+        event.set_address(@address)
+        event.set_client(@client)
+      end
+      @address = @deployment.contract_address
+    end
 
-        define_method :gas do 
-          instance_variable_get("@gas") || DEFAULT_GAS
+    def estimate(*params)
+      deploy_arguments = ""
+      if @constructor_inputs.present?
+        raise "Wrong number of arguments in a constructor" and return if params.length != @constructor_inputs.length
+        @constructor_inputs.each_index do |i|
+          args = [@constructor_inputs[i]["type"], params[i]]
+          deploy_arguments << @formatter.to_payload(args)
         end
+      end
+      deploy_payload = @code + deploy_arguments
+      result = @client.eth_estimate_gas({from: @sender, data: "0x" + deploy_payload})
+      @decoder.decode_int(result["result"])
+    end
 
-        events.each do |evt|
-          define_method "nf_#{evt.name.underscore}".to_sym do |params = {}|
-            params[:to_block] ||= "latest"
-            params[:from_block] ||= "0x0"
-            params[:address] ||=  instance_variable_get("@address")
-            params[:topics] = evt.signature
-            payload = {topics: [params[:topics]], fromBlock: params[:from_block], toBlock: params[:to_block], address: params[:address]}
-            filter_id = connection.new_filter(payload)
-            return filter_id["result"]
-          end
-
-          define_method "gfl_#{evt.name.underscore}".to_sym do |filter_id|
-            formatter = Ethereum::Formatter.new
-            logs = connection.get_filter_logs(filter_id)
-            collection = []
-            logs["result"].each do |result|
-              inputs = evt.input_types
-              outputs = inputs.zip(result["topics"][1..-1])
-              data = {blockNumber: result["blockNumber"].hex, transactionHash: result["transactionHash"], blockHash: result["blockHash"], transactionIndex: result["transactionIndex"].hex, topics: []} 
-              outputs.each do |output|
-                data[:topics] << formatter.from_payload(output)
-              end
-              collection << data 
-            end
-            return collection
-          end
-
-          define_method "gfc_#{evt.name.underscore}".to_sym do |filter_id|
-            formatter = Ethereum::Formatter.new
-            logs = connection.get_filter_changes(filter_id)
-            collection = []
-            logs["result"].each do |result|
-              inputs = evt.input_types
-              outputs = inputs.zip(result["topics"][1..-1])
-              data = {blockNumber: result["blockNumber"].hex, transactionHash: result["transactionHash"], blockHash: result["blockHash"], transactionIndex: result["transactionIndex"].hex, topics: []} 
-              outputs.each do |output|
-                data[:topics] << formatter.from_payload(output)
-              end
-              collection << data 
-            end
-            return collection
-          end
+    def call_raw(fun, *args)
+      arg_types = fun.inputs.collect(&:type)
+      return {result: :error, message: "missing parameters for #{fun.function_string}" } if arg_types.length != args.length
+      payload = [fun.signature]
+      arg_types.zip(args).each do |arg|
+        payload << @formatter.to_payload(arg)
+      end
+      raw_result = @client.eth_call({to: @address, from: @sender, data: "0x" + payload.join()})
+      raw_result = raw_result["result"]
+      output = @decoder.decode_arguments(fun.outputs, raw_result)
+      return {data: "0x" + payload.join(), raw: raw_result, formatted: output}
+    end
 
-        end
+    def call(fun, *args)
+      output = call_raw(fun, *args)[:formatted]
+      if output.length == 1
+        return output[0]
+      else
+        return output
+      end
+    end
 
-        functions.each do |fun|
+    def transact(fun, *args)
+      arg_types = fun.inputs.collect(&:type)
+      return {result: :error, message: "missing parameters for #{fun.function_string}" } if arg_types.length != args.length
+      payload = []
+      payload << fun.signature
+      arg_types.zip(args).each do |arg|
+        payload << @formatter.to_payload(arg)
+      end
+      txid = @client.eth_send_transaction({to: @address, from: @sender, data: "0x" + payload.join()})["result"]
+      return Ethereum::Transaction.new(txid, @client, payload.join(), args)
+    end
 
-          fun_count = functions.select {|x| x.name == fun.name }.count
-          derived_function_name = (fun_count == 1) ? "#{fun.name.underscore}" : "#{fun.name.underscore}__#{fun.inputs.collect {|x| x.type}.join("__")}"
-          call_function_name = "call_#{derived_function_name}".to_sym
-          call_function_name_alias = "c_#{derived_function_name}".to_sym
-          call_raw_function_name = "call_raw_#{derived_function_name}".to_sym
-          call_raw_function_name_alias = "cr_#{derived_function_name}".to_sym
-          transact_function_name = "transact_#{derived_function_name}".to_sym
-          transact_function_name_alias = "t_#{derived_function_name}".to_sym
-          transact_and_wait_function_name = "transact_and_wait_#{derived_function_name}".to_sym
-          transact_and_wait_function_name_alias = "tw_#{derived_function_name}".to_sym
+    def transact_and_wait(fun, *args)
+      tx = transact(fun, *args)
+      tx.wait_for_miner
+      return tx
+    end
 
-          define_method call_raw_function_name do |*args|
-            formatter = Ethereum::Formatter.new
-            arg_types = fun.inputs.collect(&:type)
-            connection = self.connection
-            return {result: :error, message: "missing parameters for #{fun.function_string}" } if arg_types.length != args.length
-            payload = []
-            payload << fun.signature
-            arg_types.zip(args).each do |arg|
-              payload << formatter.to_payload(arg)
-            end
-            raw_result = connection.eth_call({to: self.address, from: self.sender, data: "0x" + payload.join()})
-            raw_result = raw_result["result"]
-            formatted_result = fun.outputs.collect {|x| x.type }.zip(raw_result.gsub(/^0x/,'').scan(/.{64}/))
-            output = formatted_result.collect {|x| formatter.from_payload(x) }
-            return {data: "0x" + payload.join(), raw: raw_result, formatted: output}
-          end
+    def create_filter(evt, **params)
+      params[:to_block] ||= "latest"
+      params[:from_block] ||= "0x0"
+      params[:address] ||= @address
+      params[:topics] = @encoder.ensure_prefix(evt.signature)
+      payload = {topics: [params[:topics]], fromBlock: params[:from_block], toBlock: params[:to_block], address: @encoder.ensure_prefix(params[:address])}
+      filter_id = @client.eth_new_filter(payload)
+      return @decoder.decode_int(filter_id["result"])
+    end
 
-          define_method call_function_name do |*args|
-            data = self.send(call_raw_function_name, *args)
-            output = data[:formatted]
-            if output.length == 1 
-              return output[0]
-            else 
-              return output
-            end
-          end
+    def parse_filter_data(evt, logs)
+      formatter = Ethereum::Formatter.new
+      collection = []
+      logs["result"].each do |result|
+        inputs = evt.input_types
+        outputs = inputs.zip(result["topics"][1..-1])
+        data = {blockNumber: result["blockNumber"].hex, transactionHash: result["transactionHash"], blockHash: result["blockHash"], transactionIndex: result["transactionIndex"].hex, topics: []} 
+        outputs.each do |output|
+          data[:topics] << formatter.from_payload(output)
+        end
+        collection << data 
+      end
+      return collection
+    end
 
-          define_method transact_function_name do |*args|
-            formatter = Ethereum::Formatter.new
-            arg_types = fun.inputs.collect(&:type)
-            connection = self.connection
-            return {result: :error, message: "missing parameters for #{fun.function_string}" } if arg_types.length != args.length
-            payload = []
-            payload << fun.signature
-            arg_types.zip(args).each do |arg|
-              payload << formatter.to_payload(arg)
-            end
-            txid = connection.eth_send_transaction({to: self.address, from: self.sender, data: "0x" + payload.join()})["result"]
-            return Ethereum::Transaction.new(txid, self.connection, payload.join(), args)
-          end
+    def get_filter_logs(evt, filter_id)
+      parse_filter_data evt, @client.eth_get_filter_logs(filter_id)
+    end
 
-          define_method transact_and_wait_function_name do |*args|
-            function_name = "transact_#{derived_function_name}".to_sym
-            tx = self.send(function_name, *args)
-            tx.wait_for_miner
-            return tx
-          end
+    def get_filter_changes(evt, filter_id)
+      parse_filter_data evt, @client.eth_get_filter_changes(filter_id)
+    end
 
-          alias_method call_function_name_alias, call_function_name
-          alias_method call_raw_function_name_alias, call_raw_function_name
-          alias_method transact_function_name_alias, transact_function_name
-          alias_method transact_and_wait_function_name_alias, transact_and_wait_function_name
+    def function_name(fun)
+      count = functions.select {|x| x.name == fun.name }.count
+      name = (count == 1) ? "#{fun.name.underscore}" : "#{fun.name.underscore}__#{fun.inputs.collect {|x| x.type}.join("__")}"
+      name.to_sym
+    end
 
+    def build
+      class_name = @name.camelize
+      parent = self
+      create_function_proxies
+      create_event_proxies
+      class_methods = Class.new do
+        extend Forwardable
+        def_delegators :parent, :abi, :deployment, :events
+        def_delegators :parent, :estimate, :deploy, :deploy_and_wait
+        def_delegators :parent, :address, :address=, :sender, :sender=
+        def_delegator :parent, :call_raw_proxy, :call_raw
+        def_delegator :parent, :call_proxy, :call
+        def_delegator :parent, :transact_proxy, :transact
+        def_delegator :parent, :transact_and_wait_proxy, :transact_and_wait
+        def_delegator :parent, :new_filter_proxy, :new_filter
+        def_delegator :parent, :get_filter_logs_proxy, :get_filter_logs
+        def_delegator :parent, :get_filter_change_proxy, :get_filter_changes
+        define_method :parent do
+          parent
         end
       end
-      if Object.const_defined?(class_name)
-        Object.send(:remove_const, class_name)
-      end
+      Object.send(:remove_const, class_name) if Object.const_defined?(class_name)
       Object.const_set(class_name, class_methods)
       @class_object = class_methods
     end
 
+    private
+      def create_function_proxies
+        parent = self
+        call_raw_proxy, call_proxy, transact_proxy, transact_and_wait_proxy = Class.new, Class.new, Class.new, Class.new
+        @functions.each do |fun|
+          call_raw_proxy.send(:define_method, parent.function_name(fun)) { |*args| parent.call_raw(fun, *args) }
+          call_proxy.send(:define_method, parent.function_name(fun)) { |*args| parent.call(fun, *args) }
+          transact_proxy.send(:define_method, parent.function_name(fun)) { |*args| parent.transact(fun, *args) }
+          transact_and_wait_proxy.send(:define_method, parent.function_name(fun)) { |*args| parent.transact_and_wait(fun, *args) }
+        end
+        @call_raw_proxy, @call_proxy, @transact_proxy, @transact_and_wait_proxy =  call_raw_proxy.new, call_proxy.new, transact_proxy.new, transact_and_wait_proxy.new
+      end
+
+      def create_event_proxies
+        parent = self
+        new_filter_proxy, get_filter_logs_proxy, get_filter_change_proxy = Class.new, Class.new, Class.new
+        events.each do |evt|
+          new_filter_proxy.send(:define_method, evt.name.underscore) { |*args| parent.create_filter(evt, *args) }
+          get_filter_logs_proxy.send(:define_method, evt.name.underscore) { |*args| parent.get_filter_logs(evt, *args) }
+          get_filter_change_proxy.send(:define_method, evt.name.underscore) { |*args| parent.get_filter_changes(evt, *args) }
+        end
+        @new_filter_proxy, @get_filter_logs_proxy, @get_filter_change_proxy = new_filter_proxy.new, get_filter_logs_proxy.new, get_filter_change_proxy.new
+      end
   end
 end

data/lib/ethereum/contract_event.rb

@@ -8,8 +8,7 @@ module Ethereum
       @input_types = data["inputs"].collect {|x| x["type"]}
       @inputs = data["inputs"].collect {|x| x["name"]}
       @event_string = "#{@name}(#{@input_types.join(",")})"
-      @signature = SHA3::Digest::SHA256.hexdigest(@event_string)
-      # @signature = Digest::SHA3.hexdigest @event_string, 256
+      @signature = Digest::SHA3.hexdigest(@event_string, 256)
     end
 
     def set_address(address)

data/lib/ethereum/contract_initializer.rb

@@ -40,7 +40,7 @@ module Ethereum
     end
 
     def build(connection)
-      @contract = Ethereum::Contract.new(@name, @binary, @abi) 
+      @contract = Ethereum::Contract.new(@name, @binary, @abi, client)
       @contract.build(connection)
     end
 

data/lib/ethereum/decoder.rb

@@ -0,0 +1,58 @@
+module Ethereum
+  class Decoder
+
+    def decode(type, value, start = 0)
+      value = value.gsub(/^0x/,'')
+      core, subtype = Abi::parse_type(type)
+      method_name = "decode_#{core}".to_sym
+      if "bytes" == core and subtype.nil?
+        decode_dynamic_bytes(value, start)
+      elsif "string" == core
+        self.send(method_name, value, start)
+      else
+        self.send(method_name, value[start..start+63])
+      end
+    end
+
+    def decode_uint(value)
+      value.hex
+    end
+
+    def decode_int(value)
+      raise ArgumentError if value.nil?
+      (value[0..1] == "ff") ? (value.hex - (2 ** 256)) : value.hex
+    end
+
+    def decode_bool(value)
+      return true if value == "0000000000000000000000000000000000000000000000000000000000000001"
+      return false if value == "0000000000000000000000000000000000000000000000000000000000000000"
+      raise ArgumentError
+    end
+
+    def decode_address(value)
+      raise ArgumentError if value.size != 40
+      value
+    end
+
+    def decode_bytes(value)
+      value.scan(/.{2}/).collect {|x| x.hex}.pack('C*').strip
+    end
+
+    def decode_dynamic_bytes(value, start = 0)
+      location = decode_uint(value[start..(start+63)]) * 2
+      size = decode_uint(value[location..location+63]) * 2
+      value[location+64..location+63+size].scan(/.{2}/).collect {|x| x.hex}.pack('C*')
+    end
+
+    def decode_string(value, start = 0)
+      decode_dynamic_bytes(value, start).force_encoding('utf-8')
+    end
+
+    def decode_arguments(arguments, data)
+      data = data.gsub(/^0x/,'')
+      types = arguments.map { |o| o.type }
+      types.each.with_index.map { |t , i| decode(t, data, i*64) }
+    end
+
+  end
+end

data/lib/ethereum/deployment.rb

@@ -35,9 +35,9 @@ module Ethereum
       @valid_deployment ||= check_deployed
     end
 
-    def wait_for_deployment(timeout = DEFAULT_TIMEOUT, step: DEFAULT_STEP, &block)
+    def wait_for_deployment(timeout: DEFAULT_TIMEOUT, step: DEFAULT_STEP)
       start_time = Time.now
-      while true
+      loop do
         raise "Transaction #{@id} timed out." if ((Time.now - start_time) > timeout) 
         sleep step
         yield if block_given?

data/lib/ethereum/encoder.rb

@@ -0,0 +1,71 @@
+module Ethereum
+
+  class Encoder
+
+    def encode(type, value)
+      core, subtype = Abi::parse_type(type)
+      if core == "bytes" and subtype.nil?
+        encode_dynamic_bytes(value)
+      else
+        method_name = "encode_#{core}".to_sym
+        self.send(method_name, value)
+      end
+    end
+
+    def encode_int(value)
+      to_twos_complement(value).to_s(16).rjust(64, '0')
+    end
+
+    def encode_uint(value)
+      raise ArgumentError if value < 0
+      encode_int(value)
+    end
+
+    def encode_bool(value)
+      (value ? "1" : "0").rjust(64, '0')
+    end
+
+    def encode_fixed(_value)
+      raise NotImplementedError
+    end
+
+    def encode_ufixed(_value)
+      raise NotImplementedError
+    end
+
+    def encode_bytes(value)
+      value.each_char.map {|x| x.ord.to_s(16)}.join("").ljust(64, '0')
+    end
+
+    def encode_dynamic_bytes(value)
+      location = encode_uint(32)
+      size = encode_uint(value.size)
+      content = encode_bytes(value)
+      location + size + content
+    end
+
+    def encode_string(value)
+      location = encode_uint(32)
+      size = encode_uint(value.bytes.size)
+      content = value.bytes.map {|x| x.to_s(16)}.join("").ljust(64, '0')
+      location + size + content
+    end
+
+    def encode_address(value)
+      value = value.gsub(/^0x/,'')
+      raise ArgumentError if value.size != 40
+      value
+    end
+
+    def ensure_prefix(value)
+      value.start_with?("0x") ? value : ("0x" + value)
+    end
+
+    private
+      def to_twos_complement(number)
+        (number & ((1 << 256) - 1))
+      end
+
+  end
+
+end

data/lib/ethereum/formatter.rb

@@ -103,6 +103,10 @@ module Ethereum
       (hexstring.gsub(/^0x/,'')[0..1] == "ff") ? (hexstring.hex - (2 ** 256)) : hexstring.hex
     end
 
+    def bool_to_payload(bool)
+      int_to_payload(bool ? 1 : 0)
+    end
+
     def address_to_payload(address)
       from_address(address)
     end
@@ -112,7 +116,7 @@ module Ethereum
     end
 
     def int_to_payload(int)
-      self.to_twos_complement(uint).rjust(64, '0')
+      self.to_twos_complement(int).rjust(64, '0')
     end
 
     def bytes_to_payload(bytes)
@@ -123,6 +127,10 @@ module Ethereum
       self.bytes_to_payload(bytes)
     end
 
+    def construtor_params_to_payload(abi, params)
+      abi.map.with_index { |var, i| to_payload([var["type"], params[i]]) }.join
+    end
+
     def get_base_type(typename)
       typename.gsub(/\d+/,'')
     end

data/lib/ethereum/function.rb

@@ -12,8 +12,24 @@ module Ethereum
       @outputs = data["outputs"].collect do |output|
         Ethereum::FunctionOutput.new(output)
       end
-      @function_string = "#{@name}(#{@inputs.collect {|x| x.type }.join(",")})"
-      @signature = Digest::SHA3.hexdigest(@function_string, 256)[0..7]
+      @function_string = self.class.calc_signature(@name, @inputs)
+      @signature = self.class.calc_id(@function_string)
+    end
+
+    def self.to_canonical_type(type)
+      type
+      .gsub(/(int)(\z|\D)/, '\1256\2')
+      .gsub(/(uint)(\z|\D)/, '\1256\2')
+      .gsub(/(fixed)(\z|\D)/, '\1128x128\2')
+      .gsub(/(ufixed)(\z|\D)/, '\1128x128\2')
+    end
+
+    def self.calc_signature(name, inputs)
+      "#{name}(#{inputs.collect {|x| self.to_canonical_type(x.type) }.join(",")})"
+    end
+
+    def self.calc_id(signature)
+      Digest::SHA3.hexdigest(signature, 256)[0..7]
     end
 
   end

data/lib/ethereum/http_client.rb

@@ -30,7 +30,7 @@ module Ethereum
       return response.body
     end
 
-    def send_batch(batch)
+    def send_batch(_batch)
       raise NotImplementedError
     end
   end

data/lib/ethereum/initializer.rb

@@ -13,13 +13,13 @@ module Ethereum
         abi = JSON.parse(sol_output[contract]["abi"] )
         name = contract
         code = sol_output[contract]["bin"]
-        @contracts << Contract.new(name, code, abi)
+        @contracts << Contract.new(name, code, abi, @client)
       end
     end
 
     def build_all
       @contracts.each do |contract|
-        contract.build(@client)
+        contract.build
       end
     end
 

data/lib/ethereum/ipc_client.rb

@@ -27,7 +27,6 @@ module Ethereum
       return read
     end
 
-    # TODO: Not sure if multithread safe
     # Note: Guarantees the results are in the same order as defined in batch call.
     # client.batch do
     #   client.eth_block_number

data/lib/ethereum/singleton.rb

@@ -8,7 +8,7 @@ class Ethereum::Singleton
       @instance ||= configure_instance(create_instance)
     end
   
-    def setup(&block)
+    def setup
       yield(self)
     end
     

data/lib/ethereum/solidity.rb

@@ -39,7 +39,7 @@ module Ethereum
       
       def execute_solc(dir, filename)
         cmd = "#{@bin_path} #{@args} '#{dir}' '#{filename}'"
-        stdout, stderr, status = Open3.capture3(cmd)
+        _, stderr, status = Open3.capture3(cmd)
         raise SystemCallError, "Unanable to run solc compliers" if status.exitstatus == 127
         raise CompilationError, stderr unless status.exitstatus == 0
       end    

data/lib/ethereum/version.rb

@@ -1,3 +1,3 @@
 module Ethereum
-  VERSION = "1.6.0"
+  VERSION = "2.0.0"
 end

data/lib/tasks/ethereum_contract.rake

@@ -4,20 +4,20 @@ namespace :ethereum do
   namespace :contract do
 
     desc "Compile a contract"
-    task :compile, [:path] do |t, args|
+    task :compile, [:path] do |_, args|
       contract = Ethereum::Solidity.new.compile(args[:path])
       puts "Contract abi:"
-      puts contract["Works"]["abi"]
+      puts contract.map { |k, v| "#{k}: #{v["abi"]}" }.join("\n\n")
       puts
       puts "Contract binary code:"
-      puts contract["Works"]["bin"]
+      puts contract.map { |k, v| "#{k}: #{v["bin"]}" }.join("\n\n")
       puts
     end
 
     desc "Compile and deploy contract"
-    task :deploy, [:path] do |t, args|
+    task :deploy, [:path] do |_, args|
       puts "Deploing contract #{args[:path]}"
-      @works = Ethereum::Contract.from_file(args[:path])
+      @works = Ethereum::Contract.create(file: args[:path])
       @works.deploy_and_wait { puts "." }
       address = @works.deployment.contract_address
       puts "Contract deployed under address: #{address}"

data/lib/tasks/ethereum_node.rake

@@ -5,8 +5,8 @@ namespace :ethereum do
 
     desc "Run testnet node "
     task :test do
-      stdout, stdeerr, status = Open3.capture3("parity --chain ~/.parity/ropsten.json account list")
-      account = stdeerr.split(/[\[,\]]/)[1]
+      _, out, _ = Open3.capture3("parity --chain ~/.parity/ropsten.json account list")
+      account = out.split(/[\[,\]]/)[1]
       cmd = "parity --chain ~/.parity/ropsten.json --password ~/.parity/pass --unlock #{account} --author #{account}"
       puts cmd
       system cmd
@@ -14,8 +14,8 @@ namespace :ethereum do
 
     desc "Run morden (production) node"
     task :run do
-      stdout, stdeerr, status = Open3.capture3("parity account list")
-      account = stdeerr.split(/[\[,\]]/)[1]
+      _, out, _ = Open3.capture3("parity account list")
+      account = out.split(/[\[,\]]/)[1]
       system "parity --password ~/.parity/pass --unlock #{account}  --author #{account} --no-jsonrpc"
     end
 
@@ -30,7 +30,7 @@ namespace :ethereum do
     task :waitforsync do
       formatter = Ethereum::Formatter.new
       begin
-        while (1) do
+        loop do
            result = Ethereum::Singleton.instance.eth_syncing["result"]
            unless result
              puts "Synced"

data/lib/tasks/ethereum_transaction.rake

@@ -5,13 +5,13 @@ namespace :ethereum do
   namespace :transaction do
 
     desc "Get info about transaction"
-    task :byhash, [:id] do |t, args|
+    task :byhash, [:id] do |_, args|
       @client = Ethereum::Singleton.instance
       pp @client.eth_get_transaction_by_hash(args[:id])
     end
 
     desc "Send"
-    task :send, [:address, :amount] do |t, args|
+    task :send, [:address, :amount] do |_, args|
       @client = Ethereum::Singleton.instance
       @formatter = Ethereum::Formatter.new
       address = @formatter.to_address(args[:address])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ethereum.rb
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Marek Kirejczyk
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-18 00:00:00.000000000 Z
+date: 2017-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -147,11 +147,14 @@ files:
 - contracts/classic/QueueSample.sol
 - ethereum.gemspec
 - lib/ethereum.rb
+- lib/ethereum/abi.rb
 - lib/ethereum/client.rb
 - lib/ethereum/contract.rb
 - lib/ethereum/contract_event.rb
 - lib/ethereum/contract_initializer.rb
+- lib/ethereum/decoder.rb
 - lib/ethereum/deployment.rb
+- lib/ethereum/encoder.rb
 - lib/ethereum/formatter.rb
 - lib/ethereum/function.rb
 - lib/ethereum/function_input.rb
@@ -191,7 +194,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Ruby Ethereum client using the JSON-RPC interface