casper_network 1.0.1 → 1.1.2

data/lib/serialization/deploy_serializer.rb

@@ -3,34 +3,45 @@ 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]
         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
+      @payment_serializer += temp
+      @payment_session_serializer += temp
       temp = nil
     elsif payment.keys[0] == :StoredContractByHash
       temp_args = []
@@ -43,11 +54,11 @@ class DeploySerializer
         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
+      @payment_session_serializer += temp
       temp = nil
     elsif payment.keys[0] == :StoredContractByName
       temp_args = []
@@ -64,6 +75,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 +93,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 +111,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 = []
@@ -108,11 +122,11 @@ class DeploySerializer
         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
+      @payment_session_serializer += temp
       temp = nil
     end
 
@@ -120,7 +134,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 +143,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 = []
@@ -141,11 +156,11 @@ class DeploySerializer
         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
+      @payment_session_serializer += temp
       temp = nil
     elsif session.keys[0] == :StoredContractByName
       temp_args = []
@@ -162,6 +177,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 +195,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 +213,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,31 +221,120 @@ 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])
+          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
+          # 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
       result += temp
+      @transfer_serializer += temp
+      @payment_session_serializer += temp
       temp = nil
     end
 
     approvals =  deploy.get_approvals
     num_of_approvals = approvals.size
+    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
-    # 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)
+      CLu64.new(value)
+    elsif cl_type == "U512"
+      bytes = h[:bytes] # => 0400f90295
+      num_of_bytes = bytes[0..1] # => 04
+      bytes = bytes[2..] # => "00f90295"
+      value = [bytes].pack("H*").unpack("L*").first
+      # CLu512.new(value)
+      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 == ""
+        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
+  end
+
+  def build_cl_value_with_option(h = {})
     cl_type = h[:cl_type]
     bytes = h[:bytes]
     parsed = h[:parsed]
@@ -248,6 +355,11 @@ class DeploySerializer
     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)
+      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 +372,8 @@ 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

data/lib/types/cl_option.rb

@@ -18,6 +18,7 @@ class CLOption < CLValue
     elsif data == nil && inner_type != nil
       @inner_type = inner_type
     else
+      # @inner_type = data[:cl_type]
       @inner_type = data.get_cl_type
     end
   end
@@ -27,7 +28,14 @@ class CLOption < CLValue
   end
 
   def get_cl_type
-   CLOptionType.new(@inner_type)
+   CLOptionType.new(@inner_type).get_type
+=begin
    @inner_type
+   get_type
+=end
+  end
+
+  def get_inner_type
+   @inner_type 
   end
 end

data/lib/types/cl_public_key.rb

@@ -34,6 +34,8 @@ class CLPublicKey < CLValue
   # @param [Integer] tag
   def initialize(raw_public_key, tag)
     super()
+    @tag = tag
+    @raw_public_key = raw_public_key
     raw_public_key_length_valid?(raw_public_key, tag)
   end
 

data/lib/types/cl_value.rb

@@ -8,4 +8,12 @@ class CLValue
     @cl_type = cl_type
     @parsed = parsed
   end
+
+  def to_hash(bytes, value, type)
+    {
+      "bytes": bytes,
+      "parsed": value,
+      "cl_type": type
+    }
+  end
 end

data/lib/utils/byte_utils.rb

@@ -27,6 +27,11 @@ module Utils
       # byte_array.pack("C*").unpack1("H*")
       byte_array.pack("C*").unpack("H*").first
     end
+   
+    def byte_array_to_hex_64(byte_array)
+      # byte_array.pack("C*").unpack1("H*")
+      byte_array.pack("C*").unpack("H*").first
+    end
 
     # @param [String] str
     # @return [Array]
@@ -74,6 +79,15 @@ module Utils
     # @param [Integer] n
     # @return [String]
     def to_u64(n)
+      # bytes = Utils::ByteUtils.byte_array_to_hex(to_byte_array(n)) + "0000"
+      # puts "bytes: #{bytes}"
+      # puts "bytes_conversion: #{[bytes].pack("H*").unpack("C*")}"
+      [n].pack("Q<*").unpack("H*").first
+    end
+
+    # @param [Integer] n
+    # @return [String]
+    def to_u512(n)
       [n].pack("Q<*").unpack("H*").first
     end
 
@@ -103,5 +117,19 @@ module Utils
     def hex_to_u64_value(hex_str)
       [hex_str].pack("H*").unpack("Q*").first
     end
+    def hex_to_u512_value(hex_str)
+      [hex_str].pack("H*").unpack("Q*").first
+    end
+
+    # @return byte array containing two's complement representation of Bignum/Fixnum
+    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
   end
 end

data/lib/utils/helpers.rb

@@ -0,0 +1,10 @@
+module Utils
+  module Helpers
+    extend self
+    def construct_inner_clvalue(cl_type, value)
+      if cl_type == "U64"
+        CLu64.new(value)
+      end
+    end
+  end
+end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module CasperNetworkSDK
-  VERSION = '1.0.1'
+  VERSION = '1.1.2'
 end

data/spec/cl_value_serializer_spec.rb

@@ -69,6 +69,18 @@ describe CLValueSerializer do
     end
   end
 
+  describe "CLu512 Value Serializer" do
+    let(:u512_1) { CLu512.new(1000000000)}
+    let(:u512_2) { CLu512.new(23000000000)}
+
+    it "should serialize CLu512 values" do 
+      # puts serializer.to_bytes(u512_1)
+      expect(serializer.to_bytes(u512_1)).to eql("040000000300ca9a08")
+      # puts serializer.to_bytes(u512_2)
+      expect(serializer.to_bytes(u512_2)).to eql("05000000040026e85a08")
+    end
+  end
+
   describe "CLString Value Serializer" do
     let (:str1) { CLString.new("Hello, Casper!") }
     it "should serialize CLString values" do
@@ -133,8 +145,10 @@ describe CLValueSerializer do
   describe "CLUnit Value Serializer" do  
     let(:unit)  {CLUnit.new()}
     it "should serialize CLUnit values" do  
-      puts serializer.to_bytes(unit)
+      # puts serializer.to_bytes(unit)
       expect(serializer.to_bytes(unit)).to eql("0000000009")
     end
   end
+
+
 end

data/spec/client_spec.rb

@@ -1,8 +1,8 @@
 # client_spec.rb
-require './lib/casper_network.rb'
+require './lib/rpc/rpc_client.rb'
 
-describe CasperClient do
-  client1 = CasperClient.new("185.246.84.43")
+describe Casper::RpcClient do
+  client1 = Casper::RpcClient.new("185.246.84.43")
   # Test info_get_peers()
   describe "#info_get_peers" do
     it "returns peers array." do

data/spec/deploy_executable_spec.rb

@@ -0,0 +1,90 @@
+require_relative '../lib/entity/deploy_named_argument.rb'
+require_relative '../lib/serialization/deploy_named_arg_serializer.rb'
+require_relative '../lib/entity/deploy_executable_item_internal.rb'
+require_relative '../lib/entity/deploy_executable.rb'
+require_relative '../lib/entity/stored_contract_by_hash.rb'
+require_relative '../lib/entity/stored_contract_by_name.rb'
+require_relative '../lib/entity/stored_versioned_contract_by_hash.rb'
+require_relative '../lib/entity/stored_versioned_contract_by_name.rb'
+require_relative '../lib/serialization/deploy_executable_serializer.rb'
+require_relative '../lib/entity/deploy.rb'
+require_relative '../lib/entity/deploy_hash.rb'
+require_relative '../lib/entity/deploy_header.rb'
+require_relative '../lib/entity/deploy_approval.rb'
+require_relative '../lib/entity/deploy_info.rb'
+require_relative '../lib/entity/deploy.rb'
+require_relative '../lib/serialization/deploy_serializer.rb'
+
+
+RSpec.describe Casper::Entity::DeployExecutable do
+  # describe Casper::Entity::DeployExecutable do
+  let(:args) {[]}
+
+    
+    # ModuleBytes
+    describe Casper::Entity::ModuleBytes do
+      it "ModuleBytes serialization" do
+        args = []
+        arg1 = Casper::Entity::DeployNamedArgument.new("amount", CLu512.new(2500000000))
+        args << [arg1]
+        module_bytes = Casper::Entity::ModuleBytes.new("", args)
+        # puts Utils::ByteUtils.byte_array_to_hex(module_bytes.to_bytes)
+        expect(Utils::ByteUtils.byte_array_to_hex(module_bytes.to_bytes)).to eql("00000000000100000006000000616d6f756e74050000000400f9029508")
+      end
+    end
+
+    # StoredContractByHash
+    describe Casper::Entity::StoredContractByHash do
+      it "StoredContractByHash serialization" do 
+        arg1 = Casper::Entity::DeployNamedArgument.new("quantity", CLi32.new(1000))
+        args << [arg1]
+        stored_contract_by_hash = Casper::Entity::StoredContractByHash.new("c4c411864f7b717c27839e56f6f1ebe5da3f35ec0043f437324325d65a22afa4", "pclphXwfYmCmdITj8hnh", args)
+        # puts Utils::ByteUtils.byte_array_to_hex(stored_contract_by_hash.to_bytes)
+        expect(Utils::ByteUtils.byte_array_to_hex(stored_contract_by_hash.to_bytes)).to eql("01c4c411864f7b717c27839e56f6f1ebe5da3f35ec0043f437324325d65a22afa41400000070636c7068587766596d436d6449546a38686e6801000000080000007175616e7469747904000000e803000001")
+      end
+    end
+
+    # StoredContractByName
+    describe Casper::Entity::StoredContractByName do
+      it "StoredContractByName serialization" do
+        arg1 = Casper::Entity::DeployNamedArgument.new("quantity", CLi32.new(1000))
+        args << [arg1]
+        stored_contract_by_name = Casper::Entity::StoredContractByName.new("casper-example", "example-entry-point", args)
+        # puts Utils::ByteUtils.byte_array_to_hex(stored_contract_by_name.to_bytes)
+        expect(Utils::ByteUtils.byte_array_to_hex(stored_contract_by_name.to_bytes)).to eql("020e0000006361737065722d6578616d706c65130000006578616d706c652d656e7472792d706f696e7401000000080000007175616e7469747904000000e803000001")
+      end
+    end
+
+    # StoredVersionedContractByHash
+    describe Casper::Entity::StoredVersionedContractByHash do
+      it "StoredVersionedContractByHash serialization" do
+        arg1 = Casper::Entity::DeployNamedArgument.new("test", CLString.new("Hello, World!"))
+        args << [arg1]
+        stored_versioned_contract_by_hash = Casper::Entity::StoredVersionedContractByHash.new("b348fdd0d0b3f66468687df93141b5924f6bb957d5893c08b60d5a78d0b9a423", nil, "PsLz5c7JsqT8BK8ll0kF", args)
+        # puts Utils::ByteUtils.byte_array_to_hex(stored_versioned_contract_by_hash.to_bytes)
+        expect(Utils::ByteUtils.byte_array_to_hex(stored_versioned_contract_by_hash.to_bytes)).to eql("03b348fdd0d0b3f66468687df93141b5924f6bb957d5893c08b60d5a78d0b9a423001400000050734c7a3563374a73715438424b386c6c306b46010000000400000074657374110000000d00000048656c6c6f2c20576f726c64210a")
+      end
+    end
+
+    # StoredVersionedContractByName
+    describe Casper::Entity::StoredVersionedContractByName do
+      it "StoredVersionedContractByName serialization" do
+        arg1 = Casper::Entity::DeployNamedArgument.new("test", CLString.new("Hello, World!"))
+        args << [arg1]
+        stored_versioned_contract_by_name = Casper::Entity::StoredVersionedContractByName.new("test-contract", nil, "PsLz5c7JsqT8BK8ll0kF", args)
+        # puts Utils::ByteUtils.byte_array_to_hex(stored_versioned_contract_by_name.to_bytes)
+        expect(Utils::ByteUtils.byte_array_to_hex(stored_versioned_contract_by_name.to_bytes)).to eql("040d000000746573742d636f6e7472616374001400000050734c7a3563374a73715438424b386c6c306b46010000000400000074657374110000000d00000048656c6c6f2c20576f726c64210a")
+      end
+    end
+
+    # DeployExecutableTransfer
+    describe Casper::Entity::DeployExecutableTransfer do
+      it "DeployExecutableTransfer serialization" do
+        arg1 = Casper::Entity::DeployNamedArgument.new("amount", CLi32.new(1000))
+        args << [arg1]
+        transfer = Casper::Entity::DeployExecutableTransfer.new(args)
+        # puts Utils::ByteUtils.byte_array_to_hex(transfer.to_bytes)
+        expect(Utils::ByteUtils.byte_array_to_hex(transfer.to_bytes)).to eql("050100000006000000616d6f756e7404000000e803000001")
+      end
+    end
+end

data/spec/testnet_spec.rb

@@ -6,7 +6,9 @@ require './lib/rpc/rpc_client.rb'
 # Ip Address taken from Testnet
 # client = Casper::RpcClient.new("65.21.227.101")  # IP is taken from "TestNet"
 # client = Casper::RpcClient.new("138.201.54.44")  # IP is taken from "TestNet"
-client = Casper::RpcClient.new("5.9.23.55")        # IP is taken from "TestNet"
+# client = Casper::RpcClient.new("5.9.23.55")        # IP is taken from "TestNet"
+client = Casper::RpcClient.new("65.21.235.219")    # IP is taken from "TestNet"
+
 
 # block_Hash taken from Testnet
 block_hash = "71e19e2e9629c716dc9578066cfeceace559d32fe51b08245ddd4d218f8c18da"
@@ -250,8 +252,8 @@ describe Casper::RpcClient do
         expect(peers_from_info_get_status.size).to be > 0
       end
 
-      it "passes, node public key is : 018597e78805200d5469105024d7741894c2c1eac69fb9c15e718e1824261722a2" do
-        our_public_signing_key = "018597e78805200d5469105024d7741894c2c1eac69fb9c15e718e1824261722a2"
+      it "passes, node public key is : 01ac58a7b87cd67f03b1ccf371a1f3979efb6ddafb9fbb7b59096ed5a6425eccc3" do
+        our_public_signing_key = "01ac58a7b87cd67f03b1ccf371a1f3979efb6ddafb9fbb7b59096ed5a6425eccc3"
         expect(node_status[:our_public_signing_key]).to eql(our_public_signing_key)
       end
     end