@pezkuwi/types 16.5.5

package/src/interfaces/grandpa/definitions.ts

@@ -0,0 +1,140 @@
+// 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: {
+    AuthorityIndex: 'u64',
+    AuthorityList: 'Vec<NextAuthority>',
+    AuthoritySet: {
+      currentAuthorities: 'AuthorityList',
+      setId: 'u64',
+      pendingStandardChanges: 'ForkTreePendingChange',
+      pendingForcedChanges: 'Vec<PendingChange>',
+      authoritySetChanges: 'AuthoritySetChanges'
+    },
+    ForkTreePendingChange: {
+      roots: 'Vec<ForkTreePendingChangeNode>',
+      bestFinalizedNumber: 'Option<BlockNumber>'
+    },
+    ForkTreePendingChangeNode: {
+      hash: 'BlockHash',
+      number: 'BlockNumber',
+      data: 'PendingChange', // actual data, here PendingChange
+      children: 'Vec<ForkTreePendingChangeNode>'
+    },
+    AuthoritySetChange: '(U64, BlockNumber)',
+    AuthoritySetChanges: 'Vec<AuthoritySetChange>',
+    AuthorityWeight: 'u64',
+    DelayKind: {
+      _enum: {
+        Finalized: 'Null',
+        Best: 'DelayKindBest'
+      }
+    },
+    DelayKindBest: {
+      medianLastFinalized: 'BlockNumber'
+    },
+    EncodedFinalityProofs: 'Bytes',
+    GrandpaEquivocation: {
+      _enum: {
+        Prevote: 'GrandpaEquivocationValue',
+        Precommit: 'GrandpaEquivocationValue'
+      }
+    },
+    GrandpaEquivocationProof: {
+      setId: 'SetId',
+      equivocation: 'GrandpaEquivocation'
+    },
+    GrandpaEquivocationValue: {
+      roundNumber: 'u64',
+      identity: 'AuthorityId',
+      first: '(GrandpaPrevote, AuthoritySignature)',
+      second: '(GrandpaPrevote, AuthoritySignature)'
+    },
+    GrandpaPrevote: {
+      targetHash: 'Hash',
+      targetNumber: 'BlockNumber'
+    },
+    GrandpaCommit: {
+      targetHash: 'BlockHash',
+      targetNumber: 'BlockNumber',
+      precommits: 'Vec<GrandpaSignedPrecommit>'
+    },
+    GrandpaPrecommit: {
+      targetHash: 'BlockHash',
+      targetNumber: 'BlockNumber'
+    },
+    GrandpaSignedPrecommit: {
+      precommit: 'GrandpaPrecommit',
+      signature: 'AuthoritySignature',
+      id: 'AuthorityId'
+    },
+    GrandpaJustification: {
+      round: 'u64',
+      commit: 'GrandpaCommit',
+      votesAncestries: 'Vec<Header>'
+    },
+    JustificationNotification: 'Bytes',
+    KeyOwnerProof: 'MembershipProof',
+    NextAuthority: '(AuthorityId, AuthorityWeight)',
+    PendingChange: {
+      nextAuthorities: 'AuthorityList',
+      delay: 'BlockNumber',
+      canonHeight: 'BlockNumber',
+      canonHash: 'BlockHash',
+      delayKind: 'DelayKind'
+    },
+    PendingPause: {
+      scheduledAt: 'BlockNumber',
+      delay: 'BlockNumber'
+    },
+    PendingResume: {
+      scheduledAt: 'BlockNumber',
+      delay: 'BlockNumber'
+    },
+    Precommits: {
+      currentWeight: 'u32',
+      missing: 'BTreeSet<AuthorityId>'
+    },
+    Prevotes: {
+      currentWeight: 'u32',
+      missing: 'BTreeSet<AuthorityId>'
+    },
+    ReportedRoundStates: {
+      setId: 'u32',
+      best: 'RoundState',
+      background: 'Vec<RoundState>'
+    },
+    RoundState: {
+      round: 'u32',
+      totalWeight: 'u32',
+      thresholdWeight: 'u32',
+      prevotes: 'Prevotes',
+      precommits: 'Precommits'
+    },
+    SetId: 'u64',
+    StoredPendingChange: {
+      scheduledAt: 'BlockNumber',
+      delay: 'BlockNumber',
+      nextAuthorities: 'AuthorityList'
+    },
+    StoredState: {
+      _enum: {
+        Live: 'Null',
+        PendingPause: 'PendingPause',
+        Paused: 'Null',
+        PendingResume: 'PendingResume'
+      }
+    }
+  }
+} as Definitions;

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

@@ -0,0 +1,32 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DefinitionsRpc } from '../../types/index.js';
+
+export const rpc: DefinitionsRpc = {
+  proveFinality: {
+    description: 'Prove finality for the given block number, returning the Justification for the last block in the set.',
+    params: [
+      {
+        name: 'blockNumber',
+        type: 'BlockNumber'
+      }
+    ],
+    type: 'Option<EncodedFinalityProofs>'
+  },
+  roundState: {
+    description: 'Returns the state of the current best round state as well as the ongoing background rounds',
+    params: [],
+    type: 'ReportedRoundStates'
+  },
+  subscribeJustifications: {
+    description: 'Subscribes to grandpa justifications',
+    params: [],
+    pubsub: [
+      'justifications',
+      'subscribeJustifications',
+      'unsubscribeJustifications'
+    ],
+    type: 'JustificationNotification'
+  }
+};

package/src/interfaces/grandpa/runtime.ts

@@ -0,0 +1,60 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DefinitionsCall, DefinitionsCallEntry } from '../../types/index.js';
+
+const GRANDPA_V2_V3: DefinitionsCallEntry['methods'] = {
+  generate_key_ownership_proof: {
+    description: 'Generates a proof of key ownership for the given authority in the given set.',
+    params: [
+      {
+        name: 'setId',
+        type: 'SetId'
+      },
+      {
+        name: 'authorityId',
+        type: 'AuthorityId'
+      }
+    ],
+    type: 'Option<OpaqueKeyOwnershipProof>'
+  },
+  grandpa_authorities: {
+    description: 'Get the current GRANDPA authorities and weights. This should not change except for when changes are scheduled and the corresponding delay has passed.',
+    params: [],
+    type: 'AuthorityList'
+  },
+  submit_report_equivocation_unsigned_extrinsic: {
+    description: 'Submits an unsigned extrinsic to report an equivocation.',
+    params: [
+      {
+        name: 'equivocationProof',
+        type: 'GrandpaEquivocationProof'
+      },
+      {
+        name: 'keyOwnerProof',
+        type: 'OpaqueKeyOwnershipProof'
+      }
+    ],
+    type: 'Option<Null>'
+  }
+};
+
+export const runtime: DefinitionsCall = {
+  GrandpaApi: [
+    {
+      methods: {
+        current_set_id: {
+          description: 'Get current GRANDPA authority set id.',
+          params: [],
+          type: 'SetId'
+        },
+        ...GRANDPA_V2_V3
+      },
+      version: 3
+    },
+    {
+      methods: GRANDPA_V2_V3,
+      version: 2
+    }
+  ]
+};

package/src/interfaces/grandpa/types.ts

@@ -0,0 +1,201 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { BTreeSet, Bytes, Enum, Option, Struct, U64, Vec, u32, u64 } from '@pezkuwi/types-codec';
+import type { ITuple } from '@pezkuwi/types-codec/types';
+import type { BlockHash } from '@pezkuwi/types/interfaces/chain';
+import type { AuthorityId } from '@pezkuwi/types/interfaces/consensus';
+import type { AuthoritySignature } from '@pezkuwi/types/interfaces/imOnline';
+import type { BlockNumber, Hash, Header } from '@pezkuwi/types/interfaces/runtime';
+import type { MembershipProof } from '@pezkuwi/types/interfaces/session';
+
+/** @name AuthorityIndex */
+export interface AuthorityIndex extends u64 {}
+
+/** @name AuthorityList */
+export interface AuthorityList extends Vec<NextAuthority> {}
+
+/** @name AuthoritySet */
+export interface AuthoritySet extends Struct {
+  readonly currentAuthorities: AuthorityList;
+  readonly setId: u64;
+  readonly pendingStandardChanges: ForkTreePendingChange;
+  readonly pendingForcedChanges: Vec<PendingChange>;
+  readonly authoritySetChanges: AuthoritySetChanges;
+}
+
+/** @name AuthoritySetChange */
+export interface AuthoritySetChange extends ITuple<[U64, BlockNumber]> {}
+
+/** @name AuthoritySetChanges */
+export interface AuthoritySetChanges extends Vec<AuthoritySetChange> {}
+
+/** @name AuthorityWeight */
+export interface AuthorityWeight extends u64 {}
+
+/** @name DelayKind */
+export interface DelayKind extends Enum {
+  readonly isFinalized: boolean;
+  readonly isBest: boolean;
+  readonly asBest: DelayKindBest;
+  readonly type: 'Finalized' | 'Best';
+}
+
+/** @name DelayKindBest */
+export interface DelayKindBest extends Struct {
+  readonly medianLastFinalized: BlockNumber;
+}
+
+/** @name EncodedFinalityProofs */
+export interface EncodedFinalityProofs extends Bytes {}
+
+/** @name ForkTreePendingChange */
+export interface ForkTreePendingChange extends Struct {
+  readonly roots: Vec<ForkTreePendingChangeNode>;
+  readonly bestFinalizedNumber: Option<BlockNumber>;
+}
+
+/** @name ForkTreePendingChangeNode */
+export interface ForkTreePendingChangeNode extends Struct {
+  readonly hash: BlockHash;
+  readonly number: BlockNumber;
+  readonly data: PendingChange;
+  readonly children: Vec<ForkTreePendingChangeNode>;
+}
+
+/** @name GrandpaCommit */
+export interface GrandpaCommit extends Struct {
+  readonly targetHash: BlockHash;
+  readonly targetNumber: BlockNumber;
+  readonly precommits: Vec<GrandpaSignedPrecommit>;
+}
+
+/** @name GrandpaEquivocation */
+export interface GrandpaEquivocation extends Enum {
+  readonly isPrevote: boolean;
+  readonly asPrevote: GrandpaEquivocationValue;
+  readonly isPrecommit: boolean;
+  readonly asPrecommit: GrandpaEquivocationValue;
+  readonly type: 'Prevote' | 'Precommit';
+}
+
+/** @name GrandpaEquivocationProof */
+export interface GrandpaEquivocationProof extends Struct {
+  readonly setId: SetId;
+  readonly equivocation: GrandpaEquivocation;
+}
+
+/** @name GrandpaEquivocationValue */
+export interface GrandpaEquivocationValue extends Struct {
+  readonly roundNumber: u64;
+  readonly identity: AuthorityId;
+  readonly first: ITuple<[GrandpaPrevote, AuthoritySignature]>;
+  readonly second: ITuple<[GrandpaPrevote, AuthoritySignature]>;
+}
+
+/** @name GrandpaJustification */
+export interface GrandpaJustification extends Struct {
+  readonly round: u64;
+  readonly commit: GrandpaCommit;
+  readonly votesAncestries: Vec<Header>;
+}
+
+/** @name GrandpaPrecommit */
+export interface GrandpaPrecommit extends Struct {
+  readonly targetHash: BlockHash;
+  readonly targetNumber: BlockNumber;
+}
+
+/** @name GrandpaPrevote */
+export interface GrandpaPrevote extends Struct {
+  readonly targetHash: Hash;
+  readonly targetNumber: BlockNumber;
+}
+
+/** @name GrandpaSignedPrecommit */
+export interface GrandpaSignedPrecommit extends Struct {
+  readonly precommit: GrandpaPrecommit;
+  readonly signature: AuthoritySignature;
+  readonly id: AuthorityId;
+}
+
+/** @name JustificationNotification */
+export interface JustificationNotification extends Bytes {}
+
+/** @name KeyOwnerProof */
+export interface KeyOwnerProof extends MembershipProof {}
+
+/** @name NextAuthority */
+export interface NextAuthority extends ITuple<[AuthorityId, AuthorityWeight]> {}
+
+/** @name PendingChange */
+export interface PendingChange extends Struct {
+  readonly nextAuthorities: AuthorityList;
+  readonly delay: BlockNumber;
+  readonly canonHeight: BlockNumber;
+  readonly canonHash: BlockHash;
+  readonly delayKind: DelayKind;
+}
+
+/** @name PendingPause */
+export interface PendingPause extends Struct {
+  readonly scheduledAt: BlockNumber;
+  readonly delay: BlockNumber;
+}
+
+/** @name PendingResume */
+export interface PendingResume extends Struct {
+  readonly scheduledAt: BlockNumber;
+  readonly delay: BlockNumber;
+}
+
+/** @name Precommits */
+export interface Precommits extends Struct {
+  readonly currentWeight: u32;
+  readonly missing: BTreeSet<AuthorityId>;
+}
+
+/** @name Prevotes */
+export interface Prevotes extends Struct {
+  readonly currentWeight: u32;
+  readonly missing: BTreeSet<AuthorityId>;
+}
+
+/** @name ReportedRoundStates */
+export interface ReportedRoundStates extends Struct {
+  readonly setId: u32;
+  readonly best: RoundState;
+  readonly background: Vec<RoundState>;
+}
+
+/** @name RoundState */
+export interface RoundState extends Struct {
+  readonly round: u32;
+  readonly totalWeight: u32;
+  readonly thresholdWeight: u32;
+  readonly prevotes: Prevotes;
+  readonly precommits: Precommits;
+}
+
+/** @name SetId */
+export interface SetId extends u64 {}
+
+/** @name StoredPendingChange */
+export interface StoredPendingChange extends Struct {
+  readonly scheduledAt: BlockNumber;
+  readonly delay: BlockNumber;
+  readonly nextAuthorities: AuthorityList;
+}
+
+/** @name StoredState */
+export interface StoredState extends Enum {
+  readonly isLive: boolean;
+  readonly isPendingPause: boolean;
+  readonly asPendingPause: PendingPause;
+  readonly isPaused: boolean;
+  readonly isPendingResume: boolean;
+  readonly asPendingResume: PendingResume;
+  readonly type: 'Live' | 'PendingPause' | 'Paused' | 'PendingResume';
+}
+
+export type PHANTOM_GRANDPA = 'grandpa';

package/src/interfaces/identity/IdentityFields.spec.ts

@@ -0,0 +1,34 @@
+// 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('IdentityFields', (): void => {
+  const registry = new TypeRegistry();
+
+  it('has a custom u64 (64-bit) encodedLength', (): void => {
+    expect(
+      registry.createType('IdentityFields').encodedLength
+    ).toEqual(8);
+  });
+
+  it('encodes a sample', (): void => {
+    expect(
+      registry.createType('IdentityFields', ['Display', 'Legal']).valueEncoded.eqn(1 + 2)
+    ).toBe(true);
+  });
+
+  it('encodes to a valid u8a value', (): void => {
+    expect(
+      registry.createType('IdentityFields', ['Display', 'Legal']).toU8a()
+    ).toEqual(new Uint8Array([3, 0, 0, 0, 0, 0, 0, 0]));
+  });
+
+  it('decodes from a u8a', (): void => {
+    expect(
+      registry.createType('IdentityFields', new Uint8Array([1 + 2 + 64, 0, 0, 0, 0, 0, 0, 0])).toHuman()
+    ).toEqual(['Display', 'Legal', 'Image']);
+  });
+});

package/src/interfaces/identity/Registration.spec.ts

@@ -0,0 +1,36 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { createType, TypeRegistry } from '../../create/index.js';
+
+const registry = new TypeRegistry();
+
+describe('Registration', (): void => {
+  it('decodes a Registration', (): void => {
+    expect(
+      createType(
+        registry, 'Registration', '0x' +
+        '00' + // no judgements
+        '00a0724e180900000000000000000000' + // balance
+        '00' + // no length
+        '039911039922039944039955039933000003996600'
+      ).toJSON()
+    ).toEqual({
+      deposit: 10000000000000, // '0x0000000000000000000009184e72a000',
+      info: {
+        additional: [],
+        display: { raw: '0x9911' },
+        email: { raw: '0x9933' },
+        image: { none: null },
+        legal: { raw: '0x9922' },
+        pgpFingerprint: null,
+        riot: { raw: '0x9955' },
+        twitter: { raw: '0x9966' },
+        web: { raw: '0x9944' }
+      },
+      judgements: []
+    });
+  });
+});

package/src/interfaces/identity/definitions.ts

@@ -0,0 +1,79 @@
+// 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: {
+    IdentityFields: {
+      _set: {
+        _bitLength: 64,
+        // Mapped here to 32 bits, in Rust these are 64-bit values
+        Display: 0b00000000_00000000_00000000_0000_0001,
+        Legal: 0b00000000_00000000_00000000_0000_0010,
+        Web: 0b00000000_00000000_00000000_0000_0100,
+        Riot: 0b00000000_00000000_00000000_0000_1000,
+        Email: 0b00000000_00000000_00000000_0001_0000,
+        PgpFingerprint: 0b00000000_00000000_00000000_0010_0000,
+        Image: 0b00000000_00000000_00000000_0100_0000,
+        Twitter: 0b00000000_00000000_00000000_1000_0000
+      }
+    },
+    IdentityInfoAdditional: '(Data, Data)',
+    IdentityInfoTo198: {
+      additional: 'Vec<IdentityInfoAdditional>',
+      display: 'Data',
+      legal: 'Data',
+      web: 'Data',
+      riot: 'Data',
+      email: 'Data',
+      pgpFingerprint: 'Option<H160>',
+      image: 'Data'
+    },
+    IdentityInfo: {
+      _fallback: 'IdentityInfoTo198',
+      additional: 'Vec<IdentityInfoAdditional>',
+      display: 'Data',
+      legal: 'Data',
+      web: 'Data',
+      riot: 'Data',
+      email: 'Data',
+      pgpFingerprint: 'Option<H160>',
+      image: 'Data',
+      twitter: 'Data'
+    },
+    IdentityJudgement: {
+      _enum: {
+        Unknown: 'Null',
+        FeePaid: 'Balance',
+        Reasonable: 'Null',
+        KnownGood: 'Null',
+        OutOfDate: 'Null',
+        LowQuality: 'Null',
+        Erroneous: 'Null'
+      }
+    },
+    RegistrationJudgement: '(RegistrarIndex, IdentityJudgement)',
+    RegistrationTo198: {
+      judgements: 'Vec<RegistrationJudgement>',
+      deposit: 'Balance',
+      info: 'IdentityInfoTo198'
+    },
+    Registration: {
+      _fallback: 'RegistrationTo198',
+      judgements: 'Vec<RegistrationJudgement>',
+      deposit: 'Balance',
+      info: 'IdentityInfo'
+    },
+    RegistrarIndex: 'u32',
+    RegistrarInfo: {
+      account: 'AccountId',
+      fee: 'Balance',
+      fields: 'IdentityFields'
+    }
+  }
+} as Definitions;

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

@@ -0,0 +1,89 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Data } from '@pezkuwi/types';
+import type { Enum, Option, Set, Struct, Vec, u32 } from '@pezkuwi/types-codec';
+import type { ITuple } from '@pezkuwi/types-codec/types';
+import type { AccountId, Balance, H160 } from '@pezkuwi/types/interfaces/runtime';
+
+/** @name IdentityFields */
+export interface IdentityFields extends Set {
+  readonly isDisplay: boolean;
+  readonly isLegal: boolean;
+  readonly isWeb: boolean;
+  readonly isRiot: boolean;
+  readonly isEmail: boolean;
+  readonly isPgpFingerprint: boolean;
+  readonly isImage: boolean;
+  readonly isTwitter: boolean;
+}
+
+/** @name IdentityInfo */
+export interface IdentityInfo extends Struct {
+  readonly additional: Vec<IdentityInfoAdditional>;
+  readonly display: Data;
+  readonly legal: Data;
+  readonly web: Data;
+  readonly riot: Data;
+  readonly email: Data;
+  readonly pgpFingerprint: Option<H160>;
+  readonly image: Data;
+  readonly twitter: Data;
+}
+
+/** @name IdentityInfoAdditional */
+export interface IdentityInfoAdditional extends ITuple<[Data, Data]> {}
+
+/** @name IdentityInfoTo198 */
+export interface IdentityInfoTo198 extends Struct {
+  readonly additional: Vec<IdentityInfoAdditional>;
+  readonly display: Data;
+  readonly legal: Data;
+  readonly web: Data;
+  readonly riot: Data;
+  readonly email: Data;
+  readonly pgpFingerprint: Option<H160>;
+  readonly image: Data;
+}
+
+/** @name IdentityJudgement */
+export interface IdentityJudgement extends Enum {
+  readonly isUnknown: boolean;
+  readonly isFeePaid: boolean;
+  readonly asFeePaid: Balance;
+  readonly isReasonable: boolean;
+  readonly isKnownGood: boolean;
+  readonly isOutOfDate: boolean;
+  readonly isLowQuality: boolean;
+  readonly isErroneous: boolean;
+  readonly type: 'Unknown' | 'FeePaid' | 'Reasonable' | 'KnownGood' | 'OutOfDate' | 'LowQuality' | 'Erroneous';
+}
+
+/** @name RegistrarIndex */
+export interface RegistrarIndex extends u32 {}
+
+/** @name RegistrarInfo */
+export interface RegistrarInfo extends Struct {
+  readonly account: AccountId;
+  readonly fee: Balance;
+  readonly fields: IdentityFields;
+}
+
+/** @name Registration */
+export interface Registration extends Struct {
+  readonly judgements: Vec<RegistrationJudgement>;
+  readonly deposit: Balance;
+  readonly info: IdentityInfo;
+}
+
+/** @name RegistrationJudgement */
+export interface RegistrationJudgement extends ITuple<[RegistrarIndex, IdentityJudgement]> {}
+
+/** @name RegistrationTo198 */
+export interface RegistrationTo198 extends Struct {
+  readonly judgements: Vec<RegistrationJudgement>;
+  readonly deposit: Balance;
+  readonly info: IdentityInfoTo198;
+}
+
+export type PHANTOM_IDENTITY = 'identity';