@pezkuwi/types 16.5.5

package/src/metadata/PortableRegistry/index.ts

@@ -0,0 +1,5 @@
+// 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

@@ -0,0 +1,130 @@
+// 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

@@ -0,0 +1,10 @@
+# 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

@@ -0,0 +1,44 @@
+// 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

@@ -0,0 +1,39 @@
+// 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

@@ -0,0 +1,47 @@
+// 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

@@ -0,0 +1,58 @@
+// 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

@@ -0,0 +1,52 @@
+// 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

@@ -0,0 +1,42 @@
+// 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

@@ -0,0 +1,38 @@
+// 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

@@ -0,0 +1,90 @@
+// 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

@@ -0,0 +1,66 @@
+// 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;
+}