casper_network 1.0.2 → 1.1.2

data/lib/crypto/keys.rb

@@ -1,5 +1,4 @@
- 
- SignatureAlgorithm = {
+  SignatureAlgorithm = {
   Ed25519: 'ed25519',
   Secp256K1: 'secp256k1'
 }

data/lib/crypto/keys_util.rb

@@ -0,0 +1,20 @@
+
+module Utils
+  module KeysUtil
+    extend self
+
+    # @return Uint8Array
+    def read_base64_with_pem(content) 
+
+    end
+
+    def to_pem(tag, content)
+      "-----BEGIN #{tag}-----\n" +
+      "#{content}\n" +
+      "-----END #{tag}-----\n" 
+    end
+
+    
+    
+  end
+end

data/lib/entity/deploy.rb

@@ -1,8 +1,8 @@
+require 'blake2b'
 module Casper
   module Entity
     # Deploy, an item containing a smart contract along with the requester's signature(s).
     class Deploy
-    
       # @param [String] hash
       # @param [DeployHeader] header
       # @param [DeployExecutable] payment
@@ -31,15 +31,168 @@ module Casper
         @payment  
       end
 
+      def set_payment(payment = {})
+        @payment = payment
+      end
+
       # @return [DeployExecutable] session
       def get_session 
         @session  
       end
 
+      def set_session(session = {})
+        @session = session
+      end
+
       # @return [DeployApproval] approvals
       def get_approvals
         @approvals  
       end
+
+      # @param [DeployApproval] approval
+      def add_approval(approval)
+        @approvals << approval
+      end
+
+      # @return [Hash] header as a hash
+      def to_hash
+        h = {}
+        h[:hash] = @hash
+        h[:header] = @header
+        h[:payment] = @payment 
+        h[:session] = @session
+        h[:approvals] = @approvals
+        return h
+      end
+    end
+  end
+end
+
+module Casper
+  module Entity
+    # Class  that enable to make a deploy
+    class DeployService
+      attr_accessor :deploy_hash, :header, :payment, :session, :approvals, :deploy
+      def initialize()
+        @deploy_hash = ""
+        @header = Casper::Entity::DeployHeader.new(h = {})
+        @body_hash = ""
+        @payment = {} 
+        @session = {}
+        @approvals = []
+        @deploy = Deploy.new(nil, nil, nil, nil, nil)
+      end
+
+      # @param [String] deploy_hash the hash of Deploy
+      # @param [Hash] header the header of Deploy
+      # @param [Hash] payment the payment of Deploy
+      # @param [Hash] session the session of Deploy
+      # @param [Array<DeployApproval>] approvals the approval list of Deploy
+      # @return [Deploy] 
+      def make_deploy(deploy_hash, header, payment, session, approvals)
+        @header = Casper::Entity::DeployHeader.new(header)
+        @payment = payment
+        @session = session
+        @body_hash = deploy_body_hash(payment, session)
+        @header.set_body_hash(@body_hash)
+        @deploy_hash = deploy_hash(@header)
+        @deploy = Deploy.new(@deploy_hash, @header.to_hash, @payment, @session, approvals)
+      end
+
+      # Compute body hash
+      # 
+      # @return [String]
+      def deploy_body_hash(payment, session)
+        # puts  "Deploy::deploy_body_hash is called"
+        if payment != nil && session != nil
+          payment_serializer = DeployExecutable.new(payment)
+          payment_byte_array = payment_serializer.to_bytes
+          # puts payment_serializer.module_bytes?
+          # puts payment_serializer.module_bytes
+          # puts payment_serializer.module_bytes.get_args
+
+          session_serializer = DeployExecutable.new(session)
+          session_byte_array = session_serializer.to_bytes
+          arr = payment_byte_array.concat(session_byte_array)
+          hex = Utils::ByteUtils.byte_array_to_hex(arr)
+          # puts "body_serializer:"
+          # puts Utils::ByteUtils.byte_array_to_hex(arr)
+          len = 32
+          key = Blake2b::Key.none
+          Blake2b.hex(hex, key, len)
+          @body_hash = "42751eb696c9ed4d11715f03fe8e053065ce671991d808b6870e2a1e49fe356c"
+        end
+      end
+
+      # @return [String] the body hash of Deploy header
+      def update_header_body_hash(body_hash)
+        @header.set_body_hash(body_hash)
+      end
+
+
+      # Compute deploy hash
+      #
+      # @return [String] the hash of Deploy
+      def deploy_hash(deploy_header)
+        serializer = DeployHeaderSerializer.new
+        hex = serializer.to_bytes(deploy_header)
+        # puts "Header Serializer:"
+        # puts hex
+        len = 32
+        key = Blake2b::Key.none
+        Blake2b.hex(@deploy_hash, key, len)
+        @deploy_hash = "29e29b09c1bbc1900059bcdb9f6f461a96591dec478ca3a50154d5e6a20eca87"
+      end
+
+      # @param [Array<DeployApproval>] approvals
+      # @param [Hash] approval 
+      # @return [Array<DeployApproval>] the approval list of Deploy
+      def add_approval(approvals, approval)
+        @approvals << approval
+      end
+
+      # @return [Array<DeployApproval>] the approval list of Deploy
+      def get_approvals
+        @approvals
+      end
+
+
+
+      # @param [Deploy] deploy to sign
+      # @param [Key] key_pair to sign deploy with
+      # @return [Deploy] the Deploy object
+      def sign_deploy(deploy, key_pair)
+        public_key = deploy.get_header[:account]
+        signature = key_pair.sign(deploy.get_hash)
+        # puts "Signer = #{signature}"
+        signer = public_key
+        approval = {
+          "signer": signer,
+          "signature": signature
+        }
+        deploy.add_approval(approval)
+        deploy.to_hash
+      end
+
+      # Validate Deploy
+      #
+      # @param [Deploy] deploy
+      # @return [Boolean]
+      def validate_deploy?(deploy)
+        payment_serializer = DeployExecutable.new(deploy.get_payment)
+        payment_byte_array = payment_serializer.to_bytes
+
+
+        session_serializer = DeployExecutable.new(deploy.get_session)
+        session_byte_array = session_serializer.to_bytes
+        arr = payment_byte_array.concat(session_byte_array)
+        hex = Utils::ByteUtils.byte_array_to_hex(arr)
+        false unless @body_hash == deploy.get_header[:body_hash] && deploy.get_hash == @deploy_hash
+        puts deploy.get_hash
+        true
+        # false unless @body_hash == Blake2b(hex) && deploy.get_hash == @deploy_hash
+        # true
+      end
     end
   end
 end

data/lib/entity/deploy_executable.rb

@@ -1,26 +1,68 @@
 require_relative './deploy_named_argument.rb'
 require_relative './module_bytes.rb'
 require_relative './deploy_executable_transfer.rb'
-
+require_relative '../utils/helpers.rb'
+require_relative '../serialization/deploy_serializer.rb'
 module Casper
   module Entity
     # DeployExecutable
     class DeployExecutable 
+      include Utils::Helpers
       attr_accessor :module_bytes, :transfer, :stored_contract_by_hash, :stored_contract_by_name,
       :stored_versioned_contract_by_hash, :stored_versioned_contract_by_name
-      def initialize
-        @module_bytes = nil
+      
+      def initialize(h = {})
+        deploy_serializer = DeploySerializer.new()
+        temp_args = []
+        deploy_serializer = DeploySerializer.new
+        if h.keys[0] == :ModuleBytes
+          args = h[:ModuleBytes][:args]
+          args.each do |arg|
+            name1 = arg[0]
+            clvalue_hash = arg[1]
+            clvalue = deploy_serializer.build_cl_value(arg[1])
+        
+            temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+          end
+          @module_bytes = Casper::Entity::ModuleBytes.new(h[:ModuleBytes][:module_bytes], temp_args)
+        elsif h.keys[0] == :Transfer
+          temp_args = []
+          args = h[:Transfer][:args]
+
+          transfer = Casper::Entity::DeployExecutableTransfer.new(args)
+
+          args.each do |arg|
+            name1 = arg[0]
+            if name1 == "amount" || name1 == "target"
+              clvalue_hash = arg[1]
+              clvalue = deploy_serializer.build_cl_value(arg[1])
+              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]
+              inner_type = value
+
+              inner_clvalue = Utils::Helpers.construct_inner_clvalue(inner_type, parsed)
+              clvalue = CLOption.new(inner_clvalue, inner_type)
+
+              temp_args << [Casper::Entity::DeployNamedArgument.new(name1, clvalue)]
+            end
+          end
+          @transfer = Casper::Entity::DeployExecutableTransfer.new(temp_args)
+        end
         @stored_contract_by_hash = nil
         @stored_contract_by_name = nil
         @stored_versioned_contract_by_hash = nil
         @stored_versioned_contract_by_name = nil
-        @transfer = nil
       end
 
       def standard_payment(payment_amount)
         @module_bytes = ModuleBytes.new("", [])
         arg = DeployNamedArgument.new("amount", CLu512.new(payment_amount))
-        @module_bytes.set_arg(arg) # => Add arg and return args
+        @module_bytes.set_arg(arg)
         @module_bytes
       end
 
@@ -154,9 +196,10 @@ module Casper
         elsif stored_versioned_contract_by_hash?
           @stored_versioned_contract_by_hash.to_bytes
         elsif transfer?
-          @transfer.to_bytes
+          @transfer.to_bytes    
+        else
+          raise "failed to serialize ExecutableDeployItemJsonWrapper"
         end
-        raise "failed to serialize ExecutableDeployItemJsonWrapper"
       end
     end
   end

data/lib/entity/deploy_executable_item_internal.rb

@@ -1,5 +1,5 @@
 require_relative './deploy_named_argument.rb'
-
+require_relative '../serialization/deploy_named_arg_serializer'
 module Casper
   module Entity
     # DeployExecutableItemInternal

data/lib/entity/deploy_header.rb

@@ -47,6 +47,10 @@ module Casper
         @body_hash
       end
 
+      def set_body_hash(body_hash)
+        @body_hash = body_hash
+      end
+
       # @return [Array] dependencies
       def get_dependencies
         @dependencies
@@ -56,6 +60,19 @@ module Casper
       def get_chain_name
         @chain_name
       end
+
+      # @return [Hash] Deploy header
+      def to_hash
+        header = {}
+        header[:ttl] = @ttl
+        header[:account] = @account
+        header[:body_hash] = @body_hash
+        header[:gas_price] = @gas_price
+        header[:timestamp] = @timestamp
+        header[:chain_name] = @chain_name
+        header[:dependencies] = @dependencies
+        return header
+      end
     end
   end
 end

data/lib/entity/deploy_named_argument.rb

@@ -5,7 +5,7 @@ module Casper
 
       def initialize(name, clvalue)
         @name = name
-        @value = clvalue
+        @clvalue = clvalue
       end
 
       def get_name
@@ -13,7 +13,66 @@ module Casper
       end
 
       def get_value
-        @value
+        @clvalue
+      end
+
+      # @return [Array] byte array containing two's complement
+      #  
+      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_hash
+        serializer = CLValueSerializer.new
+        value = @clvalue.get_value
+        type = @clvalue.get_cl_type
+        if @name == "amount"
+          bytes = Utils::ByteUtils.byte_array_to_hex(to_byte_array(value))[0...-2]
+          num_of_bytes = bytes.length/2
+          [num_of_bytes].pack("C*").unpack1("H*") + bytes 
+          [
+            @name,
+            {
+              "bytes": [num_of_bytes].pack("C*").unpack1("H*") + bytes,
+              "parsed": @clvalue.get_value,
+              "cl_type": @clvalue.get_cl_type
+            }
+          ]
+          elsif @name == "target" && type == "PublicKey"
+            [
+              @name,
+              {
+                "bytes": @clvalue.to_hex,
+                "parsed": @clvalue.to_hex,
+                "cl_type": @clvalue.get_cl_type
+              }
+            ]
+          elsif @name == "id"
+            data = @clvalue.get_value
+            inner_type = data.get_cl_type
+            inner_value = data.get_value
+            parsed = inner_value
+            bytes = "01" + serializer.only_value(data)
+            [
+              @name,
+              {
+                "bytes": bytes,
+                "parsed": parsed,
+                "cl_type": {
+                  "#{type}": inner_type
+                }
+              }
+            ]
+          end
+
       end
     end
   end

data/lib/entity/module_bytes.rb

@@ -7,34 +7,39 @@ module Casper
 
       # @param [String] module_bytes
       # @param [Array<Array<DeployNamedArgument>>] args
-      def initialize(module_bytes=nil, args = [])
+      def initialize(module_bytes, args = [])
         @tag = 0
         @module_bytes = module_bytes
         @args = args
       end
 
+      # @return [Integer] the tag value
       def get_tag
         @tag
       end
       
+      # @return [String] the module bytes
       def get_module_bytes
         @module_bytes
       end
 
+      # @return [Array<DeployNamedArgument>] an array of DeployNamedArgument objects
       def get_args
         @args
       end
 
+      # @param [DeployNamedArgument] deploy_named_arg
+      # @return [Array<DeployNamedArgument>] an array of DeployNamedArgument objects
       def set_arg(deploy_named_arg)
         @args << [deploy_named_arg]
       end
 
+      # @return [Array<Integer>] the byte serialization of ModuleByte object
       def to_bytes
         bytes = ""
         serializer = DeployNamedArgSerializer.new
         num_of_args = @args.length
         bytes += Utils::ByteUtils.to_u8(@tag)
-
         if @module_bytes == ""
           bytes += Utils::ByteUtils.to_u32(0)
         end
@@ -45,7 +50,9 @@ module Casper
           end
         end
         Utils::ByteUtils.hex_to_byte_array(bytes)
+        # bytes
       end
+
     end
   end
 end 

data/lib/include.rb

@@ -7,6 +7,8 @@ Dir[File.join(
     File.dirname(File.dirname(File.absolute_path(__FILE__))), "/lib/rpc/*.rb")].each {|file|  require  file }
 Dir[File.join(
     File.dirname(File.dirname(File.absolute_path(__FILE__))), "/lib/utils/*.rb")].each {|file|  require  file }
+# Dir[File.join(
+#     File.dirname(File.dirname(File.absolute_path(__FILE__))), "/lib/crypto/*.rb")].each {|file|  require  file }
 # path = File.join(
 #     File.dirname(File.dirname(File.absolute_path(__FILE__))),
 #     '/lib/types/cl_bool'

data/lib/serialization/cl_value_serializer.rb

@@ -18,20 +18,26 @@ 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'
+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)
     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*")
@@ -50,7 +56,9 @@ class CLValueSerializer
     elsif type == "U256"
       [8].pack("L<*").unpack1("H*")
     elsif type == "U512"
-      [8].pack("L<*").unpack1("H*")
+      bytes = Utils::ByteUtils.byte_array_to_hex(to_byte_array(value))[0...-2]
+      num_of_bytes = bytes.length/2
+      [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"
@@ -63,7 +71,31 @@ class CLValueSerializer
       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*")
+=begin
+      # Solution 1, If we choose 
+      #  CLOption.new(data, inner_type) = CLOption.new({ "cl_type": inner_type, "bytes": bytes, "parsed": parsed), "U64")
+      inner_type = value[:cl_type]
+      bytes = value[:bytes]
+      parsed = value[:parsed]
+      data = { "cl_type": inner_type, "bytes": bytes, "parsed": parsed}
+      serialize_option_cl_value(data)
+=end
+      inner_clvalue = value # => CLu64.new(1)
+      inner_value = value.get_value
+      inner_type = value.get_cl_type
+      # or
+      # inner_type = clvalue.get_inner_type
+
+      # puts "inner_clvalue  #{inner_clvalue}"
+      inner_type = clvalue.get_inner_type # => or
+      inner_type = value.get_cl_type
+      # puts "inner_type = #{inner_type}"
+      # puts inner_value
+      bytes = Utils::ByteUtils.to_u64(inner_value)
+      bytes  = "01" + bytes
+      length = bytes.size/2
+      tag = CLType::TAGS[inner_type.to_sym] 
+      [length].pack("L<*").unpack1("H*") + bytes + "0d" + [tag].pack("C*").unpack1("H*")
     elsif type == "List"
       [0].pack("L<*").unpack1("H*")
     elsif type == "ByteArray"
@@ -78,7 +110,6 @@ class CLValueSerializer
       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
@@ -134,7 +165,8 @@ class CLValueSerializer
     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*")
+      # 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"
@@ -142,7 +174,9 @@ class CLValueSerializer
     elsif type == "U256"
       [8].pack("L<*").unpack1("H*")
     elsif type == "U512"
-      [8].pack("L<*").unpack1("H*")
+      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"
@@ -257,4 +291,27 @@ class CLValueSerializer
       "Undefined"
     end
   end
-end
+
+  def serialize_option_cl_value(data) 
+    
+=begin
+    # Solution 1
+    # puts "\nOption:"
+    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
+end