@pezkuwi/types 16.5.5

package/src/interfaces/definitions.spec.ts

@@ -0,0 +1,159 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DefinitionCall, DefinitionRpc, DefinitionsCall, DefinitionsCallEntry, DefinitionsRpc, DefinitionsTypes, RegistryTypes } from '../types/index.js';
+
+import rpcMetadata from '@pezkuwi/types-support/metadata/static-substrate';
+
+import { getTypeDef, TypeRegistry } from '../create/index.js';
+import { Metadata } from '../metadata/index.js';
+import * as all from './definitions.js';
+
+interface CheckDef {
+  rpc: DefinitionsRpc;
+  runtime: DefinitionsCall;
+  types: DefinitionsTypes;
+}
+
+const registry = new TypeRegistry();
+const types = Object.values(all).reduce<Record<string, unknown>>((r, { types = {} }) => {
+  Object.entries(types).forEach(([k, v]) => {
+    r[k] = v;
+  });
+
+  return r;
+}, {});
+
+registry.register(types as RegistryTypes);
+registry.setMetadata(new Metadata(registry, rpcMetadata));
+
+function inspectType (type: string): void {
+  try {
+    // get the definition
+    const { sub } = getTypeDef(registry.createType(type).toRawType());
+
+    // inspect the subs
+    if (Array.isArray(sub)) {
+      for (let i = 0, count = sub.length; i < count; i++) {
+        inspectType(sub[i].type);
+      }
+    } else if (sub) {
+      inspectType(sub.type);
+    }
+  } catch (error) {
+    throw new Error(`${type}:: ${(error as Error).message}`);
+  }
+}
+
+describe('type definitions', (): void => {
+  const allTypes = Object.entries(all).filter((v): v is [string, CheckDef] =>
+    !!v[1].types &&
+    Object.keys(v[1].types).length !== 0 &&
+    v[0] === 'benchmark'
+  );
+
+  for (const [key, { types }] of allTypes) {
+    describe(`${key}`, (): void => {
+      const typesKeys = Object.keys(types).filter((type) =>
+        // meant to fail
+        type !== 'ExtrinsicUnknown' &&
+        type !== 'ExtrinsicPayloadUnknown' &&
+        // injected at runtime
+        type !== 'Origin' &&
+        // it will fail of MetadataV0
+        type !== 'MetadataAll'
+      );
+
+      for (const type of typesKeys) {
+        it(`${type} is known`, (): void => {
+          expect(() => inspectType(type)).not.toThrow();
+        });
+      }
+    });
+  }
+});
+
+describe('rpc definitions', (): void => {
+  const rpcs = Object.entries(all).filter((v): v is [string, CheckDef] =>
+    !!v[1].rpc &&
+    Object.keys(v[1].rpc).length !== 0
+  );
+
+  for (const [section, { rpc }] of rpcs) {
+    describe(`${section}`, (): void => {
+      const methodsEntries = Object.entries<DefinitionRpc>(rpc);
+
+      for (const [method, { params, type }] of methodsEntries) {
+        describe(`${method}`, (): void => {
+          // We cannot constuct V0, so just ignore
+          if (section !== 'state' || method !== 'getMetadata') {
+            it(`output ${type} is known`, (): void => {
+              expect(() => inspectType(type)).not.toThrow();
+            });
+          }
+
+          if (params.length) {
+            describe('params', (): void => {
+              for (const { name, type } of params) {
+                it(`${name}: ${type} is known`, (): void => {
+                  expect(() => inspectType(type)).not.toThrow();
+                });
+              }
+            });
+          }
+        });
+      }
+    });
+  }
+});
+
+describe('runtime definitions', (): void => {
+  const runtimes = Object.entries(all).filter((v): v is [string, CheckDef] =>
+    !!v[1].runtime &&
+    Object.keys(v[1].runtime).length !== 0
+  );
+
+  for (const [key, { runtime }] of runtimes) {
+    describe(`${key}`, (): void => {
+      const versionsEntries = Object.entries<DefinitionsCallEntry[]>(runtime);
+
+      for (const [key, versions] of versionsEntries) {
+        describe(`${key}`, (): void => {
+          for (const { methods, version } of versions) {
+            describe(`version ${version}`, (): void => {
+              const methodsEntries = Object.entries<DefinitionCall>(methods);
+              const skipInspectTypes = ['StagingXcmV3MultiLocation', 'StagingXcmV4Location', 'Result<Vec<XcmV3MultiAsset>, FungiblesAccessError>', 'Result<XcmVersionedAssets, FungiblesAccessError>', 'XcmVersionedLocation', 'XcmVersionedAssetId', 'XcmVersionedXcm', 'Result<Vec<XcmVersionedAssetId>, XcmPaymentApiError>', 'VersionedMultiLocation', 'VersionedXcm', 'PostDispatchInfo', 'DispatchResultWithPostInfo', 'CallDryRunEffects', 'XcmDryRunEffects', 'XcmDryRunApiError', 'Result<CallDryRunEffects, XcmDryRunApiError>', 'Result<XcmDryRunEffects, XcmDryRunApiError>'];
+
+              for (const [key, { params, type }] of methodsEntries) {
+                describe(`${key}`, (): void => {
+                  // Applied from runtime, used in Fungibles
+                  const skipInspectType = skipInspectTypes.includes(type);
+
+                  if (!skipInspectType) {
+                    it(`output ${type} is known`, (): void => {
+                      expect(() => inspectType(type)).not.toThrow();
+                    });
+                  }
+
+                  if (params.length) {
+                    describe('params', (): void => {
+                      for (const { name, type } of params) {
+                        if (skipInspectTypes.includes(type)) {
+                          continue;
+                        }
+
+                        it(`${name}: ${type} is known`, (): void => {
+                          expect(() => inspectType(type)).not.toThrow();
+                        });
+                      }
+                    });
+                  }
+                });
+              }
+            });
+          }
+        });
+      }
+    });
+  }
+});

package/src/interfaces/definitions.ts

@@ -0,0 +1,92 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './essentials.js';
+
+// substrate types
+export { default as assetConversion } from './assetConversion/definitions.js';
+export { default as assets } from './assets/definitions.js';
+export { default as aura } from './aura/definitions.js';
+export { default as authorship } from './authorship/definitions.js';
+export { default as babe } from './babe/definitions.js';
+export { default as balances } from './balances/definitions.js';
+export { default as beefy } from './beefy/definitions.js';
+export { default as benchmark } from './benchmark/definitions.js';
+export { default as blockbuilder } from './blockbuilder/definitions.js';
+export { default as collective } from './collective/definitions.js';
+export { default as consensus } from './consensus/definitions.js';
+export { default as contracts } from './contracts/definitions.js';
+export { default as democracy } from './democracy/definitions.js';
+export { default as dev } from './dev/definitions.js';
+export { default as discovery } from './discovery/definitions.js';
+export { default as elections } from './elections/definitions.js';
+export { default as engine } from './engine/definitions.js';
+export { default as evm } from './evm/definitions.js';
+export { default as extrinsics } from './extrinsics/definitions.js';
+export { default as fungibles } from './fungibles/definitions.js';
+export { default as genericAsset } from './genericAsset/definitions.js';
+export { default as genesisBuilder } from './genesisBuilder/definitions.js';
+export { default as gilt } from './gilt/definitions.js';
+export { default as grandpa } from './grandpa/definitions.js';
+export { default as identity } from './identity/definitions.js';
+export { default as imOnline } from './imOnline/definitions.js';
+export { default as lottery } from './lottery/definitions.js';
+export { default as mixnet } from './mixnet/definitions.js';
+export { default as mmr } from './mmr/definitions.js';
+export { default as nfts } from './nfts/definitions.js';
+export { default as nompools } from './nompools/definitions.js';
+export { default as offences } from './offences/definitions.js';
+export { default as pow } from './pow/definitions.js';
+export { default as proxy } from './proxy/definitions.js';
+export { default as recovery } from './recovery/definitions.js';
+export { default as scheduler } from './scheduler/definitions.js';
+export { default as session } from './session/definitions.js';
+export { default as society } from './society/definitions.js';
+export { default as staking } from './staking/definitions.js';
+export { default as statement } from './statement/definitions.js';
+export { default as support } from './support/definitions.js';
+export { default as syncstate } from './syncstate/definitions.js';
+export { default as system } from './system/definitions.js';
+export { default as treasury } from './treasury/definitions.js';
+export { default as txpayment } from './txpayment/definitions.js';
+export { default as txqueue } from './txqueue/definitions.js';
+export { default as uniques } from './uniques/definitions.js';
+export { default as utility } from './utility/definitions.js';
+export { default as vesting } from './vesting/definitions.js';
+
+// polkadot-specific types
+export { default as attestations } from './attestations/definitions.js';
+export { default as bridges } from './bridges/definitions.js';
+export { default as claims } from './claims/definitions.js';
+export { default as crowdloan } from './crowdloan/definitions.js';
+export { default as cumulus } from './cumulus/definitions.js';
+export { default as finality } from './finality/definitions.js';
+export { default as parachains } from './parachains/definitions.js';
+export { default as poll } from './poll/definitions.js';
+export { default as purchase } from './purchase/definitions.js';
+
+// XCM related types
+export { default as dryRunApi } from './dryRunApi/definitions.js';
+export { default as xcm } from './xcm/definitions.js';
+export { default as xcmPaymentApi } from './xcmPaymentApi/definitions.js';
+export { default as xcmRuntimeApi } from './xcmRuntimeApi/definitions.js';
+
+// other useful types
+export { default as contractsAbi } from './contractsAbi/definitions.js';
+export { default as eth } from './eth/definitions.js';
+
+// additional known/community definitions
+export { default as nimbus } from './nimbus/definitions.js';
+export { default as ormlOracle } from './ormlOracle/definitions.js';
+export { default as ormlTokens } from './ormlTokens/definitions.js';
+
+// pull in rpc last, assuming that is uses info from above
+export { default as rpc } from './rpc/definitions.js';
+
+// rpc-only definitions
+export { default as author } from './author/definitions.js';
+export { default as chain } from './chain/definitions.js';
+export { default as childstate } from './childstate/definitions.js';
+export { default as offchain } from './offchain/definitions.js';
+export { default as payment } from './payment/definitions.js';
+export { default as state } from './state/definitions.js';

package/src/interfaces/democracy/definitions.ts

@@ -0,0 +1,121 @@
+// 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 const AllConvictions = [
+  // 0.1x votes, unlocked.
+  'None',
+  // 1x votes, locked for an enactment period following a successful vote.
+  'Locked1x',
+  // 2x votes, locked for 2x enactment periods following a successful vote.
+  'Locked2x',
+  // 3x votes, locked for 4x...
+  'Locked3x',
+  // 4x votes, locked for 8x...
+  'Locked4x',
+  // 5x votes, locked for 16x...
+  'Locked5x',
+  // 6x votes, locked for 32x...
+  'Locked6x'
+];
+
+export default {
+  rpc: {},
+  types: {
+    AccountVote: {
+      _enum: {
+        Standard: 'AccountVoteStandard',
+        Split: 'AccountVoteSplit'
+      }
+    },
+    AccountVoteSplit: {
+      aye: 'Balance',
+      nay: 'Balance'
+    },
+    AccountVoteStandard: {
+      vote: 'Vote',
+      balance: 'Balance'
+    },
+    Conviction: {
+      _enum: AllConvictions
+    },
+    Delegations: {
+      votes: 'Balance',
+      capital: 'Balance'
+    },
+    PreimageStatus: {
+      _enum: {
+        Missing: 'BlockNumber',
+        Available: 'PreimageStatusAvailable'
+      }
+    },
+    PreimageStatusAvailable: {
+      data: 'Bytes',
+      provider: 'AccountId',
+      deposit: 'Balance',
+      since: 'BlockNumber',
+      expiry: 'Option<BlockNumber>'
+    },
+    PriorLock: '(BlockNumber, Balance)',
+    PropIndex: 'u32',
+    Proposal: 'Call',
+    ProxyState: {
+      _enum: {
+        Open: 'AccountId',
+        Active: 'AccountId'
+      }
+    },
+    ReferendumIndex: 'u32',
+    ReferendumInfoTo239: {
+      end: 'BlockNumber',
+      proposalHash: 'Hash',
+      threshold: 'VoteThreshold',
+      delay: 'BlockNumber'
+    },
+    ReferendumInfo: {
+      _enum: {
+        Ongoing: 'ReferendumStatus',
+        Finished: 'ReferendumInfoFinished'
+      }
+    },
+    ReferendumInfoFinished: {
+      approved: 'bool',
+      end: 'BlockNumber'
+    },
+    ReferendumStatus: {
+      end: 'BlockNumber',
+      proposalHash: 'Hash',
+      threshold: 'VoteThreshold',
+      delay: 'BlockNumber',
+      tally: 'Tally'
+    },
+    Tally: {
+      ayes: 'Balance',
+      nays: 'Balance',
+      turnout: 'Balance'
+    },
+    Voting: {
+      _enum: {
+        Direct: 'VotingDirect',
+        Delegating: 'VotingDelegating'
+      }
+    },
+    VotingDirect: {
+      votes: 'Vec<VotingDirectVote>',
+      delegations: 'Delegations',
+      prior: 'PriorLock'
+    },
+    VotingDirectVote: '(ReferendumIndex, AccountVote)',
+    VotingDelegating: {
+      balance: 'Balance',
+      target: 'AccountId',
+      conviction: 'Conviction',
+      delegations: 'Delegations',
+      prior: 'PriorLock'
+    }
+  }
+} as Definitions;

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

@@ -0,0 +1,154 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Bytes, Enum, Option, Struct, Vec, bool, u32 } from '@pezkuwi/types-codec';
+import type { ITuple } from '@pezkuwi/types-codec/types';
+import type { Vote, VoteThreshold } from '@pezkuwi/types/interfaces/elections';
+import type { AccountId, Balance, BlockNumber, Call, Hash } from '@pezkuwi/types/interfaces/runtime';
+
+/** @name AccountVote */
+export interface AccountVote extends Enum {
+  readonly isStandard: boolean;
+  readonly asStandard: AccountVoteStandard;
+  readonly isSplit: boolean;
+  readonly asSplit: AccountVoteSplit;
+  readonly type: 'Standard' | 'Split';
+}
+
+/** @name AccountVoteSplit */
+export interface AccountVoteSplit extends Struct {
+  readonly aye: Balance;
+  readonly nay: Balance;
+}
+
+/** @name AccountVoteStandard */
+export interface AccountVoteStandard extends Struct {
+  readonly vote: Vote;
+  readonly balance: Balance;
+}
+
+/** @name Conviction */
+export interface Conviction extends Enum {
+  readonly isNone: boolean;
+  readonly isLocked1x: boolean;
+  readonly isLocked2x: boolean;
+  readonly isLocked3x: boolean;
+  readonly isLocked4x: boolean;
+  readonly isLocked5x: boolean;
+  readonly isLocked6x: boolean;
+  readonly type: 'None' | 'Locked1x' | 'Locked2x' | 'Locked3x' | 'Locked4x' | 'Locked5x' | 'Locked6x';
+}
+
+/** @name Delegations */
+export interface Delegations extends Struct {
+  readonly votes: Balance;
+  readonly capital: Balance;
+}
+
+/** @name PreimageStatus */
+export interface PreimageStatus extends Enum {
+  readonly isMissing: boolean;
+  readonly asMissing: BlockNumber;
+  readonly isAvailable: boolean;
+  readonly asAvailable: PreimageStatusAvailable;
+  readonly type: 'Missing' | 'Available';
+}
+
+/** @name PreimageStatusAvailable */
+export interface PreimageStatusAvailable extends Struct {
+  readonly data: Bytes;
+  readonly provider: AccountId;
+  readonly deposit: Balance;
+  readonly since: BlockNumber;
+  readonly expiry: Option<BlockNumber>;
+}
+
+/** @name PriorLock */
+export interface PriorLock extends ITuple<[BlockNumber, Balance]> {}
+
+/** @name PropIndex */
+export interface PropIndex extends u32 {}
+
+/** @name Proposal */
+export interface Proposal extends Call {}
+
+/** @name ProxyState */
+export interface ProxyState extends Enum {
+  readonly isOpen: boolean;
+  readonly asOpen: AccountId;
+  readonly isActive: boolean;
+  readonly asActive: AccountId;
+  readonly type: 'Open' | 'Active';
+}
+
+/** @name ReferendumIndex */
+export interface ReferendumIndex extends u32 {}
+
+/** @name ReferendumInfo */
+export interface ReferendumInfo extends Enum {
+  readonly isOngoing: boolean;
+  readonly asOngoing: ReferendumStatus;
+  readonly isFinished: boolean;
+  readonly asFinished: ReferendumInfoFinished;
+  readonly type: 'Ongoing' | 'Finished';
+}
+
+/** @name ReferendumInfoFinished */
+export interface ReferendumInfoFinished extends Struct {
+  readonly approved: bool;
+  readonly end: BlockNumber;
+}
+
+/** @name ReferendumInfoTo239 */
+export interface ReferendumInfoTo239 extends Struct {
+  readonly end: BlockNumber;
+  readonly proposalHash: Hash;
+  readonly threshold: VoteThreshold;
+  readonly delay: BlockNumber;
+}
+
+/** @name ReferendumStatus */
+export interface ReferendumStatus extends Struct {
+  readonly end: BlockNumber;
+  readonly proposalHash: Hash;
+  readonly threshold: VoteThreshold;
+  readonly delay: BlockNumber;
+  readonly tally: Tally;
+}
+
+/** @name Tally */
+export interface Tally extends Struct {
+  readonly ayes: Balance;
+  readonly nays: Balance;
+  readonly turnout: Balance;
+}
+
+/** @name Voting */
+export interface Voting extends Enum {
+  readonly isDirect: boolean;
+  readonly asDirect: VotingDirect;
+  readonly isDelegating: boolean;
+  readonly asDelegating: VotingDelegating;
+  readonly type: 'Direct' | 'Delegating';
+}
+
+/** @name VotingDelegating */
+export interface VotingDelegating extends Struct {
+  readonly balance: Balance;
+  readonly target: AccountId;
+  readonly conviction: Conviction;
+  readonly delegations: Delegations;
+  readonly prior: PriorLock;
+}
+
+/** @name VotingDirect */
+export interface VotingDirect extends Struct {
+  readonly votes: Vec<VotingDirectVote>;
+  readonly delegations: Delegations;
+  readonly prior: PriorLock;
+}
+
+/** @name VotingDirectVote */
+export interface VotingDirectVote extends ITuple<[ReferendumIndex, AccountVote]> {}
+
+export type PHANTOM_DEMOCRACY = 'democracy';

package/src/interfaces/dev/definitions.ts

@@ -0,0 +1,21 @@
+// 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: {
+    BlockStats: {
+      witnessLen: 'u64',
+      witnessCompactLen: 'u64',
+      blockLen: 'u64',
+      blockNumExtrinsics: 'u64'
+    }
+  }
+} as Definitions;

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

@@ -0,0 +1,19 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DefinitionsRpc } from '../../types/index.js';
+
+export const rpc: DefinitionsRpc = {
+  getBlockStats: {
+    description: 'Reexecute the specified `block_hash` and gather statistics while doing so',
+    isUnsafe: true,
+    params: [
+      {
+        isHistoric: true,
+        name: 'at',
+        type: 'Hash'
+      }
+    ],
+    type: 'Option<BlockStats>'
+  }
+};

package/src/interfaces/dev/types.ts

@@ -0,0 +1,14 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Struct, u64 } from '@pezkuwi/types-codec';
+
+/** @name BlockStats */
+export interface BlockStats extends Struct {
+  readonly witnessLen: u64;
+  readonly witnessCompactLen: u64;
+  readonly blockLen: u64;
+  readonly blockNumExtrinsics: u64;
+}
+
+export type PHANTOM_DEV = 'dev';

package/src/interfaces/discovery/definitions.ts

@@ -0,0 +1,15 @@
+// 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: {}
+} as Definitions;

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

@@ -0,0 +1,19 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DefinitionsCall } from '../../types/index.js';
+
+export const runtime: DefinitionsCall = {
+  AuthorityDiscoveryApi: [
+    {
+      methods: {
+        authorities: {
+          description: 'Retrieve authority identifiers of the current and next authority set.',
+          params: [],
+          type: 'Vec<AuthorityId>'
+        }
+      },
+      version: 1
+    }
+  ]
+};

package/src/interfaces/discovery/types.ts

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

package/src/interfaces/dryRunApi/definitions.ts

@@ -0,0 +1,38 @@
+// 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: {
+    PostDispatchInfo: {
+      actualWeight: 'Option<Weight>',
+      paysFee: 'Pays'
+    },
+    DispatchResultWithPostInfo: 'Result<PostDispatchInfo, DispatchError>',
+    CallDryRunEffects: {
+      executionResult: 'DispatchResultWithPostInfo',
+      emittedEvents: 'Vec<Event>',
+      localXcm: 'Option<VersionedXcm>',
+      forwardedXcms: 'Vec<(VersionedMultiLocation, Vec<VersionedXcm>)>'
+    },
+    XcmDryRunEffects: {
+      executionResult: 'OutcomeV4',
+      emittedEvents: 'Vec<Event>',
+      forwardedXcms: 'Vec<(VersionedMultiLocation, Vec<VersionedXcm>)>'
+    },
+    XcmDryRunApiError: {
+      _enum: [
+        'Unimplemented',
+        'VersionedConversionFailed'
+      ]
+    }
+  }
+} as Definitions;