casper_network 0.2.0 → 1.0.0

data/lib/rpc/rpc_client.rb

@@ -0,0 +1,233 @@
+require 'jimson'
+require 'json'
+require 'rdoc/rdoc'
+require "ipaddress"
+require 'resolv'
+require 'rest-client'
+require 'active_support/core_ext/hash/keys'
+require 'timeout'
+require 'net/http'
+require_relative './rpc_error.rb'
+# Class for interacting with the network via RPC
+module Casper
+  class RpcClient 
+    attr_accessor :ip_address, :port, :url, :state_root_hash
+
+    # Constructor 
+    # @param [String] ip_address
+    def initialize(ip_address)
+      @ip_address = ip_address
+      @url = "http://" + @ip_address + ":7777/rpc"
+      @state_root_hash = ""
+      @peer_array = []
+      @block_hash = ""
+      @deploy = {}
+      @node_status = {}
+      @block_transfers = []
+      @block_info = {}
+      @era_summary = {}
+      @balance_value = ""
+      @auction_state = {}
+     
+      @rpc_error = Casper::RpcError::ErrorHandle.new
+      @err = @rpc_error.error_handling(@url)
+
+    end
+
+    def get_error 
+      @err
+    end
+
+    # @return [Array<Hash>] peers array
+    def info_get_peers
+        begin
+          client = Jimson::Client.new(@url)
+          response = client.info_get_peers
+          @peer_array = response["peers"]
+        rescue
+          @rpc_error = Casper::RpcError::ErrorHandle.new
+          @error = @rpc_error.error_handling(@url)
+        end
+    end
+
+    # @return [String] state_root_hash value
+    def chain_get_StateRootHash(block_hash = "")
+      begin 
+        status = Timeout::timeout(10) {
+          client = Jimson::Client.new(@url)
+          result = client.chain_get_state_root_hash
+          @state_root_hash = result["state_root_hash"]
+        }
+      rescue
+        @rpc_error = Casper::RpcError::ErrorHandle.new
+        @error = @rpc_error.error_handling(@url)
+      end
+    end
+
+    # Get information about a single deploy by hash.
+    # @param [String] deploy_hash
+    # @return [Hash] Deploy
+    def info_get_deploy(deploy_hash)
+      begin
+        status = Timeout::timeout(10) {
+          client = Jimson::Client.new(@url)
+          response = client.info_get_deploy({"deploy_hash"=> deploy_hash })
+          if (deploy_hash == "" || deploy_hash == nil)
+            Casper::RpcError::InvalidParameter.error
+          end
+          @deploy = response["deploy"]
+          # @deploy.keys.each do |key|  
+          #     @deploy[(key.to_sym rescue key) || key] = @deploy.delete(key)
+          # end
+          @deploy
+        }
+      rescue
+        Casper::RpcError::InvalidParameter.error 
+      end
+    end
+
+
+    # Receive node status information 
+    # @return node_status
+    def info_get_status
+      begin
+        status = Timeout::timeout(10) {
+          client = Jimson::Client.new(@url)
+          @node_status = client.info_get_status
+        }
+      rescue
+        @rpc_error = Casper::RpcError::ErrorHandle.new
+        @error = @rpc_error.error_handling(@url)
+      end
+    end
+
+    # @param [String] block_hash
+    # @return [Array<Hash>] block_transfers
+    def chain_get_block_transfers(block_hash = "") 
+      begin
+        status = Timeout::timeout(5) {
+          client = Jimson::Client.new(@url)
+          response = client.chain_get_block_transfers({
+            "block_identifier" => {"Hash" => block_hash}
+          })
+          @block_transfers = response["transfers"]
+          @block_transfers
+        }
+      rescue
+        Casper::RpcError::InvalidParameter.error
+      end
+    end
+
+    # @param [String] block_hash
+    # @return [Hash] block_info
+    def chain_get_block(block_hash)
+      begin 
+        state = Timeout::timeout(10) {
+          client = Jimson::Client.new(@url)
+          result = client.chain_get_block({"block_identifier" => {"Hash" => block_hash}})
+          @block_info = result["block"]
+          if (!@block_info.empty?() && @block_info["hash"] != block_hash)
+            raise("Returned block does not have a matching hash.")
+          else
+            @block_info
+          end
+        }
+      rescue
+        Casper::RpcError::InvalidParameter.error
+      end
+    end
+
+    # @param [String] block_hash
+    # @return [Hash] era_summary
+    def chain_get_eraInfo_by_SwitchBlock(block_hash)
+      begin
+        state = Timeout::timeout(10) {
+        client = Jimson::Client.new(@url)
+        response = client.chain_get_era_info_by_switch_block("block_identifier" => {"Hash" => block_hash})
+        @era_summary = response["era_summary"]
+        
+        if @era_summary == nil
+          Casper::RpcError::InvalidParameter.error
+        else
+          @era_summary
+        end
+        }
+      rescue
+        Casper::RpcError::InvalidParameter.error
+      end
+    end  
+    
+    # @param [String] state_root_hash
+    # @param [String] key
+    # @param [Array] path
+    def state_get_item(state_root_hash, key, path)
+      begin
+        state = Timeout::timeout(20) {
+          client = Jimson::Client.new(@url)
+          response = client.state_get_item({ 
+            "state_root_hash" => state_root_hash, 
+            "key" => key,
+            "path" => path
+          })
+          @stored_value = response["stored_value"]
+          @stored_value
+        }
+      rescue
+        Casper::RpcError::InvalidParameter.error
+      end
+    end
+
+    # @param [String] state_root_hash
+    # @param [String] item_key
+    # @param [String] uref
+    def state_get_dictionary_item(state_root_hash, item_key, uref)
+      begin
+        state = Timeout::timeout(10) {
+          client = Jimson::Client.new(@url)
+          response = client.state_get_dictionary_item({
+            "state_root_hash" => state_root_hash,
+            "dictionary_identifier" => {'URef' => 
+              {'seed_uref' => uref, 'dictionary_item_key' => item_key} }})
+            @stored_value = response["stored_value"]
+            @stored_value
+        }
+      rescue
+        Casper::RpcError::InvalidParameter.error
+      end
+    end
+
+    # @param [String] state_root_hash
+    # @param [String] balance_uref
+    def state_get_balance(state_root_hash, balance_uref)
+      begin
+        state = Timeout::timeout(5) {
+          client = Jimson::Client.new(@url)
+          response = client.state_get_balance({
+            "state_root_hash" => state_root_hash,
+            "purse_uref" => balance_uref
+          })
+          @balance_value = response["balance_value"]
+          @balance_value
+        }
+      rescue
+        Casper::RpcError::InvalidParameter.error
+      end
+    end
+
+    # Returns current auction system contract information.
+    # @return [Hash] auction_state
+    def state_get_AuctionInfo
+      begin 
+        state = Timeout::timeout(50) {
+        client = Jimson::Client.new(@url)
+        response = client.state_get_auction_info
+        @auction_state = response['auction_state']
+        @auction_state
+        }
+      rescue
+        @rpc_error = Casper::RpcError::ErrorHandle.new
+        @error = @rpc_error.error_handling(@url)
+      end
+    end
+  end
+end

data/lib/rpc/rpc_error.rb

@@ -0,0 +1,79 @@
+
+module Casper
+  module RpcError
+    class ErrorHandle  
+      # @param [Integer] code
+      # @param [String] message
+      # @param [String] data
+      def initialize(code = 0, message = "", data = "") 
+        @code = code
+        @message = message
+        @data = data
+      end
+
+      # @return [String] err
+      def self.invalid_param 
+        @code = -32602
+        @message = "Invalid params"
+        @err = "Server error #{@code}: #{@message}"
+      end
+
+      # @param [String] url
+      # @return [String]
+      def error_handling(url)
+        begin
+          response = RestClient.get(url)
+          parsed = JSON.parse(response)
+          # p parsed
+        rescue RestClient::ResourceNotFound => e
+          e.class.inspect
+          # "ResourceNotFound"
+        rescue Errno::ECONNREFUSED => e
+          e.class.inspect
+          # p e.class
+          # "Errno::ECONNREFUSED"
+        rescue SocketError => e
+           e.class.inspect
+          # "Socket Error"
+        rescue
+          "Timed out connecting to server"
+        end
+      end 
+
+      # @return [String]
+      def invalid_address
+        "getaddrinfo: Name or service not known (SocketError)"
+      end
+
+      # @return [String]
+      def invalid_parameter
+        "Server error -32602: Invalid params"
+      end
+    end
+    
+    class ServerError < StandardError
+
+      # @return [String]
+      def initialize(code, message)
+        super("Server error #{code}: #{message}")
+      end
+    end
+
+    class InvalidParameter
+
+      def initialize  
+      end
+      
+      # @return [String]
+      def self.error
+        "Server error -32602: Invalid params"
+      end      
+
+      # @return [String]
+      def self.argument_error
+        "ArgumentError"
+      end
+    end
+
+  end
+end

data/lib/serialization/cl_type_serializer.rb

@@ -0,0 +1,76 @@
+require_relative '../types/cl_bool_type.rb'
+require_relative '../types/cl_bool.rb'
+require_relative '../types/cl_i32_type.rb'
+require_relative '../types/cl_i64_type.rb'
+require_relative '../types/cl_u8_type.rb'
+require_relative '../types/cl_u32_type.rb'
+require_relative '../types/cl_u64_type.rb'
+require_relative '../types/cl_u128_type.rb'
+require_relative '../types/cl_u256_type.rb'
+require_relative '../types/cl_u512_type.rb'
+require_relative '../types/cl_unit_type.rb'
+require_relative '../types/cl_string_type.rb'
+require_relative '../types/cl_key_type.rb'
+require_relative '../types/cl_option_type.rb'
+require_relative '../types/cl_list_type.rb'
+require_relative '../types/cl_byte_array_type.rb'
+require_relative '../types/cl_result_type.rb'
+require_relative '../types/cl_map_type.rb'
+require_relative '../types/cl_tuple_type.rb'
+require_relative '../types/cl_any_type.rb'
+require_relative '../types/cl_public_key_type.rb'
+
+class CLTypeSerizalizer
+
+  def self.serialize_cl_type(cl_type)
+    if cl_type.to_string == "Bool"
+      [0].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "I32"
+      [1].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "I64"
+      [2].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "U8"
+      [3].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "U32"
+      [4].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "U64"
+      [5].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "U128"
+      [6].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "U256"
+      [7].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "U512"
+      [8].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "Unit"
+      [9].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "String"
+      [10].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "Key"
+      [11].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "URef"
+      [12].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "Option"
+      [13].pack("C*").unpack1("H*") + serialize_cl_type(cl_type.get_inner_type)
+    elsif cl_type.to_string == "List"
+      [14].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "ByteArray"
+      [15].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "Result"
+      [16].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "Map"
+      [17].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "Tuple1"
+      [18].pack("C*").unpack1("H*") + cl_type.get_data[0].to_bytes
+    elsif cl_type.to_string == "Tuple2"
+      [19].pack("C*").unpack1("H*") + cl_type.get_data[0].to_bytes + cl_type.get_data[1].to_bytes
+    elsif cl_type.to_string == "Tuple3"
+      [20].pack("C*").unpack1("H*") + cl_type.get_data[0].to_bytes + cl_type.get_data[1].to_bytes + cl_type.get_data[2].to_bytes
+    elsif cl_type.to_string == "Any"
+      [21].pack("C*").unpack1("H*")
+    elsif cl_type.to_string == "PublicKey"
+      [22].pack("C*").unpack1("H*")
+    else
+      "Undefined"
+    end
+  end  
+end