scale_rb 0.1.0

data/lib/monkey_patching.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# https://www.rubyguides.com/2017/01/read-binary-data/
+class String
+  def to_bytes
+    data = start_with?('0x') ? self[2..] : self
+    raise 'Not valid hex string' if data =~ /[^\da-f]+/i
+
+    data = "0#{data}" if data.length.odd?
+    data.scan(/../).map(&:hex)
+  end
+
+  def to_camel
+    split('_').collect(&:capitalize).join
+  end
+
+  def underscore
+    gsub(/::/, '/')
+      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .tr('-', '_')
+      .downcase
+  end
+end
+
+class Integer
+  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
+  end
+
+  # unsigned to signed
+  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)
+    unsigned_mid = 2**(bit_length - 1)
+    unsigned_ceiling = 2**bit_length
+    raise 'out of scope' if self >= unsigned_mid || self <= -unsigned_mid
+
+    negative? ? unsigned_ceiling + self : self
+  end
+
+  # unix timestamp to utc
+  def to_utc
+    Time.at(self).utc.asctime
+  end
+
+  # utc to unix timestamp
+  def from_utc(utc_asctime)
+    Time.parse(utc_asctime)
+  end
+end
+
+class 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?
+
+    reduce('0b') { |bin, byte| bin + byte.to_s(2).rjust(8, '0') }
+  end
+
+  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)
+  end
+
+  def to_int(bit_length)
+    to_uint.to_signed(bit_length)
+  end
+
+  def flip
+    reverse
+  end
+
+  def byte_array?
+    all? { |e| e >= 0 and e <= 255 }
+  end
+end
+
+class Hash
+  def _key?(key)
+    if key.instance_of?(String)
+      key?(key) || key?(key.to_sym)
+    else
+      key?(key) || key?(key.to_s)
+    end
+  end
+
+  def _get(key)
+    if key.instance_of?(String)
+      self[key] || self[key.to_sym]
+    else
+      self[key] || self[key.to_s]
+    end
+  end
+end

data/lib/portable_codec.rb

@@ -0,0 +1,251 @@
+# 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
+    # 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 uint?(primitive)
+      return ScaleRb.decode_string(bytes) if string?(primitive)
+      return ScaleRb.decode_boolean(bytes) if boolean?(primitive)
+      # return ScaleRb.decode_int(primitive, bytes) if int?(primitive)
+      # return ScaleRb.decode_bytes(bytes) if bytes?(primitive)
+    end
+
+    def decode_compact(bytes)
+      ScaleRb.decode_compact(bytes)
+    end
+
+    def decode_array(array_type, bytes, registry)
+      len = array_type._get(:len)
+      inner_type_id = array_type._get(:type)
+      _decode_types([inner_type_id] * len, bytes, registry)
+    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 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)
+
+      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
+
+    def decode_variant(variant_type, bytes, registry)
+      variants = variant_type._get(:variants)
+
+      index = bytes[0]
+      if index > (variants.length - 1)
+        raise VariantIndexOutOfRange,
+              "type: #{variant_type}, index: #{index}, bytes: #{bytes}"
+      end
+
+      item_variant = variants.find { |v| v._get(:index) == index }
+      item_name = item_variant._get(:name)
+      item, remaining_bytes = decode_composite(item_variant, bytes[1..], registry)
+
+      [
+        item.empty? ? item_name : { item_name.to_sym => item },
+        remaining_bytes
+      ]
+    end
+
+    def _decode_types(ids, bytes, registry = {})
+      if ids.empty?
+        [[], bytes]
+      else
+        value, remaining_bytes = decode(ids.first, bytes, registry)
+        value_list, remaining_bytes = _decode_types(ids[1..], remaining_bytes, registry)
+        [[value] + value_list, remaining_bytes]
+      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(id, value, registry)
+      type = registry[id]
+      raise TypeNotFound, "id: #{id}" if type.nil?
+
+      type_def = type._get(:def)
+
+      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
+
+    def encode_primitive(type_def, value)
+      primitive = type_def._get(:primitive)
+      return ScaleRb.encode_uint(primitive, value) if uint?(primitive)
+      return ScaleRb.encode_string(value) if string?(primitive)
+      return ScaleRb.encode_boolean(value) if boolean?(primitive)
+    end
+
+    def encode_compact(value)
+      ScaleRb.encode_compact(value)
+    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
+
+      _encode_types([inner_type_id] * length, 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] * array.length, value, registry)
+    end
+
+    # 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)
+      values =
+        if value.instance_of?(Hash)
+          value.values
+        elsif value.instance_of?(Array)
+          value
+        else
+          raise CompositeInvalidValue, "value: #{value}, only hash and array"
+        end
+
+      fields = composite_type._get(:fields)
+      type_id_list = fields.map { |f| f._get(:type) }
+      _encode_types(type_id_list, values, registry)
+    end
+
+    # value:
+    # {
+    #   name: the_value(Hash)
+    # }
+    # or
+    # the_value(String)
+    def encode_variant(variant_type, value, registry)
+      variants = variant_type._get(:variants)
+
+      if value.instance_of?(Hash)
+        name = value.keys.first.to_s
+        the_value = value.values.first
+      elsif value.instance_of?(String)
+        name = value
+        the_value = {}
+      else
+        raise VariantInvalidValue, "type: #{variant_type}, value: #{value}"
+      end
+
+      variant = variants.find { |v| v[:name] == name }
+      raise VariantItemNotFound, "type: #{variant_type}, name: #{name}" if variant.nil?
+
+      ScaleRb.encode_uint('u8', variant._get(:index)) + encode_composite(variant, the_value, registry)
+    end
+
+    def _encode_types(ids, values, registry)
+      _encode_types_without_merge(ids, values, registry).flatten
+    end
+
+    def _encode_types_with_hashers(values, type_ids, registry, hashers)
+      if !hashers.nil? && hashers.length != type_ids.length
+        raise ScaleRb::LengthNotEqualErr, "type_ids length: #{type_ids.length}, hashers length: #{hashers.length}"
+      end
+
+      bytes_array = _encode_types_without_merge(type_ids, values, registry)
+      bytes_array.each_with_index.reduce([]) do |memo, (bytes, i)|
+        memo + Hasher.apply_hasher(hashers[i], bytes)
+      end
+    end
+
+    # return: [value1_bytes, value2_bytes, ...]
+    def _encode_types_without_merge(ids, values, registry)
+      raise ScaleRb::LengthNotEqualErr, "types: #{ids}, values: #{values.inspect}" if ids.length != values.length
+
+      ids.map.with_index do |type_id, i|
+        encode(type_id, values[i], registry)
+      end
+    end
+  end
+end

data/lib/registry.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ScaleRb
+  # A `registry` is a ruby Hash object, key is the type name, value is the type definition or mapped type name.
+  # A `config` contains the complete versioned type definition for a network.
+  # https://github.com/polkadot-js/api/blob/master/packages/types-known/src/spec/polkadot.ts
+  def self.build_registry_from_config(config, spec_version)
+    version = config[:versioned].find do |item|
+      item[:minmax].include?(spec_version)
+    end
+    config[:shared_types].merge(version.nil? ? {} : version[:types])
+  end
+end

data/lib/scale_rb/version.rb

@@ -0,0 +1,3 @@
+module ScaleRb
+  VERSION = "0.1.0"
+end

data/lib/scale_rb.rb

@@ -0,0 +1,39 @@
+# 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'
+require 'metadata_v14'
+
+require 'hasher'
+require 'storage_helper'
+
+# client
+require 'client/rpc'
+require 'client/client'
+
+# get registry from config
+require 'registry'
+
+module ScaleRb
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger ||= Logger.new($stdout)
+      @logger.level = Logger::INFO
+      @logger
+    end
+
+    def debug(key, value)
+      logger.debug "#{key.rjust(15)}: #{value}"
+    end
+  end
+end

data/lib/storage_helper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module StorageHelper
+  class << self
+    # params:
+    #   pallet_name: module name
+    #   method_name: storage name
+    #   params: {
+    #     values: values,
+    #     type_ids: type_ids,
+    #     hashers: hashers,
+    #   }
+    #   registry: portable_types_registry
+    def encode_storage_key(pallet_name, method_name, params = nil, registry = nil)
+      pallet_method_key = Hasher.twox128(pallet_name) + Hasher.twox128(method_name)
+
+      if params.nil?
+        pallet_method_key
+      else
+        values = params[:values]
+        type_ids = params[:type_ids]
+        hashers = params[:hashers]
+
+        pallet_method_key + PortableCodec._encode_types_with_hashers(values, type_ids, registry, hashers)
+      end
+    end
+
+    def build_params(param_values, storage_key_type_id, hashers, registry)
+      type_ids = registry._get(storage_key_type_id)._get(:def)._get(:tuple)
+      type_ids = [storage_key_type_id] if type_ids.nil?
+      {
+        values: param_values,
+        type_ids: type_ids,
+        hashers: hashers
+      }
+    end
+  end
+end

data/scale_rb.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/scale_rb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'scale_rb'
+  spec.version       = ScaleRb::VERSION
+  spec.authors       = ['Aki Wu']
+  spec.email         = ['wuminzhe@gmail.com']
+
+  spec.summary       = 'New Ruby SCALE Codec Library'
+  spec.description   = 'Ruby implementation of the parity SCALE data format'
+  spec.homepage      = 'https://github.com/wuminzhe/scale_rb'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.6.0')
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # for hashers
+  spec.add_dependency 'blake2b_rs', '~> 0.1.2'
+  spec.add_dependency 'xxhash'
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: scale_rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aki Wu
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: blake2b_rs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: xxhash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby implementation of the parity SCALE data format
+email:
+- wuminzhe@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/metadata
+- bin/setup
+- lib/client/client.rb
+- lib/client/rpc.rb
+- lib/codec.rb
+- lib/hasher.rb
+- lib/metadata.rb
+- lib/metadata_v14.rb
+- lib/monkey_patching.rb
+- lib/portable_codec.rb
+- lib/registry.rb
+- lib/scale_rb.rb
+- lib/scale_rb/version.rb
+- lib/storage_helper.rb
+- scale_rb.gemspec
+homepage: https://github.com/wuminzhe/scale_rb
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/wuminzhe/scale_rb
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: New Ruby SCALE Codec Library
+test_files: []