casper_network 1.0.1 → 1.1.2

data/lib/casper_network.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,19 @@ 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 +293,12 @@ 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" => deploy
+      })
     end
   
   end

data/lib/crypto/asymmetric_key.rb

@@ -3,15 +3,15 @@ require_relative '../types/cl_public_key.rb'
 require_relative '../utils/hex_utils.rb'
 require_relative '../utils/hash_utils.rb'
 
-CLPublicKeyTag = {
-  ED25519: 1,
-  SECP256K1: 2
-}
+# CLPublicKeyTag = {
+#   ED25519: 1,
+#   SECP256K1: 2
+# }
 
-SignatureAlgorithm = {
-  Ed25519: 'ed25519',
-  Secp256K1: 'secp256k1'
-}
+# SignatureAlgorithm = {
+#   Ed25519: 'ed25519',
+#   Secp256K1: 'secp256k1'
+# }
 
 class AsymmetricKey
   attr_reader :public_key, :private_key, :signature_algorithm
@@ -19,7 +19,8 @@ class AsymmetricKey
   # @param [CLPublicKey] public_key
   # @param [Array] private_key
   # @param [SignatureAlgorithm] signature_algorithm
-  def initialize(public_key, private_key, signature_algorithm)
+  def initialize(public_key = CLPublicKey.new([204, 238, 25, 54, 110, 175, 3, 72, 124, 184, 17, 151, 174, 142, 220, 
+  177, 180, 127, 33, 76, 238, 0, 214, 89, 115, 128, 9, 107, 159, 132, 99, 193], 1), private_key = nil, signature_algorithm = nil)
     @public_key = public_key
     @private_key = private_key
     @signature_algorithm = signature_algorithm
@@ -49,15 +50,15 @@ class AsymmetricKey
   end
 
   # @return [Array<Integer>] 
-  def account_hash
-    @tag = @public_key.get_cl_public_key_tag
-    key_name = CLPublicKeyTag.key(@tag).to_s
-    prefix = key_name.downcase.unpack("C*") + [0]
-    bytes = prefix + @public_key.get_value
-    result_array = Utils::HashUtils.byte_hash(bytes)
-    @public_key.get_value.length == 0 ? [] : result_array
-    #*** @public_key.to_account_hash_byte_array
-  end
+  # def account_hash
+  #   @tag = @public_key.get_cl_public_key_tag
+  #   key_name = CLPublicKeyTag.key(@tag).to_s
+  #   prefix = key_name.downcase.unpack("C*") + [0]
+  #   bytes = prefix + @public_key.get_value
+  #   result_array = Utils::HashUtils.byte_hash(bytes)
+  #   @public_key.get_value.length == 0 ? [] : result_array
+  #   #*** @public_key.to_account_hash_byte_array
+  # end
  
   # @param [String] path_to_private_key
   def create_from_private_key_file(path_to_private_key)

data/lib/crypto/ed25519.rb

@@ -0,0 +1,114 @@
+require 'ed25519'
+require 'blake2b'
+require 'chilkat'
+signing_key = Ed25519::SigningKey.generate
+# puts "signing_key:\t #{signing_key}" 
+# puts "seed:\t #{signing_key.seed}" 
+# puts "keypair:\t #{signing_key.keypair}" 
+# puts "verify_key:\t #{signing_key.verify_key}"
+# serialized_deploy_to_hash = "dc7edd3dde249343bc379564724b3e30116d8d84702a589513728f2e09bcd167"
+# signature = Ed25519.provider.sign("MC4CAQAwBQYDK2VwBCIEIKf7pd4LhteUsRPmagsm7by7YWZVM+thD/fWoP+QDZO7", serialized_deploy_to_hash)
+
+# key = Blake2b::Key.none
+# signature =  "01" + Blake2b.hex(signature, key, 64)
+# puts signature
+# message = "hello"
+# signature = signing_key.sign(message)
+# puts "signature:\t #{signature}"
+
+# verify_key = signing_key.verify_key
+# puts "verify_key:\t #{verify_key}"
+
+# check_validity_of_signature = verify_key.verify(signature, message)
+# puts "check_validity_of_signature:\t #{check_validity_of_signature}"
+
+# # Serializing Keys
+# signature_key_bytes = signing_key.to_bytes
+# puts "signature_key_bytes:\t #{signature_key_bytes}"
+# verify_key_bytes = verify_key.to_bytes
+# puts "verify_key_bytes:\t #{verify_key_bytes}"
+
+# signing_key = Ed25519::SigningKey.new(signature_key_bytes)
+# puts "signing_key:\t #{signing_key}"
+# verify_key  = Ed25519::VerifyKey.new(verify_key_bytes)
+# puts "verify_key:\t #{verify_key}
+
+
+#************************************************************************************************************
+
+
+# Load an Ed25519 key
+privKey = Chilkat::CkPrivateKey.new()
+
+# Load an Ed25519 key from an unencrypted PEM file (no password required).
+success = privKey.LoadAnyFormatFile("#{Dir.home}/Downloads/ed25519_secret_key.pem","")
+if (success == false)
+    print privKey.lastErrorText() + "\n";
+    exit
+end
+
+# The key type should be "ed25519" to indicate an Ed25519 key.
+print "key type = " + privKey.keyType() + "\n";
+# key type = ed25519
+
+# # What is the size of the private key in bits?  (should always be 256 bits for Ed25519)
+print "size in bits = " + privKey.get_BitLength().to_s() + "\n";
+# size in bits = 256
+
+# # Get the private and public key parts in raw hex format:
+sbPubKeyHex = Chilkat::CkStringBuilder.new()
+privKeyHex = privKey.getRawHex(sbPubKeyHex)
+
+# # We should have a 32-byte private key (a 64 character hex string).
+print "private key = " + privKeyHex + "\n";
+# private key = a7fba5de0b86d794b113e66a0b26edbcbb61665533eb610ff7d6a0ff900d93bb
+
+# # We should have a 32-byte public key (a 64 character hex string).
+print "public key = " + sbPubKeyHex.getAsString() + "\n";
+# public key = ccee19366eaf03487cb81197ae8edcb1b47f214cee00d6597380096b9f8463c1
+
+
+
+# This example assumes the Chilkat API to have been previously unlocked.
+# See Global Unlock Sample for sample code.
+
+privKeyHex = "a7fba5de0b86d794b113e66a0b26edbcbb61665533eb610ff7d6a0ff900d93bb"
+pubKeyHex = "ccee19366eaf03487cb81197ae8edcb1b47f214cee00d6597380096b9f8463c1"
+
+privKey = Chilkat::CkPrivateKey.new()
+# This example shows only one way of loading an Ed25519 private key.
+# Chilkat can load other formats (JWK, PEM, ASN.1 DER, etc.)  
+# You may do so by calling LoadAnyFormat or LoadAnyFormatFile.
+success = privKey.LoadEd25519(privKeyHex,pubKeyHex)
+if (success == false)
+    print privKey.lastErrorText() + "\n";
+    exit
+end
+
+# The data to be signed...
+bd = Chilkat::CkBinData.new()
+deploy_hash = "633435d9660122917fd5b4de16b7f495959cd832b9ef293486c6893dc694ec26"
+bd.AppendString(deploy_hash,"utf-8")
+eddsa = Chilkat::CkEdDSA.new()
+hexSig = eddsa.signBdENC(bd,"hexlower",privKey)
+
+print "signature = " + "01" + hexSig + "\n";
+
+# The expected output is: 016d49ac6138e556c9174c9c8e0d512bbb4697bbe3e96a28d8c1be83ea05c3a5945b6b87e4c974ae04e6cbcbac78bbbce672648444e269bdf30d27686fa03a440e
+
+# # Verify the signature..
+pubKey = Chilkat::CkPublicKey.new()
+success = pubKey.LoadEd25519(pubKeyHex)
+if (success == false)
+    print pubKey.lastErrorText() + "\n";
+    exit
+end
+puts pubKey
+bVerified = eddsa.VerifyBdENC(bd,hexSig,"hexlower",pubKey)
+if (bVerified == false)
+    print eddsa.lastErrorText() + "\n";
+    print "Failed to verify the signature." + "\n";
+    exit
+end
+
+print "The Ed25519 signature is verified!" + "\n";

data/lib/crypto/ed25519_key.rb

@@ -1,23 +1,129 @@
 require 'openssl'
 require 'ed25519'
-require_relative './asymmetric_key.rb'
+require 'blake2b'
+require 'chilkat'
+
+# CLPublicKeyTag = {
+#   ED25519: 1,
+#   SECP256K1: 2
+# }
 
 # ED25519 private key length in bytes
 PRIVATE_KEY_LENGTH = 32
 
-class Ed25519Key < AsymmetricKey
+class Ed25519Key
+  # attr_reader :public_key, :private_key, :signature_algorithm
+  attr_accessor :public_key_hex, :signature_algorithm, :privKey, :private_key_hex
+  # attr_reader :private_key_hex, :privKey
+  include Utils::HashUtils
+
+  def initialize()
+    # file_path = "#{Dir.home}/ed25519_secret_key.pem"
+    @file_path = "#{Dir.home}/ed25519_secret_key.pem"
+    @privKey = Chilkat::CkPrivateKey.new()
+
+    # This loads an Ed25519 key from an unencrypted PEM file (no password required).
+    success = @privKey.LoadAnyFormatFile(@file_path,"")
+    if (success == false)
+      print @privKey.lastErrorText() + "\n";
+      exit
+    end
+
+    @signature_algorithm = @privKey.keyType()
+
+    # 32-byte (256-bit)
+    @private_key_bit_length = @privKey.get_BitLength
+
+    # Get the private and public key parts in raw hex format
+    sbPubKeyHex = Chilkat::CkStringBuilder.new()
+
+    @private_key_hex = @privKey.getRawHex(sbPubKeyHex)
+    
+    @public_key_hex = sbPubKeyHex.getAsString()
+
+    success = @privKey.LoadEd25519(@private_key_hex, @public_key_hex)
+    if (success == false)
+        print @privKey.lastErrorText() + "\n";
+        exit
+    end
+  end
+
+  def get_public_key
+    raise ArgumentError, "Expected a 64 character hex String" unless @public_key_hex.length == 64
+    return "01" + @public_key_hex
+  end
+
+  def get_private_key
+    raise ArgumentError, "Expected a 64 character hex String" unless @private_key_hex.length == 64
+    return @private_key_hex
+  end
+
+  # @return [String] an encoded string, as specified by the encoding argument.
+  def get_private_key_base_encoded_format(encoding)
+    # encoding can be "base64" 
+    privKey.getPkcs1ENC(encoding)
+  end
+
+  def sign(message)
+    success = @privKey.LoadEd25519(@private_key_hex, @public_key_hex)
+    if (success == false)
+        print @privKey.lastErrorText() + "\n";
+        exit
+    end
+    @message = message
+    # @message = Utils::ByteUtils.hex_to_byte_array(@message)
+
+
+    byteData = Chilkat::CkByteData.new()
+    byteData.appendEncoded(@message, "hex");
+
+    @bd = Chilkat::CkBinData.new()
+    @bd.AppendBinary(byteData)
+    
+    @signer = Chilkat::CkEdDSA.new()
+    @signature = @signer.signBdENC(@bd, "hexlower", @privKey)
+    if @signature_algorithm == "ed25519"
+      @prefix = "0#{CLPublicKeyTag[:ED25519]}"
+      @signature = @prefix + @signature 
+    end
+     @signature
+  end
+
+  # Verify the signature
+  def verify(signature, message)
+    pubKey = Chilkat::CkPublicKey.new()
+    success = pubKey.LoadEd25519(@public_key_hex)
+    if (success == false)
+        print pubKey.lastErrorText() + "\n";
+        exit
+    end
+    # Remove prefix "01"
+    signature = signature[2...]
+    verified = @signer.VerifyBdENC(@bd, signature, "hex", pubKey);
+    if (verified == false)
+        print @signer.lastErrorText() + "\n";
+        print "Failed to verify the signature." + "\n";
+        exit
+    end
+    return true
 
-  def initialize(public_key, private_key)
-    super(public_key, private_key, SignatureAlgorithm[:Ed25519])
   end
 
+  def public_key
+    if @signature_algorithm == "ed25519" && @private_key_hex.length == 64
+      prefix = "01"
+      @public_key = prefix + @public_key_hex
+    end
+  end
+
+
   # @param [Array] public_key
   # @return [String]
   # def self.account_hex(public_key)
   #   '01' + Utils::Base16.encode16(public_key)
   # end
 
-
+  # @param [String] private_key_path
   def create_from_private_key_file(private_key_path)
 
   end
@@ -28,11 +134,6 @@ class Ed25519Key < AsymmetricKey
   def export_private_key_in_pem
   end
 
-  def sign(msg)
-  end
-
-  def verify(signature, msg)
-  end
 
   def private_to_public_key(private_key)
   end

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/auction_state.rb

@@ -4,33 +4,81 @@ module Casper
     class AuctionState
       # @param [String] state_root_hash
       # @param [Integer] block_height
-      # @param [Array] era_validators
-      # @param [Array]  bids
+      # @param [Array<Hash>] era_validators
+      # @option era_validators [Integer] :era_id
+      # @option era_validators [Array<Hash>] :validator_weights
+      # @param [Array<Hash>] bids
       def initialize(state_root_hash, block_height, era_validators, bids)
         @state_root_hash = state_root_hash
         @block_height = block_height
-        @era_validators = era_validators
+
+        @era_validators = []
+        era_validators.each do |era_validator|
+          @validators_weights = []
+          era_validator[:validator_weights].each do |validator_weight|
+            @validators_weights << Casper::Entity::ValidatorWeight.new(validator_weight[:public_key], validator_weight[:weight])
+          end
+          @era_validators << Casper::Entity::EraValidator.new(era_validator[:era_id], @validators_weights)
+          @validators_weights = []
+          # puts Casper::Entity::EraValidator.new(era_validator[:era_id], @validators_weights).get_era_id
+          # puts Casper::Entity::EraValidator.new(era_validator[:era_id], @validators_weights).get_validator_weights
+        end
+
+        # @era_validators.each do |era_validator| 
+        #   puts era_validator.get_validator_weights[0].get_era_id
+        #   puts era_validator.get_validator_weights[0].get_weight
+        # end
+
         @bids = bids
+        @bids_list = []
+        
+        bids.each do |bid|
+          bid_info = bid[:bid]
+          @delegators_list = []
+          delegators = bid_info[:delegators]
+
+          delegators.each do |delegator| 
+            @delegators_list << Casper::Entity::Delegator.new(
+              delegator[:public_key], 
+              delegator[:staked_amount], 
+              delegator[:bonding_purse], 
+              delegator[:delegatee]
+              )
+            # puts delegator
+            # puts delegator[:public_key]
+          end
+          
+          bid_info = Casper::Entity::BidInfo.new(
+            bid_info[:bonding_purse], 
+            bid_info[:staked_amount], 
+            bid_info[:delegation_rate],
+            bid_info[:vesting_schedule],
+            # bid_info[:delegators],
+            @delegators_list,
+            bid_info[:inactive]
+            )
+          @bids_list << Casper::Entity::Bid.new(bid[:public_key], bid_info)
+        end
       end
 
-      # @return [String] returns state root hash as a String
+      # @return [String] state root hash as a String
       def get_state_root_hash
         @state_root_hash
       end
 
-      # @return [Integer] returns block height as an Integer 
+      # @return [Integer] block height as an Integer 
       def get_block_height
         @block_height
       end
 
-      # @return [Array<Hash>] returns array of hashes
+      # @return [Array<EraValidator>] array of EraValidator
       def get_era_validators
         @era_validators
       end
 
-      # @return [Array<Hash>] returns array of hashes
+      # @return [Array<Bid>] array of Bid
       def get_bids
-        @bids
+        @bids_list
       end
     end
   end

data/lib/entity/bid.rb

@@ -7,7 +7,7 @@ module Casper
       # @param [BidInfo] bid_info
       def initialize(public_key, bid_info)
         @public_key = public_key
-        @BidInfo = bid_info
+        @bid_info = bid_info
 
       end
 

data/lib/entity/bid_info.rb

@@ -7,7 +7,7 @@ module Casper
       # @param [String] staked_amount
       # @param [Integer] delegation_rate
       # @param [VestingSchedule] vesting_schedule
-      # @param [Hash<Delegator>] delegators
+      # @param [Array<Delegator>] delegators
       # @param [Boolean] inactive
       def initialize(bonding_purse, staked_amount, delegation_rate, vesting_schedule, delegators, inactive)
         @bonding_purse = bonding_purse

data/lib/entity/block.rb

@@ -0,0 +1,39 @@
+module Casper
+  module Entity
+    # Block 
+    class Block
+
+      # @param [String] hash
+      # @param [Hash] header
+      # @param [Hash] body
+      # @param [Array<Hash>] proofs
+      def initialize(hash, header = {}, body = {}, proofs = [])
+        @hash = hash
+        @header = Casper::Entity::BlockHeader.new(header)
+        @body = Casper::Entity::BlockBody.new(body)
+        @proofs = []
+        proofs.each { |proof| @proofs << Casper::Entity::BlockProof.new(proof) }
+      end
+
+      # @return [String] block hash
+      def get_hash
+        @hash
+      end
+
+      # @return [BlockHeader] block header
+      def get_header
+        @header
+      end
+
+      # @return [BlockBody] block body
+      def get_body
+        @body
+      end
+
+      # @return [Array<BlockProof>] list of proofs for this block
+      def get_proofs
+        @proofs
+      end
+    end
+  end
+end

data/lib/entity/block_body.rb

@@ -0,0 +1,35 @@
+module Casper
+  module Entity
+    # BlockBody entity 
+    class BlockBody
+
+      # @param [Hash] body
+      # @option [String] :proposer
+      # @option [Array] :deploy_hashes
+      # @option [Array] :transfer_hashes
+      def initialize(body =  {})
+        @proposer = body[:proposer]
+        @deploy_hashes = body[:deploy_hashes]
+        @transfer_hashes = body[:transfer_hashes]
+      end
+
+      # @return [String] a hex-encoded cryptographic public key, 
+      #   including the algorithm tag prefix.
+      def get_proposer
+        @proposer
+      end
+
+      # @return [Array] hex-encoded Deploy hashes.
+      def get_deploy_hashes
+        @deploy_hashes
+      end
+
+      # @return [Array] a vector of hex-encoded hashes 
+      #   identifying Transfers included in this block.
+      def get_transfer_hashes
+        @transfer_hashes
+      end
+
+    end
+  end
+end