scale.rb 0.2.5 → 0.2.10

data/lib/scale.rb

@@ -23,27 +23,35 @@ 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
 
   class TypeRegistry
     include Singleton
-    attr_accessor :types, :versioning
-    attr_accessor :spec_version, :metadata
-    attr_accessor :custom_types
+    attr_reader :spec_name, :types, :versioning, :custom_types
+    attr_accessor :spec_version
+    attr_accessor :metadata
 
-    def load(spec_name = nil, custom_types = nil)
-      default_types, _ = load_chain_spec_types("default")
+    def load(spec_name: nil, custom_types: nil)
+      @spec_name = nil
+      @types = nil
+      @versioning = nil
+      @custom_types = nil
+
+      default_types, _, _ = load_chain_spec_types("default")
 
       if spec_name.nil? || spec_name == "default"
+        @spec_name = "default"
         @types = default_types
       else
-        spec_types, @versioning = load_chain_spec_types(spec_name)
+        @spec_name = spec_name
+        spec_types, @versioning, @spec_version = load_chain_spec_types(spec_name)
         @types = default_types.merge(spec_types)
       end
 
-      @custom_types = custom_types.stringify_keys if custom_types.nil? && custom_types.class.name == "Hash"
+      self.custom_types = custom_types
       true
     end
 
@@ -67,27 +75,30 @@ module Scale
       Scale::Types.constantize(type)
     end
 
-    def load_chain_spec_types(spec_name)
-      file = File.join File.expand_path("../..", __FILE__), "lib", "type_registry", "#{spec_name}.json"
-      json_string = File.open(file).read
-      json = JSON.parse(json_string)
+    def custom_types=(custom_types)
+      @custom_types = custom_types.stringify_keys if (not custom_types.nil?) && custom_types.class.name == "Hash"
+    end
 
-      runtime_id = json["runtime_id"]
+    private
 
-      [json["types"], json["versioning"]]
-    end
+      def load_chain_spec_types(spec_name)
+        file = File.join File.expand_path("../..", __FILE__), "lib", "type_registry", "#{spec_name}.json"
+        json_string = File.open(file).read
+        json = JSON.parse(json_string)
 
-    def type_traverse(type, types)
-      if types.has_key?(type)
-        type_traverse(types[type], types)
-      else
-        if type.class == ::String
-          rename(type)
+        runtime_id = json["runtime_id"]
+
+        [json["types"], json["versioning"], runtime_id]
+      end
+
+      def type_traverse(type, types)
+        type = rename(type) if type.class == ::String
+        if types.has_key?(type) && types[type] != type
+          type_traverse(types[type], types)
         else
           type
         end
       end
-    end
   end
 
   # TODO: == implement
@@ -323,6 +334,7 @@ def rename(type)
   return "Compact" if type == "<Balance as HasCompact>::Type"
   return "Compact" if type == "<BlockNumber as HasCompact>::Type"
   return "Compact" if type == "Compact<Balance>"
+  return "Compact" if type == "Compact<BlockNumber>"
   return "CompactMoment" if type == "<Moment as HasCompact>::Type"
   return "CompactMoment" if type == "Compact<Moment>"
   return "InherentOfflineReport" if type == "<InherentOfflineReport as InherentOfflineReport>::Inherent"

data/lib/scale/block.rb

@@ -96,9 +96,10 @@ module Scale
           # 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: arg[:type], scale_type: type, value: arg_obj.value }
+            type = arg[:type]
+            scale_type = Scale::Types.get(type)
+            obj = scale_type.decode(scale_bytes)
+            {name: arg[:name], type: type, scale_type: scale_type, value: obj.value }
           end
         end
 
@@ -123,6 +124,24 @@ module Scale
       end
     end
 
+    class Phase
+      include Enum
+      items isApplyExtrinsic: "Bool", asApplyExtrinsic: "U32", isFinalization: "Bool", isInitialization: "Bool"
+    end
+
+    class EventRecords
+      include SingleValue
+      
+      def self.decode(scale_bytes)
+
+        length = Compact.decode(scale_bytes).value
+
+        length.times do |i|
+          ev = EventRecord.decode(scale_bytes)
+        end
+      end
+    end
+
     class EventRecord
       include SingleValue
 

data/lib/scale/version.rb

@@ -1,3 +1,3 @@
 module Scale
-  VERSION = "0.2.5".freeze
+  VERSION = "0.2.10".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"]
+      ]
     }
   }
 }