ethereum.rb 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9c3d499f0acb7794b25b60c3caec8f728ce1212e
-  data.tar.gz: e3a239e91d23154acb7bbbc2ba4a528e7754b1eb
+  metadata.gz: ab1aee5c95b0e162120826ec4d182dad03a7e771
+  data.tar.gz: 71652479b2bb2a4f81a5d8b417a8703dff1492c6
 SHA512:
-  metadata.gz: 5b91b2eeb93f071839e1f7985915c4ec1ca47a98d58741e6e314b374a7c3aed13db7e2da53672b2075f3783a8508050aa5830404b79755cba04cf91ebf69a453
-  data.tar.gz: c82e52904d885da8073c8a1af9f33a9f70610d2dd12e1acbeb35c937e9dffdb73e8a707b1025f2527c5b914881c4b2bfb43d96ce993a54388ccd90bb880f08ef
+  metadata.gz: 66065eda0356fa17adf2e017e202c90f8f7e237b0652257816bee3e3cd73d16c435e4bfc1b27d9c69446f5a5d1b53e4b11515e13a56ce48b08f162cc99db90ae
+  data.tar.gz: 7a34dd68afe840e9f1c37edc64df9176aa7224f38f10fe3c954f3038de7099a76d62dd0fcddd3ae1680285b1ea33f3d9c94a01cc09c8aaf60cdd1571366c69c8

data/PREREQUISITES.md

@@ -0,0 +1,47 @@
+# Prerequisites
+
+## Compatibility and requirements
+
+* Tested with parity 1.5.0, might work with geth (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.
+
+### Ethereum node
+
+Currently the lib supports only [parity](https://ethcore.io/parity.html). To install parity on mac simply:
+
+    $ 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.
+
+### 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:
+
+    $ brew install solidity --beta
+
+In general get used to working on beta versions as ethereum ecosystem evolves quite fast.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ethereum.rb'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ethereum.eb

data/README.md

@@ -9,31 +9,14 @@ The goal of ethereum.rb is to make interacting with ethereum blockchain from rub
 * Pure Ruby implementation
 * IPC & HTTP Client with batch calls support
 * Compile Solidity contracts with solc compiler
-* Deploy and call contracts methods
-* Contract events
-
-## Compatibility and requirements
-
-* Tested with parity 1.5.0, might work with geth (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.
-
-### Ethereum node
-
-Currently the lib supports only [parity](https://ethcore.io/parity.html). 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.
-
-### 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).
+* Deploy and interact with contracts
+* Support for contract events
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Before installing gem make sure to go through [prerequisites](https://github.com/marekkirejczyk/ethereum.rb/blob/master/PREREQUISITES.md) section.
+
+To install gem simply add this line to your application's Gemfile:
 
 ```ruby
 gem 'ethereum.rb'
@@ -49,6 +32,18 @@ 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:
@@ -164,15 +159,25 @@ Logs from communication between ruby app and node are available under following
 /tmp/ethereum_ruby_http.log
 ```
 
+## Roadmap
+
+* Dynamic arrays serialization 
+* Signing transactions 
+
+
 ## Development
 
-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.
+Make sure `rake ethereum:test:setup` passes before running tests. 
 
-You need ethereum node up and running for tests to pass and it needs to be working on testnet (Ropsten).
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+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:
 
-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).
+    $ bundle exec rspec --tag ~blockchain && bundle exec rspec --tag blockchain
+
+You need ethereum node up and running for tests to pass and it needs to be working on testnet (Ropsten).
 
 ## Acknowledgements and license
 

data/ethereum.gemspec

@@ -27,9 +27,9 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.13"
   spec.add_development_dependency "rake", "~> 12.0"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rspec", "~> 3.5"
+  spec.add_development_dependency "pry", "~> 0.10"
 
-  spec.add_dependency "activesupport", "~> 5.0.1"
-  spec.add_dependency "digest-sha3", "~> 1.1.0"
+  spec.add_dependency "activesupport", "~> 5.0"
+  spec.add_dependency "digest-sha3", "~> 1.1"
 end

data/lib/ethereum/abi.rb

@@ -15,9 +15,18 @@ module Ethereum
 
     def self.parse_type(type)
       raise NotImplementedError if type.ends_with?("]")
-      match = /(\D+)(\d.+)?/.match(type)
+      match = /(\D+)(\d.*)?/.match(type)
       [match[1], match[2]]
     end
 
+    def self.parse_array_type(type)
+      match = /(.+)\[(\d*)\]\z/.match(type)
+      if match
+        [true, match[2].present? ? match[2].to_i : nil, match[1]]
+      else
+        [false, nil, nil]
+      end
+    end
+
   end
 end

data/lib/ethereum/decoder.rb

@@ -2,47 +2,62 @@ 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)
-      elsif "int" == core
-        size = subtype.present? ? subtype.to_i : 256
-        self.send(method_name, value[start+63-(size/4-1)..start+63], size)
+      is_array, arity, array_subtype = Abi::parse_array_type(type)
+      if is_array && arity
+        decode_static_array(arity, array_subtype, value, start)
+      elsif is_array
+        decode_dynamic_array()
       else
-        self.send(method_name, value[start..start+63])
+        value = value.gsub(/^0x/,'')
+        core, subtype = Abi::parse_type(type)
+        method_name = "decode_#{core}".to_sym
+        self.send(method_name, value, subtype, start)
       end
     end
 
-    def decode_fixed(value, n = 128)
-      decode_int(value).to_f / 2**n
+    def decode_static_array(arity, array_subtype, value, start)
+      (1..arity).map.with_index do |e, i|
+        decode(array_subtype, value, start + i * 64)
+      end
+    end
+
+    def decode_dynamic_array()
+      raise NotImplementedError
+    end
+
+    def decode_fixed(value, subtype = "128x128", start = 0)
+      decode_int(trim(value, start, fixed_bitsize(subtype))).to_f / 2**exponent(subtype)
     end
 
-    def decode_uint(value)
-      value.hex
+    def decode_uint(value, subtype = "256", start = 0)
+      trim(value, start, bitsize(subtype)).hex
     end
 
-    def decode_int(value, size = 256)
+    def decode_int(value, subtype = "256", start = 0)
       raise ArgumentError if value.nil?
+      size = bitsize(subtype)
+      value = trim(value, start, size)
       (value[0..1] == "ff") ? (value.hex - (2 ** size)) : value.hex
     end
 
-    def decode_bool(value)
-      return true if value == "0000000000000000000000000000000000000000000000000000000000000001"
-      return false if value == "0000000000000000000000000000000000000000000000000000000000000000"
+    def decode_bool(value, _, start)
+      value = trim(value, start, 4)
+      return true if value == "1"
+      return false if value == "0"
       raise ArgumentError
     end
 
-    def decode_address(value)
+    def decode_address(value, _ = nil, _)
       raise ArgumentError if value.size != 40
       value
     end
 
-    def decode_bytes(value)
-      value.scan(/.{2}/).collect {|x| x.hex}.pack('C*').strip
+    def decode_bytes(value, subtype, start)
+      subtype.present? ? decode_static_bytes(value, subtype, start) : decode_dynamic_bytes(value, start)
+    end
+
+    def decode_static_bytes(value, subtype = nil, start = 0)
+      trim(value, start, subtype.to_i*8).scan(/.{2}/).collect {|x| x.hex}.pack('C*').strip
     end
 
     def decode_dynamic_bytes(value, start = 0)
@@ -51,7 +66,7 @@ module Ethereum
       value[location+64..location+63+size].scan(/.{2}/).collect {|x| x.hex}.pack('C*')
     end
 
-    def decode_string(value, start = 0)
+    def decode_string(value, _ = nil, start = 0)
       decode_dynamic_bytes(value, start).force_encoding('utf-8')
     end
 
@@ -61,5 +76,24 @@ module Ethereum
       types.each.with_index.map { |t , i| decode(t, data, i*64) }
     end
 
+    private 
+      def trim(value, start, bitsize = 256)
+        value[start+63-(bitsize/4-1)..start+63]
+      end
+
+      def bitsize(subtype, default = 256)
+        subtype.present? ? subtype.to_i : default
+      end
+
+      def fixed_bitsize(subtype = nil, default = 256)
+        subtype ||= "128x128"
+        _, x, n = /(\d+)x(\d+)/.match(subtype).to_a
+        x.to_i + n.to_i
+      end
+
+      def exponent(subtype, default = 128)
+        subtype.nil? ? default : /(\d+)x(\d+)/.match(subtype)[2].to_i
+      end
+
   end
 end

data/lib/ethereum/encoder.rb

@@ -3,11 +3,27 @@ module Ethereum
   class Encoder
 
     def encode(type, value)
-      core, subtype = Abi::parse_type(type)
-      method_name = "encode_#{core}".to_sym
-      self.send(method_name, value, subtype)
+      is_array, arity, array_subtype = Abi::parse_array_type(type)
+      if is_array && arity
+        encode_static_array(arity, array_subtype, value)
+      elsif is_array
+        encode_dynamic_array()
+      else
+        core, subtype = Abi::parse_type(type)
+        method_name = "encode_#{core}".to_sym
+        self.send(method_name, value, subtype)
+      end
+    end
+
+    def encode_static_array(arity, array_subtype, array)
+      (1..arity).map.with_index { |e, i| encode(array_subtype, array[i]) }.join
     end
 
+    def encode_dynamic_array()
+      raise NotImplementedError
+    end
+
+
     def encode_int(value, _ = nil)
       to_twos_complement(value).to_s(16).rjust(64, '0')
     end
@@ -50,7 +66,7 @@ module Ethereum
     end
 
     def encode_string(value, _)
-      location = encode_uint(@inputs ? @inputs.size * 32 : 32)
+      location = encode_uint(@inputs ? size_of_inputs(@inputs) + @tail.size/2 : 32)
       size = encode_uint(value.bytes.size)
       content = value.bytes.map {|x| x.to_s(16)}.join("").ljust(64, '0')
       [location, size + content]
@@ -88,6 +104,12 @@ module Ethereum
         (number & ((1 << 256) - 1))
       end
 
+      def size_of_inputs(inputs)
+        inputs.map do |input|
+          _, arity, _ = Abi::parse_array_type(input.type)
+          arity.nil? ? 32 : arity * 32
+        end.inject(:+)
+      end
   end
 
 end

data/lib/ethereum/version.rb

@@ -1,3 +1,3 @@
 module Ethereum
-  VERSION = "2.0.2"
+  VERSION = "2.0.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ethereum.rb
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - Marek Kirejczyk
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-01 00:00:00.000000000 Z
+date: 2017-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -42,58 +42,58 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.5'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.10'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.0.1
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.0.1
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: digest-sha3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '1.1'
 description: Ethereum.rb is Ruby Ethereum client using the JSON-RPC interface. Provides
   interface for sending transactions, creating and interacting with contracts as well
   as usefull toolkit to work with Ethereum node.
@@ -111,6 +111,7 @@ files:
 - Gemfile
 - LICENSE
 - LICENSE.txt
+- PREREQUISITES.md
 - README.md
 - Rakefile
 - bin/console
@@ -194,7 +195,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