@pezkuwi/types 16.5.5

package/src/interfaces/runtime/Header.spec.ts

@@ -0,0 +1,64 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+
+import json1 from '@pezkuwi/types-support/json/Header.001.json' assert { type: 'json' };
+import json2 from '@pezkuwi/types-support/json/Header.002.json' assert { type: 'json' };
+import json3 from '@pezkuwi/types-support/json/Header.003.json' assert { type: 'json' };
+import block00300 from '@pezkuwi/types-support/json/SignedBlock.003.00.json' assert { type: 'json' };
+import block00301 from '@pezkuwi/types-support/json/SignedBlock.003.01.json' assert { type: 'json' };
+import { BN } from '@pezkuwi/util';
+
+import { TypeRegistry } from '../../create/index.js';
+
+describe('Header', (): void => {
+  const registry = new TypeRegistry();
+
+  it('decodes an actual JSON response', (): void => {
+    const header = registry.createType('Header', json1.result);
+
+    expect(
+      header.number.toNumber()
+    ).toEqual(0);
+    expect(
+      header.extrinsicsRoot.toString()
+    ).toEqual('0x45b0cfc220ceec5b7c1c62c4d4193d38e4eba48e8815729ce75f9c0ab0e4c1c0');
+    expect(
+      header.parentHash.toString()
+    ).toEqual('0x0000000000000000000000000000000000000000000000000000000000000000');
+    expect(
+      header.stateRoot.toString()
+    ).toEqual('0x294c3470ae3be7555240b9d034ec19c3715ba2c3f20b92441f8cea0cab66ab56');
+    expect(
+      header.digest.logs.toString()
+    ).toEqual('[]');
+  });
+
+  it('parses old-style JSON headers (deprecated)', (): void => {
+    const header = registry.createType('Header', json2.result);
+
+    expect(
+      header.digest.logs
+    ).toHaveLength(1);
+  });
+
+  it('creates a valid hash (incl. digest & compact)', (): void => {
+    const header = registry.createType('Header', json3.result);
+
+    expect(
+      header.hash.toHex()
+    ).toEqual('0x464692ad0e225a74274a7ef411e045f1fc7c2639b5f780c7c18f91f4100f5e54');
+    expect(
+      header.number.eq(new BN(1650758))
+    ).toBe(true);
+  });
+
+  it('calculates correct hash, matching with parentHash', (): void => {
+    const blockHash = registry.createType('Header', block00300.result.block.header).hash.toHex();
+
+    expect(blockHash).toEqual(block00301.result.block.header.parentHash);
+  });
+});

package/src/interfaces/runtime/KeyValue.spec.ts

@@ -0,0 +1,41 @@
+// 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';
+
+describe('KeyValue', (): void => {
+  const registry = new TypeRegistry();
+
+  it('decodes KeyValue from u8a', (): void => {
+    expect(
+      registry.createType('KeyValue', Uint8Array.from([
+        4 << 2,
+        0x11, 0x22, 0x33, 0x44,
+        9 << 2,
+        0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11
+      ])).toJSON()
+    ).toEqual(['0x11223344', '0x998877665544332211']);
+  });
+
+  it('encodes KeyValue from JSON', (): void => {
+    expect(
+      registry.createType('KeyValue', ['0x11223344', '0x998877665544332211']).toU8a()
+    ).toEqual(
+      new Uint8Array([
+        4 << 2,
+        0x11, 0x22, 0x33, 0x44,
+        9 << 2,
+        0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11
+      ])
+    );
+  });
+
+  it('exposes the properties for key/value', (): void => {
+    const [key, value] = registry.createType('KeyValue', ['0x11223344', '0x998877665544332211']);
+
+    expect(key.toHex()).toEqual('0x11223344');
+    expect(value.toHex()).toEqual('0x998877665544332211');
+  });
+});

package/src/interfaces/runtime/definitions.ts

@@ -0,0 +1,236 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// order important in structs... :)
+/* eslint-disable sort-keys */
+
+import type { Definitions } from '../../types/index.js';
+
+import { runtime } from './runtime.js';
+
+const numberTypes = {
+  Fixed64: 'Int<64, Fixed64>',
+  FixedI64: 'Int<64, FixedI64>',
+  FixedU64: 'UInt<64, FixedU64>',
+  Fixed128: 'Int<128, Fixed128>',
+  FixedI128: 'Int<128, FixedI128>',
+  FixedU128: 'UInt<128, FixedU128>',
+  I32F32: 'Int<64, I32F32>',
+  U32F32: 'UInt<64, U32F32>',
+  PerU16: 'UInt<16, PerU16>',
+  Perbill: 'UInt<32, Perbill>',
+  Percent: 'UInt<8, Percent>',
+  Permill: 'UInt<32, Permill>',
+  Perquintill: 'UInt<64, Perquintill>'
+};
+
+// Since we don't have insight into the origin specification, we can only define what we know about
+// in a pure Substrate/Polkadot implementation, any other custom origins won't be handled at all
+export const knownOrigins: Record<string, string> = {
+  //
+  // (1) Defaults from Substrate
+  //
+  Council: 'CollectiveOrigin',
+  System: 'SystemOrigin',
+  TechnicalCommittee: 'CollectiveOrigin',
+  //
+  // (2) Defaults from Polkadot
+  //
+  Xcm: 'XcmOrigin',
+  XcmPallet: 'XcmOrigin',
+  //
+  // (3) Defaults from Acala
+  //
+  Authority: 'AuthorityOrigin',
+  GeneralCouncil: 'CollectiveOrigin'
+};
+
+export default {
+  rpc: {},
+  runtime,
+  types: {
+    ...numberTypes,
+    AccountId: 'AccountId32',
+    AccountId20: 'GenericEthereumAccountId',
+    AccountId32: 'GenericAccountId32',
+    AccountId33: 'GenericAccountId33',
+    AccountIdOf: 'AccountId',
+    AccountIndex: 'GenericAccountIndex',
+    Address: 'MultiAddress',
+    AssetId: 'u32',
+    Balance: 'UInt<128, Balance>',
+    BalanceOf: 'Balance',
+    Block: 'GenericBlock',
+    BlockNumber: 'u32',
+    BlockNumberFor: 'BlockNumber',
+    BlockNumberOf: 'BlockNumber',
+    Call: 'GenericCall',
+    CallHash: 'Hash',
+    CallHashOf: 'CallHash',
+    ChangesTrieConfiguration: {
+      digestInterval: 'u32',
+      digestLevels: 'u32'
+    },
+    ChangesTrieSignal: {
+      _enum: {
+        NewConfiguration: 'Option<ChangesTrieConfiguration>'
+      }
+    },
+    ConsensusEngineId: 'GenericConsensusEngineId',
+    CodecHash: 'Hash',
+    CrateVersion: {
+      major: 'u16',
+      minor: 'u8',
+      patch: 'u8'
+    },
+    Digest: {
+      logs: 'Vec<DigestItem>'
+    },
+    DigestItem: {
+      _enum: {
+        Other: 'Bytes', // 0
+        AuthoritiesChange: 'Vec<AuthorityId>', // 1
+        ChangesTrieRoot: 'Hash', // 2
+        SealV0: 'SealV0', // 3
+        Consensus: 'Consensus', // 4
+        Seal: 'Seal', // 5
+        PreRuntime: 'PreRuntime', // 6
+        ChangesTrieSignal: 'ChangesTrieSignal', // 7
+        RuntimeEnvironmentUpdated: 'Null' // 8
+      }
+    },
+    ExtrinsicsWeight: {
+      normal: 'Weight',
+      operational: 'Weight'
+    },
+    H32: '[u8; 4; H32]',
+    H64: '[u8; 8; H64]',
+    H128: '[u8; 16; H128]',
+    H160: '[u8; 20; H160]',
+    H256: '[u8; 32; H256]',
+    H512: '[u8; 64; H512]',
+    H1024: '[u8; 128; H1024]',
+    H2048: '[u8; 256; H2048]',
+    Hash: 'H256',
+    Header: {
+      parentHash: 'Hash',
+      number: 'Compact<BlockNumber>',
+      stateRoot: 'Hash',
+      extrinsicsRoot: 'Hash',
+      digest: 'Digest'
+    },
+    HeaderPartial: {
+      parentHash: 'Hash',
+      // since we only parse JSON with this, having non-compact works
+      number: 'BlockNumber'
+    },
+    IndicesLookupSource: 'GenericLookupSource',
+    Index: 'u32',
+    Justification: '(ConsensusEngineId, EncodedJustification)',
+    EncodedJustification: 'Bytes',
+    Justifications: 'Vec<Justification>',
+    KeyValue: '(StorageKey, StorageData)',
+    KeyTypeId: 'u32',
+    LockIdentifier: '[u8; 8]',
+    LookupSource: 'MultiAddress',
+    LookupTarget: 'AccountId',
+    ModuleId: 'LockIdentifier',
+    MultiAddress: 'GenericMultiAddress',
+    MultiSigner: {
+      _enum: {
+        Ed25519: '[u8; 32]',
+        Sr25519: '[u8; 32]',
+        Ecdsa: '[u8; 33]'
+      }
+    },
+    Moment: 'UInt<64, Moment>',
+    OpaqueCall: 'Bytes',
+    Origin: 'DoNotConstruct<Origin>',
+    OriginCaller: {
+      _enum: {
+        // this should be dynamically built from the actual modules, based on index
+        System: 'SystemOrigin'
+      }
+    },
+    PalletId: 'LockIdentifier',
+    PalletsOrigin: 'OriginCaller',
+    PalletVersion: {
+      major: 'u16',
+      minor: 'u8',
+      patch: 'u8'
+    },
+    Pays: {
+      _enum: ['Yes', 'No']
+    },
+    Phantom: 'Null',
+    PhantomData: 'Null',
+    Releases: {
+      _enum: ['V1', 'V2', 'V3', 'V4', 'V5', 'V6', 'V7', 'V8', 'V9', 'V10']
+    },
+    RuntimeCall: 'Call',
+    RuntimeEvent: 'Event',
+    RuntimeDbWeight: {
+      read: 'Weight',
+      write: 'Weight'
+    },
+    SignedBlock: 'SignedBlockWithJustifications',
+    SignedBlockWithJustification: {
+      block: 'Block',
+      justification: 'Option<EncodedJustification>'
+    },
+    SignedBlockWithJustifications: {
+      block: 'Block',
+      justifications: 'Option<Justifications>'
+    },
+    Slot: 'u64',
+    SlotDuration: 'u64',
+    StorageData: 'Bytes',
+    StorageInfo: {
+      palletName: 'Bytes',
+      storage_name: 'Bytes',
+      prefix: 'Bytes',
+      maxValues: 'Option<u32>',
+      maxSize: 'Option<u32>'
+    },
+    StorageProof: {
+      trieNodes: 'Vec<Bytes>'
+    },
+    TransactionPriority: 'u64',
+    TransactionLongevity: 'u64',
+    TransactionTag: 'Bytes',
+    TransactionInfo: {
+      _alias: {
+        dataSize: 'size'
+      },
+      chunkRoot: 'H256',
+      contentHash: 'H256',
+      dataSize: 'u32',
+      blockChunks: 'u32'
+    },
+    TransactionStorageProof: {
+      chunk: 'Vec<u8>',
+      proof: 'Vec<Vec<u8>>'
+    },
+    ValidatorId: 'AccountId',
+    ValidatorIdOf: 'ValidatorId',
+    WeightV0: 'u32',
+    WeightV1: 'u64',
+    WeightV2: {
+      refTime: 'Compact<u64>',
+      proofSize: 'Compact<u64>'
+    },
+    Weight: 'WeightV2',
+    WeightMultiplier: 'Fixed64',
+
+    // digest
+    PreRuntime: '(ConsensusEngineId, Bytes)',
+    SealV0: '(u64, Signature)',
+    Seal: '(ConsensusEngineId, Bytes)',
+    Consensus: '(ConsensusEngineId, Bytes)',
+
+    // Type when core initialize_block went from v4 to v5
+    ExtrinsicInclusionMode: {
+      _enum: ['AllExtrinsics', 'OnlyInherents']
+    }
+  }
+} as Definitions;

package/src/interfaces/runtime/index.ts

@@ -0,0 +1,4 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+export * from './types.js';

package/src/interfaces/runtime/runtime.ts

@@ -0,0 +1,117 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DefinitionsCall, DefinitionsCallEntry } from '../../types/index.js';
+
+const CORE_V1_TO_V4: DefinitionsCallEntry['methods'] = {
+  execute_block: {
+    description: 'Execute the given block.',
+    params: [
+      {
+        name: 'block',
+        type: 'Block'
+      }
+    ],
+    type: 'Null'
+  }
+};
+
+const CORE_V1_TO_V2: DefinitionsCallEntry['methods'] = {
+  version: {
+    description: 'Returns the version of the runtime.',
+    params: [],
+    type: 'RuntimeVersionPre3'
+  }
+};
+
+const CORE_V2_TO_V4: DefinitionsCallEntry['methods'] = {
+  initialize_block: {
+    description: 'Initialize a block with the given header.',
+    params: [
+      {
+        name: 'header',
+        type: 'Header'
+      }
+    ],
+    type: 'Null'
+  }
+};
+
+const CORE_V4_VERSION: DefinitionsCallEntry['methods'] = {
+  version: {
+    description: 'Returns the version of the runtime.',
+    params: [],
+    type: 'RuntimeVersion'
+  }
+};
+
+const CORE_V4_TO_V5: DefinitionsCallEntry['methods'] = {
+  ...CORE_V1_TO_V4,
+  initialize_block: {
+    description: 'Initialize a block with the given header.',
+    params: [
+      {
+        name: 'header',
+        type: 'Header'
+      }
+    ],
+    type: 'ExtrinsicInclusionMode'
+  }
+};
+
+export const runtime: DefinitionsCall = {
+  Core: [
+    {
+      methods: {
+        ...CORE_V4_VERSION,
+        ...CORE_V4_TO_V5
+      },
+      version: 5
+    },
+    {
+      methods: {
+        ...CORE_V4_VERSION,
+        ...CORE_V1_TO_V4,
+        ...CORE_V2_TO_V4
+      },
+      version: 4
+    },
+    {
+      methods: {
+        version: {
+          description: 'Returns the version of the runtime.',
+          params: [],
+          type: 'RuntimeVersionPre4'
+        },
+        ...CORE_V1_TO_V4,
+        ...CORE_V2_TO_V4
+      },
+      version: 3
+    },
+    {
+      methods: {
+        ...CORE_V1_TO_V2,
+        ...CORE_V1_TO_V4,
+        ...CORE_V2_TO_V4
+      },
+      version: 2
+    },
+    {
+      methods: {
+        initialise_block: {
+          description: 'Initialize a block with the given header.',
+          params: [
+            {
+              name: 'header',
+              type: 'Header'
+            }
+          ],
+          type: 'Null'
+        },
+        ...CORE_V1_TO_V2,
+        ...CORE_V1_TO_V4
+      },
+      version: 1
+    }
+  ]
+};