@pezkuwi/types 16.5.5

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

@@ -0,0 +1,57 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { u32 } from '@pezkuwi/types-codec';
+import json from '@pezkuwi/types-support/metadata/static-substrate';
+import { u8aToHex } from '@pezkuwi/util';
+
+import { TypeRegistry } from '../../create/index.js';
+import { Metadata } from '../Metadata.js';
+import { decorateConstants, decorateExtrinsics, decorateStorage } from './index.js';
+
+const registry = new TypeRegistry();
+const metadata = new Metadata(registry, json);
+
+registry.setMetadata(metadata);
+
+describe('Decorated', () => {
+  it('should correctly get Alice\'s nonce storage key (u8a)', (): void => {
+    const query = decorateStorage(registry, metadata.asLatest, metadata.version);
+
+    expect(
+      u8aToHex(
+        query['system']['account']('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY')
+      )
+    ).toEqual(
+      '0x410126aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9de1e86a9a8c739864cf3cc5ec2bea59fd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d'
+    );
+  });
+
+  it('should return properly-encoded transactions', (): void => {
+    const tx = decorateExtrinsics(registry, metadata.asLatest, metadata.version);
+
+    expect(
+      registry.createType('Extrinsic', tx['timestamp']['set'](63)).toU8a()
+    ).toEqual(
+      new Uint8Array([
+        // length (encoded)
+        4 << 2,
+        // version, no signature
+        4,
+        // index
+        3, 0,
+        // values, Compact<Moment>
+        63 << 2
+      ])
+    );
+  });
+
+  it('should return constants with the correct type and value', (): void => {
+    const consts = decorateConstants(registry, metadata.asLatest, metadata.version);
+
+    expect(consts['democracy']['cooloffPeriod']).toBeInstanceOf(u32); // BlockNumber
+    expect(consts['democracy']['cooloffPeriod'].toHex()).toEqual('0x000c4e00');
+  });
+});

package/src/metadata/decorate/index.ts

@@ -0,0 +1,35 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { DecoratedMeta } from './types.js';
+
+import { Metadata } from '../Metadata.js';
+import { decorateConstants } from './constants/index.js';
+import { decorateErrors } from './errors/index.js';
+import { decorateEvents, filterEventsSome } from './events/index.js';
+import { decorateExtrinsics, filterCallsSome } from './extrinsics/index.js';
+import { decorateStorage } from './storage/index.js';
+
+/**
+ * Expands the metadata by decoration into consts, query and tx sections
+ */
+export function expandMetadata (registry: Registry, metadata: Metadata): DecoratedMeta {
+  if (!(metadata instanceof Metadata)) {
+    throw new Error('You need to pass a valid Metadata instance to Decorated');
+  }
+
+  const latest = metadata.asLatest;
+  const version = metadata.version;
+
+  return {
+    consts: decorateConstants(registry, latest, version),
+    errors: decorateErrors(registry, latest, version),
+    events: decorateEvents(registry, latest, version),
+    query: decorateStorage(registry, latest, version),
+    registry,
+    tx: decorateExtrinsics(registry, latest, version)
+  };
+}
+
+export { decorateConstants, decorateErrors, decorateEvents, decorateExtrinsics, decorateStorage, filterCallsSome, filterEventsSome };

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

@@ -0,0 +1,179 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { u8aToHex } from '@pezkuwi/util';
+
+import { TypeRegistry } from '../../../create/index.js';
+import { Metadata } from '../../Metadata.js';
+import { createFunction } from './createFunction.js';
+
+describe('createFunction', (): void => {
+  const registry = new TypeRegistry();
+  const metadata = new Metadata(registry, {
+    magicNumber: 1635018093,
+    metadata: {
+      v14: {
+        lookup: {
+          types: [
+            {
+              id: 0,
+              type: {
+                def: { HistoricMetaCompat: 'AccountId' }
+              }
+            },
+            {
+              id: 1,
+              type: {
+                def: { HistoricMetaCompat: 'Bytes' }
+              }
+            },
+            {
+              id: 2,
+              type: {
+                def: { HistoricMetaCompat: 'SessionKey5' }
+              }
+            },
+            {
+              id: 3,
+              type: {
+                def: { Tuple: [1, 0] }
+              }
+            },
+            {
+              id: 4,
+              type: {
+                def: { Tuple: [1, 0, 0] }
+              }
+            }
+          ]
+        }
+      }
+    }
+  });
+
+  registry.setMetadata(metadata);
+
+  it('allows creating a known 1 Map key', (): void => {
+    const storageFn = createFunction(registry, {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      meta: {
+        type: {
+          asMap: {
+            hashers: [
+              registry.createType('StorageHasher', 'Blake2_128Concat')
+            ],
+            key: 0,
+            value: 4
+          },
+          isMap: true
+        }
+      } as any,
+      method: 'Account',
+      prefix: 'System',
+      section: 'system'
+    }, {});
+
+    expect(
+      u8aToHex(
+        storageFn('DB2mp5nNhbFN86J9hxoAog8JALMhDXgwvWMxrRMLNUFMEY4')
+      )
+    ).toEqual(
+      '0x' +
+      '4101' +
+      '26aa394eea5630e07c48ae0c9558cef7' + // twox 128
+      'b99d880ec681799c0cf30e8886371da9' + // twox 128
+      '79c598d130209ab0dea15637a5b16be7' + // blake 128
+      '1a7938fede32e1275281b3eee5708706d88444a6dc898a4dec463f1eb298463f' // AccountId
+    );
+    expect(
+      storageFn.iterKey?.meta.type.asPlain.toNumber()
+    ).toEqual(0);
+  });
+
+  it('allows creating of known 2 Map keys (with Bytes)', (): void => {
+    const storageFn = createFunction(registry, {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      meta: {
+        type: {
+          asMap: {
+            hashers: [
+              registry.createType('StorageHasher', 'Twox64Concat'),
+              registry.createType('StorageHasher', 'Blake2_256')
+            ],
+            key: 3,
+            value: 4
+          },
+          isMap: true
+        }
+      } as any,
+      method: 'NextKeys',
+      prefix: 'Session',
+      section: 'session'
+    }, {});
+
+    expect(
+      u8aToHex(
+        storageFn(
+          // hex, without length prefix
+          '0x3a73657373696f6e3a6b657973',
+          // address
+          'DB2mp5nNhbFN86J9hxoAog8JALMhDXgwvWMxrRMLNUFMEY4'
+        )
+      )
+    ).toEqual(
+      '0x' +
+      '5901' + // length
+      'cec5070d609dd3497f72bde07fc96ba0' + // twox 128
+      '4c014e6bf8b8c2c011e7290b85696bb3' + // twox 128
+      '9fe6329cc0b39e09' + // twox 64
+      '343a73657373696f6e3a6b657973' + // twox 64 (concat, with length)
+      '5eb36b60f0fc4b9177116eba3e5cd57fea6289a57f5f5b9ffeb0475c66e7a521' // blake2
+    );
+  });
+
+  it('allows creating of 3 Map keys (with Bytes)', (): void => {
+    const storageFn = createFunction(registry, {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      meta: {
+        type: {
+          asMap: {
+            hashers: [
+              registry.createType('StorageHasher', 'Twox64Concat'),
+              registry.createType('StorageHasher', 'Blake2_256'),
+              registry.createType('StorageHasher', 'Blake2_256')
+            ],
+            key: 4,
+            value: 2
+          },
+          isMap: true
+        }
+      } as any,
+      method: 'NextKeys',
+      prefix: 'Session',
+      section: 'session'
+    }, {});
+
+    expect(
+      u8aToHex(
+        storageFn(
+          // hex, without length prefix
+          '0x3a73657373696f6e3a6b657973',
+          // addresses
+          'DB2mp5nNhbFN86J9hxoAog8JALMhDXgwvWMxrRMLNUFMEY4',
+          'DB2mp5nNhbFN86J9hxoAog8JALMhDXgwvWMxrRMLNUFMEY4'
+        )
+      )
+    ).toEqual(
+      '0x' +
+      'd901' + // length
+      'cec5070d609dd3497f72bde07fc96ba0' + // twox 128
+      '4c014e6bf8b8c2c011e7290b85696bb3' + // twox 128
+      '9fe6329cc0b39e09' + // twox 64
+      '343a73657373696f6e3a6b657973' + // twox 64 (concat, with length)
+      '5eb36b60f0fc4b9177116eba3e5cd57fea6289a57f5f5b9ffeb0475c66e7a521' + // blake2
+      '5eb36b60f0fc4b9177116eba3e5cd57fea6289a57f5f5b9ffeb0475c66e7a521' // blake2
+    );
+  });
+});

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

@@ -0,0 +1,258 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ICompact, Inspect, INumber } from '@pezkuwi/types-codec/types';
+import type { StorageEntryMetadataLatest, StorageHasher } from '../../../interfaces/metadata/index.js';
+import type { StorageKey } from '../../../primitive/index.js';
+import type { StorageEntry, StorageEntryIterator } from '../../../primitive/types.js';
+import type { Registry } from '../../../types/index.js';
+
+import { Raw } from '@pezkuwi/types-codec';
+import { compactAddLength, compactStripLength, isUndefined, objectSpread, stringCamelCase, u8aConcat, u8aToU8a } from '@pezkuwi/util';
+import { xxhashAsU8a } from '@pezkuwi/util-crypto';
+
+import { getSiName } from '../../util/index.js';
+import { getHasher } from './getHasher.js';
+
+export interface CreateItemOptions {
+  key?: Uint8Array | string;
+  skipHashing?: boolean;
+}
+
+export interface CreateItemBase {
+  method: string;
+  prefix: string;
+}
+
+export interface CreateItemFn extends CreateItemBase {
+  meta: StorageEntryMetadataLatest;
+  section: string;
+}
+
+interface IterFn {
+  (): Raw;
+  meta: StorageEntryMetadataLatest;
+}
+
+interface RawArgs {
+  args: unknown[];
+  hashers: StorageHasher[];
+  keys: ICompact<INumber>[];
+}
+
+export const NO_RAW_ARGS: RawArgs = {
+  args: [],
+  hashers: [],
+  keys: []
+};
+
+/** @internal */
+function filterDefined (a: unknown): boolean {
+  return !isUndefined(a);
+}
+
+/** @internal */
+function assertArgs ({ method, section }: CreateItemFn, { args, keys }: RawArgs): void {
+  if (!Array.isArray(args)) {
+    throw new Error(`Call to ${stringCamelCase(section || 'unknown')}.${stringCamelCase(method || 'unknown')} needs ${keys.length} arguments`);
+  } else if (args.filter(filterDefined).length !== keys.length) {
+    throw new Error(`Call to ${stringCamelCase(section || 'unknown')}.${stringCamelCase(method || 'unknown')} needs ${keys.length} arguments, found [${args.join(', ')}]`);
+  }
+}
+
+/** @internal */
+export function createKeyRawParts (registry: Registry, itemFn: CreateItemBase, { args, hashers, keys }: RawArgs): [Uint8Array[], Uint8Array[]] {
+  const count = keys.length;
+  const extra = new Array<Uint8Array>(count);
+
+  for (let i = 0; i < count; i++) {
+    extra[i] = getHasher(hashers[i])(
+      registry.createTypeUnsafe(registry.createLookupType(keys[i]), [args[i]]).toU8a()
+    );
+  }
+
+  return [
+    [
+      xxhashAsU8a(itemFn.prefix, 128),
+      xxhashAsU8a(itemFn.method, 128)
+    ],
+    extra
+  ];
+}
+
+/** @internal */
+export function createKeyInspect (registry: Registry, itemFn: CreateItemFn, args: RawArgs): Inspect {
+  assertArgs(itemFn, args);
+
+  const { meta } = itemFn;
+  const [prefix, extra] = createKeyRawParts(registry, itemFn, args);
+
+  let types: string[] = [];
+
+  if (meta.type.isMap) {
+    const { hashers, key } = meta.type.asMap;
+
+    types = hashers.length === 1
+      ? [`${hashers[0].type}(${getSiName(registry.lookup, key)})`]
+      : registry.lookup.getSiType(key).def.asTuple.map((k, i) =>
+        `${hashers[i].type}(${getSiName(registry.lookup, k)})`
+      );
+  }
+
+  const names = ['module', 'method'].concat(...args.args.map((_, i) => types[i]));
+
+  return {
+    inner: prefix
+      .concat(...extra)
+      .map((v, i) => ({ name: names[i], outer: [v] }))
+  };
+}
+
+/** @internal */
+export function createKeyRaw (registry: Registry, itemFn: CreateItemBase, args: RawArgs): Uint8Array {
+  const [prefix, extra] = createKeyRawParts(registry, itemFn, args);
+
+  return u8aConcat(
+    ...prefix,
+    ...extra
+  );
+}
+
+/** @internal */
+function createKey (registry: Registry, itemFn: CreateItemFn, args: RawArgs): Uint8Array {
+  assertArgs(itemFn, args);
+
+  // always add the length prefix (underlying it is Bytes)
+  return compactAddLength(
+    createKeyRaw(registry, itemFn, args)
+  );
+}
+
+/** @internal */
+function createStorageInspect (registry: Registry, itemFn: CreateItemFn, options: CreateItemOptions): (...args: unknown[]) => Inspect {
+  const { meta: { type } } = itemFn;
+
+  return (...args: unknown[]): Inspect => {
+    if (type.isPlain) {
+      return options.skipHashing
+        ? { inner: [], name: 'wellKnown', outer: [u8aToU8a(options.key)] }
+        : createKeyInspect(registry, itemFn, NO_RAW_ARGS);
+    }
+
+    const { hashers, key } = type.asMap;
+
+    return hashers.length === 1
+      ? createKeyInspect(registry, itemFn, { args, hashers, keys: [key] })
+      : createKeyInspect(registry, itemFn, { args, hashers, keys: registry.lookup.getSiType(key).def.asTuple });
+  };
+}
+
+/** @internal */
+function createStorageFn (registry: Registry, itemFn: CreateItemFn, options: CreateItemOptions): (...args: unknown[]) => Uint8Array {
+  const { meta: { type } } = itemFn;
+  let cacheKey: Uint8Array | null = null;
+
+  // Can only have zero or one argument:
+  //   - storage.system.account(address)
+  //   - storage.timestamp.blockPeriod()
+  // For higher-map queries the params are passed in as an tuple, [key1, key2]
+  return (...args: unknown[]): Uint8Array => {
+    if (type.isPlain) {
+      if (!cacheKey) {
+        cacheKey = options.skipHashing
+          ? compactAddLength(u8aToU8a(options.key))
+          : createKey(registry, itemFn, NO_RAW_ARGS);
+      }
+
+      return cacheKey;
+    }
+
+    const { hashers, key } = type.asMap;
+
+    return hashers.length === 1
+      ? createKey(registry, itemFn, { args, hashers, keys: [key] })
+      : createKey(registry, itemFn, { args, hashers, keys: registry.lookup.getSiType(key).def.asTuple });
+  };
+}
+
+/** @internal */
+function createWithMeta (registry: Registry, itemFn: CreateItemFn, options: CreateItemOptions): StorageEntry {
+  const { meta, method, prefix, section } = itemFn;
+  const storageFn = createStorageFn(registry, itemFn, options) as StorageEntry;
+
+  storageFn.inspect = createStorageInspect(registry, itemFn, options);
+  storageFn.meta = meta;
+  storageFn.method = stringCamelCase(method);
+  storageFn.prefix = prefix;
+  storageFn.section = section;
+
+  // explicitly add the actual method in the toJSON, this gets used to determine caching and without it
+  // instances (e.g. collective) will not work since it is only matched on param meta
+  storageFn.toJSON = (): any => objectSpread({ storage: { method, prefix, section } }, meta.toJSON());
+
+  return storageFn;
+}
+
+/** @internal */
+function extendHeadMeta (registry: Registry, { meta: { docs, name, type }, section }: CreateItemFn, { method }: StorageEntry, iterFn: (...args: unknown[]) => Raw): StorageEntryIterator {
+  // metadata with a fallback value using the type of the key, the normal
+  // meta fallback only applies to actual entry values, create one for head
+  const meta = registry.createTypeUnsafe<StorageEntryMetadataLatest>('StorageEntryMetadataLatest', [{
+    docs,
+    fallback: registry.createTypeUnsafe('Bytes', []),
+    modifier: registry.createTypeUnsafe('StorageEntryModifierLatest', [1]), // required
+    name,
+    type: registry.createTypeUnsafe('StorageEntryTypeLatest', [type.asMap.key, 0])
+  }]);
+
+  (iterFn as IterFn).meta = meta;
+
+  const fn = (...args: unknown[]) =>
+    registry.createTypeUnsafe<StorageKey>('StorageKey', [iterFn(...args), { method, section }]);
+
+  fn.meta = meta;
+
+  return fn;
+}
+
+/** @internal */
+function extendPrefixedMap (registry: Registry, itemFn: CreateItemFn, storageFn: StorageEntry): StorageEntry {
+  const { meta: { type }, method, section } = itemFn;
+
+  storageFn.iterKey = extendHeadMeta(registry, itemFn, storageFn, (...args: unknown[]): Raw => {
+    if (args.length && (type.isPlain || (args.length >= type.asMap.hashers.length))) {
+      throw new Error(`Iteration of ${stringCamelCase(section || 'unknown')}.${stringCamelCase(method || 'unknown')} needs arguments to be at least one less than the full arguments, found [${args.join(', ')}]`);
+    }
+
+    if (args.length) {
+      if (type.isMap) {
+        const { hashers, key } = type.asMap;
+        const keysVec = hashers.length === 1
+          ? [key]
+          : registry.lookup.getSiType(key).def.asTuple;
+
+        return new Raw(registry, createKeyRaw(registry, itemFn, { args, hashers: hashers.slice(0, args.length), keys: keysVec.slice(0, args.length) }));
+      }
+    }
+
+    return new Raw(registry, createKeyRaw(registry, itemFn, NO_RAW_ARGS));
+  });
+
+  return storageFn;
+}
+
+/** @internal */
+export function createFunction (registry: Registry, itemFn: CreateItemFn, options: CreateItemOptions): StorageEntry {
+  const { meta: { type } } = itemFn;
+  const storageFn = createWithMeta(registry, itemFn, options);
+
+  if (type.isMap) {
+    extendPrefixedMap(registry, itemFn, storageFn);
+  }
+
+  storageFn.keyPrefix = (...args: unknown[]): Uint8Array =>
+    (storageFn.iterKey && storageFn.iterKey(...args)) ||
+    compactStripLength(storageFn())[1];
+
+  return storageFn;
+}

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

@@ -0,0 +1,30 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { stringToU8a } from '@pezkuwi/util';
+import { xxhashAsU8a } from '@pezkuwi/util-crypto';
+
+import { TypeRegistry } from '../../../create/index.js';
+import { getHasher } from './getHasher.js';
+
+describe('getHasher', (): void => {
+  const registry = new TypeRegistry();
+
+  describe('Twox64Concat', (): void => {
+    it('matches the foo test from Rust', (): void => {
+      const hasher = getHasher(registry.createType('StorageHasher', 'Twox64Concat'));
+      const hash = hasher('foo');
+      const xxhash = xxhashAsU8a('foo', 128);
+
+      expect([
+        hash.subarray(0, 8),
+        hash.subarray(8)
+      ]).toEqual([
+        xxhash.subarray(0, 8),
+        stringToU8a('foo')
+      ]);
+    });
+  });
+});

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

@@ -0,0 +1,36 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { StorageHasher } from '../../../interfaces/index.js';
+import type { AllHashers } from '../../../interfaces/metadata/definitions.js';
+
+import { u8aConcat, u8aToU8a } from '@pezkuwi/util';
+import { blake2AsU8a, xxhashAsU8a } from '@pezkuwi/util-crypto';
+
+export type HasherInput = string | Buffer | Uint8Array;
+
+export type HasherFunction = (data: HasherInput) => Uint8Array;
+
+const DEFAULT_FN = (data: HasherInput): Uint8Array => xxhashAsU8a(data, 128);
+
+const HASHERS: Record<keyof typeof AllHashers, HasherFunction> = {
+  Blake2_128: (data: HasherInput) => // eslint-disable-line camelcase
+    blake2AsU8a(data, 128),
+  Blake2_128Concat: (data: HasherInput) => // eslint-disable-line camelcase
+    u8aConcat(blake2AsU8a(data, 128), u8aToU8a(data)),
+  Blake2_256: (data: HasherInput) => // eslint-disable-line camelcase
+    blake2AsU8a(data, 256),
+  Identity: (data: HasherInput) =>
+    u8aToU8a(data),
+  Twox128: (data: HasherInput) =>
+    xxhashAsU8a(data, 128),
+  Twox256: (data: HasherInput) =>
+    xxhashAsU8a(data, 256),
+  Twox64Concat: (data: HasherInput) =>
+    u8aConcat(xxhashAsU8a(data, 64), u8aToU8a(data))
+};
+
+/** @internal */
+export function getHasher (hasher: StorageHasher): HasherFunction {
+  return HASHERS[hasher.type as 'Identity'] || DEFAULT_FN;
+}

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

@@ -0,0 +1,31 @@
+// 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 { 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['substrate']).toBe('object');
+
+    expect(storage['substrate']['code']()).toEqual(compactAddLength(u8aToU8a(':code')));
+
+    expect(storage['substrate']['changesTrieConfig']).toBeTruthy();
+    expect(storage['substrate']['childStorageKeyPrefix']).toBeTruthy();
+    expect(storage['substrate']['extrinsicIndex']).toBeTruthy();
+    expect(storage['substrate']['heapPages']).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,20 @@
+// 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 { Storage } from '../types.js';
+
+import { substrate } from './substrate.js';
+
+/** @internal */
+export function getStorage (registry: Registry): Storage {
+  const storage: Record<string, StorageEntry> = {};
+  const entries = Object.entries(substrate);
+
+  for (let e = 0, count = entries.length; e < count; e++) {
+    storage[entries[e][0]] = entries[e][1](registry);
+  }
+
+  return { substrate: storage };
+}