scale.rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 455155ae80fa2688bd42bf2dfdf5d0206e53ff8a645d2f8b0936bb7657fad3a9
+  data.tar.gz: 60c09397cb38825bfd9e67cfb52a770578e7b9d6b43d6e1db6acecc9af9dac78
+SHA512:
+  metadata.gz: 2a71f2efdfbe7e376bc07c47ad35b9d1768f8b2c97c6047ae16b36ca583fbe75d23937f6e6342c624701bff2fa7f8b2a3118d9d9e5fd3db33571d9133e590713
+  data.tar.gz: 4c165871d267f740ec0f980a3fb88b5a56c0c83d3163b0268279597eec96c7e33a454ad29f9f1f5e4e0cd9e513425aabea148df7b0eee0e3a5191c358a935a90

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.rakeTasks
+/.idea

data/Dockerfile

@@ -0,0 +1,18 @@
+FROM ruby:2.6-alpine3.11
+
+ENV BUILD_PACKAGES curl-dev build-base
+
+RUN echo "http://mirrors.ustc.edu.cn/alpine/v3.11/main/" > /etc/apk/repositories && \
+    apk update && \
+    apk upgrade && \
+    apk add git $BUILD_PACKAGES
+
+WORKDIR /usr/src/app
+
+COPY . .
+RUN gem sources --add https://gems.ruby-china.com/ --remove https://rubygems.org/ && \
+    gem install bundler:1.17.3 && \
+    bundle config mirror.https://rubygems.org https://gems.ruby-china.com && \
+    bundle install
+
+CMD ["sh"]

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in scale.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,49 @@
+PATH
+  remote: .
+  specs:
+    scale.rb (0.1.0)
+      substrate_common.rb (~> 0.1.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    base58 (0.2.3)
+    blake2b (0.10.0)
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    method_source (0.9.2)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (13.0.1)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.0)
+      rspec-support (~> 3.9.0)
+    rspec-expectations (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.0)
+    substrate_common.rb (0.1.3)
+      base58
+      blake2b
+      xxhash
+    xxhash (0.4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  pry
+  rake (~> 13.0)
+  rspec (~> 3.2)
+  scale.rb!
+
+BUNDLED WITH
+   1.17.3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Wu Minzhe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,149 @@
+![grants_badge](./grants_badge.png)
+
+# scale.rb
+
+**Ruby SCALE Codec Library and Substrate Json-rpc Api Client.**
+
+SCALE is a lightweight, efficient, binary serialization and deserialization codec used by substrate. Most of the input and output data of the substrate API are encoded in SCALE data format. 
+
+This is a SCALE codec library and substrate json-rpc api client implemented in ruby language for general use. It contains the implementation of low-level data formats, various substrate types, metadata support and json-rpc client.
+
+This work is the prerequisite of our subsequent series of projects. We hope to familiarize and quickly access Polkadot and Substrate through ruby. We plan to develop the back end of our applications in ruby language, and then interact with nodes or synchronize data through this library.
+
+Please refer to the [official doc](https://substrate.dev/docs/en/overview/low-level-data-format) for more details about SCALE low-level data format.
+
+Because the feature of ruby 2.6 is used, the ruby version is required to be >= 2.6. it will be compatible with older ruby versions when released.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'scale.rb'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install scale
+
+## Usage
+
+1. decode
+
+```ruby
+require "scale"
+
+# decode a compact integer
+scale_bytes = Scale::Bytes.new("0x1501") # create scale_bytes object from scale encoded hex string
+o = Scale::Types::Compact.decode(scale_bytes) # use scale type to decode scale_bytes object
+p o.value # 69
+```
+
+2. encode
+
+```ruby
+require "scale"
+
+o = Scale::Types::Compact.new(69)
+p o.encode # "1501"
+```
+Please go to `spec` dir for more examples.
+
+## Types supported
+
+scale.rb now support types:
+
+- [x] Compact
+- [x] Bool
+- [x] U8, U16, U32, U64, U128
+- [x] Enum
+- [x] Option
+- [x] Struct
+- [x] Tuple
+- [x] Vec
+- [x] Set
+- [x] Bytes
+- [x] Hex
+- [x] String
+- [x] H160, H256, H512
+- [x] AccountId
+- [x] Balance
+- [x] BalanceOf
+- [x] BlockNumber
+- [x] AccountIndex
+- [x] Era
+
+## Running tests
+
+1. Download or clone the code to local, and enter the code root directory
+2. Run all tests
+
+```
+rspec
+```
+
+2. Run low level format tests
+
+```
+rspec spec/low_level_spec.rb
+```
+
+
+## Docker
+
+1. update to latest image
+
+   `docker pull itering/scale`
+
+2. Run image:
+
+   `docker run -it itering/scale`
+
+   This  will enter the container with a linux shell opened. 
+
+   ```shell
+   /usr/src/app # 
+   ```
+
+3. Type `rspec` to run all tests
+
+   ```shell
+   /usr/src/app # rspec
+   ...................
+   
+   Finished in 0.00883 seconds (files took 0.09656 seconds to load)
+   19 examples, 0 failures
+   ```
+
+4. Or type `./bin/console` to enter the ruby interactive environment and run any decode or encode code
+
+   ```shell
+   /usr/src/app # ./bin/console
+   [1] pry(main)> scale_bytes = Scale::Bytes.new("0x1501")
+   => #<Scale::Bytes:0x000055daa883ba70 @bytes=[21, 1], @data="0x1501", @offset=0>
+   [2] pry(main)> o = Scale::Types::Compact.decode(scale_bytes)
+   => #<Scale::Types::Compact:0x000055daa89b0db0 @value=69>
+   [3] pry(main)> p o.value
+   69
+   => 69
+   [4] pry(main)>
+   ```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/itering/scale.rb.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "scale"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start
+
+# require "irb"
+# IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/metadata/metadata.rb

@@ -0,0 +1,127 @@
+module Scale
+  module Types
+
+    class Metadata
+      include SingleValue
+      def self.decode(scale_bytes)
+        bytes = scale_bytes.get_next_bytes(4)
+        if bytes.bytes_to_utf8 == 'meta'
+          metadata_v_name = type_of("Enum", enum_values: [
+            "Scale::Types::MetadataV0", 
+            "Scale::Types::MetadataV1", 
+            "Scale::Types::MetadataV2", 
+            "Scale::Types::MetadataV3",
+            "Scale::Types::MetadataV4",
+            "Scale::Types::MetadataV5",
+            "Scale::Types::MetadataV6",
+            "Scale::Types::MetadataV7",
+            "Scale::Types::MetadataV8",
+            "Scale::Types::MetadataV9",
+            "Scale::Types::MetadataV10"
+          ]).decode(scale_bytes).value
+
+          Metadata.new(metadata_v_name.constantize.decode(scale_bytes).value)
+        end
+      end
+    end
+
+    class MetadataModule
+      include SingleValue
+      def self.decode(scale_bytes)
+        name = String.decode(scale_bytes).value
+        prefix = String.decode(scale_bytes).value
+
+        result = {
+          name: name,
+          prefix: prefix
+        }
+
+        has_storage = Bool.decode(scale_bytes).value
+        if has_storage
+          storages = type_of("Vec<MetadataModuleStorage>").decode(scale_bytes).value
+          result[:storage] = storages.map(&:value)
+        end
+
+        has_calls = Bool.decode(scale_bytes).value
+        if has_calls
+          calls = type_of("Vec<MetadataModuleCall>").decode(scale_bytes).value
+          result[:calls] = calls.map(&:value)
+        end
+
+        has_events = Bool.decode(scale_bytes).value
+        if has_events
+          events = type_of("Vec<MetadataModuleEvent>").decode(scale_bytes).value
+          result[:events] = events.map(&:value)
+        end
+
+        MetadataModule.new(result)
+      end
+    end
+
+    class MetadataModuleStorage
+      include SingleValue
+      def self.decode(scale_bytes)
+
+        result = {
+          name: String.decode(scale_bytes).value,
+          modifier: type_of("Enum", enum_values: ["Optional", "Default"]).decode(scale_bytes).value
+        }
+
+        is_key_value = Bool.decode(scale_bytes).value
+        if is_key_value
+          result[:type] = {
+            Map: {
+              key: adjust(String.decode(scale_bytes).value),
+              value: adjust(String.decode(scale_bytes).value),
+              linked: Bool.decode(scale_bytes).value
+            }
+          }
+        else
+          result[:type] = {
+            Plain: adjust(String.decode(scale_bytes).value)
+          }
+        end
+
+        result[:fallback] = Hex.decode(scale_bytes).value
+        result[:documentation] = type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+
+        MetadataModuleStorage.new(result)
+      end
+    end
+
+    class MetadataModuleCall
+      include SingleValue
+      def self.decode(scale_bytes)
+        result = {}
+        result[:name] = String.decode(scale_bytes).value
+        result[:args] = type_of("Vec<MetadataModuleCallArgument>").decode(scale_bytes).value.map(&:value)
+        result[:documentation] = type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+        MetadataModuleCall.new(result)
+      end
+    end
+
+    class MetadataModuleCallArgument
+      include SingleValue
+      def self.decode(scale_bytes)
+        result = {}
+        result[:name] = String.decode(scale_bytes).value
+        result[:type] = adjust(String.decode(scale_bytes).value)
+
+        MetadataModuleCallArgument.new(result)
+      end
+    end
+
+    class MetadataModuleEvent
+      include SingleValue
+      def self.decode(scale_bytes)
+        result = {}
+        result[:name] = String.decode(scale_bytes).value
+        result[:args] = type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+        result[:documentation] = type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+
+        MetadataModuleEvent.new(result)
+      end
+    end
+
+  end
+end

data/lib/metadata/metadata_v10.rb

@@ -0,0 +1,22 @@
+module Scale
+  module Types
+
+    class MetadataV10
+      include SingleValue
+      def self.decode(scale_bytes)
+        modules = type_of("Vec<MetadataV8Module>").decode(scale_bytes).value;
+        result = {
+          magicNumber: 1635018093,
+          metadata: {
+            V10: {
+              modules: modules.map(&:value)
+            }
+          }
+        }
+
+        MetadataV10.new(result)
+      end
+    end
+
+  end
+end

data/lib/metadata/metadata_v3.rb

@@ -0,0 +1,22 @@
+module Scale
+  module Types
+
+    class MetadataV3
+      include SingleValue
+      def self.decode(scale_bytes)
+        modules = type_of("Vec<MetadataModule>").decode(scale_bytes).value;
+        result = {
+          magicNumber: 1635018093,
+          metadata: {
+            V3: {
+              modules: modules.map(&:value)
+            }
+          }
+        }
+
+        MetadataV3.new(result)
+      end
+    end
+
+  end
+end

data/lib/metadata/metadata_v7.rb

@@ -0,0 +1,123 @@
+module Scale
+  module Types
+
+    class MetadataV7
+      include SingleValue
+      def self.decode(scale_bytes)
+        modules = type_of("Vec<MetadataV7Module>").decode(scale_bytes).value;
+        result = {
+          magicNumber: 1635018093,
+          metadata: {
+            V7: {
+              modules: modules.map(&:value)
+            }
+          }
+        }
+
+        MetadataV7.new(result)
+      end
+    end
+
+    class MetadataV7Module
+      include SingleValue
+      def self.decode(scale_bytes)
+        name = String.decode(scale_bytes).value
+
+        result = {
+          name: name,
+        }
+
+        has_storage = Bool.decode(scale_bytes).value
+        if has_storage
+          storage = MetadataV7ModuleStorage.decode(scale_bytes).value
+          result[:storage] = storage
+          result[:prefix] = storage[:prefix]
+        end
+
+        has_calls = Bool.decode(scale_bytes).value
+        if has_calls
+          calls = type_of("Vec<MetadataModuleCall>").decode(scale_bytes).value
+          result[:calls] = calls.map(&:value)
+        end
+
+        has_events = Bool.decode(scale_bytes).value
+        if has_events
+          events = type_of("Vec<MetadataModuleEvent>").decode(scale_bytes).value
+          result[:events] = events.map(&:value)
+        end
+
+        result[:constants] = type_of("Vec<MetadataV7ModuleConstants>").decode(scale_bytes).value.map(&:value)
+
+        MetadataV7Module.new(result)
+      end
+    end
+
+    class MetadataV7ModuleStorage
+      include SingleValue
+      def self.decode(scale_bytes)
+        prefix = String.decode(scale_bytes).value
+        items = type_of("Vec<MetadataV7ModuleStorageEntry>").decode(scale_bytes).value.map(&:value)
+        result = {
+          prefix: prefix,
+          items: items
+        }
+
+        MetadataV7ModuleStorage.new(result)
+      end
+    end
+
+    class MetadataV7ModuleStorageEntry
+      include SingleValue
+      def self.decode(scale_bytes)
+        result = {
+          name: String.decode(scale_bytes).value,
+          modifier: type_of("Enum", enum_values: ["Optional", "Default"]).decode(scale_bytes).value
+        }
+        storage_function_type = type_of("Enum", enum_values: ["Plain", "Map", "DoubleMap"]).decode(scale_bytes).value
+        if storage_function_type == "Plain"
+          result[:type] = {
+            Plain: adjust(String.decode(scale_bytes).value)
+          }
+        elsif storage_function_type == "Map"
+          result[:type] = {
+            Map: {
+              hasher: StorageHasher.decode(scale_bytes).value,
+              key: adjust(String.decode(scale_bytes).value),
+              value: adjust(String.decode(scale_bytes).value),
+              linked: Bool.decode(scale_bytes).value
+            }
+          }
+        elsif storage_function_type == "DoubleMap"
+          result[:type] = {
+            DoubleMap: {
+              hasher: StorageHasher.decode(scale_bytes).value,
+              key1: adjust(String.decode(scale_bytes).value),
+              key2: adjust(String.decode(scale_bytes).value),
+              value: adjust(String.decode(scale_bytes).value),
+              key2Hasher: StorageHasher.decode(scale_bytes).value
+            }
+          }
+        end
+
+        result[:fallback] = Hex.decode(scale_bytes).value
+        result[:docs] = type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+
+        MetadataV7ModuleStorageEntry.new(result)
+      end
+    end
+
+    class MetadataV7ModuleConstants
+      include SingleValue
+      def self.decode(scale_bytes)
+        result = {
+          name: String.decode(scale_bytes).value,
+          type: String.decode(scale_bytes).value, # convert
+          value: Hex.decode(scale_bytes).value,
+          docs: type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+        }
+        MetadataV7ModuleConstants.new result
+      end
+    end
+
+  end
+end

data/lib/metadata/metadata_v8.rb

@@ -0,0 +1,69 @@
+module Scale
+  module Types
+
+    class MetadataV8
+      include SingleValue
+      def self.decode(scale_bytes)
+        modules = type_of("Vec<MetadataV8Module>").decode(scale_bytes).value;
+        result = {
+          magicNumber: 1635018093,
+          metadata: {
+            V8: {
+              modules: modules.map(&:value)
+            }
+          }
+        }
+
+        MetadataV8.new(result)
+      end
+    end
+
+    class MetadataV8Module
+      include SingleValue
+      def self.decode(scale_bytes)
+        name = String.decode(scale_bytes).value
+
+        result = {
+          name: name,
+        }
+
+        has_storage = Bool.decode(scale_bytes).value
+        if has_storage
+          storage = MetadataV7ModuleStorage.decode(scale_bytes).value
+          result[:storage] = storage
+          result[:prefix] = storage[:prefix]
+        end
+
+        has_calls = Bool.decode(scale_bytes).value
+        if has_calls
+          calls = type_of("Vec<MetadataModuleCall>").decode(scale_bytes).value
+          result[:calls] = calls.map(&:value)
+        end
+
+        has_events = Bool.decode(scale_bytes).value
+        if has_events
+          events = type_of("Vec<MetadataModuleEvent>").decode(scale_bytes).value
+          result[:events] = events.map(&:value)
+        end
+
+        result[:constants] = type_of("Vec<MetadataV7ModuleConstants>").decode(scale_bytes).value.map(&:value)
+        result[:errors] = type_of("Vec<MetadataModuleError>").decode(scale_bytes).value.map(&:value)
+
+        MetadataV8Module.new(result)
+      end
+    end
+
+    class MetadataModuleError
+      include SingleValue
+      def self.decode(scale_bytes)
+        result = {
+          name: String.decode(scale_bytes).value,
+          docs: type_of("Vec<String>").decode(scale_bytes).value.map(&:value)
+        }
+
+        MetadataModuleError.new(result)
+      end
+    end
+
+  end
+end

data/lib/metadata/metadata_v9.rb

@@ -0,0 +1,22 @@
+module Scale
+  module Types
+
+    class MetadataV9
+      include SingleValue
+      def self.decode(scale_bytes)
+        modules = type_of("Vec<MetadataV8Module>").decode(scale_bytes).value;
+        result = {
+          magicNumber: 1635018093,
+          metadata: {
+            V9: {
+              modules: modules.map(&:value)
+            }
+          }
+        }
+
+        MetadataV9.new(result)
+      end
+    end
+
+  end
+end