test_sdk1 1.0.3 → 1.1.4

data/lib/serialization/deploy_serializer_update.rb

@@ -0,0 +1,397 @@
+require_relative './deploy_header_serializer'
+require_relative './deploy_approval_serializer'
+require_relative './deploy_executable_serializer'
+require_relative './deploy_named_arg_serializer'
+require_relative '../utils/byte_utils.rb'
+require_relative '../types/cl_option.rb'
+# Byte serializer for Deploy object
+class DeploySerializer
+  attr_accessor :payment_session_serializer, :transfer_serializer, :payment_serializer
+  def initialize
+  end
+  
+  def to_bytes(deploy)
+    @payment_session_serializer = ""
+    @amount_serializer = ""
+    @target_serializer = ""
+    @id_serializer = ""
+    @transfer_serializer = ""
+    @payment_serializer = ""
+    result = "" 
+    deploy_header = Casper::Entity::DeployHeader.new(deploy.get_header)
+    result += DeployHeaderSerializer.new().to_bytes(deploy_header)
+    
+    deploy_hash = Casper::Entity::DeployHash.new(deploy.get_hash)
+    result += deploy_hash.get_hash
+    payment = deploy.get_payment
+    session = deploy.get_session
+    if payment.keys[0] == :ModuleBytes 
+      temp_args = []
+      module_bytes = payment[:ModuleBytes][:module_bytes]
+      args = payment[:ModuleBytes][:args]
+      # module_bytes = Casper::Entity::ModuleBytes.new(module_bytes, args)
+      args.each do |arg|
+        name1 = arg[0]
+        clvalue_hash = arg[1]
+        clvalue = build_cl_value(arg[1])
+        # puts clvalue
+        temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+      end
+      temp = Utils::ByteUtils.byte_array_to_hex(Casper::Entity::ModuleBytes.new(module_bytes, temp_args).to_bytes)
+      result += temp
+      @payment_serializer += temp
+      @payment_session_serializer += temp
+      temp = nil
+    elsif payment.keys[0] == :StoredContractByHash
+      temp_args = []
+      hash = payment[:StoredContractByHash][:hash]
+      entry_point = payment[:StoredContractByHash][:entry_point]
+      args = payment[:StoredContractByHash][:args]
+      stored_contract_by_hash = Casper::Entity::StoredContractByHash.new(hash, entry_point, args)
+      
+      args.each do |arg|
+        name1 = arg[0] # => "quantity"
+        clvalue_hash = arg[1] # => {:cl_type=>"I32", :bytes=>"e8030000", :parsed=>1000}
+        clvalue = build_cl_value(arg[1])
+        # puts clvalue
+        temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+      end
+      temp = Utils::ByteUtils.byte_array_to_hex(Casper::Entity::StoredContractByHash.new(name, entry_point, temp_args).to_bytes)
+      result += temp
+      @payment_session_serializer += temp
+      temp = nil
+    elsif payment.keys[0] == :StoredContractByName
+      temp_args = []
+      name = payment[:StoredContractByName][:name]
+      entry_point = payment[:StoredContractByName][:entry_point]
+      args = payment[:StoredContractByName][:args]
+
+      stored_contract_by_name = Casper::Entity::StoredContractByName.new(name, entry_point, args)
+      args.each do |arg|
+        name1 = arg[0] # => "quantity"
+        clvalue_hash = arg[1] # => {:cl_type=>"I32", :bytes=>"e8030000", :parsed=>1000}
+        clvalue = build_cl_value(arg[1])
+        temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+      end
+      temp = Utils::ByteUtils.byte_array_to_hex(Casper::Entity::StoredContractByName.new(name, entry_point, temp_args).to_bytes)
+      result += temp
+      @payment_session_serializer += temp
+      temp = nil
+    elsif payment.keys[0] == :StoredVersionedContractByHash
+      temp_args = []
+      hash = payment[:StoredVersionedContractByHash][:name]
+      version = payment[:StoredVersionedContractByHash][:version]
+      entry_point = payment[:StoredVersionedContractByHash][:entry_point]
+      args = payment[:StoredVersionedContractByHash][:args]
+
+      stored_versioned_contract_by_hash = Casper::Entity::StoredVersionedContractByHash.new(hash, version, entry_point, args)
+      args.each do |arg|
+        name1 = arg[0] 
+        clvalue_hash = arg[1] 
+        clvalue = build_cl_value(arg[1])
+        temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+      end
+      temp = Utils::ByteUtils.byte_array_to_hex(Casper::Entity::StoredVersionedContractByHash.new(name, version,entry_point, temp_args).to_bytes)
+      result += temp
+      @payment_session_serializer += temp
+      temp = nil
+    elsif payment.keys[0] == :StoredVersionedContractByName
+      temp_args = []
+      name = payment[:StoredVersionedContractByName][:name]
+      version = payment[:StoredVersionedContractByName][:version]
+      entry_point = payment[:StoredVersionedContractByName][:entry_point]
+      args = payment[:StoredVersionedContractByName][:args]
+
+      stored_versioned_contract_by_name = Casper::Entity::StoredVersionedContractByName.new(name, version, entry_point, args)
+      args.each do |arg|
+        name1 = arg[0] 
+        clvalue_hash = arg[1] 
+        clvalue = build_cl_value(arg[1])
+        temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+      end
+      temp = Utils::ByteUtils.byte_array_to_hex(Casper::Entity::StoredVersionedContractByName.new(name, version,entry_point, temp_args).to_bytes)
+      result += temp
+      @payment_session_serializer += temp
+      temp = nil
+    elsif payment.keys[0] == :Transfer
+      temp_args = []
+      args = payment[:Transfer][:args]
+
+      transfer = Casper::Entity::DeployExecutableTransfer.new(args)
+      args.each do |arg|
+        name1 = arg[0] # => "amount"
+        clvalue_hash = arg[1] # => {:cl_type=>"I32", :bytes=>"e8030000", :parsed=>1000}
+        clvalue = build_cl_value(arg[1])
+        # puts clvalue
+        temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+      end
+      temp = Utils::ByteUtils.byte_array_to_hex(Casper::Entity::DeployExecutableTransfer.new(temp_args).to_bytes)
+      result += temp
+      @payment_session_serializer += temp
+      temp = nil
+    end
+
+    if session.keys[0] == :ModuleBytes
+      temp_args = []
+      module_bytes = session[:ModuleBytes][:module_bytes]
+      args = session[:ModuleBytes][:args]
+      # module_bytes = Casper::Entity::ModuleBytes.new(module_bytes, args)
+      args.each do |arg|
+        name1 = arg[0]
+        clvalue_hash = arg[1]
+        clvalue = build_cl_value(arg[1])
+        temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+      end
+      temp = Utils::ByteUtils.byte_array_to_hex(Casper::Entity::ModuleBytes.new(module_bytes, temp_args).to_bytes)
+      result += temp
+      @payment_session_serializer += temp
+      temp = nil
+    elsif session.keys[0] == :StoredContractByHash
+      temp_args = []
+      hash = session[:StoredContractByHash][:hash]
+      entry_point = session[:StoredContractByHash][:entry_point]
+      args = session[:StoredContractByHash][:args]
+      stored_contract_by_hash = Casper::Entity::StoredContractByHash.new(hash, entry_point, args)
+      
+      args.each do |arg|
+        name1 = arg[0] # => "quantity"
+        clvalue_hash = arg[1] # => {:cl_type=>"I32", :bytes=>"e8030000", :parsed=>1000}
+        clvalue = build_cl_value(arg[1])
+        # puts clvalue
+        temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+      end
+      temp = Utils::ByteUtils.byte_array_to_hex(Casper::Entity::StoredContractByHash.new(name, entry_point, temp_args).to_bytes)
+      result += temp
+      @payment_session_serializer += temp
+      temp = nil
+    elsif session.keys[0] == :StoredContractByName
+      temp_args = []
+      name = session[:StoredContractByName][:name]
+      entry_point = session[:StoredContractByName][:entry_point]
+      args = session[:StoredContractByName][:args]
+
+      stored_contract_by_name = Casper::Entity::StoredContractByName.new(name, entry_point, args)
+      args.each do |arg|
+        name1 = arg[0] # => "quantity"
+        clvalue_hash = arg[1] # => {:cl_type=>"I32", :bytes=>"e8030000", :parsed=>1000}
+        clvalue = build_cl_value(arg[1])
+        temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+      end
+      temp = Utils::ByteUtils.byte_array_to_hex(Casper::Entity::StoredContractByName.new(name, entry_point, temp_args).to_bytes)
+      result += temp
+      @payment_session_serializer += temp
+      temp = nil
+    elsif session.keys[0] == :StoredVersionedContractByHash
+      temp_args = []
+      hash = session[:StoredVersionedContractByHash][:name]
+      version = session[:StoredVersionedContractByHash][:version]
+      entry_point = session[:StoredVersionedContractByHash][:entry_point]
+      args = session[:StoredVersionedContractByHash][:args]
+
+      stored_versioned_contract_by_hash = Casper::Entity::StoredVersionedContractByHash.new(hash, version, entry_point, args)
+      args.each do |arg|
+        name1 = arg[0] 
+        clvalue_hash = arg[1] 
+        clvalue = build_cl_value(arg[1])
+        temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+      end
+      temp = Utils::ByteUtils.byte_array_to_hex(Casper::Entity::StoredVersionedContractByHash.new(name, version,entry_point, temp_args).to_bytes)
+      result += temp
+      @payment_session_serializer += temp
+      temp = nil
+    elsif session.keys[0] == :StoredVersionedContractByName
+      temp_args = []
+      name = session[:StoredVersionedContractByName][:name]
+      version = session[:StoredVersionedContractByName][:version]
+      entry_point = session[:StoredVersionedContractByName][:entry_point]
+      args = session[:StoredVersionedContractByName][:args]
+
+      stored_versioned_contract_by_name = Casper::Entity::StoredVersionedContractByName.new(name, version, entry_point, args)
+      args.each do |arg|
+        name1 = arg[0] 
+        clvalue_hash = arg[1] 
+        clvalue = build_cl_value(arg[1])
+        temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+      end
+      temp = Utils::ByteUtils.byte_array_to_hex(Casper::Entity::StoredVersionedContractByName.new(name, version,entry_point, temp_args).to_bytes)
+      result += temp
+      @payment_session_serializer += temp
+      temp = nil
+
+    elsif session.keys[0] == :Transfer
+      temp_args = []
+      args = session[:Transfer][:args]
+
+      transfer = Casper::Entity::DeployExecutableTransfer.new(args)
+      # args.each do |arg|
+      #   name1 = arg[0] # => "amount"
+      #   clvalue_hash = arg[1] # => {:cl_type=>"I32", :bytes=>"e8030000", :parsed=>1000}
+      #   clvalue = build_cl_value(arg[1])
+      #   # puts clvalue
+      #   temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+      # end
+
+      args.each do |arg|
+        name1 = arg[0]
+        if name1 == "amount" || name1 == "target"
+          clvalue_hash = arg[1]
+          clvalue = build_cl_value(arg[1])
+          # puts "clvalue.get_value: #{clvalue.get_value}"
+          temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+        elsif name1 == "id"
+          bytes = arg[1][:bytes]
+          parsed = arg[1][:parsed]
+          h = arg[1][:cl_type]
+          key, value = h.first
+          cl_type = h.keys[0]
+          # puts key, value
+          inner_type = value
+          data = { "cl_type": inner_type, "bytes": bytes, "parsed": parsed}
+          clvalue = CLOption.new(data, inner_type)
+              # type = clvalue.get_cl_type
+              # puts type
+              # value = clvalue.get_value
+              # puts value
+              # tag = CLType::TAGS[type.to_sym]
+              # puts tag
+          # cl_value = { "cl_type": cl_type, "bytes": bytes, "parsed": parsed}
+          # clvalue = build_cl_value(cloption)
+          # puts cloption.get_value
+          temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+        end
+      end
+      temp = Utils::ByteUtils.byte_array_to_hex(Casper::Entity::DeployExecutableTransfer.new(temp_args).to_bytes)
+      @target_serializer = temp
+      # puts @target_serializer
+      result += temp
+      @transfer_serializer += temp
+      @payment_session_serializer += temp
+      temp = nil
+    end
+
+    approvals =  deploy.get_approvals
+    num_of_approvals = approvals.size
+    # puts "num_of_approvals: #{num_of_approvals}"
+    approval_serializer = ""
+    deploy_approval_serializer = DeployApprovalSerializer.new
+    result += Utils::ByteUtils.to_u32(num_of_approvals)
+    approval_serializer += Utils::ByteUtils.to_u32(num_of_approvals)
+    # @payment_session_serializer += Utils::ByteUtils.to_u32(num_of_approvals)
+    for approval in approvals
+      deploy_approval = Casper::Entity::DeployApproval.new(approval)
+      # @payment_session_serializer += deploy_approval_serializer.to_bytes(deploy_approval)
+      result += deploy_approval_serializer.to_bytes(deploy_approval)
+      approval_serializer += deploy_approval_serializer.to_bytes(deploy_approval)
+    end
+    # puts "approval_serializer: #{approval_serializer}"
+    # result
+    Utils::ByteUtils.hex_to_byte_array(result)
+  end
+
+  def build_cl_value(h = {})
+    cl_type = h[:cl_type]
+    bytes = h[:bytes]
+    parsed = h[:parsed]
+    # puts "h[:bytes] = #{h[:bytes]}"
+    # puts "h[:parsed] = #{h[:parsed]}"
+    if cl_type == "Bool"
+      CLValueBytesParsers::CLBoolBytesParser.from_bytes([bytes])
+    elsif cl_type == "I32"
+      value = Utils::ByteUtils.hex_to_integer(bytes)
+      CLi32.new(value)
+    elsif cl_type == "I64"
+      value = Utils::ByteUtils.hex_to_i64_value(bytes)
+      CLi64.new(value)
+    elsif cl_type == "U8"
+      value = Utils::ByteUtils.hex_to_u8_value(bytes)
+      CLu8.new(value)
+    elsif cl_type == "U32"
+      value = Utils::ByteUtils.hex_to_u32_value(bytes)
+      CLu32.new(value)
+    elsif cl_type == "U64"
+      value = Utils::ByteUtils.hex_to_u64_value(bytes)
+      CLu32.new(value)
+    elsif cl_type == "U512"
+      bytes = h[:bytes] # => 0400f90295
+      # puts "bytes:\t#{bytes}"
+      num_of_bytes = bytes[0..1] # => 04
+      bytes = bytes[2..] # => "00f90295"
+      # puts "bytes[2..]:\t#{bytes}"
+      value = [bytes].pack("H*").unpack("L*").first
+      # puts "value:\t#{value}"
+      # CLu512.new(value)
+      # puts "parsed:\t#{parsed}"
+      # puts "parsed.to_i: #{parsed.to_i}"
+      CLu512.new(parsed.to_i)
+      # value = Utils::ByteUtils.hex_to_u64_value(bytes)
+      # CLu512.new(value)
+      # value = Utils::ByteUtils.hex_to_u512_value(bytes)
+      # CLu512.new(value)
+    elsif cl_type == "Unit"
+      # value = CLValueBytesParsers::CLUnitBytesParser.from_bytes(bytes)
+      if bytes == ""
+        value = nil
+        CLUnit.new(value)
+      end
+    elsif cl_type == "String"
+      value = CLValueBytesParsers::CLStringBytesParser.from_bytes(bytes)
+      CLString.new(value)
+    elsif cl_type == "URef"
+      value = Utils::ByteUtils.hex_to_byte_array(bytes)
+      CLValueBytesParsers::CLURefBytesParser.from_bytes(value)
+    # elsif cl_type = "Option"
+
+    elsif cl_type == "PublicKey"
+      CLPublicKey.from_hex(bytes)
+    end
+  end
+
+  def build_cl_value_with_option(h = {})
+    cl_type = h[:cl_type]
+    bytes = h[:bytes]
+    # puts bytes
+    parsed = h[:parsed]
+    if cl_type == "Bool"
+      CLValueBytesParsers::CLBoolBytesParser.from_bytes([bytes])
+    elsif cl_type == "I32"
+      value = Utils::ByteUtils.hex_to_integer(bytes)
+      CLi32.new(value)
+    elsif cl_type == "I64"
+      value = Utils::ByteUtils.hex_to_i64_value(bytes)
+      CLi64.new(value)
+    elsif cl_type == "U8"
+      value = Utils::ByteUtils.hex_to_u8_value(bytes)
+      CLu8.new(value)
+    elsif cl_type == "U32"
+      value = Utils::ByteUtils.hex_to_u32_value(bytes)
+      CLu32.new(value)
+    elsif cl_type == "U64"
+      value = Utils::ByteUtils.hex_to_u64_value(bytes)
+      CLu32.new(value)
+    elsif cl_type == "U512"
+      value = Utils::ByteUtils.hex_to_u64_value(bytes)
+      # puts "value:\t#{value}"
+      CLu512.new(value)
+      # value = Utils::ByteUtils.hex_to_u512_value(bytes)
+      # CLu512.new(value)
+    elsif cl_type == "Unit"
+      # value = CLValueBytesParsers::CLUnitBytesParser.from_bytes(bytes)
+      if bytes == ""
+        value = nil
+        CLUnit.new(value)
+      end
+    elsif cl_type == "String"
+      value = CLValueBytesParsers::CLStringBytesParser.from_bytes(bytes)
+      CLString.new(value)
+    elsif cl_type == "URef"
+      value = Utils::ByteUtils.hex_to_byte_array(bytes)
+      CLValueBytesParsers::CLURefBytesParser.from_bytes(value)
+    # elsif cl_type = "Option"
+
+    elsif cl_type == "PublicKey"
+      CLPublicKey.from_hex(bytes)
+    end
+
+
+  end
+end

data/lib/serialization/test.rb

@@ -98,7 +98,7 @@ clvalue = CLTuple3.new([u32_2, str, u32_2])
 
 clvalue = CLOption.new(CLBool.new(false))
 
-# puts clvalue.get_cl_type
+puts clvalue.get_cl_type
 
 temp = CLType.new(false)
 # p temp.get_cl_type_tag(:Bool)
@@ -120,7 +120,17 @@ cl_opt = CLOption.new(CLBool.new(true))
 # serializer = CLValueSerializer.new
 # puts serializer.to_bytes(cloption1)
 
-
+deploy_serializer = DeploySerializer.new
+h =   {
+  "bytes": "0179df0d8648700000",
+  "parsed": 123456789012345,
+  "cl_type": {
+    "Option": "U64"
+  }
+}
+h.deep_symbolize_keys!
+cl_value = deploy_serializer.build_cl_value(h)
+puts cl_value
 # *************************** CLValueSerializer::End *****************************************************#
 
 
@@ -372,9 +382,9 @@ deploy_bytes_array = deploy_serializer.to_bytes(deploy)
 deploy_hex = Utils::ByteUtils.byte_array_to_hex(deploy_bytes_array)
 # puts Blake2b.hex(deploy_hex)
 
-input = "abc"
-key = Blake2b::Key.none
-out_len = 32
+# input = "abc"
+# key = Blake2b::Key.none
+# out_len = 32
 
 # puts Blake2b.hex(input)
 # puts Blake2b.hex(input, key)
@@ -389,7 +399,6 @@ out_len = 32
 key = "01ccee19366eaf03487cb81197ae8edcb1b47f214cee00d6597380096b9f8463c1"
 
 
-# puts Blake2b.hex(deploy_hex)
 require 'openssl'
 
 # k = OpenSSL::PKey::RSA.new(File.read("/home/mehmet/Documents/ed25519_secret_key.pem"))
@@ -397,10 +406,20 @@ require 'openssl'
 require "ssh_data"
 require "ed25519"
 
-key_data = File.read("#{Dir.home}/.ssh/id_ed25519")
-key = SSHData::PrivateKey.parse_openssh(key_data)
-#=> <SSHData::PrivateKey::ED25519>
-# puts key[0][0]
+path =  File.join(
+    File.dirname(File.dirname(File.absolute_path(__FILE__))),
+    'crypto/ed25519_secret_key.pem'
+)
+# puts path
+# file = File.open(path)
+# puts file
+# file_data = file.readlines.map(&:chomp)
+# puts file_data
+
+# key_data = File.read(path)
+# key = SSHData::PrivateKey.parse_openssh(key_data)
+# #=> <SSHData::PrivateKey::ED25519>
+# puts key[0]
 SSHData::PrivateKey::ED25519.generate
 #=> raises SSHData::AlgorithmError
 
@@ -417,15 +436,16 @@ SSHData::PrivateKey::ED25519.generate
 # puts file_data
 # puts "/home/mehmet/Document/hetzner.txt"
 # puts "#{Dir.home}"
+# puts File.dirname(File.dirname(File.absolute_path(__FILE__)))
 require 'json'
 path = File.join(
     File.dirname(File.dirname(File.absolute_path(__FILE__))),
     'serialization/ed25519.pem'
 )
-puts path
+# puts path
 
 file = File.open(path)
-puts file
+# puts file
 file_data = file.readlines.map(&:chomp)
-puts file_data.inspect
+# puts file_data.inspect
 file.close

data/lib/test_sdk1.rb

@@ -10,11 +10,13 @@ require 'net/http'
 # require "./rpc/rpc.rb"
 require_relative './rpc/rpc_error.rb'
 require_relative './rpc/rpc_client.rb'
-
+require_relative './serialization/deploy_serializer.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'
+require_relative './crypto/ed25519_key.rb'
+require_relative './crypto/asymmetric_key.rb'
 module Casper
    # Interacting with the network
   class CasperClient 
@@ -141,6 +143,8 @@ module Casper
         status = Timeout::timeout(10) {
           client = Jimson::Client.new(@url)
           @node_status = client.info_get_status
+          @node_status.deep_symbolize_keys!
+          Casper::Entity::Status.new(@node_status)
         }
       rescue
         @rpc_error = Casper::RpcError::ErrorHandle.new
@@ -176,7 +180,8 @@ module Casper
           if (!@block_info.empty?() && @block_info["hash"] != block_hash)
             raise("Returned block does not have a matching hash.")
           else
-            @block_info
+            @block_info.deep_symbolize_keys!
+            Casper::Entity::Block.new(@block_info[:hash], @block_info[:header], @block_info[:body], @block_info[:proofs])
           end
         }
       rescue
@@ -196,7 +201,8 @@ module Casper
         if @era_summary == nil
           Casper::RpcError::InvalidParameter.error
         else
-          @era_summary
+          @era_summary.deep_symbolize_keys!
+          Casper::Entity::EraSummary.new(@era_summary)
         end
         }
       rescue
@@ -217,7 +223,8 @@ module Casper
             "path" => path
           })
           @stored_value = response["stored_value"]
-          @stored_value
+          @stored_value.deep_symbolize_keys!
+          Casper::Entity::StoredValue.new(@stored_value)
         }
       rescue
         Casper::RpcError::InvalidParameter.error
@@ -236,7 +243,10 @@ module Casper
             "dictionary_identifier" => {'URef' => 
               {'seed_uref' => uref, 'dictionary_item_key' => item_key} }})
             @stored_value = response["stored_value"]
-            @stored_value
+            @stored_value.deep_symbolize_keys!
+            # cl_type = @stored_value[:CLValue][:cl_type]
+            # bytes = @stored_value[:CLValue][:bytes]
+            DeploySerializer.new().build_cl_value(@stored_value[:CLValue])
         }
       rescue
         Casper::RpcError::InvalidParameter.error
@@ -263,13 +273,18 @@ module Casper
 
     # Returns current auction system contract information.
     # @return [Hash] auction_state
-    def state_get_AuctionInfo
+    def state_get_AuctionInfo(block_hash = "")
       begin 
         state = Timeout::timeout(50) {
         client = Jimson::Client.new(@url)
         response = client.state_get_auction_info
         @auction_state = response['auction_state']
-        @auction_state
+        @auction_state.deep_symbolize_keys!
+        state_root_hash = @auction_state[:state_root_hash]
+        block_height = @auction_state[:block_height]
+        era_validators = @auction_state[:era_validators]
+        bids = @auction_state[:bids]
+        Casper::Entity::AuctionState.new(state_root_hash, block_height, era_validators, bids)
         }
       rescue
         @rpc_error = Casper::RpcError::ErrorHandle.new
@@ -277,10 +292,14 @@ module Casper
       end
     end
     
+    # @param [Deploy] deploy
     def put_deploy(deploy)
-      client = Jimson::Client.new(url)
-      response = client.account_put_deploy(deploy)
-      response['deploy_hash']
+      client = Jimson::Client.new(@url)
+      # response = client.account_put_deploy(deploy)
+      # response['deploy_hash']
+      response = client.account_put_deploy({
+        "deploy" => deploy
+      })
     end
   
   end

data/lib/types/cl_option.rb

@@ -18,6 +18,7 @@ class CLOption < CLValue
     elsif data == nil && inner_type != nil
       @inner_type = inner_type
     else
+      # @inner_type = data[:cl_type]
       @inner_type = data.get_cl_type
     end
   end
@@ -27,7 +28,12 @@ class CLOption < CLValue
   end
 
   def get_cl_type
-   CLOptionType.new(@inner_type)
-   @inner_type
+   CLOptionType.new(@inner_type).get_type
+   # @inner_type
+   # get_type
+  end
+
+  def get_inner_type
+   @inner_type 
   end
 end

data/lib/types/cl_public_key.rb

@@ -34,6 +34,8 @@ class CLPublicKey < CLValue
   # @param [Integer] tag
   def initialize(raw_public_key, tag)
     super()
+    @tag = tag
+    @raw_public_key = raw_public_key
     raw_public_key_length_valid?(raw_public_key, tag)
   end
 

data/lib/types/cl_value.rb

@@ -8,4 +8,12 @@ class CLValue
     @cl_type = cl_type
     @parsed = parsed
   end
+
+  def to_hash(bytes, value, type)
+    {
+      "bytes": bytes,
+      "parsed": value,
+      "cl_type": type
+    }
+  end
 end

data/lib/utils/byte_utils.rb

@@ -27,6 +27,11 @@ module Utils
       # byte_array.pack("C*").unpack1("H*")
       byte_array.pack("C*").unpack("H*").first
     end
+   
+    def byte_array_to_hex_64(byte_array)
+      # byte_array.pack("C*").unpack1("H*")
+      byte_array.pack("C*").unpack("H*").first
+    end
 
     # @param [String] str
     # @return [Array]
@@ -74,6 +79,15 @@ module Utils
     # @param [Integer] n
     # @return [String]
     def to_u64(n)
+      # bytes = Utils::ByteUtils.byte_array_to_hex(to_byte_array(n)) + "0000"
+      # puts "bytes: #{bytes}"
+      # puts "bytes_conversion: #{[bytes].pack("H*").unpack("C*")}"
+      [n].pack("Q<*").unpack("H*").first
+    end
+
+    # @param [Integer] n
+    # @return [String]
+    def to_u512(n)
       [n].pack("Q<*").unpack("H*").first
     end
 
@@ -103,5 +117,19 @@ module Utils
     def hex_to_u64_value(hex_str)
       [hex_str].pack("H*").unpack("Q*").first
     end
+    def hex_to_u512_value(hex_str)
+      [hex_str].pack("H*").unpack("Q*").first
+    end
+
+    # @return byte array containing two's complement representation of Bignum/Fixnum
+    def to_byte_array(num)
+      result = []
+      begin
+        result << (num & 0xff)
+        num >>= 8
+      end until (num == 0 || num == -1) && (result.last[7] == num[7])
+      # result.reverse
+      result
+    end
   end
 end