test_sdk1 1.0.0

data/lib/types/cl_uref.rb

@@ -0,0 +1,120 @@
+require_relative './cl_uref_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+require 'json'
+
+
+#  Access Rights
+# https://docs.casperlabs.io/design/serialization-standard/#clvalue-uref
+
+
+class CLURef < CLValue  
+  include CLValueBytesParsers::CLURefBytesParser
+  attr_accessor :err
+  # @param [Array<Integer>] value
+  # @param [AccessRights] access_rights
+  # value is an uint8array
+  def initialize(value = nil, access_rights = nil)
+    super()
+    # raise ArgumentError.new('The length of URefAddr should be 32') unless value.length == 32
+    # rescue ArgumentError => e
+    #   p e.message
+    begin
+      raise ArgumentError.new('The length of URefAddr should be 32') unless value.length == 32
+    rescue ArgumentError => e  
+      e.message
+    end
+    begin
+      raise ArgumentError.new('Unsupported AccessRights') unless AccessRights.has_value?(access_rights)
+    rescue ArgumentError => e  
+      e.message
+    end
+    # if value.length != 32
+    #   raise ArgumentError.new('The length of URefAddr should be 32')
+    # end
+    # raise ArgumentError.new("Unsupported AccessRights") unless AccessRights.has_value?(access_rights)
+    # if value.length != 32
+    #   begin
+    #     raise Error.new('The length of URefAddr should be 32')
+    #   rescue StandardError => e
+    #     puts e
+    #   end
+    # end
+    # if !(AccessRights.has_value?(access_rights))
+    #   raise Error.new('Unsupported AccessRights')
+    # end
+    @value =  value
+    @access_rights = access_rights
+
+  end
+
+  def get_cl_type
+    @cl_type = CLURefType.new
+    @cl_type.to_string
+  end
+
+  def get_value
+    @value 
+  end
+
+  def get_access_rights
+    @access_rights
+  end
+
+  def get_size
+    @value.size
+  end
+
+  def self.parse_uref_address(str)
+    raise ArgumentError.new("Expected a string value of \'uref-\' ") unless str.start_with?("uref-")
+    raise ArgumentError.new("Expected a value of 3") unless str[0..str.length-1].split('-', 3).size == 3
+    raise ArgumentError.new("Expected a value of 32") unless str[0..str.length-1].split('-', 3)[1].length/2 == 32
+
+    arr = str[0..str.length-1].split('-', 3)
+    prefix = arr[0]
+    uref_addr = arr[1]
+    suffix = arr[2]
+    uref_byte_length = uref_addr.length / 2
+    decoded_addr = CLValueBytesParsers::CLURefBytesParser.decode_base_16(uref_addr)
+    access_rights = suffix.to_i(8)
+    # puts decoded_addr.inspect
+    # puts access_rights
+    raise ArgumentError.new("The value of \'access_rights\' is out of range. It must be >= 0 and <= 7. Received #{access_rights}") unless suffix.to_i(10).between?(0, 7)
+    CLURef.new(decoded_addr, access_rights)
+  end
+
+  # Example: str = "uref-000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f-007";
+  def to_bytes(str)
+    raise ArgumentError.new("Expected a string value of \'uref-\' ") unless str.start_with?("uref-")
+    raise ArgumentError.new("Expected a value of 3") unless str[0..str.length-1].split('-', 3).size == 3
+    raise ArgumentError.new("Expected a value of 32") unless str[0..str.length-1].split('-', 3)[1].length/2 == 32
+
+    arr = str[0..str.length-1].split('-', 3)
+    prefix = arr[0]
+    uref_addr = arr[1]
+    suffix = arr[2]
+    uref_byte_length = uref_addr.length / 2
+    access_rights = suffix.to_i(8)
+    raise ArgumentError.new("The value of \'access_rights\' is out of range. It must be >= 0 and <= 7. Received #{access_rights}") unless suffix.to_i(10).between?(0, 7)
+    uref_addr + [access_rights].pack("C*").unpack1("H*")
+  end
+
+  def self.to_json(uref)
+    decoded_addr = uref.get_value
+    # p decoded_addr
+    access_rights = uref.get_access_rights
+    decoded_addr_with_access_rights = CLValueBytesParsers::CLURefBytesParser.to_bytes(uref)
+    # p decoded_addr_with_access_rights
+    encoded_addr_with_access_rights = CLValueBytesParsers::CLURefBytesParser.encode_base_16(decoded_addr_with_access_rights)
+    # p encoded_addr_with_access_rights
+    json = {"bytes": encoded_addr_with_access_rights, "cl_type": uref.get_cl_type}.to_json
+  end
+
+  def self.from_json(json)
+    parsed = JSON.parse(json).deep_symbolize_keys
+    bytes = CLValueBytesParsers::CLURefBytesParser.decode_base_16(parsed[:bytes])
+    decoded = bytes[0...-1]
+    access_rights = bytes.pop
+    CLURef.new(decoded, access_rights)
+  end
+end

data/lib/types/cl_uref_type.rb

@@ -0,0 +1,46 @@
+require_relative './cl_type.rb'
+require_relative './constants.rb'
+
+
+
+class CLURefType < CLType
+  def initialize(value = nil)  
+    super(value)
+    @value = value
+  end
+
+  def to_string
+    TAGS.key(12).to_s
+  end
+
+  def get_value 
+    @value
+  end
+
+  def to_json 
+    to_string
+  end
+
+  def to_bytes
+    [12].pack("C*").unpack1("H*")
+  end
+end
+
+AccessRights = {
+  # No permissions
+  None: 0b00000000,
+  # Permission to read the value under the associated [[URef]].
+  READ: 0b00000001,
+  # Permission to write a value under the associated [[URef]].
+  WRITE: 0b00000010,
+  # Permission to read or write the value under the associated [[URef]].
+  READ_WRITE: 0b00000011,
+  # Permission to add to the value under the associated [[URef]].
+  ADD: 0b00000100,
+  # # Permission to read or add to the value under the associated [[URef]].
+  READ_ADD: 0b00000101,
+  # # Permission to add to, or write the value under the associated [[URef]].
+  ADD_WRITE: 0b00000110,
+  # # Permission to read, add to, or write the value under the associated [[URef]].
+  READ_ADD_WRITE: 0b00000111
+}

data/lib/types/cl_value.rb

@@ -0,0 +1,10 @@
+require_relative './cl_type.rb'
+
+class CLValue
+
+  def initialize(bytes = nil, cl_type =  nil, parsed = nil)
+    @bytes = bytes
+    @cl_type = cl_type
+    @parsed = parsed
+  end
+end

data/lib/types/constants.rb

@@ -0,0 +1,50 @@
+MIN_I32 = -2147483648
+MAX_I32 = 2147483647
+
+MIN_I64 = -9223372036854775808
+MAX_I64 = 9223372036854775807
+
+MIN_U8 = 0
+MAX_U8 = 255
+
+MIN_U32 = 0
+MAX_U32 = 2.pow(32) - 1
+
+MIN_U64 = 0
+MAX_U64 = 2.pow(64) - 1
+
+MIN_U128 = 0
+MAX_U128 = 2.pow(128) - 1
+
+MIN_U256 = 0
+MAX_U256 = 2.pow(256) - 1
+
+MIN_U512 = 0
+MAX_U512 = 2.pow(512) - 1
+
+
+BOOL_ID = 'Bool';
+KEY_ID = 'Key';
+PUBLIC_KEY_ID = 'PublicKey';
+STRING_ID = 'String';
+UREF_ID = 'URef';
+UNIT_ID = 'Unit';
+I32_ID = 'I32';
+I64_ID = 'I64';
+U8_ID = 'U8';
+U32_ID = 'U32';
+U64_ID = 'U64';
+U128_ID = 'U128';
+U256_ID = 'U256';
+U512_ID = 'U512';
+
+BYTE_ARRAY_ID = 'ByteArray';
+LIST_ID = 'List';
+MAP_ID = 'Map';
+OPTION_ID = 'Option';
+RESULT_ID = 'Result';
+TUPLE1_ID = 'Tuple1';
+TUPLE2_ID = 'Tuple2';
+TUPLE3_ID = 'Tuple3';
+
+ACCOUNT_HASH_ID = 'AccountHash';

data/lib/types/error.rb

@@ -0,0 +1,7 @@
+class Error < StandardError
+  attr_reader :err
+  def initialize(err)
+    @err = err
+    super(err)
+  end
+end

data/lib/utils/base_16.rb

@@ -0,0 +1,18 @@
+module Utils
+  module Base16
+    module_function
+
+    # @param [Array<Integer>] byte_array
+    # @return [String] encoded
+    def encode16(byte_array)
+      encoded = byte_array.pack("C*").unpack("H*").first
+    end
+
+    # @param [String] str
+    # @return [Array<Integer>] decoded
+    def decode16(str)
+      decoded = [str].pack('H*').unpack("C*")
+    end
+  end
+
+end

data/lib/utils/byte_utils.rb

@@ -0,0 +1,107 @@
+module Utils
+  module ByteUtils
+    extend self
+
+    # @param [String] str
+    # @return [String] 
+    def string_to_hex(str)
+      # str.unpack1("H*")
+      str.unpack("H*").first
+    end
+
+    # @param [String] hex_str
+    # @return [String]
+    def hex_to_string(hex_str)
+      [hex_str].pack("H*")
+    end
+
+    # @param [String] hex_str
+    # @return [Array]
+    def hex_to_byte_array(hex_str)
+      [hex_str].pack("H*").unpack("C*")
+    end
+   
+    # @param [Array] byte_array
+    # @return [String]
+    def byte_array_to_hex(byte_array)
+      # byte_array.pack("C*").unpack1("H*")
+      byte_array.pack("C*").unpack("H*").first
+    end
+
+    # @param [String] str
+    # @return [Array]
+    def string_to_byte_array(str)
+      str.unpack("C*")
+    end
+
+    # @param [Array] byte_array
+    # @return [String]
+    def byte_array_to_string(byte_array)
+      byte_array.pack("C*")
+    end 
+
+    # @param [Integer] n
+    # @return [String]
+    def integer_to_hex(n)
+      [n].pack("l<*").unpack("H*").first
+    end
+
+    # @param [String] hex_str
+    # @return [Integer] 
+    def hex_to_integer(hex_str)
+      [hex_str].pack("H*").unpack("l").first
+    end
+
+    def to_i32(n)
+      # [value].pack("l<*").unpack("C*")
+      [n].pack("l<*").unpack("H*").first
+      # [n].pack("l<*").unpack1("H*")
+    end
+    
+    def to_i64(n)
+      # [value].pack("l<*").unpack("C*")
+      [n].pack("q<*").unpack("H*").first
+      # [n].pack("l<*").unpack1("H*")
+    end
+
+    def to_u8(n)
+      [n].pack("C").unpack1("H*")
+    end
+    def to_u32(n)
+      [n].pack("L<*").unpack("H*").first
+      # [n].pack("L<*").unpack1("H*")
+    end
+    # @param [Integer] n
+    # @return [String]
+    def to_u64(n)
+      [n].pack("Q<*").unpack("H*").first
+    end
+
+    # @param [String] hex_str
+    # @return [String] 
+    def hex_from_little_endian_to_big_endian(hex_str)
+      # [hex_str].pack("H*").unpack('N*').pack('V*').unpack1('H*')
+      [hex_str].pack("H*").unpack('N*').pack('V*').unpack('H*').first
+    end
+
+    def hex_to_i32_value(hex_str)
+      [hex_str].pack("H*").unpack("l*").first
+    end
+
+    def hex_to_i64_value(hex_str)
+      [hex_str].pack("H*").unpack("q*").first
+    end
+
+    def hex_to_u8_value(hex_str)
+      [hex_str].pack("H*").unpack("C*").first
+    end
+
+    def hex_to_u32_value(hex_str)
+      [hex_str].pack("H*").unpack("L*").first
+    end
+
+    def hex_to_u64_value(hex_str)
+      [hex_str].pack("H*").unpack("Q*").first
+    end
+  end
+end

data/lib/utils/find_byte_parser_by_cl_type.rb

@@ -0,0 +1,53 @@
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+def find_byte_parser_by_cl_type(type, value)
+  if type == "Bool"
+    CLValueBytesParsers::CLBoolBytesParser.to_bytes(value)
+  elsif type == "I32"
+    CLValueBytesParsers::CLI32BytesParser.to_bytes(value)
+  elsif type == "I64"
+    CLValueBytesParsers::CLI64BytesParser.to_bytes(value)
+  elsif type == "U8"
+    CLValueBytesParsers::CLU8BytesParser.to_bytes(value)
+  elsif type == "U32"
+    CLValueBytesParsers::CLU32BytesParser.to_bytes(value)
+  elsif type == "U64"
+    CLValueBytesParsers::CLU64BytesParser.to_bytes(value)
+  elsif type == "U128"
+    CLValueBytesParsers::CLU128BytesParser.to_bytes(value)
+  elsif type == "U256"
+    CLValueBytesParsers::CLU256BytesParser.to_bytes(value)
+  elsif type == "U512"
+    CLValueBytesParsers::CLU512BytesParser.to_bytes(value)
+  elsif type == "Unit"
+    CLValueBytesParsers::CLUnitBytesParser.to_bytes(value)
+  elsif type == "String"
+    CLValueBytesParsers::CLStringBytesParser.to_bytes(value)
+  elsif type == "Key"
+    CLValueBytesParsers::CLKeyBytesParser.to_bytes(value)
+  elsif type == "URef"
+    CLValueBytesParsers::CLURefBytesParser.to_bytes(value)
+  elsif type == "Option"
+    CLValueBytesParsers::CLOptionBytesParser.to_bytes(value)
+  elsif type == "List"
+    CLValueBytesParsers::CLListBytesParser.to_bytes(value)
+  elsif type == "ByteArray"
+    CLValueBytesParsers::CLByteArrayBytesParser.to_bytes(value)
+  elsif type == "Result"
+    CLValueBytesParsers::CLResultBytesParser.to_bytes(value)
+  elsif type == "Map"
+    CLValueBytesParsers::CLMapBytesParser.to_bytes(value)
+  elsif type == "Tuple1"
+    CLValueBytesParsers::CLTupleBytesParser.to_bytes(value)
+  elsif type == "Tuple2"
+    CLValueBytesParsers::CLTupleBytesParser.to_bytes(value)
+  elsif type == "Tuple3"
+    CLValueBytesParsers::CLTupleBytesParser.to_bytes(value)
+  elsif type == "Any"
+    CLValueBytesParsers::CLAnyBytesParser.to_bytes(value)
+  elsif type == "PublicKey"
+    CLValueBytesParsers::CLPublicKeyBytesParser.to_bytes(value)
+  else
+    "Undefined type"
+  end
+end

data/lib/utils/hash_utils.rb

@@ -0,0 +1,19 @@
+require 'blake2'
+
+module Utils
+  module HashUtils
+    module_function
+
+    def byte_hash(arr)
+      str = arr.pack("C*").unpack("H*").first
+      key = Blake2::Key.none
+      Blake2.bytes(str, key, 32)
+    end
+
+    def account_hash_from_byte_to_hex(account_hash_byte_array)
+      prefix = "account-hash-"
+      hash_hex = account_hash_byte_array.pack("C*").unpack("H*").first
+      prefix + hash_hex
+    end
+  end
+end

data/lib/utils/hex_utils.rb

@@ -0,0 +1,12 @@
+module Utils
+  module HexUtils
+    module_function
+   
+    # @param [String] public_key_hex
+    # @return [Boolean]
+    def valid_public_key_format?(public_key_hex)
+      # !!"01f9235ff9c46c990e1e2eee0d531e488101fab48c05b75b8ea9983658e228f06b".match(/^0(1[0-9a-fA-F]{64}|2[0-9a-fA-F]{66})$/)
+      !!public_key_hex.match(/^0(1[0-9a-fA-F]{64}|2[0-9a-fA-F]{66})$/)
+    end
+  end
+end

data/lib/utils/time_utils.rb

@@ -0,0 +1,85 @@
+require 'date'
+require 'time'
+
+module Utils
+  module TimeUtils
+    extend self
+
+    # Convert iso datetime to ms from unix epoch
+    #
+    # @param [String] timestamp
+    # @return [Integer]
+    def to_epoc_ms(timestamp)
+      DateTime.parse( ).strftime("%Q")
+      DateTime.parse(timestamp).strftime("%Q").to_i
+    end
+
+    # Converts milliseconds to timestamp 
+    def to_iso_string(milliseconds)
+      milliseconds -= 3 * 60 * 60 * 1000
+      Time.at(milliseconds/1000.0).strftime('%Y-%m-%dT%H:%M:%S.%3NZ')
+    end
+
+    # Convert ttl into milliseconds
+    # @param [String] ttl
+    # @return [Integer]
+    def ttl_to_milliseconds(ttl)
+      arr = ttl.split(' ')
+      total_time = 0
+      n = 1
+      for item in arr do
+        if item.include?("h")
+          n = 60 * 60 * 1000
+        elsif item.include?("m") && !item.include?("ms")
+          n = 60 * 1000
+        elsif item.include?("s") && !item.include?("ms")
+          n = 1000
+        elsif item.include?("ms")
+          n = 1
+        elsif item.include?("d")
+          n = 24 * 60 * 60 * 1000
+        elsif item.include?("day")
+          n = 24 * 60 * 60 * 1000
+        end
+          value = item.gsub(/[^0-9,.]/, "").to_i
+          value *= n
+          total_time += value 
+          n = 1
+      end
+      total_time
+    end
+
+    # Milliseconds to String TTL
+    #
+    # @param [Integer] milliseconds
+    # @return [String]
+    def milliseconds_to_ttl(milliseconds)
+      return '' unless milliseconds
+      days, milliseconds   = milliseconds.divmod(1000 * 60 * 60 * 24)
+      hours, milliseconds   = milliseconds.divmod(1000 * 60 * 60)
+      minutes, milliseconds = milliseconds.divmod(1000 * 60)
+      seconds, milliseconds = milliseconds.divmod(1000)
+     str = "#{days}d #{hours}h #{minutes}m #{seconds}s #{milliseconds}ms"
+     arr = str.split(" ")
+     new_str = ""
+     for item in arr  do  
+      if item[0] != '0'
+        new_str += item + " "
+      end
+     end
+     new_str.rstrip
+    end
+
+    def get_duration_hrs_mins_secs_ms(milliseconds)
+      return '' unless milliseconds
+      hours, milliseconds   = milliseconds.divmod(1000 * 60 * 60)
+      minutes, milliseconds = milliseconds.divmod(1000 * 60)
+      seconds, milliseconds = milliseconds.divmod(1000)
+      "#{hours}h #{minutes}m #{seconds}s #{milliseconds}ms"
+    rescue 
+      ""
+    end
+
+  end
+end
+

data/lib/utils/utils.rb

@@ -0,0 +1,2 @@
+module Utils
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module CasperNetworkSDK
+  VERSION = '1.0.0'
+end