@pezkuwi/types 16.5.8 → 16.5.9

package/src/interfaces/rpc/rpc.ts

@@ -1,12 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { DefinitionsRpc } from '../../types/index.js';
-
-export const rpc: DefinitionsRpc = {
-  methods: {
-    description: 'Retrieves the list of RPC methods that are exposed by the node',
-    params: [],
-    type: 'RpcMethods'
-  }
-};

package/src/interfaces/rpc/types.ts

@@ -1,12 +0,0 @@
-// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
-/* eslint-disable */
-
-import type { Struct, Text, Vec, u32 } from '@pezkuwi/types-codec';
-
-/** @name RpcMethods */
-export interface RpcMethods extends Struct {
-  readonly version: u32;
-  readonly methods: Vec<Text>;
-}
-
-export type PHANTOM_RPC = 'rpc';

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

@@ -1,34 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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 json3 from '@pezkuwi/types-support/json/Header.003.json' assert { type: 'json' };
-
-import { TypeRegistry } from '../../create/index.js';
-
-describe('Digest', (): void => {
-  const registry = new TypeRegistry();
-
-  it('has the correct JSON representation', (): void => {
-    const digest = registry.createType('Digest', json3.result.digest);
-
-    expect(digest.logs.map((l) => l.toHex())).toEqual(json3.result.digest.logs);
-  });
-
-  it('decodes logs with consensus', (): void => {
-    const digest = registry.createType('Digest', json3.result.digest);
-
-    expect(digest.logs.length).toEqual(1);
-
-    const log = digest.logs[0];
-
-    expect(log.type).toBe('Consensus');
-    expect(log.value.toJSON()).toEqual([
-      '0x61757261',
-      '0x69c97e0f00000000479c09f7ace12ed3e1af2dba6cca6831e257e80feef56c7474d6c69bae6f4e8a6e0045a87afe14296992c38b7d55abcbe617c441cd35e8667abbcb1678f31802'
-    ]);
-  });
-});

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

@@ -1,64 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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

@@ -1,41 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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

@@ -1,236 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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 Bizinikiwi/Pezkuwi implementation, any other custom origins won't be handled at all
-export const knownOrigins: Record<string, string> = {
-  //
-  // (1) Defaults from Bizinikiwi
-  //
-  Council: 'CollectiveOrigin',
-  System: 'SystemOrigin',
-  TechnicalCommittee: 'CollectiveOrigin',
-  //
-  // (2) Defaults from Pezkuwi
-  //
-  Xcm: 'XcmOrigin',
-  XcmPezpallet: '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'
-      }
-    },
-    PezpalletId: 'LockIdentifier',
-    PezpalletsOrigin: 'OriginCaller',
-    PezpalletVersion: {
-      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

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

package/src/interfaces/runtime/runtime.ts

@@ -1,117 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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
-    }
-  ]
-};