scale_rb 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51b2e982dba83d910e71a3165d0842a84ff8cf5645c03f4fddfd5fe7c972b369
-  data.tar.gz: 4a4be7435a1821bf40bcdf917a8d148616dae4857c2cbef3d130d7ec4c64bd85
+  metadata.gz: cb19be98106d9f8331a9be9812f6252c23d6913cbd98cedcae34bf1a464e7b90
+  data.tar.gz: cff1e034d85f130ed7d149628647f020adb9ffc532d9646bceda054007d6bf14
 SHA512:
-  metadata.gz: 7bce634b3f620247fcf6dc9bc7737f2835b1e17a1f36f554bb63c83193ba3350377b309095031154d8025fced6d9badcbbda3afd0071101114360bab38872ae4
-  data.tar.gz: cd56d6ceff533df2d6b9a0c21347cb903f65a8dedb3f2b1b0f285a27649ba16f13e84eeb06249a93c7fc234f4c717b29443bb636a97b1a19c127fbc3c7e54633
+  metadata.gz: de658214901aa13071c6b8d0c1aa94c8db0b2cee3c6c1df3207eb0881399c12215ce6c05a7d89c7da115e279a60fbe4688710e5f3fba827d5bd729afb7275e59
+  data.tar.gz: 999f5311c1a66933281798c40bbb3b7956e528b3164c264f2a7694fa48c142683e49ff47a185c1e174501b2e8c3b083d2bd513d1e6c37cffff9002d9186908e4

data/.devcontainer/devcontainer.json

@@ -0,0 +1,21 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-dockerfile
+{
+	"name": "scale_rb",
+	"build": {
+		// Sets the run context to one level up instead of the .devcontainer folder.
+		"context": "..",
+		// Update the 'dockerFile' property if you aren't using the standard 'Dockerfile' filename.
+		"dockerfile": "../Dockerfile"
+	}
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+	// Uncomment the next line to run commands after the container is created.
+	// "postCreateCommand": "cat /etc/os-release",
+	// Configure tool-specific properties.
+	// "customizations": {},
+	// Uncomment to connect as an existing user other than the container default. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "devcontainer"
+}

data/Dockerfile

@@ -0,0 +1,16 @@
+FROM ruby:3.1
+
+# Dependencies
+RUN apt-get update -qq && apt-get install -y build-essential
+RUN curl https://sh.rustup.rs -sSf | bash -s -- -y
+ENV PATH="/root/.cargo/bin:${PATH}"
+
+# Set the working directory
+WORKDIR /scale_rb
+COPY . /scale_rb
+
+# Intall gems
+RUN bundle install
+
+# default command is to run a shell
+CMD ["bash"]

data/Gemfile

@@ -1,8 +1,8 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in scale_rb.gemspec
 gemspec
 
-gem "rake", "~> 12.0"
-gem "rspec", "~> 3.0"
-gem 'rubocop', group: 'development', require: false
+gem 'rake', '~> 12.0'
+gem 'rspec', '~> 3.0'
+gem 'rubocop', group: 'development', require: false

data/README.md

@@ -1,13 +1,11 @@
 # ScaleRb
 
-It is still under heavy development. Use the latest version.
-
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'scale_rb', '~> 0.4.2'
+gem "scale_rb"
 ```
 
 And then execute:
@@ -25,20 +23,34 @@ git clone https://github.com/wuminzhe/scale_rb.git
 cd scale_rb
 bundle install
 bundle exec ruby examples/http_client_1.rb
-# CONSOLE_LEVEL=debug bundle exec ruby examples/http_client_1.rb
 ```
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+### Run devcontainer
+
+Open the project in vscode, then in the command palette, type `Reopen in Container` to open the project in a devcontainer.
+
+![image](https://github.com/user-attachments/assets/39af785c-5570-46df-9e6e-bf816e7f7b68)
+
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+After the devcontainer is opened, you can run the following commands:
+
+1. Tests:
+
+   ```bash
+   bundle exec rspec
+   ```
+
+2. Examples:
+   ```bash
+   bundle exec ruby examples/http_client_1.rb
+   ```
 
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/wuminzhe/scale_rb. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/wuminzhe/scale_rb/blob/master/CODE_OF_CONDUCT.md).
 
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/examples/http_client_2.rb

@@ -14,7 +14,5 @@ def fetch_some_storages(client, block_number)
   puts "Time taken: #{end_time - start_time} seconds"
 end
 
-ScaleRb.logger.level = Logger::DEBUG
-
 client = ScaleRb::HttpClient.new('https://polkadot-rpc.dwellir.com')
 fetch_some_storages(client, 21711742)

data/exe/metadata

@@ -5,13 +5,9 @@ require 'scale_rb'
 require 'json'
 require 'optparse'
 
-def print_metadata(url, at = nil)
-  puts JSON.pretty_generate(ScaleRb::HttpClient.get_metadata(url, at))
-end
-
-# ./bin/metadata http://g2.dev.darwinia.network:2234 -b 0x23ebddd6519aaf1b7fc916c3709af13d7a4010943fb53038406581171000a58e
-# ./bin/metadata https://rpc.darwinia.network -b 10511703
-# ./bin/metadata https://pangoro-rpc.darwinia.network
+# ./exe/metadata https://polkadot-rpc.dwellir.com -b 0xfc2d86c5a2cc92b7770dcc14e74116912c9f848000b5f4ceca6fe1475588692c
+# ./exe/metadata https://polkadot-rpc.dwellir.com -b 22931689
+# ./exe/metadata https://polkadot-rpc.dwellir.com
 @options = {}
 parser = OptionParser.new do |opts|
   opts.banner = 'Usage: metadata [url] [options]'
@@ -26,16 +22,18 @@ else
   parser.parse!
   url = ARGV[0]
 
+  client = ScaleRb::HttpClient.new(url)
+
+  block_hash = nil
   if @options[:block]
     if @options[:block].length == 66
       block_hash = @options[:block]
     else
       block_number = @options[:block].to_i
-      block_hash = ScaleRb::HttpClient.chain_getBlockHash url, block_number
+      block_hash = client.chain_getBlockHash(block_number)
     end
-  else
-    block_hash = ScaleRb::HttpClient.chain_getBlockHash url
   end
 
-  print_metadata url, block_hash
+  metadata = client.get_metadata(block_hash)
+  puts JSON.pretty_generate(metadata)
 end

data/lib/address.rb

@@ -79,7 +79,7 @@ module ScaleRb
                             end
 
         input_bytes = ss58_format_bytes.bytes + pubkey_bytes
-        checksum = Blake2b.hex(SS58_PREFIX.bytes + input_bytes, 64)._to_bytes
+        checksum = Utils.hex_to_u8a(Blake2b.hex(SS58_PREFIX.bytes + input_bytes, 64))
 
         Base58.binary_to_base58((input_bytes + checksum[0...checksum_length]).pack('C*'), :bitcoin)
       end

data/lib/custom_assign.rb

@@ -0,0 +1,92 @@
+def custom_assign(positional_params, keyword_params, args, kwargs = {}, defaults = {})
+  assigned = {}
+
+  # Handle positional arguments (with optional defaults)
+  raise ArgumentError, 'Too many positional arguments' if args.length > positional_params.length
+
+  positional_params.each_with_index do |param, index|
+    if args[index]
+      assigned[param] = args[index] # Assign from args if available
+    elsif args.length == positional_params.length
+      assigned[param] = nil
+    elsif defaults.key?(param)
+      assigned[param] = defaults[param] # Assign default if no argument is provided
+    else
+      raise ArgumentError, "Missing required positional argument: #{param}"
+    end
+  end
+
+  # Handle keyword arguments (with optional defaults)
+  kwargs.each_key do |key|
+    raise ArgumentError, "Unknown keyword argument: #{key}" unless keyword_params.include?(key)
+  end
+
+  keyword_params.each do |key|
+    if kwargs.key?(key)
+      assigned[key] = kwargs[key] # Assign from kwargs if available
+    elsif defaults.key?(key)
+      assigned[key] = defaults[key] # Assign default if not provided
+    else
+      raise ArgumentError, "Missing required keyword argument: #{key}"
+    end
+  end
+
+  # assert_equal(positional_params.length + keyword_params.length, assigned.length)
+  assigned
+end
+
+def get_method_params(method)
+  params = method.parameters
+
+  positional_params = []
+  keyword_params = []
+
+  params.each do |type, name|
+    case type
+    when :req, :opt # Required, optional positional arguments
+      positional_params << name
+    when :key, :keyreq # Keyword arguments
+      keyword_params << name
+    end
+  end
+
+  [positional_params, keyword_params]
+end
+
+def assert_equal(expected, actual)
+  raise "Expected #{expected}, but got #{actual}" unless expected === actual
+end
+
+def build_assigned_params(method, defaults, args, kwargs)
+  positional_params, keyword_params = get_method_params(method)
+  custom_assign(positional_params, keyword_params, args, kwargs, defaults)
+end
+
+# def my_method(a, b = 2, c:, d: 4); end
+
+# defaults = { b: 2, d: 4 }
+
+# # my_method(5, c: 3)
+# p build_assigned_params(:my_method, defaults, 5, c: 3)
+# # => {:a=>5, :b=>2, :c=>3, :d=>4}
+
+# # my_method(5, 6, c: 3)
+# p build_assigned_params(:my_method, defaults, 5, 6, c: 3)
+# # => {:a=>5, :b=>6, :c=>3, :d=>4}
+
+# # my_method(5, 6, c: 3, d: 10)
+# p build_assigned_params(:my_method, defaults, 5, 6, c: 3, d: 10)
+# # => {:a=>5, :b=>6, :c=>3, :d=>10}
+
+# # my_method(5, 6, c: 3, d: 10, e: 11)
+# begin
+#   build_assigned_params(:my_method, defaults, 5, 6, c: 3, d: 10, e: 11)
+# rescue ArgumentError => e
+#   puts e.message # => "Unknown keyword argument: e"
+# end
+
+# begin
+#   build_assigned_params(:my_method, defaults, 5, 6, 7, c: 3, d: 10)
+# rescue ArgumentError => e
+#   puts e.message # => "Too many positional arguments"
+# end

data/lib/scale_rb/call_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ScaleRb
+  module CallHelper
+    # callbytes's structure is: pallet_index + call_index + argsbytes
+    #
+    # callbytes examples:
+    #   "0x0901"._to_bytes
+    #   "0x05000a1287977578f888bdc1c7627781af1cc000e6ab1300004c31b8d9a798"._to_bytes
+    def self.decode_call(callbytes, metadata)
+      pallet_index = callbytes[0]
+      pallet = Metadata.get_module_by_index(pallet_index, metadata)
+
+      # Remove the pallet_index
+      # The callbytes we used below should not contain the pallet index.
+      # This is because the pallet index is not part of the call type.
+      # Its structure is: call_index + call_args
+      callbytes_without_pallet_index = callbytes[1..]
+      calls_type_id = pallet._get(:calls, :type)
+      decoded = Codec.decode(
+        calls_type_id,
+        callbytes_without_pallet_index,
+        Metadata.build_registry(metadata)
+      )&.first
+
+      {
+        pallet_name: pallet._get(:name),
+        call_name: decoded.is_a?(::Hash) ? decoded.keys.first.to_s : decoded.to_s,
+        call: decoded
+      }
+    end
+
+    # call examples:
+    #   {:pallet_name=>"Deposit", :call_name=>"claim", :call=>:claim]}
+    #   {:pallet_name=>"Balances", :call_name=>"transfer", :call=>{:transfer=>{:dest=>[10, 18, 135, 151, 117, 120, 248, 136, 189, 193, 199, 98, 119, 129, 175, 28, 192, 0, 230, 171], :value=>11000000000000000000}}]}
+    def self.encode_call(call, metadata)
+      calls_type_id = Metadata.get_calls_type_id(call[:pallet_name], metadata)
+      pallet_index = Metadata.get_module(call[:pallet_name], metadata)._get(:index)
+      [pallet_index] + Codec.encode(calls_type_id, call[:call], Metadata.build_registry(metadata))
+    end
+  end
+end

data/lib/{client → scale_rb/client}/client_ext.rb

@@ -1,12 +1,11 @@
 module ScaleRb
-
   # This module is used to add extra methods to both the ScaleRb::WsClient ScaleRb::HttpClient
   module ClientExt
     # get decoded metadata at block_hash
     def get_metadata(block_hash = nil)
       block_hash ||= chain_getHead
       metadata_hex = state_getMetadata(block_hash)
-      ScaleRb::Metadata.decode_metadata(metadata_hex.strip._to_bytes)
+      Metadata.decode_metadata(metadata_hex)
     end
 
     # Get decoded storage at block_hash
@@ -39,8 +38,8 @@ module ScaleRb
         item[:changes].map do |change|
           storage_key = change[0]
           data = change[1] || default
-          storage = data.nil? ? nil : PortableCodec.decode(type_id, data._to_bytes, registry)[0]
-          { storage_key: storage_key, storage: storage }
+          storage = data.nil? ? nil : Codec.decode(type_id, Utils.hex_to_u8a(data), registry)[0]
+          { storage_key:, storage: }
         end
       end.flatten
     end
@@ -83,7 +82,7 @@ module ScaleRb
     #   'System',
     #   'Account',
     #   key = {
-    #     value: [['0x724d50824542b56f422588421643c4a162b90b5416ef063f2266a1eae6651641'._to_bytes]], # [AccountId]
+    #     value: [[Utils.hex_to_u8a('0x724d50824542b56f422588421643c4a162b90b5416ef063f2266a1eae6651641')]], # [AccountId]
     #     type: 0,
     #     hashers: ['Blake2128Concat']
     #   },
@@ -101,7 +100,7 @@ module ScaleRb
       if key
         if key[:value].nil? || key[:value].empty?
           # map, but no key's value provided. get all storages under the partial storage key
-          partial_storage_key = StorageHelper.encode_storage_key(pallet_name, item_name)._to_hex
+          partial_storage_key = Utils.u8a_to_hex(StorageHelper.encode_storage_key(pallet_name, item_name))
           get_storages_by_partial_key(
             block_hash,
             partial_storage_key,
@@ -111,7 +110,8 @@ module ScaleRb
           )
         elsif key[:value].length != key[:hashers].length
           # map with multi parts, but not have all values
-          partial_storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, key, registry)._to_hex
+          partial_storage_key = Utils.u8a_to_hex(StorageHelper.encode_storage_key(pallet_name, item_name, key,
+                                                                                  registry))
           get_storages_by_partial_key(
             block_hash,
             partial_storage_key,
@@ -120,12 +120,12 @@ module ScaleRb
             registry
           )
         else
-          storage_key = StorageHelper.encode_storage_key(pallet_name, item_name, key, registry)._to_hex
+          storage_key = Utils.u8a_to_hex(StorageHelper.encode_storage_key(pallet_name, item_name, key, registry))
           data = state_getStorage(storage_key, block_hash)
           StorageHelper.decode_storage(data, value[:type], value[:modifier] == 'Optional', value[:fallback], registry)
         end
       else
-        storage_key = StorageHelper.encode_storage_key(pallet_name, item_name)._to_hex
+        storage_key = Utils.u8a_to_hex(StorageHelper.encode_storage_key(pallet_name, item_name))
         data = state_getStorage(storage_key, block_hash)
         StorageHelper.decode_storage(data, value[:type], value[:modifier] == 'Optional', value[:fallback], registry)
       end
@@ -152,12 +152,12 @@ module ScaleRb
         if plain
           [
             nil,
-            { type: plain, modifier: modifier, fallback: fallback }
+            { type: plain, modifier:, fallback: }
           ]
         elsif map
           [
             { value: params, type: map._get(:key), hashers: map._get(:hashers) },
-            { type: map._get(:value), modifier: modifier, fallback: fallback }
+            { type: map._get(:value), modifier:, fallback: }
           ]
         else
           raise 'NoSuchStorageType'
@@ -175,11 +175,10 @@ module ScaleRb
       if key.is_a?(Integer)
         key.to_i
       elsif key.is_a?(String) && key.start_with?('0x')
-        key._to_bytes
+        Utils.hex_to_u8a(key)
       else
         key
       end
     end
-
   end
 end

data/lib/{client → scale_rb/client}/http_client.rb

@@ -30,7 +30,7 @@ module ScaleRb
       http.use_ssl = @uri.scheme == 'https'
 
       request = Net::HTTP::Post.new(@uri, 'Content-Type' => 'application/json')
-      request.body = { jsonrpc: '2.0', method: method, params: params, id: Time.now.to_i }.to_json
+      request.body = { jsonrpc: '2.0', method:, params:, id: Time.now.to_i }.to_json
       ScaleRb.logger.debug "—→ #{request.body}"
 
       # https://docs.ruby-lang.org/en/master/Net/HTTPResponse.html

data/lib/{client → scale_rb/client}/ws_client.rb

@@ -6,7 +6,6 @@ require_relative 'client_ext'
 
 module ScaleRb
   class WsClient
-
     class << self
       # @param [string] url
       def start(url)
@@ -29,7 +28,7 @@ module ScaleRb
               end
             end
 
-            client.supported_methods = client.rpc_methods()[:methods]
+            client.supported_methods = client.rpc_methods[:methods]
             yield client
 
             recv_task.wait
@@ -37,7 +36,6 @@ module ScaleRb
             recv_task&.stop
           end
         end
-
       end
 
       private
@@ -45,11 +43,10 @@ module ScaleRb
       def parse_message(message)
         message.parse
       rescue StandardError => e
-        Console::Event::Failure.for(e).emit(self, "Parse message failed!")
+        Console::Event::Failure.for(e).emit(self, 'Parse message failed!')
         nil
       end
     end
-
   end
 end
 
@@ -102,9 +99,9 @@ module ScaleRb
     def unsubscribe(method, subscription_id)
       return unless method.include?('unsubscribe')
 
-      if @subscription_handler.unsubscribe(subscription_id)
-        request(method, [subscription_id])
-      end
+      return unless @subscription_handler.unsubscribe(subscription_id)
+
+      request(method, [subscription_id])
     end
 
     def handle_response(response)
@@ -116,14 +113,14 @@ module ScaleRb
         ScaleRb.logger.info "Received an unknown response: #{response}"
       end
     rescue StandardError => e
-      Console::Event::Failure.for(e).emit(self, "Handle response failed!")
+      Console::Event::Failure.for(e).emit(self, 'Handle response failed!')
     end
 
     def read_message
       loop do
         return @connection.read
       rescue StandardError => e
-        Console::Event::Failure.for(e).emit(self, "Read message from connection failed!")
+        Console::Event::Failure.for(e).emit(self, 'Read message from connection failed!')
         sleep 1
         retry
       end
@@ -138,7 +135,7 @@ module ScaleRb
         response_future.resolve(response[:result])
       })
 
-      request = { jsonrpc: '2.0', id: @request_id, method: method, params: params }
+      request = { jsonrpc: '2.0', id: @request_id, method:, params: }
       ScaleRb.logger.debug "—→ #{request}"
       @connection.write(request.to_json)
 
@@ -186,10 +183,9 @@ module ScaleRb
       subscription_id = notification.dig(:params, :subscription)
       return if subscription_id.nil?
 
-      if @callbacks.key?(subscription_id)
-        @callbacks[subscription_id].call(notification)
-      end
+      return unless @callbacks.key?(subscription_id)
+
+      @callbacks[subscription_id].call(notification)
     end
   end
-
 end

data/lib/scale_rb/codec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'decode'
+require_relative 'encode'
+
+module ScaleRb
+  module Codec
+    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 VariantFieldsLengthNotMatch < Error; end
+    class LengthNotEqualErr < Error; end
+    class NotEnoughBytesError < Error; end
+    class Unreachable < Error; end
+    class InvalidBytesError < Error; end
+
+    extend Decode
+    extend Encode
+  end
+end

data/lib/scale_rb/codec_utils.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module ScaleRb
+  module CodecUtils
+    module InternalDecodeUtils
+      extend TypeEnforcer
+      include Types
+
+      __ :decode_uint,
+         { type: String.constrained(format: /\A[Uu]\d+\z/), bytes: U8Array },
+         DecodeResult[UnsignedInteger]
+      def decode_uint(type, bytes)
+        bit_length = type[1..].to_i
+        byte_length = bit_length / 8
+        raise Codec::NotEnoughBytesError, "type: #{type}" if bytes.length < byte_length
+
+        value = Utils.u8a_to_uint(bytes[0...byte_length].reverse)
+        # debug 'value', value
+        [
+          value,
+          bytes[byte_length..]
+        ]
+      end
+
+      __ :decode_int, { type: String.constrained(format: /\A[Ii]\d+\z/), bytes: U8Array }, DecodeResult[Integer]
+      def decode_int(type, bytes)
+        bit_length = type[1..].to_i
+        byte_length = bit_length / 8
+        raise Codec::NotEnoughBytesError, "type: #{type}" if bytes.length < byte_length
+
+        value = Utils.u8a_to_int(bytes[0...byte_length].reverse, bit_length)
+        # debug 'value', value
+        [
+          value,
+          bytes[byte_length..]
+        ]
+      end
+
+      __ :decode_str, { bytes: U8Array }, DecodeResult[String]
+      def decode_str(bytes)
+        length, remaining_bytes = _do_decode_compact(bytes)
+        raise Codec::NotEnoughBytesError, 'type: String' if remaining_bytes.length < length
+
+        [Utils.u8a_to_utf8(remaining_bytes[0...length]), remaining_bytes[length..]]
+      end
+
+      __ :decode_boolean, { bytes: U8Array }, DecodeResult[Bool]
+      def decode_boolean(bytes)
+        value = case bytes[0]
+                when 0x00 then false
+                when 0x01 then true
+                else raise Codec::InvalidBytesError, 'type: Boolean'
+                end
+        [value, bytes[1..]]
+      end
+
+      # TODO: inner type decoding
+      __ :decode_compact, { bytes: U8Array }, DecodeResult[UnsignedInteger]
+      def decode_compact(bytes)
+        _do_decode_compact(bytes)
+      end
+
+      private
+
+      def _do_decode_compact(bytes)
+        case bytes[0] & 3
+        when 0 then [bytes[0] >> 2, bytes[1..]]
+        when 1 then [Utils.u8a_to_uint(bytes[0..1].reverse) >> 2, bytes[2..]]
+        when 2 then [Utils.u8a_to_uint(bytes[0..3].reverse) >> 2, bytes[4..]]
+        when 3
+          length = 4 + (bytes[0] >> 2)
+          [Utils.u8a_to_uint(bytes[1..length].reverse), bytes[length + 1..]]
+        else
+          raise Codec::Unreachable, 'type: Compact'
+        end
+      end
+    end
+
+    module InternalEncodeUtils
+      extend TypeEnforcer
+      include Types
+
+      __ :encode_uint, { type: String.constrained(format: /\A[Uu]\d+\z/), value: Integer }, U8Array
+      def encode_uint(type, value)
+        raise InvalidValueError, "type: #{type}, value: #{value.inspect}" unless value.is_a?(::Integer)
+
+        bit_length = type[1..].to_i
+        Utils.int_to_u8a(value, bit_length).reverse
+      end
+
+      __ :encode_int, { type: String.constrained(format: /\A[Ii]\d+\z/), value: Integer }, U8Array
+      def encode_int(_type, _value)
+        raise NotImplemented, 'encode_int'
+        # raise InvalidValueError, "type: #{type}, value: #{value.inspect}" unless value.is_a?(Integer)
+        #
+        # bit_length = type[1..].to_i
+        # Utils.int_to_u8a(value, bit_length).reverse
+      end
+
+      __ :encode_str, { string: String }, U8Array
+      def encode_str(string)
+        body = string.unpack('C*')
+        encode_compact(body.length) + body
+      end
+
+      __ :encode_boolean, { value: Bool }, U8Array
+      def encode_boolean(value)
+        return [0x00] if value == false
+        return [0x01] if value == true
+
+        raise InvalidValueError, "type: Bool, value: #{value.inspect}"
+      end
+
+      __ :encode_compact, { value: Integer }, U8Array
+      def encode_compact(value)
+        return [value << 2] if value.between?(0, 63)
+        return Utils.int_to_u8a(((value << 2) + 1)).reverse if value < 2**14
+        return Utils.int_to_u8a(((value << 2) + 2)).reverse if value < 2**30
+
+        bytes = Utils.int_to_u8a(value).reverse
+        [(((bytes.length - 4) << 2) + 3)] + bytes
+      end
+    end
+
+    extend InternalDecodeUtils
+    extend InternalEncodeUtils
+  end
+end