casper_network 0.2.0 → 0.2.1

data/lib/entity/deploy_header.rb

@@ -0,0 +1,58 @@
+module Casper
+  module Entity
+    class DeployHeader 
+     
+      # @param [String] account
+      # @param [Integer] timestamp
+      # @param [Integer] ttl
+      # @param [Integer] gas_price
+      # @param [String] body_hash
+      # @param [Array] dependencies
+      # @param [String] chain_name
+      def initialize(account, timestamp, ttl, gas_price, body_hash, dependencies, chain_name)
+        @account = account
+        @timestamp = timestamp
+        @ttl = ttl
+        @gas_price = gas_price
+        @body_hash = body_hash
+        @dependencies = dependencies
+        @chain_name = chain_name
+      end
+
+      # @return [String] account
+      def get_account
+        @account
+      end
+
+      # @return [Integer] timestamp
+      def get_timestamp
+        @timestamp
+      end
+
+      # @return [Integer] ttl
+      def get_ttl
+        @ttl
+      end
+
+      # @return [Integer] gas_price
+      def get_gas_price
+        @gas_price
+      end
+
+      # @return [String] body_hash
+      def get_body_hash
+        @body_hash
+      end
+
+      # @return [Array] dependencies
+      def get_dependencies
+        @dependencies
+      end
+
+      # @return [String] chain_name
+      def get_chain_name
+        @chain_name
+      end
+    end
+  end
+end

data/lib/entity/era_summary.rb

@@ -0,0 +1,44 @@
+module Casper
+  module Entity
+    class EraSummary
+
+      # @param [String] block_hash_
+      # @param [Integer] era_id_
+      # @param [StoredValue] stored_value_
+      # @param [String] state_root_hash_
+      # @param [String] merkle_proof_
+      def initialize(block_hash_, era_id_, stored_value_, state_root_hash_, merkle_proof_)
+        @block_hash = block_hash_
+        @era_id = era_id_
+        @stored_value = stored_value_
+        @state_root_hash = state_root_hash_
+        @merkle_proof = merkle_proof_
+      end
+
+      # @return [String] block_hash
+      def get_block_hash
+        @block_hash
+      end
+
+      # @return [Integer] era_id
+      def get_era_id
+        @era_id
+      end
+
+      # @return [StoredValue] StoredValue
+      def get_stored_value
+        @stored_value
+      end
+
+      # @return [String] state_root_hash
+      def get_state_root_hash
+        @state_root_hash
+      end
+
+      # @return [String] merkle_proof
+      def get_merkle_proof
+        @merkle_proof
+      end
+    end
+  end
+end

data/lib/entity/era_validator.rb

@@ -0,0 +1,23 @@
+module Casper
+  module Entity
+    class EraValidator
+
+      # @param [Integer] era_id
+      # @param [Array<ValidatorWeight>] validator_weights
+      def initialize(era_id, validator_weights)
+        @era_id = era_id
+        @validator_weights = validator_weights
+      end
+
+      # @return [Integer] era_id
+      def get_era_id
+        @era_id
+      end
+
+      # @return [Array<ValidatorWeight>] validator_weights
+      def get_validator_weights
+        @validator_weights
+      end
+    end
+  end
+end

data/lib/entity/peer.rb

@@ -0,0 +1,25 @@
+module Casper
+  module Entity
+    class Peer
+
+      # @param [Hash] peer
+      # @option peer [String] :node_id
+      # @option peer [String] :address 
+      def initialize(peer = {})
+        @node_id = peer[:node_id]
+        @address = peer[:address]
+      end
+
+      # @return [String] node_id
+      def get_node_id
+        @node_id
+      end
+
+      # @return [String] address
+      def get_address
+        @address
+      end
+    end
+  end
+end
+

data/lib/entity/validator_weight.rb

@@ -0,0 +1,23 @@
+module Casper
+  module Entity
+    class ValidatorWeight
+
+      # @param [String] public_key
+      # @param [String] weight
+      def initialize(public_key, weight)
+        @public_key = public_key
+        @weight = weight
+      end
+
+      # @return [String] public_key
+      def get_public_key
+        @public_key
+      end
+
+      # @return [String] weight
+      def get_weight
+        @weight
+      end
+    end
+  end
+end

data/lib/rpc/rpc_client.rb

@@ -0,0 +1,227 @@
+# casper_network.rb
+require 'jimson'
+require 'json'
+require 'rdoc/rdoc'
+require "ipaddress"
+require 'resolv'
+require 'rest-client'
+require 'active_support/core_ext/hash/keys'
+require 'timeout'
+require_relative '../entity/peer.rb'
+module Casper
+  # Class for interacting with the network via RPC
+  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 = {}
+
+      @peers = []
+    end
+
+    # @return [Array<Hash>] peers array
+    def info_get_peers
+      begin
+        status = Timeout::timeout(20) {
+          client = Jimson::Client.new(@url)
+          response = client.info_get_peers
+          response.deep_symbolize_keys!
+          @peer_array = response[:peers]
+          @peer_array.map { |item| @peers << Casper::Entity::Peer.new(item) }
+          # @peers[0].get_node_id
+          # @peers[0].get_node_id
+          # @peers[0].get_address
+          @peer_array
+        }
+      rescue Timeout::Error 
+        'Timeout expired to retrieve peers!'
+      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
+        'Timeout expired to retrieve state_root_hash value!'
+      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(20) {
+          if (deploy_hash == "" || deploy_hash == nil)
+            return "Server error -32602: Invalid params"
+          end
+          client = Jimson::Client.new(@url)
+          response = client.info_get_deploy({"deploy_hash"=> deploy_hash })
+          @deploy = response["deploy"]
+          # @deploy.keys.each do |key|  
+          #     @deploy[(key.to_sym rescue key) || key] = @deploy.delete(key)
+          # end
+          @deploy
+        }
+      rescue
+        'Timeout expired to retrieve Deploy!'
+      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
+        'Timeout expired to retrieve node status information'
+      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
+        'Timeout expired to retrieve block_transfers'
+      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
+        'Timeout expired to retrieve block_info'
+      end
+    end
+
+    # @param [String] block_hash
+    # @return [Hash] era_summary
+    def chain_get_eraInfo_by_SwitchBlock(block_hash)
+      begin
+        state = Timeout::timeout(60) {
+        client = Jimson::Client.new(@url)
+        response = client.chain_get_era_info_by_switch_block("block_identifier" => {"Hash" => block_hash})
+        @era_summary = response["era_summary"]
+        @era_summary
+        }
+      rescue
+        'Timeout expired to retrieve era_summary'
+      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
+        'Timeout expired to retrieve stored_value'
+      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(5) {
+          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
+        'Timeout expired to retrieve stored_value'
+      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
+        'Timeout expired to retrieve balance_value'
+      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
+        'Timeout expired to retrieve auction_state information!'
+      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/spec/client_spec.rb

@@ -0,0 +1,25 @@
+# client_spec.rb
+require './lib/casper_network.rb'
+
+describe CasperClient do
+  client1 = CasperClient.new("185.246.84.43")
+  # Test info_get_peers()
+  describe "#info_get_peers" do
+    it "returns peers array." do
+      # Check whether ıt is an array or not
+      expect(client1.info_get_peers).to be_an(Array)
+      # Check the length of the peers array 
+      expect(client1.info_get_peers.length).to be > 0
+
+    end
+  end   
+   # Test chain_get_StateRootHash() 
+  describe "#chain_get_StateRootHash" do
+    it "returns current state_root_hash." do
+      # Check whether its type is string or not
+      expect(client1.chain_get_StateRootHash).to be_an(String)
+    end
+  end  
+
+
+end