@pezkuwi/types 16.5.5

package/build/types/registry.d.ts

@@ -0,0 +1,128 @@
+import type { Observable } from 'rxjs';
+import type { BitVec, Bool, bool, Bytes, F32, f32, F64, f64, I8, i8, I16, i16, I32, i32, I64, i64, I128, i128, I256, i256, ISize, isize, Json, Null, OptionBool, Raw, Text, Type, U8, u8, U16, u16, U32, u32, U64, u64, U128, u128, U256, u256, USize, usize } from '@pezkuwi/types-codec';
+import type { RegistryTypes } from '@pezkuwi/types-codec/types';
+import type { BN } from '@pezkuwi/util';
+import type { HexString } from '@pezkuwi/util/types';
+import type { GenericExtrinsic, GenericExtrinsicEra, GenericExtrinsicPayload, GenericSignerPayload } from '../extrinsic/index.js';
+import type { ExtDef } from '../extrinsic/signedExtensions/types.js';
+import type { GenericCall } from '../generic/index.js';
+import type { HeaderPartial } from '../interfaces/runtime/index.js';
+import type { RuntimeVersionPartial } from '../interfaces/state/index.js';
+import type { Metadata, PortableRegistry } from '../metadata/index.js';
+import type { Data, StorageKey } from '../primitive/index.js';
+import type { DefinitionRpc, DefinitionRpcSub, DefinitionsCall } from './definitions.js';
+export type { Registry, RegistryError, RegistryTypes } from '@pezkuwi/types-codec/types';
+export interface InterfaceTypes {
+    BitVec: BitVec;
+    Bytes: Bytes;
+    Json: Json;
+    Null: Null;
+    OptionBool: OptionBool;
+    Raw: Raw;
+    Text: Text;
+    Type: Type;
+    Bool: Bool;
+    F32: F32;
+    F64: F64;
+    I128: I128;
+    I16: I16;
+    I256: I256;
+    I32: I32;
+    I64: I64;
+    I8: I8;
+    ISize: ISize;
+    U128: U128;
+    U16: U16;
+    U256: U256;
+    U32: U32;
+    U64: U64;
+    U8: U8;
+    USize: USize;
+    bool: bool;
+    f32: f32;
+    f64: f64;
+    i128: i128;
+    i16: i16;
+    i256: i256;
+    i32: i32;
+    i64: i64;
+    i8: i8;
+    isize: isize;
+    u128: u128;
+    u16: u16;
+    u256: u256;
+    u32: u32;
+    u64: u64;
+    u8: u8;
+    usize: usize;
+    Extrinsic: GenericExtrinsic;
+    ExtrinsicEra: GenericExtrinsicEra;
+    ExtrinsicPayload: GenericExtrinsicPayload;
+    SignerPayload: GenericSignerPayload;
+    Call: GenericCall;
+    Data: Data;
+    StorageKey: StorageKey;
+    Metadata: Metadata;
+    PortableRegistry: PortableRegistry;
+    HeaderPartial: HeaderPartial;
+    RuntimeVersionPartial: RuntimeVersionPartial;
+}
+export type CodecHasher = (data: Uint8Array) => Uint8Array;
+export interface ChainUpgradeVersion {
+    apis: [HexString, number][];
+    blockNumber: BN;
+    specVersion: BN;
+}
+export interface ChainUpgrades {
+    genesisHash: Uint8Array;
+    network: string;
+    versions: ChainUpgradeVersion[];
+}
+export interface OverrideVersionedType {
+    minmax: [number | undefined | null, number | undefined | null] | [number?, number?] | (number | undefined | null)[];
+    types: RegistryTypes;
+}
+export type OverrideModuleType = Record<string, string>;
+export type DeriveCustom = Record<string, Record<string, (instanceId: string, api: any) => (...args: any[]) => Observable<any>>>;
+export type AliasDefinition = Record<string, OverrideModuleType>;
+export interface OverrideBundleDefinition {
+    alias?: AliasDefinition;
+    derives?: DeriveCustom;
+    hasher?: (data: Uint8Array) => Uint8Array;
+    instances?: Record<string, string[]>;
+    rpc?: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>;
+    runtime?: DefinitionsCall;
+    signedExtensions?: ExtDef;
+    types?: OverrideVersionedType[];
+}
+export interface OverrideBundleType {
+    chain?: Record<string, OverrideBundleDefinition>;
+    spec?: Record<string, OverrideBundleDefinition>;
+}
+export interface RegisteredTypes {
+    /**
+     * @description Specify the actual hasher override to use in the API. This generally should be done via the typesBundle
+     */
+    hasher?: (data: Uint8Array) => Uint8Array;
+    /**
+     * @description Additional types used by runtime modules. This is necessary if the runtime modules
+     * uses types not available in the base Substrate runtime.
+     */
+    types?: RegistryTypes;
+    /**
+     * @description Alias types, as received via the metadata, to a JS-specific type to avoid conflicts. For instance, you can rename the `Proposal` in the `treasury` module to `TreasuryProposal` as to not have conflicts with the one for democracy.
+     */
+    typesAlias?: AliasDefinition;
+    /**
+     * @description A bundle of types related to chain & spec that is injected based on what the chain contains
+     */
+    typesBundle?: OverrideBundleType;
+    /**
+     * @description Additional types that are injected based on the chain we are connecting to. There are keyed by the chain, i.e. `{ 'Kusama CC1': { ... } }`
+     */
+    typesChain?: Record<string, RegistryTypes>;
+    /**
+     * @description Additional types that are injected based on the type of node we are connecting to, as set via specName in the runtime version. There are keyed by the node, i.e. `{ 'edgeware': { ... } }`
+     */
+    typesSpec?: Record<string, RegistryTypes>;
+}

package/build/util/index.d.ts

@@ -0,0 +1 @@
+export * from './storage.js';

package/build/util/storage.d.ts

@@ -0,0 +1,7 @@
+import type { StorageEntryTypeLatest } from '../interfaces/metadata/index.js';
+import type { SiLookupTypeId } from '../interfaces/scaleInfo/index.js';
+import type { InterfaceTypes, Registry } from '../types/index.js';
+/** @internal */
+export declare function unwrapStorageSi(type: StorageEntryTypeLatest): SiLookupTypeId;
+/** @internal */
+export declare function unwrapStorageType(registry: Registry, type: StorageEntryTypeLatest, isOptional?: boolean): keyof InterfaceTypes;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/pezkuwichain/pezkuwi-api/issues",
+  "description": "Implementation of the Parity codec",
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/types#readme",
+  "license": "Apache-2.0",
+  "name": "@pezkuwi/types",
+  "repository": {
+    "directory": "packages/types",
+    "type": "git",
+    "url": "https://github.com/pezkuwichain/pezkuwi-api.git"
+  },
+  "sideEffects": [
+    "./packageDetect.js",
+    "./packageDetect.cjs"
+  ],
+  "type": "module",
+  "version": "16.5.5",
+  "main": "index.js",
+  "dependencies": {
+    "@pezkuwi/keyring": "14.0.5",
+    "@pezkuwi/types-augment": "16.5.5",
+    "@pezkuwi/types-codec": "16.5.5",
+    "@pezkuwi/types-create": "16.5.5",
+    "@pezkuwi/util": "14.0.5",
+    "@pezkuwi/util-crypto": "14.0.5",
+    "rxjs": "^7.8.1",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@pezkuwi/keyring": "14.0.5",
+    "@pezkuwi/types-support": "16.5.5"
+  }
+}

package/src/bundle.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @polkadot/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 @polkadot/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 @polkadot/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 @polkadot/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 @polkadot/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 @polkadot/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 @polkadot/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 @polkadot/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 @polkadot/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';