scale_rb 0.4.1 → 0.5.0

data/lib/scale_rb/portable_registry.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# rubocop:disable all
+module ScaleRb
+  class PortableRegistry
+    extend TypeEnforcer
+    include Types
+
+    attr_reader :data, :types
+
+    __ :initialize, { data: TypedArray[HashMap[String, Any]] }
+    def initialize(data)
+      @data = data
+      @types = ::Array.new(@data.size)
+      build_types
+    end
+
+    __ :[], { index: Ti }, PortableType
+    def [](index)
+      @types[index]
+    end
+
+    def inspect
+      "a_portable_registry"
+    end
+
+    private
+
+    __ :build_types, {}
+    def build_types
+      @data.each.with_index do |type, i|
+        id = type._get(:id)
+        raise "Invalid type id: #{id}" if id.nil? || id != i
+
+        def_ = type._get(:type, :def)
+        raise "No 'def' found: #{type}" if def_.nil?
+
+        path = type._get(:type, :path)
+
+        type_name = def_.keys.first.to_sym
+        type_def = def_._get(type_name)
+        @types[id] = _build_type(id, type_name, type_def, path)
+      end
+    end
+
+    # TODO: type_def better type definition
+    __ :_build_type, { id: Ti, type_name: Symbol, type_def: Hash | String | Array, path: TypedArray[String] }, PortableType
+    def _build_type(id, type_name, type_def, path)
+      case type_name
+      when :primitive
+        # type_def: 'I32'
+        PrimitiveType.new(primitive: type_def.to_sym, path: path)
+      when :compact
+        # type_def: { type: 1 }
+        CompactType.new(type: type_def._get(:type), registry: self, path: path)
+      when :sequence
+        # type_def: { type: 9 }
+        SequenceType.new(type: type_def._get(:type), registry: self, path: path)
+      when :bitSequence
+        # type_def: {"bitStoreType"=>2, "bitOrderType"=>502}
+        BitSequenceType.new(
+          bit_store_type: type_def._get(:bitStoreType),
+          bit_order_type: type_def._get(:bitOrderType),
+          registry: self,
+          path: path
+        )
+      when :array
+        # type_def: { len: 3, type: 1 }
+        ArrayType.new(
+          len: type_def._get(:len),
+          type: type_def._get(:type),
+          registry: self,
+          path: path
+        )
+      when :tuple
+        # type_def: [1, 2, 3]
+        TupleType.new(tuple: type_def, registry: self, path: path)
+      when :composite
+        fields = type_def._get(:fields)
+        first_field = fields.first
+
+        # type_def: {"fields"=>[]}
+        return UnitType.new(path: path) if first_field.nil?
+
+        # type_def: {"fields"=>[{"name"=>nil, "type"=>1}, {"name"=>nil, "type"=>2}]}
+        return TupleType.new(tuple: fields.map { |f| f._get(:type) }, registry: self, path: path) unless first_field._get(:name)
+
+        # type_def: { fields: [{ name: 'name', type: 1 }, { name: 'age', type: 2 }] }
+        StructType.new(
+          fields: fields.map do |field|
+            Field.new(name: field._get(:name), type: field._get(:type))
+          end,
+          registry: self,
+          path: path
+        )
+      when :variant
+        variants = type_def._get(:variants)
+
+        # type_def: {"variants"=>[]}
+        return VariantType.new(variants: [], path: path) if variants.empty?
+
+        variant_list = variants.map do |v|
+          fields = v._get(:fields)
+          if fields.empty?
+            # variant: {"name"=>"Vouching", "fields"=>[], "index"=>0, "docs"=>[]}
+            SimpleVariant.new(name: v._get(:name).to_sym, index: v._get(:index))
+          elsif fields.first._get(:name).nil?
+            # variant: {"name"=>"Seal", "fields"=>[{"name"=>nil, "type"=>15, "typeName"=>"ConsensusEngineId", "docs"=>[]}, {"name"=>nil, "type"=>11, "typeName"=>"Vec<u8>", "docs"=>[]}], "index"=>5, "docs"=>[]},
+            TupleVariant.new(
+              name: v._get(:name).to_sym,
+              index: v._get(:index),
+              tuple: TupleType.new(
+                tuple: fields.map { |field| field._get(:type) },
+                registry: self
+              )
+            )
+          else
+            # variant: {"name"=>"ExtrinsicSuccess", "fields"=>[{"name"=>"dispatch_info", "type"=>20, "typeName"=>"DispatchInfo", "docs"=>[]}], "index"=>0, "docs"=>["An extrinsic completed successfully."]},
+            StructVariant.new(
+              name: v._get(:name).to_sym,
+              index: v._get(:index),
+              struct: StructType.new(
+                fields: fields.map { |field| Field.new(name: field._get(:name), type: field._get(:type)) },
+                registry: self
+              )
+            )
+          end
+        end
+        VariantType.new(variants: variant_list, path: path)
+      end
+    end
+  end
+end

data/lib/{storage_helper.rb → scale_rb/storage_helper.rb}

@@ -20,7 +20,7 @@ module ScaleRb
               ]
             else
               [
-                registry[key[:type]]._get(:def)._get(:tuple).first(key[:value].length),
+                registry[key[:type]].tuple.first(key[:value].length),
                 key[:value],
                 key[:hashers].first(key[:value].length)
               ]
@@ -32,12 +32,24 @@ module ScaleRb
             raise "Key's value doesn't match key's type, key's value: #{key_values.inspect}, but key's type: #{key_types.inspect}. Please check your key's value."
           end
 
-          storage_key + PortableCodec._encode_types_with_hashers(key_types, key_values, registry, key_hashers)
+          storage_key + _encode_types_with_hashers(key_types, key_values, registry, key_hashers)
         else
           storage_key
         end
       end
 
+      def _encode_types_with_hashers(type_ids, values, registry, hashers)
+        if !hashers.nil? && hashers.length != type_ids.length
+          raise "type_ids length: #{type_ids.length}, hashers length: #{hashers.length}"
+        end
+
+        type_ids
+          .map.with_index { |type_id, i| ScaleRb::Codec.encode(type_id, values[i], registry) }
+          .each_with_index.reduce([]) do |memo, (bytes, i)|
+            memo + Hasher.apply_hasher(hashers[i], bytes)
+          end
+      end
+
       # data: hex string
       # type: portable type id
       # optional: boolean
@@ -45,14 +57,14 @@ module ScaleRb
       # returns nil or data
       def decode_storage(data, type, optional, fallback, registry)
         data ||= (optional ? nil : fallback)
-        PortableCodec.decode(type, data._to_bytes, registry)[0] if data
+        ScaleRb::Codec.decode(type, Utils.hex_to_u8a(data), registry)[0] if data
       end
 
       # storage_item: the storage item from metadata
       def decode_storage2(data, storage_item, registry)
         modifier = storage_item._get(:modifier) # Default | Optional
         fallback = storage_item._get(:fallback)
-        type = storage_item._get(:type)._get(:plain) || storage_item._get(:type)._get(:map)._get(:value)
+        type = storage_item._get(:type, :plain) || storage_item._get(:type, :map, :value)
         decode_storage(data, type, modifier == 'Optional', fallback, registry)
       end
 

data/lib/scale_rb/types.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+require 'dry-types'
+
+module ScaleRb
+  module Types
+    include Dry.Types()
+
+    Primitive = Types::Strict::Symbol.enum(
+      :I8, :U8, :I16, :U16, :I32, :U32, :I64, :U64, :I128, :U128, :I256, :U256, :Bool, :Str, :Char
+    )
+    Ti = Types::Strict::Integer.constrained(gteq: 0)
+    U8 = Types::Strict::Integer.constrained(gteq: 0, lt: 256)
+    U8Array = Types::Strict::Array.of(U8)
+    Hex = Types::Strict::String.constrained(format: /\A0x[0-9a-fA-F]+\z/)
+
+    Registry = Types.Interface(:[])
+
+    HashMap = lambda do |key_type, value_type|
+      Types::Hash.map(key_type, value_type)
+    end
+    UnsignedInteger = Types::Strict::Integer.constrained(gteq: 0)
+    TypedArray = ->(type) { Types::Array.of(type) }
+
+    class Base < Dry::Struct
+      attribute? :registry, Registry
+      attribute? :path, Types::Strict::Array.of(Types::Strict::String)
+
+      def t(type_id)
+        raise 'No registry' unless registry
+
+        pt = registry[type_id]
+        raise "Unknown type: #{type_id}" unless pt
+
+        pt
+      end
+
+      def to_s
+        to_string
+      end
+
+      MAX_DEPTH = 2
+      def to_string(_depth = 0)
+        raise NotImplementedError, "#{self.class} must implement to_string"
+      end
+    end
+
+    class PrimitiveType < Base
+      attribute :primitive, Primitive
+
+      def to_string(_depth = 0)
+        primitive.to_s
+      end
+    end
+
+    class CompactType < Base
+      attribute? :type, Ti
+
+      def to_string(depth = 0)
+        if type
+          if depth > MAX_DEPTH
+            'Compact<...>'
+          else
+            "Compact<#{t(type).to_string(depth + 1)}>"
+          end
+        else
+          'Compact'
+        end
+      end
+    end
+
+    class SequenceType < Base
+      attribute :type, Ti
+
+      def to_string(depth = 0)
+        if depth > MAX_DEPTH
+          '[...]'
+        else
+          "[#{t(type).to_string(depth + 1)}]"
+        end
+      end
+    end
+
+    class BitSequenceType < Base
+      attribute :bit_store_type, Ti
+      attribute :bit_order_type, Ti
+
+      def to_string(depth = 0)
+        if depth > MAX_DEPTH
+          'BitSequence<...>'
+        else
+          "BitSequence<#{t(bit_store_type).to_string(depth + 1)}, #{t(bit_order_type).to_string(depth + 1)}>"
+        end
+      end
+    end
+
+    class ArrayType < Base
+      attribute :len, Types::Strict::Integer
+      attribute :type, Ti
+
+      def to_string(depth = 0)
+        if depth > MAX_DEPTH
+          '[...]'
+        else
+          "[#{t(type).to_string(depth + 1)}; #{len}]"
+        end
+      end
+    end
+
+    class TupleType < Base
+      attribute :tuple, Types::Strict::Array.of(Ti)
+
+      def to_string(depth = 0)
+        if depth > MAX_DEPTH
+          '(...)'
+        else
+          "(#{tuple.map { |t| t(t).to_string(depth + 1) }.join(', ')})"
+        end
+      end
+    end
+
+    class Field < Dry::Struct
+      attribute :name, Types::Strict::String
+      attribute :type, Ti
+    end
+
+    class StructType < Base
+      attribute :fields, Types::Strict::Array.of(Field)
+
+      def to_string(depth = 0)
+        if depth > MAX_DEPTH
+          '{ ... }'
+        else
+          "{ #{fields.map { |field| "#{field.name}: #{t(field.type).to_string(depth + 1)}" }.join(', ')} }"
+        end
+      end
+    end
+
+    class UnitType < Base
+      def to_string(_depth = 0)
+        '()'
+      end
+    end
+
+    class SimpleVariant < Dry::Struct
+      attribute :name, Types::Strict::Symbol
+      attribute :index, Types::Strict::Integer
+    end
+
+    class TupleVariant < Dry::Struct
+      attribute :name, Types::Strict::Symbol
+      attribute :index, Types::Strict::Integer
+      attribute :tuple, TupleType
+    end
+
+    class StructVariant < Dry::Struct
+      attribute :name, Types::Strict::Symbol
+      attribute :index, Types::Strict::Integer
+      attribute :struct, StructType
+    end
+
+    VariantKind = Instance(SimpleVariant) | Instance(TupleVariant) | Instance(StructVariant)
+
+    class VariantType < Base
+      attribute :variants, Types::Array.of(VariantKind)
+
+      def to_string(depth = 0)
+        if depth > MAX_DEPTH
+          variants.sort_by(&:index).map { |v| v.name.to_s }.join(' | ')
+        else
+          variants.sort_by(&:index).map do |v|
+            case v
+            when SimpleVariant
+              v.name.to_s
+            when TupleVariant
+              "#{v.name}#{v.tuple.to_string(depth + 1)}"
+            when StructVariant
+              "#{v.name} #{v.struct.to_string(depth + 1)}"
+            end
+          end.join(' | ')
+        end
+      end
+
+      def self.option(type, registry)
+        VariantType.new(
+          variants: [
+            SimpleVariant.new(name: :None, index: 0),
+            TupleVariant.new(name: :Some, index: 1, tuple: TupleType.new(tuple: [type], registry:))
+          ],
+          registry:
+        )
+      end
+
+      def option?
+        variants.length == 2 &&
+          variants.any? { |v| v.is_a?(SimpleVariant) && v.name == :None && v.index == 0 } &&
+          variants.any? { |v| v.is_a?(TupleVariant) && v.name == :Some && v.index == 1 }
+      end
+
+      def self.result(ok_type, err_type, registry)
+        VariantType.new(
+          variants: [
+            TupleVariant.new(name: :Ok, index: 0, tuple: TupleType.new(tuple: [ok_type], registry:)),
+            TupleVariant.new(name: :Err, index: 1, tuple: TupleType.new(tuple: [err_type], registry:))
+          ],
+          registry:
+        )
+      end
+    end
+
+    PortableType = Instance(VariantType) |
+                   Instance(StructType) |
+                   Instance(TupleType) |
+                   Instance(ArrayType) |
+                   Instance(CompactType) |
+                   Instance(PrimitiveType) |
+                   Instance(UnitType) |
+                   Instance(SequenceType) |
+                   Instance(BitSequenceType)
+
+    DecodeResult = lambda do |type|
+      Types::Array.of(Types::Any).constrained(size: 2).constructor do |arr|
+        [type[arr[0]], arr[1]] # U8Array[arr[1]], but performance is not good.
+      end
+    end
+  end
+end
+
+# type = ScaleRb::Types::TypedArray[ScaleRb::Types::UnsignedInteger]
+# p type
+# p type[[1, 2]] # => [1, 2]
+# # p type[[-1, -2]] # => -1 violates constraints (gteq?(0, -1) failed)

data/lib/scale_rb/utils.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+class Hash
+  # Check if the key exists in the hash
+  # @param key [String | Symbol] Key to check
+  # @return [Boolean] True if the key exists, false otherwise
+  def _key?(key)
+    ScaleRb::Utils.key?(self, key)
+  end
+
+  # Get the value from the hash
+  # @param keys [Array<String | Symbol>] Keys to get the value from
+  # @return [Object | NilClass] Value if the key exists, nil otherwise
+  def _get(*keys)
+    ScaleRb::Utils.get(self, *keys)
+  end
+end
+
+module ScaleRb
+  module Utils
+    class << self
+      # https://www.rubyguides.com/2017/01/read-binary-data/
+      def hex_to_u8a(str)
+        data = str.start_with?('0x') ? str[2..] : str
+        raise 'Not valid hex string' if data =~ /[^\da-f]+/i
+
+        data = "0#{data}" if data.length.odd?
+        data.scan(/../).map(&:hex)
+      end
+
+      def camelize(str)
+        str.split('_').collect(&:capitalize).join
+      end
+
+      def underscore(str)
+        str.gsub(/::/, '/')
+           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .tr('-', '_')
+           .downcase
+      end
+
+      def int_to_u8a(int, bit_length = nil)
+        hex = bit_length ? int.to_s(16).rjust(bit_length / 4, '0') : int.to_s(16)
+        hex_to_u8a(hex)
+      end
+
+      def uint_to_int(unsigned, bit_length)
+        unsigned_mid = 2**(bit_length - 1)
+        unsigned_ceiling = 2**bit_length
+        unsigned >= unsigned_mid ? unsigned - unsigned_ceiling : unsigned
+      end
+
+      def int_to_uint(signed, bit_length)
+        unsigned_mid = 2**(bit_length - 1)
+        unsigned_ceiling = 2**bit_length
+        raise 'Out of scope' if signed >= unsigned_mid || signed <= -unsigned_mid
+
+        signed.negative? ? unsigned_ceiling + signed : signed
+      end
+
+      # unix timestamp to utc
+      def unix_to_utc(unix)
+        Time.at(unix).utc.asctime
+      end
+
+      # utc to unix timestamp
+      def utc_to_unix(utc_asctime)
+        Time.parse(utc_asctime)
+      end
+
+      def u8a?(arr)
+        arr.all? { |e| e >= 0 && e <= 255 }
+      end
+
+      def u8a_to_hex(u8a)
+        raise 'Not a byte array' unless u8a?(u8a)
+
+        u8a.reduce('0x') { |hex, u8| hex + u8.to_s(16).rjust(2, '0') }
+      end
+
+      def u8a_to_bin(u8a)
+        raise 'Not a byte array' unless u8a?(u8a)
+
+        u8a.reduce('0b') { |bin, u8| bin + u8.to_s(2).rjust(8, '0') }
+      end
+
+      def u8a_to_utf8(u8a)
+        raise 'Not a byte array' unless u8a?(u8a)
+
+        u8a.pack('C*').force_encoding('utf-8')
+      end
+
+      def u8a_to_uint(u8a)
+        u8a_to_hex(u8a).to_i(16)
+      end
+
+      def u8a_to_int(u8a, bit_length)
+        uint_to_int(u8a_to_uint(u8a), bit_length)
+      end
+
+      def key?(hash, key)
+        if key.instance_of?(String)
+          hash.key?(key) || hash.key?(key.to_sym)
+        else
+          hash.key?(key) || hash.key?(key.to_s)
+        end
+      end
+
+      def get(hash, *keys)
+        keys.reduce(hash) do |h, key|
+          break nil unless h.is_a?(Hash)
+
+          if key.instance_of?(String)
+            h[key] || h[key.to_sym]
+          elsif key.instance_of?(Symbol)
+            h[key] || h[key.to_s]
+          else
+            h[key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scale_rb/version.rb

@@ -1,3 +1,3 @@
 module ScaleRb
-  VERSION = '0.4.1'
+  VERSION = '0.5.0'
 end

data/lib/scale_rb.rb

@@ -1,33 +1,7 @@
 # frozen_string_literal: true
 
 require 'scale_rb/version'
-require 'logger'
-
-# scale codec
-require 'monkey_patching'
-require 'codec'
-require 'portable_codec'
-
-# metadata types, decoding and helpers
-require 'metadata/metadata_v9'
-require 'metadata/metadata_v10'
-require 'metadata/metadata_v11'
-require 'metadata/metadata_v12'
-require 'metadata/metadata_v13'
-require 'metadata/metadata_v14'
-require 'metadata/metadata'
-
-require 'hasher'
-require 'storage_helper'
-
-# get registry from config
-require 'registry'
-
-require 'address'
-
-# clients
-require 'client/http_client'
-require 'client/ws_client'
+require 'console'
 
 module ScaleRb
   class << self
@@ -39,6 +13,24 @@ module ScaleRb
   end
 end
 
-logger = Logger.new($stdout)
-logger.level = Logger::INFO
-ScaleRb.logger = logger
+ScaleRb.logger = Console
+
+require 'scale_rb/utils'
+
+require 'type_enforcer'
+
+require 'scale_rb/types'
+require 'scale_rb/portable_registry'
+require 'scale_rb/codec'
+
+require 'scale_rb/metadata/metadata'
+
+require 'scale_rb/hasher'
+require 'scale_rb/storage_helper'
+require 'scale_rb/call_helper'
+
+require 'address'
+
+# clients
+require 'scale_rb/client/http_client'
+require 'scale_rb/client/ws_client'