scale.rb 0.2.6 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 201e89b117a429345fb44cc4e9da4c77b99284e8cbf42622c96548f76777ebde
-  data.tar.gz: 5f534ca2a026903a3bc74bad4bcf58c1d683bd2e7d24988a4710709733636dba
+  metadata.gz: fcfbe30b0f6a51793d9e977e362c34b213e04ee040f7d6961cde355b1e6cb8d0
+  data.tar.gz: 310f9fcab5186b0366e4a12da5790f77bfe81aa148684d1946d3a7f07ef57c60
 SHA512:
-  metadata.gz: '0039c3cff40a7d34da5099e1b27fd6091d30213fdcc4578ee4a091496ab5bbb6048bab1e881ea0657fd8a9f3e1db6a8be7d986dc0998caa2772273ee52028568'
-  data.tar.gz: ba948fe866b16470b02c03d726a445d8fc55a19b59d15f2a6f0d9cd48822fcf17f682dc18905047f9ba83c1627dc31d1d3169f026176b61ad19aeed75c5c05e7
+  metadata.gz: 14545046f43e403d84a492905b9aa9928024b0310aa2ae8dca927dd98e9d0b4415dcffa5a3364e85af2e13ef1ef4808fdb704462c8687fcb30336fa631a2ca9f
+  data.tar.gz: 23224a2ff2578fb4c49a12bc1317ae645fb5a2237f4f8f9f312585a53b849abd78ca455c86c68f9f6c2f22c3e6dd837638e6644245c66e25674b701e39de08e5

data/Gemfile.lock

@@ -1,16 +1,16 @@
 PATH
   remote: .
   specs:
-    scale.rb (0.2.6)
+    scale.rb (0.2.12)
       activesupport (>= 4.0.0)
       json (~> 2.3.0)
-      substrate_common.rb (~> 0.1.8)
+      substrate_common.rb (~> 0.1.9)
       thor (~> 0.19.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3.1)
+    activesupport (6.0.3.4)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
@@ -44,7 +44,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-support (3.9.0)
-    substrate_common.rb (0.1.8)
+    substrate_common.rb (0.1.9)
       base58
       blake2b
       xxhash
@@ -53,7 +53,7 @@ GEM
     tzinfo (1.2.7)
       thread_safe (~> 0.1)
     xxhash (0.4.0)
-    zeitwerk (2.3.0)
+    zeitwerk (2.4.1)
 
 PLATFORMS
   ruby

data/README.md

@@ -10,7 +10,7 @@ This is a SCALE codec library implemented in ruby language for general use. It c
 
 This work is the prerequisite of our subsequent series of projects. We hope to familiarize and quickly access Polkadot and Substrate through ruby. We plan to develop the back end of our applications in ruby language, and then interact with nodes or synchronize data through this library.
 
-Please refer to the [official doc](https://substrate.dev/docs/en/overview/low-level-data-format) for more details about SCALE low-level data format.
+Please refer to the [official doc](https://substrate.dev/docs/en/knowledgebase/advanced/codec) for more details about SCALE low-level data format.
 
 Because the feature of ruby 2.6 is used, the ruby version is required to be >= 2.6. it will be compatible with older ruby versions when released.
 

data/lib/metadata/metadata.rb

@@ -6,7 +6,7 @@ module Scale
       def self.decode(scale_bytes)
         bytes = scale_bytes.get_next_bytes(4)
         if bytes.bytes_to_utf8 == "meta"
-          metadata_version = Scale::Types.type_of("Enum", %w[MetadataV0 MetadataV1 MetadataV2 MetadataV3 MetadataV4 MetadataV5 MetadataV6 MetadataV7 MetadataV8 MetadataV9 MetadataV10 MetadataV11]).decode(scale_bytes).value
+          metadata_version = Scale::Types.type_of("Enum", %w[MetadataV0 MetadataV1 MetadataV2 MetadataV3 MetadataV4 MetadataV5 MetadataV6 MetadataV7 MetadataV8 MetadataV9 MetadataV10 MetadataV11 MetadataV12]).decode(scale_bytes).value
           metadata = Metadata.new "Scale::Types::#{metadata_version}".constantize.decode(scale_bytes)
           metadata.version = metadata_version[9..].to_i
         else

data/lib/metadata/metadata_v12.rb

@@ -0,0 +1,87 @@
+module Scale
+  module Types
+    class MetadataV12
+      include SingleValue
+      attr_accessor :call_index, :event_index
+
+      def initialize(value)
+        @call_index = {}
+        @event_index = {}
+        super(value)
+      end
+
+      def self.decode(scale_bytes)
+        modules = Scale::Types.type_of("Vec<MetadataV12Module>").decode(scale_bytes).value
+
+        value = {
+          magicNumber: 1_635_018_093,
+          metadata: {
+            version: 12,
+            modules: modules.map(&:value)
+          }
+        }
+
+        result = MetadataV12.new(value)
+
+        call_module_index = 0
+        event_module_index = 0
+
+        modules.map(&:value).each do |m|
+          if m[:calls]
+            m[:calls].each_with_index do |call, index|
+              call[:lookup] = "%02x%02x" % [call_module_index, index]
+              result.call_index[call[:lookup]] = [m, call]
+            end
+            call_module_index += 1
+          end
+
+          if m[:events]
+            m[:events].each_with_index do |event, index|
+              event[:lookup] = "%02x%02x" % [event_module_index, index]
+              result.event_index[event[:lookup]] = [m, event]
+            end
+            event_module_index += 1
+          end
+        end
+
+        result
+      end
+    end
+
+    class MetadataV12Module
+      include SingleValue
+      def self.decode(scale_bytes)
+        name = String.decode(scale_bytes).value
+
+        result = {
+          name: name
+        }
+
+        has_storage = Bool.decode(scale_bytes).value
+        if has_storage
+          storage = MetadataV7ModuleStorage.decode(scale_bytes).value
+          result[:storage] = storage
+          result[:prefix] = storage[:prefix]
+        end
+
+        has_calls = Bool.decode(scale_bytes).value
+        if has_calls
+          calls = Scale::Types.type_of("Vec<MetadataModuleCall>").decode(scale_bytes).value
+          result[:calls] = calls.map(&:value)
+        end
+
+        has_events = Bool.decode(scale_bytes).value
+        if has_events
+          events = Scale::Types.type_of("Vec<MetadataModuleEvent>").decode(scale_bytes).value
+          result[:events] = events.map(&:value)
+        end
+
+        result[:constants] = Scale::Types.type_of("Vec<MetadataV7ModuleConstants>").decode(scale_bytes).value.map(&:value)
+        result[:errors] = Scale::Types.type_of("Vec<MetadataModuleError>").decode(scale_bytes).value.map(&:value)
+
+        result[:index] = U8.decode(scale_bytes).value
+        MetadataV12Module.new(result)
+      end
+    end
+  end
+end

data/lib/scale.rb

@@ -23,6 +23,7 @@ require "metadata/metadata_v8"
 require "metadata/metadata_v9"
 require "metadata/metadata_v10"
 require "metadata/metadata_v11"
+require "metadata/metadata_v12"
 
 module Scale
   class Error < StandardError; end
@@ -91,14 +92,11 @@ module Scale
       end
 
       def type_traverse(type, types)
-        if types.has_key?(type)
+        type = rename(type) if type.class == ::String
+        if types.has_key?(type) && types[type] != type
           type_traverse(types[type], types)
         else
-          if type.class == ::String
-            rename(type)
-          else
-            type
-          end
+          type
         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
 

data/lib/scale/version.rb

@@ -1,3 +1,3 @@
 module Scale
-  VERSION = "0.2.6".freeze
+  VERSION = "0.2.12".freeze
 end

data/lib/type_registry/darwinia.json

@@ -1,119 +1,300 @@
 {
   "types": {
-    "EpochDuration": "u64",
-    "EraIndex": "u32",
-    "Index": "U64",
-    "RingBalanceOf": "u128",
-    "KtonBalanceOf": "u128",
-    "ExtendedBalance": "u128",
-    "Keys": {
+    "Address": "AccountId",
+    "LookupSource": "AccountId",
+    "BalanceLock": {
       "type": "struct",
       "type_mapping": [
-         ["grandpa", "AccountId"],
-         ["babe", "AccountId"]
+        ["id", "LockIdentifier"],
+        ["lock_for", "LockFor"],
+        ["lock_reasons", "LockReasons"]
       ]
     },
-    "ValidatorPrefs": "ValidatorPrefsLegacy",
-    "StakingBalance": {
+    "LockFor": {
       "type": "enum",
       "type_mapping": [
-         ["Ring", "RingBalanceOf"],
-         ["Kton", "KtonBalanceOf"]
+        ["Common", "Common"],
+        ["Staking", "StakingLock"]
+      ]
+    },
+    "Common": {
+      "type": "struct",
+      "type_mapping": [
+        ["amount", "Balance"]
+      ]
+    },
+    "StakingLock": {
+      "type": "struct",
+      "type_mapping": [
+        ["staking_amount", "Balance"],
+        ["unbondings", "Vec<Unbonding>"]
+      ]
+    },
+    "LockReasons": {
+      "type": "enum",
+      "type_mapping": [
+        ["Fee", "Null"],
+        ["Misc", "Null"],
+        ["All", "Null"]
+      ]
+    },
+    "Unbonding": {
+      "type": "struct",
+      "type_mapping": [
+        ["amount", "Balance"],
+        ["until", "BlockNumber"]
+      ]
+    },
+    "AccountData": {
+      "type": "struct",
+      "type_mapping": [
+        ["free", "Balance"],
+        ["reserved", "Balance"],
+        ["free_kton", "Balance"],
+        ["reserved_kton", "Balance"]
+      ]
+    },
+    "RingBalance": "Balance",
+    "KtonBalance": "Balance",
+    "TsInMs": "u64",
+    "Power": "u32",
+    "DepositId": "U256",
+    "StakingBalanceT": {
+      "type": "enum",
+      "type_mapping": [
+        ["RingBalance", "Balance"],
+        ["KtonBalance", "Balance"]
+      ]
+    },
+    "StakingLedgerT": {
+      "type": "struct",
+      "type_mapping": [
+        ["stash", "AccountId"],
+        ["active_ring", "Compact<Balance>"],
+        ["active_deposit_ring", "Compact<Balance>"],
+        ["active_kton", "Compact<Balance>"],
+        ["deposit_items", "Vec<TimeDepositItem>"],
+        ["ring_staking_lock", "StakingLock"],
+        ["kton_staking_lock", "StakingLock"],
+        ["claimed_rewards", "Vec<EraIndex>"]
       ]
     },
     "TimeDepositItem": {
       "type": "struct",
       "type_mapping": [
-         ["value", "Compact<RingBalanceOf>"],
-         ["start_time", "Compact<Moment>"],
-         ["expire_time", "Compact<Moment>"]
+        ["value", "Compact<Balance>"],
+        ["start_time", "Compact<TsInMs>"],
+        ["expire_time", "Compact<TsInMs>"]
+      ]
+    },
+    "ExposureT": {
+      "type": "struct",
+      "type_mapping": [
+        ["own_ring_balance", "Compact<Balance>"],
+        ["own_kton_balance", "Compact<Balance>"],
+        ["own_power", "Power"],
+        ["total_power", "Power"],
+        ["others", "Vec<IndividualExposure>"]
       ]
     },
-    "UnlockChunk": {
+    "IndividualExposure": {
       "type": "struct",
       "type_mapping": [
-         ["value", "StakingBalance"],
-         ["era", "Compact<EraIndex>"],
-         ["is_time_deposit", "bool"]
+        ["who", "AccountId"],
+        ["ring_balance", "Compact<Balance>"],
+        ["kton_balance", "Compact<Balance>"],
+        ["power", "Power"]
       ]
     },
-    "StakingLedgers": {
+    "ElectionResultT": {
       "type": "struct",
       "type_mapping": [
-         ["stash", "AccountId"],
-         ["total_ring", "Compact<RingBalanceOf>"],
-         ["total_deposit_ring", "Compact<RingBalanceOf>"],
-         ["active_ring", "Compact<RingBalanceOf>"],
-         ["active_deposit_ring", "Compact<RingBalanceOf>"],
-         ["total_kton", "Compact<KtonBalanceOf>"],
-         ["active_kton", "Compact<KtonBalanceOf>"],
-         ["deposit_items", "Vec<TimeDepositItem>"],
-         ["unlocking", "Vec<UnlockChunk>"]
+        ["elected_stashes", "Vec<AccountId>"],
+        ["exposures", "Vec<(AccountId, ExposureT)>"],
+        ["compute", "ElectionCompute"]
       ]
     },
-    "IndividualExpo": {
+    "RKT": {
       "type": "struct",
       "type_mapping": [
-         ["who", "AccountId"],
-         ["value", "ExtendedBalance"]
+        ["r", "Balance"],
+        ["k", "Balance"]
       ]
     },
-    "Exposures": {
+    "SpanRecord": {
       "type": "struct",
       "type_mapping": [
-         ["total", "ExtendedBalance"],
-         ["own", "ExtendedBalance"],
-         ["others", "Vec<IndividualExpo>"]
+        ["slashed", "RKT"],
+        ["paid_out", "RKT"]
       ]
     },
-    "TokenBalance": "u128",
-    "Currency": "u128",
-    "CurrencyOf": "u128",
-    "Auction": {
+    "UnappliedSlash": {
       "type": "struct",
       "type_mapping": [
-         ["seller", "AccountId"],
-         ["startAt", "Moment"],
-         ["duration", "u64"],
-         ["startingPrice", "TokenBalance"],
-         ["endingPrice", "TokenBalance"],
-         ["lastRecord", "TokenBalance"],
-         ["lastBidder", "AccountId"],
-         ["lastBidStartAt", "Moment"]
+        ["validator", "AccountId"],
+        ["own", "RKT"],
+        ["others", "Vec<(AccountId, RKT)>"],
+        ["reporters", "Vec<AccountId>"],
+        ["payout", "RKT"]
       ]
     },
-    "DepositInfo": {
+    "TreasuryProposal": {
       "type": "struct",
       "type_mapping": [
-         ["month", "Moment"],
-         ["start_at", "Moment"],
-         ["value", "CurrencyOf"],
-         ["unit_interest", "u64"],
-         ["claimed", "bool"]
+        ["proposer", "AccountId"],
+        ["beneficiary", "AccountId"],
+        ["ring_value", "Balance"],
+        ["kton_value", "Balance"],
+        ["ring_bond", "Balance"],
+        ["kton_bond", "Balance"]
       ]
     },
-    "Deposit": {
+    "MappedRing": "u128",
+    "EthereumTransactionIndex": "(H256, u64)",
+    "EthereumHeaderBrief": {
       "type": "struct",
       "type_mapping": [
-         ["total_deposit", "CurrencyOf"],
-         ["deposit_list", "Vec<DepositInfo>"]
+        ["total_difficulty", "U256"],
+        ["parent_hash", "H256"],
+        ["number", "EthereumBlockNumber"],
+        ["relayer", "AccountId"]
       ]
     },
-    "Revenue": {
+    "EthereumBlockNumber": "u64",
+    "EthereumHeaderThingWithProof": {
       "type": "struct",
       "type_mapping": [
-         ["team", "TokenBalance"],
-         ["contribution", "TokenBalance"],
-         ["ktoner", "TokenBalance"],
-         ["lottery", "TokenBalance"]
+        ["header", "EthereumHeader"],
+        ["ethash_proof", "Vec<EthashProof>"],
+        ["mmr_root", "H256"],
+        ["mmr_proof", "Vec<H256>"]
       ]
     },
-    "DoubleNodeWithMerkleProof": {
+    "EthereumHeaderThing": {
       "type": "struct",
       "type_mapping": [
-        ["dag_nodes", "VecH512Length2"],
+        ["header", "EthereumHeader"],
+        ["mmr_root", "H256"]
+      ]
+    },
+    "EthereumHeader": {
+      "type": "struct",
+      "type_mapping": [
+        ["parent_hash", "H256"],
+        ["timestamp", "u64"],
+        ["number", "EthereumBlockNumber"],
+        ["author", "EthereumAddress"],
+        ["transactions_root", "H256"],
+        ["uncles_hash", "H256"],
+        ["extra_data", "Bytes"],
+        ["state_root", "H256"],
+        ["receipts_root", "H256"],
+        ["log_bloom", "Bloom"],
+        ["gas_used", "U256"],
+        ["gas_limit", "U256"],
+        ["difficulty", "U256"],
+        ["seal", "Vec<Bytes>"],
+        ["hash", "Option<H256>"]
+      ]
+    },
+    "EthereumAddress": "H160",
+    "Bloom": "[u8; 256]",
+    "H128": "[u8; 16]",
+    "EthashProof": {
+      "type": "struct",
+      "type_mapping": [
+        ["dag_nodes", "(H512, H512)"],
         ["proof", "Vec<H128>"]
       ]
+    },
+    "EthereumReceipt": {
+      "type": "struct",
+      "type_mapping": [
+        ["gas_used", "U256"],
+        ["log_bloom", "Bloom"],
+        ["logs", "Vec<LogEntry>"],
+        ["outcome", "TransactionOutcome"]
+      ]
+    },
+    "EthereumNetworkType": {
+      "type": "enum",
+      "type_mapping": [
+        ["Mainnet", "Null"],
+        ["Ropsten", "Null"]
+      ]
+    },
+    "RedeemFor": {
+      "type": "enum",
+      "type_mapping": [
+        ["Token", "Null"],
+        ["Deposit", "Null"]
+      ]
+    },
+    "EthereumReceiptProof": {
+      "type": "struct",
+      "type_mapping": [
+        ["index", "u64"],
+        ["proof", "Bytes"],
+        ["header_hash", "H256"]
+      ]
+    },
+    "EthereumReceiptProofThing": "(EthereumHeader, EthereumReceiptProof, MMRProof)",
+    "MMRProof": {
+      "type": "struct",
+      "type_mapping": [
+        ["member_leaf_index", "u64"],
+        ["last_leaf_index", "u64"],
+        ["proof", "Vec<H256>"]
+      ]
+    },
+    "OtherSignature": {
+      "type": "enum",
+      "type_mapping": [
+        ["Eth", "EcdsaSignature"],
+        ["Tron", "EcdsaSignature"]
+      ]
+    },
+    "EcdsaSignature": "[u8; 65]",
+    "OtherAddress": {
+      "type": "enum",
+      "type_mapping": [
+        ["Eth", "[u8; 20]"],
+        ["Tron", "[u8; 20]"]
+      ]
+    },
+    "AddressT": "[u8; 20]",
+    "MerkleMountainRangeRootLog": {
+      "type": "struct",
+      "type_mapping": [
+        ["prefix", "[u8; 4]"],
+        ["mmr_root", "Hash"]
+      ]
+    },
+    "Round": "u64",
+    "TcHeaderThingWithProof": "EthereumHeaderThingWithProof",
+    "TcHeaderThing": "EthereumHeaderThing",
+    "TcBlockNumber": "u64",
+    "TcHeaderHash": "H256",
+    "GameId": "TcBlockNumber",
+    "RelayProposalT": {
+      "type": "struct",
+      "type_mapping": [
+        ["relayer", "AccountId"],
+        ["bonded_proposal", "Vec<(Balance, TcHeaderThing)>"],
+        ["extend_from_header_hash", "Option<TcHeaderHash>"]
+      ]
+    },
+    "BalancesRuntimeDispatchInfo": {
+      "type": "struct",
+      "type_mapping": [
+        ["usable_balance", "Balance"]
+      ]
+    },
+    "StakingRuntimeDispatchInfo": {
+      "type": "struct",
+      "type_mapping": [
+        ["power", "Power"]
+      ]
     }
   }
 }

data/lib/type_registry/default.json

@@ -12,7 +12,6 @@
     "CallHashOf": "CallHash",
     "Fixed64": "u64",
     "Fixed128": "u128",
-    "AccountId": "GenericAccountId",
     "AccountIdOf": "AccountId",
     "AccountVoteSplit": {
       "type": "struct",

data/scale.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "substrate_common.rb", "~> 0.1.8"
+  spec.add_dependency "substrate_common.rb", "~> 0.1.9"
   spec.add_dependency "json", "~> 2.3.0"
   spec.add_dependency "activesupport", ">= 4.0.0"
   spec.add_dependency "thor", "~> 0.19.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scale.rb
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.12
 platform: ruby
 authors:
 - Wu Minzhe
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-29 00:00:00.000000000 Z
+date: 2020-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: substrate_common.rb
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.8
+        version: 0.1.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.8
+        version: 0.1.9
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -165,6 +165,7 @@ files:
 - lib/metadata/metadata_v1.rb
 - lib/metadata/metadata_v10.rb
 - lib/metadata/metadata_v11.rb
+- lib/metadata/metadata_v12.rb
 - lib/metadata/metadata_v2.rb
 - lib/metadata/metadata_v3.rb
 - lib/metadata/metadata_v4.rb
@@ -178,7 +179,6 @@ files:
 - lib/scale/block.rb
 - lib/scale/types.rb
 - lib/scale/version.rb
-- lib/type_registry/certifybook-chain.json
 - lib/type_registry/darwinia.json
 - lib/type_registry/default.json
 - lib/type_registry/edgeware.json

data/lib/type_registry/certifybook-chain.json

@@ -1,10 +0,0 @@
-{
-  "types": {
-    "Address": "AccountId",
-    "LookupSource": "AccountId",
-    "Entity": {
-      "id": "H256",
-      "status": "u8"
-    }
-  }
-}