web3-eth 0.1.0 → 0.2.0

data/lib/web3/eth/abi/utils.rb

@@ -0,0 +1,224 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'digest'
+require 'digest/sha3'
+require 'openssl'
+require 'rlp'
+
+module Web3::Eth::Abi
+  module Utils
+
+    extend self
+
+    include Constant
+
+    ##
+    # Not the keccak in sha3, although it's underlying lib named SHA3
+    #
+    def keccak256(x)
+      Digest::SHA3.new(256).digest(x)
+    end
+
+    def keccak512(x)
+      Digest::SHA3.new(512).digest(x)
+    end
+
+    def keccak256_rlp(x)
+      keccak256 RLP.encode(x)
+    end
+
+    def sha256(x)
+      Digest::SHA256.digest x
+    end
+
+    def double_sha256(x)
+      sha256 sha256(x)
+    end
+
+    def ripemd160(x)
+      Digest::RMD160.digest x
+    end
+
+    def hash160(x)
+      ripemd160 sha256(x)
+    end
+
+    def hash160_hex(x)
+      encode_hex hash160(x)
+    end
+
+    def mod_exp(x, y, n)
+      x.to_bn.mod_exp(y, n).to_i
+    end
+
+    def mod_mul(x, y, n)
+      x.to_bn.mod_mul(y, n).to_i
+    end
+
+    def to_signed(i)
+      i > Constant::INT_MAX ? (i-Constant::TT256) : i
+    end
+
+    def base58_check_to_bytes(s)
+      leadingzbytes = s.match(/\A1*/)[0]
+      data = Constant::BYTE_ZERO * leadingzbytes.size + BaseConvert.convert(s, 58, 256)
+
+      raise ChecksumError, "double sha256 checksum doesn't match" unless double_sha256(data[0...-4])[0,4] == data[-4..-1]
+      data[1...-4]
+    end
+
+    def bytes_to_base58_check(bytes, magicbyte=0)
+      bs = "#{magicbyte.chr}#{bytes}"
+      leadingzbytes = bs.match(/\A#{Constant::BYTE_ZERO}*/)[0]
+      checksum = double_sha256(bs)[0,4]
+      '1'*leadingzbytes.size + BaseConvert.convert("#{bs}#{checksum}", 256, 58)
+    end
+
+    def ceil32(x)
+      x % 32 == 0 ? x : (x + 32 - x%32)
+    end
+
+    def encode_hex(b)
+      RLP::Utils.encode_hex b
+    end
+
+    def decode_hex(s)
+      RLP::Utils.decode_hex s
+    end
+
+    def big_endian_to_int(s)
+      RLP::Sedes.big_endian_int.deserialize s.sub(/\A(\x00)+/, '')
+    end
+
+    def int_to_big_endian(n)
+      RLP::Sedes.big_endian_int.serialize n
+    end
+
+    def lpad(x, symbol, l)
+      return x if x.size >= l
+      symbol * (l - x.size) + x
+    end
+
+    def rpad(x, symbol, l)
+      return x if x.size >= l
+      x + symbol * (l - x.size)
+    end
+
+    def zpad(x, l)
+      lpad x, BYTE_ZERO, l
+    end
+
+    def zunpad(x)
+      x.sub /\A\x00+/, ''
+    end
+
+    def zpad_int(n, l=32)
+      zpad encode_int(n), l
+    end
+
+    def zpad_hex(s, l=32)
+      zpad decode_hex(s), l
+    end
+
+    def int_to_addr(x)
+      zpad_int x, 20
+    end
+
+    def encode_int(n)
+      raise ArgumentError, "Integer invalid or out of range: #{n}" unless n.is_a?(Integer) && n >= 0 && n <= UINT_MAX
+      int_to_big_endian n
+    end
+
+    def decode_int(v)
+      raise ArgumentError, "No leading zero bytes allowed for integers" if v.size > 0 && (v[0] == Constant::BYTE_ZERO || v[0] == 0)
+      big_endian_to_int v
+    end
+
+    def bytearray_to_int(arr)
+      o = 0
+      arr.each {|x| o = (o << 8) + x }
+      o
+    end
+
+    def int_array_to_bytes(arr)
+      arr.pack('C*')
+    end
+
+    def bytes_to_int_array(bytes)
+      bytes.unpack('C*')
+    end
+
+    def coerce_to_int(x)
+      if x.is_a?(Numeric)
+        x
+      elsif x.size == 40
+        big_endian_to_int decode_hex(x)
+      else
+        big_endian_to_int x
+      end
+    end
+
+    def coerce_to_bytes(x)
+      if x.is_a?(Numeric)
+        int_to_big_endian x
+      elsif x.size == 40
+        decode_hex(x)
+      else
+        x
+      end
+    end
+
+    def coerce_addr_to_hex(x)
+      if x.is_a?(Numeric)
+        encode_hex zpad(int_to_big_endian(x), 20)
+      elsif x.size == 40 || x.size == 0
+        x
+      else
+        encode_hex zpad(x, 20)[-20..-1]
+      end
+    end
+
+    def normalize_address(x, allow_blank: false)
+      address = Address.new(x)
+      raise ValueError, "address is blank" if !allow_blank && address.blank?
+      address.to_bytes
+    end
+
+    def mk_contract_address(sender, nonce)
+      keccak256_rlp([normalize_address(sender), nonce])[12..-1]
+    end
+
+    def mk_metropolis_contract_address(sender, initcode)
+      keccak256(normalize_address(sender) + initcode)[12..-1]
+    end
+
+
+    def parse_int_or_hex(s)
+      if s.is_a?(Numeric)
+        s
+      elsif s[0,2] == '0x'
+        big_endian_to_int decode_hex(normalize_hex_without_prefix(s))
+      else
+        s.to_i
+      end
+    end
+
+    def normalize_hex_without_prefix(s)
+      if s[0,2] == '0x'
+        (s.size % 2 == 1 ? '0' : '') + s[2..-1]
+      else
+        s
+      end
+    end
+
+    def function_signature method_name, arg_types
+      "#{method_name}(#{arg_types.join(',')})"
+    end
+
+    def signature_hash signature, length=64
+      encode_hex(keccak256(signature))[0...length]
+    end
+
+
+  end
+end

data/lib/web3/eth/block.rb

@@ -15,9 +15,7 @@ module Web3
           self.class.send(:define_method, k, proc {self.instance_variable_get("@#{k}")})
         end
 
-        @transactions = block_data['transactions'].collect {|t|
-          Transaction.new t
-        }
+        @transactions = @transactions.collect {|t|  Web3::Eth::Transaction.new t }
 
       end
 

data/lib/web3/eth/call_trace.rb

@@ -0,0 +1,42 @@
+module Web3
+  module Eth
+
+    class CallTrace
+
+      include Web3::Eth::Utility
+
+      attr_reader :raw_data
+
+      def initialize trace_data
+        @raw_data = trace_data
+
+        trace_data.each do |k, v|
+          self.instance_variable_set("@#{k}", v)
+          self.class.send(:define_method, k, proc {self.instance_variable_get("@#{k}")})
+        end
+
+      end
+
+      def value_eth
+        wei_to_ether from_hex action['value']
+      end
+
+      def from
+        action['from']
+      end
+
+      def to
+        action['to']
+      end
+
+      def input
+        action['input']
+      end
+
+      def output
+        result['output']
+      end
+
+    end
+  end
+end

data/lib/web3/eth/contract.rb

@@ -0,0 +1,134 @@
+module Web3
+  module Eth
+    class Contract
+
+      include Abi::AbiCoder
+      include Abi::Utils
+      include Utility
+
+      
+      class ContractInstance
+
+        def initialize contract, address
+          @contract = contract
+          @address = address
+        end
+
+        def method_missing m, *args
+          @contract.call_contract @address, m.to_s, args
+        end
+
+        def __contract__
+          @contract
+        end
+
+        def __address__
+          @address
+        end
+
+      end
+
+      class ContractMethod
+        attr_reader :abi, :signature, :name, :signature_hash, :input_types, :output_types, :constant
+
+        def initialize abi
+          @abi = abi
+          @name = abi['name']
+          @constant = !!abi['constant']
+          @input_types = abi['inputs'].map{|a| a['type']}
+          @output_types = abi['outputs'].map{|a| a['type']} if abi['outputs']
+          @signature = Abi::Utils.function_signature @name, @input_types
+          @signature_hash = Abi::Utils.signature_hash @signature, (abi['type']=='event' ? 64 : 8)
+        end
+
+      end
+
+      attr_reader :web3_rpc, :abi, :functions, :events, :constructor
+
+      def initialize abi, web_rpc = nil
+        @web3_rpc = web_rpc
+        @abi = abi.kind_of?(String) ? JSON.parse(abi) : abi
+        parse_abi @abi
+      end
+
+      def at address
+        ContractInstance.new self, address
+      end
+
+      def call_contract contract_address, method_name, args
+
+        function = functions[method_name]
+        raise "No method found in ABI: #{method_name}" unless function
+        raise "Function #{method_name} is not constant: #{method_name}, requires to sign transaction" unless function.constant
+
+        data = '0x' + function.signature_hash + encode_hex(encode_abi(function.input_types, args) )
+
+        response = web3_rpc.request "eth_call", [{ to: contract_address, data: data}]
+
+        string_data = [remove_0x_head(response)].pack('H*')
+        return nil if string_data.empty?
+
+        result = decode_abi function.output_types, string_data
+        result.length==1 ? result.first : result
+
+      end
+
+      def find_event_by_hash method_hash
+        events.values.detect{|e| e.signature_hash==method_hash}
+      end
+
+      def find_function_by_hash method_hash
+        functions.values.detect{|e| e.signature_hash==method_hash}
+      end
+
+      def parse_log_args log
+
+        event = find_event_by_hash log.method_hash
+        raise "No event found by hash #{log.method_hash}, probably ABI is not related to log event" unless event
+
+        not_indexed_types = event.abi['inputs'].select{|a| !a['indexed']}.collect{|a| a['type']}
+        not_indexed_values = not_indexed_types.empty? ? [] :
+                             decode_abi(not_indexed_types, [remove_0x_head(log.raw_data['data'])].pack('H*') )
+
+        indexed_types = event.abi['inputs'].select{|a| a['indexed']}.collect{|a| a['type']}
+        indexed_values = [indexed_types, log.indexed_args].transpose.collect{|arg|
+          decode_abi([arg.first], [arg.second].pack('H*') ).first
+        }
+
+        i = j = 0
+
+        args = event.abi['inputs'].collect{|input|
+          input['indexed'] ? (i+=1; indexed_values[i-1]) : (j+=1;not_indexed_values[j-1])
+        }
+
+        {event: event, args: args}
+
+      end
+
+      def parse_call_args transaction
+        function = find_function_by_hash transaction.method_hash
+        raise "No function found by hash #{transaction.method_hash}, probably ABI is not related to call" unless function
+        [function.input_types, transaction.method_arguments].transpose.collect{|arg|
+          decode_abi([arg.first], [arg.second].pack('H*') ).first
+        }
+      end
+
+
+      def parse_constructor_args transaction
+        # suffix # 0xa1 0x65 'b' 'z' 'z' 'r' '0' 0x58 0x20 <32 bytes swarm hash> 0x00 0x29
+        # look http://solidity.readthedocs.io/en/latest/metadata.html for details
+        args = transaction.input[/a165627a7a72305820\w{64}0029(\w*)/,1]
+        args ? decode_abi(constructor.input_types, [args].pack('H*') ) : []
+      end
+
+      private
+
+      def parse_abi abi
+        @functions = Hash[abi.select{|a| a['type']=='function'}.map{|a| [a['name'], ContractMethod.new(a)]}]
+        @events = Hash[abi.select{|a| a['type']=='event'}.map{|a| [a['name'], ContractMethod.new(a)]}]
+        @constructor = ContractMethod.new abi.detect{|a| a['type']=='constructor'}
+      end
+
+    end
+  end
+end

data/lib/web3/eth/{ethereum.rb → eth_module.rb}

@@ -1,7 +1,7 @@
 module Web3
   module Eth
 
-    class Ethereum
+    class EthModule
 
       include Web3::Eth::Utility
 
@@ -33,6 +33,15 @@ module Web3
         TransactionReceipt.new @web3_rpc.request("#{PREFIX}#{__method__}", [tx_hash])
       end
 
+      def contract abi
+        Web3::Eth::Contract.new abi, @web3_rpc
+      end
+
+      def load_contract etherscan_api, contract_address
+        contract(etherscan_api.contract_getabi address: contract_address).at contract_address
+      end
+
+
       def method_missing m, *args
         @web3_rpc.request "#{PREFIX}#{m}", args[0]
       end

data/lib/web3/eth/etherscan.rb

@@ -0,0 +1,71 @@
+module Web3
+  module Eth
+    class Etherscan
+
+
+      DEFAULT_CONNECT_OPTIONS = {
+          open_timeout: 10,
+          read_timeout: 70,
+          parse_result: true,
+          url: 'https://api.etherscan.io/api'
+      }
+
+      attr_reader :api_key, :connect_options
+
+      def initialize api_key, connect_options: DEFAULT_CONNECT_OPTIONS
+        @api_key = api_key
+        @connect_options = connect_options
+      end
+
+      def method_missing m, *args
+        api_module, action = m.to_s.split '_', 2
+        raise "Calling method must be in form <module>_<action>" unless action
+
+        arguments = args[0].kind_of?(String) ? { address: args[0] } : args[0]
+        result = request api_module, action, arguments
+
+        if connect_options[:parse_result]
+          begin
+            JSON.parse result
+          rescue
+            result
+          end
+        else
+          result
+        end
+
+      end
+
+
+      private
+
+      def request api_module, action, args = {}
+
+        uri = URI connect_options[:url]
+        uri.query = URI.encode_www_form({
+            module: api_module,
+            action: action,
+            apikey: api_key
+                                        }.merge(args))
+
+        Net::HTTP.start(uri.host, uri.port,
+                        connect_options.merge(use_ssl: uri.scheme=='https' )) do |http|
+
+          request = Net::HTTP::Get.new uri
+          response = http.request request
+
+          raise "Error code #{response.code} on request #{uri.to_s} #{request.body}" unless response.kind_of? Net::HTTPOK
+
+          json = JSON.parse(response.body)
+
+          raise "Response #{json['message']} on request #{uri.to_s}" unless json['status']=='1'
+
+          json['result']
+
+        end
+      end
+
+
+    end
+  end
+end

data/lib/web3/eth/log.rb

@@ -0,0 +1,30 @@
+module Web3
+  module Eth
+
+  class Log
+
+    attr_reader :raw_data
+
+    def initialize log
+      @raw_data = log
+
+      log.each do |k, v|
+        self.instance_variable_set("@#{k}", v)
+        self.class.send(:define_method, k, proc {self.instance_variable_get("@#{k}")})
+      end
+
+    end
+
+    def method_hash
+      topics.first[2..65]
+    end
+
+    def indexed_args
+      topics[1...topics.size].collect{|x| x[2..65]}
+    end
+
+
+  end
+
+  end
+end

data/lib/web3/eth/rpc.rb

@@ -17,6 +17,8 @@ module Web3
       DEFAULT_HOST = 'localhost'
       DEFAULT_PORT = 8545
 
+      attr_reader :eth, :trace
+
       def initialize host: DEFAULT_HOST, port: DEFAULT_PORT, connect_options: DEFAULT_CONNECT_OPTIONS
 
         @client_id = Random.rand 10000000
@@ -24,12 +26,9 @@ module Web3
         @uri = URI((connect_options[:use_ssl] ? 'https' : 'http')+ "://#{host}:#{port}")
         @connect_options = connect_options
 
-        @eth = Ethereum.new self
-      end
-
+        @eth = EthModule.new self
+        @trace = TraceModule.new self
 
-      def eth
-        @eth
       end
 
 

data/lib/web3/eth/trace_module.rb

@@ -0,0 +1,26 @@
+module Web3
+  module Eth
+
+    class TraceModule
+
+      include Web3::Eth::Utility
+
+      PREFIX = 'trace_'
+
+      def initialize web3_rpc
+        @web3_rpc = web3_rpc
+      end
+
+      def method_missing m, *args
+        @web3_rpc.request "#{PREFIX}#{m}", args[0]
+      end
+
+      def internalCallsByHash tx_hash
+        @web3_rpc.request("#{PREFIX}transaction", [tx_hash]).select{|t| t['traceAddress']!=[]}.collect{|t|
+          CallTrace.new t
+        }
+      end
+
+    end
+  end
+end

data/lib/web3/eth/transaction.rb

@@ -18,6 +18,24 @@ module Web3
 
       end
 
+      def method_hash
+        if input && input.length>=10
+          input[2...10]
+        else
+          nil
+        end
+      end
+
+      def method_arguments
+        if input && input.length>10
+          (0...(input.length-10)/ 64).to_a.collect{|index|
+            input[index*64+10..index*64+73]
+          }
+        else
+          []
+        end
+      end
+
       def block_number
         from_hex blockNumber
       end

data/lib/web3/eth/transaction_receipt.rb

@@ -15,6 +15,8 @@ module Web3
           self.class.send(:define_method, k, proc {self.instance_variable_get("@#{k}")})
         end
 
+        @logs = @logs.collect {|log|  Web3::Eth::Log.new log }
+
       end
 
       def block_number
@@ -22,7 +24,7 @@ module Web3
       end
 
       def success?
-         status==1 || status.nil?
+         status==1 || status=='0x1' || status.nil?
       end
 
       def gas_used_eth

data/lib/web3/eth/utility.rb

@@ -15,6 +15,9 @@ module Web3
         h.to_i 16
       end
 
+      def remove_0x_head(s)
+        s[0,2] == '0x' ? s[2..-1] : s
+      end
 
     end
   end

data/lib/web3/eth/version.rb

@@ -1,5 +1,5 @@
 module Web3
   module Eth
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/web3/eth.rb

@@ -1,7 +1,13 @@
 require "web3/eth/version"
+require "web3/eth/abi/abi_coder"
 require "web3/eth/utility"
 require "web3/eth/block"
 require "web3/eth/transaction"
+require "web3/eth/contract"
+require "web3/eth/call_trace"
+require "web3/eth/log"
 require "web3/eth/transaction_receipt"
-require "web3/eth/ethereum"
-require "web3/eth/rpc"
+require "web3/eth/eth_module"
+require "web3/eth/trace_module"
+require "web3/eth/etherscan"
+require "web3/eth/rpc"

data/web3-eth.gemspec

@@ -23,6 +23,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency('rlp', '~> 0.7.3')
+  spec.add_dependency('digest-sha3', '~> 1.1.0')
   spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"