casper_network 0.2.0 → 1.0.0

data/lib/casper_network.rb

@@ -1,4 +1,3 @@
-# casper_network.rb
 require 'jimson'
 require 'json'
 require 'rdoc/rdoc'
@@ -7,208 +6,284 @@ require 'resolv'
 require 'rest-client'
 require 'active_support/core_ext/hash/keys'
 require 'timeout'
+require 'net/http'
+# require "./rpc/rpc.rb"
+require_relative './rpc/rpc_error.rb'
+require_relative './rpc/rpc_client.rb'
 
+# Dir["./entity/*.rb"].each {|file|  require  file }
+# Dir["./serialization/*.rb"].each {|file|  require file }
+# Dir["./types/*.rb"].each {|file|  require file }
+require_relative './include.rb'
 # Class for interacting with the network via RPC
-class CasperClient
-  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 = {}
-  end
+# puts "Hello"
+module Casper
+  class CasperClient 
+    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)
+
+      @pr = []
 
-  # @return [Array<Hash>] peers array
-  def info_get_peers
-    begin
-      status = Timeout::timeout(20) {
-        client = Jimson::Client.new(@url)
-        result = client.info_get_peers
-        @peer_array = result["peers"]
-      }
-    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!'
+    def get_error 
+      @err
     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) {
-        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!'
+    # @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 [Array<Hash>] peers array
+    def info_get_peers
+        begin
+          client = Jimson::Client.new(@url)
+          response = client.info_get_peers
+          @peers = response["peers"]
+          # @peers.map! do |peer|
+          #   peer.symbolize_keys
+          # end
+          @peers.map { |item| @pr << Casper::Entity::Peer.new(item.symbolize_keys) }
+          @pr
+        rescue
+          @rpc_error = Casper::RpcError::ErrorHandle.new
+          @error = @rpc_error.error_handling(@url)
+        end
     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
 
-  # 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'
+    # 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
+    def info_get_deploy(deploy_hash)
+      @dep = nil
+      begin
+        status = Timeout::timeout(60) {
+          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.keys.each do |key|  
+          #     @deploy[(key.to_sym rescue key) || key] = @deploy.delete(key)
+          # end
+          temp = []
+          @deploy = response["deploy"]
+          @deploy.deep_symbolize_keys!
+          Casper::Entity::Deploy.new(@deploy[:hash], @deploy[:header], @deploy[:payment], @deploy[:session], @deploy[:approvals])
+        }
+      rescue
+        Casper::RpcError::InvalidParameter.error 
+      end
     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'
+
+    # 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
-  end
 
-  # @param [String] block_hash
-  # @return [Hash] block_info
-  def chain_get_block(block_hash)
-    begin 
-      state = Timeout::timeout(10) {
+    # @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}
+          })
+          @transfers = response["transfers"]
+          @transfers.map { |transfer| Casper::Entity::Transfer.new(transfer.deep_symbolize_keys!)}
+        }
+      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)
-        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.")
+        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
-          @block_info
+          @era_summary
         end
-      }
-    rescue
-      'Timeout expired to retrieve block_info'
+        }
+      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
-  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'
+    # @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
-  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'
+    # @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
-  end
 
-  # @param [String] state_root_hash
-  # @param [String] balance_uref
-  def state_get_balance(state_root_hash, balance_uref)
-    begin
-      state = Timeout::timeout(5) {
+    # 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_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'
+        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
-
-  # 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!'
+    
+    def put_deploy(deploy)
+      client = Jimson::Client.new(url)
+      response = client.account_put_deploy(deploy)
+      response['deploy_hash']
     end
+  
   end
-end
 
+end

data/lib/crypto/00_asymmetric_key.rb

@@ -0,0 +1,95 @@
+require_relative '../utils/base_16.rb'
+require_relative '../types/cl_public_key.rb'
+require_relative '../utils/hex_utils.rb'
+require_relative '../utils/hash_utils.rb'
+
+CLPublicKeyTag = {
+  ED25519: 1,
+  SECP256K1: 2
+}
+
+SignatureAlgorithm = {
+  Ed25519: 'ed25519',
+  Secp256K1: 'secp256k1'
+}
+
+class AsymmetricKey
+  attr_reader :public_key, :private_key, :signature_algorithm
+  include Utils::HashUtils
+  # @param [CLPublicKey] public_key
+  # @param [Array] private_key
+  # @param [SignatureAlgorithm] signature_algorithm
+  def initialize(public_key, private_key, signature_algorithm)
+    @public_key = public_key
+    @private_key = private_key
+    @signature_algorithm = signature_algorithm
+    @tag = @public_key.get_cl_public_key_tag
+  end
+
+  # @return [CLPublicKey]
+  def get_public_key
+    @public_key
+  end
+
+  def get_signature_algorithm
+    @signature_algorithm
+  end
+
+  # Get public hex-encoded string
+  #
+  # @return [String]
+  def get_public_key_hex
+   "0#{@tag}" + Utils::Base16.encode16(@public_key.get_value)
+  end
+
+  # @param [CLPublicKey] public_key
+  # @return [String] account_hex
+  def account_hex(public_key)
+    account_hex = @public_key.to_hex
+  end
+
+  # @return [Array<Integer>] 
+  def account_hash
+    @tag = @public_key.get_cl_public_key_tag
+    key_name = CLPublicKeyTag.key(@tag).to_s
+    prefix = key_name.downcase.unpack("C*") + [0]
+    bytes = prefix + @public_key.get_value
+    result_array = Utils::HashUtils.byte_hash(bytes)
+    @public_key.get_value.length == 0 ? [] : result_array
+    # @public_key.to_account_hash_byte_array
+  end
+ 
+  # @param [String] path_to_private_key
+  def create_from_private_key_file(path_to_private_key)
+    puts "AsymmetricKey::create_from_private_key_file is called!"
+  end
+
+  # Get public key which is stored in pem
+  def export_public_key_in_pem
+    puts "AsymmetricKey::export_public_key_in_pem is called!"
+  end
+
+  # @param [String] message
+  # @return [String]
+  def sign(message)
+    puts "AsymmetricKey:sign is called!"
+  end
+
+
+  # @param [String] signature
+  # @param [String] message
+  # @return [Boolean]
+  def verify(signature, message) 
+    puts "AsymmetricKey::verify is called!"
+  end
+ 
+  protected
+    attr_accessor :private_key
+
+    def to_pem(tag, content) 
+      line1 = "-----BEGIN #{tag}-----\n"
+      line2 = "#{content}"
+      line3 = "-----END #{tag}-----\n"
+      line1 + line2 + line3
+    end
+end

data/lib/crypto/01_ed25519.rb

@@ -0,0 +1,67 @@
+require 'openssl'
+require 'ed25519'
+require_relative './asymmetric_key.rb'
+
+
+
+class Ed25519Key < AsymmetricKey
+
+  def initialize(public_key, private_key)
+    super(public_key, private_key, SignatureAlgorithm[:Ed25519])
+  end
+
+  # @param [Array] public_key
+  # @return [String]
+  # def self.account_hex(public_key)
+  #   '01' + Utils::Base16.encode16(public_key)
+  # end
+
+
+  def create_from_private_key_file(path_to_private_key)
+
+  end
+
+
+  def parse_private_key_file(path)
+  end
+
+  def parse_public_key_file(path)
+  end
+
+  def parse_private_key(bytes)
+  end
+
+  def parse_public_key(bytes)
+  end
+
+  def read_base_64_with_pem(content)
+  end
+
+  # private method
+  def read_base_64_file(path)
+  end
+
+  # private
+  def parse_key(bytes, from, to)
+  end
+
+  def export_private_key_in_pem
+  end
+  
+  def export_public_key_in_pem
+  end
+
+  def sign(msg)
+  end
+
+  def verify(signature, msg)
+  end
+
+  def private_to_public(private_key)
+  end
+
+  def load_keypair_from_private_file(private_key_path)
+  end
+
+end
+