scale.rb 0.2.9 → 0.2.15

data/lib/scale/trie.rb

@@ -0,0 +1,171 @@
+module Scale
+  module Types
+    
+    class TrieNode
+      include SingleValue
+      EMPTY = 0
+      NIBBLE_PER_BYTE = 2
+      BITMAP_LENGTH = 2
+      NIBBLE_LENGTH = 16
+      NIBBLE_SIZE_BOUND = 65535
+
+      def self.decode(scale_bytes)
+        hash = "0x#{Crypto::blake2_256(scale_bytes.bytes)}"
+        first = scale_bytes.get_next_bytes(1).first
+        if first == EMPTY
+          TrieNode.new({})
+        else
+          v = first & (0b11 << 6)
+          decode_size = -> {
+            result = first & 255 >> 2
+            return result if result < 63
+            result -= 1
+            while result <= NIBBLE_SIZE_BOUND
+              n = scale_bytes.get_next_bytes(1).first
+              return (result + n + 1) if n < 255 
+              result += 255
+            end
+            return NIBBLE_SIZE_BOUND
+          }
+
+          if v == 0b01 << 6 # leaf
+            nibble_count = decode_size.call
+            # if nibble_count is odd, the half of first byte of partial is 0
+            padding = (nibble_count % NIBBLE_PER_BYTE) != 0 
+            first_byte_of_partial = scale_bytes.bytes[scale_bytes.offset]
+            if padding && (first_byte_of_partial & 0xf0) != 0
+              raise "bad format"
+            end
+
+            ### partial decoding
+            partial_bytes = scale_bytes.get_next_bytes((nibble_count + (NIBBLE_PER_BYTE - 1)) / NIBBLE_PER_BYTE)
+
+            ### value
+            count = Compact.decode(scale_bytes).value
+            value_bytes = scale_bytes.get_next_bytes(count)
+
+            return TrieNode.new({
+              hash: hash,
+              node_type: "leaf",
+              partial: {
+                hex: partial_bytes.bytes_to_hex, 
+                padding: padding
+              },
+              value: value_bytes.bytes_to_hex
+            })
+          elsif v == 0b10 << 6 || v == 0b11 << 6 # branch without mask || branch with mask
+            nibble_count = decode_size.call
+
+            ### check that the padding is valid (if any)
+            # if nibble_count is odd, the half of first byte of partial is 0
+            padding = nibble_count % NIBBLE_PER_BYTE != 0
+            first_byte_of_partial = scale_bytes.bytes[scale_bytes.offset]
+            if padding && (first_byte_of_partial & 0xf0) != 0 
+              raise "bad format"
+            end
+
+            ### partial decoding
+            partial_bytes = scale_bytes.get_next_bytes((nibble_count + (NIBBLE_PER_BYTE - 1)) / NIBBLE_PER_BYTE)
+
+            ### value decoding
+            if v == 0b11 << 6 # has value
+              count = Compact.decode(scale_bytes).value
+              value_bytes = scale_bytes.get_next_bytes(count)
+            end
+
+            ### children decoding
+            children = []
+            bitmap = U16.decode(scale_bytes).value
+            NIBBLE_LENGTH.times do |i|
+              has_child = (bitmap & (1 << i)) != 0
+              children[i] = nil
+              if has_child
+                count = Compact.decode(scale_bytes).value
+                if count == 32
+                  h = H256.decode(scale_bytes).value
+                  children[i] = h
+                else
+                  inline = scale_bytes.get_next_bytes count
+                  children[i] = inline.bytes_to_hex
+                end
+              end
+            end
+            # debug
+            # children.each_with_index do |child, i|
+            #   if child.nil?
+            #     puts "#{i}: NULL" 
+            #   else
+            #     puts "#{i}: #{child}"
+            #   end
+            # end
+
+            result = TrieNode.new({
+              hash: hash,
+              node_type: "branch",
+              partial: {
+                hex: partial_bytes.bytes_to_hex, 
+                padding: padding
+              },
+              children: children
+            })
+
+            result[:value] = value_bytes.bytes_to_hex if value_bytes
+
+            return result
+          else
+            puts "Not support"
+          end
+
+        end
+      end
+
+      def self.check(root, proof, key)
+        key = Key.new(key)
+
+        nodes = proof.map {|node_data| 
+          node = TrieNode::decode(Scale::Bytes.new(node_data)).value
+          [node[:hash], node]
+        }.to_h
+
+        self.do_check(root, nodes, key)
+      end
+
+      private
+      def self.do_check(hash, nodes, key)
+        if node = nodes[hash]
+          if node[:children]
+            position = key.next_nibble(node[:partial][:hex], node[:partial][:padding]).to_i(16)
+            child = node[:children][position]
+            return self.do_check(child, nodes, key)
+          else
+            return node[:value]
+          end
+        else
+          raise "Fail"
+        end
+      end
+    end
+
+  end
+end
+
+class Key
+  def initialize(value)
+    @value = value[2..] if value.start_with?("0x")
+    @offset = 0
+  end
+
+  def next_nibble(partial, padding)
+    partial = partial[2..] if partial.start_with?("0x")
+    partial = partial[1..] if padding
+
+    new_offset = @offset + partial.length
+    if partial == @value[@offset...new_offset]
+      nibble = @value[new_offset]
+      @offset = new_offset + 1
+      return nibble
+    else
+      raise "Fail"
+    end
+  end
+end

data/lib/scale/types.rb

@@ -225,59 +225,71 @@ module Scale
       end
     end
 
-    class Address
+    class GenericAddress
       include SingleValue
-      attr_accessor :account_length, :account_index, :account_id, :account_idx
 
+      # https://github.com/paritytech/substrate/wiki/External-Address-Format-(SS58)
+      # base58encode ( concat ( <address-type>, <address>, <checksum> ) )
+      #                                         ^^^^^^^^^
+      # the <address> is 32 byte account id or 1, 2, 4, 8 byte account index
+      # scale_bytes: account length byte  + <address>'s bytes
       def self.decode(scale_bytes)
         account_length = scale_bytes.get_next_bytes(1).first
 
-        if account_length == 0xff # 255
+        if account_length == 0xff # 32 bytes address(Public key)
           account_id = scale_bytes.get_next_bytes(32).bytes_to_hex
-          account_length = account_length.to_s(16)
-          Address.new(account_id)
+          account_length = [account_length].bytes_to_hex
+
+          Address.new({
+            account_id: account_id,
+            account_length: account_length
+          })
         else
           account_index =
-            if account_length == 0xfc
+            if account_length == 0xfc # 2 bytes address(account index)
               scale_bytes.get_next_bytes(2).bytes_to_hex
-            elsif account_length == 0xfd
+            elsif account_length == 0xfd # 4 bytes address(account index)
               scale_bytes.get_next_bytes(4).bytes_to_hex
-            elsif account_length == 0xfe
+            elsif account_length == 0xfe # 8 bytes address(account index)
               scale_bytes.get_next_bytes(8).bytes_to_hex
             else
               [account_length].bytes_to_hex
             end
-          # account_idx = 
-          account_length = account_length.to_s(16)
-          Address.new(account_index)
+          # TODO: add account_idx 
+          account_length = [account_length].bytes_to_hex
+
+          Address.new({
+            account_index: account_index,
+            account_length: account_length
+          })
         end
       end
 
-      def encode(ss58=false, addr_type=42)
-        if value.start_with?("0x")
-          if ss58 === true
-            ::Address.encode(value, addr_type)
-          else
-            prefix = if value.length == 66
-              "ff"
-            elsif value.length == 6
-              "fc"
-            elsif value.length == 10
-              "fd"
-            elsif value.length == 18
-              "fe"
-            else
-              ""
-            end
-            "#{prefix}#{value[2..]}"
-          end
+      def encode
+        if self.value[:account_id]
+          "#{self.value[:account_length][2..]}#{self.value[:account_id][2..]}"
         else
-          raise "Format error"
+          "#{self.value[:account_length][2..]}#{self.value[:account_index][2..]}"
         end
       end
     end
 
-    class RawAddress < Address; end
+    class Address < GenericAddress; end
+
+    class RawAddress < GenericAddress; end
+
+    class AccountIdAddress < GenericAddress
+      def self.decode(scale_bytes)
+        AccountIdAddress.new({
+          account_id: AccountId.decode(scale_bytes).value,
+          account_length: "0xff"
+        })
+      end
+
+      def encode
+        "ff#{self.value[:account_id][2..]}"
+      end
+    end
 
     class AccountId < H256; end
 
@@ -558,34 +570,52 @@ module Scale
 
     class VecU8Length2
       include VecU8FixedLength
+      BYTE_LENGTH = 2
     end
 
     class VecU8Length3
       include VecU8FixedLength
+      BYTE_LENGTH = 3
     end
 
     class VecU8Length4
       include VecU8FixedLength
+      BYTE_LENGTH = 4
     end
 
     class VecU8Length8
       include VecU8FixedLength
+      BYTE_LENGTH = 8
     end
 
     class VecU8Length16
       include VecU8FixedLength
+      BYTE_LENGTH = 16
     end
 
     class VecU8Length20
       include VecU8FixedLength
+      BYTE_LENGTH = 20
     end
 
     class VecU8Length32
       include VecU8FixedLength
+      BYTE_LENGTH = 32
     end
 
     class VecU8Length64
       include VecU8FixedLength
+      BYTE_LENGTH = 64
+    end
+
+    class VecU8Length128
+      include VecU8FixedLength
+      BYTE_LENGTH = 128
+    end
+
+    class VecU8Length256
+      include VecU8FixedLength
+      BYTE_LENGTH = 256
     end
 
     class BalanceLock

data/lib/scale/version.rb

@@ -1,3 +1,3 @@
 module Scale
-  VERSION = "0.2.9".freeze
+  VERSION = "0.2.15".freeze
 end

data/lib/substrate_client.rb

@@ -0,0 +1,159 @@
+
+def ws_request(url, payload)
+  result = nil
+  Kontena::Websocket::Client.connect(url, {}) do |client|
+    client.send(payload.to_json)
+
+    client.read do |message|
+      result = JSON.parse message
+      client.close(1000)
+    end
+  end
+
+  return result
+rescue Kontena::Websocket::CloseError => e
+  raise SubstrateClient::WebsocketError, e.reason
+rescue Kontena::Websocket::Error => e
+  raise SubstrateClient::WebsocketError, e.reason
+end
+
+class SubstrateClient
+  class WebsocketError < StandardError; end
+  class RpcError < StandardError; end
+  class RpcTimeout < StandardError; end
+
+  attr_reader :metadata
+  attr_reader :spec_name, :spec_version
+
+  def initialize(url)
+    @url = url
+    @request_id = 1
+    @metadata_cache = {}
+  end
+
+  def request(method, params)
+    payload = {
+      "jsonrpc" => "2.0",
+      "method" => method,
+      "params" => params,
+      "id" => @request_id
+    }
+
+    data = ws_request(@url, payload)
+    if data["error"]
+      raise RpcError, data["error"]
+    else
+      data["result"]
+    end
+  end
+
+  def init_types_and_metadata(block_hash=nil)
+    runtime_version = self.state_getRuntimeVersion(block_hash)
+    spec_name = runtime_version["specName"].downcase
+    spec_version = runtime_version["specVersion"]
+
+    registry = Scale::TypeRegistry.instance
+
+    # load types
+    if registry.types == nil
+      registry.load(spec_name: spec_name)
+    end
+    registry.spec_version = spec_version
+
+    # set current metadata
+    metadata = @metadata_cache[spec_version]
+    if metadata.nil?
+      hex = self.state_getMetadata(block_hash)
+      metadata = Scale::Types::Metadata.decode(Scale::Bytes.new(hex))
+      @metadata_cache[spec_version] = metadata
+    end
+
+    @metadata = metadata
+    registry.metadata = metadata
+
+    true
+  end
+
+  def get_metadata_from_cache(spec_version)
+
+  end
+
+  def invoke(method, *params)
+    request(method, params)
+  end
+
+  # ################################################
+  # origin rpc methods
+  # ################################################
+  def method_missing(method, *args)
+    invoke method, *args
+  end
+
+  # ################################################
+  # custom methods based on origin rpc methods
+  # ################################################
+  def methods
+    invoke("rpc_methods")["methods"]
+  end
+
+  def get_block_number(block_hash)
+    header = self.chain_getHeader(block_hash)
+    header["number"].to_i(16)
+  end
+
+  def get_metadata(block_hash=nil)
+    self.init_types_and_metadata(block_hash)
+    @metadata
+  end
+
+  def get_block(block_hash=nil)
+    self.init_types_and_metadata(block_hash)
+    block = self.chain_getBlock(block_hash)
+    SubstrateClient::Helper.decode_block(block)
+  rescue => ex
+    puts ex.message
+    puts ex.backtrace.join("\n\t")
+  end
+
+  def get_block_events(block_hash=nil)
+    self.init_types_and_metadata(block_hash)
+
+    storage_key =  "0x26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7"
+    events_data = state_getStorage storage_key, block_hash
+
+    scale_bytes = Scale::Bytes.new(events_data)
+    Scale::Types.get("Vec<EventRecord>").decode(scale_bytes).to_human
+  end
+
+  # Plain: client.get_storage("Sudo", "Key")
+  # Plain: client.get_storage("Balances", "TotalIssuance")
+  # Map: client.get_storage("System", "Account", ["0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d"])
+  # DoubleMap: client.get_storage("ImOnline", "AuthoredBlocks", [2818, "0x749ddc93a65dfec3af27cc7478212cb7d4b0c0357fef35a0163966ab5333b757"])
+  def get_storage(module_name, storage_name, params = nil, block_hash = nil)
+    self.init_types_and_metadata(block_hash)
+
+    storage_key, return_type = SubstrateClient::Helper.generate_storage_key_from_metadata(@metadata, module_name, storage_name, params)
+    data = self.state_getStorage(storage_key, block_hash)
+    return unless data
+
+    bytes = Scale::Bytes.new(data)
+    type = Scale::Types.get(return_type)
+    type.decode(bytes)
+  end
+
+  def generate_storage_key(module_name, storage_name, params = nil, block_hash = nil)
+    self.init_types_and_metadata(block_hash)
+    SubstrateClient::Helper.generate_storage_key_from_metadata(@metadata, module_name, storage_name, params)
+  end
+
+  # compose_call "Balances", "Transfer", { dest: "0x586cb27c291c813ce74e86a60dad270609abf2fc8bee107e44a80ac00225c409", value: 1_000_000_000_000 }
+  def compose_call(module_name, call_name, params, block_hash=nil)
+    self.init_types_and_metadata(block_hash)
+    SubstrateClient::Helper.compose_call_from_metadata(@metadata, module_name, call_name, params)
+  end
+
+  def generate_storage_hash_from_data(storage_hex_data)
+    "0x" + Crypto.blake2_256(Scale::Bytes.new(storage_hex_data).bytes)
+  end
+
+end