test_sdk1 1.0.0

data/lib/types/cl_list.rb

@@ -0,0 +1,25 @@
+require_relative './cl_list_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+
+
+class CLList < CLValue  
+  include CLValueBytesParsers::CLListBytesParser
+ 
+  def initialize(value = nil)
+    super
+    @value =  value
+  end
+
+  def get_cl_type
+    @cl_type = CLListType.new
+    @cl_type.to_string
+  end
+
+  def get_value
+    @value  
+  end
+
+end
+

data/lib/types/cl_list_type.rb

@@ -0,0 +1,26 @@
+require_relative './cl_type.rb'
+require_relative './constants.rb'
+
+
+class CLListType < CLType
+  def initialize(value = nil)  
+    super(value)
+    @value = value
+  end
+
+  def to_string
+    TAGS.key(14).to_s
+  end
+
+  def get_value 
+    @value
+  end
+
+  def to_json 
+    to_string
+  end
+
+  def to_bytes
+    [14].pack("C*").unpack1("H*")
+  end
+end

data/lib/types/cl_map.rb

@@ -0,0 +1,25 @@
+require_relative './cl_map_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+
+
+class CLMap < CLValue  
+  include CLValueBytesParsers::CLMapBytesParser
+ 
+  def initialize(value = nil)
+    super
+    @value =  value
+  end
+
+  def get_cl_type
+    @cl_type = CLMapType.new
+    @cl_type.to_string
+  end
+
+  def get_value
+    @value  
+  end
+
+end
+

data/lib/types/cl_map_type.rb

@@ -0,0 +1,26 @@
+require_relative './cl_type.rb'
+require_relative './constants.rb'
+
+
+class CLMapType < CLType
+  def initialize(value = nil)  
+    super(value)
+    @value = value
+  end
+
+  def to_string
+    TAGS.key(17).to_s
+  end
+
+  def get_value 
+    @value
+  end
+
+  def to_json 
+    to_string
+  end
+
+  def to_bytes
+    [17].pack("C*").unpack1("H*")
+  end
+end

data/lib/types/cl_option.rb

@@ -0,0 +1,33 @@
+require_relative './cl_option_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+=begin
+https://doc.rust-lang.org/stable/std/option/
+=end
+
+class CLOption < CLValue  
+  include CLValueBytesParsers::CLOptionBytesParser
+  
+  def initialize(data = nil, inner_type = nil)
+    super
+    @data =  data
+    @inner_type = inner_type
+    if data == nil && inner_type == nil
+      raise ArgumentError.new("You had to assign innerType for None")
+    elsif data == nil && inner_type != nil
+      @inner_type = inner_type
+    else
+      @inner_type = data.get_cl_type
+    end
+  end
+  
+  def get_value
+    @data
+  end
+
+  def get_cl_type
+   CLOptionType.new(@inner_type)
+   @inner_type
+  end
+end

data/lib/types/cl_option_type.rb

@@ -0,0 +1,52 @@
+require_relative './cl_type.rb'
+require_relative './cl_bool.rb'
+require_relative './cl_bool_type.rb'
+require_relative './constants.rb'
+
+optionTags = {
+  NONE: 0,
+  SOME: 1
+}
+
+class CLOptionType < CLType
+
+  def initialize(inner = nil)
+    @tag = TAGS[:Option]
+    @inner = inner
+    # p @inner.to_string
+    # p @inner.to_json
+    # p @inner.get_tag
+  end
+
+  # @return [String]
+  def to_string
+    @inner == nil ? TAGS.key(13).to_s + " (None)" : TAGS.key(13).to_s + " (#{@inner.to_string})"
+  end
+
+  def to_json
+    jsoned =  { "#{TAGS.key(13)}": @inner.to_string }.to_json
+    # h = JSON.parse(jsoned)
+    # h
+  end
+
+  def get_type
+    TAGS.key(13).to_s
+  end
+
+  def get_inner_type
+    @inner
+  end
+
+  def to_bytes
+    arr = []
+    arr << @tag << @inner.get_tag
+  end
+
+  def self.to_string
+    TAGS.key(13).to_s
+  end
+
+  def to_bytes
+    [13].pack("C*").unpack1("H*")
+  end
+end

data/lib/types/cl_public_key.rb

@@ -0,0 +1,152 @@
+require_relative './cl_public_key_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+require_relative '../utils/base_16.rb'
+require_relative '../utils/hex_utils.rb'
+require_relative '../utils/hash_utils.rb'
+require 'blake2'
+=begin
+PublicKey serializes as a single byte tag representing the algorithm followed by 32 bytes of the PublicKey itself:
+If the PublicKey is an Ed25519 key, the single tag byte is 1 followed by the individual bytes of the serialized key.
+If the PublicKey is a Secp256k1 key, the single tag byte is a 2 followed by the individual bytes of the serialized key.
+=end
+ED25519_LENGTH = 32
+SECP256K1_LENGTH = 33
+
+
+CLPublicKeyTag = {
+  ED25519: 1,
+  SECP256K1: 2
+}
+ 
+ SignatureAlgorithm = {
+  Ed25519: 'ed25519',
+  Secp256K1: 'secp256k1'
+}
+
+
+
+
+class CLPublicKey < CLValue  
+  include CLValueBytesParsers::CLPublicKeyBytesParser
+  include Utils::HashUtils
+  # @param [Array<Integer>] raw_public_key
+  # @param [Integer] tag
+  def initialize(raw_public_key, tag)
+    super()
+    raw_public_key_length_valid?(raw_public_key, tag)
+  end
+
+  def raw_public_key_length_valid?(raw_public_key, tag)
+    if tag == CLPublicKeyTag[:ED25519] || tag == SignatureAlgorithm[:Ed25519]
+      if raw_public_key.length != ED25519_LENGTH
+        raise ArgumentError.new("Wrong length of ED25519 key. Expected #{ED25519_LENGTH}, but got #{raw_public_key.length}")
+      end
+      @raw_public_key = raw_public_key
+      @tag = tag
+    elsif tag == CLPublicKeyTag[:SECP256K1] || tag == SignatureAlgorithm[:Secp256K1]
+      if raw_public_key.length != SECP256K1_LENGTH
+        raise ArgumentError.new("Wrong length of SECP256K1 key. Expected #{SECP256K1_LENGTH}, but got #{raw_public_key.length}")
+      end
+      @raw_public_key = raw_public_key
+      @tag = tag
+    else
+      raise ArgumentError.new("Unsupported type of public key")
+    end
+  end
+
+  def get_cl_type
+    @cl_type = CLPublicKeyType.new
+    @cl_type.to_string
+  end
+
+
+  def get_value
+    @raw_public_key  
+  end
+
+  def get_cl_public_key_tag
+    if @tag == CLPublicKeyTag[:ED25519] || @tag == SignatureAlgorithm[:Ed25519]
+      CLPublicKeyTag[:ED25519]
+    else
+      CLPublicKeyTag[:SECP256K1] 
+    end
+  end
+
+  def get_signature_algorithm
+    if @tag == CLPublicKeyTag[:ED25519] || @tag == SignatureAlgorithm[:Ed25519]
+      SignatureAlgorithm[:Ed25519]
+    else
+      SignatureAlgorithm[:Secp256K1]
+    end
+  end
+
+  def ed25519?
+    @tag == CLPublicKeyTag[:ED25519]
+  end
+
+  def secp256k1?
+    @tag == CLPublicKeyTag[:SECP256K1]
+  end
+
+  # @return [Array<Integer>] 
+  def to_account_hash_byte_array
+    key_name = CLPublicKeyTag.key(@tag).to_s
+    prefix = key_name.downcase.unpack("C*") + [0]
+    bytes = prefix + @raw_public_key
+    result_array = Utils::HashUtils.byte_hash(bytes)
+    @raw_public_key.length == 0 ? [] : result_array
+  end
+
+  # @return [String] hex
+  def to_account_hash_hex
+    bytes = to_account_hash_byte_array
+    hex = Utils::HashUtils.account_hash_from_byte_to_hex(bytes)
+  end
+
+  def from_ed25519(public_key)
+    CLPublicKey.new(public_key, CLPublicKeyTag[:ED25519])
+  end
+
+  def self.from_ed25519(public_key)
+    CLPublicKey.new(public_key, CLPublicKeyTag[:ED25519])
+  end
+
+  def from_secp256k1(public_key)
+    CLPublicKey.new(public_key, CLPublicKeyTag[:SECP256K1])
+  end
+
+  def self.from_secp256k1(public_key)
+    CLPublicKey.new(public_key, CLPublicKeyTag[:SECP256K1])
+  end
+
+  def to_hex
+    # "0#{@tag}#{Utils::Base16.encode16(@raw_public_key)}"
+    "0#{@tag}#{CLValueBytesParsers::CLPublicKeyBytesParser.encode_base_16(@raw_public_key)}"
+  end
+  
+  def from_hex(public_key_hex)
+    raise ArgumentError.new("Invalid public key") unless Utils::HexUtils.valid_public_key_format?(public_key_hex)
+    public_key_hex_bytes = Utils::Base16.decode16(public_key_hex)
+    CLPublicKey.new(public_key_hex_bytes.drop(1), public_key_hex_bytes[0])
+  end
+
+  def self.from_hex(public_key_hex)
+    raise ArgumentError.new("Invalid public key") unless Utils::HexUtils.valid_public_key_format?(public_key_hex)
+    public_key_hex_bytes = Utils::Base16.decode16(public_key_hex)
+    CLPublicKey.new(public_key_hex_bytes.drop(1), public_key_hex_bytes[0])
+  end
+
+  def self.to_json(public_key)
+    json = {"bytes": public_key.to_hex, "cl_type": public_key.get_cl_type}.to_json
+  end
+
+  def self.from_json(json)
+    parsed = JSON.parse(json).deep_symbolize_keys
+    bytes = Utils::Base16.decode16(parsed[:bytes])
+    tag = bytes[0]
+    raw_public_key = bytes[1..]
+    CLPublicKey.new(raw_public_key, tag)
+  end
+
+end

data/lib/types/cl_public_key_type.rb

@@ -0,0 +1,26 @@
+require_relative './cl_type.rb'
+require_relative './constants.rb'
+
+
+class CLPublicKeyType < CLType
+  def initialize(value = nil)  
+    super(value)
+    @value = value
+  end
+
+  def to_string
+    TAGS.key(22).to_s
+  end
+
+  def get_value 
+    @value
+  end
+
+  def to_json 
+    to_string
+  end
+
+  def to_bytes
+    [22].pack("C*").unpack1("H*")
+  end
+end

data/lib/types/cl_result.rb

@@ -0,0 +1,25 @@
+require_relative './cl_result_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+
+
+class CLResult < CLValue  
+  include CLValueBytesParsers::CLResultBytesParser
+ 
+  def initialize(value = nil)
+    super
+    @value =  value
+  end
+
+  def get_cl_type
+    @cl_type = CLResultType.new
+    @cl_type.to_string
+  end
+
+  def get_value
+    @value  
+  end
+
+end
+

data/lib/types/cl_result_type.rb

@@ -0,0 +1,26 @@
+require_relative './cl_type.rb'
+require_relative './constants.rb'
+
+
+class CLResultType < CLType
+  def initialize(value = nil)  
+    super(value)
+    @value = value
+  end
+
+  def to_string
+    TAGS.key(16).to_s
+  end
+
+  def get_value 
+    @value
+  end
+
+  def to_json 
+    to_string
+  end
+
+  def to_bytes
+    [16].pack("C*").unpack1("H*")
+  end
+end

data/lib/types/cl_string.rb

@@ -0,0 +1,39 @@
+require_relative './cl_string_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+
+class CLString < CLValue
+  attr_accessor :cl_value
+  alias_method :clvalue?, :cl_value
+  include CLValueBytesParsers::CLStringBytesParser
+
+  def initialize(value)
+    super()
+    # raise "error" unless value.is_a?(String)
+    raise "error" unless value.instance_of? String
+    @value =  value
+  end
+
+  def get_cl_type
+    @cl_string_type = CLStringType.new
+    @cl_string_type.to_string
+  end
+
+  def get_value
+    @value  
+  end
+
+  def get_size
+    @value.length
+  end
+
+  def self.to_bytes(clvalue)
+    value = clvalue.get_value
+    len = value.length
+    hex1 = len.to_s(16).rjust(8, '0').scan(/../).reverse.join('')
+    hex2 = value.unpack("H*").first
+    hex1 + hex2
+    end
+end
+

data/lib/types/cl_string_type.rb

@@ -0,0 +1,32 @@
+require_relative './cl_type.rb'
+require_relative './constants.rb'
+
+
+class CLStringType < CLType
+
+  def initialize(value = nil)
+    super(value)
+    @value = value
+  end
+
+  def to_string
+    TAGS.key(10).to_s
+  end
+
+  def get_value
+    @value  
+  end
+
+  def to_json
+    to_string
+  end
+
+  def to_bytes
+    [10].pack("C*").unpack1("H*")
+  end
+end
+
+
+
+
+

data/lib/types/cl_tuple.rb

@@ -0,0 +1,151 @@
+require_relative './cl_tuple_type.rb'
+require_relative './cl_value.rb'
+require_relative './error.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+
+
+class CLTuple < CLValue  
+  include CLValueBytesParsers::CLTupleBytesParser
+  attr_accessor :size, :data
+  # before_filter: get_cl_type
+  def initialize(size, data)
+    super()
+    @size = size
+    @data = data
+    @all_members_are_clvalues = data.all? { |item| item.is_a?(CLValue)}
+    @tuple_name = ""
+    if data.size > size && @all_members_are_clvalues
+      begin
+        raise Error.new("Too many elements!")
+      rescue => e
+        e.err
+      end
+    end
+   
+    if @all_members_are_clvalues && data.size == size
+      @size = size
+      @data = data
+    else
+      begin
+        raise Error.new("Invalid data type(s) provided.")
+      rescue => e
+        e.err
+      end
+    end
+    get_full_type
+  end
+
+  def get_full_type
+    if @all_members_are_clvalues
+      if @data.size == @size
+        if @data.size == 1
+          @cl_type = CLTuple1Type.new
+          @tuple_name =  @cl_type.to_string
+          @cl_type.to_string + " (" + @data[0].get_cl_type + ")"
+        elsif @data.size == 2
+          @cl_type = CLTuple2Type.new
+          @tuple_name =  @cl_type.to_string
+          @cl_type.to_string + " (" + @data[0].get_cl_type + ", " + @data[1].get_cl_type + ")"
+        elsif @data.size == 3
+          @cl_type = CLTuple3Type.new
+          @tuple_name =  @cl_type.to_string
+          @cl_type.to_string + " (" + @data[0].get_cl_type + ", " + @data[1].get_cl_type + ", " + @data[2].get_cl_type + ")"
+        else
+          begin
+            raise Error.new("Tuple is not defined!")
+          rescue => e
+            e.err
+          end
+        end          
+      elsif @data.size > size
+        begin
+          raise Error.new("Too many elements!")
+        rescue => e
+          e.err
+        end
+      end
+    else
+      begin
+        raise Error.new("Invalid data type(s) provided.")
+      rescue => e
+        e.err
+      end
+    end
+  end
+
+  def get_tuple_name
+    @tuple_name
+  end
+
+  def get_value
+    @data  
+  end
+
+  def get_size
+    @size
+  end
+
+  def get(index)
+    if index >= @size
+      Error.new("Tuple index out of bounds.")
+    else
+      @data[index]
+    end
+  end
+
+  def set(index, item) 
+    if index >= @size
+      Error.new("Tuple index out of bounds.")
+    else
+      data[index] = item
+    end
+  end
+
+  def push(item)
+    if @data.size < @size
+      @data.push(item)
+    else
+      Error.new("No more space in this tuple!")
+    end
+  end
+
+end
+
+
+class CLTuple1 < CLTuple
+  
+  def initialize(data)
+    super(1, data)
+  end
+
+  def get_cl_type
+    @cl_tuple_type = CLTuple1Type.new
+    @cl_tuple_type.to_string
+  end
+end
+
+class CLTuple2 < CLTuple
+  
+  def initialize(data)
+    super(2, data)
+  end
+
+  def get_cl_type
+    @cl_tuple_type = CLTuple2Type.new
+    @cl_tuple_type.to_string
+  end
+end
+
+class CLTuple3 < CLTuple
+  
+  def initialize(data)
+    super(3, data)
+    # puts data
+  end
+
+  def get_cl_type
+    @cl_tuple_type = CLTuple3Type.new
+    @cl_tuple_type.to_string
+  end
+end