casper_network 1.0.1 → 1.1.2

data/lib/entity/status.rb

@@ -0,0 +1,80 @@
+module Casper
+  module Entity
+    class Status
+      # @param [Hash] status
+      # @option status [String] :api_version
+      # @option status [String] :chainspec_name
+      # @option status [String] :starting_state_root_hash
+      # @option status [Array<Hash>] :peers
+      # @option status [Hash] :last_added_block_info
+      # @option status [String] :our_public_signing_key
+      # @option status [Integer] :round_length 
+      # @option status [String] :next_upgrade
+      # @option status [String] :build_version
+      # @option status [String] :uptime
+      def initialize(status = {})
+        @api_version = status[:api_version] 
+        @chainspec_name = status[:chainspec_name] 
+        @starting_state_root_hash = status[:starting_state_root_hash] 
+        @peers = []
+        status[:peers].map { |peer| @peers << Casper::Entity::Peer.new(peer)}
+        @last_added_block_info = status[:last_added_block_info]
+        @our_public_signing_key = status[:our_public_signing_key]
+        @round_length = status[:round_length]
+        @next_upgrade = status[:next_upgrade]
+        @build_version = status[:build_version]
+        @uptime = status[:uptime]
+      end
+
+      # @return [String] the RPC API version.
+      def get_api_version
+        @api_version
+      end
+
+      # @return [String] the chainspec name.
+      def get_chainspec_name
+        @chainspec_name
+      end
+
+      # @return [String] the state root hash used at the start of the current sessio
+      def get_starting_state_root_hash
+        @starting_state_root_hash
+      end
+
+      # @return [Array<Peer>] the node ID and network address of each connected peer.
+      def get_peers
+        @peers
+      end
+
+      # @return [Hash] the minimal info of the last block from the linear chain.
+      def get_last_added_block_info
+        @last_added_block_info
+      end
+
+      # @return [String] Our public signing key.
+      def get_our_public_signing_key
+        @our_public_signing_key
+      end
+
+      # @return [Integer] the next round length if this node is a validator.
+      def get_round_length
+        @round_length
+      end
+
+      # @return [String] information about the next scheduled upgrade.
+      def get_next_upgrade
+        @next_upgrade
+      end
+
+      # @return [String] the compiled node version.
+      def get_build_version
+        @build_version
+      end
+
+      # @return [String] the time that passed since the node has started.
+      def get_uptime
+        @uptime
+      end
+    end
+  end
+end

data/lib/entity/stored_value.rb

@@ -1,57 +1,132 @@
+
 module Casper
   module Entity
 
     # A class that represents a value stored in global state.
     class StoredValue
 
-      def initialize(cl_value, account, contract, contract_package, transfer, deploy_info, era_info, bid, withdraw)
-        @cl_value = cl_value
-        @account = account
-        @contract = contract
-        @contract_package = contract_package 
-        @transfer = transfer
-        @deploy_info = deploy_info
-        @era_info = era_info
-        @bid = bid
-        @withdraw = withdraw
+      # @param [Hash] stored_value
+      # @option stored_value [CLValue] :CLValue
+      # @option stored_value [Account] :Account
+      # @option stored_value [String] :ContractWasm
+      # @option stored_value [Contract] :Contract
+      # @option stored_value [ContractPackage] :ContractPackage
+      # @option stored_value [Transfer] :Transfer 
+      # @option stored_value [DeployInfo] :DeployInfo 
+      # @option stored_value [EraInfo] :EraInfo 
+      # @option stored_value [Bid] :Bid
+      # @option stored_value [Array] :Withdraw 
+      def initialize(stored_value = {})
+        @stored_value = stored_value
+        @cl_value = nil
+        @account = nil
+        @contract_wasm = nil
+        @contract = nil
+        @contract_package = nil
+        @transfer = nil
+        @deploy_info = nil
+        @era_info = nil
+        @bid = nil
+        @withdraw = nil
+        @key = nil
+        if stored_value.has_key?(:CLValue)
+          @cl_value = stored_value[:CLValue]
+          @key = :CLValue
+        end
+        if stored_value.has_key?(:Account)
+          @account = stored_value[:Account]
+          @key = :Account
+        end
+        if stored_value.has_key?(:ContractWasm)
+          @contract_wasm = stored_value[:ContractWasm]
+          @key = :ContractWasm
+        end
+        if stored_value.has_key?(:Contract)
+          @contract = stored_value[:Contract]
+          @key = :Contract
+        end
+        if stored_value.has_key?(:ContractPackage)
+          @contract_package = stored_value[:ContractPackage]
+          @key = :ContractPackage
+        end
+        if stored_value.has_key?(:Transfer)
+          @transfer = stored_value[:Transfer]
+          @key = :Transfer
+        end
+        if stored_value.has_key?(:DeployInfo)
+          @transfer = stored_value[:DeployInfo]
+          @key = :Deploy
+        end
+        if stored_value.has_key?(:EraInfo)
+          @era_info = stored_value[:EraInfo]
+          @key = :EraInfo
+        end
+        if stored_value.has_key?(:Bid)
+          @bid = stored_value[:Bid]
+          @key = :Bid
+        end
+        if stored_value.has_key?(:Withdraw)
+          @withdraw = stored_value[:Withdraw]
+          @key = :Withdraw
+        end
       end
 
+      # @return [CLValue] a CasperLabs value.
       def get_cl_value
         @cl_value
       end
 
+      # @return [Account] an account.
       def get_account
         @account
       end
 
+      # @return [String] a contract’s Wasm
       def get_contract
         @contract
       end
-
+      
+      # @return [Contract] methods and type signatures supported by a contract.
+      def get_contract
+        @contract
+      end
+      #  @return [ContractPackage] contract definition, metadata, and security container.
       def get_contract_package
         @contract_package
       end
 
+      # @return [Transfer] record of a transfer
       def get_transfer
         @transfer
       end
 
+      # @return [DeployInfo] record of a deploy
       def get_deploy_info
         @deploy_info
       end
 
+      # @return [EraInfo] auction metadata
       def get_era_info
         @era_info
       end
 
+      # @return [Bid] a bid
       def get_bid
         @bid
       end
 
+      # @return [Array] a withdraw
       def get_withdraw
         @withdraw
       end
 
+      def get_stored_value
+        @stored_value[@key]
+      end
+
+      def get_key
+        @key
+      end
     end
   end
 end

data/lib/entity/transfer.rb

@@ -23,32 +23,32 @@ module Casper
         @id = transfer[:id]
       end
 
-      # @return [String] deploy_hash
+      # @return [String] deploy that created the transfer
       def get_deploy_hash
         @deploy_hash
       end
 
-      # @return [String] from
+      # @return [String] account from which transfer was executed
       def get_from
         @from
       end
 
-      # @return [String] to
+      # @return [String] account to which funds are transferred
       def get_to
         @to
       end
 
-      # @return [String] source
+      # @return [String] tource purse
       def get_source
         @source
       end
 
-      # @return [String] target
+      # @return [String] target purse
       def get_target
         @target
       end
 
-      # @return [String] amount
+      # @return [String] transfer amount
       def get_amount
         @amount
       end
@@ -57,7 +57,7 @@ module Casper
       def get_gas
         @gas
       end
-      # @return [Integer] id
+      # @return [Integer] user-defined id
       def get_id
         @id
       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