scale.rb 0.2.4 → 0.2.9

data/lib/scale/block.rb

@@ -9,7 +9,8 @@ module Scale
         Blake2b.hex data, Blake2b::Key.none, 32
       end
 
-      def self.decode(scale_bytes, metadata)
+      def self.decode(scale_bytes)
+        metadata = Scale::TypeRegistry.instance.metadata
         result = {}
 
         extrinsic_length = Compact.decode(scale_bytes).value
@@ -83,11 +84,11 @@ module Scale
           result[:call_index] = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
 
         else
-          raise "Extrinsics version #{version_info} is not implemented"
+          raise "Extrinsic version #{version_info} is not implemented"
         end
 
         if result[:call_index]
-          call_module, call = metadata.value.call_index[result[:call_index]]
+          call_module, call = metadata.call_index[result[:call_index]]
 
           result[:call_function] = call[:name].downcase
           result[:call_module] = call_module[:name].downcase
@@ -95,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: type.name, value: arg_obj.value, value_raw: "0x#{arg_obj.encode}" }
+            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
 
@@ -107,24 +109,42 @@ module Scale
         Extrinsic.new result
       end
 
-      def encode(metadata)
-        puts metadata.value.value["modules"]
+      def encode
         result = "04" + self.value[:call_index]
 
-        result = result +
-          self.value[:params].map do |param|
-            param[:type].constantize.new(param[:value]).encode
-          end.join
+        result += self.value[:params].map do |param|
+          Scale::Types.get(param[:type]).new(param[:value]).encode
+        end.join
+
+        "0x" + Compact.new(result.length / 2).encode + result
+      end
 
-        result = "0x" + Compact.new(result.length / 2).encode + result
-        return result
+      def to_human
+        @value
+      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
 
-      # 0x0c000000000000001027000001010000010000000400be07e2c28688db5368445c33d32b3c7bcad15dab1ec802ba8cccc1c22b86574f6992da89ff412eaf9bafac4024
       def self.decode(scale_bytes)
         metadata = Scale::TypeRegistry.instance.metadata
 
@@ -137,22 +157,72 @@ module Scale
 
         type = scale_bytes.get_next_bytes(2).bytes_to_hex[2..]
         event = metadata.event_index[type][1]
-        mod = metadata.event_index[type][0]
+        # mod = metadata.event_index[type][0]
 
         result[:params] = []
         event[:args].each do |arg_type|
-          value = Scale::Types.get(arg_type).decode(scale_bytes).value
+          value = Scale::Types.get(arg_type).decode(scale_bytes).to_human
           result[:params] << {
+            name: event[:name],
             type: arg_type,
             value: value
           }
         end
 
-        result[:topics] = Scale::Types.get('Vec<Hash>').decode(scale_bytes).value.map(&:value)
+        result[:topics] = Scale::Types.get("Vec<Hash>").decode(scale_bytes).value.map(&:value)
 
         EventRecord.new(result)
       end
     end
 
+    # log
+    class Other < Bytes; end
+
+    class AuthoritiesChange 
+      include Vec
+      inner_type "AccountId"
+    end
+
+    class ConsensusEngineId < VecU8Length4; end
+
+    class ChangesTrieRoot < Bytes; end
+
+    class SealV0
+      include Struct
+      items(
+        slot: "U64",
+        signature: "Signature"
+      )
+    end
+
+    class Consensus
+      include Struct
+      items(
+        engine: "ConsensusEngineId",
+        data: "Hex"
+      )
+    end
+
+    class Seal
+      include Struct
+      items(
+        engine: "ConsensusEngineId",
+        data: "Hex"
+      )
+    end
+
+    class PreRuntime
+      include Struct
+      items(
+        engine: "ConsensusEngineId",
+        data: "Hex"
+      )
+    end
+
+    class LogDigest
+      include Enum
+      items %w[Other AuthoritiesChange ChangesTrieRoot SealV0 Consensus Seal PreRuntime]
+    end
+
   end
 end

data/lib/scale/types.rb

@@ -46,24 +46,34 @@ module Scale
       BYTE_LENGTH = 16
     end
 
+    class U256
+      include FixedWidthUInt
+      BYTE_LENGTH = 32
+    end
+
     class I8
       include FixedWidthInt
+      BYTE_LENGTH = 1
     end
 
     class I16
       include FixedWidthInt
+      BYTE_LENGTH = 2
     end
 
     class I32
       include FixedWidthInt
+      BYTE_LENGTH = 4
     end
 
     class I64
       include FixedWidthInt
+      BYTE_LENGTH = 8
     end
 
     class I128
       include FixedWidthInt
+      BYTE_LENGTH = 16
     end
 
     class Compact
@@ -303,7 +313,7 @@ module Scale
           value /= 1000
         end
 
-        CompactMoment.new Time.at(seconds_since_epoch_integer).to_datetime
+        CompactMoment.new Time.at(value).to_datetime.strftime("%F %T")
       end
     end
 
@@ -791,5 +801,19 @@ module Scale
       )
     end
 
+    class VecH512Length2
+      include SingleValue
+
+      def self.decode(scale_bytes)
+      end
+
+      def encode
+        "0x" + self.value.map do |item|
+          item[2..]
+        end.join
+      end
+    end
+
+
   end
 end

data/lib/scale/version.rb

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

data/lib/type_registry/darwinia.json

@@ -1,111 +1,299 @@
 {
   "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>"]
+      ]
+    },
+    "IndividualExposure": {
+      "type": "struct",
+      "type_mapping": [
+        ["who", "AccountId"],
+        ["ring_balance", "Compact<Balance>"],
+        ["kton_balance", "Compact<Balance>"],
+        ["power", "Power"]
+      ]
+    },
+    "ElectionResultT": {
+      "type": "struct",
+      "type_mapping": [
+        ["elected_stashes", "Vec<AccountId>"],
+        ["exposures", "Vec<(AccountId, ExposureT)>"],
+        ["compute", "ElectionCompute"]
+      ]
+    },
+    "RKT": {
+      "type": "struct",
+      "type_mapping": [
+        ["r", "Balance"],
+        ["k", "Balance"]
       ]
     },
-    "UnlockChunk": {
+    "SpanRecord": {
       "type": "struct",
       "type_mapping": [
-         ["value", "StakingBalance"],
-         ["era", "Compact<EraIndex>"],
-         ["is_time_deposit", "bool"]
+        ["slashed", "RKT"],
+        ["paid_out", "RKT"]
       ]
     },
-    "StakingLedgers": {
+    "UnappliedSlash": {
       "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>"]
+        ["validator", "AccountId"],
+        ["own", "RKT"],
+        ["others", "Vec<(AccountId, RKT)>"],
+        ["reporters", "Vec<AccountId>"],
+        ["payout", "RKT"]
       ]
     },
-    "IndividualExpo": {
+    "TreasuryProposal": {
       "type": "struct",
       "type_mapping": [
-         ["who", "AccountId"],
-         ["value", "ExtendedBalance"]
+        ["proposer", "AccountId"],
+        ["beneficiary", "AccountId"],
+        ["ring_value", "Balance"],
+        ["kton_value", "Balance"],
+        ["ring_bond", "Balance"],
+        ["kton_bond", "Balance"]
       ]
     },
-    "Exposures": {
+    "MappedRing": "u128",
+    "EthereumTransactionIndex": "(H256, u64)",
+    "EthereumHeaderBrief": {
       "type": "struct",
       "type_mapping": [
-         ["total", "ExtendedBalance"],
-         ["own", "ExtendedBalance"],
-         ["others", "Vec<IndividualExpo>"]
+        ["total_difficulty", "U256"],
+        ["parent_hash", "H256"],
+        ["number", "EthereumBlockNumber"],
+        ["relayer", "AccountId"]
+      ]
+    },
+    "EthereumBlockNumber": "u64",
+    "EthereumHeaderThingWithProof": {
+      "type": "struct",
+      "type_mapping": [
+        ["header", "EthereumHeader"],
+        ["ethash_proof", "Vec<EthashProof>"],
+        ["mmr_root", "H256"],
+        ["mmr_proof", "Vec<H256>"]
+      ]
+    },
+    "EthereumHeaderThing": {
+      "type": "struct",
+      "type_mapping": [
+        ["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]"]
       ]
     },
-    "TokenBalance": "u128",
-    "Currency": "u128",
-    "CurrencyOf": "u128",
-    "Auction": {
+    "AddressT": "[u8; 20]",
+    "MerkleMountainRangeRootLog": {
       "type": "struct",
       "type_mapping": [
-         ["seller", "AccountId"],
-         ["startAt", "Moment"],
-         ["duration", "u64"],
-         ["startingPrice", "TokenBalance"],
-         ["endingPrice", "TokenBalance"],
-         ["lastRecord", "TokenBalance"],
-         ["lastBidder", "AccountId"],
-         ["lastBidStartAt", "Moment"]
+        ["prefix", "[u8; 4]"],
+        ["mmr_root", "Hash"]
       ]
     },
-    "DepositInfo": {
+    "Round": "u64",
+    "TcHeaderThingWithProof": "EthereumHeaderThingWithProof",
+    "TcHeaderThing": "EthereumHeaderThing",
+    "TcBlockNumber": "u64",
+    "TcHeaderHash": "H256",
+    "GameId": "TcBlockNumber",
+    "RelayProposalT": {
       "type": "struct",
       "type_mapping": [
-         ["month", "Moment"],
-         ["start_at", "Moment"],
-         ["value", "CurrencyOf"],
-         ["unit_interest", "u64"],
-         ["claimed", "bool"]
+        ["relayer", "AccountId"],
+        ["bonded_proposal", "Vec<(Balance, TcHeaderThing)>"],
+        ["extend_from_header_hash", "Option<TcHeaderHash>"]
       ]
     },
-    "Deposit": {
+    "BalancesRuntimeDispatchInfo": {
       "type": "struct",
       "type_mapping": [
-         ["total_deposit", "CurrencyOf"],
-         ["deposit_list", "Vec<DepositInfo>"]
+        ["usable_balance", "Balance"]
       ]
     },
-    "Revenue": {
+    "StakingRuntimeDispatchInfo": {
       "type": "struct",
       "type_mapping": [
-         ["team", "TokenBalance"],
-         ["contribution", "TokenBalance"],
-         ["ktoner", "TokenBalance"],
-         ["lottery", "TokenBalance"]
+        ["power", "Power"]
       ]
     }
   }