test_sdk1 1.0.3 → 1.1.4

data/lib/serialization/cl_value_serializer_update.rb

@@ -0,0 +1,320 @@
+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 './cl_value_bytes_parsers.rb'
+require_relative '../utils/byte_utils.rb'
+
+# Byte serializer for CLValue
+class CLValueSerializer
+  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
+
+  def to_bytes(clvalue)
+    puts "\nCLValueSerializer:"
+    type = clvalue.get_cl_type
+    value = clvalue.get_value
+    tag = CLType::TAGS[type.to_sym]
+    puts "\n clvalue: "
+    puts "type:\t#{type}"
+    puts "to_bytes(clvalue): #{value}"
+    # puts CLType::TAGS[type.to_sym]
+    puts "tag:\t#{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"
+      puts "\n U512: "
+
+      # puts "value : #{value}"
+      # bytes = Utils::ByteUtils.byte_array_to_hex(to_byte_array(value))
+      # puts bytes
+      # num_of_bytes = bytes.length/2
+      # puts num_of_bytes
+      # puts [num_of_bytes].pack("C*").unpack1("H*")
+      # puts [num_of_bytes+1].pack("L<*").unpack1("H*") + [num_of_bytes].pack("C*").unpack1("H*") + bytes +  [tag].pack("C*").unpack1("H*")
+      # puts "to_byte_array(value):\t #{to_byte_array(value)}"
+      bytes = Utils::ByteUtils.byte_array_to_hex(to_byte_array(value))[0...-2]
+      puts "bytes: #{bytes}"
+      num_of_bytes = bytes.length/2
+      puts "num_of_bytes:\t#{num_of_bytes}"
+      puts "U512: " + [num_of_bytes+1].pack("L<*").unpack1("H*") + [num_of_bytes].pack("C*").unpack1("H*") + bytes +  [tag].pack("C*").unpack1("H*")
+      [num_of_bytes+1].pack("L<*").unpack1("H*") + [num_of_bytes].pack("C*").unpack1("H*") + bytes +  [tag].pack("C*").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*")
+      inner_type = value[:cl_type]
+      bytes = value[:bytes]
+      parsed = value[:parsed]
+      # puts inner_type, bytes, parsed
+      # length = bytes.length/2
+      # inner_value_bytes = bytes[2..]
+      data = { "cl_type": inner_type, "bytes": bytes, "parsed": parsed}
+      # puts length
+      serialize_option_cl_value(data)
+      # "11111111111111111111111"
+    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"
+      puts "?????????????: " + [tag].pack("C*").unpack1("H*")
+      [clvalue.to_hex.length/2].pack("L<*").unpack1("H*") + clvalue.to_hex + [tag].pack("C*").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*")
+      [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"
+      bytes = [value].pack("Q<*").unpack1("H*")
+      bytes = bytes[0, 8]
+      [8].pack("Q<*").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
+
+  def serialize_option_cl_value(data) 
+    cl_type = data[:cl_type]
+    bytes = data[:bytes]
+    parsed = data[:parsed]
+
+    if cl_type == "U64"
+      length = bytes.length/2
+      puts length
+      bytes = bytes[2..]
+      value = Utils::ByteUtils.hex_to_u64_value(bytes)
+      puts value == 1650706686882
+      clvalue = CLu64.new(value)
+      tag = CLType::TAGS[cl_type.to_sym]
+      puts "U64: " + [length].pack("L<*").unpack1("H*") + "01" + bytes + "0d" + [tag].pack("C*").unpack1("H*")
+      [length].pack("L<*").unpack1("H*") + "01" + bytes + "0d" + [tag].pack("C*").unpack1("H*")
+    end
+  end
+end

data/lib/serialization/deploy_header_serializer.rb

@@ -18,6 +18,7 @@ class DeployHeaderSerializer
     @timestamp = deploy_header.get_timestamp
     timestamp_ms = Utils::TimeUtils.to_epoc_ms(@timestamp)
     @serialized_timestamp = Utils::ByteUtils.to_u64(timestamp_ms)
+    # puts "serialized_timestamp: " + @serialized_timestamp
     @serialized_header << @serialized_timestamp
 
     @ttl = deploy_header.get_ttl

data/lib/serialization/deploy_named_arg_serializer.rb

@@ -8,6 +8,7 @@ require_relative './cl_value_serializer.rb'
 class DeployNamedArgSerializer
 
   def to_bytes(arg)
+    # puts arg
     name = arg.get_name
     serialized_name = CLValueBytesParsers::CLStringBytesParser.to_bytes(name)
     clvalue = arg.get_value

data/lib/serialization/deploy_serializer.rb

@@ -3,25 +3,35 @@ 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'
+require_relative '../utils/helpers.rb'
 # Byte serializer for Deploy object
 class DeploySerializer
-
+  include Utils::Helpers
+  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)
+      # module_bytes = Casper::Entity::ModuleBytes.new(module_bytes, args)
       args.each do |arg|
         name1 = arg[0]
         clvalue_hash = arg[1]
@@ -31,6 +41,8 @@ class DeploySerializer
       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 = []
@@ -48,6 +60,7 @@ class DeploySerializer
       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 = []
@@ -64,6 +77,7 @@ class DeploySerializer
       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 = []
@@ -81,6 +95,7 @@ class DeploySerializer
       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 = []
@@ -98,6 +113,7 @@ class DeploySerializer
       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 = []
@@ -113,6 +129,7 @@ class DeploySerializer
       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
 
@@ -120,7 +137,7 @@ class DeploySerializer
       temp_args = []
       module_bytes = session[:ModuleBytes][:module_bytes]
       args = session[:ModuleBytes][:args]
-      module_bytes = Casper::Entity::ModuleBytes.new(module_bytes, args)
+      # module_bytes = Casper::Entity::ModuleBytes.new(module_bytes, args)
       args.each do |arg|
         name1 = arg[0]
         clvalue_hash = arg[1]
@@ -129,6 +146,7 @@ class DeploySerializer
       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 = []
@@ -146,6 +164,7 @@ class DeploySerializer
       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 = []
@@ -162,6 +181,7 @@ class DeploySerializer
       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 = []
@@ -179,6 +199,7 @@ class DeploySerializer
       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 = []
@@ -196,6 +217,7 @@ class DeploySerializer
       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
@@ -203,26 +225,71 @@ class DeploySerializer
       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] # => "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)]
+        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
+          puts "Inner Type = #{value}"
+          # data = { "cl_type": inner_type, "bytes": bytes, "parsed": parsed}
+          # clvalue = CLOption.new(data, inner_type)
+
+          inner_clvalue = Utils::Helpers.construct_inner_clvalue(inner_type, parsed)
+          clvalue = CLOption.new(inner_clvalue, 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
@@ -231,6 +298,8 @@ class DeploySerializer
     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"
@@ -248,6 +317,22 @@ class DeploySerializer
     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 == ""
@@ -260,6 +345,55 @@ class DeploySerializer
     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