test_sdk1 1.0.0

data/lib/serialization/cl_value_serializer.rb

@@ -0,0 +1,259 @@
+require_relative '../types/cl_type.rb'
+require_relative '../types/cl_bool.rb'
+require_relative '../types/cl_i32.rb'
+require_relative '../types/cl_i64.rb'
+require_relative '../types/cl_u8.rb'
+require_relative '../types/cl_u32.rb'
+require_relative '../types/cl_u64.rb'
+require_relative '../types/cl_u128.rb'
+require_relative '../types/cl_u256.rb'
+require_relative '../types/cl_u512.rb'
+require_relative '../types/cl_unit.rb'
+require_relative '../types/cl_tuple.rb'
+require_relative '../types/cl_uref.rb'
+require_relative '../types/cl_option.rb'
+require_relative '../types/cl_string.rb'
+# require_relative '../types/cl_key.rb'
+require_relative '../types/cl_uref.rb'
+require_relative '../types/cl_tuple.rb'
+require_relative '../types/cl_public_key.rb'
+require_relative '../types/constants.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+class CLValueSerializer
+
+  def to_bytes(clvalue)
+    type = clvalue.get_cl_type
+    value = clvalue.get_value
+    tag = CLType::TAGS[type.to_sym]
+    # puts type
+    # puts value
+    # puts CLType::TAGS[type.to_sym]
+    # puts tag
+    [1].pack("L<*").unpack1("H*")
+    serialized = ""
+    if type == "Bool"
+      [1].pack("L<*").unpack1("H*") + [value.to_i].pack("C*").unpack1("H*") + [tag].pack("C*").unpack1("H*")
+    elsif type == "I32"
+      [4].pack("L<*").unpack1("H*") + [value].pack("l<*").unpack1("H*") + [tag].pack("C*").unpack1("H*")
+    elsif type == "I64"
+      [8].pack("L<*").unpack1("H*") + [value].pack("q<*").unpack1("H*") + [tag].pack("C*").unpack1("H*")
+    elsif type == "U8"
+      [1].pack("L<*").unpack1("H*") + [value].pack("C*").unpack1("H*") + [tag].pack("C*").unpack1("H*")
+    elsif type == "U32"
+      serialized += [4].pack("L<*").unpack1("H*") + [value].pack("L<*").unpack1("H*") + [tag].pack("C*").unpack1("H*")
+    elsif type == "U64"
+      [8].pack("L<*").unpack1("H*") + [value].pack("Q<*").unpack1("H*") + [tag].pack("C*").unpack1("H*")
+    elsif type == "U128"
+      [8].pack("L<*").unpack1("H*")
+    elsif type == "U256"
+      [8].pack("L<*").unpack1("H*")
+    elsif type == "U512"
+      [8].pack("L<*").unpack1("H*")
+    elsif type == "Unit"
+      [0].pack("L<*").unpack1("H*") + [tag].pack("C*").unpack1("H*")
+    elsif type == "String"
+      length = CLValueBytesParsers::CLStringBytesParser.to_bytes(value).length
+      [length/2].pack("L<*").unpack1("H*") + CLValueBytesParsers::CLStringBytesParser.to_bytes(value) + [tag].pack("C*").unpack1("H*")
+    elsif type == "Key"
+      [11].pack("C*").unpack1("H*")
+    elsif type == "URef"
+      uref = clvalue.get_value
+      size = clvalue.to_bytes(uref).length/2
+      [size].pack("L<*").unpack1("H*") + clvalue.to_bytes(uref) + [tag].pack("C*").unpack1("H*")
+    elsif type == "Option"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "List"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "ByteArray"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "Result"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "Map"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "Tuple1"
+      clvalue1 = clvalue.get_value[0]
+      type1 = clvalue1.get_cl_type
+      value1 = clvalue1.get_value
+      tag1 = CLType::TAGS[type1.to_sym]
+      serialized +=  helper(clvalue.get_value[0]) + [tag].pack("C*").unpack1("H*") + [tag1].pack("C*").unpack1("H*")
+      # [18].pack("C*").unpack1("H*") + cl_type.get_data[0].to_bytes
+    elsif type == "Tuple2"
+      clvalue1 = clvalue.get_value[0]
+      type1 = clvalue1.get_cl_type
+      value1 = clvalue1.get_value
+      tag1 = CLType::TAGS[type1.to_sym]
+      
+      clvalue2 = clvalue.get_value[1]
+      type2 = clvalue2.get_cl_type
+      value2 = clvalue2.get_value
+      tag2 = CLType::TAGS[type2.to_sym]
+      
+      len = only_length(clvalue.get_value[0]) + only_length(clvalue.get_value[1]) 
+      [len].pack("L<*").unpack1("H*") +  only_value(clvalue.get_value[0]) + only_value(clvalue.get_value[1]) +
+      [tag].pack("C*").unpack1("H*") + [tag1].pack("C*").unpack1("H*") + [tag2].pack("C*").unpack1("H*")
+    elsif type == "Tuple3"
+      clvalue1 = clvalue.get_value[0]
+      type1 = clvalue1.get_cl_type
+      value1 = clvalue1.get_value
+      tag1 = CLType::TAGS[type1.to_sym]
+      
+      clvalue2 = clvalue.get_value[1]
+      type2 = clvalue2.get_cl_type
+      value2 = clvalue2.get_value
+      tag2 = CLType::TAGS[type2.to_sym]      
+     
+      clvalue3 = clvalue.get_value[2]
+      type3 = clvalue3.get_cl_type
+      value3 = clvalue3.get_value
+      tag3 = CLType::TAGS[type3.to_sym]
+      
+      len = only_length(clvalue.get_value[0]) + only_length(clvalue.get_value[1]) + only_length(clvalue.get_value[2])  
+      [len].pack("L<*").unpack1("H*") +  only_value(clvalue.get_value[0]) + only_value(clvalue.get_value[1]) +  only_value(clvalue.get_value[2]) +
+      [tag].pack("C*").unpack1("H*") + [tag1].pack("C*").unpack1("H*") + [tag2].pack("C*").unpack1("H*") + [tag3].pack("C*").unpack1("H*")
+    elsif type == "Any"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "PublicKey"
+      [clvalue.to_hex.length/2].pack("L<*").unpack1("H*") + clvalue.to_hex + [tag].pack("C*").unpack1("H*")
+    else
+      "Undefined"
+    end
+  end
+
+  def helper(clvalue)
+    type = clvalue.get_cl_type
+    value = clvalue.get_value
+    serialized = ""
+    if type == "Bool"
+      [1].pack("L<*").unpack1("H*") + [value.to_i].pack("C*").unpack1("H*")
+    elsif type == "I32"
+      [4].pack("L<*").unpack1("H*") + [value].pack("l<*").unpack1("H*")
+    elsif type == "I64"
+      [8].pack("L<*").unpack1("H*") + [value].pack("q<*").unpack1("H*")
+    elsif type == "U8"
+      [1].pack("L<*").unpack1("H*") + [value].pack("C*").unpack1("H*")
+    elsif type == "U32"
+      serialized += [4].pack("L<*").unpack1("H*") + [value].pack("L<*").unpack1("H*")
+    elsif type == "U64"
+      [8].pack("L<*").unpack1("H*") + [value].pack("Q<*").unpack1("H*")
+    elsif type == "U128"
+      [8].pack("L<*").unpack1("H*")
+    elsif type == "U256"
+      [8].pack("L<*").unpack1("H*")
+    elsif type == "U512"
+      [8].pack("L<*").unpack1("H*")
+    elsif type == "Unit"
+      [9].pack("C*").unpack1("H*")
+    elsif type == "String"
+      length = CLValueBytesParsers::CLStringBytesParser.to_bytes(value).length
+      [length/2].pack("L<*").unpack1("H*") + CLValueBytesParsers::CLStringBytesParser.to_bytes(value)
+    elsif type == "Key"
+      [11].pack("C*").unpack1("H*")
+    elsif type == "URef"
+      uref = clvalue.get_value
+      size = clvalue.to_bytes(uref).length/2
+      [size].pack("L<*").unpack1("H*") + clvalue.to_bytes(uref)
+    elsif type == "Option"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "List"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "ByteArray"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "Result"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "Map"
+      [0].pack("L<*").unpack1("H*")
+    else
+      "Undefined"
+    end
+  end
+
+  def only_length(clvalue)
+    type = clvalue.get_cl_type
+    value = clvalue.get_value
+    if type == "Bool"
+      1
+    elsif type == "I32"
+      4
+    elsif type == "I64"
+      8
+    elsif type == "U8"
+      1
+    elsif type == "U32"
+      4
+    elsif type == "U64"
+      8
+    elsif type == "U128"
+      8
+    elsif type == "U256"
+      8
+    elsif type == "U512"
+      8
+    elsif type == "Unit"
+      8
+    elsif type == "String"
+      4 + value.length
+    elsif type == "Key"
+      32
+    elsif type == "URef"
+      uref = clvalue.get_value
+      size = clvalue.to_bytes(uref).length/2
+    elsif type == "Option"
+      8
+    elsif type == "List"
+      8
+    elsif type == "ByteArray"
+      8
+    elsif type == "Result"
+      8
+    elsif type == "Map"
+      8
+    else
+      0
+    end
+  end
+  def only_value(clvalue)
+    type = clvalue.get_cl_type
+    value = clvalue.get_value
+    if type == "Bool"
+      [value.to_i].pack("C*").unpack1("H*")
+    elsif type == "I32"
+      [value].pack("l<*").unpack1("H*")
+    elsif type == "I64"
+      [value].pack("q<*").unpack1("H*")
+    elsif type == "U8"
+      [value].pack("C*").unpack1("H*")
+    elsif type == "U32"
+      [value].pack("L<*").unpack1("H*")
+    elsif type == "U64"
+      [value].pack("Q<*").unpack1("H*")
+    elsif type == "U128"
+      [value].pack("Q<*").unpack1("H*")
+    elsif type == "U256"
+      [value].pack("Q<*").unpack1("H*")
+    elsif type == "U512"
+      [value].pack("Q<*").unpack1("H*")
+    elsif type == "Unit"
+      [value].pack("C*").unpack1("H*")
+    elsif type == "String"
+      CLValueBytesParsers::CLStringBytesParser.to_bytes(value)
+    elsif type == "Key"
+      [value].pack("C*").unpack1("H*")
+    elsif type == "URef"
+      uref = clvalue.get_value
+      clvalue.to_bytes(uref)
+    elsif type == "Option"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "List"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "ByteArray"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "Result"
+      [0].pack("L<*").unpack1("H*")
+    elsif type == "Map"
+      [0].pack("L<*").unpack1("H*")
+    else
+      "Undefined"
+    end
+  end
+end

data/lib/serialization/deploy_approval_serializer.rb

@@ -0,0 +1,15 @@
+require_relative '../entity/deploy_approval.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+require_relative '../utils/time_utils.rb'
+require_relative '../utils/byte_utils.rb'
+
+class DeployApprovalSerializer
+  def to_bytes(deploy_approval)
+    @approval_serializer = ""
+    @signer = deploy_approval.get_signer
+    @approval_serializer << @signer
+    
+    @signature = deploy_approval.get_signature
+    @approval_serializer << @signature
+  end
+end

data/lib/serialization/deploy_executable_serializer.rb

@@ -0,0 +1,27 @@
+require_relative '../entity/deploy_executable.rb'
+
+
+class DeployExecutableSerializer
+
+  def initialize 
+    @deploy_executable = Casper::Entity::DeployExecutable.new
+  end
+
+  # @param [DeployExecutable] deploy_executable
+  def to_bytes(deploy_executable)
+    if deploy_executable.module_bytes?
+      deploy_executable.get_module_bytes.to_bytes
+    elsif deploy_executable.stored_contract_by_hash?
+      deploy_executable.stored_contract_by_hash.to_bytes
+    elsif deploy_executable.stored_contract_by_name?
+      deploy_executable.stored_contract_by_name.to_bytes
+    elsif deploy_executable.stored_versioned_contract_by_hash?
+      deploy_executable.stored_versioned_contract_by_hash.to_bytes
+    elsif deploy_executable.stored_versioned_contract_by_name?
+      deploy_executable.stored_versioned_contract_by_name.to_bytes
+    elsif deploy_executable.transfer?
+      deploy_executable.transfer.to_bytes
+    end
+  end
+  
+end

data/lib/serialization/deploy_header_serializer.rb

@@ -0,0 +1,49 @@
+require_relative '../entity/deploy_header.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+require_relative '../utils/time_utils.rb'
+require_relative '../utils/byte_utils.rb'
+
+
+class DeployHeaderSerializer 
+
+  # @param [DeployerHeader] deploy_header
+  # @return [String] serialized_header
+  def to_bytes(deploy_header)
+    @serialized_header = ""
+
+    @account = deploy_header.get_account
+    @serialized_account = @account
+    @serialized_header << @serialized_account
+
+    @timestamp = deploy_header.get_timestamp
+    timestamp_ms = Utils::TimeUtils.to_epoc_ms(@timestamp)
+    @serialized_timestamp = Utils::ByteUtils.to_u64(timestamp_ms)
+    @serialized_header << @serialized_timestamp
+
+    @ttl = deploy_header.get_ttl
+    ttl_ms = Utils::TimeUtils.ttl_to_milliseconds(@ttl)
+    @serialized_ttl = Utils::ByteUtils.to_u64(ttl_ms)
+    @serialized_header << @serialized_ttl
+    
+    @gas_price = deploy_header.get_gas_price
+    @serialized_gas_price = Utils::ByteUtils.to_u64(@gas_price)
+    @serialized_header << @serialized_gas_price
+
+    @body_hash = deploy_header.get_body_hash
+    @serialized_body_hash = @body_hash
+    @serialized_header << @serialized_body_hash
+
+    @dependencies = deploy_header.get_dependencies
+    @serialized_dependencies = Utils::ByteUtils.to_u32(@dependencies.size) + @dependencies.join("")
+    @serialized_header << @serialized_dependencies
+
+    # @chain_name = CLString.new(deploy_header.get_chain_name)
+    # @serialized_chain_name = @chain_name.to_bytes(deploy_header.get_chain_name)
+    @chain_name = deploy_header.get_chain_name
+    @serialized_chain_name = CLValueBytesParsers::CLStringBytesParser.to_bytes(@chain_name)
+
+    @serialized_header << @serialized_chain_name
+    @serialized_header
+  end
+end
+

data/lib/serialization/deploy_named_arg_serializer.rb

@@ -0,0 +1,19 @@
+require_relative '../entity/deploy_named_argument.rb'
+require_relative '../utils/find_byte_parser_by_cl_type.rb'
+require_relative '../utils/byte_utils.rb'
+require_relative './cl_type_serializer.rb'
+require_relative './cl_value_serializer.rb'
+
+class DeployNamedArgSerializer
+
+  def to_bytes(arg)
+    name = arg.get_name
+    serialized_name = CLValueBytesParsers::CLStringBytesParser.to_bytes(name)
+    clvalue = arg.get_value
+    type = clvalue.get_cl_type
+    
+    serializer = CLValueSerializer.new
+    serialized_value = serializer.to_bytes(clvalue)
+    serialized_name + serialized_value
+  end
+end

data/lib/serialization/deploy_serializer.rb

@@ -0,0 +1,268 @@
+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'
+
+class DeploySerializer
+
+  def to_bytes(deploy)
+    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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      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
+      temp = Utils::ByteUtils.byte_array_to_hex(Casper::Entity::DeployExecutableTransfer.new(temp_args).to_bytes)
+      result += temp
+      temp = nil
+    end
+
+    approvals =  deploy.get_approvals
+    num_of_approvals = approvals.size
+    deploy_approval_serializer = DeployApprovalSerializer.new
+    result += Utils::ByteUtils.to_u32(num_of_approvals)
+    for approval in approvals
+      deploy_approval = Casper::Entity::DeployApproval.new(approval)
+      result += deploy_approval_serializer.to_bytes(deploy_approval)
+    end
+    # 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]
+    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 == "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 == "PublicKey"
+      CLPublicKey.from_hex(bytes)
+    end
+
+
+  end
+end