@pezkuwi/types 16.5.5

package/src/interfaces/syncstate/types.ts

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

package/src/interfaces/system/EventRecord.spec.ts

@@ -0,0 +1,42 @@
+// 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-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+
+import json1 from '@pezkuwi/types-support/json/EventRecord.001.json' assert { type: 'json' };
+import json3 from '@pezkuwi/types-support/json/EventRecord.003.json' assert { type: 'json' };
+import rpcMetadata from '@pezkuwi/types-support/metadata/static-substrate';
+
+import { TypeRegistry } from '../../create/index.js';
+import { Metadata } from '../../metadata/index.js';
+
+describe('EventRecord', (): void => {
+  const registry = new TypeRegistry();
+
+  describe('EventRecord (current)', (): void => {
+    beforeEach((): void => {
+      const metadata = new Metadata(registry, rpcMetadata);
+
+      registry.setMetadata(metadata);
+    });
+
+    it('decodes older EventRecord correctly', (): void => {
+      const records = registry.createType('Vec<EventRecord>', json1.params.result.changes[0][1], true);
+      const er = records[0];
+
+      expect(er.phase.type).toEqual('ApplyExtrinsic');
+    });
+
+    it('decodes EventRecord with topics correctly', (): void => {
+      const hex = json3.params.result.changes[0][1];
+      const records = registry.createType('Vec<EventRecord>', hex, true);
+      const er = records[0];
+
+      expect(er.phase.type).toEqual('ApplyExtrinsic');
+      expect(records.toHex()).toEqual(hex);
+    });
+  });
+});

package/src/interfaces/system/definitions.ts

@@ -0,0 +1,327 @@
+// 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: {
+    AccountInfo: 'AccountInfoWithTripleRefCount',
+    AccountInfoWithRefCountU8: {
+      nonce: 'Index',
+      refcount: 'u8',
+      data: 'AccountData'
+    },
+    AccountInfoWithRefCount: {
+      _fallback: 'AccountInfoWithRefCountU8',
+      nonce: 'Index',
+      refcount: 'RefCount',
+      data: 'AccountData'
+    },
+    AccountInfoWithDualRefCount: {
+      _fallback: 'AccountInfoWithRefCount',
+      nonce: 'Index',
+      consumers: 'RefCount',
+      providers: 'RefCount',
+      data: 'AccountData'
+    },
+    // original naming
+    AccountInfoWithProviders: 'AccountInfoWithDualRefCount',
+    AccountInfoWithTripleRefCount: {
+      _fallback: 'AccountInfoWithDualRefCount',
+      nonce: 'Index',
+      consumers: 'RefCount',
+      providers: 'RefCount',
+      sufficients: 'RefCount',
+      data: 'AccountData'
+    },
+    ApplyExtrinsicResult: 'Result<DispatchOutcome, TransactionValidityError>',
+    ApplyExtrinsicResultPre6: 'Result<DispatchOutcomePre6, TransactionValidityError>',
+    ArithmeticError: {
+      _enum: [
+        'Underflow',
+        'Overflow',
+        'DivisionByZero'
+      ]
+    },
+    BlockLength: {
+      max: 'PerDispatchClassU32'
+    },
+    BlockWeights: {
+      baseBlock: 'Weight',
+      maxBlock: 'Weight',
+      perClass: 'PerDispatchClassWeightsPerClass'
+    },
+    ChainProperties: 'GenericChainProperties',
+    ChainType: {
+      _enum: {
+        Development: 'Null',
+        Local: 'Null',
+        Live: 'Null',
+        Custom: 'Text'
+      }
+    },
+    ConsumedWeight: 'PerDispatchClassWeight',
+    DigestOf: 'Digest',
+    DispatchClass: {
+      _enum: ['Normal', 'Operational', 'Mandatory']
+    },
+    DispatchError: {
+      _enum: {
+        Other: 'Null',
+        CannotLookup: 'Null',
+        BadOrigin: 'Null',
+        Module: 'DispatchErrorModule',
+        ConsumerRemaining: 'Null',
+        NoProviders: 'Null',
+        TooManyConsumers: 'Null',
+        Token: 'TokenError',
+        Arithmetic: 'ArithmeticError',
+        Transactional: 'TransactionalError',
+        Exhausted: 'Null',
+        Corruption: 'Null',
+        Unavailable: 'Null'
+      }
+    },
+    DispatchErrorPre6: {
+      _enum: {
+        Other: 'Null',
+        CannotLookup: 'Null',
+        BadOrigin: 'Null',
+        Module: 'DispatchErrorModulePre6',
+        ConsumerRemaining: 'Null',
+        NoProviders: 'Null',
+        TooManyConsumers: 'Null',
+        Token: 'TokenError',
+        Arithmetic: 'ArithmeticError',
+        Transactional: 'TransactionalError'
+      }
+    },
+    DispatchErrorPre6First: {
+      // The enum was modified mid-flight, affecting asset chains -
+      // https://github.com/paritytech/substrate/pull/10382/files#diff-e4e016b33a82268b6208dc974eea841bad47597865a749fee2f937eb6fdf67b4R498
+      _enum: {
+        Other: 'Null',
+        CannotLookup: 'Null',
+        BadOrigin: 'Null',
+        Module: 'DispatchErrorModulePre6',
+        ConsumerRemaining: 'Null',
+        NoProviders: 'Null',
+        Token: 'TokenError',
+        Arithmetic: 'ArithmeticError',
+        Transactional: 'TransactionalError'
+      }
+    },
+    DispatchErrorModuleU8: {
+      index: 'u8',
+      error: 'u8'
+    },
+    DispatchErrorModuleU8a: {
+      index: 'u8',
+      error: '[u8; 4]'
+    },
+    DispatchErrorModule: 'DispatchErrorModuleU8a',
+    DispatchErrorModulePre6: 'DispatchErrorModuleU8',
+    DispatchErrorTo198: {
+      module: 'Option<u8>',
+      error: 'u8'
+    },
+    DispatchInfo: {
+      weight: 'Weight',
+      class: 'DispatchClass',
+      paysFee: 'Pays'
+    },
+    DispatchInfoTo190: {
+      weight: 'Weight',
+      class: 'DispatchClass'
+    },
+    DispatchInfoTo244: {
+      weight: 'Weight',
+      class: 'DispatchClass',
+      paysFee: 'bool'
+    },
+    DispatchOutcome: 'Result<(), DispatchError>',
+    DispatchOutcomePre6: 'Result<(), DispatchErrorPre6>',
+    DispatchResult: 'Result<(), DispatchError>',
+    DispatchResultOf: 'DispatchResult',
+    DispatchResultTo198: 'Result<(), Text>',
+    Event: 'GenericEvent',
+    EventId: '[u8; 2]',
+    EventIndex: 'u32',
+    EventRecord: {
+      phase: 'Phase',
+      event: 'Event',
+      topics: 'Vec<Hash>'
+    },
+    Health: {
+      peers: 'u64',
+      isSyncing: 'bool',
+      shouldHavePeers: 'bool'
+    },
+    InvalidTransaction: {
+      _enum: {
+        Call: 'Null',
+        Payment: 'Null',
+        Future: 'Null',
+        Stale: 'Null',
+        BadProof: 'Null',
+        AncientBirthBlock: 'Null',
+        ExhaustsResources: 'Null',
+        Custom: 'u8',
+        BadMandatory: 'Null',
+        MandatoryDispatch: 'Null',
+        BadSigner: 'Null'
+      }
+    },
+    Key: 'Bytes',
+    LastRuntimeUpgradeInfo: {
+      specVersion: 'Compact<u32>',
+      specName: 'Text'
+    },
+    NetworkState: {
+      peerId: 'Text',
+      listenedAddresses: 'Vec<Text>',
+      externalAddresses: 'Vec<Text>',
+      connectedPeers: 'HashMap<Text, Peer>',
+      notConnectedPeers: 'HashMap<Text, NotConnectedPeer>',
+      averageDownloadPerSec: 'u64',
+      averageUploadPerSec: 'u64',
+      peerset: 'NetworkStatePeerset'
+    },
+    NetworkStatePeerset: {
+      messageQueue: 'u64',
+      nodes: 'HashMap<Text, NetworkStatePeersetInfo>'
+    },
+    NetworkStatePeersetInfo: {
+      connected: 'bool',
+      reputation: 'i32'
+    },
+    NodeRole: {
+      _enum: {
+        Full: 'Null',
+        LightClient: 'Null',
+        Authority: 'Null',
+        UnknownRole: 'u8'
+      }
+    },
+    NotConnectedPeer: {
+      knownAddresses: 'Vec<Text>',
+      latestPingTime: 'Option<PeerPing>',
+      versionString: 'Option<Text>'
+    },
+    Peer: {
+      enabled: 'bool',
+      endpoint: 'PeerEndpoint',
+      knownAddresses: 'Vec<Text>',
+      latestPingTime: 'PeerPing',
+      open: 'bool',
+      versionString: 'Text'
+    },
+    PeerEndpoint: {
+      listening: 'PeerEndpointAddr'
+    },
+    PeerEndpointAddr: {
+      _alias: {
+        localAddr: 'local_addr',
+        sendBackAddr: 'send_back_addr'
+      },
+      localAddr: 'Text',
+      sendBackAddr: 'Text'
+    },
+    PeerPing: {
+      nanos: 'u64',
+      secs: 'u64'
+    },
+    PeerInfo: {
+      peerId: 'Text',
+      roles: 'Text',
+      protocolVersion: 'u32',
+      bestHash: 'Hash',
+      bestNumber: 'BlockNumber'
+    },
+    PerDispatchClassU32: {
+      normal: 'u32',
+      operational: 'u32',
+      mandatory: 'u32'
+    },
+    PerDispatchClassWeight: {
+      normal: 'Weight',
+      operational: 'Weight',
+      mandatory: 'Weight'
+    },
+    PerDispatchClassWeightsPerClass: {
+      normal: 'WeightPerClass',
+      operational: 'WeightPerClass',
+      mandatory: 'WeightPerClass'
+    },
+    Phase: {
+      _enum: {
+        ApplyExtrinsic: 'u32',
+        Finalization: 'Null',
+        Initialization: 'Null'
+      }
+    },
+    RawOrigin: {
+      _enum: {
+        Root: 'Null',
+        Signed: 'AccountId',
+        None: 'Null'
+      }
+    },
+    RefCount: 'u32',
+    RefCountTo259: 'u8',
+    SyncState: {
+      startingBlock: 'BlockNumber',
+      currentBlock: 'BlockNumber',
+      highestBlock: 'Option<BlockNumber>'
+    },
+    SystemOrigin: 'RawOrigin',
+    TokenError: {
+      _enum: [
+        'NoFunds',
+        'WouldDie',
+        'BelowMinimum',
+        'CannotCreate',
+        'UnknownAsset',
+        'Frozen',
+        'Unsupported',
+        // these are dropped, but still in older versions
+        // (if this adjusts, will need to take a re-look)
+        'Underflow',
+        'Overflow'
+      ]
+    },
+    TransactionValidityError: {
+      _enum: {
+        Invalid: 'InvalidTransaction',
+        Unknown: 'UnknownTransaction'
+      }
+    },
+    TransactionalError: {
+      _enum: [
+        'LimitReached',
+        'NoLayer'
+      ]
+    },
+    UnknownTransaction: {
+      _enum: {
+        CannotLookup: 'Null',
+        NoUnsignedValidator: 'Null',
+        Custom: 'u8'
+      }
+    },
+    WeightPerClass: {
+      baseExtrinsic: 'Weight',
+      maxExtrinsic: 'Option<Weight>',
+      maxTotal: 'Option<Weight>',
+      reserved: 'Option<Weight>'
+    }
+  }
+} as Definitions;

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

@@ -0,0 +1,144 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { DefinitionsRpc } from '../../types/index.js';
+
+export const rpc: DefinitionsRpc = {
+  accountNextIndex: {
+    alias: ['account_nextIndex'],
+    description: 'Retrieves the next accountIndex as available on the node',
+    params: [
+      {
+        name: 'accountId',
+        type: 'AccountId'
+      }
+    ],
+    type: 'Index'
+  },
+  addLogFilter: {
+    description: 'Adds the supplied directives to the current log filter',
+    isUnsafe: true,
+    params: [
+      {
+        name: 'directives',
+        type: 'Text'
+      }
+    ],
+    type: 'Null'
+  },
+  addReservedPeer: {
+    description: 'Adds a reserved peer',
+    isUnsafe: true,
+    params: [
+      {
+        name: 'peer',
+        type: 'Text'
+      }
+    ],
+    type: 'Text'
+  },
+  chain: {
+    description: 'Retrieves the chain',
+    params: [],
+    type: 'Text'
+  },
+  chainType: {
+    description: 'Retrieves the chain type',
+    params: [],
+    type: 'ChainType'
+  },
+  dryRun: {
+    alias: ['system_dryRunAt'],
+    description: 'Dry run an extrinsic at a given block',
+    isUnsafe: true,
+    params: [
+      {
+        name: 'extrinsic',
+        type: 'Bytes'
+      },
+      {
+        isHistoric: true,
+        isOptional: true,
+        name: 'at',
+        type: 'BlockHash'
+      }
+    ],
+    type: 'ApplyExtrinsicResult'
+  },
+  health: {
+    description: 'Return health status of the node',
+    noErrorLog: true,
+    params: [],
+    type: 'Health'
+  },
+  localListenAddresses: {
+    description: 'The addresses include a trailing /p2p/ with the local PeerId, and are thus suitable to be passed to addReservedPeer or as a bootnode address for example',
+    params: [],
+    type: 'Vec<Text>'
+  },
+  localPeerId: {
+    description: 'Returns the base58-encoded PeerId of the node',
+    params: [],
+    type: 'Text'
+  },
+  name: {
+    description: 'Retrieves the node name',
+    params: [],
+    type: 'Text'
+  },
+  networkState: {
+    alias: ['system_unstable_networkState'],
+    description: 'Returns current state of the network',
+    isUnsafe: true,
+    params: [],
+    type: 'NetworkState'
+  },
+  nodeRoles: {
+    description: 'Returns the roles the node is running as',
+    params: [],
+    type: 'Vec<NodeRole>'
+  },
+  peers: {
+    description: 'Returns the currently connected peers',
+    isUnsafe: true,
+    params: [],
+    type: 'Vec<PeerInfo>'
+  },
+  properties: {
+    description: 'Get a custom set of properties as a JSON object, defined in the chain spec',
+    params: [],
+    type: 'ChainProperties'
+  },
+  removeReservedPeer: {
+    description: 'Remove a reserved peer',
+    isUnsafe: true,
+    params: [
+      {
+        name: 'peerId',
+        type: 'Text'
+      }
+    ],
+    type: 'Text'
+  },
+  reservedPeers: {
+    description: 'Returns the list of reserved peers',
+    params: [],
+    type: 'Vec<Text>'
+  },
+  resetLogFilter: {
+    description: 'Resets the log filter to Substrate defaults',
+    isUnsafe: true,
+    params: [],
+    type: 'Null'
+  },
+  syncState: {
+    description: 'Returns the state of the syncing of the node',
+    params: [],
+    type: 'SyncState'
+  },
+  version: {
+    description: 'Retrieves the version of the node',
+    params: [],
+    type: 'Text'
+  }
+};

package/src/interfaces/system/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 = {
+  AccountNonceApi: [
+    {
+      methods: {
+        account_nonce: {
+          description: 'The API to query account nonce (aka transaction index)',
+          params: [
+            {
+              name: 'accountId',
+              type: 'AccountId'
+            }
+          ],
+          type: 'Index'
+        }
+      },
+      version: 1
+    }
+  ]
+};