@pezkuwi/types 16.5.5

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

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

@@ -0,0 +1,50 @@
+// Copyright 2017-2025 @polkadot/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/substrate.spec.ts

@@ -0,0 +1,36 @@
+// Copyright 2017-2025 @polkadot/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-substrate';
+import { compactAddLength, u8aToU8a } from '@pezkuwi/util';
+
+import { TypeRegistry } from '../../../create/index.js';
+import { Metadata } from '../../Metadata.js';
+import { substrate } from './substrate.js';
+
+const registry = new TypeRegistry();
+const metadata = new Metadata(registry, metadataStatic);
+
+registry.setMetadata(metadata);
+
+// console.log(JSON.stringify(registry.lookup.types));
+
+describe('substrate', (): void => {
+  const code = substrate['code'](registry);
+
+  it('creates a well-known :code key', (): void => {
+    expect(
+      code()
+    ).toEqual(
+      compactAddLength(u8aToU8a(':code'))
+    );
+  });
+
+  it('has the correct metadata', (): void => {
+    expect(
+      code.meta.type.isPlain
+    ).toEqual(true);
+  });
+});

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

@@ -0,0 +1,56 @@
+// Copyright 2017-2025 @polkadot/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 { ManualMetadata } from './util.js';
+
+import { createRuntimeFunction } from './util.js';
+
+type Creator = (registry: Registry) => StorageEntry;
+
+const prefix = 'Substrate';
+const section = 'substrate';
+
+function createSubstrateFn (method: string, key: string, meta: ManualMetadata): Creator {
+  return createRuntimeFunction({ method, prefix, section }, key, meta);
+}
+
+export const substrate: Record<string, Creator> = {
+  changesTrieConfig: createSubstrateFn('changesTrieConfig', ':changes_trie', {
+    docs: 'Changes trie configuration is stored under this key.',
+    type: 'u32'
+  }),
+  childStorageKeyPrefix: createSubstrateFn('childStorageKeyPrefix', ':child_storage:', {
+    docs: 'Prefix of child storage keys.',
+    type: 'u32'
+  }),
+  code: createSubstrateFn('code', ':code', {
+    docs: 'Wasm code of the runtime.',
+    type: 'Bytes'
+  }),
+  defaultChildStorageKeyPrefix: createSubstrateFn('defaultChildStorageKeyPrefix', ':child_storage:default:', {
+    docs: 'Prefix of the default child storage keys in the top trie.',
+    type: 'u32'
+  }),
+  extrinsicIndex: createSubstrateFn('extrinsicIndex', ':extrinsic_index', {
+    docs: 'Current extrinsic index (u32) is stored under this key.',
+    type: 'u32'
+  }),
+  heapPages: createSubstrateFn('heapPages', ':heappages', {
+    docs: 'Number of wasm linear memory pages required for execution of the runtime.',
+    type: 'u64'
+  }),
+  intrablockEntropy: createSubstrateFn('intrablockEntropy', ':intrablock_entropy', {
+    docs: 'Current intra-block entropy (a universally unique `[u8; 32]` value) is stored here.',
+    type: '[u8; 32]'
+  }),
+  storageVersionStorageKeyPostfix: createSubstrateFn('storageVersionStorageKeyPostfix', ':__STORAGE_VERSION__:', {
+    docs: 'The storage key postfix that is used to store the [`StorageVersion`] per pallet.',
+    type: 'u16'
+  }),
+  transactionLevelKey: createSubstrateFn('transactionLevelKey', ':transaction_level:', {
+    docs: 'The key that holds the current number of active layers.',
+    type: 'u32'
+  })
+};

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

@@ -0,0 +1,101 @@
+// Copyright 2017-2025 @polkadot/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 substrate 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

@@ -0,0 +1,52 @@
+// Copyright 2017-2025 @polkadot/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, PalletConstantMetadataLatest } 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: PalletConstantMetadataLatest;
+}
+
+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

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

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

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

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

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

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

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

@@ -0,0 +1,67 @@
+// Copyright 2017-2025 @polkadot/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 getPalletNames ({ 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(getPalletNames(meta)));
+}

package/src/metadata/util/index.ts

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