@pezkuwi/types 16.5.5 → 16.5.6

package/src/metadata/PortableRegistry/index.ts

@@ -1,5 +0,0 @@
-// Copyright 2017-2025 @polkadot/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export { PortableRegistry } from './PortableRegistry.js';
-export { toV1 as convertSiV0toV1 } from './toV1.js';

package/src/metadata/PortableRegistry/toV1.ts

@@ -1,130 +0,0 @@
-// Copyright 2017-2025 @polkadot/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { PortableType, Si0Field, Si0LookupTypeId, Si0Path, Si0Type, Si0TypeDefArray, Si0TypeDefBitSequence, Si0TypeDefComposite, Si0TypeDefPrimitive, Si0TypeDefSequence, Si0TypeDefVariant, Si1Field, Si1TypeDef, SiTypeDef } from '../../interfaces/index.js';
-import type { Registry } from '../../types/index.js';
-
-import { assertUnreachable } from '@pezkuwi/util';
-
-function convertType (key: 'Compact' | 'Sequence'): (registry: Registry, si: Si0TypeDefSequence) => SiTypeDef {
-  return (registry: Registry, { type }: Si0TypeDefSequence) =>
-    registry.createType('Si1TypeDef', {
-      [key]: {
-        type: type.toNumber()
-      }
-    });
-}
-
-function convertArray (registry: Registry, { len, type }: Si0TypeDefArray): Si1TypeDef {
-  return registry.createType('Si1TypeDef', {
-    Array: {
-      len,
-      type: type.toNumber()
-    }
-  });
-}
-
-function convertBitSequence (registry: Registry, { bitOrderType, bitStoreType }: Si0TypeDefBitSequence): Si1TypeDef {
-  return registry.createType('Si1TypeDef', {
-    BitSequence: {
-      bitOrderType: bitOrderType.toNumber(),
-      bitStoreType: bitStoreType.toNumber()
-    }
-  });
-}
-
-const convertCompact = convertType('Compact');
-
-function convertComposite (registry: Registry, { fields }: Si0TypeDefComposite): Si1TypeDef {
-  return registry.createType('Si1TypeDef', {
-    Composite: {
-      fields: convertFields(registry, fields)
-    }
-  });
-}
-
-function convertFields (registry: Registry, fields: Si0Field[]): Si1Field[] {
-  return fields.map(({ docs, name, type, typeName }) =>
-    registry.createType('Si1Field', {
-      docs,
-      name,
-      type: type.toNumber(),
-      typeName
-    })
-  );
-}
-
-function convertPhantom (registry: Registry, path: Si0Path): Si1TypeDef {
-  console.warn(`Converting phantom type ${path.map((p) => p.toString()).join('::')} to empty tuple`);
-
-  return registry.createType('Si1TypeDef', {
-    Tuple: []
-  });
-}
-
-function convertPrimitive (registry: Registry, prim: Si0TypeDefPrimitive): Si1TypeDef {
-  return registry.createType('Si1TypeDef', {
-    Primitive: prim.toString()
-  });
-}
-
-const convertSequence = convertType('Sequence');
-
-function convertTuple (registry: Registry, types: Si0LookupTypeId[]): Si1TypeDef {
-  return registry.createType('Si1TypeDef', {
-    Tuple: types.map((t) => t.toNumber())
-  });
-}
-
-function convertVariant (registry: Registry, { variants }: Si0TypeDefVariant): Si1TypeDef {
-  return registry.createType('Si1TypeDef', {
-    Variant: {
-      variants: variants.map(({ discriminant, docs, fields, name }, index) =>
-        registry.createType('Si1Variant', {
-          docs,
-          fields: convertFields(registry, fields),
-          index: discriminant.isSome
-            ? discriminant.unwrap().toNumber()
-            : index,
-          name
-        })
-      )
-    }
-  });
-}
-
-function convertDef (registry: Registry, { def, path }: Si0Type): Si1TypeDef {
-  let result: Si1TypeDef;
-
-  switch (def.type) {
-    case 'Array': result = convertArray(registry, def.asArray); break;
-    case 'BitSequence': result = convertBitSequence(registry, def.asBitSequence); break;
-    case 'Compact': result = convertCompact(registry, def.asCompact); break;
-    case 'Composite': result = convertComposite(registry, def.asComposite); break;
-    case 'Phantom': result = convertPhantom(registry, path); break;
-    case 'Primitive': result = convertPrimitive(registry, def.asPrimitive); break;
-    case 'Sequence': result = convertSequence(registry, def.asSequence); break;
-    case 'Tuple': result = convertTuple(registry, def.asTuple); break;
-    case 'Variant': result = convertVariant(registry, def.asVariant); break;
-    default: assertUnreachable(def.type);
-  }
-
-  return result;
-}
-
-export function toV1 (registry: Registry, types: Si0Type[]): PortableType[] {
-  return types.map((t, index) =>
-    registry.createType('PortableType', {
-      // offsets are +1 from v0
-      id: index + 1,
-      type: {
-        def: convertDef(registry, t),
-        docs: [],
-        params: t.params.map((p) => registry.createType('Si1TypeParameter', {
-          type: p.toNumber()
-        })),
-        path: t.path.map((p) => p.toString())
-      }
-    })
-  );
-}

package/src/metadata/README.md

@@ -1,10 +0,0 @@
-# metadata update
-
-0. New branch :)
-0. Start the node, typically via `cargo run --release -- purge-chain -y --dev && cargo run --release -- --dev` ([types-support/src/metadata/README.md](../../../types-support/src/metadata/README.md) has more information for specific chains)
-0. Retrieve the metadata `curl -H "Content-Type: application/json" -d '{"id":1, "jsonrpc":"2.0", "method": "state_getMetadata", "params":[]}' http://localhost:9933`
-0. Copy into the latest version folder per node type in `types-support/src/metadata` eg. `types-support/src/metadata/v14/substrate-hex.json`
-0. Re-build the interfaces `yarn build:interfaces`
-0. Run Metadata tests, `yarn test:one packages/types/src/metadata`
-0. All tests
-0. Make PR

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

@@ -1,44 +0,0 @@
-// Copyright 2017-2025 @polkadot/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import type { HexString } from '@pezkuwi/util/types';
-import type { BlockNumber } from '../../../interfaces/index.js';
-import type { Constants } from '../types.js';
-
-import rpcMetadata from '@pezkuwi/types-support/metadata/static-substrate';
-import rpcMetadataV10 from '@pezkuwi/types-support/metadata/v10/substrate-hex';
-
-import { TypeRegistry } from '../../../create/index.js';
-import { Metadata } from '../../Metadata.js';
-import { decorateConstants } from '../index.js';
-
-function init (meta: HexString): [consts: Constants, registry: TypeRegistry] {
-  const registry = new TypeRegistry();
-  const metadata = new Metadata(registry, meta);
-
-  registry.setMetadata(metadata);
-
-  return [decorateConstants(registry, metadata.asLatest, metadata.version), registry];
-}
-
-describe('decorateConstants', (): void => {
-  it('should return constants with the correct type and value', (): void => {
-    const [consts] = init(rpcMetadata);
-
-    expect((consts['democracy']['cooloffPeriod'] as unknown as BlockNumber).bitLength()).toBe(32);
-    // 3 second blocks, 28 days
-    expect((consts['democracy']['cooloffPeriod'] as unknown as BlockNumber).toNumber()).toEqual(28 * 24 * 60 * (60 / 3));
-  });
-
-  // removed from session
-  it('correctly handles bytes (V10)', (): void => {
-    const [consts] = init(rpcMetadataV10);
-
-    // 0x34 removes as the length prefix removed
-    expect(
-      consts['session']['dedupKeyPrefix'].toHex()
-    ).toEqual('0x3a73657373696f6e3a6b657973');
-  });
-});

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

@@ -1,39 +0,0 @@
-// Copyright 2017-2025 @polkadot/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Registry } from '@pezkuwi/types-codec/types';
-import type { MetadataLatest, PalletConstantMetadataLatest } from '../../../interfaces/index.js';
-import type { ConstantCodec, Constants } from '../types.js';
-
-import { hexToU8a, lazyMethod, lazyMethods, stringCamelCase } from '@pezkuwi/util';
-
-import { objectNameToCamel } from '../util.js';
-
-/** @internal */
-export function decorateConstants (registry: Registry, { pallets }: MetadataLatest, _version: number): Constants {
-  const result: Constants = {};
-
-  for (let i = 0, count = pallets.length; i < count; i++) {
-    const { constants, name } = pallets[i];
-
-    if (!constants.isEmpty) {
-      lazyMethod(result, stringCamelCase(name), () =>
-        lazyMethods(
-          {},
-          constants,
-          (constant: PalletConstantMetadataLatest): ConstantCodec => {
-            const codec = registry.createTypeUnsafe<ConstantCodec>(registry.createLookupType(constant.type), [hexToU8a(constant.value.toHex())]);
-
-            // We are casting here since we are assigning to a read-only property
-            (codec as { meta: PalletConstantMetadataLatest }).meta = constant;
-
-            return codec;
-          },
-          objectNameToCamel
-        )
-      );
-    }
-  }
-
-  return result;
-}

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

@@ -1,47 +0,0 @@
-// Copyright 2017-2025 @polkadot/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import rpcMetadata from '@pezkuwi/types-support/metadata/static-substrate';
-
-import { TypeRegistry } from '../../../create/index.js';
-import { Metadata } from '../../Metadata.js';
-import { decorateErrors } from '../index.js';
-
-const registry = new TypeRegistry();
-const metadata = new Metadata(registry, rpcMetadata);
-
-registry.setMetadata(metadata);
-
-const errors = decorateErrors(registry, metadata.asLatest, metadata.version);
-
-describe('decorateErrors', (): void => {
-  it('should return known errors', (): void => {
-    expect(errors['balances']['InsufficientBalance']).toBeDefined();
-    expect(errors['system']['FailedToExtractRuntimeVersion']).toBeDefined();
-  });
-
-  it('has the correct metadata for known errors', (): void => {
-    expect(
-      errors['proxy']['NotProxy'].meta.toJSON()
-    ).toEqual({
-      args: [],
-      docs: ['Sender is not a proxy of the account to be proxied.'],
-      fields: [],
-      index: 2,
-      name: 'NotProxy'
-    });
-  });
-
-  it('should check against a specific error', (): void => {
-    expect(
-      errors['system']['InvalidSpecName'].is(
-        registry.createType('DispatchErrorModule', {
-          error: 0,
-          index: 0
-        })
-      )
-    ).toBe(true);
-  });
-});

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

@@ -1,58 +0,0 @@
-// Copyright 2017-2025 @polkadot/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Text, u8 } from '@pezkuwi/types-codec';
-import type { Registry } from '@pezkuwi/types-codec/types';
-import type { DispatchErrorModule, DispatchErrorModuleU8, DispatchErrorModuleU8a, MetadataLatest, SiField, SiVariant } from '../../../interfaces/index.js';
-import type { PortableRegistry } from '../../../metadata/index.js';
-import type { Errors, IsError } from '../types.js';
-
-import { isCodec, isU8a, lazyMethod, objectSpread, stringCamelCase } from '@pezkuwi/util';
-
-import { lazyVariants } from '../../../create/lazy.js';
-import { objectNameToString } from '../util.js';
-
-interface ItemMeta {
-  args: string[];
-  name: Text;
-  fields: SiField[];
-  index: u8;
-  docs: Text[];
-}
-
-export function variantToMeta (lookup: PortableRegistry, variant: SiVariant): ItemMeta {
-  return objectSpread(
-    { args: variant.fields.map(({ type }) => lookup.getTypeDef(type).type) },
-    variant
-  );
-}
-
-/** @internal */
-export function decorateErrors (registry: Registry, { lookup, pallets }: MetadataLatest, version: number): Errors {
-  const result: Errors = {};
-
-  for (let i = 0, count = pallets.length; i < count; i++) {
-    const { errors, index, name } = pallets[i];
-
-    if (errors.isSome) {
-      const sectionIndex = version >= 12 ? index.toNumber() : i;
-
-      lazyMethod(result, stringCamelCase(name), () =>
-        lazyVariants(lookup, errors.unwrap(), objectNameToString, (variant: SiVariant): IsError => ({
-          // We sprinkle in isCodec & isU8a to ensure we are dealing with the correct objects
-          is: (errorMod: DispatchErrorModule | DispatchErrorModuleU8 | DispatchErrorModuleU8a) =>
-            isCodec(errorMod) &&
-            isCodec(errorMod.index) &&
-            errorMod.index.eq(sectionIndex) && (
-              isU8a(errorMod.error)
-                ? errorMod.error[0] === variant.index.toNumber()
-                : isCodec(errorMod.error) && errorMod.error.eq(variant.index)
-            ),
-          meta: registry.createTypeUnsafe('ErrorMetadataLatest', [variantToMeta(lookup, variant)])
-        }))
-      );
-    }
-  }
-
-  return result;
-}

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

@@ -1,52 +0,0 @@
-// Copyright 2017-2025 @polkadot/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import rpcMetadata from '@pezkuwi/types-support/metadata/static-substrate';
-
-import { TypeRegistry } from '../../../create/index.js';
-import { Metadata } from '../../Metadata.js';
-import { decorateEvents } from '../index.js';
-
-const registry = new TypeRegistry();
-const metadata = new Metadata(registry, rpcMetadata);
-
-registry.setMetadata(metadata);
-
-const events = decorateEvents(registry, metadata.asLatest, metadata.version);
-
-describe('decorateEvents', (): void => {
-  it('should return known errors', (): void => {
-    expect(events['balances']['Transfer']).toBeDefined();
-    expect(events['system']['CodeUpdated']).toBeDefined();
-  });
-
-  it('has the correct metadata for known errors', (): void => {
-    expect(
-      events['staking']['Rewarded'].meta.toJSON()
-    ).toEqual({
-      args: [
-        'AccountId32',
-        '{"_enum":{"Staked":"Null","Stash":"Null","Controller":"Null","Account":"AccountId32","None":"Null"}}',
-        'u128'
-      ],
-      docs: [
-        'The nominator has been rewarded by this amount to this destination.'
-      ],
-      fields: [
-        { docs: [], name: 'stash', type: 0, typeName: 'T::AccountId' },
-        { docs: [], name: 'dest', type: 48, typeName: 'RewardDestination<T::AccountId>' },
-        { docs: [], name: 'amount', type: 6, typeName: 'BalanceOf<T>' }
-      ],
-      index: 1,
-      name: 'Rewarded'
-    });
-  });
-
-  it('should check against a specific error', (): void => {
-    expect(
-      events['system']['ExtrinsicSuccess'].is(registry.createType('Event', { index: [0, 0] }))
-    ).toBe(true);
-  });
-});

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

@@ -1,42 +0,0 @@
-// Copyright 2017-2025 @polkadot/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { AnyTuple, Registry } from '@pezkuwi/types-codec/types';
-import type { MetadataLatest, PalletMetadataLatest, SiVariant } from '../../../interfaces/index.js';
-import type { IEvent, IEventLike } from '../../../types/index.js';
-import type { Events, IsEvent } from '../types.js';
-
-import { isCodec, isU8a, lazyMethod, stringCamelCase } from '@pezkuwi/util';
-
-import { lazyVariants } from '../../../create/lazy.js';
-import { variantToMeta } from '../errors/index.js';
-import { objectNameToString } from '../util.js';
-
-export function filterEventsSome ({ events }: PalletMetadataLatest): boolean {
-  return events.isSome;
-}
-
-/** @internal */
-export function decorateEvents (registry: Registry, { lookup, pallets }: MetadataLatest, version: number): Events {
-  const result: Events = {};
-  const filtered = pallets.filter(filterEventsSome);
-
-  for (let i = 0, count = filtered.length; i < count; i++) {
-    const { events, index, name } = filtered[i];
-    const sectionIndex = version >= 12 ? index.toNumber() : i;
-
-    lazyMethod(result, stringCamelCase(name), () =>
-      lazyVariants(lookup, events.unwrap(), objectNameToString, (variant: SiVariant): IsEvent<AnyTuple> => ({
-        // We sprinkle in isCodec & isU8a to ensure we are dealing with the correct objects
-        is: <T extends AnyTuple> (eventRecord: IEventLike): eventRecord is IEvent<T> =>
-          isCodec(eventRecord) &&
-          isU8a(eventRecord.index) &&
-          sectionIndex === eventRecord.index[0] &&
-          variant.index.eq(eventRecord.index[1]),
-        meta: registry.createTypeUnsafe('EventMetadataLatest', [variantToMeta(lookup, variant)])
-      }))
-    );
-  }
-
-  return result;
-}

package/src/metadata/decorate/extrinsics/createUnchecked.ts

@@ -1,38 +0,0 @@
-// Copyright 2017-2025 @polkadot/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { AnyJson, AnyTuple, Registry } from '@pezkuwi/types-codec/types';
-import type { Call, FunctionMetadataLatest } from '../../../interfaces/index.js';
-import type { CallFunction, IMethod } from '../../../types/index.js';
-
-import { stringCamelCase } from '@pezkuwi/util';
-
-function isTx <A extends AnyTuple> (tx: IMethod<AnyTuple>, callIndex: Uint8Array): tx is IMethod<A> {
-  return tx.callIndex[0] === callIndex[0] && tx.callIndex[1] === callIndex[1];
-}
-
-/** @internal */
-export function createUnchecked (registry: Registry, section: string, callIndex: Uint8Array, callMetadata: FunctionMetadataLatest): CallFunction {
-  const expectedArgs = callMetadata.fields;
-  const funcName = stringCamelCase(callMetadata.name);
-
-  const extrinsicFn = (...args: unknown[]): Call => {
-    if (expectedArgs.length !== args.length) {
-      throw new Error(`Extrinsic ${section}.${funcName} expects ${expectedArgs.length} arguments, got ${args.length}.`);
-    }
-
-    return registry.createTypeUnsafe('Call', [{ args, callIndex }, callMetadata]);
-  };
-
-  extrinsicFn.is = <A extends AnyTuple> (tx: IMethod<AnyTuple>): tx is IMethod<A> =>
-    isTx(tx, callIndex);
-
-  extrinsicFn.callIndex = callIndex;
-  extrinsicFn.meta = callMetadata;
-  extrinsicFn.method = funcName;
-  extrinsicFn.section = section;
-  extrinsicFn.toJSON = (): AnyJson =>
-    callMetadata.toJSON();
-
-  return extrinsicFn as unknown as CallFunction;
-}

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

@@ -1,90 +0,0 @@
-// 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 metadataStatic from '@pezkuwi/types-support/metadata/v13/substrate-hex';
-import { BN } from '@pezkuwi/util';
-
-import { TypeRegistry } from '../../../create/index.js';
-import { Metadata } from '../../Metadata.js';
-import { decorateExtrinsics } from './index.js';
-
-const keyring = createTestPairs({ type: 'ed25519' }, false);
-const registry = new TypeRegistry();
-const metadata = new Metadata(registry, metadataStatic);
-
-registry.setMetadata(metadata);
-registry.register({ Address: 'IndicesLookupSource', LookupSource: 'IndicesLookupSource' });
-
-const extrinsics = decorateExtrinsics(registry, metadata.asLatest, metadata.version);
-
-describe('extrinsics', (): void => {
-  it('encodes an actual transfer (actual data)', (): void => {
-    expect(
-      registry.createType('Extrinsic',
-        extrinsics['balances']['transfer'](keyring.bob.publicKey, 6969)
-      ).sign(keyring.alice, {
-        blockHash: '0xec7afaf1cca720ce88c1d1b689d81f0583cc15a97d621cf046dd9abf605ef22f',
-        genesisHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b',
-        nonce: 0,
-        runtimeVersion: {
-          apis: [],
-          authoringVersion: new BN(123),
-          implName: 'test',
-          implVersion: new BN(123),
-          specName: 'test',
-          specVersion: new BN(123),
-          transactionVersion: new BN(123)
-        }
-      }).toHex()
-    ).toEqual(
-      '0x' +
-      '2d02' + // length
-      '84' + // signed flag
-      'ffd172a74cda4c865912c32ba0a80a57ae69abae410e5ccb59dee84e2f4432db4f' + // who
-      '00' + // ed25519
-      '4634f7b973084f983ef48e2afbd72a990f7d4dd9d86c39e645cb34d9a45466b6' + // sig1
-      '263f0f2020363a6475f91e323a8b1bd43dedd97e78ec3c5d5b5197466305400e' + // sig2
-      '000000' + // nonce, era, tip
-      '0600' + // balances.transferAllowDeath
-      'ffd7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9' + // to
-      'e56c' // value
-    );
-  });
-});
-
-describe('decorateExtrinsics', (): void => {
-  it('should throw if an incorrect number of args is supplied', (): void => {
-    expect(() => extrinsics['balances']['setBalance']()).toThrow(/expects 3 arguments/);
-  });
-
-  it('should return a value if the storage function does not expect an argument', (): void => {
-    expect(() => extrinsics['balances']['setBalance']('5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF', 2, 3)).not.toThrow();
-  });
-
-  it('should return properly-encoded transactions', (): void => {
-    expect(
-      registry.createType('Extrinsic', extrinsics['timestamp']['set'](32)).toU8a()
-    ).toEqual(
-      new Uint8Array([
-        // length (encoded)
-        4 << 2,
-        // version, no signature
-        4,
-        // index
-        3, 0,
-        // values, Compact<Moment>
-        32 << 2
-      ])
-    );
-  });
-
-  it('has working .is', (): void => {
-    const tx = extrinsics['balances']['setBalance']('5C62W7ELLAAfix9LYrcx5smtcffbhvThkM5x7xfMeYXCtGwF', 2, 3);
-
-    expect(extrinsics['balances']['setBalance'].is(tx)).toBe(true);
-    expect(extrinsics['balances']['transfer'].is(tx)).toBe(false);
-  });
-});

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

@@ -1,66 +0,0 @@
-// Copyright 2017-2025 @polkadot/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Registry } from '@pezkuwi/types-codec/types';
-import type { MetadataLatest, PalletMetadataLatest, SiVariant } from '../../../interfaces/index.js';
-import type { PortableRegistry } from '../../../metadata/index.js';
-import type { CallFunction } from '../../../types/index.js';
-import type { Extrinsics } from '../types.js';
-
-import { lazyMethod, objectSpread, stringCamelCase } from '@pezkuwi/util';
-
-import { lazyVariants } from '../../../create/lazy.js';
-import { getSiName } from '../../util/index.js';
-import { objectNameToCamel } from '../util.js';
-import { createUnchecked } from './createUnchecked.js';
-
-export function filterCallsSome ({ calls }: PalletMetadataLatest): boolean {
-  return calls.isSome;
-}
-
-export function createCallFunction (registry: Registry, lookup: PortableRegistry, variant: SiVariant, sectionName: string, sectionIndex: number): CallFunction {
-  const { fields, index } = variant;
-  const count = fields.length;
-  const args = new Array<Record<string, unknown>>(count);
-
-  for (let i = 0; i < count; i++) {
-    const { name, type, typeName } = fields[i];
-
-    args[i] = objectSpread(
-      {
-        name: stringCamelCase(name.unwrapOr(`param${i}`)),
-        type: getSiName(lookup, type)
-      },
-      typeName.isSome
-        ? { typeName: typeName.unwrap() }
-        : null
-    );
-  }
-
-  return createUnchecked(
-    registry,
-    sectionName,
-    new Uint8Array([sectionIndex, index.toNumber()]),
-    registry.createTypeUnsafe('FunctionMetadataLatest', [objectSpread({ args }, variant)])
-  );
-}
-
-/** @internal */
-export function decorateExtrinsics (registry: Registry, { lookup, pallets }: MetadataLatest, version: number): Extrinsics {
-  const result: Extrinsics = {};
-  const filtered = pallets.filter(filterCallsSome);
-
-  for (let i = 0, count = filtered.length; i < count; i++) {
-    const { calls, index, name } = filtered[i];
-    const sectionName = stringCamelCase(name);
-    const sectionIndex = version >= 12 ? index.toNumber() : i;
-
-    lazyMethod(result, sectionName, () =>
-      lazyVariants(lookup, calls.unwrap(), objectNameToCamel, (variant: SiVariant) =>
-        createCallFunction(registry, lookup, variant, sectionName, sectionIndex)
-      )
-    );
-  }
-
-  return result;
-}