scale.rb 0.2.14 → 0.2.19

data/lib/scale/block.rb

@@ -5,12 +5,12 @@ module Scale
       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
+      def self.generate_hash(bytes)
+        Crypto.blake2_256 bytes
       end
 
       def self.decode(scale_bytes)
-        metadata = Scale::TypeRegistry.instance.metadata
+        metadata = Scale::TypeRegistry.instance.metadata.value
         result = {}
 
         extrinsic_length = Compact.decode(scale_bytes).value
@@ -24,9 +24,6 @@ module Scale
           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
@@ -39,9 +36,6 @@ module Scale
           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
@@ -55,9 +49,6 @@ module Scale
           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
@@ -69,13 +60,8 @@ module Scale
         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[:address] = Scale::Types.get("Address").decode(scale_bytes).value
+            result[:signature] = Scale::Types.get("MultiSignature").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
@@ -146,7 +132,7 @@ module Scale
       include SingleValue
 
       def self.decode(scale_bytes)
-        metadata = Scale::TypeRegistry.instance.metadata
+        metadata = Scale::TypeRegistry.instance.metadata.value
 
         result = {}
         phase = scale_bytes.get_next_bytes(1).first
@@ -155,9 +141,13 @@ module Scale
           result[:extrinsic_idx] = U32.decode(scale_bytes).value
         end
 
-        type = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
-        event = metadata.event_index[type][1]
-        # mod = metadata.event_index[type][0]
+        index = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
+        event = metadata.event_index[index][1]
+        the_module = metadata.event_index[index][0]
+
+        result[:event_index] = index
+        result[:event_metadata] = event
+        result[:module_metadata] = the_module
 
         result[:params] = []
         event[:args].each do |arg_type|
@@ -175,18 +165,18 @@ module Scale
       end
     end
 
-    # log
-    class Other < Bytes; end
-
     class AuthoritiesChange 
       include Vec
       inner_type "AccountId"
     end
 
-    class ConsensusEngineId < VecU8Length4; end
+    class GenericConsensusEngineId < VecU8Length4; end
 
     class ChangesTrieRoot < Bytes; end
 
+    # log
+    class Other < Bytes; end
+
     class SealV0
       include Struct
       items(

data/lib/scale/types.rb

@@ -6,10 +6,13 @@ module Scale
       BYTES_LENGTH = 1
 
       def self.decode(scale_bytes)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         bytes = scale_bytes.get_next_bytes(self::BYTES_LENGTH)
         if bytes == [0]
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           Bool.new(false)
         elsif bytes == [1]
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           Bool.new(true)
         else
           raise "Bad data"
@@ -80,6 +83,7 @@ module Scale
       include SingleValue
 
       def self.decode(scale_bytes)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         first_byte = scale_bytes.get_next_bytes(1)[0]
         first_byte_in_bin = first_byte.to_s(2).rjust(8, "0")
 
@@ -113,6 +117,7 @@ module Scale
               .to_i(16)
           end
 
+        puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         Compact.new(value)
       end
 
@@ -141,6 +146,7 @@ module Scale
       include SingleValue
 
       def self.decode(scale_bytes)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         length = Scale::Types::Compact.decode(scale_bytes).value
         bytes = scale_bytes.get_next_bytes(length)
 
@@ -148,8 +154,10 @@ module Scale
         # => "Café"
         str = bytes.pack("C*").force_encoding("utf-8")
         if str.valid_encoding?
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           Bytes.new str
         else
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           Bytes.new bytes.bytes_to_hex
         end
       end
@@ -171,8 +179,10 @@ module Scale
       include SingleValue
 
       def self.decode(scale_bytes)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         length = Scale::Types::Compact.decode(scale_bytes).value
         hex_string = scale_bytes.get_next_bytes(length).bytes_to_hex
+        puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         Hex.new(hex_string)
       end
     end
@@ -180,8 +190,10 @@ module Scale
     class String
       include SingleValue
       def self.decode(scale_bytes)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         length = Scale::Types::Compact.decode(scale_bytes).value
         bytes = scale_bytes.get_next_bytes(length)
+        puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         String.new bytes.pack("C*").force_encoding("utf-8")
       end
     end
@@ -189,7 +201,9 @@ module Scale
     class H160
       include SingleValue
       def self.decode(scale_bytes)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         bytes = scale_bytes.get_next_bytes(20)
+        puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         H160.new(bytes.bytes_to_hex)
       end
 
@@ -202,7 +216,9 @@ module Scale
     class H256
       include SingleValue
       def self.decode(scale_bytes)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         bytes = scale_bytes.get_next_bytes(32)
+        puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         H256.new(bytes.bytes_to_hex)
       end
 
@@ -215,7 +231,9 @@ module Scale
     class H512
       include SingleValue
       def self.decode(scale_bytes)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         bytes = scale_bytes.get_next_bytes(64)
+        puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         H512.new(bytes.bytes_to_hex)
       end
 
@@ -234,12 +252,14 @@ module Scale
       # 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)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         account_length = scale_bytes.get_next_bytes(1).first
 
         if account_length == 0xff # 32 bytes address(Public key)
           account_id = scale_bytes.get_next_bytes(32).bytes_to_hex
           account_length = [account_length].bytes_to_hex
 
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           Address.new({
             account_id: account_id,
             account_length: account_length
@@ -258,6 +278,7 @@ module Scale
           # TODO: add account_idx 
           account_length = [account_length].bytes_to_hex
 
+          puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
           Address.new({
             account_index: account_index,
             account_length: account_length
@@ -280,10 +301,14 @@ module Scale
 
     class AccountIdAddress < GenericAddress
       def self.decode(scale_bytes)
-        AccountIdAddress.new({
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+        result = AccountIdAddress.new({
           account_id: AccountId.decode(scale_bytes).value,
           account_length: "0xff"
         })
+
+        puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+        result
       end
 
       def encode
@@ -304,12 +329,15 @@ module Scale
     class Era
       include SingleValue
       def self.decode(scale_bytes)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         byte = scale_bytes.get_next_bytes(1).bytes_to_hex
-        if byte == "0x00"
+        result = if byte == "0x00"
           Era.new byte
         else
           Era.new byte + scale_bytes.get_next_bytes(1).bytes_to_hex()[2..]
         end
+        puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+        result
       end
     end
 
@@ -320,12 +348,14 @@ module Scale
     class CompactMoment
       include SingleValue
       def self.decode(scale_bytes)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         value = Compact.decode(scale_bytes).value
         if value > 10000000000
           value /= 1000
         end
 
-        CompactMoment.new Time.at(value).to_datetime.strftime("%F %T")
+        puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+        CompactMoment.new Time.at(value).strftime("%F %T")
       end
     end
 
@@ -570,34 +600,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
@@ -614,7 +662,9 @@ module Scale
       include SingleValue
 
       def self.decode(scale_bytes)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         bytes = scale_bytes.get_next_bytes(20)
+        puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         EthereumAddress.new(bytes.bytes_to_hex)
       end
 
@@ -631,8 +681,10 @@ module Scale
       include SingleValue
 
       def self.decode(scale_bytes)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         bytes = scale_bytes.get_next_bytes(65)
         EcdsaSignature.new(bytes.bytes_to_hex)
+        puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
       end
 
       def encode
@@ -740,7 +792,11 @@ module Scale
     class VoteOutcome
       include SingleValue
       def self.decode(scale_bytes)
-        new(scale_bytes.get_next_bytes(32))
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+        result = new(scale_bytes.get_next_bytes(32))
+        
+        puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
+        result
       end
     end
 
@@ -781,6 +837,7 @@ module Scale
       include SingleValue
 
       def self.decode(scale_bytes, metadata, chain_spec)
+        puts "BEGIN " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         call_index = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
         call_module, call = metadata.value.call_index[call_index]
 
@@ -789,6 +846,7 @@ module Scale
           {name: arg[:name], type: arg[:type], value: arg_obj.encode, value_raw: arg_obj.value}
         end
 
+        puts "  END " + self::TYPE_NAME + ": #{scale_bytes}" if Scale::Types.debug == true
         self.new({
           call_index: call_index, 
           call_function: call[:name],
@@ -826,6 +884,15 @@ module Scale
       end
     end
 
+    class GenericBlock
+      include SingleValue
+
+      def self.decode(scale_bytes)
+      end
+
+      def encode
+      end
+    end
 
   end
 end

data/lib/scale/version.rb

@@ -1,3 +1,3 @@
 module Scale
-  VERSION = "0.2.14".freeze
+  VERSION = "0.2.19".freeze
 end

data/lib/substrate_client.rb

@@ -0,0 +1,170 @@
+require "faye/websocket"
+require "eventmachine"
+
+def ws_request(url, payload)
+  result = nil
+
+  EM.run do
+    ws = Faye::WebSocket::Client.new(url)
+
+    ws.on :open do |event|
+      ws.send(payload.to_json)
+    end
+
+    ws.on :message do |event|
+      if event.data.include?("jsonrpc")
+        result = JSON.parse event.data
+        ws.close(3001, "data received")
+        EM.stop
+      end
+    end
+
+    ws.on :close do |event|
+      ws = nil
+    end
+  end
+
+  result
+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)
+    decoded = Scale::Types.get("Vec<EventRecord>").decode(scale_bytes).to_human
+    [events_data, decoded]
+  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