@polkadot-api/substrate-bindings 0.1.0 → 0.3.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 (10) hide show
  1. package/dist/index.d.mts +664 -306
  2. package/dist/index.d.ts +664 -306
  3. package/dist/index.js +165 -120
  4. package/dist/index.js.map +1 -1
  5. package/dist/index.mjs +121 -84
  6. package/dist/index.mjs.map +1 -1
  7. package/dist/min/index.d.ts +664 -306
  8. package/dist/min/index.js +1 -1
  9. package/dist/min/index.js.map +1 -1
  10. package/package.json +1 -1
package/dist/index.d.mts CHANGED
@@ -65,6 +65,45 @@ declare const selfEncoder: <T>(value: () => Encoder<T>) => Encoder<T>;
65
65
  declare const selfDecoder: <T>(value: () => Decoder<T>) => Decoder<T>;
66
66
  declare const Self: <T>(value: () => Codec<T>) => Codec<T>;
67
67
 
68
+ interface Discriminant<T extends {}> {
69
+ is<K extends keyof T>(this: {
70
+ type: keyof T;
71
+ value: T[keyof T];
72
+ }, type: K): this is {
73
+ type: K;
74
+ value: T[K];
75
+ };
76
+ as<K extends keyof T>(type: K): T[K];
77
+ }
78
+ type EnumVariant<T extends {
79
+ type: string;
80
+ value?: any;
81
+ }, K extends T["type"]> = T & {
82
+ type: K;
83
+ };
84
+ type ExtractEnumValue<T extends {
85
+ type: string;
86
+ value?: any;
87
+ }, K extends string> = EnumVariant<T, K>["value"];
88
+ type ValueArg<V> = undefined extends V ? [value?: V] : [value: V];
89
+ interface EnumFn {
90
+ <T extends {
91
+ type: string;
92
+ value: any;
93
+ }, K extends T["type"]>(type: K, ...[value]: ValueArg<ExtractEnumValue<T, K>>): EnumVariant<T, K>;
94
+ }
95
+ type Enum<T extends {}> = {
96
+ [K in keyof T & string]: {
97
+ type: K;
98
+ value: T[K];
99
+ };
100
+ }[keyof T & string] & Discriminant<T>;
101
+ declare const Enum: EnumFn;
102
+ type GetEnum<T extends Enum<any>> = {
103
+ [K in T["type"]]: (...args: ExtractEnumValue<T, K> extends undefined ? [] : [value: ExtractEnumValue<T, K>]) => EnumVariant<T, K>;
104
+ };
105
+ declare const _Enum: {};
106
+
68
107
  type Tuple<T, N extends number> = readonly [T, ...T[]] & {
69
108
  length: N;
70
109
  };
@@ -73,48 +112,10 @@ type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
73
112
  type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
74
113
  type TuplifyUnion<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<TuplifyUnion<Exclude<T, L>>, L>;
75
114
  type RestrictedLenTuple<T, O extends StringRecord<any>> = Tuple<T, TuplifyUnion<keyof O> extends Tuple<any, infer V> ? V : 0>;
76
- type ExtractEnumValue<T extends {
77
- type: string;
78
- value?: any;
79
- }, K extends string> = T extends {
80
- type: K;
81
- value: infer R;
82
- } ? R : never;
83
- interface Discriminant<T extends {
84
- type: string;
85
- value?: any;
86
- }> {
87
- is<K extends T["type"]>(this: Enum<T>, type: K): this is Enum<{
88
- type: K;
89
- value: ExtractEnumValue<T, K>;
90
- }>;
91
- as<K extends T["type"]>(type: K): ExtractEnumValue<T, K>;
92
- }
93
- declare const _Enum: {};
94
- type Enum<T extends {
95
- type: string;
96
- value?: any;
97
- }> = T & Discriminant<T>;
98
- declare const Enum: <T extends {
99
- type: string;
100
- value?: any;
101
- }, Key extends T["type"]>(type: Key, ...args: ExtractEnumValue<T, Key> extends undefined ? [] : [value: ExtractEnumValue<T, Key>]) => Enum<ExtractEnumValue<T, Key> extends undefined ? T : ExtractEnumValue<T, Key> extends never ? T : {
102
- type: Key;
103
- value: ExtractEnumValue<T, Key>;
104
- }>;
105
115
  declare const Variant: {
106
- <O extends StringRecord<Codec<any>>>(inner: O, indexes?: RestrictedLenTuple<number, O> | undefined): Codec<Enum<{ [K in keyof O]: K extends string ? {
107
- type: K;
108
- value: CodecType<O[K]>;
109
- } : never; }[keyof O]>>;
110
- enc: <O_1 extends StringRecord<Encoder<any>>>(inner: O_1, x?: RestrictedLenTuple<number, O_1> | undefined) => Encoder<Enum<{ [K_1 in keyof O_1]: K_1 extends string ? {
111
- type: K_1;
112
- value: EncoderType<O_1[K_1]>;
113
- } : never; }[keyof O_1]>>;
114
- dec: <O_2 extends StringRecord<Decoder<any>>>(inner: O_2, x?: RestrictedLenTuple<number, O_2> | undefined) => Decoder<Enum<{ [K_2 in keyof O_2]: K_2 extends string ? {
115
- type: K_2;
116
- value: DecoderType<O_2[K_2]>;
117
- } : never; }[keyof O_2]>>;
116
+ <O extends StringRecord<Codec<any>>>(inner: O, indexes?: RestrictedLenTuple<number, O> | undefined): Codec<Enum<{ [K in keyof O]: CodecType<O[K]>; }>>;
117
+ enc: <O_1 extends StringRecord<Encoder<any>>>(inner: O_1, x?: RestrictedLenTuple<number, O_1> | undefined) => Encoder<Enum<{ [K_1 in keyof O_1]: EncoderType<O_1[K_1]>; }>>;
118
+ dec: <O_2 extends StringRecord<Decoder<any>>>(inner: O_2, x?: RestrictedLenTuple<number, O_2> | undefined) => Decoder<Enum<{ [K_2 in keyof O_2]: DecoderType<O_2[K_2]>; }>>;
118
119
  };
119
120
 
120
121
  declare const ethAccount: scale_ts.Codec<string>;
@@ -125,29 +126,637 @@ declare const blockHeader: Codec<{
125
126
  stateRoot: HexString;
126
127
  extrinsicRoot: HexString;
127
128
  digests: Enum<{
128
- type: "consensus";
129
- value: {
129
+ consensus: {
130
130
  engine: string;
131
131
  payload: HexString;
132
132
  };
133
- } | {
134
- type: "seal";
135
- value: {
133
+ seal: {
136
134
  engine: string;
137
135
  payload: HexString;
138
136
  };
139
- } | {
140
- type: "preRuntime";
141
- value: {
137
+ preRuntime: {
142
138
  engine: string;
143
139
  payload: HexString;
144
140
  };
145
- } | {
146
- type: "runtimeUpdated";
147
- value: undefined;
141
+ runtimeUpdated: undefined;
148
142
  }>[];
149
143
  }>;
150
- type BlockHeader = CodecType<typeof blockHeader>;
144
+ type BlockHeader = CodecType<typeof blockHeader>;
145
+
146
+ declare const metadata: Codec<{
147
+ magicNumber: number;
148
+ metadata: {
149
+ tag: "v0";
150
+ value: unknown;
151
+ } | {
152
+ tag: "v1";
153
+ value: unknown;
154
+ } | {
155
+ tag: "v2";
156
+ value: unknown;
157
+ } | {
158
+ tag: "v3";
159
+ value: unknown;
160
+ } | {
161
+ tag: "v4";
162
+ value: unknown;
163
+ } | {
164
+ tag: "v5";
165
+ value: unknown;
166
+ } | {
167
+ tag: "v6";
168
+ value: unknown;
169
+ } | {
170
+ tag: "v7";
171
+ value: unknown;
172
+ } | {
173
+ tag: "v8";
174
+ value: unknown;
175
+ } | {
176
+ tag: "v9";
177
+ value: unknown;
178
+ } | {
179
+ tag: "v10";
180
+ value: unknown;
181
+ } | {
182
+ tag: "v11";
183
+ value: unknown;
184
+ } | {
185
+ tag: "v12";
186
+ value: unknown;
187
+ } | {
188
+ tag: "v13";
189
+ value: unknown;
190
+ } | {
191
+ tag: "v14";
192
+ value: {
193
+ lookup: {
194
+ id: number;
195
+ path: string[];
196
+ params: {
197
+ name: string;
198
+ type: number | undefined;
199
+ }[];
200
+ def: {
201
+ tag: "composite";
202
+ value: {
203
+ name: string | undefined;
204
+ type: number;
205
+ typeName: string | undefined;
206
+ docs: string[];
207
+ }[];
208
+ } | {
209
+ tag: "variant";
210
+ value: {
211
+ name: string;
212
+ fields: {
213
+ name: string | undefined;
214
+ type: number;
215
+ typeName: string | undefined;
216
+ docs: string[];
217
+ }[];
218
+ index: number;
219
+ docs: string[];
220
+ }[];
221
+ } | {
222
+ tag: "sequence";
223
+ value: number;
224
+ } | {
225
+ tag: "array";
226
+ value: {
227
+ len: number;
228
+ type: number;
229
+ };
230
+ } | {
231
+ tag: "tuple";
232
+ value: number[];
233
+ } | {
234
+ tag: "primitive";
235
+ value: {
236
+ tag: "bool";
237
+ value: undefined;
238
+ } | {
239
+ tag: "char";
240
+ value: undefined;
241
+ } | {
242
+ tag: "str";
243
+ value: undefined;
244
+ } | {
245
+ tag: "u8";
246
+ value: undefined;
247
+ } | {
248
+ tag: "u16";
249
+ value: undefined;
250
+ } | {
251
+ tag: "u32";
252
+ value: undefined;
253
+ } | {
254
+ tag: "u64";
255
+ value: undefined;
256
+ } | {
257
+ tag: "u128";
258
+ value: undefined;
259
+ } | {
260
+ tag: "u256";
261
+ value: undefined;
262
+ } | {
263
+ tag: "i8";
264
+ value: undefined;
265
+ } | {
266
+ tag: "i16";
267
+ value: undefined;
268
+ } | {
269
+ tag: "i32";
270
+ value: undefined;
271
+ } | {
272
+ tag: "i64";
273
+ value: undefined;
274
+ } | {
275
+ tag: "i128";
276
+ value: undefined;
277
+ } | {
278
+ tag: "i256";
279
+ value: undefined;
280
+ };
281
+ } | {
282
+ tag: "compact";
283
+ value: number;
284
+ } | {
285
+ tag: "bitSequence";
286
+ value: {
287
+ bitStoreType: number;
288
+ bitOrderType: number;
289
+ };
290
+ };
291
+ docs: string[];
292
+ }[];
293
+ pallets: {
294
+ docs: string[];
295
+ name: string;
296
+ storage: {
297
+ prefix: string;
298
+ items: {
299
+ name: string;
300
+ modifier: number;
301
+ type: {
302
+ tag: "map";
303
+ value: {
304
+ hashers: ({
305
+ tag: "Blake2128";
306
+ value: undefined;
307
+ } | {
308
+ tag: "Blake2256";
309
+ value: undefined;
310
+ } | {
311
+ tag: "Blake2128Concat";
312
+ value: undefined;
313
+ } | {
314
+ tag: "Twox128";
315
+ value: undefined;
316
+ } | {
317
+ tag: "Twox256";
318
+ value: undefined;
319
+ } | {
320
+ tag: "Twox64Concat";
321
+ value: undefined;
322
+ } | {
323
+ tag: "Identity";
324
+ value: undefined;
325
+ })[];
326
+ key: number;
327
+ value: number;
328
+ };
329
+ } | {
330
+ tag: "plain";
331
+ value: number;
332
+ };
333
+ fallback: HexString;
334
+ docs: string[];
335
+ }[];
336
+ } | undefined;
337
+ calls: number | undefined;
338
+ events: number | undefined;
339
+ constants: {
340
+ name: string;
341
+ type: number;
342
+ value: HexString;
343
+ docs: string[];
344
+ }[];
345
+ errors: number | undefined;
346
+ index: number;
347
+ }[];
348
+ extrinsic: {
349
+ type: number;
350
+ version: number;
351
+ signedExtensions: {
352
+ identifier: string;
353
+ type: number;
354
+ additionalSigned: number;
355
+ }[];
356
+ };
357
+ type: number;
358
+ apis: {
359
+ name: string;
360
+ methods: {
361
+ name: string;
362
+ inputs: {
363
+ name: string;
364
+ type: number;
365
+ }[];
366
+ output: number;
367
+ docs: string[];
368
+ }[];
369
+ docs: string[];
370
+ }[];
371
+ };
372
+ } | {
373
+ tag: "v15";
374
+ value: {
375
+ lookup: {
376
+ id: number;
377
+ path: string[];
378
+ params: {
379
+ name: string;
380
+ type: number | undefined;
381
+ }[];
382
+ def: {
383
+ tag: "composite";
384
+ value: {
385
+ name: string | undefined;
386
+ type: number;
387
+ typeName: string | undefined;
388
+ docs: string[];
389
+ }[];
390
+ } | {
391
+ tag: "variant";
392
+ value: {
393
+ name: string;
394
+ fields: {
395
+ name: string | undefined;
396
+ type: number;
397
+ typeName: string | undefined;
398
+ docs: string[];
399
+ }[];
400
+ index: number;
401
+ docs: string[];
402
+ }[];
403
+ } | {
404
+ tag: "sequence";
405
+ value: number;
406
+ } | {
407
+ tag: "array";
408
+ value: {
409
+ len: number;
410
+ type: number;
411
+ };
412
+ } | {
413
+ tag: "tuple";
414
+ value: number[];
415
+ } | {
416
+ tag: "primitive";
417
+ value: {
418
+ tag: "bool";
419
+ value: undefined;
420
+ } | {
421
+ tag: "char";
422
+ value: undefined;
423
+ } | {
424
+ tag: "str";
425
+ value: undefined;
426
+ } | {
427
+ tag: "u8";
428
+ value: undefined;
429
+ } | {
430
+ tag: "u16";
431
+ value: undefined;
432
+ } | {
433
+ tag: "u32";
434
+ value: undefined;
435
+ } | {
436
+ tag: "u64";
437
+ value: undefined;
438
+ } | {
439
+ tag: "u128";
440
+ value: undefined;
441
+ } | {
442
+ tag: "u256";
443
+ value: undefined;
444
+ } | {
445
+ tag: "i8";
446
+ value: undefined;
447
+ } | {
448
+ tag: "i16";
449
+ value: undefined;
450
+ } | {
451
+ tag: "i32";
452
+ value: undefined;
453
+ } | {
454
+ tag: "i64";
455
+ value: undefined;
456
+ } | {
457
+ tag: "i128";
458
+ value: undefined;
459
+ } | {
460
+ tag: "i256";
461
+ value: undefined;
462
+ };
463
+ } | {
464
+ tag: "compact";
465
+ value: number;
466
+ } | {
467
+ tag: "bitSequence";
468
+ value: {
469
+ bitStoreType: number;
470
+ bitOrderType: number;
471
+ };
472
+ };
473
+ docs: string[];
474
+ }[];
475
+ pallets: {
476
+ docs: string[];
477
+ name: string;
478
+ storage: {
479
+ prefix: string;
480
+ items: {
481
+ name: string;
482
+ modifier: number;
483
+ type: {
484
+ tag: "map";
485
+ value: {
486
+ hashers: ({
487
+ tag: "Blake2128";
488
+ value: undefined;
489
+ } | {
490
+ tag: "Blake2256";
491
+ value: undefined;
492
+ } | {
493
+ tag: "Blake2128Concat";
494
+ value: undefined;
495
+ } | {
496
+ tag: "Twox128";
497
+ value: undefined;
498
+ } | {
499
+ tag: "Twox256";
500
+ value: undefined;
501
+ } | {
502
+ tag: "Twox64Concat";
503
+ value: undefined;
504
+ } | {
505
+ tag: "Identity";
506
+ value: undefined;
507
+ })[];
508
+ key: number;
509
+ value: number;
510
+ };
511
+ } | {
512
+ tag: "plain";
513
+ value: number;
514
+ };
515
+ fallback: HexString;
516
+ docs: string[];
517
+ }[];
518
+ } | undefined;
519
+ calls: number | undefined;
520
+ events: number | undefined;
521
+ constants: {
522
+ name: string;
523
+ type: number;
524
+ value: HexString;
525
+ docs: string[];
526
+ }[];
527
+ errors: number | undefined;
528
+ index: number;
529
+ }[];
530
+ extrinsic: {
531
+ version: number;
532
+ address: number;
533
+ call: number;
534
+ signature: number;
535
+ extra: number;
536
+ signedExtensions: {
537
+ identifier: string;
538
+ type: number;
539
+ additionalSigned: number;
540
+ }[];
541
+ };
542
+ type: number;
543
+ apis: {
544
+ name: string;
545
+ methods: {
546
+ name: string;
547
+ inputs: {
548
+ name: string;
549
+ type: number;
550
+ }[];
551
+ output: number;
552
+ docs: string[];
553
+ }[];
554
+ docs: string[];
555
+ }[];
556
+ outerEnums: {
557
+ call: number;
558
+ event: number;
559
+ error: number;
560
+ };
561
+ custom: [string, {
562
+ type: number;
563
+ value: HexString;
564
+ }][];
565
+ };
566
+ };
567
+ }>;
568
+
569
+ declare const extrinsic$1: scale_ts.Codec<{
570
+ type: number;
571
+ version: number;
572
+ signedExtensions: {
573
+ identifier: string;
574
+ type: number;
575
+ additionalSigned: number;
576
+ }[];
577
+ }>;
578
+ type V14Extrinsic = CodecType<typeof extrinsic$1>;
579
+ declare const v14: scale_ts.Codec<{
580
+ lookup: {
581
+ id: number;
582
+ path: string[];
583
+ params: {
584
+ name: string;
585
+ type: number | undefined;
586
+ }[];
587
+ def: {
588
+ tag: "composite";
589
+ value: {
590
+ name: string | undefined;
591
+ type: number;
592
+ typeName: string | undefined;
593
+ docs: string[];
594
+ }[];
595
+ } | {
596
+ tag: "variant";
597
+ value: {
598
+ name: string;
599
+ fields: {
600
+ name: string | undefined;
601
+ type: number;
602
+ typeName: string | undefined;
603
+ docs: string[];
604
+ }[];
605
+ index: number;
606
+ docs: string[];
607
+ }[];
608
+ } | {
609
+ tag: "sequence";
610
+ value: number;
611
+ } | {
612
+ tag: "array";
613
+ value: {
614
+ len: number;
615
+ type: number;
616
+ };
617
+ } | {
618
+ tag: "tuple";
619
+ value: number[];
620
+ } | {
621
+ tag: "primitive";
622
+ value: {
623
+ tag: "bool";
624
+ value: undefined;
625
+ } | {
626
+ tag: "char";
627
+ value: undefined;
628
+ } | {
629
+ tag: "str";
630
+ value: undefined;
631
+ } | {
632
+ tag: "u8";
633
+ value: undefined;
634
+ } | {
635
+ tag: "u16";
636
+ value: undefined;
637
+ } | {
638
+ tag: "u32";
639
+ value: undefined;
640
+ } | {
641
+ tag: "u64";
642
+ value: undefined;
643
+ } | {
644
+ tag: "u128";
645
+ value: undefined;
646
+ } | {
647
+ tag: "u256";
648
+ value: undefined;
649
+ } | {
650
+ tag: "i8";
651
+ value: undefined;
652
+ } | {
653
+ tag: "i16";
654
+ value: undefined;
655
+ } | {
656
+ tag: "i32";
657
+ value: undefined;
658
+ } | {
659
+ tag: "i64";
660
+ value: undefined;
661
+ } | {
662
+ tag: "i128";
663
+ value: undefined;
664
+ } | {
665
+ tag: "i256";
666
+ value: undefined;
667
+ };
668
+ } | {
669
+ tag: "compact";
670
+ value: number;
671
+ } | {
672
+ tag: "bitSequence";
673
+ value: {
674
+ bitStoreType: number;
675
+ bitOrderType: number;
676
+ };
677
+ };
678
+ docs: string[];
679
+ }[];
680
+ pallets: {
681
+ docs: string[];
682
+ name: string;
683
+ storage: {
684
+ prefix: string;
685
+ items: {
686
+ name: string;
687
+ modifier: number;
688
+ type: {
689
+ tag: "map";
690
+ value: {
691
+ hashers: ({
692
+ tag: "Blake2128";
693
+ value: undefined;
694
+ } | {
695
+ tag: "Blake2256";
696
+ value: undefined;
697
+ } | {
698
+ tag: "Blake2128Concat";
699
+ value: undefined;
700
+ } | {
701
+ tag: "Twox128";
702
+ value: undefined;
703
+ } | {
704
+ tag: "Twox256";
705
+ value: undefined;
706
+ } | {
707
+ tag: "Twox64Concat";
708
+ value: undefined;
709
+ } | {
710
+ tag: "Identity";
711
+ value: undefined;
712
+ })[];
713
+ key: number;
714
+ value: number;
715
+ };
716
+ } | {
717
+ tag: "plain";
718
+ value: number;
719
+ };
720
+ fallback: HexString;
721
+ docs: string[];
722
+ }[];
723
+ } | undefined;
724
+ calls: number | undefined;
725
+ events: number | undefined;
726
+ constants: {
727
+ name: string;
728
+ type: number;
729
+ value: HexString;
730
+ docs: string[];
731
+ }[];
732
+ errors: number | undefined;
733
+ index: number;
734
+ }[];
735
+ extrinsic: {
736
+ type: number;
737
+ version: number;
738
+ signedExtensions: {
739
+ identifier: string;
740
+ type: number;
741
+ additionalSigned: number;
742
+ }[];
743
+ };
744
+ type: number;
745
+ apis: {
746
+ name: string;
747
+ methods: {
748
+ name: string;
749
+ inputs: {
750
+ name: string;
751
+ type: number;
752
+ }[];
753
+ output: number;
754
+ docs: string[];
755
+ }[];
756
+ docs: string[];
757
+ }[];
758
+ }>;
759
+ type V14 = CodecType<typeof v14>;
151
760
 
152
761
  declare const lookup: scale_ts.Codec<{
153
762
  id: number;
@@ -366,6 +975,7 @@ declare const v15: scale_ts.Codec<{
366
975
  docs: string[];
367
976
  }[];
368
977
  pallets: {
978
+ docs: string[];
369
979
  name: string;
370
980
  storage: {
371
981
  prefix: string;
@@ -418,7 +1028,6 @@ declare const v15: scale_ts.Codec<{
418
1028
  }[];
419
1029
  errors: number | undefined;
420
1030
  index: number;
421
- docs: string[];
422
1031
  }[];
423
1032
  extrinsic: {
424
1033
  version: number;
@@ -458,250 +1067,6 @@ declare const v15: scale_ts.Codec<{
458
1067
  }>;
459
1068
  type V15 = CodecType<typeof v15>;
460
1069
 
461
- declare const metadata: Codec<{
462
- magicNumber: number;
463
- metadata: {
464
- tag: "v0";
465
- value: unknown;
466
- } | {
467
- tag: "v1";
468
- value: unknown;
469
- } | {
470
- tag: "v2";
471
- value: unknown;
472
- } | {
473
- tag: "v3";
474
- value: unknown;
475
- } | {
476
- tag: "v4";
477
- value: unknown;
478
- } | {
479
- tag: "v5";
480
- value: unknown;
481
- } | {
482
- tag: "v6";
483
- value: unknown;
484
- } | {
485
- tag: "v7";
486
- value: unknown;
487
- } | {
488
- tag: "v8";
489
- value: unknown;
490
- } | {
491
- tag: "v9";
492
- value: unknown;
493
- } | {
494
- tag: "v10";
495
- value: unknown;
496
- } | {
497
- tag: "v11";
498
- value: unknown;
499
- } | {
500
- tag: "v12";
501
- value: unknown;
502
- } | {
503
- tag: "v13";
504
- value: unknown;
505
- } | {
506
- tag: "v14";
507
- value: unknown;
508
- } | {
509
- tag: "v15";
510
- value: {
511
- lookup: {
512
- id: number;
513
- path: string[];
514
- params: {
515
- name: string;
516
- type: number | undefined;
517
- }[];
518
- def: {
519
- tag: "composite";
520
- value: {
521
- name: string | undefined;
522
- type: number;
523
- typeName: string | undefined;
524
- docs: string[];
525
- }[];
526
- } | {
527
- tag: "variant";
528
- value: {
529
- name: string;
530
- fields: {
531
- name: string | undefined;
532
- type: number;
533
- typeName: string | undefined;
534
- docs: string[];
535
- }[];
536
- index: number;
537
- docs: string[];
538
- }[];
539
- } | {
540
- tag: "sequence";
541
- value: number;
542
- } | {
543
- tag: "array";
544
- value: {
545
- len: number;
546
- type: number;
547
- };
548
- } | {
549
- tag: "tuple";
550
- value: number[];
551
- } | {
552
- tag: "primitive";
553
- value: {
554
- tag: "bool";
555
- value: undefined;
556
- } | {
557
- tag: "char";
558
- value: undefined;
559
- } | {
560
- tag: "str";
561
- value: undefined;
562
- } | {
563
- tag: "u8";
564
- value: undefined;
565
- } | {
566
- tag: "u16";
567
- value: undefined;
568
- } | {
569
- tag: "u32";
570
- value: undefined;
571
- } | {
572
- tag: "u64";
573
- value: undefined;
574
- } | {
575
- tag: "u128";
576
- value: undefined;
577
- } | {
578
- tag: "u256";
579
- value: undefined;
580
- } | {
581
- tag: "i8";
582
- value: undefined;
583
- } | {
584
- tag: "i16";
585
- value: undefined;
586
- } | {
587
- tag: "i32";
588
- value: undefined;
589
- } | {
590
- tag: "i64";
591
- value: undefined;
592
- } | {
593
- tag: "i128";
594
- value: undefined;
595
- } | {
596
- tag: "i256";
597
- value: undefined;
598
- };
599
- } | {
600
- tag: "compact";
601
- value: number;
602
- } | {
603
- tag: "bitSequence";
604
- value: {
605
- bitStoreType: number;
606
- bitOrderType: number;
607
- };
608
- };
609
- docs: string[];
610
- }[];
611
- pallets: {
612
- name: string;
613
- storage: {
614
- prefix: string;
615
- items: {
616
- name: string;
617
- modifier: number;
618
- type: {
619
- tag: "map";
620
- value: {
621
- hashers: ({
622
- tag: "Blake2128";
623
- value: undefined;
624
- } | {
625
- tag: "Blake2256";
626
- value: undefined;
627
- } | {
628
- tag: "Blake2128Concat";
629
- value: undefined;
630
- } | {
631
- tag: "Twox128";
632
- value: undefined;
633
- } | {
634
- tag: "Twox256";
635
- value: undefined;
636
- } | {
637
- tag: "Twox64Concat";
638
- value: undefined;
639
- } | {
640
- tag: "Identity";
641
- value: undefined;
642
- })[];
643
- key: number;
644
- value: number;
645
- };
646
- } | {
647
- tag: "plain";
648
- value: number;
649
- };
650
- fallback: HexString;
651
- docs: string[];
652
- }[];
653
- } | undefined;
654
- calls: number | undefined;
655
- events: number | undefined;
656
- constants: {
657
- name: string;
658
- type: number;
659
- value: HexString;
660
- docs: string[];
661
- }[];
662
- errors: number | undefined;
663
- index: number;
664
- docs: string[];
665
- }[];
666
- extrinsic: {
667
- version: number;
668
- address: number;
669
- call: number;
670
- signature: number;
671
- extra: number;
672
- signedExtensions: {
673
- identifier: string;
674
- type: number;
675
- additionalSigned: number;
676
- }[];
677
- };
678
- type: number;
679
- apis: {
680
- name: string;
681
- methods: {
682
- name: string;
683
- inputs: {
684
- name: string;
685
- type: number;
686
- }[];
687
- output: number;
688
- docs: string[];
689
- }[];
690
- docs: string[];
691
- }[];
692
- outerEnums: {
693
- call: number;
694
- event: number;
695
- error: number;
696
- };
697
- custom: [string, {
698
- type: number;
699
- value: HexString;
700
- }][];
701
- };
702
- };
703
- }>;
704
-
705
1070
  declare const Blake2256: (encoded: Uint8Array) => Uint8Array;
706
1071
  declare const Blake2128: (encoded: Uint8Array) => Uint8Array;
707
1072
  declare const Blake2128Concat: (encoded: Uint8Array) => Uint8Array;
@@ -778,11 +1143,4 @@ type EventsFromDescriptors<T extends Descriptors> = ExtractPlain<PickDescriptors
778
1143
  type ErrorsFromDescriptors<T extends Descriptors> = ExtractPlain<PickDescriptors<3, T["pallets"]>>;
779
1144
  type ConstFromDescriptors<T extends Descriptors> = ExtractPlain<PickDescriptors<4, T["pallets"]>>;
780
1145
 
781
- type GetEnum<T extends Enum<{
782
- type: string;
783
- value: any;
784
- }>> = {
785
- [K in T["type"]]: (...args: ExtractEnumValue<T, K> extends undefined ? [] : [value: ExtractEnumValue<T, K>]) => T;
786
- };
787
-
788
- export { AccountId, type AssetDescriptor, Bin, Binary, type BitSequence, Blake2128, Blake2128Concat, Blake2256, type BlockHeader, type ConstFromDescriptors, type Descriptors, type Discriminant, type EncoderWithHash, Enum, type ErrorsFromDescriptors, type EventsFromDescriptors, type ExtractEnumValue, FixedSizeBinary, type GetEnum, Hex, type HexString, Identity, type PlainDescriptor, type QueryFromDescriptors, type RuntimeDescriptor, type SS58AddressInfo, type SS58String, Self, Storage, type StorageDescriptor, Twox128, Twox256, Twox64Concat, type TxDescriptor, type TxFromDescriptors, type V14Lookup, type V15, type V15Extrinsic, Variant, _Enum, bitSequence, blockHeader, char, compactBn, compactNumber, ethAccount, fixedStr, fromBufferToBase58, getSs58AddressInfo, h64, metadata, selfDecoder, selfEncoder, v15 };
1146
+ export { AccountId, type AssetDescriptor, Bin, Binary, type BitSequence, Blake2128, Blake2128Concat, Blake2256, type BlockHeader, type ConstFromDescriptors, type Descriptors, type Discriminant, type EncoderWithHash, Enum, type EnumVariant, type ErrorsFromDescriptors, type EventsFromDescriptors, type ExtractEnumValue, FixedSizeBinary, type GetEnum, Hex, type HexString, Identity, type PlainDescriptor, type QueryFromDescriptors, type RuntimeDescriptor, type SS58AddressInfo, type SS58String, Self, Storage, type StorageDescriptor, Twox128, Twox256, Twox64Concat, type TxDescriptor, type TxFromDescriptors, type V14, type V14Extrinsic, type V14Lookup, type V15, type V15Extrinsic, Variant, _Enum, bitSequence, blockHeader, char, compactBn, compactNumber, ethAccount, fixedStr, fromBufferToBase58, getSs58AddressInfo, h64, metadata, selfDecoder, selfEncoder, v14, v15 };