@pezkuwi/types 16.5.5

package/src/interfaces/assets/definitions.ts

@@ -0,0 +1,57 @@
+// 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';
+
+export default {
+  rpc: {},
+  runtime,
+  types: {
+    AssetApprovalKey: {
+      owner: 'AccountId',
+      delegate: 'AccountId'
+    },
+    AssetApproval: {
+      amount: 'TAssetBalance',
+      deposit: 'TAssetDepositBalance'
+    },
+    AssetBalance: {
+      balance: 'TAssetBalance',
+      isFrozen: 'bool',
+      isSufficient: 'bool'
+    },
+    AssetDestroyWitness: {
+      accounts: 'Compact<u32>',
+      sufficients: 'Compact<u32>',
+      approvals: 'Compact<u32>'
+    },
+    AssetDetails: {
+      owner: 'AccountId',
+      issuer: 'AccountId',
+      admin: 'AccountId',
+      freezer: 'AccountId',
+      supply: 'TAssetBalance',
+      deposit: 'TAssetDepositBalance',
+      minBalance: 'TAssetBalance',
+      isSufficient: 'bool',
+      accounts: 'u32',
+      sufficients: 'u32',
+      approvals: 'u32',
+      isFrozen: 'bool'
+    },
+    AssetMetadata: {
+      deposit: 'TAssetDepositBalance',
+      name: 'Vec<u8>',
+      symbol: 'Vec<u8>',
+      decimals: 'u8',
+      isFrozen: 'bool'
+    },
+    TAssetBalance: 'u64',
+    TAssetDepositBalance: 'BalanceOf'
+  }
+} as Definitions;

package/src/interfaces/assets/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/assets/runtime.ts

@@ -0,0 +1,24 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DefinitionsCall } from '../../types/index.js';
+
+export const runtime: DefinitionsCall = {
+  AssetsApi: [
+    {
+      methods: {
+        account_balances: {
+          description: 'Return the current set of authorities.',
+          params: [
+            {
+              name: 'account',
+              type: 'AccountId'
+            }
+          ],
+          type: 'Vec<(u32, TAssetBalance)>'
+        }
+      },
+      version: 1
+    }
+  ]
+};

package/src/interfaces/assets/types.ts

@@ -0,0 +1,64 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Bytes, Compact, Struct, bool, u32, u64, u8 } from '@pezkuwi/types-codec';
+import type { AccountId, BalanceOf } from '@pezkuwi/types/interfaces/runtime';
+
+/** @name AssetApproval */
+export interface AssetApproval extends Struct {
+  readonly amount: TAssetBalance;
+  readonly deposit: TAssetDepositBalance;
+}
+
+/** @name AssetApprovalKey */
+export interface AssetApprovalKey extends Struct {
+  readonly owner: AccountId;
+  readonly delegate: AccountId;
+}
+
+/** @name AssetBalance */
+export interface AssetBalance extends Struct {
+  readonly balance: TAssetBalance;
+  readonly isFrozen: bool;
+  readonly isSufficient: bool;
+}
+
+/** @name AssetDestroyWitness */
+export interface AssetDestroyWitness extends Struct {
+  readonly accounts: Compact<u32>;
+  readonly sufficients: Compact<u32>;
+  readonly approvals: Compact<u32>;
+}
+
+/** @name AssetDetails */
+export interface AssetDetails extends Struct {
+  readonly owner: AccountId;
+  readonly issuer: AccountId;
+  readonly admin: AccountId;
+  readonly freezer: AccountId;
+  readonly supply: TAssetBalance;
+  readonly deposit: TAssetDepositBalance;
+  readonly minBalance: TAssetBalance;
+  readonly isSufficient: bool;
+  readonly accounts: u32;
+  readonly sufficients: u32;
+  readonly approvals: u32;
+  readonly isFrozen: bool;
+}
+
+/** @name AssetMetadata */
+export interface AssetMetadata extends Struct {
+  readonly deposit: TAssetDepositBalance;
+  readonly name: Bytes;
+  readonly symbol: Bytes;
+  readonly decimals: u8;
+  readonly isFrozen: bool;
+}
+
+/** @name TAssetBalance */
+export interface TAssetBalance extends u64 {}
+
+/** @name TAssetDepositBalance */
+export interface TAssetDepositBalance extends BalanceOf {}
+
+export type PHANTOM_ASSETS = 'assets';

package/src/interfaces/attestations/definitions.ts

@@ -0,0 +1,26 @@
+// 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';
+
+export default {
+  rpc: {},
+  types: {
+    BlockAttestations: {
+      receipt: 'CandidateReceipt',
+      valid: 'Vec<AccountId>',
+      invalid: 'Vec<AccountId>'
+    },
+    IncludedBlocks: {
+      actualNumber: 'BlockNumber',
+      session: 'SessionIndex',
+      randomSeed: 'H256',
+      activeParachains: 'Vec<ParaId>',
+      paraBlocks: 'Vec<Hash>'
+    },
+    MoreAttestations: {}
+  }
+} as Definitions;

package/src/interfaces/attestations/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/attestations/types.ts

@@ -0,0 +1,28 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Struct, Vec } from '@pezkuwi/types-codec';
+import type { CandidateReceipt, ParaId } from '@pezkuwi/types/interfaces/parachains';
+import type { AccountId, BlockNumber, H256, Hash } from '@pezkuwi/types/interfaces/runtime';
+import type { SessionIndex } from '@pezkuwi/types/interfaces/session';
+
+/** @name BlockAttestations */
+export interface BlockAttestations extends Struct {
+  readonly receipt: CandidateReceipt;
+  readonly valid: Vec<AccountId>;
+  readonly invalid: Vec<AccountId>;
+}
+
+/** @name IncludedBlocks */
+export interface IncludedBlocks extends Struct {
+  readonly actualNumber: BlockNumber;
+  readonly session: SessionIndex;
+  readonly randomSeed: H256;
+  readonly activeParachains: Vec<ParaId>;
+  readonly paraBlocks: Vec<Hash>;
+}
+
+/** @name MoreAttestations */
+export interface MoreAttestations extends Struct {}
+
+export type PHANTOM_ATTESTATIONS = 'attestations';

package/src/interfaces/aura/definitions.ts

@@ -0,0 +1,19 @@
+// 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';
+
+export default {
+  rpc: {},
+  runtime,
+  types: {
+    RawAuraPreDigest: {
+      slotNumber: 'u64'
+    }
+  }
+} as Definitions;

package/src/interfaces/aura/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/aura/runtime.ts

@@ -0,0 +1,24 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DefinitionsCall } from '../../types/index.js';
+
+export const runtime: DefinitionsCall = {
+  AuraApi: [
+    {
+      methods: {
+        authorities: {
+          description: 'Return the current set of authorities.',
+          params: [],
+          type: 'Vec<AuthorityId>'
+        },
+        slot_duration: {
+          description: 'Returns the slot duration for Aura.',
+          params: [],
+          type: 'SlotDuration'
+        }
+      },
+      version: 1
+    }
+  ]
+};

package/src/interfaces/aura/types.ts

@@ -0,0 +1,11 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Struct, u64 } from '@pezkuwi/types-codec';
+
+/** @name RawAuraPreDigest */
+export interface RawAuraPreDigest extends Struct {
+  readonly slotNumber: u64;
+}
+
+export type PHANTOM_AURA = 'aura';

package/src/interfaces/author/ExtrinsicStatus.spec.ts

@@ -0,0 +1,33 @@
+// 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 type { ExtrinsicStatus } from './types.js';
+
+import rpc from '@pezkuwi/types-support/json/ExtrinsicStatus.001.json' assert { type: 'json' };
+
+import { TypeRegistry } from '../../create/index.js';
+
+describe('ExtrinsicStatus', (): void => {
+  const registry = new TypeRegistry();
+  let status: ExtrinsicStatus;
+
+  beforeEach((): void => {
+    status = registry.createType('ExtrinsicStatus', rpc.params.result);
+  });
+
+  it('has the correct type', (): void => {
+    expect(
+      status.type
+    ).toEqual('Finalized');
+  });
+
+  it('has the correct hash', (): void => {
+    expect(
+      status.value.toString()
+    ).toEqual('0xc465b92a72b1d20918d64cd4effa70c2bb58b53a3f8c24c3ac8fd8f465f059b4');
+  });
+});

package/src/interfaces/author/definitions.ts

@@ -0,0 +1,35 @@
+// 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 { rpc } from './rpc.js';
+
+export default {
+  rpc,
+  types: {
+    ExtrinsicOrHash: {
+      _enum: {
+        Hash: 'Hash',
+        Extrinsic: 'Bytes'
+      }
+    },
+    ExtrinsicStatus: {
+      _enum: {
+        Future: 'Null',
+        Ready: 'Null',
+        Broadcast: 'Vec<Text>',
+        InBlock: 'Hash',
+        Retracted: 'Hash',
+        FinalityTimeout: 'Hash',
+        Finalized: 'Hash',
+        Usurped: 'Hash',
+        Dropped: 'Null',
+        Invalid: 'Null'
+      }
+    }
+  }
+} as Definitions;

package/src/interfaces/author/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/author/rpc.ts

@@ -0,0 +1,101 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DefinitionsRpc } from '../../types/index.js';
+
+export const rpc: DefinitionsRpc = {
+  hasKey: {
+    description: 'Returns true if the keystore has private keys for the given public key and key type.',
+    isUnsafe: true,
+    params: [
+      {
+        name: 'publicKey',
+        type: 'Bytes'
+      },
+      {
+        name: 'keyType',
+        type: 'Text'
+      }
+    ],
+    type: 'bool'
+  },
+  hasSessionKeys: {
+    description: 'Returns true if the keystore has private keys for the given session public keys.',
+    isUnsafe: true,
+    params: [
+      {
+        name: 'sessionKeys',
+        type: 'Bytes'
+      }
+    ],
+    type: 'bool'
+  },
+  insertKey: {
+    description: 'Insert a key into the keystore.',
+    isUnsafe: true,
+    params: [
+      {
+        name: 'keyType',
+        type: 'Text'
+      },
+      {
+        name: 'suri',
+        type: 'Text'
+      },
+      {
+        name: 'publicKey',
+        type: 'Bytes'
+      }
+    ],
+    type: 'Bytes'
+  },
+  pendingExtrinsics: {
+    description: 'Returns all pending extrinsics, potentially grouped by sender',
+    params: [],
+    type: 'Vec<Extrinsic>'
+  },
+  removeExtrinsic: {
+    description: 'Remove given extrinsic from the pool and temporarily ban it to prevent reimporting',
+    isUnsafe: true,
+    params: [
+      {
+        name: 'bytesOrHash',
+        type: 'Vec<ExtrinsicOrHash>'
+      }
+    ],
+    type: 'Vec<Hash>'
+  },
+  rotateKeys: {
+    description: 'Generate new session keys and returns the corresponding public keys',
+    isUnsafe: true,
+    params: [],
+    type: 'Bytes'
+  },
+  submitAndWatchExtrinsic: {
+    description: 'Submit and subscribe to watch an extrinsic until unsubscribed',
+    isSigned: true,
+    params: [
+      {
+        name: 'extrinsic',
+        type: 'Extrinsic'
+      }
+    ],
+    pubsub: [
+      'extrinsicUpdate',
+      'submitAndWatchExtrinsic',
+      'unwatchExtrinsic'
+    ],
+    type: 'ExtrinsicStatus'
+  },
+  submitExtrinsic: {
+    description: 'Submit a fully formatted extrinsic for block inclusion',
+    isSigned: true,
+    params: [
+      {
+        name: 'extrinsic',
+        type: 'Extrinsic'
+      }
+    ],
+    type: 'Hash'
+  }
+};

package/src/interfaces/author/types.ts

@@ -0,0 +1,37 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Bytes, Enum, Text, Vec } from '@pezkuwi/types-codec';
+import type { Hash } from '@pezkuwi/types/interfaces/runtime';
+
+/** @name ExtrinsicOrHash */
+export interface ExtrinsicOrHash extends Enum {
+  readonly isHash: boolean;
+  readonly asHash: Hash;
+  readonly isExtrinsic: boolean;
+  readonly asExtrinsic: Bytes;
+  readonly type: 'Hash' | 'Extrinsic';
+}
+
+/** @name ExtrinsicStatus */
+export interface ExtrinsicStatus extends Enum {
+  readonly isFuture: boolean;
+  readonly isReady: boolean;
+  readonly isBroadcast: boolean;
+  readonly asBroadcast: Vec<Text>;
+  readonly isInBlock: boolean;
+  readonly asInBlock: Hash;
+  readonly isRetracted: boolean;
+  readonly asRetracted: Hash;
+  readonly isFinalityTimeout: boolean;
+  readonly asFinalityTimeout: Hash;
+  readonly isFinalized: boolean;
+  readonly asFinalized: Hash;
+  readonly isUsurped: boolean;
+  readonly asUsurped: Hash;
+  readonly isDropped: boolean;
+  readonly isInvalid: boolean;
+  readonly type: 'Future' | 'Ready' | 'Broadcast' | 'InBlock' | 'Retracted' | 'FinalityTimeout' | 'Finalized' | 'Usurped' | 'Dropped' | 'Invalid';
+}
+
+export type PHANTOM_AUTHOR = 'author';

package/src/interfaces/authorship/definitions.ts

@@ -0,0 +1,19 @@
+// 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';
+
+export default {
+  rpc: {},
+  types: {
+    UncleEntryItem: {
+      _enum: {
+        InclusionHeight: 'BlockNumber',
+        Uncle: '(Hash, Option<AccountId>)'
+      }
+    }
+  }
+} as Definitions;

package/src/interfaces/authorship/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/authorship/types.ts

@@ -0,0 +1,17 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Enum, Option } from '@pezkuwi/types-codec';
+import type { ITuple } from '@pezkuwi/types-codec/types';
+import type { AccountId, BlockNumber, Hash } from '@pezkuwi/types/interfaces/runtime';
+
+/** @name UncleEntryItem */
+export interface UncleEntryItem extends Enum {
+  readonly isInclusionHeight: boolean;
+  readonly asInclusionHeight: BlockNumber;
+  readonly isUncle: boolean;
+  readonly asUncle: ITuple<[Hash, Option<AccountId>]>;
+  readonly type: 'InclusionHeight' | 'Uncle';
+}
+
+export type PHANTOM_AUTHORSHIP = 'authorship';

package/src/interfaces/babe/definitions.ts

@@ -0,0 +1,134 @@
+// 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 { rpc } from './rpc.js';
+import { runtime } from './runtime.js';
+
+export default {
+  rpc,
+  runtime,
+  types: {
+    AllowedSlots: {
+      _enum: ['PrimarySlots', 'PrimaryAndSecondaryPlainSlots', 'PrimaryAndSecondaryVRFSlots']
+    },
+    BabeAuthorityWeight: 'u64',
+    BabeEpochConfiguration: {
+      c: '(u64, u64)',
+      allowedSlots: 'AllowedSlots'
+    },
+    BabeBlockWeight: 'u32',
+    BabeEquivocationProof: {
+      offender: 'AuthorityId',
+      slotNumber: 'SlotNumber',
+      firstHeader: 'Header',
+      secondHeader: 'Header'
+    },
+    BabeGenesisConfiguration: {
+      slotDuration: 'u64',
+      epochLength: 'u64',
+      c: '(u64, u64)',
+      genesisAuthorities: 'Vec<(AuthorityId, BabeAuthorityWeight)>',
+      randomness: 'Randomness',
+      allowedSlots: 'AllowedSlots'
+    },
+    BabeGenesisConfigurationV1: {
+      slotDuration: 'u64',
+      epochLength: 'u64',
+      c: '(u64, u64)',
+      genesisAuthorities: 'Vec<(AuthorityId, BabeAuthorityWeight)>',
+      randomness: 'Randomness',
+      secondarySlots: 'bool'
+    },
+    BabeWeight: 'u64',
+    MaybeRandomness: 'Option<Randomness>',
+    MaybeVrf: 'Option<VrfData>',
+    Epoch: {
+      epochIndex: 'u64',
+      startSlot: 'Slot',
+      duration: 'u64',
+      authorities: 'Vec<(AuthorityId, BabeAuthorityWeight)>',
+      randomness: 'Hash', // [u8; VRF_OUTPUT_LENGTH],
+      config: 'BabeEpochConfiguration'
+    },
+    EpochAuthorship: {
+      primary: 'Vec<u64>',
+      secondary: 'Vec<u64>',
+      secondary_vrf: 'Vec<u64>'
+    },
+    NextConfigDescriptor: {
+      _enum: {
+        V0: 'Null',
+        V1: 'NextConfigDescriptorV1'
+      }
+    },
+    NextConfigDescriptorV1: {
+      c: '(u64, u64)',
+      allowedSlots: 'AllowedSlots'
+    },
+    OpaqueKeyOwnershipProof: 'Bytes',
+    Randomness: 'Hash', // [u8; RANDOMNESS_LENGTH],
+    RawBabePreDigest: {
+      _enum: {
+        Phantom: 'Null', // index starts at 1... empty slot at 0
+        Primary: 'RawBabePreDigestPrimary',
+        SecondaryPlain: 'RawBabePreDigestSecondaryPlain',
+        SecondaryVRF: 'RawBabePreDigestSecondaryVRF'
+      }
+    },
+    RawBabePreDigestPrimary: {
+      authorityIndex: 'u32', // AuthorityIndex (also in aura)
+      slotNumber: 'SlotNumber',
+      vrfOutput: 'VrfOutput',
+      vrfProof: 'VrfProof'
+    },
+    RawBabePreDigestSecondaryPlain: {
+      authorityIndex: 'u32', // AuthorityIndex (also in aura)
+      slotNumber: 'SlotNumber'
+    },
+    RawBabePreDigestSecondaryVRF: {
+      authorityIndex: 'u32',
+      slotNumber: 'SlotNumber',
+      vrfOutput: 'VrfOutput',
+      vrfProof: 'VrfProof'
+    },
+    RawBabePreDigestTo159: {
+      _enum: {
+        Primary: 'RawBabePreDigestPrimaryTo159',
+        Secondary: 'RawBabePreDigestSecondaryTo159'
+      }
+    },
+    RawBabePreDigestPrimaryTo159: {
+      authorityIndex: 'u32',
+      slotNumber: 'SlotNumber',
+      weight: 'BabeBlockWeight',
+      vrfOutput: 'VrfOutput',
+      vrfProof: 'VrfProof'
+    },
+    RawBabePreDigestSecondaryTo159: {
+      authorityIndex: 'u32',
+      slotNumber: 'SlotNumber',
+      weight: 'BabeBlockWeight'
+    },
+    // a cross old/new compatible version of the digest, that is _only_ useful
+    // for partial parsing and extraction of the author. This assumes that all
+    // entries has the authorityIndex in the first position - and that it is all
+    // we are interested in
+    RawBabePreDigestCompat: {
+      _enum: {
+        Zero: 'u32',
+        One: 'u32',
+        Two: 'u32',
+        Three: 'u32'
+      }
+    },
+    SlotNumber: 'u64',
+    VrfData: '[u8; 32]',
+    VrfOutput: '[u8; 32]',
+    VrfProof: '[u8; 64]'
+  }
+} as Definitions;

package/src/interfaces/babe/index.ts

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