Etheruby is a library including a client for the JSON-RPC API and a Object-Contract Mapper to interact with smart-contracts on the Ethereum blockchain.

gem install etheruby

or add this into your Gemfile :

gem 'etheruby'

And then run bundle install.

You can use Etheruby from Ruby on Rails. Just add the gem to your Gemfile and then run the rake etheruby:setup task. It will create a new folder under /app/contracts and create the default /app/config/etheruby.yml configuration file.

The client is pretty straightforward to use. It uses method_missing to map all the possible calls. So, if it exists here : https://github.com/ethereum/wiki/wiki/JSON-RPC it works here.

balance = Etheruby::Client.eth.getBalance('0x407d73d8a49eeb85d32cf465507dd71d507100c1','latest')
vers = Etheruby::Client.net.version
sync = Etheruby::Client.eth.syncing

Etheruby is the first project of its kind. It aims to provide an easy and elegant way to describe a contract, and a native way to interact with it.

I called it an OCM for Object-Contract Mapper, since, like an ODM or an ORM, it maps another data type to ruby object to make it easier to manipulate it.

Let's review an example. Given the contract :

contract Foo {
  function bar(fixed[2] xy) {}
  function baz(uint32 x, bool y) returns (bool r) { r = x > 32 || y; }
  function sam(bytes name, bool z, uint[] data) {}
  function f(uint,uint32[],bytes10,bytes) {}
}

Thus for our Foo if we wanted to describe it with Etheruby, we would simply create a Foo class and make it inherit from the Etheruby::Contract class :

class Foo < Etheruby::Contract
  at_address 0x57eb1e64d972d9937c6f6f07a865e91608252c97
  method :bar do
    parameters array(:fixed128x128, 2)
  end
  method :baz do
    parameters :uint32, :bool
    returns :bool
  end
  method :sam do
    parameters :bytes, :bool, array(:uint256)
    returns :bool
  end
  method :f do
    parameters :uint256, array(:uint32), :bytes10, :bytes
  end
end

Now, we can use the Contract like if it was a ruby object. All methods on the contract are static methods on the ruby object.

Here is the list of the arguments you can use in the method describer :

If your method doesn't take any argument and doesn't return anything, you can remove the block after the keyword.

Foo.bar([2.125, 8.5])
Foo.baz(69,true)
Foo.sam("dave".codepoints, true, [1,2,3])
Foo.f(0x123, [0x456, 0x789], "1234567890".codepoints, "Hello, world!".codepoints)

Return types of the method are also casted to native ruby types, therefore you have a full interoperability between the contract execution and the ruby program that consumes it.

If you return multiple values, like f(uint a) returns (uint b, string c) you can create named variables in the contract definition to easily access them :

method :f do
  parameters :uint256
  returns b: :uint,
          c: :string
end
response = Contract.f(1)
response.b
response.c
...

If you find an issue, please open an issue here, on Github.

Known issue : The way on Ruby on rails to load Contracts from /app/contracts is not perfect. You must relaunch rails s after a contract definition modification.

If you want to help this project, please check the opened issues on Github, fork this repo, fix the issue and do a pull request here. Do not mess with the version of the gem, I'll handle it.

If you don't want to get involved in the developpement of Etheruby but you want to help, I love beers and pizza, and I love Ethers. Here is my Ethereum address : 0x5124e63dec9acc65203ea8e5f98d4d151c39889f