etherlite 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed20095933d11d8e8d7b9cda7dce06cfb6acd1bf
-  data.tar.gz: aebb4e88d292b3c021cebb1b87318fd8b51abd2d
+  metadata.gz: 7c11198a345cd94f0ef94e90a80187b8bd06b382
+  data.tar.gz: 871fddbd0b57e525285964b3be91327ab9b6b08d
 SHA512:
-  metadata.gz: dff58138afca0dd99d83692a218a4e410880c6f07cb6bdf0727ff8603f8ce107a5ec9c5ab7886462e831ef4bbd0dcb16bb9b2f254ea5dd7e9a328f3a345ff79d
-  data.tar.gz: d7c84736ea549eb7b3f59c9bf41e5fc493ebb3c37aaad2b25caff2a7c1d6db5ce196c7809eccf5fe1252ef1b1cd8705f6400819b6345f1af9ae54c851d880ce9
+  metadata.gz: 7994ac39cbb16387397ec0829891bc401e9d425bc62051c46b7a47244759b0d018626af088df38456060ba8558ed29836ae666be4f932fc301d093d8233bf33a
+  data.tar.gz: db831cc13de2c7f578e0659951ddde2e91697369c63af597e091b2eec1a44eb881ca882ec754184f9facf2128d035eb319a6537c0c9c05fec23a4c42bb8bbf87

data/README.md

@@ -1,8 +1,6 @@
 # Etherlite
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/etherlite`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Etherlite is a 
 
 ## Installation
 
@@ -16,13 +14,101 @@ And then execute:
 
     $ bundle
 
-Or install it yourself as:
+Initialize the configuration file and `contracts` folder:
+
+    $ rails g etherlite:init
 
-    $ gem install etherlite
+A `etherlite.yml` file will be added to your app's `config` folder, there you can configure the node locations and some other variables for each enviroment.
 
 ## Usage
 
-TODO: Write usage instructions here
+This gem is intended to be used with contract artifacts generated by Truffle. To start interacting with your contracts, drop the artifacts for the contracts you will be using in the application `contracts` folder. (You can find the contract artifacts on the `build/contracts` folder of your truffle proyect).
+
+Rails will automatically load the artifacts as ruby classes.
+
+For example, given the following contract:
+
+```solidity
+contract BikeStore {
+  event BikeSold(address buyer, string model);
+  event BikeReturned(address buyer, string reason);
+
+  function buyBike(string _model) payable {
+    // some code
+  }
+
+  function getBikePrice(string _model) returns (uint price) {
+    return _return;
+  }
+}
+```
+
+By copying the contract's artifact file in the `contracts` folder you will be able to call:
+
+```ruby
+my_store = BikeStoreContract.at('0xAAAAAAAAAAAAAAAAA') # notice the "Contract" sufix
+price = my_store.get_bike_price
+```
+
+### Accounts
+
+Etherlite supports both node managed accounts and private key accounts (via the `eth` gem).
+
+By default etherlite will try to use the first account from the configured node.
+
+```ruby
+Etherlite.default_account # this should reference the node's first account (if present)
+```
+
+When executing operations that need to send a transaction you will need to provide the account's passphrase. You can set the `passphrase` option in the configuration file:
+
+```yml
+development:
+  passphrase: <%= ENV['STORE_PASSPHRASE'] %>
+```
+
+or pass it on any transaction-triggering call:
+
+```ruby
+my_store.buy_bike('mongoose', passphrase: 'verysecure')
+```
+
+If you need to use a private key account, then set the `private_key` option in the configuration file with the account's private key. Etherlite will automatically switch to using a private key account instead of the node account:
+
+```yml
+development:
+  private_key: <%= ENV['STORE_PRIVATE_KEY'] %>
+```
+
+```ruby
+Etherlite.default_account.address # this should return the private_key corresponding address
+```
+
+If you wish to programatically load a private key account you can call:
+
+```ruby
+account = Etherlite.account_from_pk(your_private_key)
+```
+
+### Creating contract instances
+
+
+
+### Calling contract methods
+
+#### Setting gas limit and price
+
+### Transferring ether
+
+
+### Waiting for transactions
+
+
+### Searching event logs
+
+### Testing with Etherlite, rspec and testrpc
+
+Etherlite (will) provides a set of rspec helpers to make
 
 ## Development
 
@@ -34,7 +120,6 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/etherlite. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/etherlite.gemspec

@@ -29,4 +29,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "guard", "~> 2.14"
   spec.add_development_dependency "guard-rspec", "~> 4.7"
+  spec.add_development_dependency "webmock", "~> 3.0.1"
+  spec.add_development_dependency "pry"
 end

data/lib/etherlite.rb

@@ -6,13 +6,15 @@ require "etherlite/version"
 
 require "etherlite/api/address"
 require "etherlite/api/node"
+require "etherlite/api/rpc"
+
+require "etherlite/support/array"
 
 require "etherlite/types/base"
 require "etherlite/types/address"
-require "etherlite/types/array_base"
 require "etherlite/types/array_dynamic"
 require "etherlite/types/array_fixed"
-require "etherlite/types/bool"
+require "etherlite/types/boolean"
 require "etherlite/types/byte_string"
 require "etherlite/types/bytes"
 require "etherlite/types/fixed"
@@ -24,14 +26,17 @@ require "etherlite/contract/event_base"
 require "etherlite/contract/event_input"
 require "etherlite/contract/function"
 
+require "etherlite/errors"
 require "etherlite/configuration"
 require "etherlite/abi"
 require "etherlite/utils"
 require "etherlite/connection"
 require "etherlite/transaction"
 require "etherlite/nonce_manager"
-require "etherlite/pk_account"
-require "etherlite/account"
+require "etherlite/account/base"
+require "etherlite/account/local"
+require "etherlite/account/private_key"
+require "etherlite/account/anonymous"
 require "etherlite/address"
 require "etherlite/client"
 
@@ -42,10 +47,10 @@ module Etherlite
     Utils.valid_address? _value
   end
 
-  def self.connect(_url)
+  def self.connect(_url, _options = {})
     _url = URI(_url) unless _url.is_a? URI
 
-    Client.new Connection.new(_url)
+    Client.new Connection.new(_url, _options.fetch(:chain_id, config.chain_id))
   end
 
   def self.config
@@ -62,7 +67,7 @@ module Etherlite
   end
 
   def self.connection
-    @connection ||= Connection.new URI(config.url)
+    @connection ||= Connection.new(URI(config.url), config.chain_id)
   end
 end
 

data/lib/etherlite/abi.rb

@@ -3,18 +3,58 @@ require 'etherlite/commands/abi/load_contract'
 require 'etherlite/commands/abi/load_function'
 
 module Etherlite
+  ##
+  # A set of ABI related utilities
+  #
   module Abi
     extend self
 
+    ##
+    # Load a contract artifact file.
+    #
+    # This method parses a truffle artifact file and loads a **contract** class.
+    #
+    # The generated contract class exposes a series of methods to interact with an instance
+    # of the contract described by the artifact.
+    #
+    # ```
+    # contract_class = Etherlite::Abi.load_contract_at('/path/to/Contract.json')
+    # instance = contract_class.deploy(gas: 1000000)
+    # ```
+    #
+    # @param _path (String) The artifact file absolute path
+    #
+    # @return [Object] the generated contract class.
+    #
     def load_contract_at(_path)
-      json = JSON.parse File.read(_path)
-      LoadContract.for json: json
+      artifact = JSON.parse File.read(_path)
+      LoadContract.for artifact: artifact
     end
 
-    def load_contract(_json)
-      LoadContract.for json: _json
+    ##
+    # This method is similar to `load_contract_at` but takes a hash instead of the raw file.
+    #
+    # @param _artifact (Hash) The artifact hash
+    #
+    # @return [Object] the generated contract class.
+    #
+    def load_contract(_artifact)
+      LoadContract.for artifact: _artifact
     end
 
+    ##
+    # This method is used internally to load a function definition given a function signature.
+    #
+    # The function definition can be later used to call a contract's function without need of
+    # the artifact file.
+    #
+    # @param _signature (String) A string that matches:
+    #
+    #   (payable|onchain|<type>) <name>(<type>, <type>, ...), where <name> is the function's name
+    #   and <type> is any valid solidity type.
+    #
+    # @return [Object] the generated function definition.
+    #
     def load_function(_signature)
       LoadFunction.for signature: _signature
     end

data/lib/etherlite/account/anonymous.rb

@@ -0,0 +1,9 @@
+module Etherlite
+  module Account
+    class Anonymous < Base
+      def initialize(_connection)
+        super(_connection, nil)
+      end
+    end
+  end
+end

data/lib/etherlite/account/base.rb

@@ -0,0 +1,56 @@
+module Etherlite::Account
+  class Base
+    include Etherlite::Api::Address
+
+    attr_reader :connection, :normalized_address
+
+    def initialize(_connection, _normalized_address = nil)
+      @connection = _connection
+      @normalized_address = _normalized_address
+    end
+
+    def transfer_to(_target, _options = {})
+      send_transaction _options.merge(to: _target, value: _options.fetch(:amount, 0))
+    end
+
+    def call(_target, _function, *_params)
+      _function = parse_function(_function) if _function.is_a? String
+      options = _params.last.is_a?(Hash) ? _params.pop.clone : {}
+
+      if _function.constant?
+        call_constant _target, _function, _params, options
+      else
+        value = options.fetch(:pay, 0)
+        raise 'function is not payable' if value > 0 && !_function.payable?
+
+        send_transaction options.merge(
+          to: _target, data: _function.encode(_params), value: value
+        )
+      end
+    end
+
+    def send_transaction(_options = {})
+      raise NotSupportedError, 'transactions are not supported by this kind of account'
+    end
+
+    private
+
+    def call_constant(_target, _function, _params, _options)
+      params = {
+        from: json_encoded_address,
+        to: Etherlite::Utils.encode_address_param(_target),
+        data: _function.encode(_params)
+      }
+
+      params[:from] = json_encoded_address if @normalized_address.present?
+
+      block = Etherlite::Utils.encode_block_param _options.fetch(:block, :latest)
+
+      _function.decode @connection, @connection.eth_call(params, block)
+    end
+
+    def parse_function(_signature)
+      Abi::LoadFunction.for signature: _signature
+    end
+  end
+end

data/lib/etherlite/account/local.rb

@@ -0,0 +1,40 @@
+module Etherlite
+  module Account
+    class Local < Base
+      def unlock(_passphrase)
+        @passphrase = _passphrase
+      end
+
+      def lock
+        @passphrase = nil
+      end
+
+      def send_transaction(_options = {})
+        params = build_params_from_options _options
+        passphrase = _options.fetch(:passphrase, @passphrase)
+
+        Transaction.new @connection, send_transaction_with_passphrase(params, passphrase)
+      end
+
+      private
+
+      def build_params_from_options(_opt)
+        { from: json_encoded_address }.tap do |pr|
+          pr[:to] = Utils.encode_address_param(_opt[:to]) if _opt.key? :to
+          pr[:value] = Utils.encode_quantity_param(_opt[:value]) if _opt.key? :value
+          pr[:data] = _opt[:data] if _opt.key? :data
+          pr[:gas] = Utils.encode_quantity_param(_opt[:gas]) if _opt.key? :gas
+          pr[:gasPrice] = Utils.encode_quantity_param(_opt[:gas_price]) if _opt.key? :gas_price
+        end
+      end
+
+      def send_transaction_with_passphrase(_params, _passphrase)
+        if _passphrase.nil?
+          @connection.eth_send_transaction _params
+        else
+          @connection.personal_send_transaction _params, _passphrase
+        end
+      end
+    end
+  end
+end

data/lib/etherlite/account/private_key.rb

@@ -0,0 +1,51 @@
+require 'eth'
+
+module Etherlite
+  module Account
+    class PrivateKey < Base
+      def initialize(_connection, _pk)
+        @key = Eth::Key.new priv: _pk
+        super _connection, Etherlite::Utils.normalize_address(@key.address)
+      end
+
+      def send_transaction(_options = {})
+        nonce_manager.with_next_nonce_for(normalized_address) do |nonce|
+          tx = Eth::Tx.new(
+            value: _options.fetch(:value, 0),
+            data: _options.fetch(:data, ''),
+            gas_limit: _options.fetch(:gas, 90_000),
+            gas_price: _options.fetch(:gas_price, gas_price),
+            to: Etherlite::Utils.encode_address_param(_options[:to]),
+            nonce: nonce
+          )
+
+          # Since eth gem does not allow configuration of chains for every tx, we need
+          # to globally configure it before signing. This is not thread safe so a mutex is needed.
+          sign_with_connection_chain tx
+
+          Etherlite::Transaction.new @connection, @connection.eth_send_raw_transaction(tx.hex)
+        end
+      end
+
+      private
+
+      @@eth_mutex = Mutex.new
+
+      def gas_price
+        # TODO: improve on this
+        @gas_price ||= connection.eth_gas_price
+      end
+
+      def nonce_manager
+        Etherlite::NonceManager.new @connection
+      end
+
+      def sign_with_connection_chain(_tx)
+        @@eth_mutex.synchronize do
+          Eth.configure { |c| c.chain_id = @connection.chain_id }
+          _tx.sign @key
+        end
+      end
+    end
+  end
+end

data/lib/etherlite/api/node.rb

@@ -5,37 +5,40 @@ module Etherlite
       include Address
 
       def get_block_number
-        Etherlite::Utils.hex_to_uint connection.ipc_call(:eth_blockNumber)
+        connection.eth_block_number
       end
 
       def get_gas_price
-        Etherlite::Utils.hex_to_uint connection.ipc_call(:eth_gasPrice)
-      end
-
-      def get_transaction_receipt(_tx_hash)
-        connection.ipc_call(:eth_getTransactionReceipt, _tx_hash)
+        connection.eth_gas_price
       end
 
       def register_account(_passphrase)
         address = connection.ipc_call(:personal_newAccount, _passphrase)
-        Etherlite::Account.new @connection, Etherlite::Utils.normalize_address(address)
+        Etherlite::Account::Local.new @connection, Etherlite::Utils.normalize_address(address)
       end
 
       def accounts
         connection.ipc_call(:eth_accounts).map do |address|
-          Etherlite::Account.new @connection, Etherlite::Utils.normalize_address(address)
+          Etherlite::Account::Local.new @connection, Etherlite::Utils.normalize_address(address)
         end
       end
 
-      def first_account
-        @first_account ||= accounts.first
+      def default_account
+        @default_account ||= load_default_account
       end
 
       def account_from_pk(_pk)
-        Etherlite::PkAccount.new(connection, _pk)
+        Etherlite::Account::PrivateKey.new connection, _pk
       end
 
-      def_delegators :first_account, :unlock, :lock, :normalized_address, :transfer_to, :call
+      def_delegators :default_account, :unlock, :lock, :normalized_address, :transfer_to, :call
+
+      private
+
+      def load_default_account
+        # TODO: consider configuring a global PK and allow the default account to use it
+        accounts.first || Etherlite::Account::Anonymous.new(connection)
+      end
     end
   end
 end