@dedot/chaintypes 0.0.1-next.f5bf4fc2.1 → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (144) hide show
  1. package/README.md +3 -1
  2. package/aleph/consts.d.ts +94 -13
  3. package/aleph/errors.d.ts +251 -182
  4. package/aleph/events.d.ts +319 -102
  5. package/aleph/index.d.ts +16 -11
  6. package/aleph/json-rpc.d.ts +76 -0
  7. package/aleph/query.d.ts +261 -168
  8. package/aleph/runtime.d.ts +90 -39
  9. package/aleph/tx.d.ts +1822 -1052
  10. package/aleph/types.d.ts +458 -138
  11. package/astar/consts.d.ts +112 -116
  12. package/astar/errors.d.ts +342 -409
  13. package/astar/events.d.ts +449 -358
  14. package/astar/index.d.ts +16 -11
  15. package/astar/json-rpc.d.ts +131 -0
  16. package/astar/query.d.ts +459 -367
  17. package/astar/runtime.d.ts +591 -98
  18. package/astar/tx.d.ts +2485 -3430
  19. package/astar/types.d.ts +1530 -4436
  20. package/index.d.ts +3 -0
  21. package/index.ts +3 -0
  22. package/kusama/consts.d.ts +54 -115
  23. package/kusama/errors.d.ts +696 -682
  24. package/kusama/events.d.ts +592 -407
  25. package/kusama/index.d.ts +16 -11
  26. package/kusama/json-rpc.d.ts +103 -0
  27. package/kusama/query.d.ts +840 -538
  28. package/kusama/runtime.d.ts +136 -65
  29. package/kusama/tx.d.ts +4557 -3051
  30. package/kusama/types.d.ts +1437 -1161
  31. package/kusamaAssetHub/consts.d.ts +66 -20
  32. package/kusamaAssetHub/errors.d.ts +428 -308
  33. package/kusamaAssetHub/events.d.ts +497 -305
  34. package/kusamaAssetHub/index.d.ts +16 -11
  35. package/kusamaAssetHub/json-rpc.d.ts +89 -0
  36. package/kusamaAssetHub/query.d.ts +376 -253
  37. package/kusamaAssetHub/runtime.d.ts +82 -41
  38. package/kusamaAssetHub/tx.d.ts +3264 -1955
  39. package/kusamaAssetHub/types.d.ts +1262 -726
  40. package/moonbeam/consts.d.ts +115 -170
  41. package/moonbeam/errors.d.ts +564 -787
  42. package/moonbeam/events.d.ts +583 -746
  43. package/moonbeam/index.d.ts +16 -11
  44. package/moonbeam/json-rpc.d.ts +137 -0
  45. package/moonbeam/query.d.ts +507 -607
  46. package/moonbeam/runtime.d.ts +132 -47
  47. package/moonbeam/tx.d.ts +3309 -3268
  48. package/moonbeam/types.d.ts +1484 -1375
  49. package/package.json +4 -14
  50. package/paseo/consts.d.ts +1331 -0
  51. package/paseo/errors.d.ts +2644 -0
  52. package/paseo/events.d.ts +2821 -0
  53. package/paseo/index.d.ts +27 -0
  54. package/paseo/json-rpc.d.ts +103 -0
  55. package/paseo/query.d.ts +3709 -0
  56. package/paseo/runtime.d.ts +1205 -0
  57. package/paseo/tx.d.ts +8024 -0
  58. package/paseo/types.d.ts +10194 -0
  59. package/polkadot/consts.d.ts +95 -50
  60. package/polkadot/errors.d.ts +619 -468
  61. package/polkadot/events.d.ts +582 -257
  62. package/polkadot/index.d.ts +16 -11
  63. package/polkadot/json-rpc.d.ts +103 -0
  64. package/polkadot/query.d.ts +770 -399
  65. package/polkadot/runtime.d.ts +136 -65
  66. package/polkadot/tx.d.ts +4268 -2368
  67. package/polkadot/types.d.ts +1570 -745
  68. package/polkadotAssetHub/consts.d.ts +154 -15
  69. package/polkadotAssetHub/errors.d.ts +615 -234
  70. package/polkadotAssetHub/events.d.ts +829 -270
  71. package/polkadotAssetHub/index.d.ts +16 -11
  72. package/polkadotAssetHub/json-rpc.d.ts +89 -0
  73. package/polkadotAssetHub/query.d.ts +438 -243
  74. package/polkadotAssetHub/runtime.d.ts +147 -40
  75. package/polkadotAssetHub/tx.d.ts +3747 -1643
  76. package/polkadotAssetHub/types.d.ts +2096 -806
  77. package/rococo/consts.d.ts +51 -32
  78. package/rococo/errors.d.ts +549 -605
  79. package/rococo/events.d.ts +447 -238
  80. package/rococo/index.d.ts +16 -11
  81. package/rococo/json-rpc.d.ts +103 -0
  82. package/rococo/query.d.ts +724 -426
  83. package/rococo/runtime.d.ts +366 -144
  84. package/rococo/tx.d.ts +6850 -3079
  85. package/rococo/types.d.ts +5959 -1619
  86. package/rococoAssetHub/consts.d.ts +92 -7
  87. package/rococoAssetHub/errors.d.ts +381 -285
  88. package/rococoAssetHub/events.d.ts +461 -140
  89. package/rococoAssetHub/index.d.ts +16 -11
  90. package/rococoAssetHub/json-rpc.d.ts +89 -0
  91. package/rococoAssetHub/query.d.ts +487 -174
  92. package/rococoAssetHub/runtime.d.ts +235 -51
  93. package/rococoAssetHub/tx.d.ts +6005 -2163
  94. package/rococoAssetHub/types.d.ts +6683 -1003
  95. package/substrate/consts.d.ts +233 -52
  96. package/substrate/errors.d.ts +966 -781
  97. package/substrate/events.d.ts +1226 -381
  98. package/substrate/index.d.ts +16 -11
  99. package/substrate/json-rpc.d.ts +103 -0
  100. package/substrate/query.d.ts +1090 -460
  101. package/substrate/runtime.d.ts +274 -71
  102. package/substrate/tx.d.ts +12313 -4510
  103. package/substrate/types.d.ts +11036 -1432
  104. package/westend/consts.d.ts +1349 -0
  105. package/westend/errors.d.ts +2736 -0
  106. package/westend/events.d.ts +2906 -0
  107. package/westend/index.d.ts +27 -0
  108. package/westend/json-rpc.d.ts +103 -0
  109. package/westend/query.d.ts +3855 -0
  110. package/westend/runtime.d.ts +1437 -0
  111. package/westend/tx.d.ts +10248 -0
  112. package/westend/types.d.ts +14769 -0
  113. package/westendAssetHub/consts.d.ts +126 -7
  114. package/westendAssetHub/errors.d.ts +426 -285
  115. package/westendAssetHub/events.d.ts +498 -140
  116. package/westendAssetHub/index.d.ts +16 -11
  117. package/westendAssetHub/json-rpc.d.ts +89 -0
  118. package/westendAssetHub/query.d.ts +526 -174
  119. package/westendAssetHub/runtime.d.ts +245 -56
  120. package/westendAssetHub/tx.d.ts +6196 -2166
  121. package/westendAssetHub/types.d.ts +6913 -1002
  122. package/westendPeople/consts.d.ts +434 -0
  123. package/westendPeople/errors.d.ts +769 -0
  124. package/westendPeople/events.d.ts +1082 -0
  125. package/westendPeople/index.d.ts +27 -0
  126. package/westendPeople/json-rpc.d.ts +89 -0
  127. package/westendPeople/query.d.ts +1209 -0
  128. package/westendPeople/runtime.d.ts +636 -0
  129. package/westendPeople/tx.d.ts +2891 -0
  130. package/westendPeople/types.d.ts +4984 -0
  131. package/aleph/rpc.d.ts +0 -727
  132. package/astar/rpc.d.ts +0 -974
  133. package/kusama/rpc.d.ts +0 -904
  134. package/kusamaAssetHub/rpc.d.ts +0 -746
  135. package/moonbeam/rpc.d.ts +0 -1015
  136. package/packageInfo.d.ts +0 -4
  137. package/packageInfo.js +0 -2
  138. package/packageInfo.ts +0 -3
  139. package/polkadot/rpc.d.ts +0 -904
  140. package/polkadotAssetHub/rpc.d.ts +0 -746
  141. package/rococo/rpc.d.ts +0 -904
  142. package/rococoAssetHub/rpc.d.ts +0 -746
  143. package/substrate/rpc.d.ts +0 -894
  144. package/westendAssetHub/rpc.d.ts +0 -746
@@ -1,26 +1,27 @@
1
- // Generated by @dedot/codegen
1
+ // Generated by dedot cli
2
2
 
3
- import type { GenericChainStorage, GenericStorageQuery, Callback } from '@dedot/types';
3
+ import type { GenericChainStorage, GenericStorageQuery, Callback, RpcVersion } from 'dedot/types';
4
4
  import type {
5
+ AccountId32,
5
6
  AccountId32Like,
6
7
  H256,
7
8
  Bytes,
8
9
  Digest,
9
10
  Phase,
10
11
  FixedBytes,
11
- AccountId32,
12
12
  FixedU128,
13
13
  Perbill,
14
14
  Percent,
15
15
  BytesLike,
16
16
  Data,
17
17
  FixedU64,
18
- } from '@dedot/codecs';
18
+ } from 'dedot/codecs';
19
19
  import type {
20
20
  FrameSystemAccountInfo,
21
21
  FrameSupportDispatchPerDispatchClass,
22
22
  FrameSystemEventRecord,
23
23
  FrameSystemLastRuntimeUpgradeInfo,
24
+ FrameSystemCodeUpgradeAuthorization,
24
25
  SpConsensusBabeAppPublic,
25
26
  SpConsensusSlotsSlot,
26
27
  SpConsensusBabeDigestsNextConfigDescriptor,
@@ -30,7 +31,7 @@ import type {
30
31
  PalletBalancesBalanceLock,
31
32
  PalletBalancesReserveData,
32
33
  PalletBalancesIdAmount,
33
- PalletBalancesIdAmount002,
34
+ PalletBalancesIdAmountRuntimeFreezeReason,
34
35
  PalletTransactionPaymentReleases,
35
36
  PalletElectionProviderMultiPhasePhase,
36
37
  PalletElectionProviderMultiPhaseReadySolution,
@@ -43,7 +44,9 @@ import type {
43
44
  PalletStakingValidatorPrefs,
44
45
  PalletStakingNominations,
45
46
  PalletStakingActiveEraInfo,
46
- PalletStakingExposure,
47
+ SpStakingExposure,
48
+ SpStakingPagedExposureMetadata,
49
+ SpStakingExposurePage,
47
50
  PalletStakingEraRewardPoints,
48
51
  PalletStakingForcing,
49
52
  PalletStakingUnappliedSlash,
@@ -62,7 +65,9 @@ import type {
62
65
  PalletElectionsPhragmenVoter,
63
66
  PalletGrandpaStoredState,
64
67
  PalletGrandpaStoredPendingChange,
68
+ SpConsensusGrandpaAppPublic,
65
69
  PalletTreasuryProposal,
70
+ PalletTreasurySpendStatus,
66
71
  PalletContractsWasmCodeInfo,
67
72
  PalletContractsStorageContractInfo,
68
73
  PalletContractsStorageDeletionQueueManager,
@@ -71,6 +76,7 @@ import type {
71
76
  SpStakingOffenceOffenceDetails,
72
77
  PalletIdentityRegistration,
73
78
  PalletIdentityRegistrarInfo,
79
+ PalletIdentityAuthorityProperties,
74
80
  PalletSocietyGroupParams,
75
81
  PalletSocietyMemberRecord,
76
82
  PalletSocietyPayoutRecord,
@@ -84,6 +90,8 @@ import type {
84
90
  PalletVestingVestingInfo,
85
91
  PalletVestingReleases,
86
92
  PalletSchedulerScheduled,
93
+ PalletSchedulerRetryConfig,
94
+ PalletPreimageOldRequestStatus,
87
95
  PalletPreimageRequestStatus,
88
96
  PalletProxyProxyDefinition,
89
97
  PalletProxyAnnouncement,
@@ -94,6 +102,8 @@ import type {
94
102
  PalletAssetsAssetAccount,
95
103
  PalletAssetsApproval,
96
104
  PalletAssetsAssetMetadata,
105
+ SpConsensusBeefyEcdsaCryptoPublic,
106
+ SpConsensusBeefyMmrBeefyAuthoritySet,
97
107
  PalletLotteryLotteryConfig,
98
108
  PalletNisBid,
99
109
  PalletNisSummaryRecord,
@@ -137,10 +147,11 @@ import type {
137
147
  PalletRankedCollectiveMemberRecord,
138
148
  PalletRankedCollectiveVoteRecord,
139
149
  PalletAssetConversionPoolInfo,
140
- PalletAssetConversionNativeOrAssetId,
150
+ FrameSupportTokensFungibleUnionOfNativeOrWithId,
141
151
  PalletFastUnstakeUnstakeRequest,
142
152
  PalletMessageQueueBookState,
143
153
  PalletMessageQueuePage,
154
+ PalletMigrationsMigrationCursor,
144
155
  PalletBrokerConfigRecord,
145
156
  PalletBrokerScheduleItem,
146
157
  PalletBrokerLeaseRecordItem,
@@ -153,9 +164,13 @@ import type {
153
164
  PalletBrokerContributionRecord,
154
165
  PalletBrokerPoolIoRecord,
155
166
  PalletBrokerInstaPoolHistoryRecord,
167
+ SpMixnetAppPublic,
168
+ PalletMixnetBoundedMixnode,
169
+ KitchensinkRuntimeRuntimeParametersValue,
170
+ KitchensinkRuntimeRuntimeParametersKey,
156
171
  } from './types';
157
172
 
158
- export interface ChainStorage extends GenericChainStorage {
173
+ export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage<Rv> {
159
174
  /**
160
175
  * Pallet `System`'s storage queries
161
176
  **/
@@ -166,28 +181,35 @@ export interface ChainStorage extends GenericChainStorage {
166
181
  * @param {AccountId32Like} arg
167
182
  * @param {Callback<FrameSystemAccountInfo> =} callback
168
183
  **/
169
- account: GenericStorageQuery<(arg: AccountId32Like) => FrameSystemAccountInfo>;
184
+ account: GenericStorageQuery<Rv, (arg: AccountId32Like) => FrameSystemAccountInfo, AccountId32>;
170
185
 
171
186
  /**
172
187
  * Total extrinsics count for the current block.
173
188
  *
174
189
  * @param {Callback<number | undefined> =} callback
175
190
  **/
176
- extrinsicCount: GenericStorageQuery<() => number | undefined>;
191
+ extrinsicCount: GenericStorageQuery<Rv, () => number | undefined>;
192
+
193
+ /**
194
+ * Whether all inherents have been applied.
195
+ *
196
+ * @param {Callback<boolean> =} callback
197
+ **/
198
+ inherentsApplied: GenericStorageQuery<Rv, () => boolean>;
177
199
 
178
200
  /**
179
201
  * The current weight for the block.
180
202
  *
181
203
  * @param {Callback<FrameSupportDispatchPerDispatchClass> =} callback
182
204
  **/
183
- blockWeight: GenericStorageQuery<() => FrameSupportDispatchPerDispatchClass>;
205
+ blockWeight: GenericStorageQuery<Rv, () => FrameSupportDispatchPerDispatchClass>;
184
206
 
185
207
  /**
186
208
  * Total length (in bytes) for all extrinsics put together, for the current block.
187
209
  *
188
210
  * @param {Callback<number | undefined> =} callback
189
211
  **/
190
- allExtrinsicsLen: GenericStorageQuery<() => number | undefined>;
212
+ allExtrinsicsLen: GenericStorageQuery<Rv, () => number | undefined>;
191
213
 
192
214
  /**
193
215
  * Map of block numbers to block hashes.
@@ -195,7 +217,7 @@ export interface ChainStorage extends GenericChainStorage {
195
217
  * @param {number} arg
196
218
  * @param {Callback<H256> =} callback
197
219
  **/
198
- blockHash: GenericStorageQuery<(arg: number) => H256>;
220
+ blockHash: GenericStorageQuery<Rv, (arg: number) => H256, number>;
199
221
 
200
222
  /**
201
223
  * Extrinsics data for the current block (maps an extrinsic's index to its data).
@@ -203,28 +225,28 @@ export interface ChainStorage extends GenericChainStorage {
203
225
  * @param {number} arg
204
226
  * @param {Callback<Bytes> =} callback
205
227
  **/
206
- extrinsicData: GenericStorageQuery<(arg: number) => Bytes>;
228
+ extrinsicData: GenericStorageQuery<Rv, (arg: number) => Bytes, number>;
207
229
 
208
230
  /**
209
231
  * The current block number being processed. Set by `execute_block`.
210
232
  *
211
233
  * @param {Callback<number> =} callback
212
234
  **/
213
- number: GenericStorageQuery<() => number>;
235
+ number: GenericStorageQuery<Rv, () => number>;
214
236
 
215
237
  /**
216
238
  * Hash of the previous block.
217
239
  *
218
240
  * @param {Callback<H256> =} callback
219
241
  **/
220
- parentHash: GenericStorageQuery<() => H256>;
242
+ parentHash: GenericStorageQuery<Rv, () => H256>;
221
243
 
222
244
  /**
223
245
  * Digest of the current block, also part of the block header.
224
246
  *
225
247
  * @param {Callback<Digest> =} callback
226
248
  **/
227
- digest: GenericStorageQuery<() => Digest>;
249
+ digest: GenericStorageQuery<Rv, () => Digest>;
228
250
 
229
251
  /**
230
252
  * Events deposited for the current block.
@@ -237,14 +259,14 @@ export interface ChainStorage extends GenericChainStorage {
237
259
  *
238
260
  * @param {Callback<Array<FrameSystemEventRecord>> =} callback
239
261
  **/
240
- events: GenericStorageQuery<() => Array<FrameSystemEventRecord>>;
262
+ events: GenericStorageQuery<Rv, () => Array<FrameSystemEventRecord>>;
241
263
 
242
264
  /**
243
265
  * The number of events in the `Events<T>` list.
244
266
  *
245
267
  * @param {Callback<number> =} callback
246
268
  **/
247
- eventCount: GenericStorageQuery<() => number>;
269
+ eventCount: GenericStorageQuery<Rv, () => number>;
248
270
 
249
271
  /**
250
272
  * Mapping between a topic (represented by T::Hash) and a vector of indexes
@@ -261,21 +283,21 @@ export interface ChainStorage extends GenericChainStorage {
261
283
  * @param {H256} arg
262
284
  * @param {Callback<Array<[number, number]>> =} callback
263
285
  **/
264
- eventTopics: GenericStorageQuery<(arg: H256) => Array<[number, number]>>;
286
+ eventTopics: GenericStorageQuery<Rv, (arg: H256) => Array<[number, number]>, H256>;
265
287
 
266
288
  /**
267
289
  * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
268
290
  *
269
291
  * @param {Callback<FrameSystemLastRuntimeUpgradeInfo | undefined> =} callback
270
292
  **/
271
- lastRuntimeUpgrade: GenericStorageQuery<() => FrameSystemLastRuntimeUpgradeInfo | undefined>;
293
+ lastRuntimeUpgrade: GenericStorageQuery<Rv, () => FrameSystemLastRuntimeUpgradeInfo | undefined>;
272
294
 
273
295
  /**
274
296
  * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
275
297
  *
276
298
  * @param {Callback<boolean> =} callback
277
299
  **/
278
- upgradedToU32RefCount: GenericStorageQuery<() => boolean>;
300
+ upgradedToU32RefCount: GenericStorageQuery<Rv, () => boolean>;
279
301
 
280
302
  /**
281
303
  * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
@@ -283,19 +305,26 @@ export interface ChainStorage extends GenericChainStorage {
283
305
  *
284
306
  * @param {Callback<boolean> =} callback
285
307
  **/
286
- upgradedToTripleRefCount: GenericStorageQuery<() => boolean>;
308
+ upgradedToTripleRefCount: GenericStorageQuery<Rv, () => boolean>;
287
309
 
288
310
  /**
289
311
  * The execution phase of the block.
290
312
  *
291
313
  * @param {Callback<Phase | undefined> =} callback
292
314
  **/
293
- executionPhase: GenericStorageQuery<() => Phase | undefined>;
315
+ executionPhase: GenericStorageQuery<Rv, () => Phase | undefined>;
316
+
317
+ /**
318
+ * `Some` if a code upgrade has been authorized.
319
+ *
320
+ * @param {Callback<FrameSystemCodeUpgradeAuthorization | undefined> =} callback
321
+ **/
322
+ authorizedUpgrade: GenericStorageQuery<Rv, () => FrameSystemCodeUpgradeAuthorization | undefined>;
294
323
 
295
324
  /**
296
325
  * Generic pallet storage query
297
326
  **/
298
- [storage: string]: GenericStorageQuery;
327
+ [storage: string]: GenericStorageQuery<Rv>;
299
328
  };
300
329
  /**
301
330
  * Pallet `Babe`'s storage queries
@@ -306,14 +335,14 @@ export interface ChainStorage extends GenericChainStorage {
306
335
  *
307
336
  * @param {Callback<bigint> =} callback
308
337
  **/
309
- epochIndex: GenericStorageQuery<() => bigint>;
338
+ epochIndex: GenericStorageQuery<Rv, () => bigint>;
310
339
 
311
340
  /**
312
341
  * Current epoch authorities.
313
342
  *
314
343
  * @param {Callback<Array<[SpConsensusBabeAppPublic, bigint]>> =} callback
315
344
  **/
316
- authorities: GenericStorageQuery<() => Array<[SpConsensusBabeAppPublic, bigint]>>;
345
+ authorities: GenericStorageQuery<Rv, () => Array<[SpConsensusBabeAppPublic, bigint]>>;
317
346
 
318
347
  /**
319
348
  * The slot at which the first epoch actually started. This is 0
@@ -321,14 +350,14 @@ export interface ChainStorage extends GenericChainStorage {
321
350
  *
322
351
  * @param {Callback<SpConsensusSlotsSlot> =} callback
323
352
  **/
324
- genesisSlot: GenericStorageQuery<() => SpConsensusSlotsSlot>;
353
+ genesisSlot: GenericStorageQuery<Rv, () => SpConsensusSlotsSlot>;
325
354
 
326
355
  /**
327
356
  * Current slot number.
328
357
  *
329
358
  * @param {Callback<SpConsensusSlotsSlot> =} callback
330
359
  **/
331
- currentSlot: GenericStorageQuery<() => SpConsensusSlotsSlot>;
360
+ currentSlot: GenericStorageQuery<Rv, () => SpConsensusSlotsSlot>;
332
361
 
333
362
  /**
334
363
  * The epoch randomness for the *current* epoch.
@@ -344,28 +373,28 @@ export interface ChainStorage extends GenericChainStorage {
344
373
  *
345
374
  * @param {Callback<FixedBytes<32>> =} callback
346
375
  **/
347
- randomness: GenericStorageQuery<() => FixedBytes<32>>;
376
+ randomness: GenericStorageQuery<Rv, () => FixedBytes<32>>;
348
377
 
349
378
  /**
350
379
  * Pending epoch configuration change that will be applied when the next epoch is enacted.
351
380
  *
352
381
  * @param {Callback<SpConsensusBabeDigestsNextConfigDescriptor | undefined> =} callback
353
382
  **/
354
- pendingEpochConfigChange: GenericStorageQuery<() => SpConsensusBabeDigestsNextConfigDescriptor | undefined>;
383
+ pendingEpochConfigChange: GenericStorageQuery<Rv, () => SpConsensusBabeDigestsNextConfigDescriptor | undefined>;
355
384
 
356
385
  /**
357
386
  * Next epoch randomness.
358
387
  *
359
388
  * @param {Callback<FixedBytes<32>> =} callback
360
389
  **/
361
- nextRandomness: GenericStorageQuery<() => FixedBytes<32>>;
390
+ nextRandomness: GenericStorageQuery<Rv, () => FixedBytes<32>>;
362
391
 
363
392
  /**
364
393
  * Next epoch authorities.
365
394
  *
366
395
  * @param {Callback<Array<[SpConsensusBabeAppPublic, bigint]>> =} callback
367
396
  **/
368
- nextAuthorities: GenericStorageQuery<() => Array<[SpConsensusBabeAppPublic, bigint]>>;
397
+ nextAuthorities: GenericStorageQuery<Rv, () => Array<[SpConsensusBabeAppPublic, bigint]>>;
369
398
 
370
399
  /**
371
400
  * Randomness under construction.
@@ -380,7 +409,7 @@ export interface ChainStorage extends GenericChainStorage {
380
409
  *
381
410
  * @param {Callback<number> =} callback
382
411
  **/
383
- segmentIndex: GenericStorageQuery<() => number>;
412
+ segmentIndex: GenericStorageQuery<Rv, () => number>;
384
413
 
385
414
  /**
386
415
  * TWOX-NOTE: `SegmentIndex` is an increasing integer, so this is okay.
@@ -388,7 +417,7 @@ export interface ChainStorage extends GenericChainStorage {
388
417
  * @param {number} arg
389
418
  * @param {Callback<Array<FixedBytes<32>>> =} callback
390
419
  **/
391
- underConstruction: GenericStorageQuery<(arg: number) => Array<FixedBytes<32>>>;
420
+ underConstruction: GenericStorageQuery<Rv, (arg: number) => Array<FixedBytes<32>>, number>;
392
421
 
393
422
  /**
394
423
  * Temporary value (cleared at block finalization) which is `Some`
@@ -396,7 +425,7 @@ export interface ChainStorage extends GenericChainStorage {
396
425
  *
397
426
  * @param {Callback<SpConsensusBabeDigestsPreDigest | undefined | undefined> =} callback
398
427
  **/
399
- initialized: GenericStorageQuery<() => SpConsensusBabeDigestsPreDigest | undefined | undefined>;
428
+ initialized: GenericStorageQuery<Rv, () => SpConsensusBabeDigestsPreDigest | undefined | undefined>;
400
429
 
401
430
  /**
402
431
  * This field should always be populated during block processing unless
@@ -406,7 +435,7 @@ export interface ChainStorage extends GenericChainStorage {
406
435
  *
407
436
  * @param {Callback<FixedBytes<32> | undefined> =} callback
408
437
  **/
409
- authorVrfRandomness: GenericStorageQuery<() => FixedBytes<32> | undefined>;
438
+ authorVrfRandomness: GenericStorageQuery<Rv, () => FixedBytes<32> | undefined>;
410
439
 
411
440
  /**
412
441
  * The block numbers when the last and current epoch have started, respectively `N-1` and
@@ -417,7 +446,7 @@ export interface ChainStorage extends GenericChainStorage {
417
446
  *
418
447
  * @param {Callback<[number, number]> =} callback
419
448
  **/
420
- epochStart: GenericStorageQuery<() => [number, number]>;
449
+ epochStart: GenericStorageQuery<Rv, () => [number, number]>;
421
450
 
422
451
  /**
423
452
  * How late the current block is compared to its parent.
@@ -428,7 +457,7 @@ export interface ChainStorage extends GenericChainStorage {
428
457
  *
429
458
  * @param {Callback<number> =} callback
430
459
  **/
431
- lateness: GenericStorageQuery<() => number>;
460
+ lateness: GenericStorageQuery<Rv, () => number>;
432
461
 
433
462
  /**
434
463
  * The configuration for the current epoch. Should never be `None` as it is initialized in
@@ -436,7 +465,7 @@ export interface ChainStorage extends GenericChainStorage {
436
465
  *
437
466
  * @param {Callback<SpConsensusBabeBabeEpochConfiguration | undefined> =} callback
438
467
  **/
439
- epochConfig: GenericStorageQuery<() => SpConsensusBabeBabeEpochConfiguration | undefined>;
468
+ epochConfig: GenericStorageQuery<Rv, () => SpConsensusBabeBabeEpochConfiguration | undefined>;
440
469
 
441
470
  /**
442
471
  * The configuration for the next epoch, `None` if the config will not change
@@ -444,7 +473,7 @@ export interface ChainStorage extends GenericChainStorage {
444
473
  *
445
474
  * @param {Callback<SpConsensusBabeBabeEpochConfiguration | undefined> =} callback
446
475
  **/
447
- nextEpochConfig: GenericStorageQuery<() => SpConsensusBabeBabeEpochConfiguration | undefined>;
476
+ nextEpochConfig: GenericStorageQuery<Rv, () => SpConsensusBabeBabeEpochConfiguration | undefined>;
448
477
 
449
478
  /**
450
479
  * A list of the last 100 skipped epochs and the corresponding session index
@@ -458,35 +487,38 @@ export interface ChainStorage extends GenericChainStorage {
458
487
  *
459
488
  * @param {Callback<Array<[bigint, number]>> =} callback
460
489
  **/
461
- skippedEpochs: GenericStorageQuery<() => Array<[bigint, number]>>;
490
+ skippedEpochs: GenericStorageQuery<Rv, () => Array<[bigint, number]>>;
462
491
 
463
492
  /**
464
493
  * Generic pallet storage query
465
494
  **/
466
- [storage: string]: GenericStorageQuery;
495
+ [storage: string]: GenericStorageQuery<Rv>;
467
496
  };
468
497
  /**
469
498
  * Pallet `Timestamp`'s storage queries
470
499
  **/
471
500
  timestamp: {
472
501
  /**
473
- * Current time for the current block.
502
+ * The current time for the current block.
474
503
  *
475
504
  * @param {Callback<bigint> =} callback
476
505
  **/
477
- now: GenericStorageQuery<() => bigint>;
506
+ now: GenericStorageQuery<Rv, () => bigint>;
478
507
 
479
508
  /**
480
- * Did the timestamp get updated in this block?
509
+ * Whether the timestamp has been updated in this block.
510
+ *
511
+ * This value is updated to `true` upon successful submission of a timestamp by a node.
512
+ * It is then checked at the end of each block execution in the `on_finalize` hook.
481
513
  *
482
514
  * @param {Callback<boolean> =} callback
483
515
  **/
484
- didUpdate: GenericStorageQuery<() => boolean>;
516
+ didUpdate: GenericStorageQuery<Rv, () => boolean>;
485
517
 
486
518
  /**
487
519
  * Generic pallet storage query
488
520
  **/
489
- [storage: string]: GenericStorageQuery;
521
+ [storage: string]: GenericStorageQuery<Rv>;
490
522
  };
491
523
  /**
492
524
  * Pallet `Authorship`'s storage queries
@@ -497,12 +529,12 @@ export interface ChainStorage extends GenericChainStorage {
497
529
  *
498
530
  * @param {Callback<AccountId32 | undefined> =} callback
499
531
  **/
500
- author: GenericStorageQuery<() => AccountId32 | undefined>;
532
+ author: GenericStorageQuery<Rv, () => AccountId32 | undefined>;
501
533
 
502
534
  /**
503
535
  * Generic pallet storage query
504
536
  **/
505
- [storage: string]: GenericStorageQuery;
537
+ [storage: string]: GenericStorageQuery<Rv>;
506
538
  };
507
539
  /**
508
540
  * Pallet `Indices`'s storage queries
@@ -514,12 +546,12 @@ export interface ChainStorage extends GenericChainStorage {
514
546
  * @param {number} arg
515
547
  * @param {Callback<[AccountId32, bigint, boolean] | undefined> =} callback
516
548
  **/
517
- accounts: GenericStorageQuery<(arg: number) => [AccountId32, bigint, boolean] | undefined>;
549
+ accounts: GenericStorageQuery<Rv, (arg: number) => [AccountId32, bigint, boolean] | undefined, number>;
518
550
 
519
551
  /**
520
552
  * Generic pallet storage query
521
553
  **/
522
- [storage: string]: GenericStorageQuery;
554
+ [storage: string]: GenericStorageQuery<Rv>;
523
555
  };
524
556
  /**
525
557
  * Pallet `Balances`'s storage queries
@@ -530,14 +562,14 @@ export interface ChainStorage extends GenericChainStorage {
530
562
  *
531
563
  * @param {Callback<bigint> =} callback
532
564
  **/
533
- totalIssuance: GenericStorageQuery<() => bigint>;
565
+ totalIssuance: GenericStorageQuery<Rv, () => bigint>;
534
566
 
535
567
  /**
536
568
  * The total units of outstanding deactivated balance in the system.
537
569
  *
538
570
  * @param {Callback<bigint> =} callback
539
571
  **/
540
- inactiveIssuance: GenericStorageQuery<() => bigint>;
572
+ inactiveIssuance: GenericStorageQuery<Rv, () => bigint>;
541
573
 
542
574
  /**
543
575
  * The Balances pallet example of storing the balance of an account.
@@ -568,7 +600,7 @@ export interface ChainStorage extends GenericChainStorage {
568
600
  * @param {AccountId32Like} arg
569
601
  * @param {Callback<PalletBalancesAccountData> =} callback
570
602
  **/
571
- account: GenericStorageQuery<(arg: AccountId32Like) => PalletBalancesAccountData>;
603
+ account: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletBalancesAccountData, AccountId32>;
572
604
 
573
605
  /**
574
606
  * Any liquidity locks on some account balances.
@@ -577,7 +609,7 @@ export interface ChainStorage extends GenericChainStorage {
577
609
  * @param {AccountId32Like} arg
578
610
  * @param {Callback<Array<PalletBalancesBalanceLock>> =} callback
579
611
  **/
580
- locks: GenericStorageQuery<(arg: AccountId32Like) => Array<PalletBalancesBalanceLock>>;
612
+ locks: GenericStorageQuery<Rv, (arg: AccountId32Like) => Array<PalletBalancesBalanceLock>, AccountId32>;
581
613
 
582
614
  /**
583
615
  * Named reserves on some account balances.
@@ -585,7 +617,7 @@ export interface ChainStorage extends GenericChainStorage {
585
617
  * @param {AccountId32Like} arg
586
618
  * @param {Callback<Array<PalletBalancesReserveData>> =} callback
587
619
  **/
588
- reserves: GenericStorageQuery<(arg: AccountId32Like) => Array<PalletBalancesReserveData>>;
620
+ reserves: GenericStorageQuery<Rv, (arg: AccountId32Like) => Array<PalletBalancesReserveData>, AccountId32>;
589
621
 
590
622
  /**
591
623
  * Holds on account balances.
@@ -593,20 +625,24 @@ export interface ChainStorage extends GenericChainStorage {
593
625
  * @param {AccountId32Like} arg
594
626
  * @param {Callback<Array<PalletBalancesIdAmount>> =} callback
595
627
  **/
596
- holds: GenericStorageQuery<(arg: AccountId32Like) => Array<PalletBalancesIdAmount>>;
628
+ holds: GenericStorageQuery<Rv, (arg: AccountId32Like) => Array<PalletBalancesIdAmount>, AccountId32>;
597
629
 
598
630
  /**
599
631
  * Freeze locks on account balances.
600
632
  *
601
633
  * @param {AccountId32Like} arg
602
- * @param {Callback<Array<PalletBalancesIdAmount002>> =} callback
634
+ * @param {Callback<Array<PalletBalancesIdAmountRuntimeFreezeReason>> =} callback
603
635
  **/
604
- freezes: GenericStorageQuery<(arg: AccountId32Like) => Array<PalletBalancesIdAmount002>>;
636
+ freezes: GenericStorageQuery<
637
+ Rv,
638
+ (arg: AccountId32Like) => Array<PalletBalancesIdAmountRuntimeFreezeReason>,
639
+ AccountId32
640
+ >;
605
641
 
606
642
  /**
607
643
  * Generic pallet storage query
608
644
  **/
609
- [storage: string]: GenericStorageQuery;
645
+ [storage: string]: GenericStorageQuery<Rv>;
610
646
  };
611
647
  /**
612
648
  * Pallet `TransactionPayment`'s storage queries
@@ -616,18 +652,18 @@ export interface ChainStorage extends GenericChainStorage {
616
652
  *
617
653
  * @param {Callback<FixedU128> =} callback
618
654
  **/
619
- nextFeeMultiplier: GenericStorageQuery<() => FixedU128>;
655
+ nextFeeMultiplier: GenericStorageQuery<Rv, () => FixedU128>;
620
656
 
621
657
  /**
622
658
  *
623
659
  * @param {Callback<PalletTransactionPaymentReleases> =} callback
624
660
  **/
625
- storageVersion: GenericStorageQuery<() => PalletTransactionPaymentReleases>;
661
+ storageVersion: GenericStorageQuery<Rv, () => PalletTransactionPaymentReleases>;
626
662
 
627
663
  /**
628
664
  * Generic pallet storage query
629
665
  **/
630
- [storage: string]: GenericStorageQuery;
666
+ [storage: string]: GenericStorageQuery<Rv>;
631
667
  };
632
668
  /**
633
669
  * Pallet `ElectionProviderMultiPhase`'s storage queries
@@ -643,14 +679,14 @@ export interface ChainStorage extends GenericChainStorage {
643
679
  *
644
680
  * @param {Callback<number> =} callback
645
681
  **/
646
- round: GenericStorageQuery<() => number>;
682
+ round: GenericStorageQuery<Rv, () => number>;
647
683
 
648
684
  /**
649
685
  * Current phase.
650
686
  *
651
687
  * @param {Callback<PalletElectionProviderMultiPhasePhase> =} callback
652
688
  **/
653
- currentPhase: GenericStorageQuery<() => PalletElectionProviderMultiPhasePhase>;
689
+ currentPhase: GenericStorageQuery<Rv, () => PalletElectionProviderMultiPhasePhase>;
654
690
 
655
691
  /**
656
692
  * Current best solution, signed or unsigned, queued to be returned upon `elect`.
@@ -659,34 +695,37 @@ export interface ChainStorage extends GenericChainStorage {
659
695
  *
660
696
  * @param {Callback<PalletElectionProviderMultiPhaseReadySolution | undefined> =} callback
661
697
  **/
662
- queuedSolution: GenericStorageQuery<() => PalletElectionProviderMultiPhaseReadySolution | undefined>;
698
+ queuedSolution: GenericStorageQuery<Rv, () => PalletElectionProviderMultiPhaseReadySolution | undefined>;
663
699
 
664
700
  /**
665
701
  * Snapshot data of the round.
666
702
  *
667
703
  * This is created at the beginning of the signed phase and cleared upon calling `elect`.
704
+ * Note: This storage type must only be mutated through [`SnapshotWrapper`].
668
705
  *
669
706
  * @param {Callback<PalletElectionProviderMultiPhaseRoundSnapshot | undefined> =} callback
670
707
  **/
671
- snapshot: GenericStorageQuery<() => PalletElectionProviderMultiPhaseRoundSnapshot | undefined>;
708
+ snapshot: GenericStorageQuery<Rv, () => PalletElectionProviderMultiPhaseRoundSnapshot | undefined>;
672
709
 
673
710
  /**
674
711
  * Desired number of targets to elect for this round.
675
712
  *
676
713
  * Only exists when [`Snapshot`] is present.
714
+ * Note: This storage type must only be mutated through [`SnapshotWrapper`].
677
715
  *
678
716
  * @param {Callback<number | undefined> =} callback
679
717
  **/
680
- desiredTargets: GenericStorageQuery<() => number | undefined>;
718
+ desiredTargets: GenericStorageQuery<Rv, () => number | undefined>;
681
719
 
682
720
  /**
683
721
  * The metadata of the [`RoundSnapshot`]
684
722
  *
685
723
  * Only exists when [`Snapshot`] is present.
724
+ * Note: This storage type must only be mutated through [`SnapshotWrapper`].
686
725
  *
687
726
  * @param {Callback<PalletElectionProviderMultiPhaseSolutionOrSnapshotSize | undefined> =} callback
688
727
  **/
689
- snapshotMetadata: GenericStorageQuery<() => PalletElectionProviderMultiPhaseSolutionOrSnapshotSize | undefined>;
728
+ snapshotMetadata: GenericStorageQuery<Rv, () => PalletElectionProviderMultiPhaseSolutionOrSnapshotSize | undefined>;
690
729
 
691
730
  /**
692
731
  * The next index to be assigned to an incoming signed submission.
@@ -701,7 +740,7 @@ export interface ChainStorage extends GenericChainStorage {
701
740
  *
702
741
  * @param {Callback<number> =} callback
703
742
  **/
704
- signedSubmissionNextIndex: GenericStorageQuery<() => number>;
743
+ signedSubmissionNextIndex: GenericStorageQuery<Rv, () => number>;
705
744
 
706
745
  /**
707
746
  * A sorted, bounded vector of `(score, block_number, index)`, where each `index` points to a
@@ -713,7 +752,7 @@ export interface ChainStorage extends GenericChainStorage {
713
752
  *
714
753
  * @param {Callback<Array<[SpNposElectionsElectionScore, number, number]>> =} callback
715
754
  **/
716
- signedSubmissionIndices: GenericStorageQuery<() => Array<[SpNposElectionsElectionScore, number, number]>>;
755
+ signedSubmissionIndices: GenericStorageQuery<Rv, () => Array<[SpNposElectionsElectionScore, number, number]>>;
717
756
 
718
757
  /**
719
758
  * Unchecked, signed solutions.
@@ -728,7 +767,9 @@ export interface ChainStorage extends GenericChainStorage {
728
767
  * @param {Callback<PalletElectionProviderMultiPhaseSignedSignedSubmission | undefined> =} callback
729
768
  **/
730
769
  signedSubmissionsMap: GenericStorageQuery<
731
- (arg: number) => PalletElectionProviderMultiPhaseSignedSignedSubmission | undefined
770
+ Rv,
771
+ (arg: number) => PalletElectionProviderMultiPhaseSignedSignedSubmission | undefined,
772
+ number
732
773
  >;
733
774
 
734
775
  /**
@@ -739,12 +780,12 @@ export interface ChainStorage extends GenericChainStorage {
739
780
  *
740
781
  * @param {Callback<SpNposElectionsElectionScore | undefined> =} callback
741
782
  **/
742
- minimumUntrustedScore: GenericStorageQuery<() => SpNposElectionsElectionScore | undefined>;
783
+ minimumUntrustedScore: GenericStorageQuery<Rv, () => SpNposElectionsElectionScore | undefined>;
743
784
 
744
785
  /**
745
786
  * Generic pallet storage query
746
787
  **/
747
- [storage: string]: GenericStorageQuery;
788
+ [storage: string]: GenericStorageQuery<Rv>;
748
789
  };
749
790
  /**
750
791
  * Pallet `Staking`'s storage queries
@@ -755,14 +796,14 @@ export interface ChainStorage extends GenericChainStorage {
755
796
  *
756
797
  * @param {Callback<number> =} callback
757
798
  **/
758
- validatorCount: GenericStorageQuery<() => number>;
799
+ validatorCount: GenericStorageQuery<Rv, () => number>;
759
800
 
760
801
  /**
761
802
  * Minimum number of staking participants before emergency conditions are imposed.
762
803
  *
763
804
  * @param {Callback<number> =} callback
764
805
  **/
765
- minimumValidatorCount: GenericStorageQuery<() => number>;
806
+ minimumValidatorCount: GenericStorageQuery<Rv, () => number>;
766
807
 
767
808
  /**
768
809
  * Any validators that may never be slashed or forcibly kicked. It's a Vec since they're
@@ -771,7 +812,7 @@ export interface ChainStorage extends GenericChainStorage {
771
812
  *
772
813
  * @param {Callback<Array<AccountId32>> =} callback
773
814
  **/
774
- invulnerables: GenericStorageQuery<() => Array<AccountId32>>;
815
+ invulnerables: GenericStorageQuery<Rv, () => Array<AccountId32>>;
775
816
 
776
817
  /**
777
818
  * Map from all locked "stash" accounts to the controller account.
@@ -781,28 +822,28 @@ export interface ChainStorage extends GenericChainStorage {
781
822
  * @param {AccountId32Like} arg
782
823
  * @param {Callback<AccountId32 | undefined> =} callback
783
824
  **/
784
- bonded: GenericStorageQuery<(arg: AccountId32Like) => AccountId32 | undefined>;
825
+ bonded: GenericStorageQuery<Rv, (arg: AccountId32Like) => AccountId32 | undefined, AccountId32>;
785
826
 
786
827
  /**
787
828
  * The minimum active bond to become and maintain the role of a nominator.
788
829
  *
789
830
  * @param {Callback<bigint> =} callback
790
831
  **/
791
- minNominatorBond: GenericStorageQuery<() => bigint>;
832
+ minNominatorBond: GenericStorageQuery<Rv, () => bigint>;
792
833
 
793
834
  /**
794
835
  * The minimum active bond to become and maintain the role of a validator.
795
836
  *
796
837
  * @param {Callback<bigint> =} callback
797
838
  **/
798
- minValidatorBond: GenericStorageQuery<() => bigint>;
839
+ minValidatorBond: GenericStorageQuery<Rv, () => bigint>;
799
840
 
800
841
  /**
801
842
  * The minimum active nominator stake of the last successful election.
802
843
  *
803
844
  * @param {Callback<bigint> =} callback
804
845
  **/
805
- minimumActiveStake: GenericStorageQuery<() => bigint>;
846
+ minimumActiveStake: GenericStorageQuery<Rv, () => bigint>;
806
847
 
807
848
  /**
808
849
  * The minimum amount of commission that validators can set.
@@ -811,15 +852,18 @@ export interface ChainStorage extends GenericChainStorage {
811
852
  *
812
853
  * @param {Callback<Perbill> =} callback
813
854
  **/
814
- minCommission: GenericStorageQuery<() => Perbill>;
855
+ minCommission: GenericStorageQuery<Rv, () => Perbill>;
815
856
 
816
857
  /**
817
858
  * Map from all (unlocked) "controller" accounts to the info regarding the staking.
818
859
  *
860
+ * Note: All the reads and mutations to this storage *MUST* be done through the methods exposed
861
+ * by [`StakingLedger`] to ensure data and lock consistency.
862
+ *
819
863
  * @param {AccountId32Like} arg
820
864
  * @param {Callback<PalletStakingStakingLedger | undefined> =} callback
821
865
  **/
822
- ledger: GenericStorageQuery<(arg: AccountId32Like) => PalletStakingStakingLedger | undefined>;
866
+ ledger: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletStakingStakingLedger | undefined, AccountId32>;
823
867
 
824
868
  /**
825
869
  * Where the reward payment should be made. Keyed by stash.
@@ -827,9 +871,9 @@ export interface ChainStorage extends GenericChainStorage {
827
871
  * TWOX-NOTE: SAFE since `AccountId` is a secure hash.
828
872
  *
829
873
  * @param {AccountId32Like} arg
830
- * @param {Callback<PalletStakingRewardDestination> =} callback
874
+ * @param {Callback<PalletStakingRewardDestination | undefined> =} callback
831
875
  **/
832
- payee: GenericStorageQuery<(arg: AccountId32Like) => PalletStakingRewardDestination>;
876
+ payee: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletStakingRewardDestination | undefined, AccountId32>;
833
877
 
834
878
  /**
835
879
  * The map from (wannabe) validator stash key to the preferences of that validator.
@@ -839,14 +883,14 @@ export interface ChainStorage extends GenericChainStorage {
839
883
  * @param {AccountId32Like} arg
840
884
  * @param {Callback<PalletStakingValidatorPrefs> =} callback
841
885
  **/
842
- validators: GenericStorageQuery<(arg: AccountId32Like) => PalletStakingValidatorPrefs>;
886
+ validators: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletStakingValidatorPrefs, AccountId32>;
843
887
 
844
888
  /**
845
889
  * Counter for the related counted storage map
846
890
  *
847
891
  * @param {Callback<number> =} callback
848
892
  **/
849
- counterForValidators: GenericStorageQuery<() => number>;
893
+ counterForValidators: GenericStorageQuery<Rv, () => number>;
850
894
 
851
895
  /**
852
896
  * The maximum validator count before we stop allowing new validators to join.
@@ -855,7 +899,7 @@ export interface ChainStorage extends GenericChainStorage {
855
899
  *
856
900
  * @param {Callback<number | undefined> =} callback
857
901
  **/
858
- maxValidatorsCount: GenericStorageQuery<() => number | undefined>;
902
+ maxValidatorsCount: GenericStorageQuery<Rv, () => number | undefined>;
859
903
 
860
904
  /**
861
905
  * The map from nominator stash key to their nomination preferences, namely the validators that
@@ -881,14 +925,14 @@ export interface ChainStorage extends GenericChainStorage {
881
925
  * @param {AccountId32Like} arg
882
926
  * @param {Callback<PalletStakingNominations | undefined> =} callback
883
927
  **/
884
- nominators: GenericStorageQuery<(arg: AccountId32Like) => PalletStakingNominations | undefined>;
928
+ nominators: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletStakingNominations | undefined, AccountId32>;
885
929
 
886
930
  /**
887
931
  * Counter for the related counted storage map
888
932
  *
889
933
  * @param {Callback<number> =} callback
890
934
  **/
891
- counterForNominators: GenericStorageQuery<() => number>;
935
+ counterForNominators: GenericStorageQuery<Rv, () => number>;
892
936
 
893
937
  /**
894
938
  * The maximum nominator count before we stop allowing new validators to join.
@@ -897,7 +941,7 @@ export interface ChainStorage extends GenericChainStorage {
897
941
  *
898
942
  * @param {Callback<number | undefined> =} callback
899
943
  **/
900
- maxNominatorsCount: GenericStorageQuery<() => number | undefined>;
944
+ maxNominatorsCount: GenericStorageQuery<Rv, () => number | undefined>;
901
945
 
902
946
  /**
903
947
  * The current era index.
@@ -907,7 +951,7 @@ export interface ChainStorage extends GenericChainStorage {
907
951
  *
908
952
  * @param {Callback<number | undefined> =} callback
909
953
  **/
910
- currentEra: GenericStorageQuery<() => number | undefined>;
954
+ currentEra: GenericStorageQuery<Rv, () => number | undefined>;
911
955
 
912
956
  /**
913
957
  * The active era information, it holds index and start.
@@ -917,10 +961,10 @@ export interface ChainStorage extends GenericChainStorage {
917
961
  *
918
962
  * @param {Callback<PalletStakingActiveEraInfo | undefined> =} callback
919
963
  **/
920
- activeEra: GenericStorageQuery<() => PalletStakingActiveEraInfo | undefined>;
964
+ activeEra: GenericStorageQuery<Rv, () => PalletStakingActiveEraInfo | undefined>;
921
965
 
922
966
  /**
923
- * The session index at which the era start for the last `HISTORY_DEPTH` eras.
967
+ * The session index at which the era start for the last [`Config::HistoryDepth`] eras.
924
968
  *
925
969
  * Note: This tracks the starting session (i.e. session index when era start being active)
926
970
  * for the eras in `[CurrentEra - HISTORY_DEPTH, CurrentEra]`.
@@ -928,85 +972,162 @@ export interface ChainStorage extends GenericChainStorage {
928
972
  * @param {number} arg
929
973
  * @param {Callback<number | undefined> =} callback
930
974
  **/
931
- erasStartSessionIndex: GenericStorageQuery<(arg: number) => number | undefined>;
975
+ erasStartSessionIndex: GenericStorageQuery<Rv, (arg: number) => number | undefined, number>;
932
976
 
933
977
  /**
934
978
  * Exposure of validator at era.
935
979
  *
936
980
  * This is keyed first by the era index to allow bulk deletion and then the stash account.
937
981
  *
938
- * Is it removed after `HISTORY_DEPTH` eras.
982
+ * Is it removed after [`Config::HistoryDepth`] eras.
939
983
  * If stakers hasn't been set or has been removed then empty exposure is returned.
940
984
  *
985
+ * Note: Deprecated since v14. Use `EraInfo` instead to work with exposures.
986
+ *
987
+ * @param {[number, AccountId32Like]} arg
988
+ * @param {Callback<SpStakingExposure> =} callback
989
+ **/
990
+ erasStakers: GenericStorageQuery<Rv, (arg: [number, AccountId32Like]) => SpStakingExposure, [number, AccountId32]>;
991
+
992
+ /**
993
+ * Summary of validator exposure at a given era.
994
+ *
995
+ * This contains the total stake in support of the validator and their own stake. In addition,
996
+ * it can also be used to get the number of nominators backing this validator and the number of
997
+ * exposure pages they are divided into. The page count is useful to determine the number of
998
+ * pages of rewards that needs to be claimed.
999
+ *
1000
+ * This is keyed first by the era index to allow bulk deletion and then the stash account.
1001
+ * Should only be accessed through `EraInfo`.
1002
+ *
1003
+ * Is it removed after [`Config::HistoryDepth`] eras.
1004
+ * If stakers hasn't been set or has been removed then empty overview is returned.
1005
+ *
941
1006
  * @param {[number, AccountId32Like]} arg
942
- * @param {Callback<PalletStakingExposure> =} callback
1007
+ * @param {Callback<SpStakingPagedExposureMetadata | undefined> =} callback
943
1008
  **/
944
- erasStakers: GenericStorageQuery<(arg: [number, AccountId32Like]) => PalletStakingExposure>;
1009
+ erasStakersOverview: GenericStorageQuery<
1010
+ Rv,
1011
+ (arg: [number, AccountId32Like]) => SpStakingPagedExposureMetadata | undefined,
1012
+ [number, AccountId32]
1013
+ >;
945
1014
 
946
1015
  /**
947
1016
  * Clipped Exposure of validator at era.
948
1017
  *
1018
+ * Note: This is deprecated, should be used as read-only and will be removed in the future.
1019
+ * New `Exposure`s are stored in a paged manner in `ErasStakersPaged` instead.
1020
+ *
949
1021
  * This is similar to [`ErasStakers`] but number of nominators exposed is reduced to the
950
- * `T::MaxNominatorRewardedPerValidator` biggest stakers.
1022
+ * `T::MaxExposurePageSize` biggest stakers.
951
1023
  * (Note: the field `total` and `own` of the exposure remains unchanged).
952
1024
  * This is used to limit the i/o cost for the nominator payout.
953
1025
  *
954
1026
  * This is keyed fist by the era index to allow bulk deletion and then the stash account.
955
1027
  *
956
- * Is it removed after `HISTORY_DEPTH` eras.
1028
+ * It is removed after [`Config::HistoryDepth`] eras.
957
1029
  * If stakers hasn't been set or has been removed then empty exposure is returned.
958
1030
  *
1031
+ * Note: Deprecated since v14. Use `EraInfo` instead to work with exposures.
1032
+ *
1033
+ * @param {[number, AccountId32Like]} arg
1034
+ * @param {Callback<SpStakingExposure> =} callback
1035
+ **/
1036
+ erasStakersClipped: GenericStorageQuery<
1037
+ Rv,
1038
+ (arg: [number, AccountId32Like]) => SpStakingExposure,
1039
+ [number, AccountId32]
1040
+ >;
1041
+
1042
+ /**
1043
+ * Paginated exposure of a validator at given era.
1044
+ *
1045
+ * This is keyed first by the era index to allow bulk deletion, then stash account and finally
1046
+ * the page. Should only be accessed through `EraInfo`.
1047
+ *
1048
+ * This is cleared after [`Config::HistoryDepth`] eras.
1049
+ *
1050
+ * @param {[number, AccountId32Like, number]} arg
1051
+ * @param {Callback<SpStakingExposurePage | undefined> =} callback
1052
+ **/
1053
+ erasStakersPaged: GenericStorageQuery<
1054
+ Rv,
1055
+ (arg: [number, AccountId32Like, number]) => SpStakingExposurePage | undefined,
1056
+ [number, AccountId32, number]
1057
+ >;
1058
+
1059
+ /**
1060
+ * History of claimed paged rewards by era and validator.
1061
+ *
1062
+ * This is keyed by era and validator stash which maps to the set of page indexes which have
1063
+ * been claimed.
1064
+ *
1065
+ * It is removed after [`Config::HistoryDepth`] eras.
1066
+ *
959
1067
  * @param {[number, AccountId32Like]} arg
960
- * @param {Callback<PalletStakingExposure> =} callback
1068
+ * @param {Callback<Array<number>> =} callback
961
1069
  **/
962
- erasStakersClipped: GenericStorageQuery<(arg: [number, AccountId32Like]) => PalletStakingExposure>;
1070
+ claimedRewards: GenericStorageQuery<Rv, (arg: [number, AccountId32Like]) => Array<number>, [number, AccountId32]>;
963
1071
 
964
1072
  /**
965
1073
  * Similar to `ErasStakers`, this holds the preferences of validators.
966
1074
  *
967
1075
  * This is keyed first by the era index to allow bulk deletion and then the stash account.
968
1076
  *
969
- * Is it removed after `HISTORY_DEPTH` eras.
1077
+ * Is it removed after [`Config::HistoryDepth`] eras.
970
1078
  *
971
1079
  * @param {[number, AccountId32Like]} arg
972
1080
  * @param {Callback<PalletStakingValidatorPrefs> =} callback
973
1081
  **/
974
- erasValidatorPrefs: GenericStorageQuery<(arg: [number, AccountId32Like]) => PalletStakingValidatorPrefs>;
1082
+ erasValidatorPrefs: GenericStorageQuery<
1083
+ Rv,
1084
+ (arg: [number, AccountId32Like]) => PalletStakingValidatorPrefs,
1085
+ [number, AccountId32]
1086
+ >;
975
1087
 
976
1088
  /**
977
- * The total validator era payout for the last `HISTORY_DEPTH` eras.
1089
+ * The total validator era payout for the last [`Config::HistoryDepth`] eras.
978
1090
  *
979
1091
  * Eras that haven't finished yet or has been removed doesn't have reward.
980
1092
  *
981
1093
  * @param {number} arg
982
1094
  * @param {Callback<bigint | undefined> =} callback
983
1095
  **/
984
- erasValidatorReward: GenericStorageQuery<(arg: number) => bigint | undefined>;
1096
+ erasValidatorReward: GenericStorageQuery<Rv, (arg: number) => bigint | undefined, number>;
985
1097
 
986
1098
  /**
987
- * Rewards for the last `HISTORY_DEPTH` eras.
1099
+ * Rewards for the last [`Config::HistoryDepth`] eras.
988
1100
  * If reward hasn't been set or has been removed then 0 reward is returned.
989
1101
  *
990
1102
  * @param {number} arg
991
1103
  * @param {Callback<PalletStakingEraRewardPoints> =} callback
992
1104
  **/
993
- erasRewardPoints: GenericStorageQuery<(arg: number) => PalletStakingEraRewardPoints>;
1105
+ erasRewardPoints: GenericStorageQuery<Rv, (arg: number) => PalletStakingEraRewardPoints, number>;
994
1106
 
995
1107
  /**
996
- * The total amount staked for the last `HISTORY_DEPTH` eras.
1108
+ * The total amount staked for the last [`Config::HistoryDepth`] eras.
997
1109
  * If total hasn't been set or has been removed then 0 stake is returned.
998
1110
  *
999
1111
  * @param {number} arg
1000
1112
  * @param {Callback<bigint> =} callback
1001
1113
  **/
1002
- erasTotalStake: GenericStorageQuery<(arg: number) => bigint>;
1114
+ erasTotalStake: GenericStorageQuery<Rv, (arg: number) => bigint, number>;
1003
1115
 
1004
1116
  /**
1005
1117
  * Mode of era forcing.
1006
1118
  *
1007
1119
  * @param {Callback<PalletStakingForcing> =} callback
1008
1120
  **/
1009
- forceEra: GenericStorageQuery<() => PalletStakingForcing>;
1121
+ forceEra: GenericStorageQuery<Rv, () => PalletStakingForcing>;
1122
+
1123
+ /**
1124
+ * Maximum staked rewards, i.e. the percentage of the era inflation that
1125
+ * is used for stake rewards.
1126
+ * See [Era payout](./index.html#era-payout).
1127
+ *
1128
+ * @param {Callback<Percent | undefined> =} callback
1129
+ **/
1130
+ maxStakedRewards: GenericStorageQuery<Rv, () => Percent | undefined>;
1010
1131
 
1011
1132
  /**
1012
1133
  * The percentage of the slash that is distributed to reporters.
@@ -1015,7 +1136,7 @@ export interface ChainStorage extends GenericChainStorage {
1015
1136
  *
1016
1137
  * @param {Callback<Perbill> =} callback
1017
1138
  **/
1018
- slashRewardFraction: GenericStorageQuery<() => Perbill>;
1139
+ slashRewardFraction: GenericStorageQuery<Rv, () => Perbill>;
1019
1140
 
1020
1141
  /**
1021
1142
  * The amount of currency given to reporters of a slash event which was
@@ -1023,7 +1144,7 @@ export interface ChainStorage extends GenericChainStorage {
1023
1144
  *
1024
1145
  * @param {Callback<bigint> =} callback
1025
1146
  **/
1026
- canceledSlashPayout: GenericStorageQuery<() => bigint>;
1147
+ canceledSlashPayout: GenericStorageQuery<Rv, () => bigint>;
1027
1148
 
1028
1149
  /**
1029
1150
  * All unapplied slashes that are queued for later.
@@ -1031,7 +1152,7 @@ export interface ChainStorage extends GenericChainStorage {
1031
1152
  * @param {number} arg
1032
1153
  * @param {Callback<Array<PalletStakingUnappliedSlash>> =} callback
1033
1154
  **/
1034
- unappliedSlashes: GenericStorageQuery<(arg: number) => Array<PalletStakingUnappliedSlash>>;
1155
+ unappliedSlashes: GenericStorageQuery<Rv, (arg: number) => Array<PalletStakingUnappliedSlash>, number>;
1035
1156
 
1036
1157
  /**
1037
1158
  * A mapping from still-bonded eras to the first session index of that era.
@@ -1041,7 +1162,7 @@ export interface ChainStorage extends GenericChainStorage {
1041
1162
  *
1042
1163
  * @param {Callback<Array<[number, number]>> =} callback
1043
1164
  **/
1044
- bondedEras: GenericStorageQuery<() => Array<[number, number]>>;
1165
+ bondedEras: GenericStorageQuery<Rv, () => Array<[number, number]>>;
1045
1166
 
1046
1167
  /**
1047
1168
  * All slashing events on validators, mapped by era to the highest slash proportion
@@ -1050,7 +1171,11 @@ export interface ChainStorage extends GenericChainStorage {
1050
1171
  * @param {[number, AccountId32Like]} arg
1051
1172
  * @param {Callback<[Perbill, bigint] | undefined> =} callback
1052
1173
  **/
1053
- validatorSlashInEra: GenericStorageQuery<(arg: [number, AccountId32Like]) => [Perbill, bigint] | undefined>;
1174
+ validatorSlashInEra: GenericStorageQuery<
1175
+ Rv,
1176
+ (arg: [number, AccountId32Like]) => [Perbill, bigint] | undefined,
1177
+ [number, AccountId32]
1178
+ >;
1054
1179
 
1055
1180
  /**
1056
1181
  * All slashing events on nominators, mapped by era to the highest slash value of the era.
@@ -1058,7 +1183,11 @@ export interface ChainStorage extends GenericChainStorage {
1058
1183
  * @param {[number, AccountId32Like]} arg
1059
1184
  * @param {Callback<bigint | undefined> =} callback
1060
1185
  **/
1061
- nominatorSlashInEra: GenericStorageQuery<(arg: [number, AccountId32Like]) => bigint | undefined>;
1186
+ nominatorSlashInEra: GenericStorageQuery<
1187
+ Rv,
1188
+ (arg: [number, AccountId32Like]) => bigint | undefined,
1189
+ [number, AccountId32]
1190
+ >;
1062
1191
 
1063
1192
  /**
1064
1193
  * Slashing spans for stash accounts.
@@ -1066,7 +1195,11 @@ export interface ChainStorage extends GenericChainStorage {
1066
1195
  * @param {AccountId32Like} arg
1067
1196
  * @param {Callback<PalletStakingSlashingSlashingSpans | undefined> =} callback
1068
1197
  **/
1069
- slashingSpans: GenericStorageQuery<(arg: AccountId32Like) => PalletStakingSlashingSlashingSpans | undefined>;
1198
+ slashingSpans: GenericStorageQuery<
1199
+ Rv,
1200
+ (arg: AccountId32Like) => PalletStakingSlashingSlashingSpans | undefined,
1201
+ AccountId32
1202
+ >;
1070
1203
 
1071
1204
  /**
1072
1205
  * Records information about the maximum slash of a stash within a slashing span,
@@ -1075,7 +1208,11 @@ export interface ChainStorage extends GenericChainStorage {
1075
1208
  * @param {[AccountId32Like, number]} arg
1076
1209
  * @param {Callback<PalletStakingSlashingSpanRecord> =} callback
1077
1210
  **/
1078
- spanSlash: GenericStorageQuery<(arg: [AccountId32Like, number]) => PalletStakingSlashingSpanRecord>;
1211
+ spanSlash: GenericStorageQuery<
1212
+ Rv,
1213
+ (arg: [AccountId32Like, number]) => PalletStakingSlashingSpanRecord,
1214
+ [AccountId32, number]
1215
+ >;
1079
1216
 
1080
1217
  /**
1081
1218
  * The last planned session scheduled by the session pallet.
@@ -1084,7 +1221,7 @@ export interface ChainStorage extends GenericChainStorage {
1084
1221
  *
1085
1222
  * @param {Callback<number> =} callback
1086
1223
  **/
1087
- currentPlannedSession: GenericStorageQuery<() => number>;
1224
+ currentPlannedSession: GenericStorageQuery<Rv, () => number>;
1088
1225
 
1089
1226
  /**
1090
1227
  * Indices of validators that have offended in the active era and whether they are currently
@@ -1099,7 +1236,7 @@ export interface ChainStorage extends GenericChainStorage {
1099
1236
  *
1100
1237
  * @param {Callback<Array<[number, boolean]>> =} callback
1101
1238
  **/
1102
- offendingValidators: GenericStorageQuery<() => Array<[number, boolean]>>;
1239
+ offendingValidators: GenericStorageQuery<Rv, () => Array<[number, boolean]>>;
1103
1240
 
1104
1241
  /**
1105
1242
  * The threshold for when users can start calling `chill_other` for other validators /
@@ -1108,12 +1245,12 @@ export interface ChainStorage extends GenericChainStorage {
1108
1245
  *
1109
1246
  * @param {Callback<Percent | undefined> =} callback
1110
1247
  **/
1111
- chillThreshold: GenericStorageQuery<() => Percent | undefined>;
1248
+ chillThreshold: GenericStorageQuery<Rv, () => Percent | undefined>;
1112
1249
 
1113
1250
  /**
1114
1251
  * Generic pallet storage query
1115
1252
  **/
1116
- [storage: string]: GenericStorageQuery;
1253
+ [storage: string]: GenericStorageQuery<Rv>;
1117
1254
  };
1118
1255
  /**
1119
1256
  * Pallet `Session`'s storage queries
@@ -1124,14 +1261,14 @@ export interface ChainStorage extends GenericChainStorage {
1124
1261
  *
1125
1262
  * @param {Callback<Array<AccountId32>> =} callback
1126
1263
  **/
1127
- validators: GenericStorageQuery<() => Array<AccountId32>>;
1264
+ validators: GenericStorageQuery<Rv, () => Array<AccountId32>>;
1128
1265
 
1129
1266
  /**
1130
1267
  * Current index of the session.
1131
1268
  *
1132
1269
  * @param {Callback<number> =} callback
1133
1270
  **/
1134
- currentIndex: GenericStorageQuery<() => number>;
1271
+ currentIndex: GenericStorageQuery<Rv, () => number>;
1135
1272
 
1136
1273
  /**
1137
1274
  * True if the underlying economic identities or weighting behind the validators
@@ -1139,7 +1276,7 @@ export interface ChainStorage extends GenericChainStorage {
1139
1276
  *
1140
1277
  * @param {Callback<boolean> =} callback
1141
1278
  **/
1142
- queuedChanged: GenericStorageQuery<() => boolean>;
1279
+ queuedChanged: GenericStorageQuery<Rv, () => boolean>;
1143
1280
 
1144
1281
  /**
1145
1282
  * The queued keys for the next session. When the next session begins, these keys
@@ -1147,7 +1284,7 @@ export interface ChainStorage extends GenericChainStorage {
1147
1284
  *
1148
1285
  * @param {Callback<Array<[AccountId32, KitchensinkRuntimeSessionKeys]>> =} callback
1149
1286
  **/
1150
- queuedKeys: GenericStorageQuery<() => Array<[AccountId32, KitchensinkRuntimeSessionKeys]>>;
1287
+ queuedKeys: GenericStorageQuery<Rv, () => Array<[AccountId32, KitchensinkRuntimeSessionKeys]>>;
1151
1288
 
1152
1289
  /**
1153
1290
  * Indices of disabled validators.
@@ -1158,7 +1295,7 @@ export interface ChainStorage extends GenericChainStorage {
1158
1295
  *
1159
1296
  * @param {Callback<Array<number>> =} callback
1160
1297
  **/
1161
- disabledValidators: GenericStorageQuery<() => Array<number>>;
1298
+ disabledValidators: GenericStorageQuery<Rv, () => Array<number>>;
1162
1299
 
1163
1300
  /**
1164
1301
  * The next session keys for a validator.
@@ -1166,7 +1303,7 @@ export interface ChainStorage extends GenericChainStorage {
1166
1303
  * @param {AccountId32Like} arg
1167
1304
  * @param {Callback<KitchensinkRuntimeSessionKeys | undefined> =} callback
1168
1305
  **/
1169
- nextKeys: GenericStorageQuery<(arg: AccountId32Like) => KitchensinkRuntimeSessionKeys | undefined>;
1306
+ nextKeys: GenericStorageQuery<Rv, (arg: AccountId32Like) => KitchensinkRuntimeSessionKeys | undefined, AccountId32>;
1170
1307
 
1171
1308
  /**
1172
1309
  * The owner of a key. The key is the `KeyTypeId` + the encoded key.
@@ -1174,12 +1311,16 @@ export interface ChainStorage extends GenericChainStorage {
1174
1311
  * @param {[SpCoreCryptoKeyTypeId, BytesLike]} arg
1175
1312
  * @param {Callback<AccountId32 | undefined> =} callback
1176
1313
  **/
1177
- keyOwner: GenericStorageQuery<(arg: [SpCoreCryptoKeyTypeId, BytesLike]) => AccountId32 | undefined>;
1314
+ keyOwner: GenericStorageQuery<
1315
+ Rv,
1316
+ (arg: [SpCoreCryptoKeyTypeId, BytesLike]) => AccountId32 | undefined,
1317
+ [SpCoreCryptoKeyTypeId, Bytes]
1318
+ >;
1178
1319
 
1179
1320
  /**
1180
1321
  * Generic pallet storage query
1181
1322
  **/
1182
- [storage: string]: GenericStorageQuery;
1323
+ [storage: string]: GenericStorageQuery<Rv>;
1183
1324
  };
1184
1325
  /**
1185
1326
  * Pallet `Democracy`'s storage queries
@@ -1190,14 +1331,14 @@ export interface ChainStorage extends GenericChainStorage {
1190
1331
  *
1191
1332
  * @param {Callback<number> =} callback
1192
1333
  **/
1193
- publicPropCount: GenericStorageQuery<() => number>;
1334
+ publicPropCount: GenericStorageQuery<Rv, () => number>;
1194
1335
 
1195
1336
  /**
1196
1337
  * The public proposals. Unsorted. The second item is the proposal.
1197
1338
  *
1198
1339
  * @param {Callback<Array<[number, FrameSupportPreimagesBounded, AccountId32]>> =} callback
1199
1340
  **/
1200
- publicProps: GenericStorageQuery<() => Array<[number, FrameSupportPreimagesBounded, AccountId32]>>;
1341
+ publicProps: GenericStorageQuery<Rv, () => Array<[number, FrameSupportPreimagesBounded, AccountId32]>>;
1201
1342
 
1202
1343
  /**
1203
1344
  * Those who have locked a deposit.
@@ -1207,14 +1348,14 @@ export interface ChainStorage extends GenericChainStorage {
1207
1348
  * @param {number} arg
1208
1349
  * @param {Callback<[Array<AccountId32>, bigint] | undefined> =} callback
1209
1350
  **/
1210
- depositOf: GenericStorageQuery<(arg: number) => [Array<AccountId32>, bigint] | undefined>;
1351
+ depositOf: GenericStorageQuery<Rv, (arg: number) => [Array<AccountId32>, bigint] | undefined, number>;
1211
1352
 
1212
1353
  /**
1213
1354
  * The next free referendum index, aka the number of referenda started so far.
1214
1355
  *
1215
1356
  * @param {Callback<number> =} callback
1216
1357
  **/
1217
- referendumCount: GenericStorageQuery<() => number>;
1358
+ referendumCount: GenericStorageQuery<Rv, () => number>;
1218
1359
 
1219
1360
  /**
1220
1361
  * The lowest referendum index representing an unbaked referendum. Equal to
@@ -1222,7 +1363,7 @@ export interface ChainStorage extends GenericChainStorage {
1222
1363
  *
1223
1364
  * @param {Callback<number> =} callback
1224
1365
  **/
1225
- lowestUnbaked: GenericStorageQuery<() => number>;
1366
+ lowestUnbaked: GenericStorageQuery<Rv, () => number>;
1226
1367
 
1227
1368
  /**
1228
1369
  * Information concerning any given referendum.
@@ -1232,7 +1373,7 @@ export interface ChainStorage extends GenericChainStorage {
1232
1373
  * @param {number} arg
1233
1374
  * @param {Callback<PalletDemocracyReferendumInfo | undefined> =} callback
1234
1375
  **/
1235
- referendumInfoOf: GenericStorageQuery<(arg: number) => PalletDemocracyReferendumInfo | undefined>;
1376
+ referendumInfoOf: GenericStorageQuery<Rv, (arg: number) => PalletDemocracyReferendumInfo | undefined, number>;
1236
1377
 
1237
1378
  /**
1238
1379
  * All votes for a particular voter. We store the balance for the number of votes that we
@@ -1243,7 +1384,7 @@ export interface ChainStorage extends GenericChainStorage {
1243
1384
  * @param {AccountId32Like} arg
1244
1385
  * @param {Callback<PalletDemocracyVoteVoting> =} callback
1245
1386
  **/
1246
- votingOf: GenericStorageQuery<(arg: AccountId32Like) => PalletDemocracyVoteVoting>;
1387
+ votingOf: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletDemocracyVoteVoting, AccountId32>;
1247
1388
 
1248
1389
  /**
1249
1390
  * True if the last referendum tabled was submitted externally. False if it was a public
@@ -1251,7 +1392,7 @@ export interface ChainStorage extends GenericChainStorage {
1251
1392
  *
1252
1393
  * @param {Callback<boolean> =} callback
1253
1394
  **/
1254
- lastTabledWasExternal: GenericStorageQuery<() => boolean>;
1395
+ lastTabledWasExternal: GenericStorageQuery<Rv, () => boolean>;
1255
1396
 
1256
1397
  /**
1257
1398
  * The referendum to be tabled whenever it would be valid to table an external proposal.
@@ -1261,7 +1402,10 @@ export interface ChainStorage extends GenericChainStorage {
1261
1402
  *
1262
1403
  * @param {Callback<[FrameSupportPreimagesBounded, PalletDemocracyVoteThreshold] | undefined> =} callback
1263
1404
  **/
1264
- nextExternal: GenericStorageQuery<() => [FrameSupportPreimagesBounded, PalletDemocracyVoteThreshold] | undefined>;
1405
+ nextExternal: GenericStorageQuery<
1406
+ Rv,
1407
+ () => [FrameSupportPreimagesBounded, PalletDemocracyVoteThreshold] | undefined
1408
+ >;
1265
1409
 
1266
1410
  /**
1267
1411
  * A record of who vetoed what. Maps proposal hash to a possible existent block number
@@ -1270,7 +1414,7 @@ export interface ChainStorage extends GenericChainStorage {
1270
1414
  * @param {H256} arg
1271
1415
  * @param {Callback<[number, Array<AccountId32>] | undefined> =} callback
1272
1416
  **/
1273
- blacklist: GenericStorageQuery<(arg: H256) => [number, Array<AccountId32>] | undefined>;
1417
+ blacklist: GenericStorageQuery<Rv, (arg: H256) => [number, Array<AccountId32>] | undefined, H256>;
1274
1418
 
1275
1419
  /**
1276
1420
  * Record of all proposals that have been subject to emergency cancellation.
@@ -1278,11 +1422,11 @@ export interface ChainStorage extends GenericChainStorage {
1278
1422
  * @param {H256} arg
1279
1423
  * @param {Callback<boolean> =} callback
1280
1424
  **/
1281
- cancellations: GenericStorageQuery<(arg: H256) => boolean>;
1425
+ cancellations: GenericStorageQuery<Rv, (arg: H256) => boolean, H256>;
1282
1426
 
1283
1427
  /**
1284
1428
  * General information concerning any proposal or referendum.
1285
- * The `PreimageHash` refers to the preimage of the `Preimages` provider which can be a JSON
1429
+ * The `Hash` refers to the preimage of the `Preimages` provider which can be a JSON
1286
1430
  * dump or IPFS hash of a JSON file.
1287
1431
  *
1288
1432
  * Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)
@@ -1291,12 +1435,16 @@ export interface ChainStorage extends GenericChainStorage {
1291
1435
  * @param {PalletDemocracyMetadataOwner} arg
1292
1436
  * @param {Callback<H256 | undefined> =} callback
1293
1437
  **/
1294
- metadataOf: GenericStorageQuery<(arg: PalletDemocracyMetadataOwner) => H256 | undefined>;
1438
+ metadataOf: GenericStorageQuery<
1439
+ Rv,
1440
+ (arg: PalletDemocracyMetadataOwner) => H256 | undefined,
1441
+ PalletDemocracyMetadataOwner
1442
+ >;
1295
1443
 
1296
1444
  /**
1297
1445
  * Generic pallet storage query
1298
1446
  **/
1299
- [storage: string]: GenericStorageQuery;
1447
+ [storage: string]: GenericStorageQuery<Rv>;
1300
1448
  };
1301
1449
  /**
1302
1450
  * Pallet `Council`'s storage queries
@@ -1307,7 +1455,7 @@ export interface ChainStorage extends GenericChainStorage {
1307
1455
  *
1308
1456
  * @param {Callback<Array<H256>> =} callback
1309
1457
  **/
1310
- proposals: GenericStorageQuery<() => Array<H256>>;
1458
+ proposals: GenericStorageQuery<Rv, () => Array<H256>>;
1311
1459
 
1312
1460
  /**
1313
1461
  * Actual proposal for a given hash, if it's current.
@@ -1315,7 +1463,7 @@ export interface ChainStorage extends GenericChainStorage {
1315
1463
  * @param {H256} arg
1316
1464
  * @param {Callback<KitchensinkRuntimeRuntimeCall | undefined> =} callback
1317
1465
  **/
1318
- proposalOf: GenericStorageQuery<(arg: H256) => KitchensinkRuntimeRuntimeCall | undefined>;
1466
+ proposalOf: GenericStorageQuery<Rv, (arg: H256) => KitchensinkRuntimeRuntimeCall | undefined, H256>;
1319
1467
 
1320
1468
  /**
1321
1469
  * Votes on a given proposal, if it is ongoing.
@@ -1323,33 +1471,33 @@ export interface ChainStorage extends GenericChainStorage {
1323
1471
  * @param {H256} arg
1324
1472
  * @param {Callback<PalletCollectiveVotes | undefined> =} callback
1325
1473
  **/
1326
- voting: GenericStorageQuery<(arg: H256) => PalletCollectiveVotes | undefined>;
1474
+ voting: GenericStorageQuery<Rv, (arg: H256) => PalletCollectiveVotes | undefined, H256>;
1327
1475
 
1328
1476
  /**
1329
1477
  * Proposals so far.
1330
1478
  *
1331
1479
  * @param {Callback<number> =} callback
1332
1480
  **/
1333
- proposalCount: GenericStorageQuery<() => number>;
1481
+ proposalCount: GenericStorageQuery<Rv, () => number>;
1334
1482
 
1335
1483
  /**
1336
1484
  * The current members of the collective. This is stored sorted (just by value).
1337
1485
  *
1338
1486
  * @param {Callback<Array<AccountId32>> =} callback
1339
1487
  **/
1340
- members: GenericStorageQuery<() => Array<AccountId32>>;
1488
+ members: GenericStorageQuery<Rv, () => Array<AccountId32>>;
1341
1489
 
1342
1490
  /**
1343
1491
  * The prime member that helps determine the default vote behavior in case of absentations.
1344
1492
  *
1345
1493
  * @param {Callback<AccountId32 | undefined> =} callback
1346
1494
  **/
1347
- prime: GenericStorageQuery<() => AccountId32 | undefined>;
1495
+ prime: GenericStorageQuery<Rv, () => AccountId32 | undefined>;
1348
1496
 
1349
1497
  /**
1350
1498
  * Generic pallet storage query
1351
1499
  **/
1352
- [storage: string]: GenericStorageQuery;
1500
+ [storage: string]: GenericStorageQuery<Rv>;
1353
1501
  };
1354
1502
  /**
1355
1503
  * Pallet `TechnicalCommittee`'s storage queries
@@ -1360,7 +1508,7 @@ export interface ChainStorage extends GenericChainStorage {
1360
1508
  *
1361
1509
  * @param {Callback<Array<H256>> =} callback
1362
1510
  **/
1363
- proposals: GenericStorageQuery<() => Array<H256>>;
1511
+ proposals: GenericStorageQuery<Rv, () => Array<H256>>;
1364
1512
 
1365
1513
  /**
1366
1514
  * Actual proposal for a given hash, if it's current.
@@ -1368,7 +1516,7 @@ export interface ChainStorage extends GenericChainStorage {
1368
1516
  * @param {H256} arg
1369
1517
  * @param {Callback<KitchensinkRuntimeRuntimeCall | undefined> =} callback
1370
1518
  **/
1371
- proposalOf: GenericStorageQuery<(arg: H256) => KitchensinkRuntimeRuntimeCall | undefined>;
1519
+ proposalOf: GenericStorageQuery<Rv, (arg: H256) => KitchensinkRuntimeRuntimeCall | undefined, H256>;
1372
1520
 
1373
1521
  /**
1374
1522
  * Votes on a given proposal, if it is ongoing.
@@ -1376,33 +1524,33 @@ export interface ChainStorage extends GenericChainStorage {
1376
1524
  * @param {H256} arg
1377
1525
  * @param {Callback<PalletCollectiveVotes | undefined> =} callback
1378
1526
  **/
1379
- voting: GenericStorageQuery<(arg: H256) => PalletCollectiveVotes | undefined>;
1527
+ voting: GenericStorageQuery<Rv, (arg: H256) => PalletCollectiveVotes | undefined, H256>;
1380
1528
 
1381
1529
  /**
1382
1530
  * Proposals so far.
1383
1531
  *
1384
1532
  * @param {Callback<number> =} callback
1385
1533
  **/
1386
- proposalCount: GenericStorageQuery<() => number>;
1534
+ proposalCount: GenericStorageQuery<Rv, () => number>;
1387
1535
 
1388
1536
  /**
1389
1537
  * The current members of the collective. This is stored sorted (just by value).
1390
1538
  *
1391
1539
  * @param {Callback<Array<AccountId32>> =} callback
1392
1540
  **/
1393
- members: GenericStorageQuery<() => Array<AccountId32>>;
1541
+ members: GenericStorageQuery<Rv, () => Array<AccountId32>>;
1394
1542
 
1395
1543
  /**
1396
1544
  * The prime member that helps determine the default vote behavior in case of absentations.
1397
1545
  *
1398
1546
  * @param {Callback<AccountId32 | undefined> =} callback
1399
1547
  **/
1400
- prime: GenericStorageQuery<() => AccountId32 | undefined>;
1548
+ prime: GenericStorageQuery<Rv, () => AccountId32 | undefined>;
1401
1549
 
1402
1550
  /**
1403
1551
  * Generic pallet storage query
1404
1552
  **/
1405
- [storage: string]: GenericStorageQuery;
1553
+ [storage: string]: GenericStorageQuery<Rv>;
1406
1554
  };
1407
1555
  /**
1408
1556
  * Pallet `Elections`'s storage queries
@@ -1415,7 +1563,7 @@ export interface ChainStorage extends GenericChainStorage {
1415
1563
  *
1416
1564
  * @param {Callback<Array<PalletElectionsPhragmenSeatHolder>> =} callback
1417
1565
  **/
1418
- members: GenericStorageQuery<() => Array<PalletElectionsPhragmenSeatHolder>>;
1566
+ members: GenericStorageQuery<Rv, () => Array<PalletElectionsPhragmenSeatHolder>>;
1419
1567
 
1420
1568
  /**
1421
1569
  * The current reserved runners-up.
@@ -1425,7 +1573,7 @@ export interface ChainStorage extends GenericChainStorage {
1425
1573
  *
1426
1574
  * @param {Callback<Array<PalletElectionsPhragmenSeatHolder>> =} callback
1427
1575
  **/
1428
- runnersUp: GenericStorageQuery<() => Array<PalletElectionsPhragmenSeatHolder>>;
1576
+ runnersUp: GenericStorageQuery<Rv, () => Array<PalletElectionsPhragmenSeatHolder>>;
1429
1577
 
1430
1578
  /**
1431
1579
  * The present candidate list. A current member or runner-up can never enter this vector
@@ -1437,14 +1585,14 @@ export interface ChainStorage extends GenericChainStorage {
1437
1585
  *
1438
1586
  * @param {Callback<Array<[AccountId32, bigint]>> =} callback
1439
1587
  **/
1440
- candidates: GenericStorageQuery<() => Array<[AccountId32, bigint]>>;
1588
+ candidates: GenericStorageQuery<Rv, () => Array<[AccountId32, bigint]>>;
1441
1589
 
1442
1590
  /**
1443
1591
  * The total number of vote rounds that have happened, excluding the upcoming one.
1444
1592
  *
1445
1593
  * @param {Callback<number> =} callback
1446
1594
  **/
1447
- electionRounds: GenericStorageQuery<() => number>;
1595
+ electionRounds: GenericStorageQuery<Rv, () => number>;
1448
1596
 
1449
1597
  /**
1450
1598
  * Votes and locked stake of a particular voter.
@@ -1454,12 +1602,12 @@ export interface ChainStorage extends GenericChainStorage {
1454
1602
  * @param {AccountId32Like} arg
1455
1603
  * @param {Callback<PalletElectionsPhragmenVoter> =} callback
1456
1604
  **/
1457
- voting: GenericStorageQuery<(arg: AccountId32Like) => PalletElectionsPhragmenVoter>;
1605
+ voting: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletElectionsPhragmenVoter, AccountId32>;
1458
1606
 
1459
1607
  /**
1460
1608
  * Generic pallet storage query
1461
1609
  **/
1462
- [storage: string]: GenericStorageQuery;
1610
+ [storage: string]: GenericStorageQuery<Rv>;
1463
1611
  };
1464
1612
  /**
1465
1613
  * Pallet `TechnicalMembership`'s storage queries
@@ -1470,19 +1618,19 @@ export interface ChainStorage extends GenericChainStorage {
1470
1618
  *
1471
1619
  * @param {Callback<Array<AccountId32>> =} callback
1472
1620
  **/
1473
- members: GenericStorageQuery<() => Array<AccountId32>>;
1621
+ members: GenericStorageQuery<Rv, () => Array<AccountId32>>;
1474
1622
 
1475
1623
  /**
1476
1624
  * The current prime member, if one exists.
1477
1625
  *
1478
1626
  * @param {Callback<AccountId32 | undefined> =} callback
1479
1627
  **/
1480
- prime: GenericStorageQuery<() => AccountId32 | undefined>;
1628
+ prime: GenericStorageQuery<Rv, () => AccountId32 | undefined>;
1481
1629
 
1482
1630
  /**
1483
1631
  * Generic pallet storage query
1484
1632
  **/
1485
- [storage: string]: GenericStorageQuery;
1633
+ [storage: string]: GenericStorageQuery<Rv>;
1486
1634
  };
1487
1635
  /**
1488
1636
  * Pallet `Grandpa`'s storage queries
@@ -1493,28 +1641,28 @@ export interface ChainStorage extends GenericChainStorage {
1493
1641
  *
1494
1642
  * @param {Callback<PalletGrandpaStoredState> =} callback
1495
1643
  **/
1496
- state: GenericStorageQuery<() => PalletGrandpaStoredState>;
1644
+ state: GenericStorageQuery<Rv, () => PalletGrandpaStoredState>;
1497
1645
 
1498
1646
  /**
1499
1647
  * Pending change: (signaled at, scheduled change).
1500
1648
  *
1501
1649
  * @param {Callback<PalletGrandpaStoredPendingChange | undefined> =} callback
1502
1650
  **/
1503
- pendingChange: GenericStorageQuery<() => PalletGrandpaStoredPendingChange | undefined>;
1651
+ pendingChange: GenericStorageQuery<Rv, () => PalletGrandpaStoredPendingChange | undefined>;
1504
1652
 
1505
1653
  /**
1506
1654
  * next block number where we can force a change.
1507
1655
  *
1508
1656
  * @param {Callback<number | undefined> =} callback
1509
1657
  **/
1510
- nextForced: GenericStorageQuery<() => number | undefined>;
1658
+ nextForced: GenericStorageQuery<Rv, () => number | undefined>;
1511
1659
 
1512
1660
  /**
1513
1661
  * `true` if we are currently stalled.
1514
1662
  *
1515
1663
  * @param {Callback<[number, number] | undefined> =} callback
1516
1664
  **/
1517
- stalled: GenericStorageQuery<() => [number, number] | undefined>;
1665
+ stalled: GenericStorageQuery<Rv, () => [number, number] | undefined>;
1518
1666
 
1519
1667
  /**
1520
1668
  * The number of changes (both in terms of keys and underlying economic responsibilities)
@@ -1522,7 +1670,7 @@ export interface ChainStorage extends GenericChainStorage {
1522
1670
  *
1523
1671
  * @param {Callback<bigint> =} callback
1524
1672
  **/
1525
- currentSetId: GenericStorageQuery<() => bigint>;
1673
+ currentSetId: GenericStorageQuery<Rv, () => bigint>;
1526
1674
 
1527
1675
  /**
1528
1676
  * A mapping from grandpa set ID to the index of the *most recent* session for which its
@@ -1539,12 +1687,19 @@ export interface ChainStorage extends GenericChainStorage {
1539
1687
  * @param {bigint} arg
1540
1688
  * @param {Callback<number | undefined> =} callback
1541
1689
  **/
1542
- setIdSession: GenericStorageQuery<(arg: bigint) => number | undefined>;
1690
+ setIdSession: GenericStorageQuery<Rv, (arg: bigint) => number | undefined, bigint>;
1691
+
1692
+ /**
1693
+ * The current list of authorities.
1694
+ *
1695
+ * @param {Callback<Array<[SpConsensusGrandpaAppPublic, bigint]>> =} callback
1696
+ **/
1697
+ authorities: GenericStorageQuery<Rv, () => Array<[SpConsensusGrandpaAppPublic, bigint]>>;
1543
1698
 
1544
1699
  /**
1545
1700
  * Generic pallet storage query
1546
1701
  **/
1547
- [storage: string]: GenericStorageQuery;
1702
+ [storage: string]: GenericStorageQuery<Rv>;
1548
1703
  };
1549
1704
  /**
1550
1705
  * Pallet `Treasury`'s storage queries
@@ -1555,7 +1710,7 @@ export interface ChainStorage extends GenericChainStorage {
1555
1710
  *
1556
1711
  * @param {Callback<number> =} callback
1557
1712
  **/
1558
- proposalCount: GenericStorageQuery<() => number>;
1713
+ proposalCount: GenericStorageQuery<Rv, () => number>;
1559
1714
 
1560
1715
  /**
1561
1716
  * Proposals that have been made.
@@ -1563,26 +1718,41 @@ export interface ChainStorage extends GenericChainStorage {
1563
1718
  * @param {number} arg
1564
1719
  * @param {Callback<PalletTreasuryProposal | undefined> =} callback
1565
1720
  **/
1566
- proposals: GenericStorageQuery<(arg: number) => PalletTreasuryProposal | undefined>;
1721
+ proposals: GenericStorageQuery<Rv, (arg: number) => PalletTreasuryProposal | undefined, number>;
1567
1722
 
1568
1723
  /**
1569
1724
  * The amount which has been reported as inactive to Currency.
1570
1725
  *
1571
1726
  * @param {Callback<bigint> =} callback
1572
1727
  **/
1573
- deactivated: GenericStorageQuery<() => bigint>;
1728
+ deactivated: GenericStorageQuery<Rv, () => bigint>;
1574
1729
 
1575
1730
  /**
1576
1731
  * Proposal indices that have been approved but not yet awarded.
1577
1732
  *
1578
1733
  * @param {Callback<Array<number>> =} callback
1579
1734
  **/
1580
- approvals: GenericStorageQuery<() => Array<number>>;
1735
+ approvals: GenericStorageQuery<Rv, () => Array<number>>;
1736
+
1737
+ /**
1738
+ * The count of spends that have been made.
1739
+ *
1740
+ * @param {Callback<number> =} callback
1741
+ **/
1742
+ spendCount: GenericStorageQuery<Rv, () => number>;
1743
+
1744
+ /**
1745
+ * Spends that have been approved and being processed.
1746
+ *
1747
+ * @param {number} arg
1748
+ * @param {Callback<PalletTreasurySpendStatus | undefined> =} callback
1749
+ **/
1750
+ spends: GenericStorageQuery<Rv, (arg: number) => PalletTreasurySpendStatus | undefined, number>;
1581
1751
 
1582
1752
  /**
1583
1753
  * Generic pallet storage query
1584
1754
  **/
1585
- [storage: string]: GenericStorageQuery;
1755
+ [storage: string]: GenericStorageQuery<Rv>;
1586
1756
  };
1587
1757
  /**
1588
1758
  * Pallet `AssetRate`'s storage queries
@@ -1596,12 +1766,12 @@ export interface ChainStorage extends GenericChainStorage {
1596
1766
  * @param {number} arg
1597
1767
  * @param {Callback<FixedU128 | undefined> =} callback
1598
1768
  **/
1599
- conversionRateToNative: GenericStorageQuery<(arg: number) => FixedU128 | undefined>;
1769
+ conversionRateToNative: GenericStorageQuery<Rv, (arg: number) => FixedU128 | undefined, number>;
1600
1770
 
1601
1771
  /**
1602
1772
  * Generic pallet storage query
1603
1773
  **/
1604
- [storage: string]: GenericStorageQuery;
1774
+ [storage: string]: GenericStorageQuery<Rv>;
1605
1775
  };
1606
1776
  /**
1607
1777
  * Pallet `Contracts`'s storage queries
@@ -1613,7 +1783,7 @@ export interface ChainStorage extends GenericChainStorage {
1613
1783
  * @param {H256} arg
1614
1784
  * @param {Callback<Bytes | undefined> =} callback
1615
1785
  **/
1616
- pristineCode: GenericStorageQuery<(arg: H256) => Bytes | undefined>;
1786
+ pristineCode: GenericStorageQuery<Rv, (arg: H256) => Bytes | undefined, H256>;
1617
1787
 
1618
1788
  /**
1619
1789
  * A mapping from a contract's code hash to its code info.
@@ -1621,7 +1791,7 @@ export interface ChainStorage extends GenericChainStorage {
1621
1791
  * @param {H256} arg
1622
1792
  * @param {Callback<PalletContractsWasmCodeInfo | undefined> =} callback
1623
1793
  **/
1624
- codeInfoOf: GenericStorageQuery<(arg: H256) => PalletContractsWasmCodeInfo | undefined>;
1794
+ codeInfoOf: GenericStorageQuery<Rv, (arg: H256) => PalletContractsWasmCodeInfo | undefined, H256>;
1625
1795
 
1626
1796
  /**
1627
1797
  * This is a **monotonic** counter incremented on contract instantiation.
@@ -1649,7 +1819,7 @@ export interface ChainStorage extends GenericChainStorage {
1649
1819
  *
1650
1820
  * @param {Callback<bigint> =} callback
1651
1821
  **/
1652
- nonce: GenericStorageQuery<() => bigint>;
1822
+ nonce: GenericStorageQuery<Rv, () => bigint>;
1653
1823
 
1654
1824
  /**
1655
1825
  * The code associated with a given account.
@@ -1659,7 +1829,11 @@ export interface ChainStorage extends GenericChainStorage {
1659
1829
  * @param {AccountId32Like} arg
1660
1830
  * @param {Callback<PalletContractsStorageContractInfo | undefined> =} callback
1661
1831
  **/
1662
- contractInfoOf: GenericStorageQuery<(arg: AccountId32Like) => PalletContractsStorageContractInfo | undefined>;
1832
+ contractInfoOf: GenericStorageQuery<
1833
+ Rv,
1834
+ (arg: AccountId32Like) => PalletContractsStorageContractInfo | undefined,
1835
+ AccountId32
1836
+ >;
1663
1837
 
1664
1838
  /**
1665
1839
  * Evicted contracts that await child trie deletion.
@@ -1670,7 +1844,7 @@ export interface ChainStorage extends GenericChainStorage {
1670
1844
  * @param {number} arg
1671
1845
  * @param {Callback<Bytes | undefined> =} callback
1672
1846
  **/
1673
- deletionQueue: GenericStorageQuery<(arg: number) => Bytes | undefined>;
1847
+ deletionQueue: GenericStorageQuery<Rv, (arg: number) => Bytes | undefined, number>;
1674
1848
 
1675
1849
  /**
1676
1850
  * A pair of monotonic counters used to track the latest contract marked for deletion
@@ -1678,7 +1852,7 @@ export interface ChainStorage extends GenericChainStorage {
1678
1852
  *
1679
1853
  * @param {Callback<PalletContractsStorageDeletionQueueManager> =} callback
1680
1854
  **/
1681
- deletionQueueCounter: GenericStorageQuery<() => PalletContractsStorageDeletionQueueManager>;
1855
+ deletionQueueCounter: GenericStorageQuery<Rv, () => PalletContractsStorageDeletionQueueManager>;
1682
1856
 
1683
1857
  /**
1684
1858
  * A migration can span across multiple blocks. This storage defines a cursor to track the
@@ -1686,12 +1860,12 @@ export interface ChainStorage extends GenericChainStorage {
1686
1860
  *
1687
1861
  * @param {Callback<Bytes | undefined> =} callback
1688
1862
  **/
1689
- migrationInProgress: GenericStorageQuery<() => Bytes | undefined>;
1863
+ migrationInProgress: GenericStorageQuery<Rv, () => Bytes | undefined>;
1690
1864
 
1691
1865
  /**
1692
1866
  * Generic pallet storage query
1693
1867
  **/
1694
- [storage: string]: GenericStorageQuery;
1868
+ [storage: string]: GenericStorageQuery<Rv>;
1695
1869
  };
1696
1870
  /**
1697
1871
  * Pallet `Sudo`'s storage queries
@@ -1702,12 +1876,12 @@ export interface ChainStorage extends GenericChainStorage {
1702
1876
  *
1703
1877
  * @param {Callback<AccountId32 | undefined> =} callback
1704
1878
  **/
1705
- key: GenericStorageQuery<() => AccountId32 | undefined>;
1879
+ key: GenericStorageQuery<Rv, () => AccountId32 | undefined>;
1706
1880
 
1707
1881
  /**
1708
1882
  * Generic pallet storage query
1709
1883
  **/
1710
- [storage: string]: GenericStorageQuery;
1884
+ [storage: string]: GenericStorageQuery<Rv>;
1711
1885
  };
1712
1886
  /**
1713
1887
  * Pallet `ImOnline`'s storage queries
@@ -1728,14 +1902,14 @@ export interface ChainStorage extends GenericChainStorage {
1728
1902
  *
1729
1903
  * @param {Callback<number> =} callback
1730
1904
  **/
1731
- heartbeatAfter: GenericStorageQuery<() => number>;
1905
+ heartbeatAfter: GenericStorageQuery<Rv, () => number>;
1732
1906
 
1733
1907
  /**
1734
1908
  * The current set of keys that may issue a heartbeat.
1735
1909
  *
1736
1910
  * @param {Callback<Array<PalletImOnlineSr25519AppSr25519Public>> =} callback
1737
1911
  **/
1738
- keys: GenericStorageQuery<() => Array<PalletImOnlineSr25519AppSr25519Public>>;
1912
+ keys: GenericStorageQuery<Rv, () => Array<PalletImOnlineSr25519AppSr25519Public>>;
1739
1913
 
1740
1914
  /**
1741
1915
  * For each session index, we keep a mapping of `SessionIndex` and `AuthIndex`.
@@ -1743,7 +1917,7 @@ export interface ChainStorage extends GenericChainStorage {
1743
1917
  * @param {[number, number]} arg
1744
1918
  * @param {Callback<boolean | undefined> =} callback
1745
1919
  **/
1746
- receivedHeartbeats: GenericStorageQuery<(arg: [number, number]) => boolean | undefined>;
1920
+ receivedHeartbeats: GenericStorageQuery<Rv, (arg: [number, number]) => boolean | undefined, [number, number]>;
1747
1921
 
1748
1922
  /**
1749
1923
  * For each session index, we keep a mapping of `ValidatorId<T>` to the
@@ -1752,12 +1926,12 @@ export interface ChainStorage extends GenericChainStorage {
1752
1926
  * @param {[number, AccountId32Like]} arg
1753
1927
  * @param {Callback<number> =} callback
1754
1928
  **/
1755
- authoredBlocks: GenericStorageQuery<(arg: [number, AccountId32Like]) => number>;
1929
+ authoredBlocks: GenericStorageQuery<Rv, (arg: [number, AccountId32Like]) => number, [number, AccountId32]>;
1756
1930
 
1757
1931
  /**
1758
1932
  * Generic pallet storage query
1759
1933
  **/
1760
- [storage: string]: GenericStorageQuery;
1934
+ [storage: string]: GenericStorageQuery<Rv>;
1761
1935
  };
1762
1936
  /**
1763
1937
  * Pallet `AuthorityDiscovery`'s storage queries
@@ -1768,19 +1942,19 @@ export interface ChainStorage extends GenericChainStorage {
1768
1942
  *
1769
1943
  * @param {Callback<Array<SpAuthorityDiscoveryAppPublic>> =} callback
1770
1944
  **/
1771
- keys: GenericStorageQuery<() => Array<SpAuthorityDiscoveryAppPublic>>;
1945
+ keys: GenericStorageQuery<Rv, () => Array<SpAuthorityDiscoveryAppPublic>>;
1772
1946
 
1773
1947
  /**
1774
1948
  * Keys of the next authority set.
1775
1949
  *
1776
1950
  * @param {Callback<Array<SpAuthorityDiscoveryAppPublic>> =} callback
1777
1951
  **/
1778
- nextKeys: GenericStorageQuery<() => Array<SpAuthorityDiscoveryAppPublic>>;
1952
+ nextKeys: GenericStorageQuery<Rv, () => Array<SpAuthorityDiscoveryAppPublic>>;
1779
1953
 
1780
1954
  /**
1781
1955
  * Generic pallet storage query
1782
1956
  **/
1783
- [storage: string]: GenericStorageQuery;
1957
+ [storage: string]: GenericStorageQuery<Rv>;
1784
1958
  };
1785
1959
  /**
1786
1960
  * Pallet `Offences`'s storage queries
@@ -1792,7 +1966,7 @@ export interface ChainStorage extends GenericChainStorage {
1792
1966
  * @param {H256} arg
1793
1967
  * @param {Callback<SpStakingOffenceOffenceDetails | undefined> =} callback
1794
1968
  **/
1795
- reports: GenericStorageQuery<(arg: H256) => SpStakingOffenceOffenceDetails | undefined>;
1969
+ reports: GenericStorageQuery<Rv, (arg: H256) => SpStakingOffenceOffenceDetails | undefined, H256>;
1796
1970
 
1797
1971
  /**
1798
1972
  * A vector of reports of the same kind that happened at the same time slot.
@@ -1800,12 +1974,40 @@ export interface ChainStorage extends GenericChainStorage {
1800
1974
  * @param {[FixedBytes<16>, BytesLike]} arg
1801
1975
  * @param {Callback<Array<H256>> =} callback
1802
1976
  **/
1803
- concurrentReportsIndex: GenericStorageQuery<(arg: [FixedBytes<16>, BytesLike]) => Array<H256>>;
1977
+ concurrentReportsIndex: GenericStorageQuery<
1978
+ Rv,
1979
+ (arg: [FixedBytes<16>, BytesLike]) => Array<H256>,
1980
+ [FixedBytes<16>, Bytes]
1981
+ >;
1982
+
1983
+ /**
1984
+ * Generic pallet storage query
1985
+ **/
1986
+ [storage: string]: GenericStorageQuery<Rv>;
1987
+ };
1988
+ /**
1989
+ * Pallet `Historical`'s storage queries
1990
+ **/
1991
+ historical: {
1992
+ /**
1993
+ * Mapping from historical session indices to session-data root hash and validator count.
1994
+ *
1995
+ * @param {number} arg
1996
+ * @param {Callback<[H256, number] | undefined> =} callback
1997
+ **/
1998
+ historicalSessions: GenericStorageQuery<Rv, (arg: number) => [H256, number] | undefined, number>;
1999
+
2000
+ /**
2001
+ * The range of historical sessions we store. [first, last)
2002
+ *
2003
+ * @param {Callback<[number, number] | undefined> =} callback
2004
+ **/
2005
+ storedRange: GenericStorageQuery<Rv, () => [number, number] | undefined>;
1804
2006
 
1805
2007
  /**
1806
2008
  * Generic pallet storage query
1807
2009
  **/
1808
- [storage: string]: GenericStorageQuery;
2010
+ [storage: string]: GenericStorageQuery<Rv>;
1809
2011
  };
1810
2012
  /**
1811
2013
  * Pallet `RandomnessCollectiveFlip`'s storage queries
@@ -1818,26 +2020,31 @@ export interface ChainStorage extends GenericChainStorage {
1818
2020
  *
1819
2021
  * @param {Callback<Array<H256>> =} callback
1820
2022
  **/
1821
- randomMaterial: GenericStorageQuery<() => Array<H256>>;
2023
+ randomMaterial: GenericStorageQuery<Rv, () => Array<H256>>;
1822
2024
 
1823
2025
  /**
1824
2026
  * Generic pallet storage query
1825
2027
  **/
1826
- [storage: string]: GenericStorageQuery;
2028
+ [storage: string]: GenericStorageQuery<Rv>;
1827
2029
  };
1828
2030
  /**
1829
2031
  * Pallet `Identity`'s storage queries
1830
2032
  **/
1831
2033
  identity: {
1832
2034
  /**
1833
- * Information that is pertinent to identify the entity behind an account.
2035
+ * Information that is pertinent to identify the entity behind an account. First item is the
2036
+ * registration, second is the account's primary username.
1834
2037
  *
1835
2038
  * TWOX-NOTE: OK ― `AccountId` is a secure hash.
1836
2039
  *
1837
2040
  * @param {AccountId32Like} arg
1838
- * @param {Callback<PalletIdentityRegistration | undefined> =} callback
2041
+ * @param {Callback<[PalletIdentityRegistration, Bytes | undefined] | undefined> =} callback
1839
2042
  **/
1840
- identityOf: GenericStorageQuery<(arg: AccountId32Like) => PalletIdentityRegistration | undefined>;
2043
+ identityOf: GenericStorageQuery<
2044
+ Rv,
2045
+ (arg: AccountId32Like) => [PalletIdentityRegistration, Bytes | undefined] | undefined,
2046
+ AccountId32
2047
+ >;
1841
2048
 
1842
2049
  /**
1843
2050
  * The super-identity of an alternative "sub" identity together with its name, within that
@@ -1846,7 +2053,7 @@ export interface ChainStorage extends GenericChainStorage {
1846
2053
  * @param {AccountId32Like} arg
1847
2054
  * @param {Callback<[AccountId32, Data] | undefined> =} callback
1848
2055
  **/
1849
- superOf: GenericStorageQuery<(arg: AccountId32Like) => [AccountId32, Data] | undefined>;
2056
+ superOf: GenericStorageQuery<Rv, (arg: AccountId32Like) => [AccountId32, Data] | undefined, AccountId32>;
1850
2057
 
1851
2058
  /**
1852
2059
  * Alternative "sub" identities of this account.
@@ -1858,7 +2065,7 @@ export interface ChainStorage extends GenericChainStorage {
1858
2065
  * @param {AccountId32Like} arg
1859
2066
  * @param {Callback<[bigint, Array<AccountId32>]> =} callback
1860
2067
  **/
1861
- subsOf: GenericStorageQuery<(arg: AccountId32Like) => [bigint, Array<AccountId32>]>;
2068
+ subsOf: GenericStorageQuery<Rv, (arg: AccountId32Like) => [bigint, Array<AccountId32>], AccountId32>;
1862
2069
 
1863
2070
  /**
1864
2071
  * The set of registrars. Not expected to get very big as can only be added through a
@@ -1868,12 +2075,49 @@ export interface ChainStorage extends GenericChainStorage {
1868
2075
  *
1869
2076
  * @param {Callback<Array<PalletIdentityRegistrarInfo | undefined>> =} callback
1870
2077
  **/
1871
- registrars: GenericStorageQuery<() => Array<PalletIdentityRegistrarInfo | undefined>>;
2078
+ registrars: GenericStorageQuery<Rv, () => Array<PalletIdentityRegistrarInfo | undefined>>;
2079
+
2080
+ /**
2081
+ * A map of the accounts who are authorized to grant usernames.
2082
+ *
2083
+ * @param {AccountId32Like} arg
2084
+ * @param {Callback<PalletIdentityAuthorityProperties | undefined> =} callback
2085
+ **/
2086
+ usernameAuthorities: GenericStorageQuery<
2087
+ Rv,
2088
+ (arg: AccountId32Like) => PalletIdentityAuthorityProperties | undefined,
2089
+ AccountId32
2090
+ >;
2091
+
2092
+ /**
2093
+ * Reverse lookup from `username` to the `AccountId` that has registered it. The value should
2094
+ * be a key in the `IdentityOf` map, but it may not if the user has cleared their identity.
2095
+ *
2096
+ * Multiple usernames may map to the same `AccountId`, but `IdentityOf` will only map to one
2097
+ * primary username.
2098
+ *
2099
+ * @param {BytesLike} arg
2100
+ * @param {Callback<AccountId32 | undefined> =} callback
2101
+ **/
2102
+ accountOfUsername: GenericStorageQuery<Rv, (arg: BytesLike) => AccountId32 | undefined, Bytes>;
2103
+
2104
+ /**
2105
+ * Usernames that an authority has granted, but that the account controller has not confirmed
2106
+ * that they want it. Used primarily in cases where the `AccountId` cannot provide a signature
2107
+ * because they are a pure proxy, multisig, etc. In order to confirm it, they should call
2108
+ * [`Call::accept_username`].
2109
+ *
2110
+ * First tuple item is the account and second is the acceptance deadline.
2111
+ *
2112
+ * @param {BytesLike} arg
2113
+ * @param {Callback<[AccountId32, number] | undefined> =} callback
2114
+ **/
2115
+ pendingUsernames: GenericStorageQuery<Rv, (arg: BytesLike) => [AccountId32, number] | undefined, Bytes>;
1872
2116
 
1873
2117
  /**
1874
2118
  * Generic pallet storage query
1875
2119
  **/
1876
- [storage: string]: GenericStorageQuery;
2120
+ [storage: string]: GenericStorageQuery<Rv>;
1877
2121
  };
1878
2122
  /**
1879
2123
  * Pallet `Society`'s storage queries
@@ -1884,28 +2128,28 @@ export interface ChainStorage extends GenericChainStorage {
1884
2128
  *
1885
2129
  * @param {Callback<PalletSocietyGroupParams | undefined> =} callback
1886
2130
  **/
1887
- parameters: GenericStorageQuery<() => PalletSocietyGroupParams | undefined>;
2131
+ parameters: GenericStorageQuery<Rv, () => PalletSocietyGroupParams | undefined>;
1888
2132
 
1889
2133
  /**
1890
2134
  * Amount of our account balance that is specifically for the next round's bid(s).
1891
2135
  *
1892
2136
  * @param {Callback<bigint> =} callback
1893
2137
  **/
1894
- pot: GenericStorageQuery<() => bigint>;
2138
+ pot: GenericStorageQuery<Rv, () => bigint>;
1895
2139
 
1896
2140
  /**
1897
2141
  * The first member.
1898
2142
  *
1899
2143
  * @param {Callback<AccountId32 | undefined> =} callback
1900
2144
  **/
1901
- founder: GenericStorageQuery<() => AccountId32 | undefined>;
2145
+ founder: GenericStorageQuery<Rv, () => AccountId32 | undefined>;
1902
2146
 
1903
2147
  /**
1904
2148
  * The most primary from the most recently approved rank 0 members in the society.
1905
2149
  *
1906
2150
  * @param {Callback<AccountId32 | undefined> =} callback
1907
2151
  **/
1908
- head: GenericStorageQuery<() => AccountId32 | undefined>;
2152
+ head: GenericStorageQuery<Rv, () => AccountId32 | undefined>;
1909
2153
 
1910
2154
  /**
1911
2155
  * A hash of the rules of this society concerning membership. Can only be set once and
@@ -1913,7 +2157,7 @@ export interface ChainStorage extends GenericChainStorage {
1913
2157
  *
1914
2158
  * @param {Callback<H256 | undefined> =} callback
1915
2159
  **/
1916
- rules: GenericStorageQuery<() => H256 | undefined>;
2160
+ rules: GenericStorageQuery<Rv, () => H256 | undefined>;
1917
2161
 
1918
2162
  /**
1919
2163
  * The current members and their rank. Doesn't include `SuspendedMembers`.
@@ -1921,7 +2165,7 @@ export interface ChainStorage extends GenericChainStorage {
1921
2165
  * @param {AccountId32Like} arg
1922
2166
  * @param {Callback<PalletSocietyMemberRecord | undefined> =} callback
1923
2167
  **/
1924
- members: GenericStorageQuery<(arg: AccountId32Like) => PalletSocietyMemberRecord | undefined>;
2168
+ members: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletSocietyMemberRecord | undefined, AccountId32>;
1925
2169
 
1926
2170
  /**
1927
2171
  * Information regarding rank-0 payouts, past and future.
@@ -1929,14 +2173,14 @@ export interface ChainStorage extends GenericChainStorage {
1929
2173
  * @param {AccountId32Like} arg
1930
2174
  * @param {Callback<PalletSocietyPayoutRecord> =} callback
1931
2175
  **/
1932
- payouts: GenericStorageQuery<(arg: AccountId32Like) => PalletSocietyPayoutRecord>;
2176
+ payouts: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletSocietyPayoutRecord, AccountId32>;
1933
2177
 
1934
2178
  /**
1935
2179
  * The number of items in `Members` currently. (Doesn't include `SuspendedMembers`.)
1936
2180
  *
1937
2181
  * @param {Callback<number> =} callback
1938
2182
  **/
1939
- memberCount: GenericStorageQuery<() => number>;
2183
+ memberCount: GenericStorageQuery<Rv, () => number>;
1940
2184
 
1941
2185
  /**
1942
2186
  * The current items in `Members` keyed by their unique index. Keys are densely populated
@@ -1945,7 +2189,7 @@ export interface ChainStorage extends GenericChainStorage {
1945
2189
  * @param {number} arg
1946
2190
  * @param {Callback<AccountId32 | undefined> =} callback
1947
2191
  **/
1948
- memberByIndex: GenericStorageQuery<(arg: number) => AccountId32 | undefined>;
2192
+ memberByIndex: GenericStorageQuery<Rv, (arg: number) => AccountId32 | undefined, number>;
1949
2193
 
1950
2194
  /**
1951
2195
  * The set of suspended members, with their old membership record.
@@ -1953,35 +2197,39 @@ export interface ChainStorage extends GenericChainStorage {
1953
2197
  * @param {AccountId32Like} arg
1954
2198
  * @param {Callback<PalletSocietyMemberRecord | undefined> =} callback
1955
2199
  **/
1956
- suspendedMembers: GenericStorageQuery<(arg: AccountId32Like) => PalletSocietyMemberRecord | undefined>;
2200
+ suspendedMembers: GenericStorageQuery<
2201
+ Rv,
2202
+ (arg: AccountId32Like) => PalletSocietyMemberRecord | undefined,
2203
+ AccountId32
2204
+ >;
1957
2205
 
1958
2206
  /**
1959
2207
  * The number of rounds which have passed.
1960
2208
  *
1961
2209
  * @param {Callback<number> =} callback
1962
2210
  **/
1963
- roundCount: GenericStorageQuery<() => number>;
2211
+ roundCount: GenericStorageQuery<Rv, () => number>;
1964
2212
 
1965
2213
  /**
1966
2214
  * The current bids, stored ordered by the value of the bid.
1967
2215
  *
1968
2216
  * @param {Callback<Array<PalletSocietyBid>> =} callback
1969
2217
  **/
1970
- bids: GenericStorageQuery<() => Array<PalletSocietyBid>>;
2218
+ bids: GenericStorageQuery<Rv, () => Array<PalletSocietyBid>>;
1971
2219
 
1972
2220
  /**
1973
2221
  *
1974
2222
  * @param {AccountId32Like} arg
1975
2223
  * @param {Callback<PalletSocietyCandidacy | undefined> =} callback
1976
2224
  **/
1977
- candidates: GenericStorageQuery<(arg: AccountId32Like) => PalletSocietyCandidacy | undefined>;
2225
+ candidates: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletSocietyCandidacy | undefined, AccountId32>;
1978
2226
 
1979
2227
  /**
1980
2228
  * The current skeptic.
1981
2229
  *
1982
2230
  * @param {Callback<AccountId32 | undefined> =} callback
1983
2231
  **/
1984
- skeptic: GenericStorageQuery<() => AccountId32 | undefined>;
2232
+ skeptic: GenericStorageQuery<Rv, () => AccountId32 | undefined>;
1985
2233
 
1986
2234
  /**
1987
2235
  * Double map from Candidate -> Voter -> (Maybe) Vote.
@@ -1989,7 +2237,11 @@ export interface ChainStorage extends GenericChainStorage {
1989
2237
  * @param {[AccountId32Like, AccountId32Like]} arg
1990
2238
  * @param {Callback<PalletSocietyVote | undefined> =} callback
1991
2239
  **/
1992
- votes: GenericStorageQuery<(arg: [AccountId32Like, AccountId32Like]) => PalletSocietyVote | undefined>;
2240
+ votes: GenericStorageQuery<
2241
+ Rv,
2242
+ (arg: [AccountId32Like, AccountId32Like]) => PalletSocietyVote | undefined,
2243
+ [AccountId32, AccountId32]
2244
+ >;
1993
2245
 
1994
2246
  /**
1995
2247
  * Clear-cursor for Vote, map from Candidate -> (Maybe) Cursor.
@@ -1997,7 +2249,7 @@ export interface ChainStorage extends GenericChainStorage {
1997
2249
  * @param {AccountId32Like} arg
1998
2250
  * @param {Callback<Bytes | undefined> =} callback
1999
2251
  **/
2000
- voteClearCursor: GenericStorageQuery<(arg: AccountId32Like) => Bytes | undefined>;
2252
+ voteClearCursor: GenericStorageQuery<Rv, (arg: AccountId32Like) => Bytes | undefined, AccountId32>;
2001
2253
 
2002
2254
  /**
2003
2255
  * At the end of the claim period, this contains the most recently approved members (along with
@@ -2006,21 +2258,21 @@ export interface ChainStorage extends GenericChainStorage {
2006
2258
  *
2007
2259
  * @param {Callback<PalletSocietyIntakeRecord | undefined> =} callback
2008
2260
  **/
2009
- nextHead: GenericStorageQuery<() => PalletSocietyIntakeRecord | undefined>;
2261
+ nextHead: GenericStorageQuery<Rv, () => PalletSocietyIntakeRecord | undefined>;
2010
2262
 
2011
2263
  /**
2012
2264
  * The number of challenge rounds there have been. Used to identify stale DefenderVotes.
2013
2265
  *
2014
2266
  * @param {Callback<number> =} callback
2015
2267
  **/
2016
- challengeRoundCount: GenericStorageQuery<() => number>;
2268
+ challengeRoundCount: GenericStorageQuery<Rv, () => number>;
2017
2269
 
2018
2270
  /**
2019
2271
  * The defending member currently being challenged, along with a running tally of votes.
2020
2272
  *
2021
2273
  * @param {Callback<[AccountId32, AccountId32, PalletSocietyTally] | undefined> =} callback
2022
2274
  **/
2023
- defending: GenericStorageQuery<() => [AccountId32, AccountId32, PalletSocietyTally] | undefined>;
2275
+ defending: GenericStorageQuery<Rv, () => [AccountId32, AccountId32, PalletSocietyTally] | undefined>;
2024
2276
 
2025
2277
  /**
2026
2278
  * Votes for the defender, keyed by challenge round.
@@ -2028,12 +2280,16 @@ export interface ChainStorage extends GenericChainStorage {
2028
2280
  * @param {[number, AccountId32Like]} arg
2029
2281
  * @param {Callback<PalletSocietyVote | undefined> =} callback
2030
2282
  **/
2031
- defenderVotes: GenericStorageQuery<(arg: [number, AccountId32Like]) => PalletSocietyVote | undefined>;
2283
+ defenderVotes: GenericStorageQuery<
2284
+ Rv,
2285
+ (arg: [number, AccountId32Like]) => PalletSocietyVote | undefined,
2286
+ [number, AccountId32]
2287
+ >;
2032
2288
 
2033
2289
  /**
2034
2290
  * Generic pallet storage query
2035
2291
  **/
2036
- [storage: string]: GenericStorageQuery;
2292
+ [storage: string]: GenericStorageQuery<Rv>;
2037
2293
  };
2038
2294
  /**
2039
2295
  * Pallet `Recovery`'s storage queries
@@ -2045,7 +2301,11 @@ export interface ChainStorage extends GenericChainStorage {
2045
2301
  * @param {AccountId32Like} arg
2046
2302
  * @param {Callback<PalletRecoveryRecoveryConfig | undefined> =} callback
2047
2303
  **/
2048
- recoverable: GenericStorageQuery<(arg: AccountId32Like) => PalletRecoveryRecoveryConfig | undefined>;
2304
+ recoverable: GenericStorageQuery<
2305
+ Rv,
2306
+ (arg: AccountId32Like) => PalletRecoveryRecoveryConfig | undefined,
2307
+ AccountId32
2308
+ >;
2049
2309
 
2050
2310
  /**
2051
2311
  * Active recovery attempts.
@@ -2057,7 +2317,9 @@ export interface ChainStorage extends GenericChainStorage {
2057
2317
  * @param {Callback<PalletRecoveryActiveRecovery | undefined> =} callback
2058
2318
  **/
2059
2319
  activeRecoveries: GenericStorageQuery<
2060
- (arg: [AccountId32Like, AccountId32Like]) => PalletRecoveryActiveRecovery | undefined
2320
+ Rv,
2321
+ (arg: [AccountId32Like, AccountId32Like]) => PalletRecoveryActiveRecovery | undefined,
2322
+ [AccountId32, AccountId32]
2061
2323
  >;
2062
2324
 
2063
2325
  /**
@@ -2068,12 +2330,12 @@ export interface ChainStorage extends GenericChainStorage {
2068
2330
  * @param {AccountId32Like} arg
2069
2331
  * @param {Callback<AccountId32 | undefined> =} callback
2070
2332
  **/
2071
- proxy: GenericStorageQuery<(arg: AccountId32Like) => AccountId32 | undefined>;
2333
+ proxy: GenericStorageQuery<Rv, (arg: AccountId32Like) => AccountId32 | undefined, AccountId32>;
2072
2334
 
2073
2335
  /**
2074
2336
  * Generic pallet storage query
2075
2337
  **/
2076
- [storage: string]: GenericStorageQuery;
2338
+ [storage: string]: GenericStorageQuery<Rv>;
2077
2339
  };
2078
2340
  /**
2079
2341
  * Pallet `Vesting`'s storage queries
@@ -2085,7 +2347,11 @@ export interface ChainStorage extends GenericChainStorage {
2085
2347
  * @param {AccountId32Like} arg
2086
2348
  * @param {Callback<Array<PalletVestingVestingInfo> | undefined> =} callback
2087
2349
  **/
2088
- vesting: GenericStorageQuery<(arg: AccountId32Like) => Array<PalletVestingVestingInfo> | undefined>;
2350
+ vesting: GenericStorageQuery<
2351
+ Rv,
2352
+ (arg: AccountId32Like) => Array<PalletVestingVestingInfo> | undefined,
2353
+ AccountId32
2354
+ >;
2089
2355
 
2090
2356
  /**
2091
2357
  * Storage version of the pallet.
@@ -2094,12 +2360,12 @@ export interface ChainStorage extends GenericChainStorage {
2094
2360
  *
2095
2361
  * @param {Callback<PalletVestingReleases> =} callback
2096
2362
  **/
2097
- storageVersion: GenericStorageQuery<() => PalletVestingReleases>;
2363
+ storageVersion: GenericStorageQuery<Rv, () => PalletVestingReleases>;
2098
2364
 
2099
2365
  /**
2100
2366
  * Generic pallet storage query
2101
2367
  **/
2102
- [storage: string]: GenericStorageQuery;
2368
+ [storage: string]: GenericStorageQuery<Rv>;
2103
2369
  };
2104
2370
  /**
2105
2371
  * Pallet `Scheduler`'s storage queries
@@ -2109,7 +2375,7 @@ export interface ChainStorage extends GenericChainStorage {
2109
2375
  *
2110
2376
  * @param {Callback<number | undefined> =} callback
2111
2377
  **/
2112
- incompleteSince: GenericStorageQuery<() => number | undefined>;
2378
+ incompleteSince: GenericStorageQuery<Rv, () => number | undefined>;
2113
2379
 
2114
2380
  /**
2115
2381
  * Items to be executed, indexed by the block number that they should be executed on.
@@ -2117,7 +2383,19 @@ export interface ChainStorage extends GenericChainStorage {
2117
2383
  * @param {number} arg
2118
2384
  * @param {Callback<Array<PalletSchedulerScheduled | undefined>> =} callback
2119
2385
  **/
2120
- agenda: GenericStorageQuery<(arg: number) => Array<PalletSchedulerScheduled | undefined>>;
2386
+ agenda: GenericStorageQuery<Rv, (arg: number) => Array<PalletSchedulerScheduled | undefined>, number>;
2387
+
2388
+ /**
2389
+ * Retry configurations for items to be executed, indexed by task address.
2390
+ *
2391
+ * @param {[number, number]} arg
2392
+ * @param {Callback<PalletSchedulerRetryConfig | undefined> =} callback
2393
+ **/
2394
+ retries: GenericStorageQuery<
2395
+ Rv,
2396
+ (arg: [number, number]) => PalletSchedulerRetryConfig | undefined,
2397
+ [number, number]
2398
+ >;
2121
2399
 
2122
2400
  /**
2123
2401
  * Lookup from a name to the block number and index of the task.
@@ -2128,12 +2406,12 @@ export interface ChainStorage extends GenericChainStorage {
2128
2406
  * @param {FixedBytes<32>} arg
2129
2407
  * @param {Callback<[number, number] | undefined> =} callback
2130
2408
  **/
2131
- lookup: GenericStorageQuery<(arg: FixedBytes<32>) => [number, number] | undefined>;
2409
+ lookup: GenericStorageQuery<Rv, (arg: FixedBytes<32>) => [number, number] | undefined, FixedBytes<32>>;
2132
2410
 
2133
2411
  /**
2134
2412
  * Generic pallet storage query
2135
2413
  **/
2136
- [storage: string]: GenericStorageQuery;
2414
+ [storage: string]: GenericStorageQuery<Rv>;
2137
2415
  };
2138
2416
  /**
2139
2417
  * Pallet `Glutton`'s storage queries
@@ -2147,7 +2425,7 @@ export interface ChainStorage extends GenericChainStorage {
2147
2425
  *
2148
2426
  * @param {Callback<FixedU64> =} callback
2149
2427
  **/
2150
- compute: GenericStorageQuery<() => FixedU64>;
2428
+ compute: GenericStorageQuery<Rv, () => FixedU64>;
2151
2429
 
2152
2430
  /**
2153
2431
  * The proportion of the remaining `proof_size` to consume during `on_idle`.
@@ -2157,7 +2435,7 @@ export interface ChainStorage extends GenericChainStorage {
2157
2435
  *
2158
2436
  * @param {Callback<FixedU64> =} callback
2159
2437
  **/
2160
- storage: GenericStorageQuery<() => FixedU64>;
2438
+ storage: GenericStorageQuery<Rv, () => FixedU64>;
2161
2439
 
2162
2440
  /**
2163
2441
  * Storage map used for wasting proof size.
@@ -2172,43 +2450,51 @@ export interface ChainStorage extends GenericChainStorage {
2172
2450
  * @param {number} arg
2173
2451
  * @param {Callback<FixedBytes<1024> | undefined> =} callback
2174
2452
  **/
2175
- trashData: GenericStorageQuery<(arg: number) => FixedBytes<1024> | undefined>;
2453
+ trashData: GenericStorageQuery<Rv, (arg: number) => FixedBytes<1024> | undefined, number>;
2176
2454
 
2177
2455
  /**
2178
2456
  * The current number of entries in `TrashData`.
2179
2457
  *
2180
2458
  * @param {Callback<number> =} callback
2181
2459
  **/
2182
- trashDataCount: GenericStorageQuery<() => number>;
2460
+ trashDataCount: GenericStorageQuery<Rv, () => number>;
2183
2461
 
2184
2462
  /**
2185
2463
  * Generic pallet storage query
2186
2464
  **/
2187
- [storage: string]: GenericStorageQuery;
2465
+ [storage: string]: GenericStorageQuery<Rv>;
2188
2466
  };
2189
2467
  /**
2190
2468
  * Pallet `Preimage`'s storage queries
2191
2469
  **/
2192
2470
  preimage: {
2471
+ /**
2472
+ * The request status of a given hash.
2473
+ *
2474
+ * @param {H256} arg
2475
+ * @param {Callback<PalletPreimageOldRequestStatus | undefined> =} callback
2476
+ **/
2477
+ statusFor: GenericStorageQuery<Rv, (arg: H256) => PalletPreimageOldRequestStatus | undefined, H256>;
2478
+
2193
2479
  /**
2194
2480
  * The request status of a given hash.
2195
2481
  *
2196
2482
  * @param {H256} arg
2197
2483
  * @param {Callback<PalletPreimageRequestStatus | undefined> =} callback
2198
2484
  **/
2199
- statusFor: GenericStorageQuery<(arg: H256) => PalletPreimageRequestStatus | undefined>;
2485
+ requestStatusFor: GenericStorageQuery<Rv, (arg: H256) => PalletPreimageRequestStatus | undefined, H256>;
2200
2486
 
2201
2487
  /**
2202
2488
  *
2203
2489
  * @param {[H256, number]} arg
2204
2490
  * @param {Callback<Bytes | undefined> =} callback
2205
2491
  **/
2206
- preimageFor: GenericStorageQuery<(arg: [H256, number]) => Bytes | undefined>;
2492
+ preimageFor: GenericStorageQuery<Rv, (arg: [H256, number]) => Bytes | undefined, [H256, number]>;
2207
2493
 
2208
2494
  /**
2209
2495
  * Generic pallet storage query
2210
2496
  **/
2211
- [storage: string]: GenericStorageQuery;
2497
+ [storage: string]: GenericStorageQuery<Rv>;
2212
2498
  };
2213
2499
  /**
2214
2500
  * Pallet `Proxy`'s storage queries
@@ -2221,7 +2507,11 @@ export interface ChainStorage extends GenericChainStorage {
2221
2507
  * @param {AccountId32Like} arg
2222
2508
  * @param {Callback<[Array<PalletProxyProxyDefinition>, bigint]> =} callback
2223
2509
  **/
2224
- proxies: GenericStorageQuery<(arg: AccountId32Like) => [Array<PalletProxyProxyDefinition>, bigint]>;
2510
+ proxies: GenericStorageQuery<
2511
+ Rv,
2512
+ (arg: AccountId32Like) => [Array<PalletProxyProxyDefinition>, bigint],
2513
+ AccountId32
2514
+ >;
2225
2515
 
2226
2516
  /**
2227
2517
  * The announcements made by the proxy (key).
@@ -2229,12 +2519,16 @@ export interface ChainStorage extends GenericChainStorage {
2229
2519
  * @param {AccountId32Like} arg
2230
2520
  * @param {Callback<[Array<PalletProxyAnnouncement>, bigint]> =} callback
2231
2521
  **/
2232
- announcements: GenericStorageQuery<(arg: AccountId32Like) => [Array<PalletProxyAnnouncement>, bigint]>;
2522
+ announcements: GenericStorageQuery<
2523
+ Rv,
2524
+ (arg: AccountId32Like) => [Array<PalletProxyAnnouncement>, bigint],
2525
+ AccountId32
2526
+ >;
2233
2527
 
2234
2528
  /**
2235
2529
  * Generic pallet storage query
2236
2530
  **/
2237
- [storage: string]: GenericStorageQuery;
2531
+ [storage: string]: GenericStorageQuery<Rv>;
2238
2532
  };
2239
2533
  /**
2240
2534
  * Pallet `Multisig`'s storage queries
@@ -2246,12 +2540,16 @@ export interface ChainStorage extends GenericChainStorage {
2246
2540
  * @param {[AccountId32Like, FixedBytes<32>]} arg
2247
2541
  * @param {Callback<PalletMultisigMultisig | undefined> =} callback
2248
2542
  **/
2249
- multisigs: GenericStorageQuery<(arg: [AccountId32Like, FixedBytes<32>]) => PalletMultisigMultisig | undefined>;
2543
+ multisigs: GenericStorageQuery<
2544
+ Rv,
2545
+ (arg: [AccountId32Like, FixedBytes<32>]) => PalletMultisigMultisig | undefined,
2546
+ [AccountId32, FixedBytes<32>]
2547
+ >;
2250
2548
 
2251
2549
  /**
2252
2550
  * Generic pallet storage query
2253
2551
  **/
2254
- [storage: string]: GenericStorageQuery;
2552
+ [storage: string]: GenericStorageQuery<Rv>;
2255
2553
  };
2256
2554
  /**
2257
2555
  * Pallet `Bounties`'s storage queries
@@ -2262,7 +2560,7 @@ export interface ChainStorage extends GenericChainStorage {
2262
2560
  *
2263
2561
  * @param {Callback<number> =} callback
2264
2562
  **/
2265
- bountyCount: GenericStorageQuery<() => number>;
2563
+ bountyCount: GenericStorageQuery<Rv, () => number>;
2266
2564
 
2267
2565
  /**
2268
2566
  * Bounties that have been made.
@@ -2270,7 +2568,7 @@ export interface ChainStorage extends GenericChainStorage {
2270
2568
  * @param {number} arg
2271
2569
  * @param {Callback<PalletBountiesBounty | undefined> =} callback
2272
2570
  **/
2273
- bounties: GenericStorageQuery<(arg: number) => PalletBountiesBounty | undefined>;
2571
+ bounties: GenericStorageQuery<Rv, (arg: number) => PalletBountiesBounty | undefined, number>;
2274
2572
 
2275
2573
  /**
2276
2574
  * The description of each bounty.
@@ -2278,19 +2576,19 @@ export interface ChainStorage extends GenericChainStorage {
2278
2576
  * @param {number} arg
2279
2577
  * @param {Callback<Bytes | undefined> =} callback
2280
2578
  **/
2281
- bountyDescriptions: GenericStorageQuery<(arg: number) => Bytes | undefined>;
2579
+ bountyDescriptions: GenericStorageQuery<Rv, (arg: number) => Bytes | undefined, number>;
2282
2580
 
2283
2581
  /**
2284
2582
  * Bounty indices that have been approved but not yet funded.
2285
2583
  *
2286
2584
  * @param {Callback<Array<number>> =} callback
2287
2585
  **/
2288
- bountyApprovals: GenericStorageQuery<() => Array<number>>;
2586
+ bountyApprovals: GenericStorageQuery<Rv, () => Array<number>>;
2289
2587
 
2290
2588
  /**
2291
2589
  * Generic pallet storage query
2292
2590
  **/
2293
- [storage: string]: GenericStorageQuery;
2591
+ [storage: string]: GenericStorageQuery<Rv>;
2294
2592
  };
2295
2593
  /**
2296
2594
  * Pallet `Tips`'s storage queries
@@ -2304,7 +2602,7 @@ export interface ChainStorage extends GenericChainStorage {
2304
2602
  * @param {H256} arg
2305
2603
  * @param {Callback<PalletTipsOpenTip | undefined> =} callback
2306
2604
  **/
2307
- tips: GenericStorageQuery<(arg: H256) => PalletTipsOpenTip | undefined>;
2605
+ tips: GenericStorageQuery<Rv, (arg: H256) => PalletTipsOpenTip | undefined, H256>;
2308
2606
 
2309
2607
  /**
2310
2608
  * Simple preimage lookup from the reason's hash to the original data. Again, has an
@@ -2313,12 +2611,12 @@ export interface ChainStorage extends GenericChainStorage {
2313
2611
  * @param {H256} arg
2314
2612
  * @param {Callback<Bytes | undefined> =} callback
2315
2613
  **/
2316
- reasons: GenericStorageQuery<(arg: H256) => Bytes | undefined>;
2614
+ reasons: GenericStorageQuery<Rv, (arg: H256) => Bytes | undefined, H256>;
2317
2615
 
2318
2616
  /**
2319
2617
  * Generic pallet storage query
2320
2618
  **/
2321
- [storage: string]: GenericStorageQuery;
2619
+ [storage: string]: GenericStorageQuery<Rv>;
2322
2620
  };
2323
2621
  /**
2324
2622
  * Pallet `Assets`'s storage queries
@@ -2330,7 +2628,7 @@ export interface ChainStorage extends GenericChainStorage {
2330
2628
  * @param {number} arg
2331
2629
  * @param {Callback<PalletAssetsAssetDetails | undefined> =} callback
2332
2630
  **/
2333
- asset: GenericStorageQuery<(arg: number) => PalletAssetsAssetDetails | undefined>;
2631
+ asset: GenericStorageQuery<Rv, (arg: number) => PalletAssetsAssetDetails | undefined, number>;
2334
2632
 
2335
2633
  /**
2336
2634
  * The holdings of a specific account for a specific asset.
@@ -2338,7 +2636,11 @@ export interface ChainStorage extends GenericChainStorage {
2338
2636
  * @param {[number, AccountId32Like]} arg
2339
2637
  * @param {Callback<PalletAssetsAssetAccount | undefined> =} callback
2340
2638
  **/
2341
- account: GenericStorageQuery<(arg: [number, AccountId32Like]) => PalletAssetsAssetAccount | undefined>;
2639
+ account: GenericStorageQuery<
2640
+ Rv,
2641
+ (arg: [number, AccountId32Like]) => PalletAssetsAssetAccount | undefined,
2642
+ [number, AccountId32]
2643
+ >;
2342
2644
 
2343
2645
  /**
2344
2646
  * Approved balance transfers. First balance is the amount approved for transfer. Second
@@ -2349,7 +2651,9 @@ export interface ChainStorage extends GenericChainStorage {
2349
2651
  * @param {Callback<PalletAssetsApproval | undefined> =} callback
2350
2652
  **/
2351
2653
  approvals: GenericStorageQuery<
2352
- (arg: [number, AccountId32Like, AccountId32Like]) => PalletAssetsApproval | undefined
2654
+ Rv,
2655
+ (arg: [number, AccountId32Like, AccountId32Like]) => PalletAssetsApproval | undefined,
2656
+ [number, AccountId32, AccountId32]
2353
2657
  >;
2354
2658
 
2355
2659
  /**
@@ -2358,12 +2662,12 @@ export interface ChainStorage extends GenericChainStorage {
2358
2662
  * @param {number} arg
2359
2663
  * @param {Callback<PalletAssetsAssetMetadata> =} callback
2360
2664
  **/
2361
- metadata: GenericStorageQuery<(arg: number) => PalletAssetsAssetMetadata>;
2665
+ metadata: GenericStorageQuery<Rv, (arg: number) => PalletAssetsAssetMetadata, number>;
2362
2666
 
2363
2667
  /**
2364
2668
  * Generic pallet storage query
2365
2669
  **/
2366
- [storage: string]: GenericStorageQuery;
2670
+ [storage: string]: GenericStorageQuery<Rv>;
2367
2671
  };
2368
2672
  /**
2369
2673
  * Pallet `PoolAssets`'s storage queries
@@ -2375,7 +2679,7 @@ export interface ChainStorage extends GenericChainStorage {
2375
2679
  * @param {number} arg
2376
2680
  * @param {Callback<PalletAssetsAssetDetails | undefined> =} callback
2377
2681
  **/
2378
- asset: GenericStorageQuery<(arg: number) => PalletAssetsAssetDetails | undefined>;
2682
+ asset: GenericStorageQuery<Rv, (arg: number) => PalletAssetsAssetDetails | undefined, number>;
2379
2683
 
2380
2684
  /**
2381
2685
  * The holdings of a specific account for a specific asset.
@@ -2383,7 +2687,11 @@ export interface ChainStorage extends GenericChainStorage {
2383
2687
  * @param {[number, AccountId32Like]} arg
2384
2688
  * @param {Callback<PalletAssetsAssetAccount | undefined> =} callback
2385
2689
  **/
2386
- account: GenericStorageQuery<(arg: [number, AccountId32Like]) => PalletAssetsAssetAccount | undefined>;
2690
+ account: GenericStorageQuery<
2691
+ Rv,
2692
+ (arg: [number, AccountId32Like]) => PalletAssetsAssetAccount | undefined,
2693
+ [number, AccountId32]
2694
+ >;
2387
2695
 
2388
2696
  /**
2389
2697
  * Approved balance transfers. First balance is the amount approved for transfer. Second
@@ -2394,7 +2702,9 @@ export interface ChainStorage extends GenericChainStorage {
2394
2702
  * @param {Callback<PalletAssetsApproval | undefined> =} callback
2395
2703
  **/
2396
2704
  approvals: GenericStorageQuery<
2397
- (arg: [number, AccountId32Like, AccountId32Like]) => PalletAssetsApproval | undefined
2705
+ Rv,
2706
+ (arg: [number, AccountId32Like, AccountId32Like]) => PalletAssetsApproval | undefined,
2707
+ [number, AccountId32, AccountId32]
2398
2708
  >;
2399
2709
 
2400
2710
  /**
@@ -2403,12 +2713,68 @@ export interface ChainStorage extends GenericChainStorage {
2403
2713
  * @param {number} arg
2404
2714
  * @param {Callback<PalletAssetsAssetMetadata> =} callback
2405
2715
  **/
2406
- metadata: GenericStorageQuery<(arg: number) => PalletAssetsAssetMetadata>;
2716
+ metadata: GenericStorageQuery<Rv, (arg: number) => PalletAssetsAssetMetadata, number>;
2407
2717
 
2408
2718
  /**
2409
2719
  * Generic pallet storage query
2410
2720
  **/
2411
- [storage: string]: GenericStorageQuery;
2721
+ [storage: string]: GenericStorageQuery<Rv>;
2722
+ };
2723
+ /**
2724
+ * Pallet `Beefy`'s storage queries
2725
+ **/
2726
+ beefy: {
2727
+ /**
2728
+ * The current authorities set
2729
+ *
2730
+ * @param {Callback<Array<SpConsensusBeefyEcdsaCryptoPublic>> =} callback
2731
+ **/
2732
+ authorities: GenericStorageQuery<Rv, () => Array<SpConsensusBeefyEcdsaCryptoPublic>>;
2733
+
2734
+ /**
2735
+ * The current validator set id
2736
+ *
2737
+ * @param {Callback<bigint> =} callback
2738
+ **/
2739
+ validatorSetId: GenericStorageQuery<Rv, () => bigint>;
2740
+
2741
+ /**
2742
+ * Authorities set scheduled to be used with the next session
2743
+ *
2744
+ * @param {Callback<Array<SpConsensusBeefyEcdsaCryptoPublic>> =} callback
2745
+ **/
2746
+ nextAuthorities: GenericStorageQuery<Rv, () => Array<SpConsensusBeefyEcdsaCryptoPublic>>;
2747
+
2748
+ /**
2749
+ * A mapping from BEEFY set ID to the index of the *most recent* session for which its
2750
+ * members were responsible.
2751
+ *
2752
+ * This is only used for validating equivocation proofs. An equivocation proof must
2753
+ * contains a key-ownership proof for a given session, therefore we need a way to tie
2754
+ * together sessions and BEEFY set ids, i.e. we need to validate that a validator
2755
+ * was the owner of a given key on a given session, and what the active set ID was
2756
+ * during that session.
2757
+ *
2758
+ * TWOX-NOTE: `ValidatorSetId` is not under user control.
2759
+ *
2760
+ * @param {bigint} arg
2761
+ * @param {Callback<number | undefined> =} callback
2762
+ **/
2763
+ setIdSession: GenericStorageQuery<Rv, (arg: bigint) => number | undefined, bigint>;
2764
+
2765
+ /**
2766
+ * Block number where BEEFY consensus is enabled/started.
2767
+ * By changing this (through privileged `set_new_genesis()`), BEEFY consensus is effectively
2768
+ * restarted from the newly set block number.
2769
+ *
2770
+ * @param {Callback<number | undefined> =} callback
2771
+ **/
2772
+ genesisBlock: GenericStorageQuery<Rv, () => number | undefined>;
2773
+
2774
+ /**
2775
+ * Generic pallet storage query
2776
+ **/
2777
+ [storage: string]: GenericStorageQuery<Rv>;
2412
2778
  };
2413
2779
  /**
2414
2780
  * Pallet `Mmr`'s storage queries
@@ -2419,14 +2785,14 @@ export interface ChainStorage extends GenericChainStorage {
2419
2785
  *
2420
2786
  * @param {Callback<H256> =} callback
2421
2787
  **/
2422
- rootHash: GenericStorageQuery<() => H256>;
2788
+ rootHash: GenericStorageQuery<Rv, () => H256>;
2423
2789
 
2424
2790
  /**
2425
2791
  * Current size of the MMR (number of leaves).
2426
2792
  *
2427
2793
  * @param {Callback<bigint> =} callback
2428
2794
  **/
2429
- numberOfLeaves: GenericStorageQuery<() => bigint>;
2795
+ numberOfLeaves: GenericStorageQuery<Rv, () => bigint>;
2430
2796
 
2431
2797
  /**
2432
2798
  * Hashes of the nodes in the MMR.
@@ -2437,12 +2803,37 @@ export interface ChainStorage extends GenericChainStorage {
2437
2803
  * @param {bigint} arg
2438
2804
  * @param {Callback<H256 | undefined> =} callback
2439
2805
  **/
2440
- nodes: GenericStorageQuery<(arg: bigint) => H256 | undefined>;
2806
+ nodes: GenericStorageQuery<Rv, (arg: bigint) => H256 | undefined, bigint>;
2807
+
2808
+ /**
2809
+ * Generic pallet storage query
2810
+ **/
2811
+ [storage: string]: GenericStorageQuery<Rv>;
2812
+ };
2813
+ /**
2814
+ * Pallet `MmrLeaf`'s storage queries
2815
+ **/
2816
+ mmrLeaf: {
2817
+ /**
2818
+ * Details of current BEEFY authority set.
2819
+ *
2820
+ * @param {Callback<SpConsensusBeefyMmrBeefyAuthoritySet> =} callback
2821
+ **/
2822
+ beefyAuthorities: GenericStorageQuery<Rv, () => SpConsensusBeefyMmrBeefyAuthoritySet>;
2823
+
2824
+ /**
2825
+ * Details of next BEEFY authority set.
2826
+ *
2827
+ * This storage entry is used as cache for calls to `update_beefy_next_authority_set`.
2828
+ *
2829
+ * @param {Callback<SpConsensusBeefyMmrBeefyAuthoritySet> =} callback
2830
+ **/
2831
+ beefyNextAuthorities: GenericStorageQuery<Rv, () => SpConsensusBeefyMmrBeefyAuthoritySet>;
2441
2832
 
2442
2833
  /**
2443
2834
  * Generic pallet storage query
2444
2835
  **/
2445
- [storage: string]: GenericStorageQuery;
2836
+ [storage: string]: GenericStorageQuery<Rv>;
2446
2837
  };
2447
2838
  /**
2448
2839
  * Pallet `Lottery`'s storage queries
@@ -2452,14 +2843,14 @@ export interface ChainStorage extends GenericChainStorage {
2452
2843
  *
2453
2844
  * @param {Callback<number> =} callback
2454
2845
  **/
2455
- lotteryIndex: GenericStorageQuery<() => number>;
2846
+ lotteryIndex: GenericStorageQuery<Rv, () => number>;
2456
2847
 
2457
2848
  /**
2458
2849
  * The configuration for the current lottery.
2459
2850
  *
2460
2851
  * @param {Callback<PalletLotteryLotteryConfig | undefined> =} callback
2461
2852
  **/
2462
- lottery: GenericStorageQuery<() => PalletLotteryLotteryConfig | undefined>;
2853
+ lottery: GenericStorageQuery<Rv, () => PalletLotteryLotteryConfig | undefined>;
2463
2854
 
2464
2855
  /**
2465
2856
  * Users who have purchased a ticket. (Lottery Index, Tickets Purchased)
@@ -2467,14 +2858,14 @@ export interface ChainStorage extends GenericChainStorage {
2467
2858
  * @param {AccountId32Like} arg
2468
2859
  * @param {Callback<[number, Array<[number, number]>]> =} callback
2469
2860
  **/
2470
- participants: GenericStorageQuery<(arg: AccountId32Like) => [number, Array<[number, number]>]>;
2861
+ participants: GenericStorageQuery<Rv, (arg: AccountId32Like) => [number, Array<[number, number]>], AccountId32>;
2471
2862
 
2472
2863
  /**
2473
2864
  * Total number of tickets sold.
2474
2865
  *
2475
2866
  * @param {Callback<number> =} callback
2476
2867
  **/
2477
- ticketsCount: GenericStorageQuery<() => number>;
2868
+ ticketsCount: GenericStorageQuery<Rv, () => number>;
2478
2869
 
2479
2870
  /**
2480
2871
  * Each ticket's owner.
@@ -2485,7 +2876,7 @@ export interface ChainStorage extends GenericChainStorage {
2485
2876
  * @param {number} arg
2486
2877
  * @param {Callback<AccountId32 | undefined> =} callback
2487
2878
  **/
2488
- tickets: GenericStorageQuery<(arg: number) => AccountId32 | undefined>;
2879
+ tickets: GenericStorageQuery<Rv, (arg: number) => AccountId32 | undefined, number>;
2489
2880
 
2490
2881
  /**
2491
2882
  * The calls stored in this pallet to be used in an active lottery if configured
@@ -2493,12 +2884,12 @@ export interface ChainStorage extends GenericChainStorage {
2493
2884
  *
2494
2885
  * @param {Callback<Array<[number, number]>> =} callback
2495
2886
  **/
2496
- callIndices: GenericStorageQuery<() => Array<[number, number]>>;
2887
+ callIndices: GenericStorageQuery<Rv, () => Array<[number, number]>>;
2497
2888
 
2498
2889
  /**
2499
2890
  * Generic pallet storage query
2500
2891
  **/
2501
- [storage: string]: GenericStorageQuery;
2892
+ [storage: string]: GenericStorageQuery<Rv>;
2502
2893
  };
2503
2894
  /**
2504
2895
  * Pallet `Nis`'s storage queries
@@ -2513,7 +2904,7 @@ export interface ChainStorage extends GenericChainStorage {
2513
2904
  *
2514
2905
  * @param {Callback<Array<[number, bigint]>> =} callback
2515
2906
  **/
2516
- queueTotals: GenericStorageQuery<() => Array<[number, bigint]>>;
2907
+ queueTotals: GenericStorageQuery<Rv, () => Array<[number, bigint]>>;
2517
2908
 
2518
2909
  /**
2519
2910
  * The queues of bids. Indexed by duration (in `Period`s).
@@ -2521,14 +2912,14 @@ export interface ChainStorage extends GenericChainStorage {
2521
2912
  * @param {number} arg
2522
2913
  * @param {Callback<Array<PalletNisBid>> =} callback
2523
2914
  **/
2524
- queues: GenericStorageQuery<(arg: number) => Array<PalletNisBid>>;
2915
+ queues: GenericStorageQuery<Rv, (arg: number) => Array<PalletNisBid>, number>;
2525
2916
 
2526
2917
  /**
2527
2918
  * Summary information over the general state.
2528
2919
  *
2529
2920
  * @param {Callback<PalletNisSummaryRecord> =} callback
2530
2921
  **/
2531
- summary: GenericStorageQuery<() => PalletNisSummaryRecord>;
2922
+ summary: GenericStorageQuery<Rv, () => PalletNisSummaryRecord>;
2532
2923
 
2533
2924
  /**
2534
2925
  * The currently outstanding receipts, indexed according to the order of creation.
@@ -2536,12 +2927,12 @@ export interface ChainStorage extends GenericChainStorage {
2536
2927
  * @param {number} arg
2537
2928
  * @param {Callback<PalletNisReceiptRecord | undefined> =} callback
2538
2929
  **/
2539
- receipts: GenericStorageQuery<(arg: number) => PalletNisReceiptRecord | undefined>;
2930
+ receipts: GenericStorageQuery<Rv, (arg: number) => PalletNisReceiptRecord | undefined, number>;
2540
2931
 
2541
2932
  /**
2542
2933
  * Generic pallet storage query
2543
2934
  **/
2544
- [storage: string]: GenericStorageQuery;
2935
+ [storage: string]: GenericStorageQuery<Rv>;
2545
2936
  };
2546
2937
  /**
2547
2938
  * Pallet `Uniques`'s storage queries
@@ -2553,7 +2944,7 @@ export interface ChainStorage extends GenericChainStorage {
2553
2944
  * @param {number} arg
2554
2945
  * @param {Callback<PalletUniquesCollectionDetails | undefined> =} callback
2555
2946
  **/
2556
- class: GenericStorageQuery<(arg: number) => PalletUniquesCollectionDetails | undefined>;
2947
+ class: GenericStorageQuery<Rv, (arg: number) => PalletUniquesCollectionDetails | undefined, number>;
2557
2948
 
2558
2949
  /**
2559
2950
  * The collection, if any, of which an account is willing to take ownership.
@@ -2561,7 +2952,7 @@ export interface ChainStorage extends GenericChainStorage {
2561
2952
  * @param {AccountId32Like} arg
2562
2953
  * @param {Callback<number | undefined> =} callback
2563
2954
  **/
2564
- ownershipAcceptance: GenericStorageQuery<(arg: AccountId32Like) => number | undefined>;
2955
+ ownershipAcceptance: GenericStorageQuery<Rv, (arg: AccountId32Like) => number | undefined, AccountId32>;
2565
2956
 
2566
2957
  /**
2567
2958
  * The items held by any given account; set out this way so that items owned by a single
@@ -2570,7 +2961,11 @@ export interface ChainStorage extends GenericChainStorage {
2570
2961
  * @param {[AccountId32Like, number, number]} arg
2571
2962
  * @param {Callback<[] | undefined> =} callback
2572
2963
  **/
2573
- account: GenericStorageQuery<(arg: [AccountId32Like, number, number]) => [] | undefined>;
2964
+ account: GenericStorageQuery<
2965
+ Rv,
2966
+ (arg: [AccountId32Like, number, number]) => [] | undefined,
2967
+ [AccountId32, number, number]
2968
+ >;
2574
2969
 
2575
2970
  /**
2576
2971
  * The collections owned by any given account; set out this way so that collections owned by
@@ -2579,7 +2974,7 @@ export interface ChainStorage extends GenericChainStorage {
2579
2974
  * @param {[AccountId32Like, number]} arg
2580
2975
  * @param {Callback<[] | undefined> =} callback
2581
2976
  **/
2582
- classAccount: GenericStorageQuery<(arg: [AccountId32Like, number]) => [] | undefined>;
2977
+ classAccount: GenericStorageQuery<Rv, (arg: [AccountId32Like, number]) => [] | undefined, [AccountId32, number]>;
2583
2978
 
2584
2979
  /**
2585
2980
  * The items in existence and their ownership details.
@@ -2587,7 +2982,7 @@ export interface ChainStorage extends GenericChainStorage {
2587
2982
  * @param {[number, number]} arg
2588
2983
  * @param {Callback<PalletUniquesItemDetails | undefined> =} callback
2589
2984
  **/
2590
- asset: GenericStorageQuery<(arg: [number, number]) => PalletUniquesItemDetails | undefined>;
2985
+ asset: GenericStorageQuery<Rv, (arg: [number, number]) => PalletUniquesItemDetails | undefined, [number, number]>;
2591
2986
 
2592
2987
  /**
2593
2988
  * Metadata of a collection.
@@ -2595,7 +2990,7 @@ export interface ChainStorage extends GenericChainStorage {
2595
2990
  * @param {number} arg
2596
2991
  * @param {Callback<PalletUniquesCollectionMetadata | undefined> =} callback
2597
2992
  **/
2598
- classMetadataOf: GenericStorageQuery<(arg: number) => PalletUniquesCollectionMetadata | undefined>;
2993
+ classMetadataOf: GenericStorageQuery<Rv, (arg: number) => PalletUniquesCollectionMetadata | undefined, number>;
2599
2994
 
2600
2995
  /**
2601
2996
  * Metadata of an item.
@@ -2603,7 +2998,11 @@ export interface ChainStorage extends GenericChainStorage {
2603
2998
  * @param {[number, number]} arg
2604
2999
  * @param {Callback<PalletUniquesItemMetadata | undefined> =} callback
2605
3000
  **/
2606
- instanceMetadataOf: GenericStorageQuery<(arg: [number, number]) => PalletUniquesItemMetadata | undefined>;
3001
+ instanceMetadataOf: GenericStorageQuery<
3002
+ Rv,
3003
+ (arg: [number, number]) => PalletUniquesItemMetadata | undefined,
3004
+ [number, number]
3005
+ >;
2607
3006
 
2608
3007
  /**
2609
3008
  * Attributes of a collection.
@@ -2611,7 +3010,11 @@ export interface ChainStorage extends GenericChainStorage {
2611
3010
  * @param {[number, number | undefined, BytesLike]} arg
2612
3011
  * @param {Callback<[Bytes, bigint] | undefined> =} callback
2613
3012
  **/
2614
- attribute: GenericStorageQuery<(arg: [number, number | undefined, BytesLike]) => [Bytes, bigint] | undefined>;
3013
+ attribute: GenericStorageQuery<
3014
+ Rv,
3015
+ (arg: [number, number | undefined, BytesLike]) => [Bytes, bigint] | undefined,
3016
+ [number, number | undefined, Bytes]
3017
+ >;
2615
3018
 
2616
3019
  /**
2617
3020
  * Price of an asset instance.
@@ -2619,7 +3022,11 @@ export interface ChainStorage extends GenericChainStorage {
2619
3022
  * @param {[number, number]} arg
2620
3023
  * @param {Callback<[bigint, AccountId32 | undefined] | undefined> =} callback
2621
3024
  **/
2622
- itemPriceOf: GenericStorageQuery<(arg: [number, number]) => [bigint, AccountId32 | undefined] | undefined>;
3025
+ itemPriceOf: GenericStorageQuery<
3026
+ Rv,
3027
+ (arg: [number, number]) => [bigint, AccountId32 | undefined] | undefined,
3028
+ [number, number]
3029
+ >;
2623
3030
 
2624
3031
  /**
2625
3032
  * Keeps track of the number of items a collection might have.
@@ -2627,12 +3034,12 @@ export interface ChainStorage extends GenericChainStorage {
2627
3034
  * @param {number} arg
2628
3035
  * @param {Callback<number | undefined> =} callback
2629
3036
  **/
2630
- collectionMaxSupply: GenericStorageQuery<(arg: number) => number | undefined>;
3037
+ collectionMaxSupply: GenericStorageQuery<Rv, (arg: number) => number | undefined, number>;
2631
3038
 
2632
3039
  /**
2633
3040
  * Generic pallet storage query
2634
3041
  **/
2635
- [storage: string]: GenericStorageQuery;
3042
+ [storage: string]: GenericStorageQuery<Rv>;
2636
3043
  };
2637
3044
  /**
2638
3045
  * Pallet `Nfts`'s storage queries
@@ -2644,7 +3051,7 @@ export interface ChainStorage extends GenericChainStorage {
2644
3051
  * @param {number} arg
2645
3052
  * @param {Callback<PalletNftsCollectionDetails | undefined> =} callback
2646
3053
  **/
2647
- collection: GenericStorageQuery<(arg: number) => PalletNftsCollectionDetails | undefined>;
3054
+ collection: GenericStorageQuery<Rv, (arg: number) => PalletNftsCollectionDetails | undefined, number>;
2648
3055
 
2649
3056
  /**
2650
3057
  * The collection, if any, of which an account is willing to take ownership.
@@ -2652,7 +3059,7 @@ export interface ChainStorage extends GenericChainStorage {
2652
3059
  * @param {AccountId32Like} arg
2653
3060
  * @param {Callback<number | undefined> =} callback
2654
3061
  **/
2655
- ownershipAcceptance: GenericStorageQuery<(arg: AccountId32Like) => number | undefined>;
3062
+ ownershipAcceptance: GenericStorageQuery<Rv, (arg: AccountId32Like) => number | undefined, AccountId32>;
2656
3063
 
2657
3064
  /**
2658
3065
  * The items held by any given account; set out this way so that items owned by a single
@@ -2661,7 +3068,11 @@ export interface ChainStorage extends GenericChainStorage {
2661
3068
  * @param {[AccountId32Like, number, number]} arg
2662
3069
  * @param {Callback<[] | undefined> =} callback
2663
3070
  **/
2664
- account: GenericStorageQuery<(arg: [AccountId32Like, number, number]) => [] | undefined>;
3071
+ account: GenericStorageQuery<
3072
+ Rv,
3073
+ (arg: [AccountId32Like, number, number]) => [] | undefined,
3074
+ [AccountId32, number, number]
3075
+ >;
2665
3076
 
2666
3077
  /**
2667
3078
  * The collections owned by any given account; set out this way so that collections owned by
@@ -2670,7 +3081,11 @@ export interface ChainStorage extends GenericChainStorage {
2670
3081
  * @param {[AccountId32Like, number]} arg
2671
3082
  * @param {Callback<[] | undefined> =} callback
2672
3083
  **/
2673
- collectionAccount: GenericStorageQuery<(arg: [AccountId32Like, number]) => [] | undefined>;
3084
+ collectionAccount: GenericStorageQuery<
3085
+ Rv,
3086
+ (arg: [AccountId32Like, number]) => [] | undefined,
3087
+ [AccountId32, number]
3088
+ >;
2674
3089
 
2675
3090
  /**
2676
3091
  * The items in existence and their ownership details.
@@ -2680,7 +3095,9 @@ export interface ChainStorage extends GenericChainStorage {
2680
3095
  * @param {Callback<PalletNftsBitFlagsCollectionRole | undefined> =} callback
2681
3096
  **/
2682
3097
  collectionRoleOf: GenericStorageQuery<
2683
- (arg: [number, AccountId32Like]) => PalletNftsBitFlagsCollectionRole | undefined
3098
+ Rv,
3099
+ (arg: [number, AccountId32Like]) => PalletNftsBitFlagsCollectionRole | undefined,
3100
+ [number, AccountId32]
2684
3101
  >;
2685
3102
 
2686
3103
  /**
@@ -2689,7 +3106,7 @@ export interface ChainStorage extends GenericChainStorage {
2689
3106
  * @param {[number, number]} arg
2690
3107
  * @param {Callback<PalletNftsItemDetails | undefined> =} callback
2691
3108
  **/
2692
- item: GenericStorageQuery<(arg: [number, number]) => PalletNftsItemDetails | undefined>;
3109
+ item: GenericStorageQuery<Rv, (arg: [number, number]) => PalletNftsItemDetails | undefined, [number, number]>;
2693
3110
 
2694
3111
  /**
2695
3112
  * Metadata of a collection.
@@ -2697,7 +3114,7 @@ export interface ChainStorage extends GenericChainStorage {
2697
3114
  * @param {number} arg
2698
3115
  * @param {Callback<PalletNftsCollectionMetadata | undefined> =} callback
2699
3116
  **/
2700
- collectionMetadataOf: GenericStorageQuery<(arg: number) => PalletNftsCollectionMetadata | undefined>;
3117
+ collectionMetadataOf: GenericStorageQuery<Rv, (arg: number) => PalletNftsCollectionMetadata | undefined, number>;
2701
3118
 
2702
3119
  /**
2703
3120
  * Metadata of an item.
@@ -2705,7 +3122,11 @@ export interface ChainStorage extends GenericChainStorage {
2705
3122
  * @param {[number, number]} arg
2706
3123
  * @param {Callback<PalletNftsItemMetadata | undefined> =} callback
2707
3124
  **/
2708
- itemMetadataOf: GenericStorageQuery<(arg: [number, number]) => PalletNftsItemMetadata | undefined>;
3125
+ itemMetadataOf: GenericStorageQuery<
3126
+ Rv,
3127
+ (arg: [number, number]) => PalletNftsItemMetadata | undefined,
3128
+ [number, number]
3129
+ >;
2709
3130
 
2710
3131
  /**
2711
3132
  * Attributes of a collection.
@@ -2714,9 +3135,11 @@ export interface ChainStorage extends GenericChainStorage {
2714
3135
  * @param {Callback<[Bytes, PalletNftsAttributeDeposit] | undefined> =} callback
2715
3136
  **/
2716
3137
  attribute: GenericStorageQuery<
3138
+ Rv,
2717
3139
  (
2718
3140
  arg: [number, number | undefined, PalletNftsAttributeNamespace, BytesLike],
2719
- ) => [Bytes, PalletNftsAttributeDeposit] | undefined
3141
+ ) => [Bytes, PalletNftsAttributeDeposit] | undefined,
3142
+ [number, number | undefined, PalletNftsAttributeNamespace, Bytes]
2720
3143
  >;
2721
3144
 
2722
3145
  /**
@@ -2725,7 +3148,11 @@ export interface ChainStorage extends GenericChainStorage {
2725
3148
  * @param {[number, number]} arg
2726
3149
  * @param {Callback<[bigint, AccountId32 | undefined] | undefined> =} callback
2727
3150
  **/
2728
- itemPriceOf: GenericStorageQuery<(arg: [number, number]) => [bigint, AccountId32 | undefined] | undefined>;
3151
+ itemPriceOf: GenericStorageQuery<
3152
+ Rv,
3153
+ (arg: [number, number]) => [bigint, AccountId32 | undefined] | undefined,
3154
+ [number, number]
3155
+ >;
2729
3156
 
2730
3157
  /**
2731
3158
  * Item attribute approvals.
@@ -2733,7 +3160,7 @@ export interface ChainStorage extends GenericChainStorage {
2733
3160
  * @param {[number, number]} arg
2734
3161
  * @param {Callback<Array<AccountId32>> =} callback
2735
3162
  **/
2736
- itemAttributesApprovalsOf: GenericStorageQuery<(arg: [number, number]) => Array<AccountId32>>;
3163
+ itemAttributesApprovalsOf: GenericStorageQuery<Rv, (arg: [number, number]) => Array<AccountId32>, [number, number]>;
2737
3164
 
2738
3165
  /**
2739
3166
  * Stores the `CollectionId` that is going to be used for the next collection.
@@ -2741,7 +3168,7 @@ export interface ChainStorage extends GenericChainStorage {
2741
3168
  *
2742
3169
  * @param {Callback<number | undefined> =} callback
2743
3170
  **/
2744
- nextCollectionId: GenericStorageQuery<() => number | undefined>;
3171
+ nextCollectionId: GenericStorageQuery<Rv, () => number | undefined>;
2745
3172
 
2746
3173
  /**
2747
3174
  * Handles all the pending swaps.
@@ -2749,7 +3176,11 @@ export interface ChainStorage extends GenericChainStorage {
2749
3176
  * @param {[number, number]} arg
2750
3177
  * @param {Callback<PalletNftsPendingSwap | undefined> =} callback
2751
3178
  **/
2752
- pendingSwapOf: GenericStorageQuery<(arg: [number, number]) => PalletNftsPendingSwap | undefined>;
3179
+ pendingSwapOf: GenericStorageQuery<
3180
+ Rv,
3181
+ (arg: [number, number]) => PalletNftsPendingSwap | undefined,
3182
+ [number, number]
3183
+ >;
2753
3184
 
2754
3185
  /**
2755
3186
  * Config of a collection.
@@ -2757,7 +3188,7 @@ export interface ChainStorage extends GenericChainStorage {
2757
3188
  * @param {number} arg
2758
3189
  * @param {Callback<PalletNftsCollectionConfig | undefined> =} callback
2759
3190
  **/
2760
- collectionConfigOf: GenericStorageQuery<(arg: number) => PalletNftsCollectionConfig | undefined>;
3191
+ collectionConfigOf: GenericStorageQuery<Rv, (arg: number) => PalletNftsCollectionConfig | undefined, number>;
2761
3192
 
2762
3193
  /**
2763
3194
  * Config of an item.
@@ -2765,12 +3196,16 @@ export interface ChainStorage extends GenericChainStorage {
2765
3196
  * @param {[number, number]} arg
2766
3197
  * @param {Callback<PalletNftsItemConfig | undefined> =} callback
2767
3198
  **/
2768
- itemConfigOf: GenericStorageQuery<(arg: [number, number]) => PalletNftsItemConfig | undefined>;
3199
+ itemConfigOf: GenericStorageQuery<
3200
+ Rv,
3201
+ (arg: [number, number]) => PalletNftsItemConfig | undefined,
3202
+ [number, number]
3203
+ >;
2769
3204
 
2770
3205
  /**
2771
3206
  * Generic pallet storage query
2772
3207
  **/
2773
- [storage: string]: GenericStorageQuery;
3208
+ [storage: string]: GenericStorageQuery<Rv>;
2774
3209
  };
2775
3210
  /**
2776
3211
  * Pallet `NftFractionalization`'s storage queries
@@ -2782,12 +3217,16 @@ export interface ChainStorage extends GenericChainStorage {
2782
3217
  * @param {[number, number]} arg
2783
3218
  * @param {Callback<PalletNftFractionalizationDetails | undefined> =} callback
2784
3219
  **/
2785
- nftToAsset: GenericStorageQuery<(arg: [number, number]) => PalletNftFractionalizationDetails | undefined>;
3220
+ nftToAsset: GenericStorageQuery<
3221
+ Rv,
3222
+ (arg: [number, number]) => PalletNftFractionalizationDetails | undefined,
3223
+ [number, number]
3224
+ >;
2786
3225
 
2787
3226
  /**
2788
3227
  * Generic pallet storage query
2789
3228
  **/
2790
- [storage: string]: GenericStorageQuery;
3229
+ [storage: string]: GenericStorageQuery<Rv>;
2791
3230
  };
2792
3231
  /**
2793
3232
  * Pallet `Salary`'s storage queries
@@ -2798,7 +3237,7 @@ export interface ChainStorage extends GenericChainStorage {
2798
3237
  *
2799
3238
  * @param {Callback<PalletSalaryStatusType | undefined> =} callback
2800
3239
  **/
2801
- status: GenericStorageQuery<() => PalletSalaryStatusType | undefined>;
3240
+ status: GenericStorageQuery<Rv, () => PalletSalaryStatusType | undefined>;
2802
3241
 
2803
3242
  /**
2804
3243
  * The status of a claimant.
@@ -2806,12 +3245,12 @@ export interface ChainStorage extends GenericChainStorage {
2806
3245
  * @param {AccountId32Like} arg
2807
3246
  * @param {Callback<PalletSalaryClaimantStatus | undefined> =} callback
2808
3247
  **/
2809
- claimant: GenericStorageQuery<(arg: AccountId32Like) => PalletSalaryClaimantStatus | undefined>;
3248
+ claimant: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletSalaryClaimantStatus | undefined, AccountId32>;
2810
3249
 
2811
3250
  /**
2812
3251
  * Generic pallet storage query
2813
3252
  **/
2814
- [storage: string]: GenericStorageQuery;
3253
+ [storage: string]: GenericStorageQuery<Rv>;
2815
3254
  };
2816
3255
  /**
2817
3256
  * Pallet `CoreFellowship`'s storage queries
@@ -2822,7 +3261,7 @@ export interface ChainStorage extends GenericChainStorage {
2822
3261
  *
2823
3262
  * @param {Callback<PalletCoreFellowshipParamsType> =} callback
2824
3263
  **/
2825
- params: GenericStorageQuery<() => PalletCoreFellowshipParamsType>;
3264
+ params: GenericStorageQuery<Rv, () => PalletCoreFellowshipParamsType>;
2826
3265
 
2827
3266
  /**
2828
3267
  * The status of a claimant.
@@ -2830,7 +3269,11 @@ export interface ChainStorage extends GenericChainStorage {
2830
3269
  * @param {AccountId32Like} arg
2831
3270
  * @param {Callback<PalletCoreFellowshipMemberStatus | undefined> =} callback
2832
3271
  **/
2833
- member: GenericStorageQuery<(arg: AccountId32Like) => PalletCoreFellowshipMemberStatus | undefined>;
3272
+ member: GenericStorageQuery<
3273
+ Rv,
3274
+ (arg: AccountId32Like) => PalletCoreFellowshipMemberStatus | undefined,
3275
+ AccountId32
3276
+ >;
2834
3277
 
2835
3278
  /**
2836
3279
  * Some evidence together with the desired outcome for which it was presented.
@@ -2838,12 +3281,16 @@ export interface ChainStorage extends GenericChainStorage {
2838
3281
  * @param {AccountId32Like} arg
2839
3282
  * @param {Callback<[PalletCoreFellowshipWish, Bytes] | undefined> =} callback
2840
3283
  **/
2841
- memberEvidence: GenericStorageQuery<(arg: AccountId32Like) => [PalletCoreFellowshipWish, Bytes] | undefined>;
3284
+ memberEvidence: GenericStorageQuery<
3285
+ Rv,
3286
+ (arg: AccountId32Like) => [PalletCoreFellowshipWish, Bytes] | undefined,
3287
+ AccountId32
3288
+ >;
2842
3289
 
2843
3290
  /**
2844
3291
  * Generic pallet storage query
2845
3292
  **/
2846
- [storage: string]: GenericStorageQuery;
3293
+ [storage: string]: GenericStorageQuery<Rv>;
2847
3294
  };
2848
3295
  /**
2849
3296
  * Pallet `TransactionStorage`'s storage queries
@@ -2855,7 +3302,11 @@ export interface ChainStorage extends GenericChainStorage {
2855
3302
  * @param {number} arg
2856
3303
  * @param {Callback<Array<PalletTransactionStorageTransactionInfo> | undefined> =} callback
2857
3304
  **/
2858
- transactions: GenericStorageQuery<(arg: number) => Array<PalletTransactionStorageTransactionInfo> | undefined>;
3305
+ transactions: GenericStorageQuery<
3306
+ Rv,
3307
+ (arg: number) => Array<PalletTransactionStorageTransactionInfo> | undefined,
3308
+ number
3309
+ >;
2859
3310
 
2860
3311
  /**
2861
3312
  * Count indexed chunks for each block.
@@ -2863,21 +3314,21 @@ export interface ChainStorage extends GenericChainStorage {
2863
3314
  * @param {number} arg
2864
3315
  * @param {Callback<number> =} callback
2865
3316
  **/
2866
- chunkCount: GenericStorageQuery<(arg: number) => number>;
3317
+ chunkCount: GenericStorageQuery<Rv, (arg: number) => number, number>;
2867
3318
 
2868
3319
  /**
2869
3320
  * Storage fee per byte.
2870
3321
  *
2871
3322
  * @param {Callback<bigint | undefined> =} callback
2872
3323
  **/
2873
- byteFee: GenericStorageQuery<() => bigint | undefined>;
3324
+ byteFee: GenericStorageQuery<Rv, () => bigint | undefined>;
2874
3325
 
2875
3326
  /**
2876
3327
  * Storage fee per transaction.
2877
3328
  *
2878
3329
  * @param {Callback<bigint | undefined> =} callback
2879
3330
  **/
2880
- entryFee: GenericStorageQuery<() => bigint | undefined>;
3331
+ entryFee: GenericStorageQuery<Rv, () => bigint | undefined>;
2881
3332
 
2882
3333
  /**
2883
3334
  * Storage period for data in blocks. Should match `sp_storage_proof::DEFAULT_STORAGE_PERIOD`
@@ -2885,25 +3336,25 @@ export interface ChainStorage extends GenericChainStorage {
2885
3336
  *
2886
3337
  * @param {Callback<number> =} callback
2887
3338
  **/
2888
- storagePeriod: GenericStorageQuery<() => number>;
3339
+ storagePeriod: GenericStorageQuery<Rv, () => number>;
2889
3340
 
2890
3341
  /**
2891
3342
  *
2892
3343
  * @param {Callback<Array<PalletTransactionStorageTransactionInfo>> =} callback
2893
3344
  **/
2894
- blockTransactions: GenericStorageQuery<() => Array<PalletTransactionStorageTransactionInfo>>;
3345
+ blockTransactions: GenericStorageQuery<Rv, () => Array<PalletTransactionStorageTransactionInfo>>;
2895
3346
 
2896
3347
  /**
2897
3348
  * Was the proof checked in this block?
2898
3349
  *
2899
3350
  * @param {Callback<boolean> =} callback
2900
3351
  **/
2901
- proofChecked: GenericStorageQuery<() => boolean>;
3352
+ proofChecked: GenericStorageQuery<Rv, () => boolean>;
2902
3353
 
2903
3354
  /**
2904
3355
  * Generic pallet storage query
2905
3356
  **/
2906
- [storage: string]: GenericStorageQuery;
3357
+ [storage: string]: GenericStorageQuery<Rv>;
2907
3358
  };
2908
3359
  /**
2909
3360
  * Pallet `VoterList`'s storage queries
@@ -2917,14 +3368,14 @@ export interface ChainStorage extends GenericChainStorage {
2917
3368
  * @param {AccountId32Like} arg
2918
3369
  * @param {Callback<PalletBagsListListNode | undefined> =} callback
2919
3370
  **/
2920
- listNodes: GenericStorageQuery<(arg: AccountId32Like) => PalletBagsListListNode | undefined>;
3371
+ listNodes: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletBagsListListNode | undefined, AccountId32>;
2921
3372
 
2922
3373
  /**
2923
3374
  * Counter for the related counted storage map
2924
3375
  *
2925
3376
  * @param {Callback<number> =} callback
2926
3377
  **/
2927
- counterForListNodes: GenericStorageQuery<() => number>;
3378
+ counterForListNodes: GenericStorageQuery<Rv, () => number>;
2928
3379
 
2929
3380
  /**
2930
3381
  * A bag stored in storage.
@@ -2934,12 +3385,12 @@ export interface ChainStorage extends GenericChainStorage {
2934
3385
  * @param {bigint} arg
2935
3386
  * @param {Callback<PalletBagsListListBag | undefined> =} callback
2936
3387
  **/
2937
- listBags: GenericStorageQuery<(arg: bigint) => PalletBagsListListBag | undefined>;
3388
+ listBags: GenericStorageQuery<Rv, (arg: bigint) => PalletBagsListListBag | undefined, bigint>;
2938
3389
 
2939
3390
  /**
2940
3391
  * Generic pallet storage query
2941
3392
  **/
2942
- [storage: string]: GenericStorageQuery;
3393
+ [storage: string]: GenericStorageQuery<Rv>;
2943
3394
  };
2944
3395
  /**
2945
3396
  * Pallet `StateTrieMigration`'s storage queries
@@ -2953,7 +3404,7 @@ export interface ChainStorage extends GenericChainStorage {
2953
3404
  *
2954
3405
  * @param {Callback<PalletStateTrieMigrationMigrationTask> =} callback
2955
3406
  **/
2956
- migrationProcess: GenericStorageQuery<() => PalletStateTrieMigrationMigrationTask>;
3407
+ migrationProcess: GenericStorageQuery<Rv, () => PalletStateTrieMigrationMigrationTask>;
2957
3408
 
2958
3409
  /**
2959
3410
  * The limits that are imposed on automatic migrations.
@@ -2962,7 +3413,7 @@ export interface ChainStorage extends GenericChainStorage {
2962
3413
  *
2963
3414
  * @param {Callback<PalletStateTrieMigrationMigrationLimits | undefined> =} callback
2964
3415
  **/
2965
- autoLimits: GenericStorageQuery<() => PalletStateTrieMigrationMigrationLimits | undefined>;
3416
+ autoLimits: GenericStorageQuery<Rv, () => PalletStateTrieMigrationMigrationLimits | undefined>;
2966
3417
 
2967
3418
  /**
2968
3419
  * The maximum limits that the signed migration could use.
@@ -2971,12 +3422,12 @@ export interface ChainStorage extends GenericChainStorage {
2971
3422
  *
2972
3423
  * @param {Callback<PalletStateTrieMigrationMigrationLimits | undefined> =} callback
2973
3424
  **/
2974
- signedMigrationMaxLimits: GenericStorageQuery<() => PalletStateTrieMigrationMigrationLimits | undefined>;
3425
+ signedMigrationMaxLimits: GenericStorageQuery<Rv, () => PalletStateTrieMigrationMigrationLimits | undefined>;
2975
3426
 
2976
3427
  /**
2977
3428
  * Generic pallet storage query
2978
3429
  **/
2979
- [storage: string]: GenericStorageQuery;
3430
+ [storage: string]: GenericStorageQuery<Rv>;
2980
3431
  };
2981
3432
  /**
2982
3433
  * Pallet `ChildBounties`'s storage queries
@@ -2987,7 +3438,7 @@ export interface ChainStorage extends GenericChainStorage {
2987
3438
  *
2988
3439
  * @param {Callback<number> =} callback
2989
3440
  **/
2990
- childBountyCount: GenericStorageQuery<() => number>;
3441
+ childBountyCount: GenericStorageQuery<Rv, () => number>;
2991
3442
 
2992
3443
  /**
2993
3444
  * Number of child bounties per parent bounty.
@@ -2996,7 +3447,7 @@ export interface ChainStorage extends GenericChainStorage {
2996
3447
  * @param {number} arg
2997
3448
  * @param {Callback<number> =} callback
2998
3449
  **/
2999
- parentChildBounties: GenericStorageQuery<(arg: number) => number>;
3450
+ parentChildBounties: GenericStorageQuery<Rv, (arg: number) => number, number>;
3000
3451
 
3001
3452
  /**
3002
3453
  * Child bounties that have been added.
@@ -3004,7 +3455,11 @@ export interface ChainStorage extends GenericChainStorage {
3004
3455
  * @param {[number, number]} arg
3005
3456
  * @param {Callback<PalletChildBountiesChildBounty | undefined> =} callback
3006
3457
  **/
3007
- childBounties: GenericStorageQuery<(arg: [number, number]) => PalletChildBountiesChildBounty | undefined>;
3458
+ childBounties: GenericStorageQuery<
3459
+ Rv,
3460
+ (arg: [number, number]) => PalletChildBountiesChildBounty | undefined,
3461
+ [number, number]
3462
+ >;
3008
3463
 
3009
3464
  /**
3010
3465
  * The description of each child-bounty.
@@ -3012,7 +3467,7 @@ export interface ChainStorage extends GenericChainStorage {
3012
3467
  * @param {number} arg
3013
3468
  * @param {Callback<Bytes | undefined> =} callback
3014
3469
  **/
3015
- childBountyDescriptions: GenericStorageQuery<(arg: number) => Bytes | undefined>;
3470
+ childBountyDescriptions: GenericStorageQuery<Rv, (arg: number) => Bytes | undefined, number>;
3016
3471
 
3017
3472
  /**
3018
3473
  * The cumulative child-bounty curator fee for each parent bounty.
@@ -3020,12 +3475,12 @@ export interface ChainStorage extends GenericChainStorage {
3020
3475
  * @param {number} arg
3021
3476
  * @param {Callback<bigint> =} callback
3022
3477
  **/
3023
- childrenCuratorFees: GenericStorageQuery<(arg: number) => bigint>;
3478
+ childrenCuratorFees: GenericStorageQuery<Rv, (arg: number) => bigint, number>;
3024
3479
 
3025
3480
  /**
3026
3481
  * Generic pallet storage query
3027
3482
  **/
3028
- [storage: string]: GenericStorageQuery;
3483
+ [storage: string]: GenericStorageQuery<Rv>;
3029
3484
  };
3030
3485
  /**
3031
3486
  * Pallet `Referenda`'s storage queries
@@ -3036,7 +3491,7 @@ export interface ChainStorage extends GenericChainStorage {
3036
3491
  *
3037
3492
  * @param {Callback<number> =} callback
3038
3493
  **/
3039
- referendumCount: GenericStorageQuery<() => number>;
3494
+ referendumCount: GenericStorageQuery<Rv, () => number>;
3040
3495
 
3041
3496
  /**
3042
3497
  * Information concerning any given referendum.
@@ -3044,7 +3499,7 @@ export interface ChainStorage extends GenericChainStorage {
3044
3499
  * @param {number} arg
3045
3500
  * @param {Callback<PalletReferendaReferendumInfo | undefined> =} callback
3046
3501
  **/
3047
- referendumInfoFor: GenericStorageQuery<(arg: number) => PalletReferendaReferendumInfo | undefined>;
3502
+ referendumInfoFor: GenericStorageQuery<Rv, (arg: number) => PalletReferendaReferendumInfo | undefined, number>;
3048
3503
 
3049
3504
  /**
3050
3505
  * The sorted list of referenda ready to be decided but not yet being decided, ordered by
@@ -3055,7 +3510,7 @@ export interface ChainStorage extends GenericChainStorage {
3055
3510
  * @param {number} arg
3056
3511
  * @param {Callback<Array<[number, bigint]>> =} callback
3057
3512
  **/
3058
- trackQueue: GenericStorageQuery<(arg: number) => Array<[number, bigint]>>;
3513
+ trackQueue: GenericStorageQuery<Rv, (arg: number) => Array<[number, bigint]>, number>;
3059
3514
 
3060
3515
  /**
3061
3516
  * The number of referenda being decided currently.
@@ -3063,11 +3518,11 @@ export interface ChainStorage extends GenericChainStorage {
3063
3518
  * @param {number} arg
3064
3519
  * @param {Callback<number> =} callback
3065
3520
  **/
3066
- decidingCount: GenericStorageQuery<(arg: number) => number>;
3521
+ decidingCount: GenericStorageQuery<Rv, (arg: number) => number, number>;
3067
3522
 
3068
3523
  /**
3069
3524
  * The metadata is a general information concerning the referendum.
3070
- * The `PreimageHash` refers to the preimage of the `Preimages` provider which can be a JSON
3525
+ * The `Hash` refers to the preimage of the `Preimages` provider which can be a JSON
3071
3526
  * dump or IPFS hash of a JSON file.
3072
3527
  *
3073
3528
  * Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)
@@ -3076,12 +3531,12 @@ export interface ChainStorage extends GenericChainStorage {
3076
3531
  * @param {number} arg
3077
3532
  * @param {Callback<H256 | undefined> =} callback
3078
3533
  **/
3079
- metadataOf: GenericStorageQuery<(arg: number) => H256 | undefined>;
3534
+ metadataOf: GenericStorageQuery<Rv, (arg: number) => H256 | undefined, number>;
3080
3535
 
3081
3536
  /**
3082
3537
  * Generic pallet storage query
3083
3538
  **/
3084
- [storage: string]: GenericStorageQuery;
3539
+ [storage: string]: GenericStorageQuery<Rv>;
3085
3540
  };
3086
3541
  /**
3087
3542
  * Pallet `ConvictionVoting`'s storage queries
@@ -3094,7 +3549,11 @@ export interface ChainStorage extends GenericChainStorage {
3094
3549
  * @param {[AccountId32Like, number]} arg
3095
3550
  * @param {Callback<PalletConvictionVotingVoteVoting> =} callback
3096
3551
  **/
3097
- votingFor: GenericStorageQuery<(arg: [AccountId32Like, number]) => PalletConvictionVotingVoteVoting>;
3552
+ votingFor: GenericStorageQuery<
3553
+ Rv,
3554
+ (arg: [AccountId32Like, number]) => PalletConvictionVotingVoteVoting,
3555
+ [AccountId32, number]
3556
+ >;
3098
3557
 
3099
3558
  /**
3100
3559
  * The voting classes which have a non-zero lock requirement and the lock amounts which they
@@ -3104,12 +3563,12 @@ export interface ChainStorage extends GenericChainStorage {
3104
3563
  * @param {AccountId32Like} arg
3105
3564
  * @param {Callback<Array<[number, bigint]>> =} callback
3106
3565
  **/
3107
- classLocksFor: GenericStorageQuery<(arg: AccountId32Like) => Array<[number, bigint]>>;
3566
+ classLocksFor: GenericStorageQuery<Rv, (arg: AccountId32Like) => Array<[number, bigint]>, AccountId32>;
3108
3567
 
3109
3568
  /**
3110
3569
  * Generic pallet storage query
3111
3570
  **/
3112
- [storage: string]: GenericStorageQuery;
3571
+ [storage: string]: GenericStorageQuery<Rv>;
3113
3572
  };
3114
3573
  /**
3115
3574
  * Pallet `Whitelist`'s storage queries
@@ -3120,12 +3579,12 @@ export interface ChainStorage extends GenericChainStorage {
3120
3579
  * @param {H256} arg
3121
3580
  * @param {Callback<[] | undefined> =} callback
3122
3581
  **/
3123
- whitelistedCall: GenericStorageQuery<(arg: H256) => [] | undefined>;
3582
+ whitelistedCall: GenericStorageQuery<Rv, (arg: H256) => [] | undefined, H256>;
3124
3583
 
3125
3584
  /**
3126
3585
  * Generic pallet storage query
3127
3586
  **/
3128
- [storage: string]: GenericStorageQuery;
3587
+ [storage: string]: GenericStorageQuery<Rv>;
3129
3588
  };
3130
3589
  /**
3131
3590
  * Pallet `AllianceMotion`'s storage queries
@@ -3136,7 +3595,7 @@ export interface ChainStorage extends GenericChainStorage {
3136
3595
  *
3137
3596
  * @param {Callback<Array<H256>> =} callback
3138
3597
  **/
3139
- proposals: GenericStorageQuery<() => Array<H256>>;
3598
+ proposals: GenericStorageQuery<Rv, () => Array<H256>>;
3140
3599
 
3141
3600
  /**
3142
3601
  * Actual proposal for a given hash, if it's current.
@@ -3144,7 +3603,7 @@ export interface ChainStorage extends GenericChainStorage {
3144
3603
  * @param {H256} arg
3145
3604
  * @param {Callback<KitchensinkRuntimeRuntimeCall | undefined> =} callback
3146
3605
  **/
3147
- proposalOf: GenericStorageQuery<(arg: H256) => KitchensinkRuntimeRuntimeCall | undefined>;
3606
+ proposalOf: GenericStorageQuery<Rv, (arg: H256) => KitchensinkRuntimeRuntimeCall | undefined, H256>;
3148
3607
 
3149
3608
  /**
3150
3609
  * Votes on a given proposal, if it is ongoing.
@@ -3152,33 +3611,33 @@ export interface ChainStorage extends GenericChainStorage {
3152
3611
  * @param {H256} arg
3153
3612
  * @param {Callback<PalletCollectiveVotes | undefined> =} callback
3154
3613
  **/
3155
- voting: GenericStorageQuery<(arg: H256) => PalletCollectiveVotes | undefined>;
3614
+ voting: GenericStorageQuery<Rv, (arg: H256) => PalletCollectiveVotes | undefined, H256>;
3156
3615
 
3157
3616
  /**
3158
3617
  * Proposals so far.
3159
3618
  *
3160
3619
  * @param {Callback<number> =} callback
3161
3620
  **/
3162
- proposalCount: GenericStorageQuery<() => number>;
3621
+ proposalCount: GenericStorageQuery<Rv, () => number>;
3163
3622
 
3164
3623
  /**
3165
3624
  * The current members of the collective. This is stored sorted (just by value).
3166
3625
  *
3167
3626
  * @param {Callback<Array<AccountId32>> =} callback
3168
3627
  **/
3169
- members: GenericStorageQuery<() => Array<AccountId32>>;
3628
+ members: GenericStorageQuery<Rv, () => Array<AccountId32>>;
3170
3629
 
3171
3630
  /**
3172
3631
  * The prime member that helps determine the default vote behavior in case of absentations.
3173
3632
  *
3174
3633
  * @param {Callback<AccountId32 | undefined> =} callback
3175
3634
  **/
3176
- prime: GenericStorageQuery<() => AccountId32 | undefined>;
3635
+ prime: GenericStorageQuery<Rv, () => AccountId32 | undefined>;
3177
3636
 
3178
3637
  /**
3179
3638
  * Generic pallet storage query
3180
3639
  **/
3181
- [storage: string]: GenericStorageQuery;
3640
+ [storage: string]: GenericStorageQuery<Rv>;
3182
3641
  };
3183
3642
  /**
3184
3643
  * Pallet `Alliance`'s storage queries
@@ -3190,14 +3649,14 @@ export interface ChainStorage extends GenericChainStorage {
3190
3649
  *
3191
3650
  * @param {Callback<PalletAllianceCid | undefined> =} callback
3192
3651
  **/
3193
- rule: GenericStorageQuery<() => PalletAllianceCid | undefined>;
3652
+ rule: GenericStorageQuery<Rv, () => PalletAllianceCid | undefined>;
3194
3653
 
3195
3654
  /**
3196
3655
  * The current IPFS CIDs of any announcements.
3197
3656
  *
3198
3657
  * @param {Callback<Array<PalletAllianceCid>> =} callback
3199
3658
  **/
3200
- announcements: GenericStorageQuery<() => Array<PalletAllianceCid>>;
3659
+ announcements: GenericStorageQuery<Rv, () => Array<PalletAllianceCid>>;
3201
3660
 
3202
3661
  /**
3203
3662
  * Maps members to their candidacy deposit.
@@ -3205,7 +3664,7 @@ export interface ChainStorage extends GenericChainStorage {
3205
3664
  * @param {AccountId32Like} arg
3206
3665
  * @param {Callback<bigint | undefined> =} callback
3207
3666
  **/
3208
- depositOf: GenericStorageQuery<(arg: AccountId32Like) => bigint | undefined>;
3667
+ depositOf: GenericStorageQuery<Rv, (arg: AccountId32Like) => bigint | undefined, AccountId32>;
3209
3668
 
3210
3669
  /**
3211
3670
  * Maps member type to members of each type.
@@ -3213,7 +3672,7 @@ export interface ChainStorage extends GenericChainStorage {
3213
3672
  * @param {PalletAllianceMemberRole} arg
3214
3673
  * @param {Callback<Array<AccountId32>> =} callback
3215
3674
  **/
3216
- members: GenericStorageQuery<(arg: PalletAllianceMemberRole) => Array<AccountId32>>;
3675
+ members: GenericStorageQuery<Rv, (arg: PalletAllianceMemberRole) => Array<AccountId32>, PalletAllianceMemberRole>;
3217
3676
 
3218
3677
  /**
3219
3678
  * A set of members who gave a retirement notice. They can retire after the end of retirement
@@ -3222,7 +3681,7 @@ export interface ChainStorage extends GenericChainStorage {
3222
3681
  * @param {AccountId32Like} arg
3223
3682
  * @param {Callback<number | undefined> =} callback
3224
3683
  **/
3225
- retiringMembers: GenericStorageQuery<(arg: AccountId32Like) => number | undefined>;
3684
+ retiringMembers: GenericStorageQuery<Rv, (arg: AccountId32Like) => number | undefined, AccountId32>;
3226
3685
 
3227
3686
  /**
3228
3687
  * The current list of accounts deemed unscrupulous. These accounts non grata cannot submit
@@ -3230,30 +3689,41 @@ export interface ChainStorage extends GenericChainStorage {
3230
3689
  *
3231
3690
  * @param {Callback<Array<AccountId32>> =} callback
3232
3691
  **/
3233
- unscrupulousAccounts: GenericStorageQuery<() => Array<AccountId32>>;
3692
+ unscrupulousAccounts: GenericStorageQuery<Rv, () => Array<AccountId32>>;
3234
3693
 
3235
3694
  /**
3236
3695
  * The current list of websites deemed unscrupulous.
3237
3696
  *
3238
3697
  * @param {Callback<Array<Bytes>> =} callback
3239
3698
  **/
3240
- unscrupulousWebsites: GenericStorageQuery<() => Array<Bytes>>;
3699
+ unscrupulousWebsites: GenericStorageQuery<Rv, () => Array<Bytes>>;
3241
3700
 
3242
3701
  /**
3243
3702
  * Generic pallet storage query
3244
3703
  **/
3245
- [storage: string]: GenericStorageQuery;
3704
+ [storage: string]: GenericStorageQuery<Rv>;
3246
3705
  };
3247
3706
  /**
3248
3707
  * Pallet `NominationPools`'s storage queries
3249
3708
  **/
3250
3709
  nominationPools: {
3710
+ /**
3711
+ * The sum of funds across all pools.
3712
+ *
3713
+ * This might be lower but never higher than the sum of `total_balance` of all [`PoolMembers`]
3714
+ * because calling `pool_withdraw_unbonded` might decrease the total stake of the pool's
3715
+ * `bonded_account` without adjusting the pallet-internal `UnbondingPool`'s.
3716
+ *
3717
+ * @param {Callback<bigint> =} callback
3718
+ **/
3719
+ totalValueLocked: GenericStorageQuery<Rv, () => bigint>;
3720
+
3251
3721
  /**
3252
3722
  * Minimum amount to bond to join a pool.
3253
3723
  *
3254
3724
  * @param {Callback<bigint> =} callback
3255
3725
  **/
3256
- minJoinBond: GenericStorageQuery<() => bigint>;
3726
+ minJoinBond: GenericStorageQuery<Rv, () => bigint>;
3257
3727
 
3258
3728
  /**
3259
3729
  * Minimum bond required to create a pool.
@@ -3266,7 +3736,7 @@ export interface ChainStorage extends GenericChainStorage {
3266
3736
  *
3267
3737
  * @param {Callback<bigint> =} callback
3268
3738
  **/
3269
- minCreateBond: GenericStorageQuery<() => bigint>;
3739
+ minCreateBond: GenericStorageQuery<Rv, () => bigint>;
3270
3740
 
3271
3741
  /**
3272
3742
  * Maximum number of nomination pools that can exist. If `None`, then an unbounded number of
@@ -3274,7 +3744,7 @@ export interface ChainStorage extends GenericChainStorage {
3274
3744
  *
3275
3745
  * @param {Callback<number | undefined> =} callback
3276
3746
  **/
3277
- maxPools: GenericStorageQuery<() => number | undefined>;
3747
+ maxPools: GenericStorageQuery<Rv, () => number | undefined>;
3278
3748
 
3279
3749
  /**
3280
3750
  * Maximum number of members that can exist in the system. If `None`, then the count
@@ -3282,7 +3752,7 @@ export interface ChainStorage extends GenericChainStorage {
3282
3752
  *
3283
3753
  * @param {Callback<number | undefined> =} callback
3284
3754
  **/
3285
- maxPoolMembers: GenericStorageQuery<() => number | undefined>;
3755
+ maxPoolMembers: GenericStorageQuery<Rv, () => number | undefined>;
3286
3756
 
3287
3757
  /**
3288
3758
  * Maximum number of members that may belong to pool. If `None`, then the count of
@@ -3290,7 +3760,7 @@ export interface ChainStorage extends GenericChainStorage {
3290
3760
  *
3291
3761
  * @param {Callback<number | undefined> =} callback
3292
3762
  **/
3293
- maxPoolMembersPerPool: GenericStorageQuery<() => number | undefined>;
3763
+ maxPoolMembersPerPool: GenericStorageQuery<Rv, () => number | undefined>;
3294
3764
 
3295
3765
  /**
3296
3766
  * The maximum commission that can be charged by a pool. Used on commission payouts to bound
@@ -3299,7 +3769,7 @@ export interface ChainStorage extends GenericChainStorage {
3299
3769
  *
3300
3770
  * @param {Callback<Perbill | undefined> =} callback
3301
3771
  **/
3302
- globalMaxCommission: GenericStorageQuery<() => Perbill | undefined>;
3772
+ globalMaxCommission: GenericStorageQuery<Rv, () => Perbill | undefined>;
3303
3773
 
3304
3774
  /**
3305
3775
  * Active members.
@@ -3309,14 +3779,18 @@ export interface ChainStorage extends GenericChainStorage {
3309
3779
  * @param {AccountId32Like} arg
3310
3780
  * @param {Callback<PalletNominationPoolsPoolMember | undefined> =} callback
3311
3781
  **/
3312
- poolMembers: GenericStorageQuery<(arg: AccountId32Like) => PalletNominationPoolsPoolMember | undefined>;
3782
+ poolMembers: GenericStorageQuery<
3783
+ Rv,
3784
+ (arg: AccountId32Like) => PalletNominationPoolsPoolMember | undefined,
3785
+ AccountId32
3786
+ >;
3313
3787
 
3314
3788
  /**
3315
3789
  * Counter for the related counted storage map
3316
3790
  *
3317
3791
  * @param {Callback<number> =} callback
3318
3792
  **/
3319
- counterForPoolMembers: GenericStorageQuery<() => number>;
3793
+ counterForPoolMembers: GenericStorageQuery<Rv, () => number>;
3320
3794
 
3321
3795
  /**
3322
3796
  * Storage for bonded pools.
@@ -3324,30 +3798,30 @@ export interface ChainStorage extends GenericChainStorage {
3324
3798
  * @param {number} arg
3325
3799
  * @param {Callback<PalletNominationPoolsBondedPoolInner | undefined> =} callback
3326
3800
  **/
3327
- bondedPools: GenericStorageQuery<(arg: number) => PalletNominationPoolsBondedPoolInner | undefined>;
3801
+ bondedPools: GenericStorageQuery<Rv, (arg: number) => PalletNominationPoolsBondedPoolInner | undefined, number>;
3328
3802
 
3329
3803
  /**
3330
3804
  * Counter for the related counted storage map
3331
3805
  *
3332
3806
  * @param {Callback<number> =} callback
3333
3807
  **/
3334
- counterForBondedPools: GenericStorageQuery<() => number>;
3808
+ counterForBondedPools: GenericStorageQuery<Rv, () => number>;
3335
3809
 
3336
3810
  /**
3337
3811
  * Reward pools. This is where there rewards for each pool accumulate. When a members payout is
3338
- * claimed, the balance comes out fo the reward pool. Keyed by the bonded pools account.
3812
+ * claimed, the balance comes out of the reward pool. Keyed by the bonded pools account.
3339
3813
  *
3340
3814
  * @param {number} arg
3341
3815
  * @param {Callback<PalletNominationPoolsRewardPool | undefined> =} callback
3342
3816
  **/
3343
- rewardPools: GenericStorageQuery<(arg: number) => PalletNominationPoolsRewardPool | undefined>;
3817
+ rewardPools: GenericStorageQuery<Rv, (arg: number) => PalletNominationPoolsRewardPool | undefined, number>;
3344
3818
 
3345
3819
  /**
3346
3820
  * Counter for the related counted storage map
3347
3821
  *
3348
3822
  * @param {Callback<number> =} callback
3349
3823
  **/
3350
- counterForRewardPools: GenericStorageQuery<() => number>;
3824
+ counterForRewardPools: GenericStorageQuery<Rv, () => number>;
3351
3825
 
3352
3826
  /**
3353
3827
  * Groups of unbonding pools. Each group of unbonding pools belongs to a
@@ -3356,14 +3830,14 @@ export interface ChainStorage extends GenericChainStorage {
3356
3830
  * @param {number} arg
3357
3831
  * @param {Callback<PalletNominationPoolsSubPools | undefined> =} callback
3358
3832
  **/
3359
- subPoolsStorage: GenericStorageQuery<(arg: number) => PalletNominationPoolsSubPools | undefined>;
3833
+ subPoolsStorage: GenericStorageQuery<Rv, (arg: number) => PalletNominationPoolsSubPools | undefined, number>;
3360
3834
 
3361
3835
  /**
3362
3836
  * Counter for the related counted storage map
3363
3837
  *
3364
3838
  * @param {Callback<number> =} callback
3365
3839
  **/
3366
- counterForSubPoolsStorage: GenericStorageQuery<() => number>;
3840
+ counterForSubPoolsStorage: GenericStorageQuery<Rv, () => number>;
3367
3841
 
3368
3842
  /**
3369
3843
  * Metadata for the pool.
@@ -3371,39 +3845,39 @@ export interface ChainStorage extends GenericChainStorage {
3371
3845
  * @param {number} arg
3372
3846
  * @param {Callback<Bytes> =} callback
3373
3847
  **/
3374
- metadata: GenericStorageQuery<(arg: number) => Bytes>;
3848
+ metadata: GenericStorageQuery<Rv, (arg: number) => Bytes, number>;
3375
3849
 
3376
3850
  /**
3377
3851
  * Counter for the related counted storage map
3378
3852
  *
3379
3853
  * @param {Callback<number> =} callback
3380
3854
  **/
3381
- counterForMetadata: GenericStorageQuery<() => number>;
3855
+ counterForMetadata: GenericStorageQuery<Rv, () => number>;
3382
3856
 
3383
3857
  /**
3384
3858
  * Ever increasing number of all pools created so far.
3385
3859
  *
3386
3860
  * @param {Callback<number> =} callback
3387
3861
  **/
3388
- lastPoolId: GenericStorageQuery<() => number>;
3862
+ lastPoolId: GenericStorageQuery<Rv, () => number>;
3389
3863
 
3390
3864
  /**
3391
3865
  * A reverse lookup from the pool's account id to its id.
3392
3866
  *
3393
- * This is only used for slashing. In all other instances, the pool id is used, and the
3394
- * accounts are deterministically derived from it.
3867
+ * This is only used for slashing and on automatic withdraw update. In all other instances, the
3868
+ * pool id is used, and the accounts are deterministically derived from it.
3395
3869
  *
3396
3870
  * @param {AccountId32Like} arg
3397
3871
  * @param {Callback<number | undefined> =} callback
3398
3872
  **/
3399
- reversePoolIdLookup: GenericStorageQuery<(arg: AccountId32Like) => number | undefined>;
3873
+ reversePoolIdLookup: GenericStorageQuery<Rv, (arg: AccountId32Like) => number | undefined, AccountId32>;
3400
3874
 
3401
3875
  /**
3402
3876
  * Counter for the related counted storage map
3403
3877
  *
3404
3878
  * @param {Callback<number> =} callback
3405
3879
  **/
3406
- counterForReversePoolIdLookup: GenericStorageQuery<() => number>;
3880
+ counterForReversePoolIdLookup: GenericStorageQuery<Rv, () => number>;
3407
3881
 
3408
3882
  /**
3409
3883
  * Map from a pool member account to their opted claim permission.
@@ -3411,12 +3885,16 @@ export interface ChainStorage extends GenericChainStorage {
3411
3885
  * @param {AccountId32Like} arg
3412
3886
  * @param {Callback<PalletNominationPoolsClaimPermission> =} callback
3413
3887
  **/
3414
- claimPermissions: GenericStorageQuery<(arg: AccountId32Like) => PalletNominationPoolsClaimPermission>;
3888
+ claimPermissions: GenericStorageQuery<
3889
+ Rv,
3890
+ (arg: AccountId32Like) => PalletNominationPoolsClaimPermission,
3891
+ AccountId32
3892
+ >;
3415
3893
 
3416
3894
  /**
3417
3895
  * Generic pallet storage query
3418
3896
  **/
3419
- [storage: string]: GenericStorageQuery;
3897
+ [storage: string]: GenericStorageQuery<Rv>;
3420
3898
  };
3421
3899
  /**
3422
3900
  * Pallet `RankedPolls`'s storage queries
@@ -3427,7 +3905,7 @@ export interface ChainStorage extends GenericChainStorage {
3427
3905
  *
3428
3906
  * @param {Callback<number> =} callback
3429
3907
  **/
3430
- referendumCount: GenericStorageQuery<() => number>;
3908
+ referendumCount: GenericStorageQuery<Rv, () => number>;
3431
3909
 
3432
3910
  /**
3433
3911
  * Information concerning any given referendum.
@@ -3435,7 +3913,7 @@ export interface ChainStorage extends GenericChainStorage {
3435
3913
  * @param {number} arg
3436
3914
  * @param {Callback<PalletReferendaReferendumInfoTally | undefined> =} callback
3437
3915
  **/
3438
- referendumInfoFor: GenericStorageQuery<(arg: number) => PalletReferendaReferendumInfoTally | undefined>;
3916
+ referendumInfoFor: GenericStorageQuery<Rv, (arg: number) => PalletReferendaReferendumInfoTally | undefined, number>;
3439
3917
 
3440
3918
  /**
3441
3919
  * The sorted list of referenda ready to be decided but not yet being decided, ordered by
@@ -3446,7 +3924,7 @@ export interface ChainStorage extends GenericChainStorage {
3446
3924
  * @param {number} arg
3447
3925
  * @param {Callback<Array<[number, number]>> =} callback
3448
3926
  **/
3449
- trackQueue: GenericStorageQuery<(arg: number) => Array<[number, number]>>;
3927
+ trackQueue: GenericStorageQuery<Rv, (arg: number) => Array<[number, number]>, number>;
3450
3928
 
3451
3929
  /**
3452
3930
  * The number of referenda being decided currently.
@@ -3454,11 +3932,11 @@ export interface ChainStorage extends GenericChainStorage {
3454
3932
  * @param {number} arg
3455
3933
  * @param {Callback<number> =} callback
3456
3934
  **/
3457
- decidingCount: GenericStorageQuery<(arg: number) => number>;
3935
+ decidingCount: GenericStorageQuery<Rv, (arg: number) => number, number>;
3458
3936
 
3459
3937
  /**
3460
3938
  * The metadata is a general information concerning the referendum.
3461
- * The `PreimageHash` refers to the preimage of the `Preimages` provider which can be a JSON
3939
+ * The `Hash` refers to the preimage of the `Preimages` provider which can be a JSON
3462
3940
  * dump or IPFS hash of a JSON file.
3463
3941
  *
3464
3942
  * Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)
@@ -3467,12 +3945,12 @@ export interface ChainStorage extends GenericChainStorage {
3467
3945
  * @param {number} arg
3468
3946
  * @param {Callback<H256 | undefined> =} callback
3469
3947
  **/
3470
- metadataOf: GenericStorageQuery<(arg: number) => H256 | undefined>;
3948
+ metadataOf: GenericStorageQuery<Rv, (arg: number) => H256 | undefined, number>;
3471
3949
 
3472
3950
  /**
3473
3951
  * Generic pallet storage query
3474
3952
  **/
3475
- [storage: string]: GenericStorageQuery;
3953
+ [storage: string]: GenericStorageQuery<Rv>;
3476
3954
  };
3477
3955
  /**
3478
3956
  * Pallet `RankedCollective`'s storage queries
@@ -3485,7 +3963,7 @@ export interface ChainStorage extends GenericChainStorage {
3485
3963
  * @param {number} arg
3486
3964
  * @param {Callback<number> =} callback
3487
3965
  **/
3488
- memberCount: GenericStorageQuery<(arg: number) => number>;
3966
+ memberCount: GenericStorageQuery<Rv, (arg: number) => number, number>;
3489
3967
 
3490
3968
  /**
3491
3969
  * The current members of the collective.
@@ -3493,7 +3971,11 @@ export interface ChainStorage extends GenericChainStorage {
3493
3971
  * @param {AccountId32Like} arg
3494
3972
  * @param {Callback<PalletRankedCollectiveMemberRecord | undefined> =} callback
3495
3973
  **/
3496
- members: GenericStorageQuery<(arg: AccountId32Like) => PalletRankedCollectiveMemberRecord | undefined>;
3974
+ members: GenericStorageQuery<
3975
+ Rv,
3976
+ (arg: AccountId32Like) => PalletRankedCollectiveMemberRecord | undefined,
3977
+ AccountId32
3978
+ >;
3497
3979
 
3498
3980
  /**
3499
3981
  * The index of each ranks's member into the group of members who have at least that rank.
@@ -3501,7 +3983,7 @@ export interface ChainStorage extends GenericChainStorage {
3501
3983
  * @param {[number, AccountId32Like]} arg
3502
3984
  * @param {Callback<number | undefined> =} callback
3503
3985
  **/
3504
- idToIndex: GenericStorageQuery<(arg: [number, AccountId32Like]) => number | undefined>;
3986
+ idToIndex: GenericStorageQuery<Rv, (arg: [number, AccountId32Like]) => number | undefined, [number, AccountId32]>;
3505
3987
 
3506
3988
  /**
3507
3989
  * The members in the collective by index. All indices in the range `0..MemberCount` will
@@ -3510,7 +3992,7 @@ export interface ChainStorage extends GenericChainStorage {
3510
3992
  * @param {[number, number]} arg
3511
3993
  * @param {Callback<AccountId32 | undefined> =} callback
3512
3994
  **/
3513
- indexToId: GenericStorageQuery<(arg: [number, number]) => AccountId32 | undefined>;
3995
+ indexToId: GenericStorageQuery<Rv, (arg: [number, number]) => AccountId32 | undefined, [number, number]>;
3514
3996
 
3515
3997
  /**
3516
3998
  * Votes on a given proposal, if it is ongoing.
@@ -3518,19 +4000,23 @@ export interface ChainStorage extends GenericChainStorage {
3518
4000
  * @param {[number, AccountId32Like]} arg
3519
4001
  * @param {Callback<PalletRankedCollectiveVoteRecord | undefined> =} callback
3520
4002
  **/
3521
- voting: GenericStorageQuery<(arg: [number, AccountId32Like]) => PalletRankedCollectiveVoteRecord | undefined>;
4003
+ voting: GenericStorageQuery<
4004
+ Rv,
4005
+ (arg: [number, AccountId32Like]) => PalletRankedCollectiveVoteRecord | undefined,
4006
+ [number, AccountId32]
4007
+ >;
3522
4008
 
3523
4009
  /**
3524
4010
  *
3525
4011
  * @param {number} arg
3526
4012
  * @param {Callback<Bytes | undefined> =} callback
3527
4013
  **/
3528
- votingCleanup: GenericStorageQuery<(arg: number) => Bytes | undefined>;
4014
+ votingCleanup: GenericStorageQuery<Rv, (arg: number) => Bytes | undefined, number>;
3529
4015
 
3530
4016
  /**
3531
4017
  * Generic pallet storage query
3532
4018
  **/
3533
- [storage: string]: GenericStorageQuery;
4019
+ [storage: string]: GenericStorageQuery<Rv>;
3534
4020
  };
3535
4021
  /**
3536
4022
  * Pallet `AssetConversion`'s storage queries
@@ -3540,13 +4026,15 @@ export interface ChainStorage extends GenericChainStorage {
3540
4026
  * Map from `PoolAssetId` to `PoolInfo`. This establishes whether a pool has been officially
3541
4027
  * created rather than people sending tokens directly to a pool's public account.
3542
4028
  *
3543
- * @param {[PalletAssetConversionNativeOrAssetId, PalletAssetConversionNativeOrAssetId]} arg
4029
+ * @param {[FrameSupportTokensFungibleUnionOfNativeOrWithId, FrameSupportTokensFungibleUnionOfNativeOrWithId]} arg
3544
4030
  * @param {Callback<PalletAssetConversionPoolInfo | undefined> =} callback
3545
4031
  **/
3546
4032
  pools: GenericStorageQuery<
4033
+ Rv,
3547
4034
  (
3548
- arg: [PalletAssetConversionNativeOrAssetId, PalletAssetConversionNativeOrAssetId],
3549
- ) => PalletAssetConversionPoolInfo | undefined
4035
+ arg: [FrameSupportTokensFungibleUnionOfNativeOrWithId, FrameSupportTokensFungibleUnionOfNativeOrWithId],
4036
+ ) => PalletAssetConversionPoolInfo | undefined,
4037
+ [FrameSupportTokensFungibleUnionOfNativeOrWithId, FrameSupportTokensFungibleUnionOfNativeOrWithId]
3550
4038
  >;
3551
4039
 
3552
4040
  /**
@@ -3555,12 +4043,12 @@ export interface ChainStorage extends GenericChainStorage {
3555
4043
  *
3556
4044
  * @param {Callback<number | undefined> =} callback
3557
4045
  **/
3558
- nextPoolAssetId: GenericStorageQuery<() => number | undefined>;
4046
+ nextPoolAssetId: GenericStorageQuery<Rv, () => number | undefined>;
3559
4047
 
3560
4048
  /**
3561
4049
  * Generic pallet storage query
3562
4050
  **/
3563
- [storage: string]: GenericStorageQuery;
4051
+ [storage: string]: GenericStorageQuery<Rv>;
3564
4052
  };
3565
4053
  /**
3566
4054
  * Pallet `FastUnstake`'s storage queries
@@ -3573,7 +4061,7 @@ export interface ChainStorage extends GenericChainStorage {
3573
4061
  *
3574
4062
  * @param {Callback<PalletFastUnstakeUnstakeRequest | undefined> =} callback
3575
4063
  **/
3576
- head: GenericStorageQuery<() => PalletFastUnstakeUnstakeRequest | undefined>;
4064
+ head: GenericStorageQuery<Rv, () => PalletFastUnstakeUnstakeRequest | undefined>;
3577
4065
 
3578
4066
  /**
3579
4067
  * The map of all accounts wishing to be unstaked.
@@ -3583,14 +4071,14 @@ export interface ChainStorage extends GenericChainStorage {
3583
4071
  * @param {AccountId32Like} arg
3584
4072
  * @param {Callback<bigint | undefined> =} callback
3585
4073
  **/
3586
- queue: GenericStorageQuery<(arg: AccountId32Like) => bigint | undefined>;
4074
+ queue: GenericStorageQuery<Rv, (arg: AccountId32Like) => bigint | undefined, AccountId32>;
3587
4075
 
3588
4076
  /**
3589
4077
  * Counter for the related counted storage map
3590
4078
  *
3591
4079
  * @param {Callback<number> =} callback
3592
4080
  **/
3593
- counterForQueue: GenericStorageQuery<() => number>;
4081
+ counterForQueue: GenericStorageQuery<Rv, () => number>;
3594
4082
 
3595
4083
  /**
3596
4084
  * Number of eras to check per block.
@@ -3604,12 +4092,12 @@ export interface ChainStorage extends GenericChainStorage {
3604
4092
  *
3605
4093
  * @param {Callback<number> =} callback
3606
4094
  **/
3607
- erasToCheckPerBlock: GenericStorageQuery<() => number>;
4095
+ erasToCheckPerBlock: GenericStorageQuery<Rv, () => number>;
3608
4096
 
3609
4097
  /**
3610
4098
  * Generic pallet storage query
3611
4099
  **/
3612
- [storage: string]: GenericStorageQuery;
4100
+ [storage: string]: GenericStorageQuery<Rv>;
3613
4101
  };
3614
4102
  /**
3615
4103
  * Pallet `MessageQueue`'s storage queries
@@ -3621,14 +4109,14 @@ export interface ChainStorage extends GenericChainStorage {
3621
4109
  * @param {number} arg
3622
4110
  * @param {Callback<PalletMessageQueueBookState> =} callback
3623
4111
  **/
3624
- bookStateFor: GenericStorageQuery<(arg: number) => PalletMessageQueueBookState>;
4112
+ bookStateFor: GenericStorageQuery<Rv, (arg: number) => PalletMessageQueueBookState, number>;
3625
4113
 
3626
4114
  /**
3627
4115
  * The origin at which we should begin servicing.
3628
4116
  *
3629
4117
  * @param {Callback<number | undefined> =} callback
3630
4118
  **/
3631
- serviceHead: GenericStorageQuery<() => number | undefined>;
4119
+ serviceHead: GenericStorageQuery<Rv, () => number | undefined>;
3632
4120
 
3633
4121
  /**
3634
4122
  * The map of page indices to pages.
@@ -3636,12 +4124,12 @@ export interface ChainStorage extends GenericChainStorage {
3636
4124
  * @param {[number, number]} arg
3637
4125
  * @param {Callback<PalletMessageQueuePage | undefined> =} callback
3638
4126
  **/
3639
- pages: GenericStorageQuery<(arg: [number, number]) => PalletMessageQueuePage | undefined>;
4127
+ pages: GenericStorageQuery<Rv, (arg: [number, number]) => PalletMessageQueuePage | undefined, [number, number]>;
3640
4128
 
3641
4129
  /**
3642
4130
  * Generic pallet storage query
3643
4131
  **/
3644
- [storage: string]: GenericStorageQuery;
4132
+ [storage: string]: GenericStorageQuery<Rv>;
3645
4133
  };
3646
4134
  /**
3647
4135
  * Pallet `Pov`'s storage queries
@@ -3651,40 +4139,40 @@ export interface ChainStorage extends GenericChainStorage {
3651
4139
  *
3652
4140
  * @param {Callback<number | undefined> =} callback
3653
4141
  **/
3654
- value: GenericStorageQuery<() => number | undefined>;
4142
+ value: GenericStorageQuery<Rv, () => number | undefined>;
3655
4143
 
3656
4144
  /**
3657
4145
  *
3658
4146
  * @param {Callback<number | undefined> =} callback
3659
4147
  **/
3660
- value2: GenericStorageQuery<() => number | undefined>;
4148
+ value2: GenericStorageQuery<Rv, () => number | undefined>;
3661
4149
 
3662
4150
  /**
3663
4151
  * A value without a MEL bound.
3664
4152
  *
3665
4153
  * @param {Callback<Bytes | undefined> =} callback
3666
4154
  **/
3667
- unboundedValue: GenericStorageQuery<() => Bytes | undefined>;
4155
+ unboundedValue: GenericStorageQuery<Rv, () => Bytes | undefined>;
3668
4156
 
3669
4157
  /**
3670
4158
  * A value with a MEL bound of 32 byte.
3671
4159
  *
3672
4160
  * @param {Callback<Bytes | undefined> =} callback
3673
4161
  **/
3674
- boundedValue: GenericStorageQuery<() => Bytes | undefined>;
4162
+ boundedValue: GenericStorageQuery<Rv, () => Bytes | undefined>;
3675
4163
 
3676
4164
  /**
3677
4165
  * 4MiB value.
3678
4166
  *
3679
4167
  * @param {Callback<Bytes | undefined> =} callback
3680
4168
  **/
3681
- largeValue: GenericStorageQuery<() => Bytes | undefined>;
4169
+ largeValue: GenericStorageQuery<Rv, () => Bytes | undefined>;
3682
4170
 
3683
4171
  /**
3684
4172
  *
3685
4173
  * @param {Callback<Bytes | undefined> =} callback
3686
4174
  **/
3687
- largeValue2: GenericStorageQuery<() => Bytes | undefined>;
4175
+ largeValue2: GenericStorageQuery<Rv, () => Bytes | undefined>;
3688
4176
 
3689
4177
  /**
3690
4178
  * A map with a maximum of 1M entries.
@@ -3692,7 +4180,7 @@ export interface ChainStorage extends GenericChainStorage {
3692
4180
  * @param {number} arg
3693
4181
  * @param {Callback<number | undefined> =} callback
3694
4182
  **/
3695
- map1M: GenericStorageQuery<(arg: number) => number | undefined>;
4183
+ map1M: GenericStorageQuery<Rv, (arg: number) => number | undefined, number>;
3696
4184
 
3697
4185
  /**
3698
4186
  * A map with a maximum of 16M entries.
@@ -3700,40 +4188,40 @@ export interface ChainStorage extends GenericChainStorage {
3700
4188
  * @param {number} arg
3701
4189
  * @param {Callback<number | undefined> =} callback
3702
4190
  **/
3703
- map16M: GenericStorageQuery<(arg: number) => number | undefined>;
4191
+ map16M: GenericStorageQuery<Rv, (arg: number) => number | undefined, number>;
3704
4192
 
3705
4193
  /**
3706
4194
  *
3707
4195
  * @param {[number, number]} arg
3708
4196
  * @param {Callback<number | undefined> =} callback
3709
4197
  **/
3710
- doubleMap1M: GenericStorageQuery<(arg: [number, number]) => number | undefined>;
4198
+ doubleMap1M: GenericStorageQuery<Rv, (arg: [number, number]) => number | undefined, [number, number]>;
3711
4199
 
3712
4200
  /**
3713
4201
  *
3714
4202
  * @param {number} arg
3715
4203
  * @param {Callback<Array<number> | undefined> =} callback
3716
4204
  **/
3717
- unboundedMap: GenericStorageQuery<(arg: number) => Array<number> | undefined>;
4205
+ unboundedMap: GenericStorageQuery<Rv, (arg: number) => Array<number> | undefined, number>;
3718
4206
 
3719
4207
  /**
3720
4208
  *
3721
4209
  * @param {number} arg
3722
4210
  * @param {Callback<Array<number> | undefined> =} callback
3723
4211
  **/
3724
- unboundedMap2: GenericStorageQuery<(arg: number) => Array<number> | undefined>;
4212
+ unboundedMap2: GenericStorageQuery<Rv, (arg: number) => Array<number> | undefined, number>;
3725
4213
 
3726
4214
  /**
3727
4215
  *
3728
4216
  * @param {number} arg
3729
4217
  * @param {Callback<Array<number> | undefined> =} callback
3730
4218
  **/
3731
- unboundedMapTwox: GenericStorageQuery<(arg: number) => Array<number> | undefined>;
4219
+ unboundedMapTwox: GenericStorageQuery<Rv, (arg: number) => Array<number> | undefined, number>;
3732
4220
 
3733
4221
  /**
3734
4222
  * Generic pallet storage query
3735
4223
  **/
3736
- [storage: string]: GenericStorageQuery;
4224
+ [storage: string]: GenericStorageQuery<Rv>;
3737
4225
  };
3738
4226
  /**
3739
4227
  * Pallet `TxPause`'s storage queries
@@ -3745,12 +4233,12 @@ export interface ChainStorage extends GenericChainStorage {
3745
4233
  * @param {[BytesLike, BytesLike]} arg
3746
4234
  * @param {Callback<[] | undefined> =} callback
3747
4235
  **/
3748
- pausedCalls: GenericStorageQuery<(arg: [BytesLike, BytesLike]) => [] | undefined>;
4236
+ pausedCalls: GenericStorageQuery<Rv, (arg: [BytesLike, BytesLike]) => [] | undefined, [Bytes, Bytes]>;
3749
4237
 
3750
4238
  /**
3751
4239
  * Generic pallet storage query
3752
4240
  **/
3753
- [storage: string]: GenericStorageQuery;
4241
+ [storage: string]: GenericStorageQuery<Rv>;
3754
4242
  };
3755
4243
  /**
3756
4244
  * Pallet `SafeMode`'s storage queries
@@ -3765,7 +4253,7 @@ export interface ChainStorage extends GenericChainStorage {
3765
4253
  *
3766
4254
  * @param {Callback<number | undefined> =} callback
3767
4255
  **/
3768
- enteredUntil: GenericStorageQuery<() => number | undefined>;
4256
+ enteredUntil: GenericStorageQuery<Rv, () => number | undefined>;
3769
4257
 
3770
4258
  /**
3771
4259
  * Holds the reserve that was taken from an account at a specific block number.
@@ -3776,12 +4264,41 @@ export interface ChainStorage extends GenericChainStorage {
3776
4264
  * @param {[AccountId32Like, number]} arg
3777
4265
  * @param {Callback<bigint | undefined> =} callback
3778
4266
  **/
3779
- deposits: GenericStorageQuery<(arg: [AccountId32Like, number]) => bigint | undefined>;
4267
+ deposits: GenericStorageQuery<Rv, (arg: [AccountId32Like, number]) => bigint | undefined, [AccountId32, number]>;
3780
4268
 
3781
4269
  /**
3782
4270
  * Generic pallet storage query
3783
4271
  **/
3784
- [storage: string]: GenericStorageQuery;
4272
+ [storage: string]: GenericStorageQuery<Rv>;
4273
+ };
4274
+ /**
4275
+ * Pallet `MultiBlockMigrations`'s storage queries
4276
+ **/
4277
+ multiBlockMigrations: {
4278
+ /**
4279
+ * The currently active migration to run and its cursor.
4280
+ *
4281
+ * `None` indicates that no migration is running.
4282
+ *
4283
+ * @param {Callback<PalletMigrationsMigrationCursor | undefined> =} callback
4284
+ **/
4285
+ cursor: GenericStorageQuery<Rv, () => PalletMigrationsMigrationCursor | undefined>;
4286
+
4287
+ /**
4288
+ * Set of all successfully executed migrations.
4289
+ *
4290
+ * This is used as blacklist, to not re-execute migrations that have not been removed from the
4291
+ * codebase yet. Governance can regularly clear this out via `clear_historic`.
4292
+ *
4293
+ * @param {BytesLike} arg
4294
+ * @param {Callback<[] | undefined> =} callback
4295
+ **/
4296
+ historic: GenericStorageQuery<Rv, (arg: BytesLike) => [] | undefined, Bytes>;
4297
+
4298
+ /**
4299
+ * Generic pallet storage query
4300
+ **/
4301
+ [storage: string]: GenericStorageQuery<Rv>;
3785
4302
  };
3786
4303
  /**
3787
4304
  * Pallet `Broker`'s storage queries
@@ -3792,35 +4309,35 @@ export interface ChainStorage extends GenericChainStorage {
3792
4309
  *
3793
4310
  * @param {Callback<PalletBrokerConfigRecord | undefined> =} callback
3794
4311
  **/
3795
- configuration: GenericStorageQuery<() => PalletBrokerConfigRecord | undefined>;
4312
+ configuration: GenericStorageQuery<Rv, () => PalletBrokerConfigRecord | undefined>;
3796
4313
 
3797
4314
  /**
3798
4315
  * The Polkadot Core reservations (generally tasked with the maintenance of System Chains).
3799
4316
  *
3800
4317
  * @param {Callback<Array<Array<PalletBrokerScheduleItem>>> =} callback
3801
4318
  **/
3802
- reservations: GenericStorageQuery<() => Array<Array<PalletBrokerScheduleItem>>>;
4319
+ reservations: GenericStorageQuery<Rv, () => Array<Array<PalletBrokerScheduleItem>>>;
3803
4320
 
3804
4321
  /**
3805
4322
  * The Polkadot Core legacy leases.
3806
4323
  *
3807
4324
  * @param {Callback<Array<PalletBrokerLeaseRecordItem>> =} callback
3808
4325
  **/
3809
- leases: GenericStorageQuery<() => Array<PalletBrokerLeaseRecordItem>>;
4326
+ leases: GenericStorageQuery<Rv, () => Array<PalletBrokerLeaseRecordItem>>;
3810
4327
 
3811
4328
  /**
3812
4329
  * The current status of miscellaneous subsystems of this pallet.
3813
4330
  *
3814
4331
  * @param {Callback<PalletBrokerStatusRecord | undefined> =} callback
3815
4332
  **/
3816
- status: GenericStorageQuery<() => PalletBrokerStatusRecord | undefined>;
4333
+ status: GenericStorageQuery<Rv, () => PalletBrokerStatusRecord | undefined>;
3817
4334
 
3818
4335
  /**
3819
4336
  * The details of the current sale, including its properties and status.
3820
4337
  *
3821
4338
  * @param {Callback<PalletBrokerSaleInfoRecord | undefined> =} callback
3822
4339
  **/
3823
- saleInfo: GenericStorageQuery<() => PalletBrokerSaleInfoRecord | undefined>;
4340
+ saleInfo: GenericStorageQuery<Rv, () => PalletBrokerSaleInfoRecord | undefined>;
3824
4341
 
3825
4342
  /**
3826
4343
  * Records of allowed renewals.
@@ -3829,7 +4346,9 @@ export interface ChainStorage extends GenericChainStorage {
3829
4346
  * @param {Callback<PalletBrokerAllowedRenewalRecord | undefined> =} callback
3830
4347
  **/
3831
4348
  allowedRenewals: GenericStorageQuery<
3832
- (arg: PalletBrokerAllowedRenewalId) => PalletBrokerAllowedRenewalRecord | undefined
4349
+ Rv,
4350
+ (arg: PalletBrokerAllowedRenewalId) => PalletBrokerAllowedRenewalRecord | undefined,
4351
+ PalletBrokerAllowedRenewalId
3833
4352
  >;
3834
4353
 
3835
4354
  /**
@@ -3838,7 +4357,11 @@ export interface ChainStorage extends GenericChainStorage {
3838
4357
  * @param {PalletBrokerRegionId} arg
3839
4358
  * @param {Callback<PalletBrokerRegionRecord | undefined> =} callback
3840
4359
  **/
3841
- regions: GenericStorageQuery<(arg: PalletBrokerRegionId) => PalletBrokerRegionRecord | undefined>;
4360
+ regions: GenericStorageQuery<
4361
+ Rv,
4362
+ (arg: PalletBrokerRegionId) => PalletBrokerRegionRecord | undefined,
4363
+ PalletBrokerRegionId
4364
+ >;
3842
4365
 
3843
4366
  /**
3844
4367
  * The work we plan on having each core do at a particular time in the future.
@@ -3846,7 +4369,11 @@ export interface ChainStorage extends GenericChainStorage {
3846
4369
  * @param {[number, number]} arg
3847
4370
  * @param {Callback<Array<PalletBrokerScheduleItem> | undefined> =} callback
3848
4371
  **/
3849
- workplan: GenericStorageQuery<(arg: [number, number]) => Array<PalletBrokerScheduleItem> | undefined>;
4372
+ workplan: GenericStorageQuery<
4373
+ Rv,
4374
+ (arg: [number, number]) => Array<PalletBrokerScheduleItem> | undefined,
4375
+ [number, number]
4376
+ >;
3850
4377
 
3851
4378
  /**
3852
4379
  * The current workload of each core. This gets updated with workplan as timeslices pass.
@@ -3854,7 +4381,7 @@ export interface ChainStorage extends GenericChainStorage {
3854
4381
  * @param {number} arg
3855
4382
  * @param {Callback<Array<PalletBrokerScheduleItem>> =} callback
3856
4383
  **/
3857
- workload: GenericStorageQuery<(arg: number) => Array<PalletBrokerScheduleItem>>;
4384
+ workload: GenericStorageQuery<Rv, (arg: number) => Array<PalletBrokerScheduleItem>, number>;
3858
4385
 
3859
4386
  /**
3860
4387
  * Record of a single contribution to the Instantaneous Coretime Pool.
@@ -3863,7 +4390,9 @@ export interface ChainStorage extends GenericChainStorage {
3863
4390
  * @param {Callback<PalletBrokerContributionRecord | undefined> =} callback
3864
4391
  **/
3865
4392
  instaPoolContribution: GenericStorageQuery<
3866
- (arg: PalletBrokerRegionId) => PalletBrokerContributionRecord | undefined
4393
+ Rv,
4394
+ (arg: PalletBrokerRegionId) => PalletBrokerContributionRecord | undefined,
4395
+ PalletBrokerRegionId
3867
4396
  >;
3868
4397
 
3869
4398
  /**
@@ -3872,7 +4401,7 @@ export interface ChainStorage extends GenericChainStorage {
3872
4401
  * @param {number} arg
3873
4402
  * @param {Callback<PalletBrokerPoolIoRecord> =} callback
3874
4403
  **/
3875
- instaPoolIo: GenericStorageQuery<(arg: number) => PalletBrokerPoolIoRecord>;
4404
+ instaPoolIo: GenericStorageQuery<Rv, (arg: number) => PalletBrokerPoolIoRecord, number>;
3876
4405
 
3877
4406
  /**
3878
4407
  * Total InstaPool rewards for each Timeslice and the number of core parts which contributed.
@@ -3880,11 +4409,112 @@ export interface ChainStorage extends GenericChainStorage {
3880
4409
  * @param {number} arg
3881
4410
  * @param {Callback<PalletBrokerInstaPoolHistoryRecord | undefined> =} callback
3882
4411
  **/
3883
- instaPoolHistory: GenericStorageQuery<(arg: number) => PalletBrokerInstaPoolHistoryRecord | undefined>;
4412
+ instaPoolHistory: GenericStorageQuery<Rv, (arg: number) => PalletBrokerInstaPoolHistoryRecord | undefined, number>;
4413
+
4414
+ /**
4415
+ * Received core count change from the relay chain.
4416
+ *
4417
+ * @param {Callback<number | undefined> =} callback
4418
+ **/
4419
+ coreCountInbox: GenericStorageQuery<Rv, () => number | undefined>;
4420
+
4421
+ /**
4422
+ * Generic pallet storage query
4423
+ **/
4424
+ [storage: string]: GenericStorageQuery<Rv>;
4425
+ };
4426
+ /**
4427
+ * Pallet `TasksExample`'s storage queries
4428
+ **/
4429
+ tasksExample: {
4430
+ /**
4431
+ * Some running total.
4432
+ *
4433
+ * @param {Callback<[number, number]> =} callback
4434
+ **/
4435
+ total: GenericStorageQuery<Rv, () => [number, number]>;
4436
+
4437
+ /**
4438
+ * Numbers to be added into the total.
4439
+ *
4440
+ * @param {number} arg
4441
+ * @param {Callback<number | undefined> =} callback
4442
+ **/
4443
+ numbers: GenericStorageQuery<Rv, (arg: number) => number | undefined, number>;
4444
+
4445
+ /**
4446
+ * Generic pallet storage query
4447
+ **/
4448
+ [storage: string]: GenericStorageQuery<Rv>;
4449
+ };
4450
+ /**
4451
+ * Pallet `Mixnet`'s storage queries
4452
+ **/
4453
+ mixnet: {
4454
+ /**
4455
+ * Index of the current session. This may be offset relative to the session index tracked by
4456
+ * eg `pallet_session`; mixnet session indices are independent.
4457
+ *
4458
+ * @param {Callback<number> =} callback
4459
+ **/
4460
+ currentSessionIndex: GenericStorageQuery<Rv, () => number>;
4461
+
4462
+ /**
4463
+ * Block in which the current session started.
4464
+ *
4465
+ * @param {Callback<number> =} callback
4466
+ **/
4467
+ currentSessionStartBlock: GenericStorageQuery<Rv, () => number>;
4468
+
4469
+ /**
4470
+ * Authority list for the next session.
4471
+ *
4472
+ * @param {number} arg
4473
+ * @param {Callback<SpMixnetAppPublic | undefined> =} callback
4474
+ **/
4475
+ nextAuthorityIds: GenericStorageQuery<Rv, (arg: number) => SpMixnetAppPublic | undefined, number>;
4476
+
4477
+ /**
4478
+ * Mixnode sets by session index. Only the mixnode sets for the previous, current, and next
4479
+ * sessions are kept; older sets are discarded.
4480
+ *
4481
+ * The mixnodes in each set are keyed by authority index so we can easily check if an
4482
+ * authority has registered a mixnode. The authority indices should only be used during
4483
+ * registration; the authority indices for the very first session are made up.
4484
+ *
4485
+ * @param {[number, number]} arg
4486
+ * @param {Callback<PalletMixnetBoundedMixnode | undefined> =} callback
4487
+ **/
4488
+ mixnodes: GenericStorageQuery<
4489
+ Rv,
4490
+ (arg: [number, number]) => PalletMixnetBoundedMixnode | undefined,
4491
+ [number, number]
4492
+ >;
4493
+
4494
+ /**
4495
+ * Generic pallet storage query
4496
+ **/
4497
+ [storage: string]: GenericStorageQuery<Rv>;
4498
+ };
4499
+ /**
4500
+ * Pallet `Parameters`'s storage queries
4501
+ **/
4502
+ parameters: {
4503
+ /**
4504
+ * Stored parameters.
4505
+ *
4506
+ * @param {KitchensinkRuntimeRuntimeParametersKey} arg
4507
+ * @param {Callback<KitchensinkRuntimeRuntimeParametersValue | undefined> =} callback
4508
+ **/
4509
+ parameters: GenericStorageQuery<
4510
+ Rv,
4511
+ (arg: KitchensinkRuntimeRuntimeParametersKey) => KitchensinkRuntimeRuntimeParametersValue | undefined,
4512
+ KitchensinkRuntimeRuntimeParametersKey
4513
+ >;
3884
4514
 
3885
4515
  /**
3886
4516
  * Generic pallet storage query
3887
4517
  **/
3888
- [storage: string]: GenericStorageQuery;
4518
+ [storage: string]: GenericStorageQuery<Rv>;
3889
4519
  };
3890
4520
  }