scale_rb 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d53289f0b86d457c262f850a693fd75c8c007fe6fe6fb716241d30897c7f57c
-  data.tar.gz: 3784af581e51a87e7bdc10d6da633d719189e328f0d373ddfb93f1d120e6a44e
+  metadata.gz: a4ecdacacab52152c1db21cd934b452fca391320112c7a8a1c5a8479b4df9946
+  data.tar.gz: 637a12f9313b048bcd7e5c77dd34862225db553b0e42f620736aea5c78505a49
 SHA512:
-  metadata.gz: a6fa663c9058b64cb9b5f77450cfddf2eac1ddd582ce1c56445d0d255bddd479339b644f95cb436cb53e5e1e46698593dc862e7a6d6e77515ea17798427ec029
-  data.tar.gz: baf73201617384641f980d6aa8d83650edc483a60969c240c78ef935f22fce267b5084e9de30487a5b4a79bc4333f1b240f00003991ded04e3b32c94bca3df9d
+  metadata.gz: 18c6f40b6f41b3fa59a08c93a44b348e94642fe510f695576b164d5b0ad70362bfa0ade33823c422b85b9db55f2f23995598c9990c2a4b7c6e6113cb17b73ba0
+  data.tar.gz: bbb523afb3209dfd58827094cc4f1fce4d841fff5bba5b94538a736edac05803fb0dd3624dcedc5d2c068944614f7d43e053528574df402713f56b9ecb03c2ce

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    scale_rb (0.1.7)
+    scale_rb (0.1.9)
       base58
       blake2b_rs (~> 0.1.4)
       xxhash

data/lib/address.rb

@@ -73,6 +73,8 @@ class Address
 
       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)

data/lib/metadata/metadata.rb

@@ -14,12 +14,86 @@ 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
+
+    def get_call_type(pallet_name, call_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_call_type(pallet_name, call_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,26 @@ module Metadata
           item._get(:name) == item_name
         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
+
+      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_call_type(pallet_name, call_name, metadata)
+        calls_type = get_calls_type(pallet_name, metadata)
+        calls_type._get(:type)._get(:def)._get(:variant)._get(:variants).find do |variant|
+          variant._get(:name).downcase == call_name.downcase
+        end
+      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:
     #   {
@@ -103,7 +112,7 @@ module PortableCodec
     def decode_variant(variant_type, bytes, registry)
       variants = variant_type._get(:variants)
 
-      index = bytes[0]
+      index = bytes[0].to_i # TODO: check
       item = variants.find { |v| v._get(:index) == index } # item is an composite
 
       raise VariantIndexOutOfRange, "type: #{variant_type}, index: #{index}, bytes: #{bytes}" if item.nil?
@@ -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.7'
+  VERSION = '0.1.9'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scale_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.9
 platform: ruby
 authors:
 - Aki Wu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-04-04 00:00:00.000000000 Z
+date: 2023-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: blake2b_rs