casper_network 0.2.0 → 1.0.0

data/lib/types/cl_i32_type.rb

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

data/lib/types/cl_i64.rb

@@ -0,0 +1,26 @@
+require_relative './cl_i64_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+
+
+
+class CLi64 < CLValue  
+  include CLValueBytesParsers::CLI64BytesParser
+ 
+  def initialize(value = nil)
+    raise "error"  unless value.instance_of? Integer
+    super
+    @value =  value
+  end
+
+  def get_cl_type
+    @cl_type = CLI64Type.new
+    @cl_type.to_string
+  end
+
+  def get_value
+    @value  
+  end
+
+end
+

data/lib/types/cl_i64_type.rb

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

data/lib/types/cl_key.rb

@@ -0,0 +1,39 @@
+require_relative './cl_key_type.rb'
+require_relative './cl_value.rb'
+require_relative '../serialization/cl_value_bytes_parsers.rb'
+=begin
+Key values serialize as a single byte tag representing the variant, followed by the serialization of the data that variant contains. 
+For most variants, this is simply a fixed-length 32-byte array. 
+The exception is Key::URef, which contains a URef; so its data serializes per the description above. 
+The tags are as follows: Key::Account serializes as 0, Key::Hash as 1, Key::URef as 2.
+=end
+
+
+KEY_TYPE_ACCOUNT = 0
+KEY_TYPE_HASH    = 1
+KEY_TYPE_UREF    = 2
+
+# ACCOUNT_HASH_ID = 'AccountHash'
+ACCOUNT_HASH_LENGTH = 32
+
+# UREF_ID = 'URef'
+
+class CLKey < CLValue  
+  include CLValueBytesParsers::CLKeyBytesParser
+
+  def initialize(value)
+    super
+    @value =  value
+  end
+
+  def get_cl_type
+    @cl_type = CLKeyType.new
+    @cl_type.to_string
+  end
+
+  def get_value
+    @value  
+  end
+
+end
+

data/lib/types/cl_key_type.rb

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

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
+
+
+
+
+