scale_rb 0.1.15 → 0.2.2

data/lib/monkey_patching.rb

@@ -2,7 +2,7 @@
 
 # https://www.rubyguides.com/2017/01/read-binary-data/
 class String
-  def to_bytes
+  def _to_bytes
     data = start_with?('0x') ? self[2..] : self
     raise 'Not valid hex string' if data =~ /[^\da-f]+/i
 
@@ -10,11 +10,11 @@ class String
     data.scan(/../).map(&:hex)
   end
 
-  def to_camel
+  def _to_camel
     split('_').collect(&:capitalize).join
   end
 
-  def underscore
+  def _underscore
     gsub(/::/, '/')
       .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
       .gsub(/([a-z\d])([A-Z])/, '\1_\2')
@@ -24,22 +24,22 @@ class String
 end
 
 class Integer
-  def to_bytes(bit_length = nil)
-    return to_s(16).to_bytes unless bit_length
+  def _to_bytes(bit_length = nil)
+    return to_s(16)._to_bytes unless bit_length
 
     hex = to_s(16).rjust(bit_length / 4, '0')
-    hex.to_bytes
+    hex._to_bytes
   end
 
   # unsigned to signed
-  def to_signed(bit_length)
+  def _to_signed(bit_length)
     unsigned_mid = 2**(bit_length - 1)
     unsigned_ceiling = 2**bit_length
     self >= unsigned_mid ? self - unsigned_ceiling : self
   end
 
   # signed to unsigned
-  def to_unsigned(bit_length)
+  def _to_unsigned(bit_length)
     unsigned_mid = 2**(bit_length - 1)
     unsigned_ceiling = 2**bit_length
     raise 'out of scope' if self >= unsigned_mid || self <= -unsigned_mid
@@ -48,48 +48,48 @@ class Integer
   end
 
   # unix timestamp to utc
-  def to_utc
+  def _to_utc
     Time.at(self).utc.asctime
   end
 
   # utc to unix timestamp
-  def from_utc(utc_asctime)
+  def _from_utc(utc_asctime)
     Time.parse(utc_asctime)
   end
 end
 
 class Array
-  def to_hex
-    raise 'Not a byte array' unless byte_array?
+  def _to_hex
+    raise 'Not a byte array' unless _byte_array?
 
     reduce('0x') { |hex, byte| hex + byte.to_s(16).rjust(2, '0') }
   end
 
-  def to_bin
-    raise 'Not a byte array' unless byte_array?
+  def _to_bin
+    raise 'Not a byte array' unless _byte_array?
 
     reduce('0b') { |bin, byte| bin + byte.to_s(2).rjust(8, '0') }
   end
 
-  def to_utf8
-    raise 'Not a byte array' unless byte_array?
+  def _to_utf8
+    raise 'Not a byte array' unless _byte_array?
 
     pack('C*').force_encoding('utf-8')
   end
 
-  def to_uint
-    to_hex.to_i(16)
+  def _to_uint
+    _to_hex.to_i(16)
   end
 
-  def to_int(bit_length)
-    to_uint.to_signed(bit_length)
+  def _to_int(bit_length)
+    _to_uint._to_signed(bit_length)
   end
 
-  def flip
+  def _flip
     reverse
   end
 
-  def byte_array?
+  def _byte_array?
     all? { |e| e >= 0 and e <= 255 }
   end
 end

data/lib/portable_codec.rb

@@ -1,280 +1,284 @@
 # frozen_string_literal: true
 
-module PortableCodec
-  class Error < StandardError; end
-  class TypeNotFound < Error; end
-  class TypeNotImplemented < Error; end
-  class CompositeInvalidValue < Error; end
-  class ArrayLengthNotEqual < Error; end
-  class VariantItemNotFound < Error; end
-  class VariantIndexOutOfRange < Error; end
-  class VariantInvalidValue < Error; end
-
-  class << self
-    def u256(value)
-      bytes = ScaleRb.encode('u256', value)
-      bytes.each_slice(8).map do |slice|
-        ScaleRb.decode('u64', slice).first
+module ScaleRb
+  module PortableCodec
+    class Error < StandardError; end
+    class TypeNotFound < Error; end
+    class TypeNotImplemented < Error; end
+    class CompositeInvalidValue < Error; end
+    class ArrayLengthNotEqual < Error; end
+    class VariantItemNotFound < Error; end
+    class VariantIndexOutOfRange < Error; end
+    class VariantInvalidValue < Error; end
+
+    class << self
+      def u256(value)
+        bytes = ScaleRb.encode('u256', value)
+        bytes.each_slice(8).map do |slice|
+          ScaleRb.decode('u64', slice).first
+        end
       end
     end
-  end
 
-  class << self
-    # registry:
-    #   {
-    #     0 => {
-    #       path: [...],
-    #       params: [...],
-    #       def: {
-    #         primitive: 'u8' | array: {} | ...
-    #       }
-    #     },
-    #     1 => {
-    #       ...
-    #     }
-    #   }
-    def decode(id, bytes, registry)
-      type = registry[id]
-      raise TypeNotFound, "id: #{id}" if type.nil?
-
-      _path = type._get(:path)
-      _params = type._get(:params)
-      type_def = type._get(:def)
-
-      return decode_primitive(type_def, bytes) if type_def._key?(:primitive)
-      return decode_compact(bytes) if type_def._key?(:compact)
-      return decode_array(type_def._get(:array), bytes, registry) if type_def._key?(:array)
-      return decode_sequence(type_def._get(:sequence), bytes, registry) if type_def._key?(:sequence)
-      return decode_tuple(type_def._get(:tuple), bytes, registry) if type_def._key?(:tuple)
-      return decode_composite(type_def._get(:composite), bytes, registry) if type_def._key?(:composite)
-      return decode_variant(type_def._get(:variant), bytes, registry) if type_def._key?(:variant)
-
-      raise TypeNotImplemented, "id: #{id}"
-    end
+    class << self
+      # registry:
+      #   {
+      #     0 => {
+      #       path: [...],
+      #       params: [...],
+      #       def: {
+      #         primitive: 'u8' | array: {} | ...
+      #       }
+      #     },
+      #     1 => {
+      #       ...
+      #     }
+      #   }
+      def decode(id, bytes, registry)
+        type = registry[id]
+        raise TypeNotFound, "id: #{id}" if type.nil?
+
+        _path = type._get(:path)
+        _params = type._get(:params)
+        type_def = type._get(:def)
+
+        return decode_primitive(type_def, bytes) if type_def._key?(:primitive)
+        return decode_compact(bytes) if type_def._key?(:compact)
+        return decode_array(type_def._get(:array), bytes, registry) if type_def._key?(:array)
+        return decode_sequence(type_def._get(:sequence), bytes, registry) if type_def._key?(:sequence)
+        return decode_tuple(type_def._get(:tuple), bytes, registry) if type_def._key?(:tuple)
+        return decode_composite(type_def._get(:composite), bytes, registry) if type_def._key?(:composite)
+        return decode_variant(type_def._get(:variant), bytes, registry) if type_def._key?(:variant)
+
+        raise TypeNotImplemented, "id: #{id}"
+      end
 
-    # Uint, Str, Bool
-    # Int, Bytes ?
-    def decode_primitive(type_def, bytes)
-      primitive = type_def._get(:primitive)
-      return ScaleRb.decode_uint(primitive, bytes) if ScaleRb.uint?(primitive)
-      return ScaleRb.decode_string(bytes) if ScaleRb.string?(primitive)
-      return ScaleRb.decode_boolean(bytes) if ScaleRb.boolean?(primitive)
-      # return ScaleRb.decode_int(primitive, bytes) if int?(primitive)
-      # return ScaleRb.decode_bytes(bytes) if bytes?(primitive)
-    end
+      # Uint, Str, Bool
+      # Int, Bytes ?
+      def decode_primitive(type_def, bytes)
+        primitive = type_def._get(:primitive)
+        return ScaleRb.decode_uint(primitive, bytes) if ScaleRb.uint?(primitive)
+        return ScaleRb.decode_string(bytes) if ScaleRb.string?(primitive)
 
-    def decode_compact(bytes)
-      ScaleRb.decode_compact(bytes)
-    end
+        ScaleRb.decode_boolean(bytes) if ScaleRb.boolean?(primitive)
+        # return ScaleRb.decode_int(primitive, bytes) if int?(primitive)
+        # return ScaleRb.decode_bytes(bytes) if bytes?(primitive)
+      end
 
-    def decode_array(array_type, bytes, registry)
-      len = array_type._get(:len)
-      inner_type_id = array_type._get(:type)
-
-      # check if the type of inner_type_id is a u8
-      if _u8?(inner_type_id, registry)
-        [
-          bytes[0...len].to_hex,
-          bytes[len..]
-        ]
-      else
-        _decode_types([inner_type_id] * len, bytes, registry)
+      def decode_compact(bytes)
+        ScaleRb.decode_compact(bytes)
       end
-    end
 
-    def _u8?(type_id, registry)
-      type = registry[type_id]
-      raise TypeNotFound, "id: #{type_id}" if type.nil?
+      def decode_array(array_type, bytes, registry)
+        len = array_type._get(:len)
+        inner_type_id = array_type._get(:type)
 
-      type._get(:def)._get(:primitive)&.downcase == 'u8'
-    end
+        # check if the type of inner_type_id is a u8
+        if _u8?(inner_type_id, registry)
+          [
+            bytes[0...len]._to_hex,
+            bytes[len..]
+          ]
+        else
+          _decode_types([inner_type_id] * len, bytes, registry)
+        end
+      end
 
-    def decode_sequence(sequence_type, bytes, registry)
-      len, remaining_bytes = decode_compact(bytes)
-      inner_type_id = sequence_type._get(:type)
-      _decode_types([inner_type_id] * len, remaining_bytes, registry)
-    end
+      def _u8?(type_id, registry)
+        type = registry[type_id]
+        raise TypeNotFound, "id: #{type_id}" if type.nil?
 
-    def decode_tuple(tuple_type, bytes, registry)
-      _decode_types(tuple_type, bytes, registry)
-    end
+        type._get(:def)._get(:primitive)&.downcase == 'u8'
+      end
 
-    # {
-    #   name: value,
-    #   ...
-    # }
-    def decode_composite(composite_type, bytes, registry)
-      fields = composite_type._get(:fields)
-
-      # reduce composite level when composite only has one field without name
-      if fields.length == 1 && fields.first._get(:name).nil?
-        decode(fields.first._get(:type), bytes, registry)
-      else
-        type_name_list = fields.map { |f| f._get(:name) }
-        type_id_list = fields.map { |f| f._get(:type) }
-
-        type_value_list, remaining_bytes = _decode_types(type_id_list, bytes, registry)
-        [
-          if type_name_list.all?(&:nil?)
-            type_value_list
-          else
-            [type_name_list.map(&:to_sym), type_value_list].transpose.to_h
-          end,
-          remaining_bytes
-        ]
+      def decode_sequence(sequence_type, bytes, registry)
+        len, remaining_bytes = decode_compact(bytes)
+        inner_type_id = sequence_type._get(:type)
+        _decode_types([inner_type_id] * len, remaining_bytes, registry)
+      end
+
+      def decode_tuple(tuple_type, bytes, registry)
+        _decode_types(tuple_type, bytes, registry)
+      end
+
+      # {
+      #   name: value,
+      #   ...
+      # }
+      def decode_composite(composite_type, bytes, registry)
+        fields = composite_type._get(:fields)
+
+        # reduce composite level when composite only has one field without name
+        if fields.length == 1 && fields.first._get(:name).nil?
+          decode(fields.first._get(:type), bytes, registry)
+        else
+          type_name_list = fields.map { |f| f._get(:name) }
+          type_id_list = fields.map { |f| f._get(:type) }
+
+          type_value_list, remaining_bytes = _decode_types(type_id_list, bytes, registry)
+          [
+            if type_name_list.all?(&:nil?)
+              type_value_list
+            else
+              [type_name_list.map(&:to_sym), type_value_list].transpose.to_h
+            end,
+            remaining_bytes
+          ]
+        end
       end
-    end
 
-    def decode_variant(variant_type, bytes, registry)
-      variants = variant_type._get(:variants)
+      def decode_variant(variant_type, bytes, registry)
+        variants = variant_type._get(:variants)
 
-      index = bytes[0].to_i # TODO: check
-      item = variants.find { |v| v._get(:index) == index } # item is an composite
+        index = bytes[0].to_i # TODO: check
+        item = variants.find { |v| v._get(:index) == index } # item is an composite
 
-      raise VariantIndexOutOfRange, "type: #{variant_type}, index: #{index}, bytes: #{bytes}" if item.nil?
+        raise VariantIndexOutOfRange, "type: #{variant_type}, index: #{index}, bytes: #{bytes}" if item.nil?
 
-      item_name = item._get(:name)
-      item_fields = item._get(:fields)
-      if item_fields.empty?
-        [item_name, bytes[1..]]
-      else
-        item_value, remaining_bytes = decode_composite(item, bytes[1..], registry)
-        [{ item_name.to_sym => item_value }, remaining_bytes]
+        item_name = item._get(:name)
+        item_fields = item._get(:fields)
+        if item_fields.empty?
+          [item_name, bytes[1..]]
+        else
+          item_value, remaining_bytes = decode_composite(item, bytes[1..], registry)
+          [{ item_name.to_sym => item_value }, remaining_bytes]
+        end
       end
-    end
 
-    def _decode_types(ids, bytes, registry = {})
-      ScaleRb._decode_each(ids, bytes) do |id, remaining_bytes|
-        decode(id, remaining_bytes, registry)
+      def _decode_types(ids, bytes, registry = {})
+        ScaleRb._decode_each(ids, bytes) do |id, remaining_bytes|
+          decode(id, remaining_bytes, registry)
+        end
       end
-    end
 
-    def encode_with_hasher(value, type_id, registry, hasher)
-      value_bytes = encode(type_id, value, registry)
-      Hasher.apply_hasher(hasher, value_bytes)
-    end
+      def encode_with_hasher(value, type_id, registry, hasher)
+        value_bytes = encode(type_id, value, registry)
+        Hasher.apply_hasher(hasher, value_bytes)
+      end
 
-    def encode(id, value, registry)
-      type = registry[id]
-      raise TypeNotFound, "id: #{id}" if type.nil?
+      def encode(id, value, registry)
+        type = registry[id]
+        raise TypeNotFound, "id: #{id}" if type.nil?
 
-      type_def = type._get(:def)
-      # debug
-      # p type_def
-      # p value
+        type_def = type._get(:def)
+        # debug
+        # p type_def
+        # p value
 
-      return encode_primitive(type_def, value) if type_def._key?(:primitive)
-      return encode_compact(value) if type_def._key?(:compact)
-      return encode_array(type_def._get(:array), value, registry) if type_def._key?(:array)
-      return encode_sequence(type_def._get(:sequence), value, registry) if type_def._key?(:sequence)
-      return encode_tuple(type_def._get(:tuple), value, registry) if type_def._key?(:tuple)
-      return encode_composite(type_def._get(:composite), value, registry) if type_def._key?(:composite)
-      return encode_variant(type_def._get(:variant), value, registry) if type_def._key?(:variant)
+        return encode_primitive(type_def, value) if type_def._key?(:primitive)
+        return encode_compact(value) if type_def._key?(:compact)
+        return encode_array(type_def._get(:array), value, registry) if type_def._key?(:array)
+        return encode_sequence(type_def._get(:sequence), value, registry) if type_def._key?(:sequence)
+        return encode_tuple(type_def._get(:tuple), value, registry) if type_def._key?(:tuple)
+        return encode_composite(type_def._get(:composite), value, registry) if type_def._key?(:composite)
+        return encode_variant(type_def._get(:variant), value, registry) if type_def._key?(:variant)
 
-      raise TypeNotImplemented, "id: #{id}"
-    end
+        raise TypeNotImplemented, "id: #{id}"
+      end
 
-    def encode_primitive(type_def, value)
-      primitive = type_def._get(:primitive)
-      return ScaleRb.encode_uint(primitive, value) if ScaleRb.uint?(primitive)
-      return ScaleRb.encode_string(value) if ScaleRb.string?(primitive)
-      return ScaleRb.encode_boolean(value) if ScaleRb.boolean?(primitive)
-    end
+      def encode_primitive(type_def, value)
+        primitive = type_def._get(:primitive)
+        return ScaleRb.encode_uint(primitive, value) if ScaleRb.uint?(primitive)
+        return ScaleRb.encode_string(value) if ScaleRb.string?(primitive)
 
-    def encode_compact(value)
-      ScaleRb.encode_compact(value)
-    end
+        ScaleRb.encode_boolean(value) if ScaleRb.boolean?(primitive)
+      end
 
-    def encode_array(array_type, value, registry)
-      length = array_type._get(:len)
-      inner_type_id = array_type._get(:type)
-      raise ArrayLengthNotEqual, "type: #{array_type}, value: #{value.inspect}" if length != value.length
+      def encode_compact(value)
+        ScaleRb.encode_compact(value)
+      end
 
-      _encode_types([inner_type_id] * length, value, registry)
-    end
+      def encode_array(array_type, value, registry)
+        length = array_type._get(:len)
+        inner_type_id = array_type._get(:type)
+        raise ArrayLengthNotEqual, "type: #{array_type}, value: #{value.inspect}" if length != value.length
 
-    def encode_sequence(sequence_type, value, registry)
-      inner_type_id = sequence_type._get(:type)
-      length_bytes = encode_compact(value.length)
-      length_bytes + _encode_types([inner_type_id] * value.length, value, registry)
-    end
+        _encode_types([inner_type_id] * length, value, registry)
+      end
 
-    # tuple_type: [type_id1, type_id2, ...]
-    def encode_tuple(tuple_type, value, registry)
-      _encode_types(tuple_type, value, registry)
-    end
+      def encode_sequence(sequence_type, value, registry)
+        inner_type_id = sequence_type._get(:type)
+        length_bytes = encode_compact(value.length)
+        length_bytes + _encode_types([inner_type_id] * value.length, value, registry)
+      end
 
-    # value:
-    #   {
-    #     name1: value1,
-    #     name2: value2,
-    #     ...
-    #   }
-    #   or
-    #   [value1, value2, ...]
-    def encode_composite(composite_type, value, registry)
-      fields = composite_type._get(:fields)
-      # reduce composite level when composite only has one field without name
-      if fields.length == 1 && fields.first._get(:name).nil?
-        # debug
-        # p fields.first._get(:type)
-        # p value
-        encode(fields.first._get(:type), value, registry)
-      else
-        values =
+      # tuple_type: [type_id1, type_id2, ...]
+      def encode_tuple(tuple_type, value, registry)
+        _encode_types(tuple_type, value, registry)
+      end
+
+      # value:
+      #   {
+      #     name1: value1,
+      #     name2: value2,
+      #     ...
+      #   }
+      #   or
+      #   [value1, value2, ...]
+      def encode_composite(composite_type, value, registry)
+        fields = composite_type._get(:fields)
+        # reduce composite level when composite only has one field without name
+        if fields.length == 1 && fields.first._get(:name).nil?
+          # debug
+          # p fields.first._get(:type)
+          # p value
+          encode(fields.first._get(:type), value, registry)
+        else
+          values =
+            if value.instance_of?(Hash)
+              value.values
+            elsif value.instance_of?(Array)
+              value
+            else
+              raise CompositeInvalidValue, "value: #{value}, only hash and array"
+            end
+
+          type_id_list = fields.map { |f| f._get(:type) }
+          _encode_types(type_id_list, values, registry)
+        end
+      end
+
+      # value:
+      # {
+      #   name: v(Hash)
+      # }
+      # or
+      # the_value(String)
+      def encode_variant(variant_type, value, registry)
+        variants = variant_type._get(:variants)
+
+        name, v = # v: item inner value
           if value.instance_of?(Hash)
-            value.values
-          elsif value.instance_of?(Array)
-            value
+            [value.keys.first.to_s, value.values.first]
+          elsif value.instance_of?(String)
+            [value, {}]
           else
-            raise CompositeInvalidValue, "value: #{value}, only hash and array"
+            raise VariantInvalidValue, "type: #{variant_type}, value: #{value}"
           end
 
-        type_id_list = fields.map { |f| f._get(:type) }
-        _encode_types(type_id_list, values, registry)
-      end
-    end
+        item = variants.find { |var| var._get(:name) == name }
+        raise VariantItemNotFound, "type: #{variant_type}, name: #{name}" if item.nil?
 
-    # value:
-    # {
-    #   name: v(Hash)
-    # }
-    # or
-    # the_value(String)
-    def encode_variant(variant_type, value, registry)
-      variants = variant_type._get(:variants)
-
-      name, v = # v: item inner value
-        if value.instance_of?(Hash)
-          [value.keys.first.to_s, value.values.first]
-        elsif value.instance_of?(String)
-          [value, {}]
-        else
-          raise VariantInvalidValue, "type: #{variant_type}, value: #{value}"
+        # if the variant item has more than one field, the value must be a hash with the same length.
+        # if the variant item has only one field, that means the field is a type id point to a composite. TODO: check the type's fields length
+        if item._get(:fields).length > 1 && item._get(:fields).length != v.length
+          raise VariantFieldsLengthNotMatch,
+                "type: #{variant_type}, \nvalue: #{v}"
         end
 
-      item = variants.find { |var| var._get(:name) == name }
-      raise VariantItemNotFound, "type: #{variant_type}, name: #{name}" if item.nil?
-
-      # if the variant item has more than one field, the value must be a hash with the same length.
-      # if the variant item has only one field, that means the field is a type id point to a composite. TODO: check the type's fields length
-      if item._get(:fields).length > 1 && item._get(:fields).length != v.length
-        raise VariantFieldsLengthNotMatch,
-              "type: #{variant_type}, \nvalue: #{v}"
+        ScaleRb.encode_uint('u8', item._get(:index)) + encode_composite(item, v, registry)
       end
 
-      ScaleRb.encode_uint('u8', item._get(:index)) + encode_composite(item, v, registry)
-    end
-
-    def _encode_types(ids, values, registry)
-      ScaleRb._encode_each(ids, values) do |id, value|
-        encode(id, value, registry)
+      def _encode_types(ids, values, registry)
+        ScaleRb._encode_each(ids, values) do |id, value|
+          encode(id, value, registry)
+        end
       end
-    end
 
-    def _encode_types_with_hashers(ids, values, registry, hashers)
-      ScaleRb._encode_each_with_hashers(ids, values, hashers) do |id, value|
-        encode(id, value, registry)
+      def _encode_types_with_hashers(ids, values, registry, hashers)
+        ScaleRb._encode_each_with_hashers(ids, values, hashers) do |id, value|
+          encode(id, value, registry)
+        end
       end
     end
   end

data/lib/scale_rb/version.rb

@@ -1,3 +1,3 @@
 module ScaleRb
-  VERSION = '0.1.15'
+  VERSION = '0.2.2'
 end

data/lib/scale_rb.rb

@@ -21,7 +21,6 @@ require 'hasher'
 require 'storage_helper'
 
 # client
-require 'client/rpc_request_builder'
 require 'client/http_client'
 require 'client/abstract_ws_client'