scale_rb 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c6c07616c5b65f7aee2b0504956231534d94cd3df9eba9320e4a22d2a38aed2
-  data.tar.gz: f2f3572c5d7ed389d5772c6245fb2e02eb75d57cf5ff28b78a8db82642d47402
+  metadata.gz: 241f9857282220d19480bed1cf2a1bcaeacd0948963a65455ee1c57b708ed4d6
+  data.tar.gz: 8ab8fad9f853c7f3d1d57bf9f283b2fbe16a6d17bb2f1221b84ff3a78feff34c
 SHA512:
-  metadata.gz: 1709366a718feafae82a60b5a5aeb05e5e78fbc3160c151de66b2be25e62ad3f6031c50db0097cc1880c00ec263962f45b4cf3fcb6f4ccd0d13ab48ce9b84976
-  data.tar.gz: 231963a7fc17cc7d25ec5aded79120f11733e97d81edf58f4f2fc31edbb11865b435bd286b9817db744d98bad8751433eb68e809d567f9590d5ee70c5687b97d
+  metadata.gz: b712d5a8dc5a9c6c90580467f81939b843e876bc4bbf7f6b53bccbeb12a411e8104acffdfd3419ad70d760c4f375862c09de1b6964c5e4ecf8a92cdc4efdfdb2
+  data.tar.gz: 2b9cb6bb007b0dbff88839e3e811628241290de7383e1f85cfc68ba7a7936ea85d0a479d54035854d18e3cf79685aba1bf8f7f0d7b519ab4089cd75048f0262a

data/Gemfile.lock

@@ -1,13 +1,15 @@
 PATH
   remote: .
   specs:
-    scale_rb (0.1.6)
+    scale_rb (0.1.8)
+      base58
       blake2b_rs (~> 0.1.4)
       xxhash
 
 GEM
   remote: https://rubygems.org/
   specs:
+    base58 (0.2.3)
     blake2b_rs (0.1.4)
       ffi (~> 1.0)
       thermite (~> 0)

data/README.md

@@ -2,9 +2,6 @@
 
 *WARNING: UNDER DEVELOPMENT*
 
-* Only support metadata v14.
-* Http & WebSocket client helper. No Client in this repo.
-
 ## Installation
 
 Add this line to your application's Gemfile:

data/exe/metadata

@@ -6,7 +6,7 @@ require 'json'
 require 'optparse'
 
 def print_metadata(url, at = nil)
-  puts JSON.pretty_generate(HttpClient.get_metadata(url, at))
+  puts JSON.pretty_generate(ScaleRb::HttpClient.get_metadata(url, at))
 end
 
 # ./bin/metadata http://g2.dev.darwinia.network:2234 -b 0x23ebddd6519aaf1b7fc916c3709af13d7a4010943fb53038406581171000a58e
@@ -31,10 +31,10 @@ else
       block_hash = @options[:block]
     else
       block_number = @options[:block].to_i
-      block_hash = HttpClient.chain_getBlockHash url, block_number
+      block_hash = ScaleRb::HttpClient.chain_getBlockHash url, block_number
     end
   else
-    block_hash = HttpClient.chain_getBlockHash url
+    block_hash = ScaleRb::HttpClient.chain_getBlockHash url
   end
 
   print_metadata url, block_hash

data/lib/address.rb

@@ -0,0 +1,97 @@
+require 'base58'
+
+# Warning: Just for test
+class Address
+  SS58_PREFIX = 'SS58PRE'
+
+  TYPES = [
+    # Polkadot Live (SS58, AccountId)
+    0, 1,
+    # Polkadot Canary (SS58, AccountId)
+    2, 3,
+    # Kulupu (SS58, Reserved)
+    16, 17,
+    # Darwinia Live
+    18,
+    # Dothereum (SS58, AccountId)
+    20, 21, 
+    # Generic Substrate wildcard (SS58, AccountId)
+    42, 43,
+
+    # Schnorr/Ristretto 25519 ("S/R 25519") key
+    48,
+    # Edwards Ed25519 key
+    49,
+    # ECDSA SECP256k1 key
+    50,
+
+    # Reserved for future address format extensions.
+    *64..255
+  ]
+
+  class << self
+
+    def array_to_hex_string(arr)
+      body = arr.map { |i| i.to_s(16).rjust(2, '0') }.join
+      "0x#{body}"
+    end
+
+    def decode(address, addr_type = 42, ignore_checksum = true)
+      decoded = Base58.base58_to_binary(address, :bitcoin)
+      is_pubkey = decoded.size == 35
+
+      size = decoded.size - ( is_pubkey ? 2 : 1 )
+
+      prefix = decoded[0, 1].unpack("C*").first
+
+      raise "Invalid address type" unless TYPES.include?(addr_type)
+      
+      hash_bytes = make_hash(decoded[0, size])
+      if is_pubkey
+        is_valid_checksum = decoded[-2].unpack("C*").first == hash_bytes[0] && decoded[-1].unpack("C*").first == hash_bytes[1]
+      else
+        is_valid_checksum = decoded[-1].unpack("C*").first == hash_bytes[0]
+      end
+
+      # raise "Invalid decoded address checksum" unless is_valid_checksum && ignore_checksum
+
+      decoded[1...size].unpack("H*").first
+    end
+
+
+    def encode(pubkey, addr_type = 42)
+      pubkey = pubkey[2..-1] if pubkey =~ /^0x/i
+      key = [pubkey].pack("H*")
+
+      u8_array = key.bytes
+
+      u8_array.unshift(addr_type)
+
+      bytes = make_hash(u8_array.pack("C*"))
+      
+      checksum = bytes[0, key.size == 32 ? 2 : 1]
+
+      u8_array.push(*checksum)
+
+      u8_array = u8_array.map { |i| if i.is_a?(String) then i.to_i(16) else i end }
+      # u8_array = [42, 202, 122, 179, 154, 86, 153, 242, 157, 207, 38, 115, 170, 163, 73, 75, 72, 81, 26, 186, 224, 220, 60, 101, 15, 243, 152, 246, 95, 229, 225, 18, 56, 0x7e]
+      input = u8_array.pack("C*")
+
+      Base58.binary_to_base58(input, :bitcoin)
+    end
+
+    def make_hash(body)
+      Blake2b.hex("#{SS58_PREFIX}#{body}".bytes, 64)
+    end
+
+    def is_ss58_address?(address)
+      begin
+        decode(address)
+      rescue
+        return false
+      end
+      return true
+    end
+
+  end
+end

data/lib/metadata/metadata.rb

@@ -14,12 +14,79 @@ module Metadata
       MetadataV14.build_registry(metadata_v14)
     end
 
+    def get_module(pallet_name, metadata)
+      version = metadata._get(:metadata).keys.first
+      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13 v14].include?(version.to_s)
+
+      Metadata.const_get("Metadata#{version.upcase}").get_module(pallet_name, metadata)
+    end
+
+    def get_module_by_index(pallet_index, metadata)
+      version = metadata._get(:metadata).keys.first
+      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13 v14].include?(version.to_s)
+
+      Metadata.const_get("Metadata#{version.upcase}").get_module_by_index(pallet_index, metadata)
+    end
+
     def get_storage_item(pallet_name, item_name, metadata)
       version = metadata._get(:metadata).keys.first
       raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13 v14].include?(version.to_s)
 
       Metadata.const_get("Metadata#{version.upcase}").get_storage_item(pallet_name, item_name, metadata)
     end
+
+    def get_calls_type(pallet_name, metadata)
+      version = metadata._get(:metadata).keys.first
+      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13 v14].include?(version.to_s)
+
+      Metadata.const_get("Metadata#{version.upcase}").get_calls_type(pallet_name, metadata)
+    end
+
+    def get_calls_type_id(pallet_name, metadata)
+      version = metadata._get(:metadata).keys.first
+      raise ScaleRb::NotImplemented, metadata._get(:metadata).keys.first unless %w[v9 v10 v11 v12 v13 v14].include?(version.to_s)
+
+      Metadata.const_get("Metadata#{version.upcase}").get_calls_type_id(pallet_name, metadata)
+    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 encode_call(call, metadata)
+      calls_type_id = get_calls_type_id(call[:pallet_name], metadata)
+      pallet_index = get_module(call[:pallet_name], metadata)._get(:index)
+      [pallet_index] + PortableCodec.encode(calls_type_id, call[:call].first, build_registry(metadata))
+    end
+
+    # callbytes's structure is: pallet_index + call_index + argsbytes
+    # 
+    # callbytes examples:
+    #   "0x0901".to_bytes
+    #   "0x05000a1287977578f888bdc1c7627781af1cc000e6ab1300004c31b8d9a798".to_bytes
+    def decode_call(callbytes, metadata)
+      pallet_index = callbytes[0]
+      pallet = get_module_by_index(pallet_index, metadata)
+      
+      pallet_name = pallet._get(:name)
+
+      # 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)._get(:type)
+      decoded = PortableCodec.decode(
+        calls_type_id, 
+        callbytes_without_pallet_index, 
+        build_registry(metadata)
+      )
+
+      {
+        pallet_name: pallet_name,
+        call_name: decoded.first.is_a?(String) ? decoded.first.to_camel : decoded.first.keys.first.to_s.to_camel,
+        call: decoded
+      }
+    end
   end
 
   TYPES = {

data/lib/metadata/metadata_v14.rb

@@ -14,6 +14,12 @@ module Metadata
         end
       end
 
+      def get_module_by_index(pallet_index, metadata)
+        metadata._get(:metadata)._get(:v14)._get(:pallets).find do |p|
+          p._get(:index) == pallet_index
+        end
+      end
+
       def get_storage_item(pallet_name, item_name, metadata)
         pallet = get_module(pallet_name, metadata)
         raise "Pallet `#{pallet_name}` not found" if pallet.nil?
@@ -21,6 +27,19 @@ module Metadata
           item._get(:name) == item_name
         end
       end
+
+      def get_calls_type(pallet_name, metadata)
+        type_id = get_calls_type_id(pallet_name, metadata)
+        metadata._get(:metadata)._get(:v14)._get(:lookup)._get(:types).find do |type|
+          type._get(:id) == type_id
+        end
+      end
+
+      def get_calls_type_id(pallet_name, metadata)
+        pallet = get_module(pallet_name, metadata)
+        raise "Pallet `#{pallet_name}` not found" if pallet.nil?
+        pallet._get(:calls)._get(:type)
+      end
     end
 
     TYPES = {

data/lib/portable_codec.rb

@@ -10,6 +10,15 @@ module PortableCodec
   class VariantIndexOutOfRange < Error; end
   class VariantInvalidValue < Error; end
 
+  class << self
+    def u256(value)
+      bytes = ScaleRb.encode('u256', value)
+      bytes.each_slice(8).map do |slice|
+        ScaleRb.decode('u64', slice).first
+      end
+    end
+  end
+
   class << self
     # registry:
     #   {
@@ -171,7 +180,7 @@ module PortableCodec
     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)
+      length_bytes + _encode_types([inner_type_id] * value.length, value, registry)
     end
 
     # tuple_type: [type_id1, type_id2, ...]
@@ -230,7 +239,10 @@ module PortableCodec
 
       item = variants.find { |var| var._get(:name) == name }
       raise VariantItemNotFound, "type: #{variant_type}, name: #{name}" if item.nil?
-      raise VariantInvalidValue, "type: #{variant_type}, v: #{v}" if item._get(:fields).length != v.length
+
+      # if the variant item has more than one field, the value must be a hash with the same length.
+      # if the variant item has only one field, that means the field is a type id point to a composite. TODO: check the type's fields length
+      raise VariantFieldsLengthNotMatch, "type: #{variant_type}, \nvalue: #{v}" if item._get(:fields).length > 1 && item._get(:fields).length != v.length
 
       ScaleRb.encode_uint('u8', item._get(:index)) + encode_composite(item, v, registry)
     end

data/lib/scale_rb/version.rb

@@ -1,3 +1,3 @@
 module ScaleRb
-  VERSION = '0.1.6'
+  VERSION = '0.1.8'
 end

data/lib/scale_rb.rb

@@ -28,6 +28,8 @@ require 'client/abstract_ws_client'
 # get registry from config
 require 'registry'
 
+require 'address'
+
 module ScaleRb
   class << self
     attr_writer :logger

data/scale_rb.gemspec

@@ -28,4 +28,5 @@ Gem::Specification.new do |spec|
   # for hashers
   spec.add_dependency 'blake2b_rs', '~> 0.1.4'
   spec.add_dependency 'xxhash'
+  spec.add_dependency "base58"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scale_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Aki Wu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-04-01 00:00:00.000000000 Z
+date: 2023-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: blake2b_rs
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: base58
+  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
@@ -59,6 +73,7 @@ files:
 - bin/console
 - bin/setup
 - exe/metadata
+- lib/address.rb
 - lib/client/abstract_ws_client.rb
 - lib/client/http_client.rb
 - lib/client/rpc_request_builder.rb