scale_rb 0.4.2 → 0.5.0

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.2'
+  VERSION = '0.5.0'
 end

data/lib/scale_rb.rb

@@ -3,32 +3,6 @@
 require 'scale_rb/version'
 require 'console'
 
-# 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'
-
 module ScaleRb
   class << self
     attr_accessor :logger
@@ -40,3 +14,23 @@ module ScaleRb
 end
 
 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'

data/lib/type_enforcer.rb

@@ -0,0 +1,170 @@
+require_relative 'custom_assign'
+require 'benchmark'
+
+# rubocop:disable all
+module TypeEnforcer
+
+  def self.extended(base)
+    base.instance_variable_set(:@type_enforcements, {})
+    base.instance_variable_set(:@applying_enforcement, false)
+  end
+
+  def __(method_name, param_types, return_type = nil, level: 1, skip: [])
+    return unless type_enforcement_enabled?
+
+    @type_enforcements[method_name] = {
+      params: param_types,
+      return: return_type,
+      level: level,
+      skip: skip
+    }
+  end
+
+  def method_added(method_name)
+    super
+    apply_enforcement(method_name)
+  end
+
+  private
+
+  def apply_enforcement(method_name)
+    return unless type_enforcement_enabled?
+    return if @applying_enforcement
+    return unless @type_enforcements.key?(method_name)
+
+    @applying_enforcement = true
+    begin
+      result = @type_enforcements[method_name]
+      if result[:level] > type_enforcement_level
+        decorate(method_name, result[:params], result[:return], result[:skip])
+      end
+    ensure
+      @applying_enforcement = false
+    end
+  end
+
+  def type_enforcement_enabled?
+    return true if ENV['ENABLE_TYPE_ENFORCEMENT'] && ENV['ENABLE_TYPE_ENFORCEMENT'] == 'true'
+
+    false
+  end
+
+  def type_enforcement_level
+    ENV['TYPE_ENFORCEMENT_LEVEL'].to_i || 2
+  end
+
+  def decorate(method_name, param_types, return_type, skip)
+    target = self
+    original_method = target.instance_method(method_name)
+    method_parameters = original_method.parameters
+
+    # only support positional args and keyword args for now
+    # TODO: support splat(rest), double splat(keyrest) args, and block
+    target.define_method(method_name) do |*args, **kwargs|
+      ScaleRb.logger.debug("----------------------------------------------------------")
+      ScaleRb.logger.debug("method:          #{method_name}")
+      ScaleRb.logger.debug("params:          args: #{args}, kwargs: #{kwargs}")
+      ScaleRb.logger.debug("param kinds:     #{method_parameters}")
+      ScaleRb.logger.debug("param types:     #{param_types}")
+
+      validated_args = []
+      validated_kwargs = {}
+
+      # build a hash of param_name => value | default_value
+      defaults = method_parameters.each_with_object({}) do |(_param_kind, param_name), memo|
+        type = param_types[param_name]
+        memo[param_name] = type.value if type.respond_to?(:value)
+      end
+      assigned_params = build_assigned_params(original_method, defaults, args, kwargs)
+      ScaleRb.logger.debug("assigned params: #{assigned_params}")
+
+      # validate each param
+      method_parameters.each do |param_kind, param_name|
+        case param_kind
+        when :req, :opt
+          value = assigned_params[param_name]
+          if skip.include?(param_name)
+            validated_args << value
+          else
+            type = param_types[param_name]
+            validated_args << type[value]
+          end
+        when :keyreq, :key
+          value = assigned_params[param_name]
+          if skip.include?(param_name)
+            validated_kwargs[param_name] = value
+          else
+            type = param_types[param_name]
+            validated_kwargs[param_name] = type[value]
+          end
+        when :rest, :keyrest
+          raise NotImplementedError, 'rest and keyrest args not supported'
+        end
+      end
+
+      result = original_method.bind(self).call(*validated_args, **validated_kwargs)
+
+      if skip.include?(:returns) && return_type
+        return_type[result]
+      else
+        result
+      end
+    end
+  end
+end
+
+# require 'dry-types'
+
+# module Types
+#   include Dry.Types()
+# end
+
+# class Example
+#   extend TypeEnforcer
+
+#   __ :add, { a: Types::Strict::Integer, b: Types::Strict::Integer }, Types::Strict::Integer
+#   def self.add(a, b)
+#     a + b
+#   end
+
+#   __ :subtract, { a: Types::Strict::Integer, b: Types::Strict::Integer }, Types::Strict::Integer
+#   def subtract(a, b)
+#     a - b
+#   end
+
+#   __ :my_method, {
+#     a: Types::Strict::Integer,
+#     b: Types::Strict::Integer.default(2),
+#     c: Types::Strict::Integer,
+#     d: Types::Strict::Integer.default(4)
+#   }, Types::Strict::String
+#   def my_method(a, b = 2, c:, d: 4)
+#     "a: #{a}, b: #{b}, c: #{c}, d: #{d}"
+#   end
+# end
+
+# puts Example.add(1, 2) # => 3
+
+# puts Example.new.subtract(3, 1) # => 2
+
+# begin
+#   puts Example.new.subtract(3, '1')
+# rescue StandardError => e
+#   puts e.class # => Dry::Types::ConstraintError
+#   puts e.message # => "1" violates constraints (type?(Integer, "1") failed)
+# end
+
+# puts Example.new.my_method(5, c: 3) # => "a: 5, b: 2, c: 3, d: 4"
+# puts Example.new.my_method(5, 6, c: 3) # => "a: 5, b: 6, c: 3, d: 4"
+# puts Example.new.my_method(5, 6, c: 3, d: 10) # => "a: 5, b: 6, c: 3, d: 10"
+# begin
+#   puts Example.new.my_method(5, 6, c: 3, d: '10')
+# rescue StandardError => e
+#   puts e.class # => Dry::Types::ConstraintError
+#   puts e.message # => "10" violates constraints (type?(Integer, "10") failed)
+# end
+# begin
+#   puts Example.new.my_method(5, 6, d: 10)
+# rescue StandardError => e
+#   puts e.message # => Missing required keyword argument: c
+# end

data/scale_rb.gemspec

@@ -40,4 +40,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'async-websocket', '~> 0.26.2'
   # for logger
   spec.add_dependency 'console'
+  # for types restriction
+  spec.add_dependency 'dry-struct'
+  spec.add_dependency 'dry-types'
 end