ethereum.rb 2.0.4 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fed925e12c750f5d20aacd3ac6629f53a9b5f2bd
-  data.tar.gz: 0bfd128f76455bea9937f82d4d338923d7c6108f
+  metadata.gz: be2456e92fe65e0d189e20fe4918441737ec34f9
+  data.tar.gz: 2d02debd5fa6c4f521ffb0d12d58d595d5694441
 SHA512:
-  metadata.gz: 04f8f2bada3e7ad9862a36793954452ce4a6c7f0244953bac92a6321dd815422a717d67954b9e7b7d7e9a034e543401ad5cb3de430e6886558a10bbaaad267eb
-  data.tar.gz: 25db0535bd9f92c205e2cbb3b3eaad6da21994893b7431e7192d8ed5bd59698cdd7e0401b0b9d805a2f14a2abf88aea970b4f04dfdffc89be5a3223cb0ec1c50
+  metadata.gz: 178e6371e427adf8524a44e5a578207eb581fc4bc7cb987e499c034f5a64340089034358cd2d9bc8054d35dfc8b5bd03fc75b0dc1703f7a8bbbfe6f165e776ec
+  data.tar.gz: e9c0fa8ba6f3f28ad908ebf0da7347ea41d5a10b0061b0d37ebc70f62dfd91c4ca3c76ffd5e073758b71fd4805a72a55b391ad19917d37a13b023653d6b91cf4

data/PREREQUISITES.md

@@ -2,29 +2,37 @@
 
 ## Compatibility and requirements
 
-* Tested with parity 1.5.0, might work with geth (but was not tested)
+* Tested with parity 1.5, might work with geth and older parity, but was not tested.
 * Tested with solc 0.4.9
 * Ruby 2.x
 * UNIX/Linux or OS X environment
 
-## Prerequisites
-
-Ethereum.rb requires installation of ethereum node and solidity compiler.
+## Installing prerequisites
 
 ### Ethereum node
 
-Currently the lib supports only [parity](https://ethcore.io/parity.html). To install parity on mac simply:
+Currently the only node supported by ethereum.rb is [parity](https://ethcore.io/parity.html). To install parity on mac simply:
 
+    $ brew tap ethcore/ethcore
     $ brew install parity --beta
 
 To install parity on linux download latest package from [parity github](https://github.com/ethcore/parity/releases) and install on your computer.
 
-It might work with [geth](https://github.com/ethereum/go-ethereum/wiki/geth) as well, but this configuration is not tested. Library assumes that you have at least one wallet configured.
+It might work with [geth](https://github.com/ethereum/go-ethereum/wiki/geth) as well, but this configuration is not tested. 
+
+To work correctly ethereum.rb needs parity to have at least one wallet configured. Parity should automatically create one for you during installation. 
+You can see the list of wallets by calling:
+
+    $ parity account list
+
+And create one with following command:
+
+    $ parity account new
 
 ### Solidity complier
 
 To be able to compile [solidity](https://github.com/ethereum/solidity) contracts you need to install solc compiler. Installation instructions are available [here](http://solidity.readthedocs.io/en/latest/installing-solidity.html).
-To install on mac simply:
+To install on mac type:
 
     $ brew install solidity --beta
 
@@ -45,3 +53,20 @@ And then execute:
 Or install it yourself as:
 
     $ gem install ethereum.eb
+
+### Running a node
+
+There is a rake task to run node on testnet network, that you can run from your application directory:
+
+    $ rake ethereum:node:test
+
+It will run parity node, unlock the first account on the account list, but you need to supply it with password. 
+To do that adding create file containing password accessable from your parity folder, which should be one of the following:
+ * `/Users/You/AppData/Roaming/Parity/Ethereum` on Windows
+ * `/Users/you/Library/Application Support/io.parity.ethereum` on MacOS
+ * `/home/you/.local/share/parity` on Linux/Unix
+ * `/home/you/.parity` on Linux and MacOS for Parity versions older then 1.5.0
+
+Warnning: Running a parity node with unlock wallet is a considerable security risk and should be avoided on production servers. Especially avoid running node with unlocked wallet and enabled json rpc server in http mode.
+
+To send transaction on a testnet blockchain you will need test ether, you can get it [here](http://faucet.ropsten.be:3001/).

data/README.md

@@ -4,18 +4,27 @@
 
 The goal of ethereum.rb is to make interacting with ethereum blockchain from ruby as easy as possible (but not easier).
 
+Announcement: The Ropsten network is currently being spammed, therefore CI is down and you might have issues to start working with testnet. Use mainnet instead.
+
 ## Highlights
 
+* Simple syntax, programmer friendly
 * Deploy and interact with contracts on the blockchain
+* Contract - ruby object mapping
 * Compile Solidity contracts with solc compiler from ruby
-* Receive events from contract 
-* Run json rpc calls from ruby
+* Receive events from contract
+* Make direct json rpc calls to node from ruby application
 * Connect to node via IPC or HTTP
 * Helpful rake tasks for common actions
 
 ## Installation
 
-Before installing gem make sure you meet all [prerequisites](https://github.com/marekkirejczyk/ethereum.rb/blob/master/PREREQUISITES.md).
+Before installing gem make sure you meet all [prerequisites](https://github.com/marekkirejczyk/ethereum.rb/blob/master/PREREQUISITES.md), especially that you have:
+* compatible ethereum node installed
+* compatible solidity compiler installed
+* wallet with some ethereum on it
+
+Before you run a program check that the node is running and accounts you want to spend from are unlocked.
 
 To install gem simply add this line to your application's Gemfile:
 
@@ -33,125 +42,173 @@ Or install it yourself as:
 
 ## Basic Usage
 
-### Running a node
-
-Right after parity installation you will have one default account. There is a rake task to run test node, that you can run from your application directory:
-
-    $ rake ethereum:node:test
-    
-It will run parity node, unlock the first account on the account list, but you need to supply it with password. To do that adding create file containing password accessable from the following path:
-
-`~/.parity/pass`
-
-To run operations modifiying blockchain you will need test ether, you can get it [here](http://faucet.ropsten.be:3001/).
-
-### IPC Client Connection
-
-To create client instance simply create Ethereum::IpcClient:
+You can create contract from solidity source and deploy it to the blockchain, with following code:
 
 ```ruby
-client = Ethereum::IpcClient.new
+contract = Ethereum::Contract.create(file: "greeter.sol")
+address = contract.deploy_and_wait("Hello from ethereum.rb!")
 ```
 
-You can also customize it with path to ipc file path and logging flag:
+Deployment may take up to couple of minutes. Once deployed you can start interacting with contract, e.g. calling it's methods:
 
 ```ruby
-client = Ethereum::IpcClient.new("~/.parity/mycustom.ipc", false)
+contract.call.greet # => "Hello from ethereum.rb!"
 ```
 
-If no ipc file path given, IpcClient looks for ipc file in default locations for parity and geth.
-By default logging is on and logs are saved in "/tmp/ethereum_ruby_http.log".
+You can see example contract [greeter here](https://github.com/marekkirejczyk/ruby_ethereum_example/blob/master/contracts/greeter.sol).
 
+## Creating contract
 
-### Solidity contract compilation and deployment
-
-You can create contract from solidity source and deploy it to the blockchain.
-
-```ruby
-contract = Ethereum::Contract.create(file: "mycontract.sol", client: client)
-address = contract.deploy_and_wait
-```
+### Compile multiple contracts at once
 
-Deployment may take up to couple minutes.
-If you want to complie multiple contracts at once, you can create new instances using newly declared clasess:
+If you want to complie multiple contracts at once, you can create new instances using newly declared ruby clasess:
 
 ```ruby
-Ethereum::Contract.create(file: "mycontract.sol", client: client)
-contract = MyContract.new
+Ethereum::Contract.create(file: "mycontracts.sol", client: client)
+contract = MyContract1.new
 contract = contract.deploy_and_wait
+contract2 = MyContract2.new
+contract2 = contract.deploy_and_wait
 ```
 
 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. 
+
+Note: 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.
+The other way to obtain contract instance is get one that already exist in the blockchain. To do so you need a contract name, contract address and ABI definition.
 
 ```ruby
-contract = Ethereum::Contract.create(name: "MyContract", address: "0x01a4d1A62F01ED966646acBfA8BB0b59960D06dd ", abi: abi, client: client)
+contract = Ethereum::Contract.create(name: "MyContract", address: "0x01a4d1A62F01ED966646acBfA8BB0b59960D06dd ", abi: abi)
 ```
 
 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:
+Alternatively you can obtain abi definition and name from contract source file:
+
+```ruby
+contract = Ethereum::Contract.create(file: "MyContract.sol", address: "0x01a4d1A62F01ED966646acBfA8BB0b59960D06dd ")
+```
+
+If you want to create new contract, that is not yet deployed from ABI definition you will need also to supply binary code:
 
 ```ruby
-contract = Ethereum::Contract.create(name: "MyContract", address: "0x01a4d1A62F01ED966646acBfA8BB0b59960D06dd ", abi: abi, code: "...")
+contract = Ethereum::Contract.create(name: "MyContract", abi: abi, code: "...")
 ```
 
-### Transacting and Calling Solidity Functions
+### Interacting with contract
 
-Functions defined in a contract are exposed using the following conventions: 
+Functions defined in a contract are exposed using the following conventions:
 
 ```
-contract.transact.[function_name](params) 
+contract.transact.[function_name](params)
 contract.transact_and_wait.[function_name](params)  
 contract.call.[function_name](params)
 ```
 
 **Example Contract in Solidity**
 ```
-contract SimpleNameRegistry {
+contract SimpleRegistry {
 
-  mapping (address => bool) public myMapping;
+  mapping (bytes32 => string) public registry;
 
-  function register(address _a, bytes32 _b) {
+  function register(bytes32 key, string value) {
+    registry[key] = value;
   }
 
-  function getSomeValue(address _x) public constant returns(bool b, address b) {
+  function get(bytes32 key) public constant returns(string) {
+    return registry[key];
   }
 
 }
 ```
 
-And here is how to access it's methods:
+For contract above here is how to access it's methods:
+
+```ruby
+contract.transact_and_wait.register("performer", "Beastie Boys")
+```
+
+Will send transaction to the blockchain and wait for it to be mined.
+
+```ruby
+contract.transact.register("performer", "Black Eyed Peas")
+```
+
+Will send transaction to the blockchain return instantly.
+
+```ruby
+contract.call.get("performer") # => "Black Eyed Peas"
+```
+
+Will call method of the contract and return result.
+Note that no transaction need to be send to the network as method is read-only.
+On the other hand `register` method will change contract state, so you need to use `transact` or `transact_and_wait` to call it.
+
+
+### IPC Client Connection
+
+By default methods interacting with contracts will use default Json RPC Client that will handle connection to ethereum node.
+Default client communicate via IPC. If you want to create custom client or use multiple clients you can create them yourself.
+
+To create IPC client instance of simply create Ethereum::IpcClient:
+
+```ruby
+client = Ethereum::IpcClient.new
+```
+
+You can also customize it with path to ipc file path and logging flag:
 
 ```ruby
-contract.transact_and_wait.register("0x5b6cb65d40b0e27fab87a2180abcab22174a2d45", "minter.contract.dgx")
-contract.transact.register("0x385acafdb80b71ae001f1dbd0d65e62ec2fff055", "anthony@eufemio.dgx")
-contract.call.get_some_value("0x385acafdb80b71ae001f1dbd0d65e62ec2fff055")
+client = Ethereum::IpcClient.new("~/.parity/mycustom.ipc", false)
 ```
 
-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.
+If no ipc file path given, IpcClient looks for ipc file in default locations for parity and geth.
+The second argument is optional. If it is true then logging is on.
 
-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.
+By default logging is on and logs are saved in "/tmp/ethereum_ruby_http.log".
+
+To create Http client use following:
+
+```ruby
+client = Ethereum::HttpClient.new('http://localhost:8545')
+```
 
+You can supply client when creating a contract:
+
+```ruby
+contract = Ethereum::Contract.create(client: client, ...)
+```
+
+You can also obtain default client:
+
+```ruby
+client = Ethereum::Singleton.instance
+```
+
+### Calling json rpc methods
+
+Ethereum.rb allows you to interact directly with Ethereum node using json rpc api calls.
+Api calls translates directly to client methods. E.g. to call `eth_gasPrice` method:
+
+```ruby
+client.eth_gas_price # => {"jsonrpc"=>"2.0", "result"=>"0x4a817c800", "id"=>1}
+```
+
+Note: methods are transated to underscore notation.
+
+Full list of json rpc methods is available [here](https://github.com/ethereum/wiki/wiki/JSON-RPC#user-content-json-rpc-methods)
 
 ## Utils rake tasks
 
-There is plenty of useful rake tasks for interacting with blockchain:
+There are couple of rake tasks to help in wallet maintenance, i.e.:
 
 ```ruby
-rake ethereum:contract:compile[path]            # Compile a contract / Compile and deploy contract
-rake ethereum:node:mine                         # Mine ethereum testing environment for ethereum node
-rake ethereum:node:run                          # Run morden (production) node
-rake ethereum:node:test                         # Run testnet node
-rake ethereum:test:setup                        # Setup testing environment for ethereum node
+rake ethereum:contract:deploy[path]             # Compile and deploy contract
+rake ethereum:contract:compile[path]            # Compile a contract
 rake ethereum:transaction:byhash[id]            # Get info about transaction
 rake ethereum:transaction:send[address,amount]  # Send [amount of] ether to an account
-
 ```
 
 ## Debbuging
@@ -162,17 +219,16 @@ Logs from communication between ruby app and node are available under following
 
 ## Roadmap
 
-* Dynamic arrays serialization 
-* Signing transactions 
-
+* Rubydoc documentation
+* Signing transactions
 
 ## Development
 
-Make sure `rake ethereum:test:setup` passes before running tests. 
+Run `bin/console` for an interactive prompt that will allow you to experiment.
 
-You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Make sure `rake ethereum:test:setup` passes before running tests.
 
-Then, run `rake spec` to run the tests. 
+Then, run `rake spec` to run the tests.
 
 Test that do send transactions to blockchain are marked with `blockchain` tag. Good practice is to run first fast tests that use no ether and only if they pass, run slow tests that do spend ether. To do that  use the following line:
 
@@ -185,4 +241,3 @@ You need ethereum node up and running for tests to pass and it needs to be worki
 This library has been forked from [ethereum-ruby](https://github.com/DigixGlobal/ethereum-ruby) by DigixGlobal Pte Ltd (https://dgx.io).
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/lib/ethereum/client.rb

@@ -48,46 +48,38 @@ module Ethereum
       @default_account || eth_accounts["result"][0]
     end
 
-    def int_to_hex(n)
-      return "0x#{n.to_s(16)}"
+    def int_to_hex(p)
+      p.is_a?(Integer) ? "0x#{p.to_s(16)}" : p 
     end
 
-    # https://github.com/ethereum/wiki/wiki/JSON-RPC#output-hex-values
     def encode_params(params)
-      return params.map do |p|
-        if p.is_a?(Integer)
-          int_to_hex(p)
-        else
-          p
-        end
+      params.map(&method(:int_to_hex))
+    end
+
+    def send_command(command,args)
+      if ["eth_getBalance", "eth_call"].include?(command)
+        args << "latest"
+      end
+
+      payload = {jsonrpc: "2.0", method: command, params: encode_params(args), id: get_id}
+
+      @logger.info("Sending #{payload.to_json}") if @log
+
+      if @batch
+        @batch << payload
+        return true
+      else
+        output = JSON.parse(send_single(payload.to_json))
+        @logger.info("Received #{output.to_json}") if @log
+        reset_id
+        return output
       end
     end
 
     (RPC_COMMANDS + RPC_MANAGEMENT_COMMANDS).each do |rpc_command|
       method_name = rpc_command.underscore
       define_method method_name do |*args|
-        command = rpc_command
-        if ["eth_getBalance", "eth_call"].include?(command)
-          args << "latest"
-        end
-        payload = {jsonrpc: "2.0", method: command, params: encode_params(args), id: get_id}
-
-        if @log == true
-          @logger.info("Sending #{payload.to_json}")
-        end
-
-        if @batch
-          @batch << payload
-          return true
-        else
-          read = send_single(payload.to_json)
-          output = JSON.parse(read)
-          if @log == true
-            @logger.info("Received #{output.to_json}")
-          end
-          reset_id
-          return output
-        end
+        send_command(rpc_command, args)
       end
     end
 

data/lib/ethereum/decoder.rb

@@ -16,13 +16,13 @@ module Ethereum
     end
 
     def decode_static_array(arity, array_subtype, value, start)
-      (1..arity).map.with_index { |e, i| decode(array_subtype, value, start + i * 64) }
+      (0..arity-1).map { |i| decode(array_subtype, value, start + i * 64) }
     end
 
     def decode_dynamic_array(array_subtype, value, start)
       location = decode_uint(value[start..(start+63)]) * 2
       size = decode_uint(value[location..location+63])
-      (1..size).map.with_index { |e, i| decode(array_subtype, value, location + (i+1) * 64) }
+      (0..size-1).map { |i| decode(array_subtype, value, location + (i+1) * 64) }
     end
 
     def decode_fixed(value, subtype = "128x128", start = 0)
@@ -85,7 +85,7 @@ module Ethereum
         subtype.present? ? subtype.to_i : default
       end
 
-      def fixed_bitsize(subtype = nil, default = 256)
+      def fixed_bitsize(subtype = nil)
         subtype ||= "128x128"
         _, x, n = /(\d+)x(\d+)/.match(subtype).to_a
         x.to_i + n.to_i

data/lib/ethereum/encoder.rb

@@ -16,13 +16,14 @@ module Ethereum
     end
 
     def encode_static_array(arity, array_subtype, array)
-      (1..arity).map.with_index { |e, i| encode(array_subtype, array[i]) }.join
+      raise "Wrong number of arguments" if arity != array.size
+      array.inject("") { |a, e| a << encode(array_subtype, e) }
     end
 
     def encode_dynamic_array(array_subtype, array)
       location = encode_uint(@inputs ? size_of_inputs(@inputs) + @tail.size/2 : 32)
       size = encode_uint(array.size)
-      data = (1..array.size).map.with_index { |e, i| encode(array_subtype, array[i]) }.join
+      data = array.inject("") { |a, e| a << encode(array_subtype, e) }
       [location, size + data]
     end
 

data/lib/ethereum/railtie.rb

@@ -4,6 +4,8 @@ module Ethereum
     rake_tasks do
       load('tasks/ethereum_test.rake')
       load('tasks/ethereum_node.rake')
+      load('tasks/ethereum_contract.rake')
+      load('tasks/ethereum_transaction.rake')
     end
   end
 

data/lib/ethereum/solidity.rb

@@ -19,8 +19,8 @@ module Ethereum
 
     def compile(filename)
       result = {}
-      execute_solc(nil, filename).scan(OUTPUT_REGEXP).each do |match|
-        file, name, bin, abi = match
+      execute_solc(filename).scan(OUTPUT_REGEXP).each do |match|
+        _file, name, bin, abi = match
         result[name] = {}
         result[name]["abi"] = abi
         result[name]["bin"] = bin
@@ -29,7 +29,7 @@ module Ethereum
     end
 
     private    
-      def execute_solc(dir, filename)
+      def execute_solc(filename)
         cmd = "#{@bin_path} #{@args} '#{filename}'"
         out, stderr, status = Open3.capture3(cmd)
         raise SystemCallError, "Unanable to run solc compliers" if status.exitstatus == 127

data/lib/ethereum/version.rb

@@ -1,3 +1,3 @@
 module Ethereum
-  VERSION = "2.0.4"
+  VERSION = "2.0.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ethereum.rb
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.0.5
 platform: ruby
 authors:
 - Marek Kirejczyk
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-05 00:00:00.000000000 Z
+date: 2017-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -195,7 +195,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Ruby Ethereum client using the JSON-RPC interface