etherlite 0.1.4 → 0.1.5

data/lib/etherlite/support/array.rb

@@ -0,0 +1,43 @@
+module Etherlite::Support
+  module Array
+    extend self
+
+    def encode(_types, _values)
+      head = []
+      tail = []
+      tail_offset = _types.sum(0) { |type| type.dynamic? ? 32 : type.size } # type.size is always 32
+
+      _types.each_with_index do |type, i|
+        content = type.encode _values[i]
+        if type.dynamic?
+          head << Etherlite::Utils.uint_to_hex(tail_offset)
+          tail << content
+          tail_offset += content.length / 2 # hex string, 2 characters per byte
+        else
+          head << content
+        end
+      end
+
+      head.join + tail.join
+    end
+
+    def decode(_connection, _types, _data)
+      words = _data.scan(/.{64}/)
+      offset = 0
+
+      [].tap do |r|
+        _types.each do |type|
+          if type.dynamic?
+            offset_words = Etherlite::Utils.hex_to_uint(words[offset]) / 32
+            r << type.decode(_connection, words[offset_words..-1].join)
+            offset += 1
+          else
+            size_in_words = type.size / 32 # type.size is always 32
+            r << type.decode(_connection, words.slice(offset, size_in_words).join)
+            offset += size_in_words
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etherlite/transaction.rb

@@ -1,10 +1,42 @@
 module Etherlite
   class Transaction
-    attr_reader :tx_hash
+    attr_reader :tx_hash, :receipt
 
     def initialize(_connection, _tx_hash)
       @connection = _connection
       @tx_hash = _tx_hash
+      @receipt = {}
+    end
+
+    def refresh
+      @receipt = @connection.eth_get_transaction_receipt(@tx_hash) || {}
+      mined?
+    end
+
+    def mined?
+      @receipt.key? 'blockNumber'
+    end
+
+    def gas_used
+      Utils.hex_to_uint @receipt['gasUsed']
+    end
+
+    def block_number
+      Utils.hex_to_uint @receipt['blockNumber']
+    end
+
+    def contract_address
+      @receipt['contractAddress']
+    end
+
+    def wait_for_block(timeout: 120)
+      start = Time.now
+      while !refresh
+        return false if Time.now - start > timeout
+        sleep 1
+      end
+
+      true
     end
   end
 end

data/lib/etherlite/types/array_dynamic.rb

@@ -1,13 +1,27 @@
 module Etherlite::Types
-  class ArrayDynamic < ArrayBase
+  class ArrayDynamic < Base
+    attr_reader :subtype
+
+    def initialize(_subtype)
+      raise ArgumentError, 'An array can not contain a dynamic type' if _subtype.dynamic?
+
+      @subtype = _subtype
+    end
+
     def signature
-      "#{subtype.signature}[]"
+      "#{@subtype.signature}[]"
     end
 
-    def encode(_value)
-      raise ArgumentError, "expected an array for #{signature}" unless _value.is_a? Array
+    def encode(_values)
+      raise ArgumentError, "expected an array for #{signature}" unless _values.is_a? Array
+
+      encoded_array = Etherlite::Support::Array.encode([@subtype] * _values.length, _values)
+      Etherlite::Utils.uint_to_hex(_values.length) + encoded_array
+    end
 
-      Etherlite::Utils.uint_to_hex(_value.size) + encode_values(_value)
+    def decode(_connection, _data)
+      length = Etherlite::Utils.hex_to_uint(_data[0..63])
+      Etherlite::Support::Array.decode(_connection, [@subtype] * length, _data[64..-1])
     end
   end
 end

data/lib/etherlite/types/array_fixed.rb

@@ -1,23 +1,32 @@
 module Etherlite::Types
-  class ArrayFixed < ArrayBase
-    def initialize(_subtype, _size)
-      super _subtype
-      @size = _size
+  class ArrayFixed < Base
+    attr_reader :length, :subtype
+
+    def initialize(_subtype, _length)
+      raise ArgumentError, 'An array can not contain a dynamic type' if _subtype.dynamic?
+
+      @subtype = _subtype
+      @length = _length
     end
 
     def signature
-      "#{subtype.signature}[#{@size}]"
+      "#{@subtype.signature}[#{@length}]"
     end
 
     def size
-      subtype.size * @size
+      return nil if @subtype.dynamic?
+      @subtype.size * @length
     end
 
-    def encode(_value)
-      raise ArgumentError, "expected an array for #{signature}" unless _value.is_a? Array
-      raise ArgumentError, "expected array of size #{@size}" unless _value.size == @size
+    def encode(_values)
+      raise ArgumentError, "expected an array for #{signature}" unless _values.is_a? Array
+      raise ArgumentError, "expected array of length #{@length}" unless _values.length == @length
+
+      Etherlite::Support::Array.encode([@subtype] * @length, _values)
+    end
 
-      encode_values _value
+    def decode(_connection, _data)
+      Etherlite::Support::Array.decode(_connection, [@subtype] * @length, _data)
     end
   end
 end

data/lib/etherlite/types/{bool.rb → boolean.rb}

@@ -1,5 +1,5 @@
 module Etherlite::Types
-  class Bool < Base
+  class Boolean < Base
     TRUE = '0000000000000000000000000000000000000000000000000000000000000001'.freeze # 32 bytes
     FALSE = '0000000000000000000000000000000000000000000000000000000000000000'.freeze
 

data/lib/etherlite/types/byte_string.rb

@@ -13,5 +13,11 @@ module Etherlite::Types
 
       Etherlite::Utils.uint_to_hex(bytes) + bytes_as_hex.ljust(padded_size * 2, '0')
     end
+
+    def decode(_connection, _value)
+      size = Etherlite::Utils.hex_to_uint _value[0...64]
+
+      [_value[64...64 + size * 2]].pack('H*')
+    end
   end
 end

data/lib/etherlite/types/string.rb

@@ -1,10 +1,15 @@
 module Etherlite::Types
-  class String < Base
+  class String < ByteString
     def signature
       "string"
     end
 
     def encode(_value)
+      super _value.encode('UTF-8')
+    end
+
+    def decode(_connection, _value)
+      super(_connection, _value).force_encoding("utf-8")
     end
   end
 end

data/lib/etherlite/utils.rb

@@ -25,8 +25,10 @@ module Etherlite
       _hex_value.hex
     end
 
-    def hex_to_int(_hex_value)
-      # TODO.
+    def hex_to_int(_hex_value, bytes: 32)
+      value = _hex_value.hex
+      top_bit = (1 << (bytes * 8 - 1))
+      value & top_bit > 0 ? (value - 2 * top_bit) : value
     end
 
     def valid_address?(_address)

data/lib/etherlite/version.rb

@@ -1,3 +1,3 @@
 module Etherlite
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/generators/etherlite/templates/etherlite.yml

@@ -8,4 +8,5 @@ test: &defaults
   url: 'http://127.0.0.1:8545'
 
 production: &defaults
+  chain_id: 1
   url: 'http://127.0.0.1:8545'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: etherlite
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Ignacio Baixas
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-01 00:00:00.000000000 Z
+date: 2017-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: digest-sha3
@@ -136,6 +136,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.7'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ''
 email:
 - ignacio@surbtc.com
@@ -157,17 +185,19 @@ files:
 - etherlite.gemspec
 - lib/etherlite.rb
 - lib/etherlite/abi.rb
-- lib/etherlite/account.rb
+- lib/etherlite/account/anonymous.rb
+- lib/etherlite/account/base.rb
+- lib/etherlite/account/local.rb
+- lib/etherlite/account/private_key.rb
 - lib/etherlite/address.rb
 - lib/etherlite/api/address.rb
 - lib/etherlite/api/node.rb
+- lib/etherlite/api/rpc.rb
 - lib/etherlite/client.rb
 - lib/etherlite/commands/abi/load_contract.rb
 - lib/etherlite/commands/abi/load_function.rb
 - lib/etherlite/commands/abi/load_type.rb
-- lib/etherlite/commands/base.rb
 - lib/etherlite/commands/contract/event_base/decode_log_inputs.rb
-- lib/etherlite/commands/contract/function/encode_arguments.rb
 - lib/etherlite/commands/utils/validate_address.rb
 - lib/etherlite/configuration.rb
 - lib/etherlite/connection.rb
@@ -175,18 +205,18 @@ files:
 - lib/etherlite/contract/event_base.rb
 - lib/etherlite/contract/event_input.rb
 - lib/etherlite/contract/function.rb
+- lib/etherlite/errors.rb
 - lib/etherlite/nonce_manager.rb
-- lib/etherlite/pk_account.rb
 - lib/etherlite/railtie.rb
 - lib/etherlite/railties/configuration_extensions.rb
 - lib/etherlite/railties/utils.rb
+- lib/etherlite/support/array.rb
 - lib/etherlite/transaction.rb
 - lib/etherlite/types/address.rb
-- lib/etherlite/types/array_base.rb
 - lib/etherlite/types/array_dynamic.rb
 - lib/etherlite/types/array_fixed.rb
 - lib/etherlite/types/base.rb
-- lib/etherlite/types/bool.rb
+- lib/etherlite/types/boolean.rb
 - lib/etherlite/types/byte_string.rb
 - lib/etherlite/types/bytes.rb
 - lib/etherlite/types/fixed.rb

data/lib/etherlite/account.rb

@@ -1,85 +0,0 @@
-module Etherlite
-  class Account
-    include Etherlite::Api::Address
-
-    attr_reader :connection, :normalized_address
-
-    def initialize(_connection, _normalized_address)
-      @connection = _connection
-      @normalized_address = _normalized_address
-    end
-
-    def unlock(_passphrase)
-      @passphrase = _passphrase
-    end
-
-    def lock
-      @passphrase = nil
-    end
-
-    def transfer_to(_target, _options = {})
-      params = {
-        from: json_encoded_address,
-        to: Utils.encode_address_param(_target),
-        value: Utils.encode_quantity_param(_options.fetch(:amount, 0))
-      }
-
-      send_transaction params, _options
-    end
-
-    def call(_target, _function, *_params)
-      _function = Utils.parse_function(_function) unless _function.is_a? Contract::Function
-      options = _params.last.is_a?(Hash) ? _params.pop : {}
-
-      if _function.constant?
-        call_constant _target, _function, _params, options
-      else
-        send_function_transaction _target, _function, _params, options
-      end
-    end
-
-    private
-
-    attr_reader :normalized_address
-
-    def call_constant(_target, _function, _params, _options)
-      ipc_params = {
-        from: json_encoded_address,
-        to: Utils.encode_address_param(_target),
-        data: _function.encode(_params)
-      }
-
-      block = Utils.encode_block_param _options.fetch(:block, :latest)
-
-      _function.decode @connection, @connection.ipc_call(:eth_call, ipc_params, block)
-    end
-
-    def send_function_transaction(_target, _function, _params, _options)
-      ipc_params = {
-        from: json_encoded_address,
-        to: Utils.encode_address_param(_target),
-        data: _function.encode(_params)
-      }
-
-      value = _options.fetch(:pay, 0)
-      raise 'function is not payable' if value > 0 && !_function.payable?
-      ipc_params[:value] = value
-
-      send_transaction(ipc_params, _options)
-    end
-
-    def send_transaction(_params, _opt)
-      _params[:gas] = Utils.encode_quantity_param(_opt[:gas]) if _opt.key? :gas
-      _params[:gasPrice] = Utils.encode_quantity_param(_opt[:gas_price]) if _opt.key? :gas_price
-
-      passphrase = _opt.fetch(:passphrase, @passphrase)
-      tx_hash = if passphrase.nil?
-                  @connection.ipc_call(:eth_sendTransaction, _params)
-                else
-                  @connection.ipc_call(:personal_sendTransaction, _params, passphrase)
-                end
-
-      Transaction.new @connection, tx_hash
-    end
-  end
-end

data/lib/etherlite/commands/contract/function/encode_arguments.rb

@@ -1,32 +0,0 @@
-class Etherlite::Contract::Function
-  class EncodeArguments < PowerTypes::Command.new(:subtypes, :values)
-    def perform # rubocop:disable Metrics/MethodLength
-      if @values.length != @subtypes.count
-        raise ArgumentError, "Expected #{@subtypes.count} arguments, got #{@values.length} "
-      end
-
-      head = []
-      tail = []
-      tail_offset = calculate_head_offset
-
-      @subtypes.each_with_index do |type, i|
-        content = type.encode @values[i]
-        if type.dynamic?
-          head << Etherlite::Utils.uint_to_hex(tail_offset)
-          tail << content
-          tail_offset += content.length / 2 # hex string, 2 characters per byte
-        else
-          head << content
-        end
-      end
-
-      head.join + tail.join
-    end
-
-    private
-
-    def calculate_head_offset
-      @subtypes.inject(0) { |r, type| r + (type.dynamic? ? 32 : type.size) }
-    end
-  end
-end