@pezkuwi/types 16.5.8 → 16.5.9

package/src/metadata/decorate/storage/getStorage.spec.ts

@@ -1,31 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import metadataStatic from '@pezkuwi/types-support/metadata/static-bizinikiwi';
-import { compactAddLength, u8aToU8a } from '@pezkuwi/util';
-
-import { TypeRegistry } from '../../../create/index.js';
-import { Metadata } from '../../Metadata.js';
-import { getStorage } from './getStorage.js';
-
-const registry = new TypeRegistry();
-const metadata = new Metadata(registry, metadataStatic);
-
-registry.setMetadata(metadata);
-
-describe('getSorage', (): void => {
-  const storage = getStorage(registry);
-
-  it('should return well known keys', (): void => {
-    expect(typeof storage['bizinikiwi']).toBe('object');
-
-    expect(storage['bizinikiwi']['code']()).toEqual(compactAddLength(u8aToU8a(':code')));
-
-    expect(storage['bizinikiwi']['changesTrieConfig']).toBeTruthy();
-    expect(storage['bizinikiwi']['childStorageKeyPrefix']).toBeTruthy();
-    expect(storage['bizinikiwi']['extrinsicIndex']).toBeTruthy();
-    expect(storage['bizinikiwi']['heapPages']).toBeTruthy();
-  });
-});

package/src/metadata/decorate/storage/getStorage.ts

@@ -1,20 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Registry } from '@pezkuwi/types-codec/types';
-import type { StorageEntry } from '../../../primitive/types.js';
-import type { Storage } from '../types.js';
-
-import { bizinikiwi } from './bizinikiwi.js';
-
-/** @internal */
-export function getStorage (registry: Registry): Storage {
-  const storage: Record<string, StorageEntry> = {};
-  const entries = Object.entries(bizinikiwi);
-
-  for (let e = 0, count = entries.length; e < count; e++) {
-    storage[entries[e][0]] = entries[e][1](registry);
-  }
-
-  return { bizinikiwi: storage };
-}

package/src/metadata/decorate/storage/index.spec.ts

@@ -1,67 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { createTestPairs } from '@pezkuwi/keyring/testingPairs';
-import rpcMetadata from '@pezkuwi/types-support/metadata/static-bizinikiwi';
-import { u8aToHex } from '@pezkuwi/util';
-import { xxhashAsHex } from '@pezkuwi/util-crypto';
-
-import { TypeRegistry } from '../../../create/index.js';
-import { Metadata } from '../../index.js';
-import { decorateStorage } from '../index.js';
-
-const keyring = createTestPairs({ type: 'ed25519' });
-
-describe('decorateStorage', (): void => {
-  const registry = new TypeRegistry();
-  const metadata = new Metadata(registry, rpcMetadata);
-
-  registry.setMetadata(metadata);
-
-  const query = decorateStorage(registry, metadata.asLatest, metadata.version);
-
-  it('should throw if the storage function expects an argument', (): void => {
-    expect(() => query['balances']['account']()).toThrow('Call to balances.account needs 1 arguments, found []');
-  });
-
-  it('should throw if the storage function expects multiple arguments', (): void => {
-    expect(() => query['staking']['erasStakers']([1])).toThrow('Call to staking.erasStakers needs 2 arguments, found [1]');
-  });
-
-  it('should throw if the storage function expects tuple arguments', (): void => {
-    expect(() => query['staking']['erasStakers'](1)).toThrow('Call to staking.erasStakers needs 2 arguments, found [1]');
-  });
-
-  it('should return a value if the storage function does not expect an argument', (): void => {
-    expect(() => query['timestamp']['now']()).not.toThrow();
-  });
-
-  it('should return a value if the storage function has the correct arguments', (): void => {
-    expect(() => query['staking']['erasStakers'](1, keyring.alice.address)).not.toThrow();
-  });
-
-  it('should return the correct length-prefixed storage key', (): void => {
-    expect(
-      u8aToHex(query['system']['account'](keyring.alice.address))
-    ).toEqual(
-      '0x' +
-      '4101' + // length
-      '26aa394eea5630e07c48ae0c9558cef7' + // System
-      'b99d880ec681799c0cf30e8886371da9' + // account
-      'de1e86a9a8c739864cf3cc5ec2bea59fd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d'
-    );
-  });
-
-  it('should decorate the palletVersion entry', (): void => {
-    expect(
-      u8aToHex(query['system']['palletVersion']())
-    ).toEqual(
-      '0x' +
-      '80' + // length
-      '26aa394eea5630e07c48ae0c9558cef7' + // System
-      xxhashAsHex(':__STORAGE_VERSION__:', 128).substring(2)
-    );
-  });
-});

package/src/metadata/decorate/storage/index.ts

@@ -1,50 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Registry } from '@pezkuwi/types-codec/types';
-import type { MetadataLatest, StorageEntryMetadataLatest } from '../../../interfaces/index.js';
-import type { Storage } from '../types.js';
-
-import { lazyMethod, lazyMethods, stringCamelCase } from '@pezkuwi/util';
-
-import { objectNameToCamel } from '../util.js';
-import { createFunction, createKeyRaw, NO_RAW_ARGS } from './createFunction.js';
-import { getStorage } from './getStorage.js';
-import { createRuntimeFunction } from './util.js';
-
-const VERSION_NAME = 'palletVersion';
-const VERSION_KEY = ':__STORAGE_VERSION__:';
-const VERSION_DOCS = { docs: 'Returns the current pallet version from storage', type: 'u16' };
-
-/** @internal */
-export function decorateStorage (registry: Registry, { pallets }: MetadataLatest, _metaVersion: number): Storage {
-  const result: Storage = getStorage(registry);
-
-  for (let i = 0, count = pallets.length; i < count; i++) {
-    const { name, storage } = pallets[i];
-
-    if (storage.isSome) {
-      const section = stringCamelCase(name);
-      const { items, prefix: _prefix } = storage.unwrap();
-      const prefix = _prefix.toString();
-
-      lazyMethod(result, section, () =>
-        lazyMethods(
-          {
-            palletVersion: createRuntimeFunction(
-              { method: VERSION_NAME, prefix, section },
-              createKeyRaw(registry, { method: VERSION_KEY, prefix: name.toString() }, NO_RAW_ARGS),
-              VERSION_DOCS
-            )(registry)
-          },
-          items,
-          (meta: StorageEntryMetadataLatest) =>
-            createFunction(registry, { meta, method: meta.name.toString(), prefix, section }, {}),
-          objectNameToCamel
-        )
-      );
-    }
-  }
-
-  return result;
-}

package/src/metadata/decorate/storage/util.ts

@@ -1,101 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { PortableType } from '../../../interfaces/index.js';
-import type { StorageEntry } from '../../../primitive/types.js';
-import type { Registry } from '../../../types/index.js';
-
-import { getTypeDef } from '@pezkuwi/types-create';
-
-import { createFunction } from './createFunction.js';
-
-export interface ManualMetadata {
-  docs: string;
-  type: string;
-}
-
-interface ManualDefinition {
-  method: string;
-  prefix: string;
-  section: string;
-}
-
-function findSiPrimitive (registry: Registry, type: string): PortableType | undefined {
-  const prim = type.toLowerCase();
-
-  return registry.lookup.types.find((t) =>
-    (
-      t.type.def.isPrimitive &&
-      t.type.def.asPrimitive.toString().toLowerCase() === prim
-    ) || (
-      t.type.def.isHistoricMetaCompat &&
-      t.type.def.asHistoricMetaCompat.toString().toLowerCase() === prim
-    )
-  );
-}
-
-function findSiType (registry: Registry, type: string): PortableType | undefined {
-  let portable = findSiPrimitive(registry, type);
-
-  // some types are either Sequence or Arrays, cater for these
-  // specifically (these all come from the base bizinikiwi known keys)
-  if (!portable && (type === 'Bytes' || type.startsWith('[u8;'))) {
-    const u8 = findSiPrimitive(registry, 'u8');
-
-    if (u8) {
-      if (type === 'Bytes') {
-        portable = registry.lookup.types.find((t) =>
-          (
-            t.type.def.isSequence &&
-            t.type.def.asSequence.type.eq(u8.id)
-          ) || (
-            t.type.def.isHistoricMetaCompat &&
-            t.type.def.asHistoricMetaCompat.eq(type)
-          )
-        );
-      } else {
-        const td = getTypeDef(type);
-
-        portable = registry.lookup.types.find((t) =>
-          (
-            t.type.def.isArray &&
-            t.type.def.asArray.eq({
-              len: td.length,
-              type: u8.id
-            })
-          ) || (
-            t.type.def.isHistoricMetaCompat &&
-            t.type.def.asHistoricMetaCompat.eq(type)
-          )
-        );
-      }
-    }
-  }
-
-  if (!portable) {
-    // Not fatal, however if this happens the storage key using this
-    // type will not return valid values, rather it will most probably
-    // be decoded incorrectly
-    console.warn(`Unable to map ${type} to a lookup index`);
-  }
-
-  return portable;
-}
-
-// Small helper function to factorize code on this page.
-/** @internal */
-export function createRuntimeFunction ({ method, prefix, section }: ManualDefinition, key: Uint8Array | string, { docs, type }: ManualMetadata): (registry: Registry) => StorageEntry {
-  return (registry: Registry): StorageEntry =>
-    createFunction(registry, {
-      meta: registry.createTypeUnsafe('StorageEntryMetadataLatest', [{
-        docs: registry.createTypeUnsafe('Vec<Text>', [[docs]]),
-        modifier: registry.createTypeUnsafe('StorageEntryModifierLatest', ['Required']),
-        name: registry.createTypeUnsafe('Text', [method]),
-        toJSON: (): any => key,
-        type: registry.createTypeUnsafe('StorageEntryTypeLatest', [{ Plain: findSiType(registry, type)?.id || 0 }])
-      }]),
-      method,
-      prefix,
-      section
-    }, { key, skipHashing: true });
-}

package/src/metadata/decorate/types.ts

@@ -1,52 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { AnyTuple, Codec, Registry } from '@pezkuwi/types-codec/types';
-import type { DispatchErrorModule, DispatchErrorModuleU8, DispatchErrorModuleU8a, ErrorMetadataLatest, EventMetadataLatest, PezpalletConstantMetadataLatest } from '../../interfaces/index.js';
-import type { StorageEntry } from '../../primitive/types.js';
-import type { CallFunction, IEvent, IEventLike } from '../../types/index.js';
-
-export interface ConstantCodec extends Codec {
-  readonly meta: PezpalletConstantMetadataLatest;
-}
-
-export interface IsError {
-  readonly meta: ErrorMetadataLatest;
-
-  is: (moduleError: DispatchErrorModule | DispatchErrorModuleU8 | DispatchErrorModuleU8a) => boolean;
-}
-
-export interface IsEvent <T extends AnyTuple, N = unknown> {
-  readonly meta: EventMetadataLatest;
-
-  is: (event: IEventLike) => event is IEvent<T, N>;
-}
-
-export type ModuleConstants = Record<string, ConstantCodec>;
-
-export type ModuleErrors = Record<string, IsError>;
-
-export type ModuleEvents = Record<string, IsEvent<AnyTuple>>;
-
-export type ModuleExtrinsics = Record<string, CallFunction>;
-
-export type ModuleStorage = Record<string, StorageEntry>
-
-export type Constants = Record<string, ModuleConstants>;
-
-export type Errors = Record<string, ModuleErrors>;
-
-export type Events = Record<string, ModuleEvents>;
-
-export type Extrinsics = Record<string, ModuleExtrinsics>
-
-export type Storage = Record<string, ModuleStorage>;
-
-export interface DecoratedMeta {
-  readonly consts: Constants;
-  readonly errors: Errors;
-  readonly events: Events;
-  readonly query: Storage;
-  readonly registry: Registry;
-  readonly tx: Extrinsics
-}

package/src/metadata/decorate/util.ts

@@ -1,20 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Text } from '@pezkuwi/types-codec';
-
-import { stringCamelCase } from '@pezkuwi/util';
-
-type Name = string | Text;
-
-interface Named {
-  name: Name;
-}
-
-function convert (fn: (n: Name) => string): (n: Named) => string {
-  return ({ name }: Named) => fn(name);
-}
-
-export const objectNameToCamel = /*#__PURE__*/ convert(stringCamelCase);
-
-export const objectNameToString = /*#__PURE__*/ convert((n) => n.toString());

package/src/metadata/index.ts

@@ -1,6 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export { decorateConstants, decorateExtrinsics, decorateStorage, expandMetadata } from './decorate/index.js';
-export { Metadata } from './Metadata.js';
-export { PortableRegistry } from './PortableRegistry/index.js';

package/src/metadata/types.ts

@@ -1,9 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Vec } from '@pezkuwi/types-codec';
-import type { Codec } from '../types/index.js';
-
-export interface MetadataInterface<Modules extends Codec> extends Codec {
-  pallets: Vec<Modules>;
-}

package/src/metadata/util/extractTypes.ts

@@ -1,64 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { TypeDef } from '@pezkuwi/types-create/types';
-
-import { getTypeDef, TypeDefInfo } from '@pezkuwi/types-create';
-
-type Extracted = string | Extracted[];
-
-function extractSubSingle (_: string, { sub }: TypeDef): Extracted[] {
-  const { lookupName, type } = sub as unknown as TypeDef;
-
-  return extractTypes([lookupName || type]);
-}
-
-function extractSubArray (_: string, { sub }: TypeDef): Extracted[] {
-  return extractTypes((sub as TypeDef[]).map(({ lookupName, type }) => lookupName || type));
-}
-
-function unhandled (type: string, { info }: TypeDef): never {
-  throw new Error(`Unhandled: Unable to create and validate type from ${type} (info=${TypeDefInfo[info]})`);
-}
-
-// we only handle the types with params here
-const mapping: Record<TypeDefInfo, (type: string, typeDef: TypeDef) => Extracted> = {
-  [TypeDefInfo.BTreeMap]: extractSubArray,
-  [TypeDefInfo.BTreeSet]: extractSubSingle,
-  [TypeDefInfo.Compact]: extractSubSingle,
-  [TypeDefInfo.DoNotConstruct]: unhandled,
-  [TypeDefInfo.Enum]: extractSubArray,
-  [TypeDefInfo.HashMap]: extractSubArray,
-  [TypeDefInfo.Int]: unhandled,
-  [TypeDefInfo.Linkage]: extractSubSingle,
-  [TypeDefInfo.Null]: unhandled,
-  [TypeDefInfo.Option]: extractSubSingle,
-  [TypeDefInfo.Plain]: (_: string, typeDef: TypeDef) => typeDef.lookupName || typeDef.type,
-  [TypeDefInfo.Range]: extractSubSingle,
-  [TypeDefInfo.RangeInclusive]: extractSubSingle,
-  [TypeDefInfo.Result]: extractSubArray,
-  [TypeDefInfo.Set]: extractSubArray,
-  [TypeDefInfo.Si]: unhandled,
-  [TypeDefInfo.Struct]: extractSubArray,
-  [TypeDefInfo.Tuple]: extractSubArray,
-  [TypeDefInfo.UInt]: unhandled,
-  [TypeDefInfo.Vec]: extractSubSingle,
-  [TypeDefInfo.VecFixed]: extractSubSingle,
-  [TypeDefInfo.WrapperKeepOpaque]: extractSubSingle,
-  [TypeDefInfo.WrapperOpaque]: extractSubSingle
-};
-
-/** @internal */
-export function extractTypes (types: string[]): Extracted[] {
-  const count = types.length;
-  const result = new Array<Extracted>(count);
-
-  for (let i = 0; i < count; i++) {
-    const type = types[i];
-    const typeDef = getTypeDef(type);
-
-    result[i] = mapping[typeDef.info](type, typeDef);
-  }
-
-  return result;
-}

package/src/metadata/util/flattenUniq.spec.ts

@@ -1,20 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { flattenUniq } from './index.js';
-
-describe('flattenUniq', (): void => {
-  it('flattens nested arrays', (): void => {
-    expect(
-      flattenUniq(['a', ['b', ['c', 'd', ['e']]], [['f', 'g']]])
-    ).toEqual(['a', 'b', 'c', 'd', 'e', 'f', 'g']);
-  });
-
-  it('flattens nested arrays, removing duplicated', (): void => {
-    expect(
-      flattenUniq(['a', 'b', ['b', ['b', 'c', 'd', ['e'], 'f', 'g']], ['c', ['f', 'g']]])
-    ).toEqual(['a', 'b', 'c', 'd', 'e', 'f', 'g']);
-  });
-});

package/src/metadata/util/flattenUniq.ts

@@ -1,19 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-type Types = string | Types[];
-
-/** @internal */
-export function flattenUniq (list: Types[], result: string[] = []): string[] {
-  for (let i = 0, count = list.length; i < count; i++) {
-    const entry = list[i];
-
-    if (Array.isArray(entry)) {
-      flattenUniq(entry, result);
-    } else {
-      result.push(entry);
-    }
-  }
-
-  return [...new Set(result)];
-}

package/src/metadata/util/getSiName.ts

@@ -1,11 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { ILookup } from '@pezkuwi/types-create/types';
-import type { SiLookupTypeId } from '../../interfaces/index.js';
-
-export function getSiName (lookup: ILookup, type: SiLookupTypeId): string {
-  const typeDef = lookup.getTypeDef(type);
-
-  return typeDef.lookupName || typeDef.type;
-}

package/src/metadata/util/getUniqTypes.ts

@@ -1,67 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Registry } from '@pezkuwi/types-codec/types';
-import type { MetadataLatest, SiLookupTypeId } from '../../interfaces/index.js';
-import type { PortableRegistry } from '../../metadata/index.js';
-
-import { flattenUniq } from './flattenUniq.js';
-import { validateTypes } from './validateTypes.js';
-
-/** @internal */
-function extractTypes (lookup: PortableRegistry, types: { type: SiLookupTypeId }[]): string[] {
-  return types.map(({ type }) =>
-    lookup.getTypeDef(type).type
-  );
-}
-
-/** @internal */
-function extractFieldTypes (lookup: PortableRegistry, type: SiLookupTypeId): string[][] {
-  return lookup.getSiType(type).def.asVariant.variants.map(({ fields }) =>
-    extractTypes(lookup, fields)
-  );
-}
-
-/** @internal */
-function getPezpalletNames ({ lookup, pallets }: MetadataLatest): string[][][] {
-  return pallets.reduce<string[][][]>((all, { calls, constants, events, storage }) => {
-    all.push([extractTypes(lookup, constants)]);
-
-    if (calls.isSome) {
-      all.push(extractFieldTypes(lookup, calls.unwrap().type));
-    }
-
-    if (events.isSome) {
-      all.push(extractFieldTypes(lookup, events.unwrap().type));
-    }
-
-    if (storage.isSome) {
-      all.push(storage.unwrap().items.map(({ type }): string[] => {
-        if (type.isPlain) {
-          return [lookup.getTypeDef(type.asPlain).type];
-        }
-
-        const { hashers, key, value } = type.asMap;
-
-        return hashers.length === 1
-          ? [
-            lookup.getTypeDef(value).type,
-            lookup.getTypeDef(key).type
-          ]
-          : [
-            lookup.getTypeDef(value).type,
-            ...lookup.getSiType(key).def.asTuple.map((t) =>
-              lookup.getTypeDef(t).type
-            )
-          ];
-      }));
-    }
-
-    return all;
-  }, []);
-}
-
-/** @internal */
-export function getUniqTypes (registry: Registry, meta: MetadataLatest, throwError: boolean): string[] {
-  return validateTypes(registry, throwError, flattenUniq(getPezpalletNames(meta)));
-}

package/src/metadata/util/index.ts

@@ -1,8 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export { flattenUniq } from './flattenUniq.js';
-export { getSiName } from './getSiName.js';
-export { getUniqTypes } from './getUniqTypes.js';
-export { toCallsOnly } from './toCallsOnly.js';
-export { validateTypes } from './validateTypes.js';