@pezkuwi/types 16.5.5 → 16.5.6

package/cjs/primitive/StorageKey.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageKey = void 0;
+const types_codec_1 = require("@pezkuwi/types-codec");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../metadata/util/index.js");
+const index_js_2 = require("../util/index.js");
+const HASHER_MAP = {
+    // opaque
+    Blake2_128: [16, false], // eslint-disable-line camelcase
+    Blake2_128Concat: [16, true], // eslint-disable-line camelcase
+    Blake2_256: [32, false], // eslint-disable-line camelcase
+    Identity: [0, true],
+    Twox128: [16, false],
+    Twox256: [32, false],
+    Twox64Concat: [8, true]
+};
+/** @internal */
+function decodeStorageKey(value) {
+    if ((0, util_1.isU8a)(value) || !value || (0, util_1.isString)(value)) {
+        // let Bytes handle these inputs
+        return { key: value };
+    }
+    else if (value instanceof StorageKey) {
+        return {
+            key: value,
+            method: value.method,
+            section: value.section
+        };
+    }
+    else if ((0, util_1.isFunction)(value)) {
+        return {
+            key: value(),
+            method: value.method,
+            section: value.section
+        };
+    }
+    else if (Array.isArray(value)) {
+        const [fn, args = []] = value;
+        if (!(0, util_1.isFunction)(fn)) {
+            throw new Error('Expected function input for key construction');
+        }
+        if (fn.meta && fn.meta.type.isMap) {
+            const map = fn.meta.type.asMap;
+            if (!Array.isArray(args) || args.length !== map.hashers.length) {
+                throw new Error(`Expected an array of ${map.hashers.length} values as params to a Map query`);
+            }
+        }
+        return {
+            key: fn(...args),
+            method: fn.method,
+            section: fn.section
+        };
+    }
+    throw new Error(`Unable to convert input ${value} to StorageKey`);
+}
+/** @internal */
+function decodeHashers(registry, value, hashers) {
+    // the storage entry is xxhashAsU8a(prefix, 128) + xxhashAsU8a(method, 128), 256 bits total
+    let offset = 32;
+    const count = hashers.length;
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+        const [hasher, type] = hashers[i];
+        const [hashLen, canDecode] = HASHER_MAP[hasher.type];
+        const decoded = canDecode
+            ? registry.createTypeUnsafe((0, index_js_1.getSiName)(registry.lookup, type), [value.subarray(offset + hashLen)])
+            : registry.createTypeUnsafe('Raw', [value.subarray(offset, offset + hashLen)]);
+        offset += hashLen + (canDecode ? decoded.encodedLength : 0);
+        result[i] = decoded;
+    }
+    return result;
+}
+/** @internal */
+function decodeArgsFromMeta(registry, value, meta) {
+    if (!meta || !meta.type.isMap) {
+        return [];
+    }
+    const { hashers, key } = meta.type.asMap;
+    const keys = hashers.length === 1
+        ? [key]
+        : registry.lookup.getSiType(key).def.asTuple;
+    return decodeHashers(registry, value, hashers.map((h, i) => [h, keys[i]]));
+}
+/** @internal */
+function getMeta(value) {
+    if (value instanceof StorageKey) {
+        return value.meta;
+    }
+    else if ((0, util_1.isFunction)(value)) {
+        return value.meta;
+    }
+    else if (Array.isArray(value)) {
+        const [fn] = value;
+        return fn.meta;
+    }
+    return undefined;
+}
+/** @internal */
+function getType(registry, value) {
+    if (value instanceof StorageKey) {
+        return value.outputType;
+    }
+    else if ((0, util_1.isFunction)(value)) {
+        return (0, index_js_2.unwrapStorageType)(registry, value.meta.type);
+    }
+    else if (Array.isArray(value)) {
+        const [fn] = value;
+        if (fn.meta) {
+            return (0, index_js_2.unwrapStorageType)(registry, fn.meta.type);
+        }
+    }
+    // If we have no type set, default to Raw
+    return 'Raw';
+}
+/**
+ * @name StorageKey
+ * @description
+ * A representation of a storage key (typically hashed) in the system. It can be
+ * constructed by passing in a raw key or a StorageEntry with (optional) arguments.
+ */
+class StorageKey extends types_codec_1.Bytes {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore This is assigned via this.decodeArgsFromMeta()
+    #args;
+    #meta;
+    #outputType;
+    #method;
+    #section;
+    constructor(registry, value, override = {}) {
+        const { key, method, section } = decodeStorageKey(value);
+        super(registry, key);
+        this.#outputType = getType(registry, value);
+        // decode the args (as applicable based on the key and the hashers, after all init)
+        this.setMeta(getMeta(value), override.section || section, override.method || method);
+    }
+    /**
+     * @description Return the decoded arguments (applicable to map with decodable values)
+     */
+    get args() {
+        return this.#args;
+    }
+    /**
+     * @description The metadata or `undefined` when not available
+     */
+    get meta() {
+        return this.#meta;
+    }
+    /**
+     * @description The key method or `undefined` when not specified
+     */
+    get method() {
+        return this.#method;
+    }
+    /**
+     * @description The output type
+     */
+    get outputType() {
+        return this.#outputType;
+    }
+    /**
+     * @description The key section or `undefined` when not specified
+     */
+    get section() {
+        return this.#section;
+    }
+    is(key) {
+        return key.section === this.section && key.method === this.method;
+    }
+    /**
+     * @description Sets the meta for this key
+     */
+    setMeta(meta, section, method) {
+        this.#meta = meta;
+        this.#method = method || this.#method;
+        this.#section = section || this.#section;
+        if (meta) {
+            this.#outputType = (0, index_js_2.unwrapStorageType)(this.registry, meta.type);
+        }
+        try {
+            this.#args = decodeArgsFromMeta(this.registry, this.toU8a(true), meta);
+        }
+        catch {
+            // ignore...
+        }
+        return this;
+    }
+    /**
+     * @description Returns the Human representation for this type
+     */
+    toHuman(_isExtended, disableAscii) {
+        return this.#args.length
+            ? this.#args.map((a) => a.toHuman(undefined, disableAscii))
+            : super.toHuman(undefined, disableAscii);
+    }
+    /**
+     * @description Returns the raw type for this
+     */
+    toRawType() {
+        return 'StorageKey';
+    }
+}
+exports.StorageKey = StorageKey;

package/cjs/primitive/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageKey = exports.Data = exports.usize = exports.USize = exports.u256 = exports.U256 = exports.u128 = exports.U128 = exports.u64 = exports.U64 = exports.u32 = exports.U32 = exports.u16 = exports.U16 = exports.u8 = exports.U8 = exports.Type = exports.Text = exports.OptionBool = exports.Null = exports.isize = exports.ISize = exports.i256 = exports.I256 = exports.i128 = exports.I128 = exports.i64 = exports.I64 = exports.i32 = exports.I32 = exports.i16 = exports.I16 = exports.i8 = exports.I8 = exports.f64 = exports.F64 = exports.f32 = exports.F32 = exports.Bytes = exports.bool = exports.Bool = exports.BitVec = void 0;
+/**
+ * @summary Type definitions that are used in the system
+ */
+var types_codec_1 = require("@pezkuwi/types-codec");
+Object.defineProperty(exports, "BitVec", { enumerable: true, get: function () { return types_codec_1.BitVec; } });
+Object.defineProperty(exports, "Bool", { enumerable: true, get: function () { return types_codec_1.Bool; } });
+Object.defineProperty(exports, "bool", { enumerable: true, get: function () { return types_codec_1.bool; } });
+Object.defineProperty(exports, "Bytes", { enumerable: true, get: function () { return types_codec_1.Bytes; } });
+Object.defineProperty(exports, "F32", { enumerable: true, get: function () { return types_codec_1.F32; } });
+Object.defineProperty(exports, "f32", { enumerable: true, get: function () { return types_codec_1.f32; } });
+Object.defineProperty(exports, "F64", { enumerable: true, get: function () { return types_codec_1.F64; } });
+Object.defineProperty(exports, "f64", { enumerable: true, get: function () { return types_codec_1.f64; } });
+Object.defineProperty(exports, "I8", { enumerable: true, get: function () { return types_codec_1.I8; } });
+Object.defineProperty(exports, "i8", { enumerable: true, get: function () { return types_codec_1.i8; } });
+Object.defineProperty(exports, "I16", { enumerable: true, get: function () { return types_codec_1.I16; } });
+Object.defineProperty(exports, "i16", { enumerable: true, get: function () { return types_codec_1.i16; } });
+Object.defineProperty(exports, "I32", { enumerable: true, get: function () { return types_codec_1.I32; } });
+Object.defineProperty(exports, "i32", { enumerable: true, get: function () { return types_codec_1.i32; } });
+Object.defineProperty(exports, "I64", { enumerable: true, get: function () { return types_codec_1.I64; } });
+Object.defineProperty(exports, "i64", { enumerable: true, get: function () { return types_codec_1.i64; } });
+Object.defineProperty(exports, "I128", { enumerable: true, get: function () { return types_codec_1.I128; } });
+Object.defineProperty(exports, "i128", { enumerable: true, get: function () { return types_codec_1.i128; } });
+Object.defineProperty(exports, "I256", { enumerable: true, get: function () { return types_codec_1.I256; } });
+Object.defineProperty(exports, "i256", { enumerable: true, get: function () { return types_codec_1.i256; } });
+Object.defineProperty(exports, "ISize", { enumerable: true, get: function () { return types_codec_1.ISize; } });
+Object.defineProperty(exports, "isize", { enumerable: true, get: function () { return types_codec_1.isize; } });
+Object.defineProperty(exports, "Null", { enumerable: true, get: function () { return types_codec_1.Null; } });
+Object.defineProperty(exports, "OptionBool", { enumerable: true, get: function () { return types_codec_1.OptionBool; } });
+Object.defineProperty(exports, "Text", { enumerable: true, get: function () { return types_codec_1.Text; } });
+Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return types_codec_1.Type; } });
+Object.defineProperty(exports, "U8", { enumerable: true, get: function () { return types_codec_1.U8; } });
+Object.defineProperty(exports, "u8", { enumerable: true, get: function () { return types_codec_1.u8; } });
+Object.defineProperty(exports, "U16", { enumerable: true, get: function () { return types_codec_1.U16; } });
+Object.defineProperty(exports, "u16", { enumerable: true, get: function () { return types_codec_1.u16; } });
+Object.defineProperty(exports, "U32", { enumerable: true, get: function () { return types_codec_1.U32; } });
+Object.defineProperty(exports, "u32", { enumerable: true, get: function () { return types_codec_1.u32; } });
+Object.defineProperty(exports, "U64", { enumerable: true, get: function () { return types_codec_1.U64; } });
+Object.defineProperty(exports, "u64", { enumerable: true, get: function () { return types_codec_1.u64; } });
+Object.defineProperty(exports, "U128", { enumerable: true, get: function () { return types_codec_1.U128; } });
+Object.defineProperty(exports, "u128", { enumerable: true, get: function () { return types_codec_1.u128; } });
+Object.defineProperty(exports, "U256", { enumerable: true, get: function () { return types_codec_1.U256; } });
+Object.defineProperty(exports, "u256", { enumerable: true, get: function () { return types_codec_1.u256; } });
+Object.defineProperty(exports, "USize", { enumerable: true, get: function () { return types_codec_1.USize; } });
+Object.defineProperty(exports, "usize", { enumerable: true, get: function () { return types_codec_1.usize; } });
+var Data_js_1 = require("./Data.js");
+Object.defineProperty(exports, "Data", { enumerable: true, get: function () { return Data_js_1.Data; } });
+var StorageKey_js_1 = require("./StorageKey.js");
+Object.defineProperty(exports, "StorageKey", { enumerable: true, get: function () { return StorageKey_js_1.StorageKey; } });

package/cjs/primitive/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/augmentLookup.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@pezkuwi/types-create/types/lookup");

package/cjs/types/augmentRegistry.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("@pezkuwi/types-codec/types/registry");
+require("@pezkuwi/types-create/types/augmentRegistry");

package/cjs/types/calls.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/codec.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/definitions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/detect.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/extrinsic.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("./augmentLookup.js");
+require("./augmentRegistry.js");
+tslib_1.__exportStar(require("@pezkuwi/types/types/registry"), exports);
+tslib_1.__exportStar(require("../create/types.js"), exports);
+tslib_1.__exportStar(require("./calls.js"), exports);
+tslib_1.__exportStar(require("./codec.js"), exports);
+tslib_1.__exportStar(require("./definitions.js"), exports);
+tslib_1.__exportStar(require("./detect.js"), exports);
+tslib_1.__exportStar(require("./events.js"), exports);
+tslib_1.__exportStar(require("./extrinsic.js"), exports);
+tslib_1.__exportStar(require("./interfaces.js"), exports);

package/cjs/types/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/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 Bizinikiwi 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. `{ 'Zagros 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/cjs/types/registry.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/util/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./storage.js"), exports);

package/cjs/util/storage.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapStorageSi = unwrapStorageSi;
+exports.unwrapStorageType = unwrapStorageType;
+const index_js_1 = require("../metadata/util/index.js");
+/** @internal */
+function unwrapStorageSi(type) {
+    return type.isPlain
+        ? type.asPlain
+        : type.asMap.value;
+}
+/** @internal */
+function unwrapStorageType(registry, type, isOptional) {
+    const outputType = (0, index_js_1.getSiName)(registry.lookup, unwrapStorageSi(type));
+    return isOptional
+        ? `Option<${outputType}>`
+        : outputType;
+}

package/codec/index.d.ts

@@ -0,0 +1 @@
+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/codec/index.js

@@ -0,0 +1 @@
+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/codec/types.d.ts

@@ -0,0 +1 @@
+export type { U8aBitLength, UIntBitLength } from '@pezkuwi/types-codec/types';

package/codec/types.js

@@ -0,0 +1 @@
+export {};

package/create/createClass.d.ts

@@ -0,0 +1,3 @@
+import type { Codec, CodecClass, Registry } from '@pezkuwi/types-codec/types';
+import type { DetectCodec } from '../types/index.js';
+export declare function createClass<T extends Codec = Codec, K extends string = string>(registry: Registry, type: K): CodecClass<DetectCodec<T, K>>;

package/create/createClass.js

@@ -0,0 +1,4 @@
+import { createClassUnsafe } from '@pezkuwi/types-create';
+export function createClass(registry, type) {
+    return createClassUnsafe(registry, type);
+}

package/create/createType.d.ts

@@ -0,0 +1,9 @@
+import type { Codec, Registry } from '@pezkuwi/types-codec/types';
+import type { DetectCodec } from '../types/index.js';
+/**
+ * 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 declare function createType<T extends Codec = Codec, K extends string = string>(registry: Registry, type: K, ...params: unknown[]): DetectCodec<T, K>;

package/create/createType.js

@@ -0,0 +1,10 @@
+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(registry, type, ...params) {
+    return createTypeUnsafe(registry, type, params);
+}

package/create/index.d.ts

@@ -0,0 +1,5 @@
+export * from '@pezkuwi/types-create/exports';
+export * from './createClass.js';
+export * from './createType.js';
+export * from './lazy.js';
+export * from './registry.js';

package/create/index.js

@@ -0,0 +1,5 @@
+export * from '@pezkuwi/types-create/exports';
+export * from './createClass.js';
+export * from './createType.js';
+export * from './lazy.js';
+export * from './registry.js';

package/create/lazy.d.ts

@@ -0,0 +1,7 @@
+import type { SiLookupTypeId, SiVariant } from '../interfaces/index.js';
+import type { PortableRegistry } from '../metadata/index.js';
+interface TypeHolder {
+    type: SiLookupTypeId;
+}
+export declare function lazyVariants<T>(lookup: PortableRegistry, { type }: TypeHolder, getName: (v: SiVariant) => string, creator: (v: SiVariant) => T): Record<string, T>;
+export {};

package/create/lazy.js

@@ -0,0 +1,9 @@
+import { lazyMethod } from '@pezkuwi/util';
+export function lazyVariants(lookup, { type }, getName, creator) {
+    const result = {};
+    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;
+}

package/create/registry.d.ts

@@ -0,0 +1,74 @@
+import type { AnyString, Codec, CodecClass, IU8a, LookupString } from '@pezkuwi/types-codec/types';
+import type { CreateOptions, TypeDef } from '@pezkuwi/types-create/types';
+import type { ExtDef } from '../extrinsic/signedExtensions/types.js';
+import type { ChainProperties, DispatchErrorModule, DispatchErrorModuleU8, DispatchErrorModuleU8a, Hash, MetadataLatest, SiLookupTypeId } from '../interfaces/types.js';
+import type { CallFunction, CodecHasher, DetectCodec, RegisteredTypes, Registry, RegistryError, RegistryTypes } from '../types/index.js';
+import { GenericEventData } from '../generic/Event.js';
+import { Metadata } from '../metadata/Metadata.js';
+import { PortableRegistry } from '../metadata/PortableRegistry/index.js';
+export declare class TypeRegistry implements Registry {
+    #private;
+    createdAtHash?: Hash;
+    constructor(createdAtHash?: Hash | Uint8Array | string);
+    get chainDecimals(): number[];
+    get chainIsEthereum(): boolean;
+    get chainSS58(): number | undefined;
+    get chainTokens(): string[];
+    get firstCallIndex(): Uint8Array;
+    /**
+     * @description Returns true if the type is in a Compat format
+     */
+    isLookupType(value: string): value is LookupString;
+    /**
+     * @description Creates a lookup string from the supplied id
+     */
+    createLookupType(lookupId: SiLookupTypeId | number): LookupString;
+    get knownTypes(): RegisteredTypes;
+    get lookup(): PortableRegistry;
+    get metadata(): MetadataLatest;
+    get unknownTypes(): string[];
+    get signedExtensions(): string[];
+    clearCache(): void;
+    /**
+     * @describe Creates an instance of the class
+     */
+    createClass<T extends Codec = Codec, K extends string = string>(type: K): CodecClass<DetectCodec<T, K>>;
+    /**
+     * @describe Creates an instance of the class
+     */
+    createClassUnsafe<T extends Codec = Codec, K extends string = string>(type: K): CodecClass<T>;
+    /**
+     * @description Creates an instance of a type as registered
+     */
+    createType<T extends Codec = Codec, K extends string = string>(type: K, ...params: unknown[]): DetectCodec<T, K>;
+    /**
+     * @description Creates an instance of a type as registered
+     */
+    createTypeUnsafe<T extends Codec = Codec, K extends string = string>(type: K, params: unknown[], options?: CreateOptions): T;
+    findMetaCall(callIndex: Uint8Array): CallFunction;
+    findMetaError(errorIndex: Uint8Array | DispatchErrorModule | DispatchErrorModuleU8 | DispatchErrorModuleU8a): RegistryError;
+    findMetaEvent(eventIndex: Uint8Array): CodecClass<GenericEventData>;
+    get<T extends Codec = Codec, K extends string = string>(name: K, withUnknown?: boolean, knownTypeDef?: TypeDef): CodecClass<T> | undefined;
+    getUnsafe<T extends Codec = Codec, K extends string = string>(name: K, withUnknown?: boolean, knownTypeDef?: TypeDef): CodecClass<T> | undefined;
+    getChainProperties(): ChainProperties | undefined;
+    getClassName(Type: CodecClass): string | undefined;
+    getDefinition(typeName: string): string | undefined;
+    getModuleInstances(specName: AnyString, moduleName: string): string[] | undefined;
+    getOrThrow<T extends Codec = Codec, K extends string = string, R = DetectCodec<T, K>>(name: K): CodecClass<R>;
+    getOrUnknown<T extends Codec = Codec, K extends string = string, R = DetectCodec<T, K>>(name: K): CodecClass<R>;
+    getTransactionExtensionVersion(): number;
+    getSignedExtensionExtra(): Record<string, string>;
+    getSignedExtensionTypes(): Record<string, string>;
+    hasClass(name: string): boolean;
+    hasDef(name: string): boolean;
+    hasType(name: string): boolean;
+    hash(data: Uint8Array): IU8a;
+    register(type: CodecClass | RegistryTypes): void;
+    register(name: string, type: CodecClass): void;
+    setChainProperties(properties?: ChainProperties): void;
+    setHasher(hasher?: CodecHasher | null): void;
+    setKnownTypes(knownTypes: RegisteredTypes): void;
+    setLookup(lookup: PortableRegistry): void;
+    setMetadata(metadata: Metadata, signedExtensions?: string[], userExtensions?: ExtDef, noInitWarn?: boolean): void;
+    setSignedExtensions(signedExtensions?: string[], userExtensions?: ExtDef, noInitWarn?: boolean): void;
+}