scale.rb 0.1.0 → 0.2.0

data/lib/scale/base.rb

@@ -8,8 +8,8 @@ module Scale
         @value = value
       end
 
-      def ==(another)
-        self.value == another.value
+      def ==(other)
+        value == other.value
       end
     end
 
@@ -21,18 +21,18 @@ module Scale
         def decode(scale_bytes)
           byte = scale_bytes.get_next_bytes(1)
           if byte == [0]
-            return self.new(nil)
+            new(nil)
           elsif byte == [1]
-            if self::INNER_TYPE_STR == 'boolean'
-              return self.new(false)
+            if self::INNER_TYPE_STR == "boolean"
+              new(false)
             else
               # big process
-              value = type_of(self::INNER_TYPE_STR).decode(scale_bytes)
-              return self.new(value)
+              value = Scale::Types.get(self::INNER_TYPE_STR).decode(scale_bytes)
+              new(value)
             end
           elsif byte == [2]
-            if self::INNER_TYPE_STR == 'boolean'
-              return self.new(true)
+            if self::INNER_TYPE_STR == "boolean"
+              new(true)
             else
               raise "bad data"
             end
@@ -42,7 +42,7 @@ module Scale
         end
 
         def inner_type(type_str)
-          self.const_set(:INNER_TYPE_STR, type_str)
+          const_set(:INNER_TYPE_STR, type_str)
         end
       end
 
@@ -52,26 +52,54 @@ module Scale
 
       def encode
         # TODO: add Null type
-        if self.value.nil?
+        if value.nil?
           "00"
         else
-          return "02" if self.value.class == TrueClass && self.value === true
-          return "01" if self.value.class == FalseClass && self.value === false
-          "01" + self.value.encode 
+          return "02" if value.class == TrueClass && value === true
+          return "01" if value.class == FalseClass && value === false
+          "01" + value.encode
         end
       end
     end
 
+    module FixedWidthInt
+      include SingleValue
+
+      module ClassMethods
+        def decode(scale_bytes)
+          bit_length = to_s[15..].to_i
+          byte_length = bit_length / 8
+          bytes = scale_bytes.get_next_bytes byte_length
+          value = bytes.reverse.bytes_to_hex.to_i(16).to_signed(bit_length)
+          new(value)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def encode
+        if value.class != ::Integer
+          raise "#{self.class}'s value must be integer"
+        end
+        bit_length = self.class.name[15..].to_i
+        hex = value.to_unsigned(bit_length).to_s(16).hex_to_bytes.reverse.bytes_to_hex
+        hex[2..]
+      end
+    end
+
     module FixedWidthUInt
       include SingleValue
 
       module ClassMethods
+        attr_accessor :byte_length
+
         def decode(scale_bytes)
-          class_name = self.to_s
-          bytes = scale_bytes.get_next_bytes self::BYTES_LENGTH
+          bytes = scale_bytes.get_next_bytes self::BYTE_LENGTH
           bytes_reversed = bytes.reverse
-          hex = bytes_reversed.reduce('0x') { |hex, byte| hex + byte.to_s(16).rjust(2, '0') }
-          self.new(hex.to_i(16))
+          hex = bytes_reversed.reduce("0x") { |hex, byte| hex + byte.to_s(16).rjust(2, "0") }
+          new(hex.to_i(16))
         end
       end
 
@@ -80,7 +108,10 @@ module Scale
       end
 
       def encode
-        bytes = self.value.to_s(16).rjust(self.class::BYTES_LENGTH*2, '0').scan(/.{2}/).reverse.map {|hex| hex.to_i(16) }
+        if value.class != ::Integer
+          raise "#{self.class}'s value must be integer"
+        end
+        bytes = value.to_s(16).rjust(self.class::BYTE_LENGTH * 2, "0").scan(/.{2}/).reverse.map {|hex| hex.to_i(16) }
         bytes.bytes_to_hex[2..]
       end
     end
@@ -92,7 +123,7 @@ module Scale
       module ClassMethods
         def decode(scale_bytes)
           item_values = self::ITEM_TYPE_STRS.map do |item_type_str|
-            type_of(item_type_str).decode(scale_bytes)
+            Scale::Types.get(item_type_str).decode(scale_bytes)
           end
 
           value = {}
@@ -100,25 +131,25 @@ module Scale
             value[attr] = val
           end
 
-          result = self.new(value)
+          result = new(value)
           value.each_pair do |attr, val|
             result.send "#{attr}=", val
           end
-          return result
+          result
         end
 
-        def items(**items)
+        def items(items)
           attr_names = []
           attr_type_strs = []
 
           items.each_pair do |attr_name, attr_type_str|
-            attr_names << attr_name
+            attr_names << attr_name.to_s.gsub("-", "")
             attr_type_strs << attr_type_str
           end
 
-          self.const_set(:ITEM_NAMES, attr_names)
-          self.const_set(:ITEM_TYPE_STRS, attr_type_strs)
-          self.attr_accessor *attr_names
+          const_set(:ITEM_NAMES, attr_names)
+          const_set(:ITEM_TYPE_STRS, attr_type_strs)
+          attr_accessor *attr_names
         end
       end
 
@@ -127,8 +158,8 @@ module Scale
       end
 
       def encode
-        [].tap do |result| 
-          self.value.each_pair do |attr_name, attr_value|
+        [].tap do |result|
+          value.each_pair do |attr_name, attr_value|
             result << attr_value.encode
           end
         end.join
@@ -137,17 +168,17 @@ module Scale
 
     module Tuple
       include SingleValue
-      
+
       module ClassMethods
         def decode(scale_bytes)
           values = self::TYPE_STRS.map do |type_str|
-            type_of(type_str).decode(scale_bytes)
+            Scale::Types.get(type_str).decode(scale_bytes)
           end
-          return self.new(values)
+          new(values)
         end
 
         def inner_types(*type_strs)
-          self.const_set(:TYPE_STRS, type_strs)
+          const_set(:TYPE_STRS, type_strs)
         end
       end
 
@@ -156,7 +187,7 @@ module Scale
       end
 
       def encode
-        self.value.map(&:encode).join
+        value.map(&:encode).join
       end
     end
 
@@ -166,18 +197,17 @@ module Scale
       module ClassMethods
         def decode(scale_bytes)
           index = scale_bytes.get_next_bytes(1)[0]
-          if self.const_defined? "ITEM_NAMES"
+          if const_defined? "ITEM_NAMES"
             item_type_str = self::ITEM_TYPE_STRS[index]
             raise "There is no such member with index #{index} for enum #{self}" if item_type_str.nil?
-            value = type_of(item_type_str).decode(scale_bytes)
-            return self.new(value)
+            value = Scale::Types.get(item_type_str).decode(scale_bytes)
           else
             value = self::VALUES[index]
-            return self.new(value)
           end
+          new(value)
         end
 
-        def items(**items)
+        def items(items)
           attr_names = []
           attr_type_strs = []
 
@@ -186,12 +216,12 @@ module Scale
             attr_type_strs << attr_type_str
           end
 
-          self.const_set(:ITEM_NAMES, attr_names)
-          self.const_set(:ITEM_TYPE_STRS, attr_type_strs)
+          const_set(:ITEM_NAMES, attr_names)
+          const_set(:ITEM_TYPE_STRS, attr_type_strs)
         end
 
         def values(*values)
-          self.const_set(:VALUES, values)
+          const_set(:VALUES, values)
         end
       end
 
@@ -201,11 +231,11 @@ module Scale
 
       def encode
         if self.class.const_defined? "ITEM_NAMES"
-          value_type_str = self.value.class.to_s.split("::").last.to_s
-          index = self::class::ITEM_TYPE_STRS.index(value_type_str).to_s(16).rjust(2, '0')
-          index + self.value.encode
+          value_type_str = value.class.to_s.split("::").last.to_s
+          index = self.class::ITEM_TYPE_STRS.index(value_type_str).to_s(16).rjust(2, "0")
+          index + value.encode
         else
-          self::class::VALUES.index(self.value).to_s(16).rjust(2, '0')
+          self.class::VALUES.index(value).to_s(16).rjust(2, "0")
         end
       end
     end
@@ -214,18 +244,18 @@ module Scale
       include SingleValue # value is an array
 
       module ClassMethods
-        def decode(scale_bytes, raw=false)
+        def decode(scale_bytes, raw = false)
           number = Scale::Types::Compact.decode(scale_bytes).value
           items = []
           number.times do
-            item = type_of(self::INNER_TYPE_STR).decode(scale_bytes)
+            item = Scale::Types.get(self::INNER_TYPE_STR).decode(scale_bytes)
             items << item
           end
-          raw ? items : self.new(items)
+          raw ? items : new(items)
         end
 
         def inner_type(type_str)
-          self.const_set(:INNER_TYPE_STR, type_str)
+          const_set(:INNER_TYPE_STR, type_str)
         end
       end
 
@@ -234,9 +264,9 @@ module Scale
       end
 
       def encode
-        number = Scale::Types::Compact.new(self.value.length).encode
+        number = Scale::Types::Compact.new(value.length).encode
         [number].tap do |result|
-          self.value.each do |element|
+          value.each do |element|
             result << element.encode
           end
         end.join
@@ -248,24 +278,24 @@ module Scale
 
       module ClassMethods
         def decode(scale_bytes)
-          value = "Scale::Types::U#{self::BYTES_LENGTH*8}".constantize.decode(scale_bytes).value
-          return self.new [] if not value || value <= 0
+          value = "Scale::Types::U#{self::BYTES_LENGTH * 8}".constantize.decode(scale_bytes).value
+          return new [] unless value || value <= 0
 
-          result = self::VALUES.select{ |_, mask| value & mask > 0 }.keys
-          return self.new result
+          result = self::ITEMS.select { |_, mask| value & mask > 0 }.keys
+          new result
         end
 
-        # values is a hash:
+        # items is a hash:
         #   {
         #     "TransactionPayment" => 0b00000001,
         #     "Transfer" => 0b00000010,
         #     "Reserve" => 0b00000100,
         #     ...
         #   }
-        def values(values, bytes_length=1)
-          raise "byte length is wrong: #{bytes_length}" if not [1, 2, 4, 8, 16].include?(bytes_length)
-          self.const_set(:VALUES, values)
-          self.const_set(:BYTES_LENGTH, bytes_length)
+        def items(items, bytes_length = 1)
+          raise "byte length is wrong: #{bytes_length}" unless [1, 2, 4, 8, 16].include?(bytes_length)
+          const_set(:ITEMS, items)
+          const_set(:BYTES_LENGTH, bytes_length)
         end
       end
 
@@ -274,8 +304,8 @@ module Scale
       end
 
       def encode
-        value = self.class::VALUES.select{ |str, _| self.value.include?(str) }.values.sum
-        "Scale::Types::U#{self.class::BYTES_LENGTH*8}".constantize.new(value).encode
+        value = self.class::ITEMS.select { |key, _| self.value.include?(key) }.values.sum
+        "Scale::Types::U#{self.class::BYTES_LENGTH * 8}".constantize.new(value).encode
       end
     end
 
@@ -284,17 +314,16 @@ module Scale
 
       module ClassMethods
         def decode(scale_bytes)
-          class_name = self.to_s
-          length = class_name[class_name.length-1]
-          raise "length is wrong: #{length}" if not ["2", "3", "4", "8", "16", "20", "32", "64"].include?(length)
-          length = length.to_i
+          byte_length = name[25..]
+          raise "length is wrong: #{byte_length}" unless %w[2 3 4 8 16 20 32 64].include?(byte_length)
+          byte_length = byte_length.to_i
 
-          bytes = scale_bytes.get_next_bytes(length)
+          bytes = scale_bytes.get_next_bytes(byte_length)
           str = bytes.pack("C*").force_encoding("utf-8")
           if str.valid_encoding?
-            self.new str
+            new str
           else
-            self.new bytes.bytes_to_hex
+            new bytes.bytes_to_hex
           end
         end
       end
@@ -305,14 +334,14 @@ module Scale
 
       def encode
         class_name = self.class.to_s
-        length = class_name[class_name.length-1]
-        raise "length is wrong: #{length}" if not ["2", "3", "4", "8", "16", "20", "32", "64"].include?(length)
+        length = class_name[25..]
+        raise "length is wrong: #{length}" unless %w[2 3 4 8 16 20 32 64].include?(length)
         length = length.to_i
 
-        if self.value.start_with?("0x") && self.value.length == (length*2+2) 
-          self.value[2..]
+        if value.start_with?("0x") && value.length == (length * 2 + 2)
+          value[2..]
         else
-          bytes = self.value.unpack("C*")
+          bytes = value.unpack("C*")
           bytes.bytes_to_hex[2..]
         end
       end

data/lib/scale/block.rb

@@ -0,0 +1,115 @@
+module Scale
+  module Types
+
+    class Extrinsic
+      include SingleValue
+      # attr_accessor :address, :signature, :nonce, :era, :extrinsic_hash, :call_index, :params_raw, :params
+
+      def self.generate_hash(data)
+        Blake2b.hex data, Blake2b::Key.none, 32
+      end
+
+      def self.decode(scale_bytes, metadata)
+        result = {}
+
+        extrinsic_length = Compact.decode(scale_bytes).value
+        # TODO: legacy version
+
+        version_info = scale_bytes.get_next_bytes(1).bytes_to_hex
+        contains_transaction = version_info.to_i(16) >= 80
+
+        if version_info == "0x01" || version_info == "0x81"
+
+          if contains_transaction
+            address = Scale::Types.get("Address").decode(scale_bytes)
+            result[:address] = address.value
+            result[:account_length] = address.account_length
+            result[:account_id] = address.account_id
+            result[:account_index] = address.account_index
+            result[:signature] = Scale::Types.get("Signature").decode(scale_bytes).value
+            result[:nonce] = Scale::Types.get("Compact").decode(scale_bytes).value
+            result[:era] = Scale::Types.get("Era").decode(scale_bytes).value
+            result[:extrinsic_hash] = generate_hash(scale_bytes.bytes)
+          end
+          result[:call_index] = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
+
+        elsif version_info == "0x02" || version_info == "0x82"
+
+          if contains_transaction
+            address = Scale::Types.get("Address").decode(scale_bytes)
+            result[:address] = address.value
+            result[:account_length] = address.account_length
+            result[:account_id] = address.account_id
+            result[:account_index] = address.account_index
+            result[:signature] = Scale::Types.get("Signature").decode(scale_bytes).value
+            result[:era] = Scale::Types.get("Era").decode(scale_bytes).value
+            result[:nonce] = Scale::Types.get("Compact").decode(scale_bytes).value
+            result[:tip] = Scale::Types.get("Compact").decode(scale_bytes).value
+            result[:extrinsic_hash] = generate_hash(scale_bytes.bytes)
+          end
+          result[:call_index] = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
+
+        elsif version_info == "0x03" || version_info == "0x83"
+
+          if contains_transaction
+            address = Scale::Types.get("Address").decode(scale_bytes)
+            result[:address] = address.value
+            result[:account_length] = address.account_length
+            result[:account_id] = address.account_id
+            result[:account_index] = address.account_index
+            result[:signature] = Scale::Types.get("Signature").decode(scale_bytes).value
+            result[:era] = Scale::Types.get("Era").decode(scale_bytes).value
+            result[:nonce] = Scale::Types.get("Compact").decode(scale_bytes).value
+            result[:tip] = Scale::Types.get("Compact").decode(scale_bytes).value
+            result[:extrinsic_hash] = generate_hash(scale_bytes.bytes)
+          end
+          result[:call_index] = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
+
+        elsif version_info == "0x04" || version_info == "0x84"
+
+          if contains_transaction
+            address = Scale::Types.get("Address").decode(scale_bytes)
+            result[:address] = address.value
+            result[:account_length] = address.account_length
+            result[:account_id] = address.account_id
+            result[:account_index] = address.account_index
+            result[:signature_version] = Scale::Types.get("U8").decode(scale_bytes).value
+            result[:signature] = Scale::Types.get("Signature").decode(scale_bytes).value
+            result[:era] = Scale::Types.get("Era").decode(scale_bytes).value
+            result[:nonce] = Scale::Types.get("Compact").decode(scale_bytes).value
+            result[:tip] = Scale::Types.get("Compact").decode(scale_bytes).value
+            result[:extrinsic_hash] = generate_hash(scale_bytes.bytes)
+          end
+          result[:call_index] = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
+
+        else
+          raise "Extrinsics version #{version_info} is not implemented"
+        end
+
+        if result[:call_index]
+          call_module, call = metadata.value.call_index[result[:call_index]]
+
+          result[:call_function] = call[:name].downcase
+          result[:call_module] = call_module[:name].downcase
+
+          # decode params
+          result[:params_raw] = scale_bytes.get_remaining_bytes.bytes_to_hex
+          result[:params] = call[:args].map do |arg|
+            type = Scale::Types.get(arg[:type])
+            arg_obj = type.decode(scale_bytes)
+            {name: arg[:name], type: type.name, value: arg_obj.value, value_raw: "0x#{arg_obj.encode}" }
+          end
+        end
+
+        result[:extrinsic_length] = extrinsic_length
+        result[:version_info] = version_info
+
+        result
+      end
+
+      def encode
+      end
+    end
+
+  end
+end