@pezkuwi/types 16.5.5

package/src/interfaces/benchmark/definitions.ts

@@ -0,0 +1,52 @@
+// 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: {
+    BenchmarkBatch: {
+      pallet: 'Text',
+      instance: 'Text',
+      benchmark: 'Text',
+      results: 'Vec<BenchmarkResult>'
+    },
+    BenchmarkConfig: {
+      pallet: 'Bytes',
+      benchmark: 'Bytes',
+      selectedComponents: 'Vec<(BenchmarkParameter, u32)>',
+      verify: 'bool',
+      internalRepeats: 'u32'
+    },
+    BenchmarkList: {
+      pallet: 'Bytes',
+      instance: 'Bytes',
+      benchmarks: 'Vec<BenchmarkMetadata>'
+    },
+    BenchmarkMetadata: {
+      name: 'Bytes',
+      components: 'Vec<(BenchmarkParameter, u32, u32)>'
+    },
+    BenchmarkParameter: {
+      _enum: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
+    },
+    BenchmarkResult: {
+      components: 'Vec<(BenchmarkParameter, u32)>',
+      extrinsicTime: 'u128',
+      storageRootTime: 'u128',
+      reads: 'u32',
+      repeatReads: 'u32',
+      writes: 'u32',
+      repeatWrites: 'u32',
+      proofSize: 'u32',
+      benchKeys: 'Vec<(Vec<u8>, u32, u32, bool)>'
+    }
+  }
+} as Definitions;

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

@@ -0,0 +1,34 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DefinitionsCall } from '../../types/index.js';
+
+export const runtime: DefinitionsCall = {
+  Benchmark: [
+    {
+      methods: {
+        benchmark_metadata: {
+          description: 'Get the benchmark metadata available for this runtime.',
+          params: [
+            {
+              name: 'extra',
+              type: 'bool'
+            }
+          ],
+          type: '(Vec<BenchmarkList>, Vec<StorageInfo>)'
+        },
+        dispatch_benchmark: {
+          description: 'Dispatch the given benchmark.',
+          params: [
+            {
+              name: 'config',
+              type: 'BenchmarkConfig'
+            }
+          ],
+          type: 'Result<Vec<BenchmarkBatch>, Text>'
+        }
+      },
+      version: 1
+    }
+  ]
+};

package/src/interfaces/benchmark/types.ts

@@ -0,0 +1,81 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Bytes, Enum, Struct, Text, Vec, bool, u128, u32 } from '@pezkuwi/types-codec';
+import type { ITuple } from '@pezkuwi/types-codec/types';
+
+/** @name BenchmarkBatch */
+export interface BenchmarkBatch extends Struct {
+  readonly pallet: Text;
+  readonly instance: Text;
+  readonly benchmark: Text;
+  readonly results: Vec<BenchmarkResult>;
+}
+
+/** @name BenchmarkConfig */
+export interface BenchmarkConfig extends Struct {
+  readonly pallet: Bytes;
+  readonly benchmark: Bytes;
+  readonly selectedComponents: Vec<ITuple<[BenchmarkParameter, u32]>>;
+  readonly verify: bool;
+  readonly internalRepeats: u32;
+}
+
+/** @name BenchmarkList */
+export interface BenchmarkList extends Struct {
+  readonly pallet: Bytes;
+  readonly instance: Bytes;
+  readonly benchmarks: Vec<BenchmarkMetadata>;
+}
+
+/** @name BenchmarkMetadata */
+export interface BenchmarkMetadata extends Struct {
+  readonly name: Bytes;
+  readonly components: Vec<ITuple<[BenchmarkParameter, u32, u32]>>;
+}
+
+/** @name BenchmarkParameter */
+export interface BenchmarkParameter extends Enum {
+  readonly isA: boolean;
+  readonly isB: boolean;
+  readonly isC: boolean;
+  readonly isD: boolean;
+  readonly isE: boolean;
+  readonly isF: boolean;
+  readonly isG: boolean;
+  readonly isH: boolean;
+  readonly isI: boolean;
+  readonly isJ: boolean;
+  readonly isK: boolean;
+  readonly isL: boolean;
+  readonly isM: boolean;
+  readonly isN: boolean;
+  readonly isO: boolean;
+  readonly isP: boolean;
+  readonly isQ: boolean;
+  readonly isR: boolean;
+  readonly isS: boolean;
+  readonly isT: boolean;
+  readonly isU: boolean;
+  readonly isV: boolean;
+  readonly isW: boolean;
+  readonly isX: boolean;
+  readonly isY: boolean;
+  readonly isZ: boolean;
+  readonly type: 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+}
+
+/** @name BenchmarkResult */
+export interface BenchmarkResult extends Struct {
+  readonly components: Vec<ITuple<[BenchmarkParameter, u32]>>;
+  readonly extrinsicTime: u128;
+  readonly storageRootTime: u128;
+  readonly reads: u32;
+  readonly repeatReads: u32;
+  readonly writes: u32;
+  readonly repeatWrites: u32;
+  readonly proofSize: u32;
+  readonly benchKeys: Vec<ITuple<[Bytes, u32, u32, bool]>>;
+}
+
+export type PHANTOM_BENCHMARK = 'benchmark';

package/src/interfaces/blockbuilder/definitions.ts

@@ -0,0 +1,25 @@
+// 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: {
+    CheckInherentsResult: {
+      okay: 'bool',
+      fatalError: 'bool',
+      errors: 'InherentData'
+    },
+    InherentData: {
+      data: 'BTreeMap<InherentIdentifier, Bytes>'
+    },
+    InherentIdentifier: '[u8; 8]'
+  }
+} as Definitions;

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

@@ -0,0 +1,124 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DefinitionsCall, DefinitionsCallEntry } from '../../types/index.js';
+
+const BB_V2_TO_V4: DefinitionsCallEntry['methods'] = {
+  // this was removed after V4
+  random_seed: {
+    description: 'Generate a random seed.',
+    params: [],
+    type: 'Hash'
+  }
+};
+
+const BB_V2_TO_V5: DefinitionsCallEntry['methods'] = {
+  apply_extrinsic: {
+    description: 'Apply the given extrinsic.',
+    params: [
+      {
+        name: 'extrinsic',
+        type: 'Extrinsic'
+      }
+    ],
+    type: 'ApplyExtrinsicResultPre6'
+  }
+};
+
+const BB_V2_TO_V6: DefinitionsCallEntry['methods'] = {
+  check_inherents: {
+    description: 'Check that the inherents are valid.',
+    params: [
+      {
+        name: 'block',
+        type: 'Block'
+      },
+      {
+        name: 'data',
+        type: 'InherentData'
+      }
+    ],
+    type: 'CheckInherentsResult'
+  },
+  inherent_extrinsics: {
+    description: 'Generate inherent extrinsics.',
+    params: [
+      {
+        name: 'inherent',
+        type: 'InherentData'
+      }
+    ],
+    type: 'Vec<Extrinsic>'
+  }
+};
+
+const BB_V3_TO_V6: DefinitionsCallEntry['methods'] = {
+  // renamed in v3 from finalize_block
+  finalize_block: {
+    description: 'Finish the current block.',
+    params: [],
+    type: 'Header'
+  }
+};
+
+export const runtime: DefinitionsCall = {
+  BlockBuilder: [
+    {
+      methods: {
+        apply_extrinsic: {
+          description: 'Apply the given extrinsic.',
+          params: [
+            {
+              name: 'extrinsic',
+              type: 'Extrinsic'
+            }
+          ],
+          type: 'ApplyExtrinsicResult'
+        },
+        ...BB_V2_TO_V6,
+        ...BB_V3_TO_V6
+      },
+      version: 6
+    },
+    {
+      methods: {
+        // apply_extrinsic result changed in 6
+        ...BB_V2_TO_V5,
+        ...BB_V2_TO_V6,
+        ...BB_V3_TO_V6
+      },
+      version: 5
+    },
+    {
+      methods: {
+        // random_seed removed
+        ...BB_V2_TO_V4,
+        ...BB_V2_TO_V5,
+        ...BB_V2_TO_V6,
+        ...BB_V3_TO_V6
+      },
+      version: 4
+    },
+    {
+      methods: {
+        // finalize_block renamed
+        ...BB_V2_TO_V4,
+        ...BB_V2_TO_V6,
+        ...BB_V3_TO_V6
+      },
+      version: 3
+    },
+    {
+      methods: {
+        finalise_block: {
+          description: 'Finish the current block.',
+          params: [],
+          type: 'Header'
+        },
+        ...BB_V2_TO_V4,
+        ...BB_V2_TO_V6
+      },
+      version: 2
+    }
+  ]
+};

package/src/interfaces/blockbuilder/types.ts

@@ -0,0 +1,21 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { BTreeMap, Bytes, Struct, U8aFixed, bool } from '@pezkuwi/types-codec';
+
+/** @name CheckInherentsResult */
+export interface CheckInherentsResult extends Struct {
+  readonly okay: bool;
+  readonly fatalError: bool;
+  readonly errors: InherentData;
+}
+
+/** @name InherentData */
+export interface InherentData extends Struct {
+  readonly data: BTreeMap<InherentIdentifier, Bytes>;
+}
+
+/** @name InherentIdentifier */
+export interface InherentIdentifier extends U8aFixed {}
+
+export type PHANTOM_BLOCKBUILDER = 'blockbuilder';

package/src/interfaces/bridges/definitions.ts

@@ -0,0 +1,94 @@
+// 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: {
+    BridgedBlockHash: 'H256',
+    BridgedBlockNumber: 'BlockNumber',
+    BridgedHeader: 'Header',
+    BridgeMessageId: '(LaneId, MessageNonce)',
+    CallOrigin: {
+      _enum: {
+        SourceRoot: 'Null',
+        TargetAccount: '(AccountId, MultiSigner, MultiSignature)',
+        SourceAccount: 'AccountId'
+      }
+    },
+    ChainId: '[u8; 4]',
+    DeliveredMessages: {
+      begin: 'MessageNonce',
+      end: 'MessageNonce',
+      // pub type DispatchResultsBitVec = BitVec<Msb0, u8>;
+      dispatchResults: 'BitVec'
+    },
+    DispatchFeePayment: {
+      _enum: ['AtSourceChain', 'AtTargetChain']
+    },
+    InboundLaneData: {
+      relayers: 'Vec<UnrewardedRelayer>',
+      lastConfirmedNonce: 'MessageNonce'
+    },
+    InboundRelayer: 'AccountId',
+    InitializationData: {
+      header: 'Header',
+      authorityList: 'AuthorityList',
+      setId: 'SetId',
+      isHalted: 'bool'
+    },
+    LaneId: '[u8; 4]',
+    MessageData: {
+      payload: 'Bytes',
+      fee: 'Balance'
+    },
+    MessagesDeliveryProofOf: {
+      bridgedHeaderHash: 'BlockHash',
+      storageProof: 'Vec<Bytes>',
+      lane: 'LaneId'
+    },
+    MessageKey: {
+      laneId: 'LaneId',
+      nonce: 'MessageNonce'
+    },
+    MessageNonce: 'u64',
+    MessagesProofOf: {
+      bridgedHeaderHash: 'BridgedBlockHash',
+      storageProof: 'Vec<Bytes>',
+      lane: 'LaneId',
+      noncesStart: 'MessageNonce',
+      noncesEnd: 'MessageNonce'
+    },
+    OperatingMode: {
+      _enum: ['Normal', 'RejectingOutboundMessages', 'Halted']
+    },
+    OutboundLaneData: {
+      oldestUnprunedNonce: 'MessageNonce',
+      latestReceivedNonce: 'MessageNonce',
+      latestGeneratedNonce: 'MessageNonce'
+    },
+    OutboundMessageFee: 'Balance',
+    OutboundPayload: {
+      specVersion: 'u32',
+      weight: 'Weight',
+      origin: 'CallOrigin',
+      dispatchFeePayment: 'DispatchFeePayment',
+      call: 'Bytes'
+    },
+    Parameter: 'Null',
+    RelayerId: 'AccountId',
+    UnrewardedRelayer: {
+      relayer: 'RelayerId',
+      messages: 'DeliveredMessages'
+    },
+    UnrewardedRelayersState: {
+      unrewardedRelayer_Entries: 'MessageNonce',
+      messagesInOldestEntry: 'MessageNonce',
+      totalMessages: 'MessageNonce'
+    }
+  }
+} as Definitions;

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

@@ -0,0 +1,147 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { BitVec, Bytes, Enum, Null, Struct, U8aFixed, Vec, bool, u32, u64 } from '@pezkuwi/types-codec';
+import type { ITuple } from '@pezkuwi/types-codec/types';
+import type { BlockHash } from '@pezkuwi/types/interfaces/chain';
+import type { MultiSignature } from '@pezkuwi/types/interfaces/extrinsics';
+import type { AuthorityList, SetId } from '@pezkuwi/types/interfaces/grandpa';
+import type { AccountId, Balance, BlockNumber, H256, Header, MultiSigner, Weight } from '@pezkuwi/types/interfaces/runtime';
+
+/** @name BridgedBlockHash */
+export interface BridgedBlockHash extends H256 {}
+
+/** @name BridgedBlockNumber */
+export interface BridgedBlockNumber extends BlockNumber {}
+
+/** @name BridgedHeader */
+export interface BridgedHeader extends Header {}
+
+/** @name BridgeMessageId */
+export interface BridgeMessageId extends ITuple<[LaneId, MessageNonce]> {}
+
+/** @name CallOrigin */
+export interface CallOrigin extends Enum {
+  readonly isSourceRoot: boolean;
+  readonly isTargetAccount: boolean;
+  readonly asTargetAccount: ITuple<[AccountId, MultiSigner, MultiSignature]>;
+  readonly isSourceAccount: boolean;
+  readonly asSourceAccount: AccountId;
+  readonly type: 'SourceRoot' | 'TargetAccount' | 'SourceAccount';
+}
+
+/** @name ChainId */
+export interface ChainId extends U8aFixed {}
+
+/** @name DeliveredMessages */
+export interface DeliveredMessages extends Struct {
+  readonly begin: MessageNonce;
+  readonly end: MessageNonce;
+  readonly dispatchResults: BitVec;
+}
+
+/** @name DispatchFeePayment */
+export interface DispatchFeePayment extends Enum {
+  readonly isAtSourceChain: boolean;
+  readonly isAtTargetChain: boolean;
+  readonly type: 'AtSourceChain' | 'AtTargetChain';
+}
+
+/** @name InboundLaneData */
+export interface InboundLaneData extends Struct {
+  readonly relayers: Vec<UnrewardedRelayer>;
+  readonly lastConfirmedNonce: MessageNonce;
+}
+
+/** @name InboundRelayer */
+export interface InboundRelayer extends AccountId {}
+
+/** @name InitializationData */
+export interface InitializationData extends Struct {
+  readonly header: Header;
+  readonly authorityList: AuthorityList;
+  readonly setId: SetId;
+  readonly isHalted: bool;
+}
+
+/** @name LaneId */
+export interface LaneId extends U8aFixed {}
+
+/** @name MessageData */
+export interface MessageData extends Struct {
+  readonly payload: Bytes;
+  readonly fee: Balance;
+}
+
+/** @name MessageKey */
+export interface MessageKey extends Struct {
+  readonly laneId: LaneId;
+  readonly nonce: MessageNonce;
+}
+
+/** @name MessageNonce */
+export interface MessageNonce extends u64 {}
+
+/** @name MessagesDeliveryProofOf */
+export interface MessagesDeliveryProofOf extends Struct {
+  readonly bridgedHeaderHash: BlockHash;
+  readonly storageProof: Vec<Bytes>;
+  readonly lane: LaneId;
+}
+
+/** @name MessagesProofOf */
+export interface MessagesProofOf extends Struct {
+  readonly bridgedHeaderHash: BridgedBlockHash;
+  readonly storageProof: Vec<Bytes>;
+  readonly lane: LaneId;
+  readonly noncesStart: MessageNonce;
+  readonly noncesEnd: MessageNonce;
+}
+
+/** @name OperatingMode */
+export interface OperatingMode extends Enum {
+  readonly isNormal: boolean;
+  readonly isRejectingOutboundMessages: boolean;
+  readonly isHalted: boolean;
+  readonly type: 'Normal' | 'RejectingOutboundMessages' | 'Halted';
+}
+
+/** @name OutboundLaneData */
+export interface OutboundLaneData extends Struct {
+  readonly oldestUnprunedNonce: MessageNonce;
+  readonly latestReceivedNonce: MessageNonce;
+  readonly latestGeneratedNonce: MessageNonce;
+}
+
+/** @name OutboundMessageFee */
+export interface OutboundMessageFee extends Balance {}
+
+/** @name OutboundPayload */
+export interface OutboundPayload extends Struct {
+  readonly specVersion: u32;
+  readonly weight: Weight;
+  readonly origin: CallOrigin;
+  readonly dispatchFeePayment: DispatchFeePayment;
+  readonly call: Bytes;
+}
+
+/** @name Parameter */
+export interface Parameter extends Null {}
+
+/** @name RelayerId */
+export interface RelayerId extends AccountId {}
+
+/** @name UnrewardedRelayer */
+export interface UnrewardedRelayer extends Struct {
+  readonly relayer: RelayerId;
+  readonly messages: DeliveredMessages;
+}
+
+/** @name UnrewardedRelayersState */
+export interface UnrewardedRelayersState extends Struct {
+  readonly unrewardedRelayer_Entries: MessageNonce;
+  readonly messagesInOldestEntry: MessageNonce;
+  readonly totalMessages: MessageNonce;
+}
+
+export type PHANTOM_BRIDGES = 'bridges';

package/src/interfaces/chain/definitions.ts

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

package/src/interfaces/chain/index.ts

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