@pezkuwi/types 16.5.16 → 16.5.18

package/src/bundle.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import * as typeDefinitions from './interfaces/definitions.js';
+import rpcDefinitions from './interfaces/jsonrpc.js';
+
+// all external
+export { TypeDefInfo } from '@pezkuwi/types-create';
+
+// all named
+export { convertSiV0toV1 } from './metadata/PortableRegistry/index.js';
+export { packageInfo } from './packageInfo.js';
+export { unwrapStorageType } from './util/index.js';
+
+// all starred
+export * from './codec/index.js';
+export * from './create/index.js';
+export * from './index.types.js';
+export * from './metadata/index.js';
+
+// local
+export { rpcDefinitions, typeDefinitions };

package/src/checkTypes.manual.ts

@@ -0,0 +1,101 @@
+// Copyright 2017-2025 @pezkuwi/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import '@pezkuwi/types-augment';
+
+import type { Bytes, Compact, Option, u32 } from '@pezkuwi/types-codec';
+import type { IOption, ITuple } from '@pezkuwi/types-codec/types';
+import type { AccountId, BlockAttestations, SessionKeys7 } from './interfaces/index.js';
+
+import { assert } from '@pezkuwi/util';
+
+import { TypeRegistry } from './create/index.js';
+
+const registry = new TypeRegistry();
+
+// something that uses overrides
+const oo0 = registry.createType('Something' as 'u32');
+const oo1 = registry.createType<BlockAttestations>('u32');
+const oo2 = registry.createType<SessionKeys7>('u32');
+const oo3 = registry.createType<u32>('Something');
+const oo4 = registry.createType<AccountId>('Option<u32>');
+const oo5 = registry.createType<IOption<u32>>('u32');
+const oo6 = registry.createType<Option<Compact<u32>>>('u32');
+const oo7 = registry.createType<Bytes>('u64');
+const oo8 = registry.createType<ITuple<[Bytes, u32]>>('(u32)');
+
+assert(oo0.divn(123) && [...oo1.values()] && oo2[6].isAscii && oo3.divn(3) && oo4.isAscii && oo5.unwrap().divn(1) && oo6.unwrap().unwrap().divn(1) && oo7.isAscii && oo8[1].toNumber(), 'All ok');
+
+// There are in the interface registry
+const aa0 = registry.createType(' AccountId');
+const aa1 = registry.createType('BlockAttestations');
+const aa2 = registry.createType('ExtrinsicEra');
+const aa3 = registry.createType('VestingInfo');
+const aa4 = registry.createType('(Vec<ValidatorIndex>, CompactAssignmentsTo257, PhragmenScore, EraIndex)');
+
+assert(aa0.isAscii && aa1.receipt && aa2.isMortalEra && aa3.toHuman() && aa4[3].toNumber(), 'All ok');
+
+// Should be Codec, we don't know this one
+const bb = registry.createType('Something');
+
+assert(bb.toHuman(), 'All ok');
+
+// Should be Vec<Option<Compact<ReferendumIndex>>>
+const ee = registry.createType('Vec<Option<Compact<ReferendumIndex>>>');
+// Option<Bytes>
+const vb = registry.createType('Option< Vec< u8 > >');
+// nested vecs
+const vv = registry.createType('Vec< Vec< Vec< Vec<u8>> > >');
+// vec with tuple
+const vt = registry.createType('Vec<(u8, u16)>');
+// nested stuff from all-over
+const vn = registry.createType('Vec<(u32, (u32, u64), Vec<u8>, Vec<u32>, Vec<(u32, u64)>, [u8;32], [u128;32])>');
+// nested fixed
+const nf = registry.createType('[[[u8;32];5];3]');
+// with linkage
+const tl = registry.createType('(ValidatorPrefsWithCommission, Linkage<AccountId>)');
+
+assert(ee[0].unwrap().unwrap().divn(123) && vb.unwrap().bitLength() && vv.toHuman() && vn[0][3][0].bitLength() && vt.toHuman() && nf.toHuman() && tl[1].next, 'All ok');
+
+// tuple & struct
+const vs = registry.createType('(u8, {"a":"u32","b":"(u32,u64)"},(u8,u16),{"foo":"Bar"},u16)');
+// set
+const st = registry.createType('{"_set": { "A": 1, "B": 2, "C": 4 } }');
+// enum
+const en = registry.createType('{"_enum": { "A": 1, "B": 2, "C": 4 } }');
+
+assert(vs.toHuman() && st.strings && en.index, 'All ok');
+
+// Should end up as Raw
+const gg = registry.createType('[ u8   ;678]');
+
+assert(gg.subarray(1), 'All ok');
+
+// Should end up as VecFixed<u128>
+const hh = registry.createType('[u128; 32]');
+// maps and sets
+const ms = registry.createType('(BTreeSet<u8>, BTreeMap<u16, u32>, HashMap<u64, u128>)');
+
+assert(hh[0].bitLength() && ms[0].strings && ms[1].values() && ms[2].keys, 'All ok');
+
+// tuple! ITuple<[u32, Compact<u64>, u128, Codec]>
+const tt1 = registry.createType('(u32, Compact<u64>,    u128  , Something)');
+// unwraps into a u32
+const tt2 = registry.createType('(((u32)))');
+// TEST: Adding a single param makes this go over the recursion limit in 4.4.4
+// lots and lots of params (indicates recursion limit)
+const tt4 = registry.createType('(u8,u16,u32,u64,u128,u256,u8,u16,u32,u64,u128,u256,u8,u16,u32,u64,u128,u256,u8)');
+// empty
+const tt5 = registry.createType('()');
+// nested tuples
+const tt6 = registry.createType('(u8, (u16, (u32, u64, u128)), (u64, u128))');
+// more nested tuples
+const tt7 = registry.createType('(((u8, u16, u32), (u32, u16, u8)), u128, u256)');
+// nested tuples with a wrapper
+const tt8 = registry.createType('(u8, Vec<(u16, u32)>, Option<(u128, u128)>)');
+// same example as above
+const tt9 = registry.createType('(u32, (u32, u64), Vec<u8>, Vec<(u32, u64)>, [u8;32], [u128;32])');
+// tuple with nested fixed
+const tta = registry.createType('([u8;32], [u16;5])');
+
+assert(tt1[2].bitLength() && tt2.bitLength() && tt4[3].bitLength() && tt5.isEmpty && tt6[1].toHuman() && tt7.toHuman() && tt8.toHuman() && tt9.toHuman() && tta[1][1].bitLength(), 'All ok');

package/src/codec/index.ts

@@ -0,0 +1,9 @@
+// Copyright 2017-2025 @pezkuwi/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// NOTE We are not exporting everything here. These _should_ be enough to use the
+// actual interfaces from a "create-a-working-coder" perspective. If not, we should
+// expand with slight care (for instance, Length is really only used internally to
+// others, so there _should_ not be need for direct use)
+
+export { BTreeMap, BTreeSet, CodecMap, CodecSet, Compact, DoNotConstruct, Enum, HashMap, Int, Json, Linkage, Map, Option, Range, RangeInclusive, Raw, Result, Set, Struct, Tuple, U8aFixed, UInt, Vec, VecFixed, WrapperKeepOpaque, WrapperOpaque } from '@pezkuwi/types-codec';

package/src/codec/types.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2025 @pezkuwi/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export type { U8aBitLength, UIntBitLength } from '@pezkuwi/types-codec/types';

package/src/create/createClass.spec.ts

@@ -0,0 +1,47 @@
+// Copyright 2017-2025 @pezkuwi/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { TypeDefInfo } from '@pezkuwi/types-create';
+
+import { createClass, getTypeClass, TypeRegistry } from './index.js';
+
+describe('createClass', (): void => {
+  const registry = new TypeRegistry();
+
+  it('should memoize from strings', (): void => {
+    const a = createClass(registry, 'BabeWeight');
+    const b = createClass(registry, 'BabeWeight');
+
+    expect(a).toBe(b);
+  });
+
+  it('should return equivalents for Bytes & Vec<u8>', (): void => {
+    const A = createClass(registry, 'Vec<u8>');
+    const B = createClass(registry, 'Bytes');
+
+    expect(new A(registry) instanceof B).toBe(true);
+  });
+});
+
+describe('getTypeClass', (): void => {
+  const registry = new TypeRegistry();
+
+  it('warns on invalid types', (): void => {
+    const spy = jest.spyOn(console, 'warn');
+    const typeDef = { info: TypeDefInfo.Plain, type: 'ABC' };
+
+    try {
+      getTypeClass(registry, typeDef);
+    } catch {
+      // ignore
+    }
+
+    expect(spy).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      'Unable to resolve type ABC, it will fail on construction'
+    );
+  });
+});

package/src/create/createClass.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2025 @pezkuwi/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Codec, CodecClass, Registry } from '@pezkuwi/types-codec/types';
+import type { DetectCodec } from '../types/index.js';
+
+import { createClassUnsafe } from '@pezkuwi/types-create';
+
+export function createClass<T extends Codec = Codec, K extends string = string> (registry: Registry, type: K): CodecClass<DetectCodec<T, K>> {
+  return createClassUnsafe(registry, type);
+}

package/src/create/createType.spec.ts

@@ -0,0 +1,252 @@
+// Copyright 2017-2025 @pezkuwi/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import type { CodecSet } from '@pezkuwi/types-codec';
+
+import { Int } from '@pezkuwi/types-codec';
+
+import { createClass, TypeRegistry } from './index.js';
+
+describe('createType', (): void => {
+  const registry = new TypeRegistry();
+
+  it('allows creation of a H256 (with proper toRawType)', (): void => {
+    expect(
+      registry.createType('H256').toRawType()
+    ).toEqual('H256');
+    expect(
+      registry.createType('Hash').toRawType()
+    ).toEqual('H256');
+  });
+
+  it('allows creation of a Fixed64 (with proper toRawType & instance)', (): void => {
+    const f64 = registry.createType('Fixed64');
+
+    expect(f64.toRawType()).toEqual('Fixed64');
+    expect(f64.bitLength()).toEqual(64);
+    expect(f64.isUnsigned).toBe(false);
+    expect(f64 instanceof Int).toBe(true);
+  });
+
+  it('allows creation of a Struct', (): void => {
+    const raw = '{"balance":"Balance","index":"u32"}';
+    const struct = registry.createTypeUnsafe(raw, [{
+      balance: 1234,
+      index: '0x10'
+    }]);
+
+    expect(struct.toJSON()).toEqual({
+      balance: 1234, // '0x000000000000000000000000000004d2',
+      index: 16
+    });
+    expect(struct.toRawType()).toEqual(raw);
+  });
+
+  it('allows creation of a BTreeMap', (): void => {
+    expect(
+      registry.createTypeUnsafe('BTreeMap<Text,u32>', ['0x041c62617a7a696e6745000000']).toString()
+    ).toEqual('{"bazzing":69}');
+  });
+
+  it('allows creation of a BTreeSet', (): void => {
+    expect(
+      registry.createTypeUnsafe('BTreeSet<u32>', ['0x1002000000180000001e00000050000000']).toString()
+    ).toEqual('[2,24,30,80]');
+  });
+
+  it('allows creation of a Enum (simple)', (): void => {
+    expect(
+      registry.createTypeUnsafe('{"_enum": ["A", "B", "C"]}', [1]).toJSON()
+    ).toEqual('B');
+  });
+
+  it('allows creation of a Enum (with types)', (): void => {
+    expect(
+      registry.createTypeUnsafe('{"_enum": {"A": null, "B": "u32", "C": null} }', [1]).toJSON()
+    ).toEqual({ b: 0 });
+  });
+
+  it('allows creation of a Enum (with indexes)', (): void => {
+    expect(
+      registry.createTypeUnsafe('{"_enum": {"A": 42, "B": 69, "C": 255} }', [69]).toJSON()
+    ).toEqual('B');
+  });
+
+  it('allows creation of a Result', (): void => {
+    expect(
+      registry.createTypeUnsafe('Result<u32,Text>', ['0x011064656667']).toJSON()
+    ).toEqual({ err: 'defg' });
+  });
+
+  it('allows creation of a Set', (): void => {
+    expect(
+      registry.createTypeUnsafe<CodecSet>('{"_set": { "A": 1, "B": 2, "C": 4, "D": 8, "E": 16, "G": 32, "H": 64, "I": 128 } }', [1 + 4 + 16 + 64]).strings
+    ).toEqual(['A', 'C', 'E', 'H']);
+  });
+
+  it('allows creation of a Tuple', (): void => {
+    expect(
+      registry.createTypeUnsafe('(Balance,u32)', [[1234, 5678]]).toJSON()
+    ).toEqual([
+      1234, // '0x000000000000000000000000000004d2',
+      5678
+    ]);
+  });
+
+  it('allows creation for a UInt<bitLength>', (): void => {
+    expect(
+      registry.createType('UInt<2048>').toRawType()
+    ).toEqual('u2048');
+  });
+
+  it('fails creation for a UInt<bitLength> where bitLength is not power of 8', (): void => {
+    expect(
+      () => registry.createType('UInt<20>').toRawType()
+    ).toThrow(/UInt<20>: Only support for UInt<bitLength>, where length <= 8192 and a power of 8/);
+  });
+
+  it('fails on creation of DoNotConstruct', (): void => {
+    const Clazz = createClass(registry, 'DoNotConstruct<UnknownSomething>');
+
+    expect(
+      () => new Clazz(registry)
+    ).toThrow(/Cannot construct unknown type UnknownSomething/);
+  });
+
+  it('allows creation of a [u8; 8]', (): void => {
+    expect(
+      registry.createTypeUnsafe('[u8; 8]', [[0x12, 0x00, 0x23, 0x00, 0x45, 0x00, 0x67, 0x00]]).toHex()
+    ).toEqual('0x1200230045006700');
+  });
+
+  it('allows creation of a [u16; 4]', (): void => {
+    expect(
+      registry.createTypeUnsafe('[u16; 4]', [[0x1200, 0x2300, 0x4500, 0x6700]]).toU8a()
+    ).toEqual(new Uint8Array([0x00, 0x12, 0x00, 0x23, 0x00, 0x45, 0x00, 0x67]));
+  });
+
+  describe('isPedantic', (): void => {
+    it('correctly decodes Bytes', (): void => {
+      expect(
+        registry.createTypeUnsafe('Bytes', ['0x12345678'], { isPedantic: true }).toHex()
+      ).toEqual('0x12345678');
+    });
+
+    it('correctly decodes Bytes (prefixed)', (): void => {
+      expect(
+        registry.createTypeUnsafe('Bytes', [new Uint8Array([4 << 2, 0x12, 0x34, 0x56, 0x78])], { isPedantic: true }).toHex()
+      ).toEqual('0x12345678');
+    });
+
+    it('correctly decodes Text', (): void => {
+      expect(
+        registry.createTypeUnsafe('Text', ['0x70726f7669646572'], { isPedantic: true }).toString()
+      ).toEqual('provider');
+    });
+
+    it('correctly decodes Type', (): void => {
+      expect(
+        registry.createTypeUnsafe('Type', ['0x5665633c75383e'], { isPedantic: true }).toString()
+      ).toEqual('Bytes'); // Vec<u8> -> Bytes
+    });
+
+    it('correctly decodes [u16; 4]', (): void => {
+      expect(
+        registry.createTypeUnsafe('[u16; 4]', ['0x0012002300450067'], { isPedantic: true }).toHex()
+      ).toEqual('0x0012002300450067');
+    });
+  });
+
+  describe('instanceof', (): void => {
+    it('instanceof should work (primitive type)', (): void => {
+      const value = registry.createType('Balance', 1234);
+
+      expect(value instanceof registry.createClass('Balance')).toBe(true);
+    });
+
+    it('instanceof should work (srml type)', (): void => {
+      const value = registry.createType('Gas', 1234);
+      const Gas = registry.createClass('Gas');
+
+      expect(value instanceof Gas).toBe(true);
+    });
+
+    it('instanceof should work (complex type)', (): void => {
+      registry.register({
+        TestComplex: {
+          balance: 'Balance',
+          // eslint-disable-next-line sort-keys
+          accountId: 'AccountId',
+          log: '(u64, u32)',
+          // eslint-disable-next-line sort-keys
+          fromSrml: 'Gas'
+        }
+      });
+
+      const value = registry.createType('TestComplex', {
+        accountId: '0x1234567812345678123456781234567812345678123456781234567812345678',
+        balance: 123,
+        fromSrml: 0,
+        log: [456, 789]
+      });
+
+      expect(value instanceof createClass(registry, 'TestComplex')).toBe(true);
+    });
+
+    it('allows for re-registration of a type', (): void => {
+      const balDef = registry.createType('Balance');
+
+      expect(balDef instanceof registry.createClass('Balance')).toBe(true);
+      expect(balDef.bitLength()).toEqual(128);
+
+      registry.register({ Balance: 'u32' });
+
+      const balu32 = registry.createType('Balance');
+
+      expect(balu32 instanceof registry.createClass('Balance')).toBe(true);
+      expect(balu32.bitLength()).toEqual(32);
+    });
+
+    it('allows for re-registration of a type (derived types)', (): void => {
+      registry.clearCache();
+      registry.register({
+        Balance: 'u128',
+        TestComplex: {
+          balance: 'Balance',
+          // eslint-disable-next-line sort-keys
+          accountId: 'AccountId',
+          log: '(u64, u32)',
+          // eslint-disable-next-line sort-keys
+          fromSrml: 'Gas'
+        }
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const cmpDef: any = registry.createType('TestComplex');
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
+      expect(cmpDef.balance.bitLength()).toEqual(128);
+
+      registry.clearCache();
+      registry.register({
+        Balance: 'u32',
+        TestComplex: {
+          balance: 'Balance',
+          // eslint-disable-next-line sort-keys
+          accountId: 'AccountId',
+          log: '(u64, u32)',
+          // eslint-disable-next-line sort-keys
+          fromSrml: 'Gas'
+        }
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      const cmpu32: any = registry.createType('TestComplex');
+
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
+      expect(cmpu32.balance.bitLength()).toEqual(32);
+    });
+  });
+});

package/src/create/createType.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2025 @pezkuwi/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Codec, Registry } from '@pezkuwi/types-codec/types';
+import type { DetectCodec } from '../types/index.js';
+
+import { createTypeUnsafe } from '@pezkuwi/types-create';
+
+/**
+ * Create an instance of a `type` with a given `params`.
+ * @param type - A recognizable string representing the type to create an
+ * instance from
+ * @param params - The value to instantiate the type with
+ */
+export function createType<T extends Codec = Codec, K extends string = string> (registry: Registry, type: K, ...params: unknown[]): DetectCodec<T, K> {
+  return createTypeUnsafe(registry, type, params);
+}

package/src/create/index.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2025 @pezkuwi/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// all external
+export * from '@pezkuwi/types-create/exports';
+
+// all local
+export * from './createClass.js';
+export * from './createType.js';
+export * from './lazy.js';
+export * from './registry.js';

package/src/create/lazy.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { SiLookupTypeId, SiVariant } from '../interfaces/index.js';
+import type { PortableRegistry } from '../metadata/index.js';
+
+import { lazyMethod } from '@pezkuwi/util';
+
+interface TypeHolder {
+  type: SiLookupTypeId
+}
+
+export function lazyVariants <T> (lookup: PortableRegistry, { type }: TypeHolder, getName: (v: SiVariant) => string, creator: (v: SiVariant) => T): Record<string, T> {
+  const result: Record<string, T> = {};
+  const variants = lookup.getSiType(type).def.asVariant.variants;
+
+  for (let i = 0, count = variants.length; i < count; i++) {
+    lazyMethod(result, variants[i], creator, getName, i);
+  }
+
+  return result;
+}