web3-hpb 0.0.2

data/lib/web3/hpb/contract.rb

@@ -0,0 +1,172 @@
+module Web3
+  module Hpb
+
+    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_type_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{|collect|
+              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))
+          puts data
+
+          response = web3_rpc.request("hpb_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, :fucntions_by_hash, :events_by_hash
+
+      def initialize(abi, web_rpc = nil)
+        @web3_rpc = web_rpc
+        # parse to json format
+        @abi = abi.is_a?(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_method_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 do |a|
+          case a['type']
+          when 'function'
+            method = ContractMethod.new(a)
+            @functions[method.name] = method
+            puts @functions
+            @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
+end

data/lib/web3/hpb/hpb_module.rb

@@ -0,0 +1,47 @@
+module Web3
+  module Hpb
+
+    class HpbModule
+
+      include Web3::Hpb::Utility
+
+      PREFIX = 'hpb_'
+
+      def initialize web3_rpc
+        @web3_rpc = web3_rpc
+      end
+
+      def getBalance address, block = 'latest', convert_to_hpb = true
+        wei = @web3_rpc.request("#{PREFIX}#{__method__}", [address, block]).to_i 16
+        convert_to_hpb ? wei_to_hpb(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::Hpb::Contract.new abi, @web3_rpc
+      end
+
+      def method_missing m, *args
+        @web3_rpc.request "#{PREFIX}#{m}", args[0]
+      end
+
+
+    end
+  end
+end

data/lib/web3/hpb/log.rb

@@ -0,0 +1,30 @@
+module Web3
+  module Hpb
+
+    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/hpb/rpc.rb

@@ -0,0 +1,64 @@
+module Web3
+  module Hpb
+
+    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 :hpb, :trace
+
+      def initialize(host: DEFAULT_HOST, port:DEFAULT_PORT, connect_options: DEFAULT_CONNECT_OPTIONS)
+
+        @client_id = Random.rand(1000_000)
+
+        @uri = URI((connect_options[:use_ssl] ? 'https' : 'http') + "://#{host}:#{port}#{connect_options[:rpc_path]}")
+        @connect_options = connect_options
+        @hpb = HpbModule.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/hpb/trace_module.rb

@@ -0,0 +1,26 @@
+module Web3
+  module Hpb
+
+    class TraceModule
+
+      include Web3::Hpb::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/hpb/transaction.rb

@@ -0,0 +1,73 @@
+module Web3
+  module Hpb
+
+    class Transaction
+
+      include Web3::Hpb::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_hpb
+        wei_to_hpb(from_hex value)
+      end
+
+      def gas_limit
+        from_hex gas
+      end
+
+      def gasPrice_hpb
+        wei_to_hpb(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

data/lib/web3/hpb/transaction_receipt.rb

@@ -0,0 +1,41 @@
+module Web3
+  module Hpb
+
+    class TransactionReceipt
+
+      include Web3::Hpb::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
+
+        @logs = @logs.collect {|log|  Web3::Hpb::Log.new log }
+
+      end
+
+      def block_number
+        from_hex blockNumber
+      end
+
+      def success?
+         status==1 || status=='0x1' || status.nil?
+      end
+
+      def gas_used
+        from_hex gasUsed
+      end
+
+
+      def cumulative_gas_used
+        from_hex cumulativeGasUsed
+      end
+
+    end
+  end
+end