test_sdk1 1.0.0

data/lib/test_sdk1.rb

@@ -0,0 +1,289 @@
+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 "./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
+# 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 = []
+
+    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 [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
+
+    # @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
+    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
+
+
+    # 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}
+          })
+          @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)
+        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
+    
+    def put_deploy(deploy)
+      client = Jimson::Client.new(url)
+      response = client.account_put_deploy(deploy)
+      response['deploy_hash']
+    end
+  
+  end
+
+end

data/lib/types/cl_account_hash.rb

@@ -0,0 +1,24 @@
+require_relative './cl_account_hash_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+
+class CLAccountHash < CLValue  
+ 
+  def initialize(value)
+    super()
+    @value =  value
+  end
+
+  def get_cl_type
+    @cl_type = CLAccountHashType.new
+    @cl_type.to_string
+  end
+
+  def get_value
+    @value  
+  end
+end
+
+# cl_account_hash = CLAccountHash.new([10, 20])
+# puts cl_account_hash.get_cl_type

data/lib/types/cl_account_hash_type.rb

@@ -0,0 +1,22 @@
+require_relative './cl_type.rb'
+require_relative './constants.rb'
+
+
+class CLAccountHashType < CLType
+  # def initialize(value = nil)  
+  #   super(value)
+  #   @value = value
+  # end
+
+  def to_string
+    ACCOUNT_HASH_ID
+  end
+
+  def get_value 
+    @value
+  end
+
+  def to_json 
+    to_string
+  end
+end

data/lib/types/cl_any.rb

@@ -0,0 +1,25 @@
+require_relative './cl_any_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+
+
+class CLAny < CLValue  
+  include CLValueBytesParsers::CLAnyBytesParser
+ 
+  def initialize(value = nil)
+    super
+    @value =  value
+  end
+
+  def get_cl_type
+    @cl_type = CLAnyType.new
+    @cl_type.to_string
+  end
+
+  def get_value
+    @value  
+  end
+
+end
+

data/lib/types/cl_any_type.rb

@@ -0,0 +1,22 @@
+require_relative './cl_type.rb'
+require_relative './constants.rb'
+
+
+class CLAnyType < CLType
+  def initialize(value = nil)  
+    super(value)
+    @value = value
+  end
+
+  def to_string
+    TAGS.key(21).to_s
+  end
+
+  def get_value 
+    @value
+  end
+
+  def to_json 
+    to_string
+  end
+end

data/lib/types/cl_bool.rb

@@ -0,0 +1,32 @@
+require_relative './cl_bool_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+
+module Boolean; end
+class TrueClass; include Boolean; end
+class FalseClass; include Boolean; end
+
+class CLBool < CLValue  
+  include Boolean
+  include CLValueBytesParsers::CLBoolBytesParser
+  def initialize(value)
+    super
+    raise "error" unless value.is_a?(Boolean)
+    @value =  value
+  end
+
+  def get_cl_type
+    @cl_bool_type = CLBoolType.new(true)
+    @cl_bool_type.to_string
+  end
+
+  def get_cl_tag
+    CLBoolType.get_tag
+  end
+
+  def get_value
+    @value  
+  end
+end
+

data/lib/types/cl_bool_type.rb

@@ -0,0 +1,35 @@
+require_relative './cl_type.rb'
+require_relative './constants.rb'
+
+
+class CLBoolType  < CLType
+
+  def initialize(value = nil)  
+    super(value)
+    @value = value
+  end
+
+  def to_string
+    TAGS.key(0).to_s
+  end
+
+  # def get_value 
+  #   @value
+  # end
+
+  def to_json 
+    to_string
+  end
+
+  def self.get_tag
+    TAGS[:Bool]
+  end
+  
+  def get_tag
+    TAGS[:Bool]
+  end
+
+  def to_bytes
+    [0].pack("C*").unpack1("H*")
+  end
+end

data/lib/types/cl_byte_array.rb

@@ -0,0 +1,25 @@
+require_relative './cl_byte_array_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+
+
+class CLByteArray < CLValue  
+  include CLValueBytesParsers::CLByteArrayBytesParser
+ 
+  def initialize(value = nil)
+    super
+    @value =  value
+  end
+
+  def get_cl_type
+    @cl_type = CLByteArrayType.new
+    @cl_type.to_string
+  end
+
+  def get_value
+    @value  
+  end
+
+end
+

data/lib/types/cl_byte_array_type.rb

@@ -0,0 +1,27 @@
+require_relative './cl_type.rb'
+require_relative './constants.rb'
+
+
+class CLByteArrayType < CLType
+  def initialize(value = nil)  
+    super(value)
+    @value = value
+  end
+
+  def to_string
+    TAGS.key(15).to_s
+  end
+
+  def get_value 
+    @value
+  end
+
+  def to_json 
+    to_string
+  end
+
+  def to_bytes
+    [15].pack("C*").unpack1("H*")
+  end
+
+end

data/lib/types/cl_i32.rb

@@ -0,0 +1,26 @@
+require_relative './cl_i32_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+
+
+class CLi32 < CLValue  
+  include CLValueBytesParsers::CLI32BytesParser
+ 
+  def initialize(value)
+    raise "error" unless value.instance_of? Integer
+    super
+    @value =  value
+  end
+
+  def get_cl_type
+    @cl_type = CLI32Type.new
+    @cl_type.to_string
+  end
+
+  def get_value
+    @value  
+  end
+
+end
+

data/lib/types/cl_i32_type.rb

@@ -0,0 +1,26 @@
+require_relative './cl_type.rb'
+require_relative './constants.rb'
+
+
+class CLI32Type < CLType
+  def initialize(value = nil)  
+    super(value)
+    @value = value
+  end
+
+  def to_string
+    TAGS.key(1).to_s
+  end
+
+  def get_value 
+    @value
+  end
+
+  def to_json 
+    to_string
+  end
+
+  def to_bytes
+    [1].pack("C*").unpack1("H*")
+  end
+end

data/lib/types/cl_i64.rb

@@ -0,0 +1,26 @@
+require_relative './cl_i64_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+
+
+class CLi64 < CLValue  
+  include CLValueBytesParsers::CLI64BytesParser
+ 
+  def initialize(value = nil)
+    raise "error"  unless value.instance_of? Integer
+    super
+    @value =  value
+  end
+
+  def get_cl_type
+    @cl_type = CLI64Type.new
+    @cl_type.to_string
+  end
+
+  def get_value
+    @value  
+  end
+
+end
+

data/lib/types/cl_i64_type.rb

@@ -0,0 +1,27 @@
+require_relative './cl_type.rb'
+require_relative './constants.rb'
+
+
+class CLI64Type < CLType
+  def initialize(value = nil)  
+    super(value)
+    @value = value
+  end
+
+  def to_string
+    TAGS.key(2).to_s
+  end
+
+  def get_value 
+    @value
+  end
+
+  def to_json 
+    to_string
+  end
+
+  def to_bytes
+    [2].pack("C*").unpack1("H*")
+  end
+
+end

data/lib/types/cl_key.rb

@@ -0,0 +1,39 @@
+require_relative './cl_key_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+=begin
+Key values serialize as a single byte tag representing the variant, followed by the serialization of the data that variant contains. 
+For most variants, this is simply a fixed-length 32-byte array. 
+The exception is Key::URef, which contains a URef; so its data serializes per the description above. 
+The tags are as follows: Key::Account serializes as 0, Key::Hash as 1, Key::URef as 2.
+=end
+
+
+KEY_TYPE_ACCOUNT = 0
+KEY_TYPE_HASH    = 1
+KEY_TYPE_UREF    = 2
+
+# ACCOUNT_HASH_ID = 'AccountHash'
+ACCOUNT_HASH_LENGTH = 32
+
+# UREF_ID = 'URef'
+
+class CLKey < CLValue  
+  include CLValueBytesParsers::CLKeyBytesParser
+
+  def initialize(value)
+    super
+    @value =  value
+  end
+
+  def get_cl_type
+    @cl_type = CLKeyType.new
+    @cl_type.to_string
+  end
+
+  def get_value
+    @value  
+  end
+
+end
+

data/lib/types/cl_key_type.rb

@@ -0,0 +1,27 @@
+require_relative './cl_type.rb'
+require_relative './constants.rb'
+
+
+class CLKeyType < CLType
+  def initialize(value = nil)  
+    super(value)
+    @value = value
+  end
+
+  def to_string
+    TAGS.key(11).to_s
+  end
+
+  def get_value 
+    @value
+  end
+
+  def to_json 
+    to_string
+  end
+
+  def to_bytes
+    [11].pack("C*").unpack1("H*")
+  end
+
+end