web3ethereum 1.0.0

data/lib/web3/eth/contract.rb

@@ -0,0 +1,171 @@
+module Web3
+  module Eth
+    class Contract
+
+      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
+
+        include Abi::AbiCoder
+        include Abi::Utils
+        include Utility
+
+        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
+
+        def parse_event_args log
+
+          log_data = remove_0x_head log.raw_data['data']
+          indexed_types = abi['inputs'].select{|a| a['indexed']}.collect{|a| a['type']}
+          not_indexed_types = abi['inputs'].select{|a| !a['indexed']}.collect{|a| a['type']}
+
+          indexed_args = log.indexed_args
+
+          if indexed_args.size==indexed_types.size
+
+            indexed_values = [indexed_types, indexed_args].transpose.collect{|arg|
+              decode_typed_data( arg.first, [arg.second].pack('H*') )
+            }
+
+            not_indexed_values = not_indexed_types.empty? ? [] :
+                                     decode_abi(not_indexed_types, [log_data].pack('H*') )
+
+            i = j = 0
+
+            abi['inputs'].collect{|input|
+              input['indexed'] ? (i+=1; indexed_values[i-1]) : (j+=1;not_indexed_values[j-1])
+            }
+
+          elsif !indexed_args.empty? || !log_data.empty?
+            all_types = abi['inputs'].collect{|a| a['type']}
+            [all_types[0...indexed_args.size], indexed_args].transpose.collect{|arg|
+              decode_typed_data( arg.first, [arg.second].pack('H*') )
+            } + decode_abi(all_types[indexed_args.size..-1], [log_data].pack('H*') )
+          else
+            []
+          end
+
+        end
+
+
+        def parse_method_args transaction
+          d = transaction.call_input_data
+          (!d || d.empty?) ? [] : decode_abi(input_types, [d].pack('H*'))
+        end
+
+        def do_call web3_rpc, contract_address, args
+          data = '0x' + signature_hash + encode_hex(encode_abi(input_types, args) )
+
+          response = web3_rpc.request "eth_call", [{ to: contract_address, data: data}, 'latest']
+
+          string_data = [remove_0x_head(response)].pack('H*')
+          return nil if string_data.empty?
+
+          result = decode_abi output_types, string_data
+          result.length==1 ? result.first : result
+        end
+
+      end
+
+      attr_reader :web3_rpc, :abi, :functions, :events, :constructor, :functions_by_hash, :events_by_hash
+
+      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
+        function.do_call web3_rpc, contract_address, args
+      end
+
+      def find_event_by_hash method_hash
+        @events_by_hash[method_hash]
+      end
+
+      def find_function_by_hash method_hash
+        @functions_by_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
+        event.parse_event_args log
+      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.parse_method_args transaction
+      end
+
+
+      def parse_constructor_args transaction
+        constructor ? constructor.parse_method_args(transaction) : []
+      end
+
+      private
+
+      def parse_abi abi
+        @functions = {}
+        @events = {}
+
+        @functions_by_hash = {}
+        @events_by_hash = {}
+
+        abi.each{|a|
+
+          case a['type']
+            when 'function'
+              method = ContractMethod.new(a)
+              @functions[method.name] = method
+              @functions_by_hash[method.signature_hash] = method
+            when 'event'
+              method = ContractMethod.new(a)
+              @events[method.name] = method
+              @events_by_hash[method.signature_hash] = method
+            when 'constructor'
+              method = ContractMethod.new(a)
+              @constructor = method
+          end
+        }
+      end
+
+    end
+  end
+end

data/lib/web3/eth/eth_module.rb

@@ -0,0 +1,52 @@
+module Web3
+  module Eth
+
+    class EthModule
+
+      include Web3::Eth::Utility
+
+      PREFIX = 'eth_'
+
+      def initialize web3_rpc
+        @web3_rpc = web3_rpc
+      end
+
+      def getBalance address, block = 'latest', convert_to_eth = true
+        wei = @web3_rpc.request("#{PREFIX}#{__method__}", [address, block]).to_i 16
+        convert_to_eth ? wei_to_ether(wei) : wei
+      end
+
+      def getBlockByNumber block, full = true, convert_to_object = true
+        resp = @web3_rpc.request("#{PREFIX}#{__method__}", [hex(block), full])
+        convert_to_object ? Block.new(resp) : resp
+      end
+
+      def blockNumber
+        from_hex @web3_rpc.request("#{PREFIX}#{__method__}")
+      end
+
+      def getTransactionByHash tx_hash
+        Transaction.new @web3_rpc.request("#{PREFIX}#{__method__}", [tx_hash])
+      end
+
+      def getTransactionReceipt tx_hash
+        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
+
+
+    end
+  end
+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,34 @@
+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 has_topics?
+      !!topics.first
+    end
+
+    def method_hash
+      topics.first && 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

@@ -0,0 +1,71 @@
+module Web3
+  module Eth
+
+    class Rpc
+
+      require 'json'
+      require 'net/http'
+
+      JSON_RPC_VERSION = '2.0'
+
+      DEFAULT_CONNECT_OPTIONS = {
+          use_ssl: false,
+          open_timeout: 10,
+          read_timeout: 70
+      }
+
+      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
+
+        @uri = URI((connect_options[:use_ssl] ? 'https' : 'http')+ "://#{host}:#{port}#{connect_options[:rpc_path]}")
+        @connect_options = connect_options
+
+        @eth = EthModule.new self
+        @trace = TraceModule.new self
+
+      end
+
+
+      def request method, params = nil
+
+
+        Net::HTTP.start(@uri.host, @uri.port, @connect_options) do |http|
+
+          request = Net::HTTP::Post.new @uri, {"Content-Type" => "application/json"}
+          request.body = {:jsonrpc => JSON_RPC_VERSION, method: method, params: params, id: @client_id}.compact.to_json
+          response = http.request request
+
+          raise "Error code #{response.code} on request #{@uri.to_s} #{request.body}" unless response.kind_of? Net::HTTPOK
+
+          body = JSON.parse(response.body)
+
+          if body['result']
+            body['result']
+          elsif body['error']
+            raise "Error #{@uri.to_s} #{body['error']} on request #{@uri.to_s} #{request.body}"
+          else
+            raise "No response on request #{@uri.to_s} #{request.body}"
+          end
+
+        end
+
+      end
+
+
+    end
+  end
+end
+
+unless Hash.method_defined?(:compact)
+  class Hash
+    def compact
+      self.reject{ |_k, v| v.nil? }
+    end
+  end
+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

@@ -0,0 +1,73 @@
+module Web3
+  module Eth
+
+    class Transaction
+
+      include Web3::Eth::Utility
+
+      attr_reader :raw_data
+
+      def initialize transaction_data
+        @raw_data = transaction_data
+        transaction_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 method_hash
+        if input && input.length>=10
+          input[2...10]
+        else
+          nil
+        end
+      end
+
+      # 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
+      def call_input_data
+        if raw_data['creates'] && input
+          fetch_constructor_data input
+        elsif input && input.length>10
+          input[10..input.length]
+        else
+          []
+        end
+      end
+
+      def block_number
+        # if transaction is less than 12 seconds old, blockNumber will be nil
+        # :. nil check before calling `to_hex` to avoid argument error
+        blockNumber && from_hex(blockNumber)
+      end
+
+      def value_wei
+        from_hex value
+      end
+
+      def value_eth
+        wei_to_ether from_hex value
+      end
+
+      def gas_limit
+        from_hex gas
+      end
+
+      def gasPrice_eth
+        wei_to_ether from_hex gasPrice
+      end
+
+      private
+
+      CONSTRUCTOR_SEQ = /a165627a7a72305820\w{64}0029(\w*)$/
+      def fetch_constructor_data input
+        data = input[CONSTRUCTOR_SEQ,1]
+        while data && (d = data[CONSTRUCTOR_SEQ,1])
+          data = d
+        end
+        data
+      end
+
+    end
+  end
+end