@pezkuwi/types 16.5.5

package/src/metadata/v9/toV10.ts

@@ -0,0 +1,62 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetadataV9, MetadataV10, ModuleMetadataV9, ModuleMetadataV10, StorageEntryMetadataV9, StorageEntryTypeV9, StorageHasherV9, StorageHasherV10 } from '../../interfaces/metadata/index.js';
+
+import { objectSpread } from '@pezkuwi/util';
+
+// migrate a storage hasher type
+// see https://github.com/paritytech/substrate/pull/4462
+/** @internal */
+function createStorageHasher (registry: Registry, hasher: StorageHasherV9): StorageHasherV10 {
+  // Blake2_128_Concat has been added at index 2, so we increment all the
+  // indexes greater than 2
+  if (hasher.toNumber() >= 2) {
+    return registry.createTypeUnsafe('StorageHasherV10', [hasher.toNumber() + 1]);
+  }
+
+  return registry.createTypeUnsafe('StorageHasherV10', [hasher]);
+}
+
+/** @internal */
+function createStorageType (registry: Registry, entryType: StorageEntryTypeV9): [any, number] {
+  if (entryType.isMap) {
+    return [objectSpread({}, entryType.asMap, {
+      hasher: createStorageHasher(registry, entryType.asMap.hasher)
+    }), 1];
+  }
+
+  if (entryType.isDoubleMap) {
+    return [objectSpread({}, entryType.asDoubleMap, {
+      hasher: createStorageHasher(registry, entryType.asDoubleMap.hasher),
+      key2Hasher: createStorageHasher(registry, entryType.asDoubleMap.key2Hasher)
+    }), 2];
+  }
+
+  return [entryType.asPlain, 0];
+}
+
+/** @internal */
+function convertModule (registry: Registry, mod: ModuleMetadataV9): ModuleMetadataV10 {
+  const storage = mod.storage.unwrapOr(null);
+
+  return registry.createTypeUnsafe('ModuleMetadataV10', [objectSpread({}, mod, {
+    storage: storage
+      ? objectSpread({}, storage, {
+        items: storage.items.map((item: StorageEntryMetadataV9): any =>
+          objectSpread({}, item, {
+            type: registry.createTypeUnsafe('StorageEntryTypeV10', createStorageType(registry, item.type))
+          })
+        )
+      })
+      : null
+  })]);
+}
+
+/** @internal */
+export function toV10 (registry: Registry, { modules }: MetadataV9): MetadataV10 {
+  return registry.createTypeUnsafe('MetadataV10', [{
+    modules: modules.map((mod) => convertModule(registry, mod))
+  }]);
+}

package/src/metadata/versions.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Use these to generate all the Meta* types below via template keys
+// NOTE: Keep from latest -> earliest, see the LATEST_VERSION 0 index
+export const KNOWN_VERSIONS = [16, 15, 14, 13, 12, 11, 10, 9] as const;
+export const LATEST_VERSION = KNOWN_VERSIONS[0];
+
+// This is part of migration. The toCallsOnly would be usede for esxtensions,
+// i.e. they need to be updated. To ensure that they are passed a known version
+// we actually set this to a known-working version
+//
+// NOTE: This would only work on compatible types, i.e. v14 & v15 comply
+export const TO_CALLS_VERSION = 14; // LATEST_VERSION;
+
+export type MetaVersionAll = typeof KNOWN_VERSIONS[number];
+export type MetaVersionAsX = `asV${MetaVersionAll}`;

package/src/mod.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index.js';

package/src/packageDetect.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+// (packageInfo imports will be kept as-is, user-editable)
+
+import { packageInfo as codecInfo } from '@pezkuwi/types-codec/packageInfo';
+import { packageInfo as createInfo } from '@pezkuwi/types-create/packageInfo';
+import { detectPackage } from '@pezkuwi/util';
+
+import { packageInfo } from './packageInfo.js';
+
+detectPackage(packageInfo, null, [codecInfo, createInfo]);

package/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+
+export const packageInfo = { name: '@pezkuwi/types', path: 'auto', type: 'auto', version: '16.5.5' };

package/src/primitive/Data.spec.ts

@@ -0,0 +1,45 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { TypeRegistry } from '../create/index.js';
+import { Data } from './index.js';
+
+const registry = new TypeRegistry();
+
+describe('Data', (): void => {
+  it('encodes a normal None', (): void => {
+    expect(
+      new Data(registry).toHex()
+    ).toEqual('0x00');
+  });
+
+  it('encodes a hashed value correctly', (): void => {
+    expect(
+      new Data(registry, { Keccak256: '0x0102030405060708091011121314151617181920212223242526272829303132' }).toHex()
+    ).toEqual('0x240102030405060708091011121314151617181920212223242526272829303132');
+  });
+
+  it('encodes a Raw value correctly', (): void => {
+    expect(
+      new Data(registry, { Raw: '0x0102030405060708' }).toHex()
+    ).toEqual('0x090102030405060708');
+  });
+
+  it('throws on a very long string (only 32 bytes)', (): void => {
+    expect(
+      () => new Data(registry, { Raw: 'this is some very long string that is added here that will fail' })
+    ).toThrow('Data.Raw values are limited to a maximum length of 32 bytes');
+  });
+
+  it('encodes a large value correctly (max 32)', (): void => {
+    expect(
+      // without the assert (and above test), add extra bytes to the end to check the encoding
+      new Data(registry, { Raw: '0x0102030405060708091011121314151617181920212223242526272829303132' }).toHex()
+    ).toEqual(
+      // first byte is 32 + 1 === 33 === 0x21
+      '0x210102030405060708091011121314151617181920212223242526272829303132'
+    );
+  });
+});

package/src/primitive/Data.ts

@@ -0,0 +1,142 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Bytes } from '@pezkuwi/types-codec';
+import type { IU8a, Registry } from '@pezkuwi/types-codec/types';
+import type { H256 } from '../interfaces/runtime/index.js';
+
+import { Enum } from '@pezkuwi/types-codec';
+import { isString, isU8a, u8aToU8a } from '@pezkuwi/util';
+
+/** @internal */
+function decodeDataU8a (registry: Registry, value: Uint8Array): [undefined | Uint8Array, number | undefined] {
+  const indicator = value[0];
+
+  if (!indicator) {
+    return [undefined, undefined];
+  } else if (indicator >= 1 && indicator <= 33) {
+    const length = indicator - 1;
+    const data = value.subarray(1, length + 1);
+
+    // in this case, we are passing a Raw back (since we have no length)
+    return [registry.createTypeUnsafe<IU8a>('Raw', [data]), 1];
+  } else if (indicator >= 34 && indicator <= 37) {
+    return [value.subarray(1, 32 + 1), indicator - 32]; // 34 becomes 2
+  }
+
+  throw new Error(`Unable to decode Data, invalid indicator byte ${indicator}`);
+}
+
+/** @internal */
+function decodeData (registry: Registry, value?: Record<string, any> | Uint8Array | Enum | string): [any, number | undefined] {
+  if (isU8a(value) || isString(value)) {
+    return decodeDataU8a(registry, u8aToU8a(value));
+  } else if (!value) {
+    return [undefined, undefined];
+  }
+
+  // assume we have an Enum or an  object input, handle this via the normal Enum decoding
+  return [value, undefined];
+}
+
+/**
+ * @name Data
+ * @description
+ * A [[Data]] container with node, raw or hashed data
+ */
+export class Data extends Enum {
+  constructor (registry: Registry, value?: Record<string, any> | Uint8Array | Enum | string) {
+    super(registry, {
+      None: 'Null', // 0
+      Raw: 'Bytes', // 1
+      // eslint-disable-next-line sort-keys
+      BlakeTwo256: 'H256', // 2
+      Sha256: 'H256', // 3
+      // eslint-disable-next-line sort-keys
+      Keccak256: 'H256', // 4
+      ShaThree256: 'H256' // 5
+    }, ...decodeData(registry, value));
+
+    if (this.isRaw && this.asRaw.length > 32) {
+      throw new Error('Data.Raw values are limited to a maximum length of 32 bytes');
+    }
+  }
+
+  public get asBlakeTwo256 (): H256 {
+    return this.value as H256;
+  }
+
+  public get asKeccak256 (): H256 {
+    return this.value as H256;
+  }
+
+  public get asRaw (): Bytes {
+    return this.value as Bytes;
+  }
+
+  public get asSha256 (): H256 {
+    return this.value as H256;
+  }
+
+  public get asShaThree256 (): H256 {
+    return this.value as H256;
+  }
+
+  public get isBlakeTwo256 (): boolean {
+    return this.index === 2;
+  }
+
+  public get isKeccak256 (): boolean {
+    return this.index === 4;
+  }
+
+  public override get isNone (): boolean {
+    return this.index === 0;
+  }
+
+  public get isRaw (): boolean {
+    return this.index === 1;
+  }
+
+  public get isSha256 (): boolean {
+    return this.index === 3;
+  }
+
+  public get isShaThree256 (): boolean {
+    return this.index === 5;
+  }
+
+  /**
+   * @description The encoded length
+   */
+  public override get encodedLength (): number {
+    return this.toU8a().length;
+  }
+
+  /**
+   * @description Encodes the value as a Uint8Array as per the SCALE specifications
+   */
+  public override toU8a (): Uint8Array {
+    if (this.index === 0) {
+      return new Uint8Array(1);
+    } else if (this.index === 1) {
+      // don't add the length, just the data
+      const data = this.value.toU8a(true);
+      const length = Math.min(data.length, 32);
+      const u8a = new Uint8Array(length + 1);
+
+      u8a.set([length + 1], 0);
+      u8a.set(data.subarray(0, length), 1);
+
+      return u8a;
+    }
+
+    // otherwise we simply have a hash
+    const u8a = new Uint8Array(33);
+
+    u8a.set([this.index + 32], 0);
+    u8a.set(this.value.toU8a(), 1);
+
+    return u8a;
+  }
+}

package/src/primitive/StorageKey.spec.ts

@@ -0,0 +1,43 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import rpcDataV11 from '@pezkuwi/types-support/metadata/v11/substrate-hex';
+
+import { TypeRegistry } from '../create/index.js';
+import { decorateStorage, Metadata } from '../metadata/index.js';
+import { StorageKey } from './index.js';
+
+describe('StorageKey', (): void => {
+  const registry = new TypeRegistry();
+
+  describe('with MetadataV11', (): void => {
+    const metadata = new Metadata(registry, rpcDataV11);
+
+    registry.setMetadata(metadata);
+
+    const query = decorateStorage(registry, metadata.asLatest, metadata.version);
+
+    it('should allow decoding of a DoubleMap key', (): void => {
+      const key = new StorageKey(registry, '0x5f3e4907f716ac89b6347d15ececedca8bde0a0ea8864605e3b68ed9cb2da01b66ccada06515787c10000000e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f');
+
+      key.setMeta(query['staking']['erasStakers'].meta);
+
+      expect(key.toHuman()).toEqual([
+        '16',
+        '5GNJqTPyNqANBkUVMN1LPPrxXnFouWXoe2wNSmmEoLctxiZY'
+      ]);
+    });
+
+    it('should allow decoding of a Map key', (): void => {
+      const key = new StorageKey(registry, '0x426e15054d267946093858132eb537f191ca57b0c4b20b29ae7e99d6201d680cc906f7710aa165d62c709012f807af8fc3f0d2abb0c51ca9a88d4ef24d1a092bf89dacf5ce63ea1d');
+
+      key.setMeta(query['society']['defenderVotes'].meta);
+
+      expect(key.toHuman()).toEqual([
+        '5D4yQHKfqCQYThhHmTfN1JEDi47uyDJc1xg9eZfAG1R7FC7J'
+      ]);
+    });
+  });
+});

package/src/primitive/StorageKey.ts

@@ -0,0 +1,251 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyJson, AnyTuple, Codec } from '@pezkuwi/types-codec/types';
+import type { AllHashers } from '../interfaces/metadata/definitions.js';
+import type { StorageEntryMetadataLatest, StorageHasher } from '../interfaces/metadata/index.js';
+import type { SiLookupTypeId } from '../interfaces/scaleInfo/index.js';
+import type { IStorageKey, Registry } from '../types/index.js';
+import type { StorageEntry } from './types.js';
+
+import { Bytes } from '@pezkuwi/types-codec';
+import { isFunction, isString, isU8a } from '@pezkuwi/util';
+
+import { getSiName } from '../metadata/util/index.js';
+import { unwrapStorageType } from '../util/index.js';
+
+interface Decoded {
+  key?: Uint8Array | string | undefined;
+  method?: string | undefined;
+  section?: string | undefined;
+}
+
+interface StorageKeyExtra {
+  method: string;
+  section: string;
+}
+
+// hasher type -> [initialHashLength, canDecodeKey]
+const HASHER_MAP: Record<keyof typeof AllHashers, [number, boolean]> = {
+  // 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?: string | Uint8Array | StorageKey | StorageEntry | [StorageEntry, unknown[]?]): Decoded {
+  if (isU8a(value) || !value || 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 (isFunction(value)) {
+    return {
+      key: value(),
+      method: value.method,
+      section: value.section
+    };
+  } else if (Array.isArray(value)) {
+    const [fn, args = []] = value;
+
+    if (!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 as string} to StorageKey`);
+}
+
+/** @internal */
+function decodeHashers <A extends AnyTuple> (registry: Registry, value: Uint8Array, hashers: [StorageHasher, SiLookupTypeId][]): A {
+  // the storage entry is xxhashAsU8a(prefix, 128) + xxhashAsU8a(method, 128), 256 bits total
+  let offset = 32;
+  const count = hashers.length;
+  const result = new Array<Codec>(count);
+
+  for (let i = 0; i < count; i++) {
+    const [hasher, type] = hashers[i];
+    const [hashLen, canDecode] = HASHER_MAP[hasher.type as 'Identity'];
+    const decoded = canDecode
+      ? registry.createTypeUnsafe(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 as A;
+}
+
+/** @internal */
+function decodeArgsFromMeta <A extends AnyTuple> (registry: Registry, value: Uint8Array, meta?: StorageEntryMetadataLatest): A {
+  if (!meta || !meta.type.isMap) {
+    return [] as unknown as A;
+  }
+
+  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: StorageKey | StorageEntry | [StorageEntry, unknown[]?]): StorageEntryMetadataLatest | undefined {
+  if (value instanceof StorageKey) {
+    return value.meta;
+  } else if (isFunction(value)) {
+    return value.meta;
+  } else if (Array.isArray(value)) {
+    const [fn] = value;
+
+    return fn.meta;
+  }
+
+  return undefined;
+}
+
+/** @internal */
+function getType (registry: Registry, value: StorageKey | StorageEntry | [StorageEntry, unknown[]?]): string {
+  if (value instanceof StorageKey) {
+    return value.outputType;
+  } else if (isFunction(value)) {
+    return unwrapStorageType(registry, value.meta.type);
+  } else if (Array.isArray(value)) {
+    const [fn] = value;
+
+    if (fn.meta) {
+      return 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.
+ */
+export class StorageKey<A extends AnyTuple = AnyTuple> extends Bytes implements IStorageKey<A> {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore This is assigned via this.decodeArgsFromMeta()
+  #args: A;
+  #meta?: StorageEntryMetadataLatest | undefined;
+  #outputType: string;
+  #method?: string | undefined;
+  #section?: string | undefined;
+
+  constructor (registry: Registry, value?: string | Uint8Array | StorageKey | StorageEntry | [StorageEntry, unknown[]?], override: Partial<StorageKeyExtra> = {}) {
+    const { key, method, section } = decodeStorageKey(value);
+
+    super(registry, key);
+
+    this.#outputType = getType(registry, value as StorageKey);
+
+    // decode the args (as applicable based on the key and the hashers, after all init)
+    this.setMeta(getMeta(value as StorageKey), override.section || section, override.method || method);
+  }
+
+  /**
+   * @description Return the decoded arguments (applicable to map with decodable values)
+   */
+  public get args (): A {
+    return this.#args;
+  }
+
+  /**
+   * @description The metadata or `undefined` when not available
+   */
+  public get meta (): StorageEntryMetadataLatest | undefined {
+    return this.#meta;
+  }
+
+  /**
+   * @description The key method or `undefined` when not specified
+   */
+  public get method (): string | undefined {
+    return this.#method;
+  }
+
+  /**
+   * @description The output type
+   */
+  public get outputType (): string {
+    return this.#outputType;
+  }
+
+  /**
+   * @description The key section or `undefined` when not specified
+   */
+  public get section (): string | undefined {
+    return this.#section;
+  }
+
+  public is (key: IStorageKey<AnyTuple>): key is IStorageKey<A> {
+    return key.section === this.section && key.method === this.method;
+  }
+
+  /**
+   * @description Sets the meta for this key
+   */
+  public setMeta (meta?: StorageEntryMetadataLatest, section?: string, method?: string): this {
+    this.#meta = meta;
+    this.#method = method || this.#method;
+    this.#section = section || this.#section;
+
+    if (meta) {
+      this.#outputType = 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
+   */
+  public override toHuman (_isExtended?: boolean, disableAscii?: boolean): AnyJson {
+    return this.#args.length
+      ? this.#args.map((a) => a.toHuman(undefined, disableAscii))
+      : super.toHuman(undefined, disableAscii);
+  }
+
+  /**
+   * @description Returns the raw type for this
+   */
+  public override toRawType (): string {
+    return 'StorageKey';
+  }
+}

package/src/primitive/index.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @summary Type definitions that are used in the system
+ */
+
+// all external
+export { BitVec, Bool, bool, Bytes, F32, f32, F64, f64, I8, i8, I16, i16, I32, i32, I64, i64, I128, i128, I256, i256, ISize, isize, Null, OptionBool, Text, Type, U8, u8, U16, u16, U32, u32, U64, u64, U128, u128, U256, u256, USize, usize } from '@pezkuwi/types-codec';
+
+// all local
+export { Data } from './Data.js';
+export { StorageKey } from './StorageKey.js';

package/src/primitive/types.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { StorageEntryMetadataLatest } from '../interfaces/metadata/index.js';
+import type { Codec, Inspect } from '../types/index.js';
+
+export interface StorageEntryIterator {
+  (...args: unknown[]): Uint8Array & Codec;
+  meta: StorageEntryMetadataLatest;
+}
+
+export interface StorageEntry {
+  (...args: unknown[]): Uint8Array;
+  iterKey?: StorageEntryIterator;
+  inspect: (...args: unknown[]) => Inspect;
+  keyPrefix: (...args: unknown[]) => Uint8Array;
+  meta: StorageEntryMetadataLatest;
+  method: string;
+  prefix: string;
+  section: string;
+  toJSON: () => any;
+}

package/src/types/augmentLookup.ts

@@ -0,0 +1,23 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import '@pezkuwi/types-create/types/lookup';
+
+import type { Vec } from '@pezkuwi/types-codec';
+import type { LookupString } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { PortableType } from '../interfaces/metadata/index.js';
+import type { SiLookupTypeId, SiType } from '../interfaces/scaleInfo/index.js';
+
+declare module '@pezkuwi/types-create/types/lookup' {
+  interface ILookup {
+    readonly names: string[];
+    readonly types: Vec<PortableType>;
+
+    getName (lookupId: SiLookupTypeId | LookupString | number): string | undefined;
+    getSiType (lookupId: SiLookupTypeId | LookupString | number): SiType;
+    getTypeDef (lookupId: SiLookupTypeId | LookupString | number): TypeDef;
+  }
+}