feat: initial Pezkuwi Apps rebrand from polkadot-apps

Rebranded terminology:
- Polkadot → Pezkuwi
- Kusama → Dicle
- Westend → Zagros
- Rococo → PezkuwiChain
- Substrate → Bizinikiwi
- parachain → teyrchain

Custom logos with Kurdistan brand colors (#e6007a → #86e62a):
- bizinikiwi-hexagon.svg
- sora-bizinikiwi.svg
- hezscanner.svg
- heztreasury.svg
- pezkuwiscan.svg
- pezkuwistats.svg
- pezkuwiassembly.svg
- pezkuwiholic.svg

packages/apps-config/src/api/spec/acala.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { typesBundleForPezkuwi } from '@acala-network/type-definitions';
+
+export default typesBundleForPezkuwi.spec;

packages/apps-config/src/api/spec/ajuna.ts

@@ -0,0 +1,20 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+/* eslint-disable sort-keys */
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/allfeat.ts

@@ -0,0 +1,20 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        AccountId: 'EthereumAccountId',
+        Address: 'AccountId',
+        LookupSource: 'AccountId'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/altair.ts

@@ -0,0 +1,35 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        TeyrchainAccountIdOf: 'AccountId',
+        Proof: {
+          leafHash: 'Hash',
+          sortedHashes: 'Vec<Hash>'
+        },
+        ProxyType: {
+          _enum: [
+            'Any',
+            'NonTransfer',
+            'Governance',
+            '_Staking',
+            'NonProxy'
+          ]
+        },
+        RelayChainAccountId: 'AccountId',
+        RootHashOf: 'Hash'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/apron.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'AccountId',
+        LookupSource: 'AccountId'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/ares-gladios.ts

@@ -0,0 +1,207 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        AskPeriodNum: 'u64',
+        AskPointNum: 'u32',
+        AuthorityAres: 'AccountId',
+        AccountParticipateEstimates: {
+          account: 'AccountId',
+          end: 'BlockNumber',
+          estimates: 'Option<u64>',
+          range_index: 'Option<u8>',
+          bsc_address: 'Option<Bytes>',
+          multiplier: 'MultiplierOption',
+          reward: 'u128'
+        },
+        AresPriceData: {
+          price: 'u64',
+          account_id: 'AccountId',
+          create_bn: 'BlockNumber',
+          fraction_len: 'FractionLength',
+          raw_number: 'JsonNumberValue',
+          timestamp: 'u64'
+        },
+        BalanceOf: 'Balance',
+        ChooseWinnersPayload: {
+          block_number: 'BlockNumber',
+          winners: 'Vec<AccountParticipateEstimates>',
+          public: 'AccountId',
+          estimates_id: 'u64',
+          symbol: 'Bytes',
+          price: '(u64, FractionLength)'
+        },
+        EstimatesState: {
+          _enum: [
+            'InActive',
+            'Active',
+            'WaitingPayout',
+            'Completed'
+          ]
+        },
+        EstimatesType: {
+          _enum: [
+            'DEVIATION', 'RANGE'
+          ]
+        },
+        FractionLength: 'u32',
+        HttpError: {
+          _enum: {
+            IoErr: 'Bytes',
+            TimeOut: 'Bytes',
+            StatusErr: '(Bytes,u16)',
+            ParseErr: 'Bytes'
+          }
+        },
+        HttpErrTracePayload: {
+          trace_data: 'HttpErrTraceData<BlockNumber, AuthorityId>',
+          auth: 'AuthorityId',
+          public: 'MultiSigner'
+        },
+        HttpErrTraceData: {
+          block_number: 'BlockNumber',
+          err_auth: 'AuthorityId',
+          err_status: 'HttpError',
+          tip: 'Bytes'
+        },
+        JsonNumberValue: {
+          integer: 'u64',
+          fraction: 'u64',
+          fraction_length: 'u32',
+          exponent: 'u32'
+        },
+        Keys: 'SessionKeys3',
+        LookupSource: 'MultiAddress',
+        MultiplierOption: {
+          _enum: [
+            'Base1', 'Base2', 'Base5'
+          ]
+        },
+        OcwControlData: {
+          need_verifier_check: 'bool',
+          open_free_price_reporter: 'bool',
+          open_paid_price_reporter: 'bool'
+        },
+        OffchainSignature: 'MultiSignature',
+        PaidValue: {
+          create_bn: 'BlockNumber',
+          amount: 'BalanceOf',
+          is_income: 'bool'
+        },
+        PurchasedId: 'Bytes',
+        PriceKey: 'Vec<u8>',
+        PriceToken: 'Bytes',
+        PreCheckPayload: {
+          block_number: 'BlockNumber',
+          pre_check_stash: 'AccountId',
+          pre_check_auth: 'AuthorityId',
+          auth: 'AuthorityId',
+          public: 'MultiSigner'
+        },
+        PreCheckResultPayload: {
+          block_number: 'BlockNumber',
+          pre_check_list: 'Vec<PreCheckStruct>',
+          pre_check_stash: 'AccountId',
+          pre_check_auth: 'AuthorityId',
+          public: 'MultiSigner'
+        },
+        PreCheckCompareLog: {
+          chain_avg_price_list: 'BTreeMap<Bytes, (u64, FractionLength)>',
+          validator_up_price_list: 'BTreeMap<Bytes, (u64, FractionLength)>',
+          raw_precheck_list: 'Vec<PreCheckStruct>'
+        },
+        PreCheckStruct: {
+          price_key: 'Vec<u8>',
+          number_val: 'JsonNumberValue',
+          max_offset: 'Percent',
+          timestamp: 'u64'
+        },
+        PricePayloadSubPrice: '(PriceKey, u64, FractionLength, JsonNumberValue, u64)',
+        PricePayloadSubJumpBlock: '(PriceKey, RequestInterval)',
+        PricePayload: {
+          block_number: 'BlockNumber',
+          price: 'Vec<PricePayloadSubPrice>',
+          jump_block: 'Vec<PricePayloadSubJumpBlock>',
+          auth: 'AuthorityId',
+          public: 'MultiSigner'
+        },
+        PreCheckStatus: {
+          _enum: [
+            'Review',
+            'Prohibit',
+            'Pass'
+          ]
+        },
+        PurchasedRequestData: {
+          account_id: 'AccountId',
+          offer: 'BalanceOf',
+          create_bn: 'BlockNumber',
+          submit_threshold: 'u8',
+          max_duration: 'u64',
+          request_keys: 'Vec<Vec<u8>>'
+        },
+        PurchasedPricePayload: {
+          block_number: 'BlockNumber',
+          purchase_id: 'Vec<u8>',
+          price: 'Vec<PricePayloadSubPrice>',
+          auth: 'AuthorityId',
+          public: 'MultiSigner'
+        },
+        PurchasedAvgPriceData: {
+          create_bn: 'u64',
+          reached_type: 'u8',
+          price_data: '(u64, FractionLength)'
+        },
+        PurchasedDefaultData: {
+          submit_threshold: 'u8',
+          max_duration: 'u64',
+          avg_keep_duration: 'u64'
+        },
+        PurchasedForceCleanPayload: {
+          BlockNumber: 'BlockNumber',
+          purchase_id_list: 'Vec<Vec<u8>>',
+          auth: 'AuthorityId',
+          public: 'MultiSigner'
+        },
+        PurchaseId: 'Vec<u8>',
+        Releases: {
+          _enum: [
+            'V1_0_0_Ancestral',
+            'V1_0_1_HttpErrUpgrade',
+            'V1_1_0_HttpErrUpgrade',
+            'V1_2_0'
+          ]
+        },
+        RequestInterval: 'u8',
+        StatusErr: '(u16)',
+        SymbolEstimatesConfig: {
+          symbol: 'Bytes',
+          estimates_type: 'EstimatesType',
+          id: 'u64',
+          ticket_price: 'Balance',
+          symbol_completed_price: 'u64',
+          symbol_fraction: 'FractionLength',
+          start: 'BlockNumber',
+          end: 'BlockNumber',
+          distribute: 'BlockNumber',
+          deviation: 'Option<Permill>',
+          range: 'Option<Vec<u64>>',
+          total_reward: 'Balance',
+          state: 'EstimatesState'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/ares-parachain.ts

@@ -0,0 +1,208 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        AskPeriodNum: 'u64',
+        AskPointNum: 'u32',
+        AuthorityAres: 'AccountId',
+        AccountParticipateEstimates: {
+          account: 'AccountId',
+          end: 'BlockNumber',
+          estimates: 'Option<u64>',
+          range_index: 'Option<u8>',
+          eth_address: 'Option<Bytes>',
+          multiplier: 'MultiplierOption',
+          reward: 'u128'
+        },
+        AresPriceData: {
+          price: 'u64',
+          account_id: 'AccountId',
+          create_bn: 'BlockNumber',
+          fraction_len: 'FractionLength',
+          raw_number: 'JsonNumberValue',
+          timestamp: 'u64'
+        },
+        BalanceOf: 'Balance',
+        ChooseWinnersPayload: {
+          block_number: 'BlockNumber',
+          winners: 'Vec<AccountParticipateEstimates>',
+          public: 'AccountId',
+          estimates_config: 'Bytes',
+          symbol: 'Bytes',
+          price: '(u64, FractionLength)'
+        },
+        EstimatesState: {
+          _enum: [
+            'InActive',
+            'Active',
+            'WaitingPayout',
+            'Completed'
+          ]
+        },
+        EstimatesType: {
+          _enum: [
+            'DEVIATION', 'RANGE'
+          ]
+        },
+        FractionLength: 'u32',
+        HttpError: {
+          _enum: {
+            IoErr: 'Bytes',
+            TimeOut: 'Bytes',
+            StatusErr: '(Bytes,u16)',
+            ParseErr: 'Bytes'
+          }
+        },
+        HttpErrTracePayload: {
+          trace_data: 'HttpErrTraceData<BlockNumber, AuthorityId>',
+          auth: 'AuthorityId',
+          public: 'MultiSigner'
+        },
+        HttpErrTraceData: {
+          block_number: 'BlockNumber',
+          err_auth: 'AuthorityId',
+          err_status: 'HttpError',
+          tip: 'Bytes'
+        },
+        JsonNumberValue: {
+          integer: 'u64',
+          fraction: 'u64',
+          fraction_length: 'u32',
+          exponent: 'u32'
+        },
+        Keys: 'SessionKeys4',
+        LookupSource: 'MultiAddress',
+        MultiplierOption: {
+          _enum: [
+            'Base1', 'Base2', 'Base5'
+          ]
+        },
+        OcwControlData: {
+          need_verifier_check: 'bool',
+          open_free_price_reporter: 'bool',
+          open_paid_price_reporter: 'bool'
+        },
+        OffchainSignature: 'MultiSignature',
+        PaidValue: {
+          create_bn: 'BlockNumber',
+          amount: 'BalanceOf',
+          is_income: 'bool'
+        },
+        PurchasedId: 'Bytes',
+        PriceKey: 'Vec<u8>',
+        PriceToken: 'Bytes',
+        PreCheckPayload: {
+          block_number: 'BlockNumber',
+          pre_check_stash: 'AccountId',
+          pre_check_auth: 'AuthorityId',
+          auth: 'AuthorityId',
+          public: 'MultiSigner'
+        },
+        PreCheckResultPayload: {
+          block_number: 'BlockNumber',
+          pre_check_list: 'Vec<PreCheckStruct>',
+          pre_check_stash: 'AccountId',
+          pre_check_auth: 'AuthorityId',
+          public: 'MultiSigner'
+        },
+        PreCheckCompareLog: {
+          chain_avg_price_list: 'BTreeMap<Bytes, (u64, FractionLength)>',
+          validator_up_price_list: 'BTreeMap<Bytes, (u64, FractionLength)>',
+          raw_precheck_list: 'Vec<PreCheckStruct>'
+        },
+        PreCheckStruct: {
+          price_key: 'Vec<u8>',
+          number_val: 'JsonNumberValue',
+          max_offset: 'Percent',
+          timestamp: 'u64'
+        },
+        PricePayloadSubPrice: '(PriceKey, u64, FractionLength, JsonNumberValue, u64)',
+        PricePayloadSubJumpBlock: '(PriceKey, RequestInterval)',
+        PricePayload: {
+          block_number: 'BlockNumber',
+          price: 'Vec<PricePayloadSubPrice>',
+          jump_block: 'Vec<PricePayloadSubJumpBlock>',
+          auth: 'AuthorityId',
+          public: 'MultiSigner'
+        },
+        PreCheckStatus: {
+          _enum: [
+            'Review',
+            'Prohibit',
+            'Pass'
+          ]
+        },
+        PurchasedRequestData: {
+          account_id: 'AccountId',
+          offer: 'BalanceOf',
+          create_bn: 'BlockNumber',
+          submit_threshold: 'u8',
+          max_duration: 'u64',
+          request_keys: 'Vec<Vec<u8>>'
+        },
+        PurchasedPricePayload: {
+          block_number: 'BlockNumber',
+          purchase_id: 'Vec<u8>',
+          price: 'Vec<PricePayloadSubPrice>',
+          auth: 'AuthorityId',
+          public: 'MultiSigner'
+        },
+        PurchasedAvgPriceData: {
+          create_bn: 'u64',
+          reached_type: 'u8',
+          price_data: '(u64, FractionLength)'
+        },
+        PurchasedDefaultData: {
+          submit_threshold: 'u8',
+          max_duration: 'u64',
+          avg_keep_duration: 'u64'
+        },
+        PurchasedForceCleanPayload: {
+          BlockNumber: 'BlockNumber',
+          purchase_id_list: 'Vec<Vec<u8>>',
+          auth: 'AuthorityId',
+          public: 'MultiSigner'
+        },
+        PurchaseId: 'Vec<u8>',
+        Releases: {
+          _enum: [
+            'V1_0_0_Ancestral',
+            'V1_0_1_HttpErrUpgrade',
+            'V1_1_0_HttpErrUpgrade',
+            'V1_2_0'
+          ]
+        },
+        RequestInterval: 'u8',
+        StatusErr: '(u16)',
+        SymbolEstimatesConfig: {
+          symbol: 'Bytes',
+          estimates_type: 'EstimatesType',
+          id: 'u64',
+          ticket_price: 'Balance',
+          symbol_completed_price: 'u64',
+          symbol_fraction: 'FractionLength',
+          start: 'BlockNumber',
+          end: 'BlockNumber',
+          distribute: 'BlockNumber',
+          deviation: 'Option<Permill>',
+          range: 'Option<Vec<u64>>',
+          total_reward: 'Balance',
+          state: 'EstimatesState'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/argon.ts

@@ -0,0 +1,60 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+/* eslint-disable sort-keys */
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Satoshis: 'u64'
+      }
+    }
+  ],
+  runtime: {
+    MiningSlotApi: [
+      {
+        methods: {
+          next_slot_era: {
+            description: 'Get the next slot block start and end',
+            params: [],
+            type: '(BlockNumber, BlockNumber)'
+          }
+        },
+        version: 1
+      }
+    ],
+    BitcoinApis: [
+      {
+        methods: {
+          redemption_rate: {
+            description: 'Get the current redemption rate for a given number of satoshis',
+            params: [
+              {
+                name: 'satoshis',
+                type: 'Satoshis'
+              }
+            ],
+            type: 'Balance'
+          },
+          market_rate: {
+            description: 'Get the current market rate for a given number of satoshis',
+            params: [
+              {
+                name: 'satoshis',
+                type: 'Satoshis'
+              }
+            ],
+            type: 'Balance'
+          }
+        },
+        version: 1
+      }
+    ]
+  }
+};
+
+export default definitions;

packages/apps-config/src/api/spec/astar.ts

@@ -0,0 +1,42 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Keys: 'AccountId',
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        AmountOf: 'Amount',
+        Amount: 'i128',
+        SmartContract: {
+          _enum: {
+            Evm: 'H160',
+            Wasm: 'AccountId'
+          }
+        },
+        EraStakingPoints: {
+          total: 'Balance',
+          stakers: 'BTreeMap<AccountId, Balance>',
+          formerStakedEra: 'EraIndex',
+          claimedRewards: 'Balance'
+        },
+        EraRewardAndStake: {
+          rewards: 'Balance',
+          staked: 'Balance'
+        },
+        EraIndex: 'u32'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/bajun.ts

@@ -0,0 +1,20 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+/* eslint-disable sort-keys */
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/basilisk.ts

@@ -0,0 +1,97 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  alias: { tokens: { AccountData: 'OrmlAccountData' } },
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        AssetPair: { asset_in: 'AssetId', asset_out: 'AssetId' },
+        Amount: 'i128',
+        AmountOf: 'Amount',
+        Address: 'AccountId',
+        OrmlAccountData: { free: 'Balance', frozen: 'Balance', reserved: 'Balance' },
+        Fee: { numerator: 'u32', denominator: 'u32' },
+        BalanceInfo: { amount: 'Balance', assetId: 'AssetId' },
+        Chain: { genesisHash: 'Vec<u8>', lastBlockHash: 'Vec<u8>' },
+        Currency: 'AssetId',
+        CurrencyId: 'AssetId',
+        CurrencyIdOf: 'AssetId',
+        Intention: {
+          who: 'AccountId',
+          asset_sell: 'AssetId',
+          asset_buy: 'AssetId',
+          amount: 'Balance',
+          discount: 'bool',
+          sell_or_buy: 'IntentionType'
+        },
+        IntentionId: 'Hash',
+        IntentionType: { _enum: ['SELL', 'BUY'] },
+        LookupSource: 'AccountId',
+        Price: 'Balance',
+        ClassId: 'u64',
+        TokenId: 'u64',
+        ClassData: { is_pool: 'bool' },
+        TokenData: { locked: 'bool' },
+        ClassInfo: { metadata: 'Vec<u8>', total_issuance: 'TokenId', owner: 'AccountId', data: 'ClassData' },
+        TokenInfo: { metadata: 'Vec<u8>', owner: 'AccountId', data: 'TokenData' },
+        ClassInfoOf: 'ClassInfo',
+        TokenInfoOf: 'TokenInfo',
+        ClassIdOf: 'ClassId',
+        TokenIdOf: 'TokenId',
+        OrderedSet: 'Vec<AssetId>',
+        VestingSchedule: {
+          start: 'BlockNumber',
+          period: 'BlockNumber',
+          period_count: 'u32',
+          per_period: 'Compact<Balance>'
+        },
+        VestingScheduleOf: 'VestingSchedule',
+        LBPWeight: 'u32',
+        WeightCurveType: { _enum: ['Linear'] },
+        PoolId: 'AccountId',
+        BalanceOf: 'Balance',
+        AssetType: {
+          _enum: {
+            Token: 'Null',
+            PoolShare: '(AssetId,AssetId)'
+          }
+        },
+        Pool: {
+          owner: 'AccountId',
+          start: 'BlockNumber',
+          end: 'BlockNumber',
+          assets: 'AssetPair',
+          initial_weights: 'LBPWeight',
+          final_weights: 'LBPWeight',
+          weight_curve: 'WeightCurveType',
+          pausable: 'bool',
+          paused: 'bool',
+          fee: 'Fee',
+          fee_receiver: 'AccountId'
+        },
+        AssetDetails: {
+          name: 'Vec<u8>',
+          asset_type: 'AssetType',
+          existential_deposit: 'Balance',
+          locked: 'bool'
+        },
+        AssetDetailsT: 'AssetDetails',
+        AssetMetadata: { symbol: 'Vec<u8>', decimals: 'u8' },
+        AssetInstance: 'AssetInstanceV1',
+        MultiLocation: 'MultiLocationV1',
+        MultiAsset: 'MultiAssetV1',
+        Xcm: 'XcmV1',
+        XcmOrder: 'XcmOrderV1'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/beresheet.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import pkg from '@edgeware/node-types';
+
+export default (pkg.spec.typesBundle as { spec: { edgeware: OverrideBundleDefinition } }).spec.edgeware;

packages/apps-config/src/api/spec/bifrost-asgard.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { typesBundleForPezkuwi } from '@bifrost-finance/type-definitions';
+
+export default (typesBundleForPezkuwi as { spec: { asgard: OverrideBundleDefinition } }).spec.asgard;

packages/apps-config/src/api/spec/bifrost-parachain.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { typesBundleForPezkuwi } from '@bifrost-finance/type-definitions';
+
+export default (typesBundleForPezkuwi as { spec: { bifrost: OverrideBundleDefinition } }).spec.bifrost;

packages/apps-config/src/api/spec/bifrost.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { typesBundleForPezkuwi } from '@bifrost-finance/type-definitions';
+
+export default (typesBundleForPezkuwi as { spec: { bifrost: OverrideBundleDefinition } }).spec.bifrost;

packages/apps-config/src/api/spec/bitcountry-pezkuwichain.ts

@@ -0,0 +1,128 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        AssetInfo: {
+          owner: 'AccountId',
+          data: 'AssetData'
+        },
+        AssetData: {
+          name: 'Text',
+          description: 'Text',
+          properties: 'Text',
+          supporters: 'Vec<AccountId>'
+        },
+        AuctionId: 'u64',
+        AuctionItem: {
+          asset_id: 'TokenId',
+          class_id: 'ClassId',
+          recipient: 'AccountId',
+          initial_amount: 'Balance',
+          amount: 'Balance',
+          start_time: 'u32',
+          end_time: 'u32'
+        },
+        AuctionInfo: {
+          bid: 'Option<(AccountId,Balance)>',
+          start: 'BlockNumber',
+          end: 'Option<BlockNumber>'
+        },
+        RentId: 'u64',
+        RentalInfo: {
+          owner: 'AccountId',
+          start: 'BlockNumber',
+          end: 'Option<BlockNumber>',
+          price_per_block: 'Balance'
+        },
+        CountryId: 'u64',
+        CollectionId: 'u64',
+        ClassId: 'u32',
+        TokenId: 'u64',
+        ClassInfoOf: {
+          metadata: 'Vec<u8>',
+          total_issuance: 'TokenId',
+          owner: 'AccountId',
+          data: 'NftClassData'
+        },
+        TokenInfoOf: {
+          metadata: 'Vec<u8>',
+          owner: 'AccountId',
+          data: 'NftAssetData'
+        },
+        NftCollectionData: {
+          name: 'Vec<u8>',
+          owner: 'AccountId',
+          properties: 'Vec<u8>'
+        },
+        TokenType: {
+          _enum: [
+            'Transferrable',
+            'BoundToAddress'
+          ]
+        },
+        NftAssetData: {
+          name: 'Vec<u8>',
+          description: 'Vec<u8>',
+          properties: 'Vec<u8>'
+        },
+        NftClassData: {
+          deposit: 'Balance',
+          properties: 'Vec<u8>',
+          token_type: 'TokenType'
+        },
+        NetworkId: {
+          _enum: {
+            Any: 'Null',
+            Named: 'Vec<u8>',
+            Pezkuwi: 'Null',
+            Dicle: 'Null'
+          }
+        },
+        CurrencyId: {
+          _enum: {
+            Token: 'TokenSymbol'
+          }
+        },
+        TokenSymbol: {
+          _enum: [
+            'NUUM',
+            'AUSD',
+            'ACA',
+            'HEZ'
+          ]
+        },
+        CountryCurrencyId: 'u32',
+        CurrencyIdOf: 'CurrencyId',
+        BalanceIdOf: 'Balance',
+        ChainId: {
+          _enum: {
+            RelayChain: 'Null',
+            ParaChain: 'ParaId'
+          }
+        },
+        XCurrencyId: {
+          chain_id: 'ChainId',
+          currency_id: 'CurrencyId'
+        },
+        GroupCollectionId: 'u64',
+        ClassIdOf: 'u32',
+        TokenIdOf: 'u32',
+        SpotId: 'u32'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/bitcountry-pioneer.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { types } from '@metaverse-network-sdk/type-definitions';
+
+export default types;

packages/apps-config/src/api/spec/bitcountry.ts

@@ -0,0 +1,82 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        AssetInfo: {
+          owner: 'AccountId',
+          data: 'AssetData'
+        },
+        AssetData: {
+          name: 'Text',
+          description: 'Text',
+          properties: 'Text',
+          supporters: 'Vec<AccountId>'
+        },
+        AuctionId: 'u64',
+        AuctionItem: {
+          asset_id: 'TokenId',
+          class_id: 'ClassId',
+          recipient: 'AccountId',
+          initial_amount: 'Balance',
+          amount: 'Balance',
+          start_time: 'u32',
+          end_time: 'u32'
+        },
+        AuctionInfo: {
+          bid: 'Option<(AccountId,Balance)>',
+          start: 'BlockNumber',
+          end: 'Option<BlockNumber>'
+        },
+        RentId: 'u64',
+        RentalInfo: {
+          owner: 'AccountId',
+          start: 'BlockNumber',
+          end: 'Option<BlockNumber>',
+          price_per_block: 'Balance'
+        },
+        CountryId: 'u64',
+        CountryCurrencyId: 'u32',
+        CollectionId: 'u64',
+        ClassId: 'u32',
+        TokenId: 'u64',
+        ClassInfoOf: {
+          metadata: 'Vec<u8>',
+          total_issuance: 'TokenId',
+          owner: 'AccountId',
+          data: 'NftClassData'
+        },
+        TokenInfoOf: {
+          metadata: 'Vec<u8>',
+          owner: 'AccountId',
+          data: 'NftAssetData'
+        },
+        NftCollectionData: {
+          name: 'Vec<u8>',
+          owner: 'AccountId',
+          properties: 'Vec<u8>'
+        },
+        CurrencyId: 'u32',
+        CurrencyIdOf: 'CurrencyId',
+        BalanceIdOf: 'Balance',
+        GroupCollectionId: 'u64',
+        ClassIdOf: 'u32',
+        TokenIdOf: 'u32',
+        SpotId: 'u32'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/bittensor.ts

@@ -0,0 +1,44 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Balance: 'u64',
+        NeuronMetadata: {
+          version: 'u32',
+          ip: 'u128',
+          port: 'u16',
+          ipType: 'u8',
+          uid: 'u32',
+          netuid: 'u16',
+          modality: 'u8',
+          hotkey: 'AccountId',
+          coldkey: 'AccountId',
+          active: 'u32',
+          lastUpdate: 'u64',
+          priority: 'u64',
+          stake: 'u64',
+          rank: 'u64',
+          trust: 'u64',
+          consensus: 'u64',
+          incentive: 'u64',
+          dividends: 'u64',
+          emission: 'u64',
+          bonds: 'Vec<(u32, u64)>',
+          weights: 'Vec<(u32, u32)>'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/centrifuge-chain.ts

@@ -0,0 +1,75 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        AnchorData: {
+          id: 'H256',
+          docRoot: 'H256',
+          anchoredBlock: 'u64'
+        },
+        Fee: {
+          key: 'Hash',
+          price: 'Balance'
+        },
+        PreCommitData: {
+          signingRoot: 'H256',
+          identity: 'H256',
+          expirationBlock: 'u64'
+        },
+        Proof: {
+          leafHash: 'H256',
+          sortedHashes: 'H256'
+        },
+        // MultiAccount
+        MultiAccountData: {
+          threshold: 'u16',
+          signatories: 'Vec<AccountId>',
+          deposit: 'Balance',
+          depositor: 'AccountId'
+        },
+        // Bridge constants
+        ChainId: 'u8',
+        ResourceId: '[u8; 32]',
+        'chainbridge::ChainId': 'u8',
+        DepositNonce: 'u64',
+        // NFT
+        RegistryId: 'H160',
+        TokenId: 'U256',
+        AssetId: {
+          registryId: 'RegistryId',
+          tokenId: 'TokenId'
+        },
+        RegistryInfo: {
+          ownerCanBurn: 'bool',
+          fields: 'Vec<Bytes>'
+        },
+        AssetInfo: {
+          metadata: 'Bytes'
+        },
+        ProofMint: {
+          value: 'Bytes',
+          property: 'Bytes',
+          salt: '[u8; 32]',
+          hashes: 'Vec<Hash>'
+        },
+        MintInfo: {
+          anchorId: 'Hash',
+          staticHashes: '[Hash; 3]',
+          proofs: 'Vec<ProofMint>'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/centrifuge.ts

@@ -0,0 +1,53 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        AnchorData: {
+          id: 'Hash',
+          docRoot: 'Hash',
+          anchoredBlock: 'u64'
+        },
+        ChainId: 'u8',
+        'chainbridge::ChainId': 'u8',
+        DepositNonce: 'u64',
+        Fee: {
+          key: 'Hash',
+          price: 'Balance'
+        },
+        TeyrchainAccountIdOf: 'AccountId',
+        PreCommitData: {
+          signingRoot: 'Hash',
+          identity: 'AccountId',
+          expirationBlock: 'u64'
+        },
+        Proof: {
+          leafHash: 'Hash',
+          sortedHashes: 'Vec<Hash>'
+        },
+        ProxyType: {
+          _enum: [
+            'Any',
+            'NonTransfer',
+            'Governance',
+            '_Staking',
+            'NonProxy'
+          ]
+        },
+        ResourceId: '[u8; 32]',
+        RelayChainAccountId: 'AccountId',
+        RootHashOf: 'Hash'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/chainx.ts

@@ -0,0 +1,462 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'AccountId',
+        LookupSource: 'AccountId',
+        Chain: {
+          _enum: [
+            'ChainX',
+            'Bitcoin',
+            'Ethereum',
+            'Pezkuwi'
+          ]
+        },
+        NetworkType: {
+          _enum: [
+            'Mainnet',
+            'Testnet'
+          ]
+        },
+        AssetType: {
+          _enum: [
+            'Usable',
+            'Locked',
+            'Reserved',
+            'ReservedWithdrawal',
+            'ReservedDexSpot'
+          ]
+        },
+        OrderType: {
+          _enum: [
+            'Limit',
+            'Market'
+          ]
+        },
+        Side: {
+          _enum: [
+            'Buy',
+            'Sell'
+          ]
+        },
+        LockedType: {
+          _enum: [
+            'Bonded',
+            'BondedWithdrawal'
+          ]
+        },
+        Memo: 'Text',
+        AssetInfo: {
+          token: 'String',
+          tokenName: 'String',
+          chain: 'Chain',
+          decimals: 'Decimals',
+          desc: 'String'
+        },
+        TradingPairProfile: {
+          id: 'TradingPairId',
+          currencyPair: 'CurrencyPair',
+          pipDecimals: 'u32',
+          tickDecimals: 'u32',
+          tradable: 'bool'
+        },
+        Order: {
+          props: 'OrderProperty',
+          status: 'OrderStatus',
+          remaining: 'Balance',
+          executedIndices: 'Vec<TradingHistoryIndex>',
+          alreadyFilled: 'Balance',
+          lastUpdateAt: 'BlockNumber'
+        },
+        TradingPairInfo: {
+          latestPrice: 'Price',
+          lastUpdated: 'BlockNumber'
+        },
+        OrderExecutedInfo: {
+          tradingHistoryIdx: 'TradingHistoryIndex',
+          pairId: 'TradingPairId',
+          price: 'Price',
+          maker: 'AccountId',
+          taker: 'AccountId',
+          makerOrderId: 'OrderId',
+          takerOrderId: 'OrderId',
+          turnover: 'Balance',
+          executedAt: 'BlockNumber'
+        },
+        BtcHeaderInfo: {
+          header: 'BtcHeader',
+          height: 'u32'
+        },
+        BtcParams: {
+          maxBits: 'u32',
+          blockMaxFuture: 'u32',
+          targetTimespanSeconds: 'u32',
+          targetSpacingSeconds: 'u32',
+          retargetingFactor: 'u32',
+          retargetingInterval: 'u32',
+          minTimespan: 'u32',
+          maxTimespan: 'u32'
+        },
+        MiningAssetInfo: {
+          assetId: 'AssetId',
+          miningPower: 'FixedAssetPower',
+          rewardPot: 'AccountId',
+          rewardPotBalance: 'RpcBalance',
+          lastTotalMiningWeight: 'RpcMiningWeight',
+          lastTotalMiningWeightUpdate: 'BlockNumber'
+        },
+        MiningDividendInfo: {
+          own: 'Balance',
+          other: 'Balance',
+          insufficientStake: 'Balance'
+        },
+        AssetLedger: {
+          lastTotalMiningWeight: 'MiningWeight',
+          lastTotalMiningWeightUpdate: 'BlockNumber'
+        },
+        MinerLedger: {
+          lastMiningWeight: 'MiningWeight',
+          lastMiningWeightUpdate: 'BlockNumber',
+          lastClaim: 'Option<BlockNumber>'
+        },
+        ClaimRestriction: {
+          stakingRequirement: 'StakingRequirement',
+          frequencyLimit: 'BlockNumber'
+        },
+        NominatorInfo: {
+          lastRebond: 'Option<BlockNumber>'
+        },
+        BondRequirement: {
+          selfBonded: 'Balance',
+          total: 'Balance'
+        },
+        Unbonded: {
+          value: 'Balance',
+          lockedUntil: 'BlockNumber'
+        },
+        ValidatorLedger: {
+          totalNomination: 'Balance',
+          lastTotalVoteWeight: 'VoteWeight',
+          lastTotalVoteWeightUpdate: 'BlockNumber'
+        },
+        NominatorLedger: {
+          nomination: 'Balance',
+          lastVoteWeight: 'VoteWeight',
+          lastVoteWeightUpdate: 'BlockNumber',
+          unbondedChunks: 'Vec<Unbonded>'
+        },
+        ValidatorProfile: {
+          registeredAt: 'BlockNumber',
+          isChilled: 'bool',
+          lastChilled: 'Option<BlockNumber>',
+          referralId: 'ReferralId'
+        },
+        GlobalDistribution: {
+          treasury: 'u32',
+          mining: 'u32'
+        },
+        MiningDistribution: {
+          asset: 'u32',
+          staking: 'u32'
+        },
+        InclusionFee: {
+          baseFee: 'Balance',
+          lenFee: 'Balance',
+          adjustedWeightFee: 'Balance'
+        },
+        FeeDetails: {
+          inclusionFee: 'Option<InclusionFee<Balance>>',
+          extraFee: 'Balance',
+          tip: 'Balance',
+          finalFee: 'Balance'
+        },
+        UnbondedIndex: 'u32',
+        Token: 'Text',
+        Desc: 'Text',
+        AddrStr: 'Text',
+        HandicapInfo: 'Handicap',
+        Price: 'u128',
+        OrderId: 'u64',
+        TradingPairId: 'u32',
+        TradingHistoryIndex: 'u64',
+        PriceFluctuation: 'u32',
+        BtcAddress: 'Text',
+        FixedAssetPower: 'u32',
+        StakingRequirement: 'u32',
+        Decimals: 'u8',
+        CurrencyPair: {
+          base: 'AssetId',
+          quote: 'AssetId'
+        },
+        OrderStatus: {
+          _enum: [
+            'Created',
+            'PartialFill',
+            'Filled',
+            'PartialFillAndCanceled',
+            'Canceled'
+          ]
+        },
+        AssetId: 'u32',
+        MiningWeight: 'u128',
+        VoteWeight: 'u128',
+        ReferralId: 'Text',
+        AssetRestriction: {
+          _enum: [
+            'Move',
+            'Transfer',
+            'Deposit',
+            'Withdraw',
+            'DestroyWithdrawal',
+            'DestroyFree'
+          ]
+        },
+        AssetRestrictions: {
+          bits: 'u32'
+        },
+        BtcHeader: 'Vec<u8>',
+        BtcNetwork: {
+          _enum: [
+            'Mainnet',
+            'Testnet'
+          ]
+        },
+        OrderInfo: 'Order',
+        Amount: 'i128',
+        AmountOf: 'Amount',
+        CurrencyIdOf: 'AssetId',
+        CurrencyId: 'AssetId',
+        Handicap: {
+          highestBid: 'Price',
+          lowestAsk: 'Price'
+        },
+        OrderProperty: {
+          id: 'OrderId',
+          side: 'Side',
+          price: 'Price',
+          amount: 'Amount',
+          pairId: 'TradingPairId',
+          submitter: 'AccountId',
+          orderType: 'OrderType',
+          createdAt: 'BlockNumber'
+        },
+        TotalAssetInfo: {
+          info: 'AssetInfo',
+          balance: 'BTreeMap<AssetType, Balance>',
+          isOnline: 'bool',
+          restrictions: 'AssetRestrictions'
+        },
+        WithdrawalRecordId: 'u32',
+        WithdrawalState: {
+          _enum: [
+            'Applying',
+            'Processing',
+            'NormalFinish',
+            'RootFinish',
+            'NormalCancel',
+            'RootCancel'
+          ]
+        },
+        WithdrawalRecord: {
+          assetId: 'AssetId',
+          applicant: 'AccountId',
+          balance: 'Balance',
+          addr: 'AddrStr',
+          ext: 'Memo',
+          height: 'BlockNumber'
+        },
+        WithdrawalLimit: {
+          minimalWithdrawal: 'Balance',
+          fee: 'Balance'
+        },
+        TrusteeInfoConfig: {
+          minTrusteeCount: 'u32',
+          maxTrusteeCount: 'u32'
+        },
+        GenericTrusteeIntentionProps: {
+          about: 'Text',
+          hotEntity: 'Vec<u8>',
+          coldEntity: 'Vec<u8>'
+        },
+        GenericTrusteeSessionInfo: {
+          trusteeList: 'Vec<AccountId>',
+          threshold: 'u16',
+          hotAddress: 'Vec<u8>',
+          coldAddress: 'Vec<u8>'
+        },
+        ChainAddress: 'Vec<u8>',
+        BtcTrusteeType: 'Vec<u8>',
+        BtcTrusteeAddrInfo: {
+          addr: 'BtcAddress',
+          redeemScript: 'Vec<u8>'
+        },
+        BtcTrusteeIntentionProps: {
+          about: 'Text',
+          hotEntity: 'BtcTrusteeType',
+          coldEntity: 'BtcTrusteeType'
+        },
+        BtcTrusteeSessionInfo: {
+          trusteeList: 'Vec<AccountId>',
+          threshold: 'u16',
+          hotAddress: 'BtcTrusteeAddrInfo',
+          coldAddress: 'BtcTrusteeAddrInfo'
+        },
+        BtcTransaction: 'Vec<u8>',
+        BtcPartialMerkleTree: 'Vec<u8>',
+        BtcRelayedTxInfo: {
+          blockHash: 'H256',
+          merkleProof: 'BtcPartialMerkleTree'
+        },
+        BtcHeaderIndex: {
+          hash: 'H256',
+          height: 'u32'
+        },
+        BtcTxResult: {
+          _enum: [
+            'Success',
+            'Failure'
+          ]
+        },
+        BtcTxState: {
+          txType: 'BtcTxType',
+          result: 'BtcTxResult'
+        },
+        BtcTxType: {
+          _enum: [
+            'Withdrawal',
+            'Deposit',
+            'HotAndCold',
+            'TrusteeTransition',
+            'Irrelevance'
+          ]
+        },
+        BtcDepositCache: {
+          txid: 'H256',
+          balance: 'u64'
+        },
+        BtcVoteResult: {
+          _enum: [
+            'Unfinish',
+            'Finish'
+          ]
+        },
+        BtcWithdrawalProposal: {
+          sigState: 'BtcVoteResult',
+          withdrawalIdList: 'Vec<u32>',
+          tx: 'BtcTransaction',
+          trusteeList: 'Vec<(AccountId, bool)>'
+        },
+        BtcTxVerifier: {
+          _enum: [
+            'Recover',
+            'RuntimeInterface'
+          ]
+        },
+        RpcTotalAssetInfo: {
+          info: 'AssetInfo',
+          balance: 'BTreeMap<AssetType, RpcBalance>',
+          isOnline: 'bool',
+          restrictions: 'AssetRestrictions'
+        },
+        RpcOrder: {
+          id: 'OrderId',
+          side: 'Side',
+          price: 'RpcPrice',
+          amount: 'RpcBalance',
+          pairId: 'TradingPairId',
+          submitter: 'AccountId',
+          orderType: 'OrderType',
+          createdAt: 'BlockNumber',
+          status: 'OrderStatus',
+          remaining: 'RpcBalance',
+          executedIndices: 'Vec<TradingHistoryIndex>',
+          alreadyFilled: 'RpcBalance',
+          reservedBalance: 'RpcBalance',
+          lastUpdateAt: 'BlockNumber'
+        },
+        RpcWithdrawalRecord: {
+          assetId: 'AssetId',
+          applicant: 'AccountId',
+          balance: 'RpcBalance',
+          addr: 'String',
+          ext: 'String',
+          height: 'BlockNumber',
+          state: 'WithdrawalState'
+        },
+        RpcMiningDividendInfo: {
+          own: 'RpcBalance',
+          other: 'RpcBalance',
+          insufficientStake: 'RpcBalance'
+        },
+        RpcInclusionFee: {
+          baseFee: 'RpcBalance',
+          lenFee: 'RpcBalance',
+          adjustedWeightFee: 'RpcBalance'
+        },
+        RpcFeeDetails: {
+          inclusionFee: 'Option<RpcInclusionFee>',
+          tip: 'RpcBalance',
+          extraFee: 'RpcBalance',
+          finalFee: 'RpcBalance'
+        },
+        ValidatorInfo: {
+          account: 'AccountId',
+          registeredAt: 'BlockNumber',
+          isChilled: 'bool',
+          lastChilled: 'Option<BlockNumber>',
+          totalNomination: 'RpcBalance',
+          lastTotalVoteWeight: 'RpcVoteWeight',
+          lastTotalVoteWeightUpdate: 'BlockNumber',
+          isValidating: 'bool',
+          selfBonded: 'RpcBalance',
+          referralId: 'String',
+          rewardPotAccount: 'AccountId',
+          rewardPotBalance: 'RpcBalance'
+        },
+        FullPairInfo: {
+          baseCurrency: 'AssetId',
+          highestBid: 'RpcPrice',
+          id: 'TradingPairId',
+          latestPrice: 'RpcPrice',
+          latestPriceUpdatedAt: 'BlockNumber',
+          lowestAsk: 'RpcPrice',
+          maxValidBid: 'RpcPrice',
+          minValidAsk: 'RpcPrice',
+          pipDecimals: 'u32',
+          quoteCurrency: 'AssetId',
+          tickDecimals: 'u32',
+          tradable: 'bool'
+        },
+        Depth: {
+          asks: 'Vec<(RpcPrice, RpcBalance)>',
+          bids: 'Vec<(RpcPrice, RpcBalance)>'
+        },
+        Page: {
+          pageIndex: 'u32',
+          pageSize: 'u32',
+          data: 'Vec<RpcOrder>'
+        },
+        String: 'Text',
+        Balance: 'u128',
+        RpcPrice: 'String',
+        RpcBalance: 'String',
+        RpcMiningWeight: 'String',
+        RpcVoteWeight: 'String',
+        FullIdentification: 'ValidatorId',
+        WithdrawalRecordOf: 'WithdrawalRecord'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/clover-pezkuwichain.ts

@@ -0,0 +1,74 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Amount: 'i128',
+        AmountOf: 'Amount',
+        Balance: 'u128',
+        CurrencyId: {
+          _enum: ['CLV', 'CUSDT', 'HEZ', 'CETH']
+        },
+        CurrencyIdOf: 'CurrencyId',
+        CurrencyTypeEnum: {
+          _enum: ['CLV', 'CUSDT', 'HEZ', 'CETH']
+        },
+        PairKey: 'u64',
+        Rate: 'FixedU128',
+        Ratio: 'FixedU128',
+        Price: 'FixedU128',
+        Share: 'u128',
+        OracleKey: 'CurrencyId',
+        CurrencyInfo: {
+          id: 'CurrencyId',
+          name: 'CurrencyTypeEnum'
+        },
+        ExchangeInfo: {
+          balance: 'Balance',
+          routes: 'Vec<CurrencyTypeEnum>'
+        },
+        PoolId: {
+          _enum: {
+            Swap: 'u64'
+          }
+        },
+        EcdsaSignature: '[u8; 65]',
+        EvmAddress: 'H160',
+        ExitSucceed: {
+          _enum: ['Stopped', 'Returned', 'Suicided']
+        },
+        ExitRevert: {
+          _enum: ['Reverted']
+        },
+        ExitError: {
+          _enum: [
+            'StackUnderflow', 'StackOverflow', 'InvalidJump', 'InvalidRange', 'DesignatedInvalid', 'CallTooDeep',
+            'CreateCollision', 'CreateContractLimit', 'OutOfOffset', 'OutOfGas', 'OutOfFund', 'PCUnderflow', 'CreateEmpty',
+            'Other<String>'
+          ]
+        },
+        ExitFatal: {
+          _enum: ['NotSupported', 'UnhandledInterrupt', 'CallErrorAsFatal', 'Other<String>']
+        },
+        ExitReason: {
+          _enum: ['Succeed<ExitSucceed>',
+            'Error<ExitError>',
+            'Revert<ExitRevert>',
+            'Fatal<ExitFatal>'
+          ]
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/clover.ts

@@ -0,0 +1,32 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Amount: 'i128',
+        Keys: 'SessionKeys4',
+        AmountOf: 'Amount',
+        Balance: 'u128',
+        Rate: 'FixedU128',
+        Ratio: 'FixedU128',
+        EcdsaSignature: '[u8; 65]',
+        EvmAddress: 'H160',
+        EthereumTxHash: 'H256',
+        BridgeNetworks: {
+          _enum: ['BSC', 'Ethereum', 'CloverPara']
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/coinversation.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'AccountId',
+        LookupSource: 'AccountId'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/communeai.ts

@@ -0,0 +1,44 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Balance: 'u64',
+        NeuronMetadata: {
+          version: 'u32',
+          ip: 'u128',
+          port: 'u16',
+          ipType: 'u8',
+          uid: 'u32',
+          netuid: 'u16',
+          modality: 'u8',
+          hotkey: 'AccountId',
+          coldkey: 'AccountId',
+          active: 'u32',
+          lastUpdate: 'u64',
+          priority: 'u64',
+          stake: 'u64',
+          rank: 'u64',
+          trust: 'u64',
+          consensus: 'u64',
+          incentive: 'u64',
+          dividends: 'u64',
+          emission: 'u64',
+          bonds: 'Vec<(u32, u64)>',
+          weights: 'Vec<(u32, u32)>'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/competitors-club.ts

@@ -0,0 +1,82 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        ClassId: 'u64',
+        ClassInfoOf: 'ClassId',
+        BalanceOf: 'Balance',
+        BalanceReservableOf: 'BalanceOf',
+        Moment: 'u64',
+        Place: {
+          spot: 'u32',
+          payout: 'Balance'
+        },
+        Competitor: {
+          vie_id: '[u8;16]',
+          staked: 'bool',
+          submitted_winner: 'bool'
+        },
+        Vie: {
+          operator: 'AccountId',
+          stake: 'Balance',
+          places: 'Vec<Place>',
+          time: 'Moment',
+          competitors: 'Vec<AccountId>',
+          memo: 'Vec<u8>'
+        },
+        VieOf: 'Vie',
+        VieReq: {
+          stake: 'Balance',
+          places: 'Vec<Place>',
+          competitors: 'Vec<AccountId>',
+          memo: 'Vec<u8>'
+        },
+        VieRequestOf: 'VieReq',
+        Participants: {
+          AccountId: '[u8;16]'
+        },
+        Operators: {
+          AccountId: '[u8;16]'
+        },
+        StandingReq: {
+          competitor: 'AccountId',
+          spot: 'u32'
+        },
+        PodiumReq: {
+          champion: 'AccountId',
+          podium: 'Vec<StandingReq>'
+        },
+        PodiumReqOf: 'PodiumReq',
+        Trophy: {
+          trophy: '[u8; 16]',
+          competitors: 'Vec<AccountId>',
+          stake: 'Balance',
+          memo: 'Vec<u8>',
+          time: 'u64',
+          podium: 'Vec<StandingReq>'
+        },
+        TokenId: 'u64',
+        TokenInfo: {
+          metadata: 'Vec<u8>',
+          owner: 'AccountId',
+          data: 'Trophy'
+        },
+        TokenInfoOf: 'TokenInfo'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/contracts.ts

@@ -0,0 +1,30 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      minmax: [0, 8],
+      types: {
+        Address: 'AccountId',
+        Keys: 'SessionKeys2',
+        LookupSource: 'AccountId',
+        Schedule: 'ScheduleTo258'
+      }
+    },
+    {
+      // updated to Bizinikiwi master
+      minmax: [9, undefined],
+      types: {
+        Keys: 'SessionKeys2'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/crown-sterling.ts

@@ -0,0 +1,53 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        AccountInfo: {
+          nonce: 'Index',
+          consumers: 'RefCount',
+          providers: 'RefCount',
+          data: 'AccountData'
+        },
+        Balance: 'u128',
+        BalanceOf: 'Balance',
+        AuthorityOf: 'AccountId',
+        PaymentId: '[u8;16]',
+        Payment: {
+          id: 'PaymentId',
+          account_id: 'AccountId',
+          success_url: 'Vec<u8>',
+          failure_url: 'Vec<u8>',
+          paid: 'bool',
+          pay_to: 'AccountId'
+        },
+        PeerId: '(Vec<u8>)',
+        Amendment: {
+          statement: 'Vec<u8>',
+          owners: 'Vec<AccountId>'
+        },
+        BlockNumber: 'u32',
+        VestingSchedule: {
+          start: 'BlockNumber',
+          period: 'BlockNumber',
+          period_count: 'BlockNumber',
+          per_period: 'Compact<Balance>'
+        },
+        VestingScheduleOf: 'VestingSchedule'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/crust.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { typesBundleForPezkuwi } from '@crustio/type-definitions';
+
+export default typesBundleForPezkuwi.spec.crust as unknown as OverrideBundleDefinition;

packages/apps-config/src/api/spec/cumulus-test-parachain.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'AccountId',
+        LookupSource: 'AccountId'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/curio.ts

@@ -0,0 +1,58 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+/* eslint-disable sort-keys */
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        StakingRates: {
+          collatorStakingRate: 'Perquintill',
+          collatorRewardRate: 'Perquintill',
+          delegatorStakingRate: 'Perquintill',
+          delegatorRewardRate: 'Perquintill'
+        }
+      }
+    }
+  ],
+  runtime: {
+    Staking: [
+      {
+        methods: {
+          get_staking_rates: {
+            description: 'Calculate the current staking and reward rates for collators and delegators',
+            params: [],
+            type: 'StakingRates'
+          },
+          get_unclaimed_staking_rewards: {
+            description: 'Calculate the claimable staking rewards for a given account address',
+            params: [
+              {
+                name: 'account',
+                type: 'AccountId32'
+              }
+            ],
+            type: 'Balance'
+          },
+          get_sorted_proposed_candidates: {
+            description: 'Provides a sorted list of collators most suited for given delegator\'s stake amount determined with some heuristic algorithm',
+            params: [
+              {
+                name: 'balance',
+                type: 'Balance'
+              }
+            ],
+            type: 'Vec<AccountId32>'
+          }
+        },
+        version: 1
+      }
+    ]
+  }
+};
+
+export default definitions;

packages/apps-config/src/api/spec/datahighway.ts

@@ -0,0 +1,238 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Keys: 'SessionKeys2',
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        RoamingOperator: '[u8; 16]',
+        RoamingOperatorIndex: 'u64',
+        RoamingNetwork: '[u8; 16]',
+        RoamingNetworkIndex: 'u64',
+        RoamingOrganization: '[u8; 16]',
+        RoamingOrganizationIndex: 'u64',
+        RoamingNetworkServer: '[u8; 16]',
+        RoamingNetworkServerIndex: 'u64',
+        RoamingDevice: '[u8; 16]',
+        RoamingDeviceIndex: 'u64',
+        RoamingRoutingProfile: '[u8; 16]',
+        RoamingRoutingProfileIndex: 'u64',
+        RoamingRoutingProfileAppServer: 'Text',
+        RoamingServiceProfile: '[u8; 16]',
+        RoamingServiceProfileIndex: 'u64',
+        RoamingServiceProfileUplinkRate: 'u32',
+        RoamingServiceProfileDownlinkRate: 'u32',
+        RoamingAccountingPolicy: '[u8; 16]',
+        RoamingAccountingPolicyIndex: 'u64',
+        RoamingAccountingPolicyType: 'Text',
+        RoamingAccountingPolicyUplinkFeeFactor: 'u32',
+        RoamingAccountingPolicyDownlinkFeeFactor: 'u32',
+        RoamingAccountingPolicyConfig: {
+          policy_type: 'Text',
+          subscription_fee: 'Balance',
+          uplink_fee_factor: 'u32',
+          downlink_fee_factor: 'u32'
+        },
+        RoamingAgreementPolicy: '[u8; 16]',
+        RoamingAgreementPolicyIndex: 'u64',
+        RoamingAgreementPolicyActivationType: 'Text',
+        RoamingAgreementPolicyConfig: {
+          policy_activation_type: 'Text',
+          policy_expiry_block: 'Moment'
+        },
+        RoamingNetworkProfile: '[u8; 16]',
+        RoamingNetworkProfileIndex: 'u64',
+        RoamingDeviceProfile: '[u8; 16]',
+        RoamingDeviceProfileIndex: 'u64',
+        RoamingDeviceProfileDevAddr: 'Text',
+        RoamingDeviceProfileDevEUI: 'Text',
+        RoamingDeviceProfileJoinEUI: 'Text',
+        RoamingDeviceProfileVendorID: 'Text',
+        RoamingDeviceProfileConfig: {
+          device_profile_devaddr: 'Text',
+          device_profile_deveui: 'Text',
+          device_profile_joineui: 'Text',
+          device_profile_vendorid: 'Text'
+        },
+        RoamingSession: '[u8; 16]',
+        RoamingSessionIndex: 'u64',
+        RoamingSessionJoinRequest: {
+          session_network_server_id: 'Moment',
+          session_join_requested_at_block: 'Moment'
+        },
+        RoamingSessionJoinAccept: {
+          session_join_request_accept_expiry: 'Moment',
+          session_join_request_accept_accepted_at_block: 'Moment'
+        },
+        RoamingBillingPolicy: '[u8; 16]',
+        RoamingBillingPolicyIndex: 'u64',
+        RoamingBillingPolicyConfig: {
+          policy_next_billing_at_block: 'Moment',
+          policy_frequency_in_blocks: 'Moment'
+        },
+        RoamingChargingPolicy: '[u8; 16]',
+        RoamingChargingPolicyIndex: 'u64',
+        RoamingChargingPolicyConfig: {
+          policy_next_charging_at_block: 'Moment',
+          policy_delay_after_billing_in_blocks: 'u64'
+        },
+        RoamingPacketBundle: '[u8; 16]',
+        RoamingPacketBundleIndex: 'u64',
+        RoamingPacketBundleReceivedAtHome: 'bool',
+        RoamingPacketBundleReceivedPacketsCount: 'u64',
+        RoamingPacketBundleReceivedPacketsOkCount: 'u64',
+        RoamingPacketBundleExternalDataStorageHash: 'Hash',
+        RoamingPacketBundleReceiver: {
+          packet_bundle_received_at_home: 'bool',
+          packet_bundle_received_packets_count: 'u64',
+          packet_bundle_received_packets_ok_count: 'u64',
+          packet_bundle_received_started_at_block: 'Moment',
+          packet_bundle_received_ended_at_block: 'Moment',
+          packet_bundle_external_data_storage_hash: 'Hash'
+        },
+        MiningRatesToken: '[u8; 16]',
+        MiningRatesTokenIndex: 'u64',
+        MiningRatesTokenTokenDOT: 'u32',
+        MiningRatesTokenTokenMXC: 'u32',
+        MiningRatesTokenTokenIOTA: 'u32',
+        MiningRatesTokenMaxToken: 'u32',
+        MiningRatesTokenMaxLoyalty: 'u32',
+        MiningRatesTokenConfig: {
+          token_token_mxc: 'u32',
+          token_token_iota: 'u32',
+          token_token_dot: 'u32',
+          token_max_token: 'u32',
+          token_max_loyalty: 'u32'
+        },
+        MiningRatesHardware: '[u8; 16]',
+        MiningRatesHardwareIndex: 'u64',
+        MiningRatesHardwareSecure: 'u32',
+        MiningRatesHardwareInsecure: 'u32',
+        MiningRatesHardwareMaxHardware: 'u32',
+        MiningRatesHardwareCategory1MaxTokenBonusPerGateway: 'u32',
+        MiningRatesHardwareCategory2MaxTokenBonusPerGateway: 'u32',
+        MiningRatesHardwareCategory3MaxTokenBonusPerGateway: 'u32',
+        MiningRatesHardwareConfig: {
+          hardware_hardware_secure: 'u32',
+          hardware_hardware_insecure: 'u32',
+          hardware_max_hardware: 'u32',
+          hardware_category_1_max_token_bonus_per_gateway: 'u32',
+          hardware_category_2_max_token_bonus_per_gateway: 'u32',
+          hardware_category_3_max_token_bonus_per_gateway: 'u32'
+        },
+        MiningConfigToken: '[u8; 16]',
+        MiningConfigTokenIndex: 'u64',
+        MiningConfigTokenType: 'Text',
+        MiningConfigTokenLockAmount: 'u64',
+        MiningConfigTokenConfig: {
+          token_type: 'Text',
+          token_lock_amount: 'u64',
+          token_lock_start_block: 'Moment',
+          token_lock_interval_blocks: 'Moment'
+        },
+        MiningConfigTokenRequirementsConfig: {
+          token_type: 'Text',
+          token_lock_min_amount: 'u64',
+          token_lock_min_blocks: 'u32'
+        },
+        MiningConfigHardware: '[u8; 16]',
+        MiningConfigHardwareIndex: 'u64',
+        MiningConfigHardwareSecure: 'bool',
+        MiningConfigHardwareType: 'Text',
+        MiningConfigHardwareID: 'u64',
+        MiningConfigHardwareDevEUI: 'u64',
+        MiningConfigHardwareConfig: {
+          hardware_secure: 'bool',
+          hardware_type: 'Text',
+          hardware_id: 'u64',
+          hardware_dev_eui: 'u64',
+          hardware_lock_start_block: 'Moment',
+          hardware_lock_interval_blocks: 'Moment'
+        },
+        MiningSamplingToken: '[u8; 16]',
+        MiningSamplingTokenIndex: 'u64',
+        MiningSamplingTokenSampleLockedAmount: 'u64',
+        MiningSamplingTokenConfig: {
+          token_sample_block: 'Moment',
+          token_sample_locked_amount: 'u64'
+        },
+        MiningSamplingHardware: '[u8; 16]',
+        MiningSamplingHardwareIndex: 'u64',
+        MiningSamplingHardwareSampleHardwareOnline: 'u64',
+        MiningSamplingHardwareConfig: {
+          hardware_sample_block: 'Moment',
+          hardware_sample_hardware_online: 'bool'
+        },
+        MiningEligibilityToken: '[u8; 16]',
+        MiningEligibilityTokenIndex: 'u64',
+        MiningEligibilityTokenCalculatedEligibility: 'u64',
+        MiningEligibilityTokenLockedPercentage: 'u32',
+        MiningEligibilityTokenAuditorAccountID: 'u64',
+        MiningEligibilityTokenResult: {
+          token_calculated_eligibility: 'u64',
+          token_token_locked_percentage: 'u32',
+          token_date_audited: 'Moment',
+          token_auditor_account_id: 'u64'
+        },
+        MiningEligibilityHardware: '[u8; 16]',
+        MiningEligibilityHardwareIndex: 'u64',
+        MiningEligibilityHardwareCalculatedEligibility: 'u64',
+        MiningEligibilityHardwareUptimePercentage: 'u32',
+        MiningEligibilityHardwareAuditorAccountID: 'u64',
+        MiningEligibilityHardwareResult: {
+          hardware_calculated_eligibility: 'u64',
+          hardware_uptime_percentage: 'u32',
+          hardware_block_audited: 'Moment',
+          hardware_auditor_account_id: 'u64'
+        },
+        MiningClaimsToken: '[u8; 16]',
+        MiningClaimsTokenIndex: 'u64',
+        MiningClaimsTokenClaimAmount: 'u64',
+        MiningClaimsTokenClaimResult: {
+          token_claim_amount: 'u64',
+          token_claim_block_redeemed: 'u64'
+        },
+        MiningClaimsHardware: '[u8; 16]',
+        MiningClaimsHardwareIndex: 'u64',
+        MiningClaimsHardwareClaimAmount: 'u64',
+        MiningClaimsHardwareClaimResult: {
+          hardware_claim_amount: 'u64',
+          hardware_claim_block_redeemed: 'u64'
+        },
+        MiningExecutionToken: '[u8; 16]',
+        MiningExecutionTokenIndex: 'u64',
+        MiningExecutionTokenExecutorAccountID: 'u64',
+        MiningExecutionTokenExecutionResult: {
+          token_execution_exector_account_id: 'u64',
+          token_execution_started_block: 'Moment',
+          token_execution_ended_block: 'Moment'
+        },
+        ExchangeRateIndex: 'u64',
+        ExchangeRateConfig: {
+          hbtc: 'u64',
+          dot: 'u64',
+          iota: 'u64',
+          fil: 'u64',
+          decimals_after_point: 'u32'
+        },
+        HBTCRate: 'u64',
+        DOTRate: 'u64',
+        IOTARate: 'u64',
+        FILRate: 'u64',
+        DecimalsAfterPoint: 'u32'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/dock-mainnet.ts

@@ -0,0 +1,9 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// @ts-expect-error No definitions provided in package
+import { spec } from '@docknetwork/node-types';
+
+export default (spec as { 'dock-main-runtime': OverrideBundleDefinition })['dock-main-runtime'];

packages/apps-config/src/api/spec/dock-testnet.ts

@@ -0,0 +1,9 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// @ts-expect-error No definitions provided in package
+import { spec } from '@docknetwork/node-types';
+
+export default (spec as { 'dock-test-runtime': OverrideBundleDefinition })['dock-test-runtime'];

packages/apps-config/src/api/spec/dolphin.ts

@@ -0,0 +1,30 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types:
+      {
+        CurrencyId: {
+          _enum: [
+            'DOL'
+          ]
+        },
+        CurrencyIdOf: 'CurrencyId',
+        Amount: 'i128',
+        AmountOf: 'Amount',
+        AccountInfo: 'AccountInfoWithDualRefCount'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/dotmog.ts

@@ -0,0 +1,81 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        MogwaiStruct: {
+          id: 'Hash',
+          dna: 'Hash',
+          genesis: 'BlockNumber',
+          price: 'Balance',
+          gen: 'u32',
+          rarity: 'RarityType'
+        },
+        MogwaiBios: {
+          mogwai_id: 'Hash',
+          state: 'u32',
+          metaxy: 'Vec<[u8;16]>',
+          intrinsic: 'Balance',
+          level: 'u8',
+          phases: 'Vec<BlockNumber>',
+          adaptations: 'Vec<Hash>'
+        },
+        GameEvent: {
+          id: 'Hash',
+          begin: 'BlockNumber',
+          duration: 'u16',
+          event_type: 'GameEventType',
+          hashes: 'Vec<Hash>',
+          value: 'u64'
+        },
+        GameEventType: {
+          _enum: [
+            'Default',
+            'Hatch'
+          ]
+        },
+        RarityType: {
+          _enum: [
+            'Minor',
+            'Normal',
+            'Rare',
+            'Epic',
+            'Legendary'
+          ]
+        },
+        MogwaicoinAddress: {
+          address: 'Vec<u8>',
+          account: 'AccountId',
+          signature: 'Vec<u8>',
+          state: 'ClaimState',
+          balance: 'Balance'
+        },
+        ClaimState: {
+          _enum: [
+            'None',
+            'Registred',
+            'Verified',
+            'Secured',
+            'Processed',
+            'Holded',
+            'Failed',
+            'Cancelled'
+          ]
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/eave.ts

@@ -0,0 +1,430 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+    // on all versions
+      minmax: [0, undefined],
+      types: {
+        AccountIdOf: 'AccountId',
+        Address: 'MultiAddress',
+        AirDropCurrencyId: {
+          _enum: [
+            'ICE',
+            'EAVE'
+          ]
+        },
+        Amount: 'i128',
+        AmountOf: 'Amount',
+        AsOriginId: 'AuthoritysOriginId',
+        AssetId: 'u64',
+        AssetIdOf: 'AssetId',
+        AuctionId: 'u32',
+        AuctionIdOf: 'AuctionId',
+        AuctionInfo: {
+          bid: 'Option<(AccountId, Balance)>',
+          start: 'BlockNumber',
+          end: 'Option<BlockNumber>'
+        },
+        AuthoritysOriginId: {
+          _enum: [
+            'Root',
+            'EaveTreasury',
+            'CdpTreasury',
+            'ElpTreasury',
+            'DSWF'
+          ]
+        },
+        BalanceInfo: {
+          amount: 'Balance'
+        },
+        BalanceRequest: {
+          amount: 'Balance'
+        },
+        BalanceWrapper: {
+          amount: 'Balance'
+        },
+        BondingLedger: {
+          total: 'Compact<Balance>',
+          active: 'Compact<Balance>',
+          unlocking: 'Vec<UnlockChunk>'
+        },
+        CID: 'Vec<u8>',
+        CallOf: 'Call',
+        CallRequest: {
+          from: 'Option<H160>',
+          to: 'Option<H160>',
+          gasLimit: 'Option<u32>',
+          storageLimit: 'Option<u32>',
+          value: 'Option<U128>',
+          data: 'Option<Bytes>'
+        },
+        ChainId: {
+          _enum: {
+            RelayChain: 'Null',
+            ParaChain: 'ParaId'
+          }
+        },
+        ChangeBalance: {
+          _enum: {
+            NoChange: 'Null',
+            NewValue: 'Balance'
+          }
+        },
+        ChangeOptionRate: {
+          _enum: {
+            NoChange: 'Null',
+            NewValue: 'OptionRate'
+          }
+        },
+        ChangeOptionRatio: {
+          _enum: {
+            NoChange: 'Null',
+            NewValue: 'OptionRatio'
+          }
+        },
+        ChangeRate: {
+          _enum: {
+            NoChange: 'Null',
+            NewValue: 'Rate'
+          }
+        },
+        ChangeRatio: {
+          _enum: {
+            NoChange: 'Null',
+            NewValue: 'Ratio'
+          }
+        },
+        ClassData: {
+          deposit: 'Balance',
+          properties: 'Properties'
+        },
+        ClassId: 'u32',
+        ClassIdOf: 'ClassId',
+        ClassInfoOf: {
+          metadata: 'CID',
+          totalIssuance: 'TokenId',
+          owner: 'AccountId',
+          data: 'ClassData'
+        },
+        CodeInfo: {
+          codeSize: 'u32',
+          refCount: 'u32'
+        },
+        CollateralAuctionItem: {
+          refundRecipient: 'AccountId',
+          currencyId: 'CurrencyId',
+          initialAmount: 'Compact<Balance>',
+          amount: 'Compact<Balance>',
+          target: 'Compact<Balance>',
+          startTime: 'BlockNumber'
+        },
+        CurrencyId: {
+          _enum: {
+            Token: 'TokenSymbol',
+            DEXShare: '(TokenSymbol, TokenSymbol)',
+            ERC20: 'EvmAddress'
+          }
+        },
+        CurrencyIdOf: 'CurrencyId',
+        DataProviderId: {
+          _enum: [
+            'Aggregated',
+            'Eave',
+            'Band'
+          ]
+        },
+        DebitAuctionItem: {
+          initialAmount: 'Compact<Balance>',
+          amount: 'Compact<Balance>',
+          fix: 'Compact<Balance>',
+          startTime: 'BlockNumber'
+        },
+        DelayedDispatchTime: {
+          _enum: {
+            At: 'BlockNumber',
+            After: 'BlockNumber'
+          }
+        },
+        DelayedOrigin: {
+          delay: 'BlockNumber',
+          origin: 'PalletsOrigin'
+        },
+        DestAddress: 'Vec<u8>',
+        DispatchId: 'u32',
+        DispatchTime: {
+          _enum: {
+            At: 'BlockNumber',
+            After: 'BlockNumber'
+          }
+        },
+        ElpUnlockChunk: {
+          value: 'Compact<Balance>',
+          era: 'Compact<EraIndex>'
+        },
+        EvmAccountInfo: {
+          nonce: 'Index',
+          contractInfo: 'Option<EvmContractInfo>',
+          developerDeposit: 'Option<Balance>'
+        },
+        EvmAddress: 'H160',
+        EvmContractInfo: {
+          codeHash: 'H256',
+          maintainer: 'H160',
+          deployed: 'bool'
+        },
+        ExchangeRate: 'FixedU128',
+        GraduallyUpdate: {
+          key: 'StorageKey',
+          targetValue: 'StorageValue',
+          perBlock: 'StorageValue'
+        },
+        Keys: 'SessionKeys2',
+        Ledger: {
+          bonded: 'Balance',
+          unbondingToFree: 'Balance',
+          freePool: 'Balance',
+          toUnbondNextEra: '(Balance, Balance)'
+        },
+        LiquidationStrategy: {
+          _enum: [
+            'Auction',
+            'Exchange'
+          ]
+        },
+        LiquidityPool: {
+          currency_ids: 'Vec<AssetIdOf>',
+          lp_token_id: 'AssetId',
+          pool_config_id: 'u32',
+          pool_reserves: 'Vec<Balance>'
+        },
+        LiquidityPoolConfig_: 'PoolConfig',
+        LiquidityPool_: 'LiquidityPool',
+        LookupSource: 'MultiAddress',
+        NomineeId: 'AccountId',
+        NFTBalance: 'u128',
+        OptionRate: 'Option<Rate>',
+        OptionRatio: 'Option<Ratio>',
+        OracleKey: 'CurrencyId',
+        OracleValue: 'Price',
+        OrderedSet: 'Vec<AccountId>',
+        OrmlAccountData: {
+          free: 'Balance',
+          frozen: 'Balance',
+          reserved: 'Balance'
+        },
+        OrmlBalanceLock: {
+          amount: 'Balance',
+          id: 'LockIdentifier'
+        },
+        OrmlVestingSchedule: {
+          start: 'BlockNumber',
+          period: 'BlockNumber',
+          periodCount: 'u32',
+          perPeriod: 'Compact<Balance>'
+        },
+        PalletBalanceOf: 'Balance',
+        PalletsOrigin: {
+          _enum: {
+            System: 'SystemOrigin',
+            Timestamp: 'Null',
+            RandomnessCollectiveFlip: 'Null',
+            Balances: 'Null',
+            Accounts: 'Null',
+            Currencies: 'Null',
+            Tokens: 'Null',
+            Vesting: 'Null',
+            EaveTreasury: 'Null',
+            Utility: 'Null',
+            Multisig: 'Null',
+            Recovery: 'Null',
+            Proxy: 'Null',
+            Scheduler: 'Null',
+            Indices: 'Null',
+            GraduallyUpdate: 'Null',
+            Authorship: 'Null',
+            Babe: 'Null',
+            Grandpa: 'Null',
+            Staking: 'Null',
+            Session: 'Null',
+            Historical: 'Null',
+            GeneralCouncil: 'CollectiveOrigin',
+            GeneralCouncilMembership: 'Null',
+            EYECouncil: 'CollectiveOrigin',
+            EYECouncilMembership: 'Null',
+            ElpCouncil: 'CollectiveOrigin',
+            ElpCouncilMembership: 'Null',
+            TechnicalCommittee: 'CollectiveOrigin',
+            TechnicalCommitteeMembership: 'Null',
+            Authority: 'DelayedOrigin',
+            ElectionsPhragmen: 'Null',
+            EaveOracle: 'Null',
+            BandOracle: 'Null',
+            OperatorMembershipEave: 'Null',
+            OperatorMembershipBand: 'Null',
+            Auction: 'Null',
+            Rewards: 'Null',
+            OrmlNFT: 'Null',
+            Prices: 'Null',
+            Dex: 'Null',
+            AuctionManager: 'Null',
+            Loans: 'Null',
+            EYE: 'Null',
+            CdpTreasury: 'Null',
+            CdpEngine: 'Null',
+            EmergencyShutdown: 'Null',
+            Elp: 'Null',
+            NomineesElection: 'Null',
+            StakingPool: 'Null',
+            PezkuwiBridge: 'Null',
+            Incentives: 'Null',
+            AirDrop: 'Null',
+            NFT: 'Null',
+            RenVmBridge: 'Null',
+            Contracts: 'Null',
+            EVM: 'Null',
+            Sudo: 'Null',
+            TransactionPayment: 'Null'
+          }
+        },
+        Params: {
+          targetMaxFreeUnbondedRatio: 'Ratio',
+          targetMinFreeUnbondedRatio: 'Ratio',
+          targetUnbondingToFreeRatio: 'Ratio',
+          unbondingToFreeAdjustment: 'Ratio',
+          baseFeeRate: 'Rate'
+        },
+        PezkuwiAccountId: 'AccountId',
+        PezkuwiAccountIdOf: 'PezkuwiAccountId',
+        PoolId: {
+          _enum: {
+            Loans: 'CurrencyId',
+            DexIncentive: 'CurrencyId',
+            DexSaving: 'CurrencyId',
+            Elp: 'Null'
+          }
+        },
+        PoolInfo: {
+          totalShares: 'Compact<Share>',
+          totalRewards: 'Compact<Balance>',
+          totalWithdrawnRewards: 'Compact<Balance>'
+        },
+        Position: {
+          collateral: 'Balance',
+          debit: 'Balance'
+        },
+        Price: 'FixedU128',
+        Properties: {
+          _set: {
+            _bitLength: 8,
+            Transferable: 1,
+            Burnable: 2
+          }
+        },
+        PublicKey: '[u8; 20]',
+        Rate: 'FixedU128',
+        Ratio: 'FixedU128',
+        RedeemStrategy: {
+          _enum: {
+            Immediately: 'Null',
+            Target: 'EraIndex',
+            WaitForUnbonding: 'Null'
+          }
+        },
+        RelaychainAccountId: 'AccountId',
+        RiskManagementParams: {
+          maximumTotalDebitValue: 'Balance',
+          stabilityFee: 'Option<Rate>',
+          liquidationRatio: 'Option<Rate>',
+          liquidationPenalty: 'Option<Rate>',
+          requiredCollateralRatio: 'Option<Rate>'
+        },
+        RpcDataProviderId: 'Text',
+        ScheduleTaskIndex: 'u32',
+        Share: 'u128',
+        StorageKeyBytes: 'Vec<u8>',
+        StorageValue: 'Vec<u8>',
+        StorageValueBytes: 'Vec<u8>',
+        SubAccountStatus: {
+          bonded: 'Balance',
+          available: 'Balance',
+          unbonding: 'Vec<(EraIndex,Balance)>',
+          mockRewardRate: 'Rate'
+        },
+        SurplusAuctionItem: {
+          amount: 'Compact<Balance>',
+          startTime: 'BlockNumber'
+        },
+        TimestampedValue: {
+          value: 'OracleValue',
+          timestamp: 'Moment'
+        },
+        TimestampedValueOf: 'TimestampedValue',
+        TokenBalanceOf: 'Balance',
+        TokenData: {
+          deposit: 'Balance'
+        },
+        TokenId: 'u64',
+        TokenIdOf: 'TokenId',
+        TokenInfo: {
+          name: 'Text',
+          symbol: 'Text',
+          decimals: 'u8',
+          owner: 'AccountId'
+        },
+        TokenInfoOf: {
+          metadata: 'CID',
+          owner: 'AccountId',
+          data: 'TokenData'
+        },
+        TokenSymbol: {
+          _enum: {
+            EAVE: 0,
+            EUSD: 1,
+            HEZ: 2,
+            LDOT: 3,
+            XBTC: 4,
+            RENBTC: 5,
+            INTERBTC: 6,
+            PLM: 7,
+            PHA: 8,
+            HDT: 9,
+            ICE: 128,
+            IUSD: 129,
+            DCL: 130,
+            LKSM: 131,
+            SDN: 135,
+            KILT: 138
+          }
+        },
+        TradingPair: '(CurrencyId,  CurrencyId)',
+        TradingPairProvisionParameters: {
+          minContribution: '(Balance, Balance)',
+          targetProvision: '(Balance, Balance)',
+          accumulatedProvision: '(Balance, Balance)',
+          notBefore: 'BlockNumber'
+        },
+        TradingPairStatus: {
+          _enum: {
+            NotEnabled: 'Null',
+            Provisioning: 'TradingPairProvisionParameters',
+            Enabled: 'Null'
+          }
+        },
+        VestingScheduleOf: 'OrmlVestingSchedule',
+        XCurrencyId: {
+          chainId: 'ChainId',
+          currencyId: 'Vec<u8>'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/edgeware.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import pkg from '@edgeware/node-types';
+
+export default (pkg.spec.typesBundle as { spec: { edgeware: OverrideBundleDefinition } }).spec.edgeware;

packages/apps-config/src/api/spec/elysium.ts

@@ -0,0 +1,38 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+/* eslint-disable sort-keys */
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        Account: {
+          nonce: 'U256',
+          balance: 'U256'
+        },
+        Transaction: {
+          nonce: 'U256',
+          action: 'String',
+          gas_price: 'u64',
+          gas_limit: 'u64',
+          value: 'U256',
+          input: 'Vec<u8>',
+          signature: 'Signature'
+        },
+        Signature: {
+          v: 'u64',
+          r: 'H256',
+          s: 'H256'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/encointer-node-notee.ts

@@ -0,0 +1,254 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // Metadata v14 was introduced here. Hence, we don't need type overrides anymore.
+      minmax: [9, undefined],
+      types: {
+        // Types for the signed extensions still need to be declared.
+        CommunityIdentifier: {
+          geohash: 'GeoHash',
+          digest: 'CidDigest'
+        },
+        GeoHash: '[u8; 5]',
+        // We need to call it `CidDigest` because plain `Digest` is already a bizinikiwi type.
+        CidDigest: '[u8; 4]'
+      }
+    },
+    {
+      // until v14
+      minmax: [0, 8],
+      types: {
+        ShardIdentifier: 'Hash',
+        GetterArgs: '(AccountId, CommunityIdentifier)',
+        Enclave: {
+          pubkey: 'AccountId',
+          mrenclave: 'Hash',
+          timestamp: 'u64',
+          url: 'Text'
+        },
+        PublicGetter: {
+          _enum: {
+            total_issuance: 'CommunityIdentifier',
+            participant_count: 'CommunityIdentifier',
+            meetup_count: 'CommunityIdentifier',
+            ceremony_reward: 'CommunityIdentifier',
+            location_tolerance: 'CommunityIdentifier',
+            time_tolerance: 'CommunityIdentifier',
+            scheduler_state: 'CommunityIdentifier'
+          }
+        },
+        TrustedGetter: {
+          _enum: {
+            balance: '(AccountId, CommunityIdentifier)',
+            participant_index: '(AccountId, CommunityIdentifier)',
+            meetup_index: '(AccountId, CommunityIdentifier)',
+            attestations: '(AccountId, CommunityIdentifier)',
+            meetup_registry: '(AccountId, CommunityIdentifier)'
+          }
+        },
+        TrustedGetterSigned: {
+          getter: 'TrustedGetter',
+          signature: 'Signature'
+        },
+        Getter: {
+          _enum: {
+            public: 'PublicGetter',
+            trusted: 'TrustedGetterSigned'
+          }
+        },
+        ClientRequest: {
+          _enum: {
+            PubKeyWorker: null,
+            MuRaPortWorker: null,
+            StfState: '(Getter, ShardIdentifier)'
+          }
+        },
+        WorkerEncoded: 'Vec<u8>',
+        Request: {
+          shard: 'ShardIdentifier',
+          cyphertext: 'WorkerEncoded'
+        },
+        TrustedCallSigned: {
+          call: 'TrustedCall',
+          nonce: 'u32',
+          signature: 'Signature'
+        },
+        TrustedCall: {
+          _enum: {
+            balance_transfer: 'BalanceTransferArgs',
+            ceremonies_register_participant: 'RegisterParticipantArgs',
+            ceremonies_register_attestations: 'RegisterAttestationsArgs',
+            ceremonies_grant_reputation: 'GrantReputationArgs'
+          }
+        },
+        BalanceTransferArgs: '(AccountId, AccountId, CommunityIdentifier, BalanceType)',
+        RegisterParticipantArgs: '(AccountId, CommunityIdentifier, Option<ProofOfAttendance<MultiSignature, AccountId>>)',
+        RegisterAttestationsArgs: '(AccountId, Vec<Attestation<MultiSignature, AccountId, u64>>)',
+        GrantReputationArgs: '(AccountId, CommunityIdentifier, AccountId)',
+        BalanceType: 'i128',
+        BalanceEntry: {
+          principal: 'BalanceType',
+          lastUpdate: 'BlockNumber'
+        },
+        Demurrage: 'BalanceType',
+
+        BusinessIdentifier: {
+          communityIdentifier: 'CommunityIdentifier',
+          controller: 'AccountId'
+        },
+        OfferingIdentifier: 'u32',
+        BusinessData: {
+          url: 'PalletString',
+          last_oid: 'u32'
+        },
+        OfferingData: {
+          url: 'PalletString'
+        },
+        PalletString: 'Text',
+        IpfsCid: 'Text',
+        FixedI64F64: {
+          bits: 'i128'
+        },
+        CeremonyIndexType: 'u32',
+        CeremonyPhaseType: {
+          _enum: ['Registering', 'Assigning', 'Attesting']
+        },
+        ParticipantIndexType: 'u64',
+        MeetupIndexType: 'u64',
+        AttestationIndexType: 'u64',
+        MeetupAssignment: '(MeetupIndexType, Option<Location>)',
+        MeetupTimeOffsetType: 'i32',
+        Reputation: {
+          _enum: ['Unverified', 'UnverifiedReputable', 'VerifiedUnlinked', 'VerifiedLinked']
+        },
+        CommunityReputation: {
+          communityIdentifier: 'CommunityIdentifier',
+          reputation: 'Reputation'
+        },
+        ClaimOfAttendance: {
+          claimantPublic: 'AccountId',
+          ceremonyIndex: 'CeremonyIndexType',
+          communityIdentifier: 'CommunityIdentifier',
+          meetupIndex: 'MeetupIndexType',
+          location: 'Location',
+          timestamp: 'Moment',
+          numberOfParticipantsConfirmed: 'u32',
+          claimantSignature: 'Option<MultiSignature>'
+        },
+        ClaimOfAttendanceSigningPayload: {
+          claimantPublic: 'AccountId',
+          ceremonyIndex: 'CeremonyIndexType',
+          communityIdentifier: 'CommunityIdentifier',
+          meetupIndex: 'MeetupIndexType',
+          location: 'Location',
+          timestamp: 'Moment',
+          numberOfParticipantsConfirmed: 'u32'
+        },
+        AssignmentCount: {
+          bootstrappers: 'ParticipantIndexType',
+          reputables: 'ParticipantIndexType',
+          endorsees: 'ParticipantIndexType',
+          newbies: 'ParticipantIndexType'
+        },
+        Assignment: {
+          bootstrappersReputables: 'AssignmentParams',
+          endorsees: 'AssignmentParams',
+          newbies: 'AssignmentParams',
+          locations: 'AssignmentParams'
+        },
+        AssignmentParams: {
+          m: 'u64',
+          s1: 'u64',
+          s2: 'u64'
+        },
+        CommunityCeremonyStats: {
+          communityCeremony: '(CommunityIdentifier, CeremonyIndexType)',
+          assignment: 'Assignment',
+          assignmentCount: 'AssignmentCount',
+          meetupCount: 'MeetupIndexType',
+          meetups: 'Vec<Meetup>'
+        },
+        Meetup: {
+          index: 'MeetupIndexType',
+          location: 'LocationRpc',
+          time: 'Moment',
+          registrations: 'Vec<(AccountId, ParticipantRegistration)>'
+        },
+        ParticipantRegistration: {
+          index: 'ParticipantIndexType',
+          registrationType: 'RegistrationType'
+        },
+        RegistrationType: {
+          _enum: ['Bootstrapper', 'Reputable', 'Endorsee', 'Newbie']
+        },
+        // Todo: remove this type does no longer exist in ceremonies, but it still exists in the trusted stuff.
+        Attestation: {
+          claim: 'ClaimOfAttendance',
+          signature: 'MultiSignature',
+          public: 'AccountId'
+        },
+        ProofOfAttendance: {
+          proverPublic: 'AccountId',
+          ceremonyIndex: 'CeremonyIndexType',
+          communityIdentifier: 'CommunityIdentifier',
+          attendeePublic: 'AccountId',
+          attendeeSignature: 'MultiSignature'
+        },
+        CommunityIdentifier: {
+          geohash: 'GeoHash',
+          digest: 'CidDigest'
+        },
+        GeoHash: '[u8; 5]',
+        // We need to call it `CidDigest` because plain `Digest` is already a bizinikiwi type.
+        CidDigest: '[u8; 4]',
+        CommunityCeremony: '(CommunityIdentifier,CeremonyIndexType)',
+        NominalIncomeType: 'BalanceType',
+        // This is used when handling fixed-point numbers that have been serialized with `serialize_fixed` on rusts end,
+        // which is the case when we call any rpc-getters.
+        DegreeRpc: 'Text',
+        // This is used when we need to encode fixed-point numbers with scale-codec, e.g., when using it in an extrinsic.
+        DegreeFixed: 'i128',
+        Location: {
+          lat: 'DegreeFixed',
+          lon: 'DegreeFixed'
+        },
+        LocationRpc: {
+          lat: 'DegreeRpc',
+          lon: 'DegreeRpc'
+        },
+        CidName: {
+          cid: 'CommunityIdentifier',
+          name: 'Text'
+        },
+        CommunityMetadataType: {
+          name: 'Text',
+          symbol: 'Text',
+          assets: 'Text',
+          theme: 'Option<Text>',
+          url: 'Option<Text>'
+        },
+        SystemNumber: 'u32',
+        SchedulerState: '(CeremonyIndexType, CeremonyPhaseType, SystemNumber)'
+      }
+    }
+  ],
+  signedExtensions: {
+    ChargeAssetTxPayment: {
+      extrinsic: {
+        tip: 'Compact<Balance>',
+        assetId: 'Option<CommunityIdentifier>'
+      },
+      payload: {}
+    }
+  }
+};
+
+export default definitions;

packages/apps-config/src/api/spec/encointer-node-teeproxy.ts

@@ -0,0 +1,54 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        CeremonyPhaseType: {
+          _enum: [
+            'Registering',
+            'Assigning',
+            'Attesting'
+          ]
+        },
+        CeremonyIndexType: 'u32',
+        CurrencyIdentifier: 'Hash',
+        CurrencyCeremony: {
+          cid: 'CurrencyIdentifier',
+          cindex: 'CeremonyIndexType'
+        },
+        Location: {
+          lat: 'i64',
+          lon: 'i64'
+        },
+        CurrencyPropertiesType: {
+          name_utf8: 'Text',
+          demurrage_per_block: 'i128'
+        },
+        ShardIdentifier: 'Hash',
+        Request: {
+          shard: 'ShardIdentifier',
+          cyphertext: 'Vec<u8>'
+        },
+        Enclave: {
+          pubkey: 'AccountId',
+          mrenclave: 'Hash',
+          timestamp: 'u64',
+          url: 'Text'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/encointer-para.ts

@@ -0,0 +1,258 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // metadata v14 was introduced here. Hence, we don't need type overrides anymore.
+      minmax: [3, undefined],
+      types: {
+        CommunityIdentifier: {
+          geohash: 'GeoHash',
+          digest: 'CidDigest'
+        },
+        GeoHash: '[u8; 5]',
+        // We need to call it `CidDigest` because plain `Digest` is already a bizinikiwi type.
+        CidDigest: '[u8; 4]'
+      }
+    },
+    {
+      // until metadata v14
+      minmax: [0, 2],
+      types: {
+        ShardIdentifier: 'Hash',
+        GetterArgs: '(AccountId, CommunityIdentifier)',
+        Enclave: {
+          pubkey: 'AccountId',
+          mrenclave: 'Hash',
+          timestamp: 'u64',
+          url: 'Text'
+        },
+        PublicGetter: {
+          _enum: {
+            total_issuance: 'CommunityIdentifier',
+            participant_count: 'CommunityIdentifier',
+            meetup_count: 'CommunityIdentifier',
+            ceremony_reward: 'CommunityIdentifier',
+            location_tolerance: 'CommunityIdentifier',
+            time_tolerance: 'CommunityIdentifier',
+            scheduler_state: 'CommunityIdentifier'
+          }
+        },
+        TrustedGetter: {
+          _enum: {
+            balance: '(AccountId, CommunityIdentifier)',
+            participant_index: '(AccountId, CommunityIdentifier)',
+            meetup_index: '(AccountId, CommunityIdentifier)',
+            attestations: '(AccountId, CommunityIdentifier)',
+            meetup_registry: '(AccountId, CommunityIdentifier)'
+          }
+        },
+        TrustedGetterSigned: {
+          getter: 'TrustedGetter',
+          signature: 'Signature'
+        },
+        Getter: {
+          _enum: {
+            public: 'PublicGetter',
+            trusted: 'TrustedGetterSigned'
+          }
+        },
+        ClientRequest: {
+          _enum: {
+            PubKeyWorker: null,
+            MuRaPortWorker: null,
+            StfState: '(Getter, ShardIdentifier)'
+          }
+        },
+        WorkerEncoded: 'Vec<u8>',
+        Request: {
+          shard: 'ShardIdentifier',
+          cyphertext: 'WorkerEncoded'
+        },
+        TrustedCallSigned: {
+          call: 'TrustedCall',
+          nonce: 'u32',
+          signature: 'Signature'
+        },
+        TrustedCall: {
+          _enum: {
+            balance_transfer: 'BalanceTransferArgs',
+            ceremonies_register_participant: 'RegisterParticipantArgs',
+            ceremonies_register_attestations: 'RegisterAttestationsArgs',
+            ceremonies_grant_reputation: 'GrantReputationArgs'
+          }
+        },
+        BalanceTransferArgs: '(AccountId, AccountId, CommunityIdentifier, BalanceType)',
+        RegisterParticipantArgs: '(AccountId, CommunityIdentifier, Option<ProofOfAttendance<MultiSignature, AccountId>>)',
+        RegisterAttestationsArgs: '(AccountId, Vec<Attestation<MultiSignature, AccountId, u64>>)',
+        GrantReputationArgs: '(AccountId, CommunityIdentifier, AccountId)',
+
+        BalanceType: 'i128',
+        BalanceEntry: {
+          principal: 'BalanceType',
+          lastUpdate: 'BlockNumber'
+        },
+        Demurrage: 'BalanceType',
+
+        BusinessIdentifier: {
+          communityIdentifier: 'CommunityIdentifier',
+          controller: 'AccountId'
+        },
+        OfferingIdentifier: 'u32',
+        BusinessData: {
+          url: 'PalletString',
+          last_oid: 'u32'
+        },
+        OfferingData: {
+          url: 'PalletString'
+        },
+
+        PalletString: 'Text',
+        IpfsCid: 'Text',
+        FixedI64F64: {
+          bits: 'i128'
+        },
+
+        CeremonyIndexType: 'u32',
+        CeremonyPhaseType: {
+          _enum: ['Registering', 'Assigning', 'Attesting']
+        },
+        ParticipantIndexType: 'u64',
+        MeetupIndexType: 'u64',
+        AttestationIndexType: 'u64',
+        MeetupAssignment: '(MeetupIndexType, Option<Location>)',
+        MeetupTimeOffsetType: 'i32',
+        Reputation: {
+          _enum: ['Unverified', 'UnverifiedReputable', 'VerifiedUnlinked', 'VerifiedLinked']
+        },
+        CommunityReputation: {
+          communityIdentifier: 'CommunityIdentifier',
+          reputation: 'Reputation'
+        },
+        ClaimOfAttendance: {
+          claimantPublic: 'AccountId',
+          ceremonyIndex: 'CeremonyIndexType',
+          communityIdentifier: 'CommunityIdentifier',
+          meetupIndex: 'MeetupIndexType',
+          location: 'Location',
+          timestamp: 'Moment',
+          numberOfParticipantsConfirmed: 'u32',
+          claimantSignature: 'Option<MultiSignature>'
+        },
+        ClaimOfAttendanceSigningPayload: {
+          claimantPublic: 'AccountId',
+          ceremonyIndex: 'CeremonyIndexType',
+          communityIdentifier: 'CommunityIdentifier',
+          meetupIndex: 'MeetupIndexType',
+          location: 'Location',
+          timestamp: 'Moment',
+          numberOfParticipantsConfirmed: 'u32'
+        },
+        AssignmentCount: {
+          bootstrappers: 'ParticipantIndexType',
+          reputables: 'ParticipantIndexType',
+          endorsees: 'ParticipantIndexType',
+          newbies: 'ParticipantIndexType'
+        },
+        Assignment: {
+          bootstrappersReputables: 'AssignmentParams',
+          endorsees: 'AssignmentParams',
+          newbies: 'AssignmentParams',
+          locations: 'AssignmentParams'
+        },
+        AssignmentParams: {
+          m: 'u64',
+          s1: 'u64',
+          s2: 'u64'
+        },
+        CommunityCeremonyStats: {
+          communityCeremony: '(CommunityIdentifier, CeremonyIndexType)',
+          assignment: 'Assignment',
+          assignmentCount: 'AssignmentCount',
+          meetupCount: 'MeetupIndexType',
+          meetups: 'Vec<Meetup>'
+        },
+        Meetup: {
+          index: 'MeetupIndexType',
+          location: 'LocationRpc',
+          time: 'Moment',
+          registrations: 'Vec<(AccountId, ParticipantRegistration)>'
+        },
+        ParticipantRegistration: {
+          index: 'ParticipantIndexType',
+          registrationType: 'RegistrationType'
+        },
+        RegistrationType: {
+          _enum: ['Bootstrapper', 'Reputable', 'Endorsee', 'Newbie']
+        },
+        // Todo: remove this type does no longer exist in ceremonies, but it still exists in the trusted stuff.
+        Attestation: {
+          claim: 'ClaimOfAttendance',
+          signature: 'MultiSignature',
+          public: 'AccountId'
+        },
+        ProofOfAttendance: {
+          proverPublic: 'AccountId',
+          ceremonyIndex: 'CeremonyIndexType',
+          communityIdentifier: 'CommunityIdentifier',
+          attendeePublic: 'AccountId',
+          attendeeSignature: 'MultiSignature'
+        },
+
+        CommunityIdentifier: {
+          geohash: 'GeoHash',
+          digest: 'CidDigest'
+        },
+        GeoHash: '[u8; 5]',
+        // We need to call it `CidDigest` because plain `Digest` is already a bizinikiwi type.
+        CidDigest: '[u8; 4]',
+        CommunityCeremony: '(CommunityIdentifier,CeremonyIndexType)',
+        NominalIncomeType: 'BalanceType',
+        // This is used when handling fixed-point numbers that have been serialized with `serialize_fixed` on rusts end,
+        // which is the case when we call any rpc-getters.
+        DegreeRpc: 'Text',
+        // This is used when we need to encode fixed-point numbers with scale-codec, e.g., when using it in an extrinsic.
+        DegreeFixed: 'i128',
+        Location: {
+          lat: 'DegreeFixed',
+          lon: 'DegreeFixed'
+        },
+        LocationRpc: {
+          lat: 'DegreeRpc',
+          lon: 'DegreeRpc'
+        },
+        CidName: {
+          cid: 'CommunityIdentifier',
+          name: 'Text'
+        },
+        CommunityMetadataType: {
+          name: 'Text',
+          symbol: 'Text',
+          assets: 'Text',
+          theme: 'Option<Text>',
+          url: 'Option<Text>'
+        },
+
+        SystemNumber: 'u32',
+        SchedulerState: '(CeremonyIndexType, CeremonyPhaseType, SystemNumber)'
+      }
+    }
+  ],
+  signedExtensions: {
+    ChargeAssetTxPayment: {
+      extrinsic: {
+        tip: 'Compact<Balance>',
+        assetId: 'Option<CommunityIdentifier>'
+      },
+      payload: {}
+    }
+  }
+};
+
+export default definitions;

packages/apps-config/src/api/spec/equilibrium.ts

@@ -0,0 +1,108 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ApiInterfaceRx } from '@pezkuwi/api/types';
+import type { Enum } from '@pezkuwi/types';
+import type { AccountId, AccountIndex, Address, Balance } from '@pezkuwi/types/interfaces';
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+import type { Struct, u64, u128, Vec } from '@pezkuwi/types-codec';
+import type { ITuple } from '@pezkuwi/types-codec/types';
+
+import { map, of } from 'rxjs';
+
+import { memo } from '@pezkuwi/api-derive/util';
+import { U8aFixed } from '@pezkuwi/types-codec';
+
+export interface SignedBalance extends Enum {
+  readonly isPositive: boolean;
+  readonly asPositive: Balance;
+  readonly isNegative: boolean;
+  readonly asNegative: Balance;
+}
+
+export const u64FromCurrency = (currency: string): bigint => {
+  const buf = Buffer.from(currency.toLowerCase());
+  const size = buf.length;
+
+  return buf.reduce((val, digit, i) => {
+    const exp = BigInt(size - 1 - i);
+
+    return BigInt(val) + BigInt(256) ** exp * BigInt(digit);
+  }, BigInt(0));
+};
+
+const TOKENS = ['eq'];
+
+interface EqPrimitivesBalanceAccountData extends Enum {
+  readonly isV0: boolean;
+  readonly asV0: {
+    readonly lock: u128;
+    readonly balance: Vec<ITuple<[u64, EqPrimitivesSignedBalance]>>;
+  } & Struct;
+  readonly type: 'V0';
+}
+
+interface EqPrimitivesSignedBalance extends Enum {
+  readonly isPositive: boolean;
+  readonly asPositive: u128;
+  readonly isNegative: boolean;
+  readonly asNegative: u128;
+  readonly type: 'Positive' | 'Negative';
+}
+
+export const createDerives = (tokens: string[]) => tokens.reduce((prev, token, i) => {
+  const isNative = !i;
+
+  return {
+    ...prev,
+
+    [token]: { customAccount: (instanceId: string, api: ApiInterfaceRx) => {
+      const { registry } = api;
+      const asset = u64FromCurrency(token);
+
+      return memo(instanceId, (address: AccountIndex | AccountId | Address | string) => api.query.system.account(address).pipe(map((v) => {
+        const data = (v as unknown as { data: EqPrimitivesBalanceAccountData }).data;
+
+        const miscFrozen = isNative ? data.asV0.lock : registry.createType('u128', 0);
+        const feeFrozen = miscFrozen;
+        const reserved = registry.createType('u128', 0);
+
+        const entry = data.asV0.balance.find(([assetId]) => {
+          return assetId.toBigInt() === asset;
+        });
+
+        const balance = entry?.[1];
+
+        const free = balance?.isPositive
+          ? balance.asPositive
+          : registry.createType('u128', 0);
+
+        return {
+          feeFrozen, free, miscFrozen, reserved
+        };
+      })));
+    },
+    customLocks: (instanceId: string, api: ApiInterfaceRx) => {
+      const { registry } = api;
+
+      return memo(instanceId, (address: AccountIndex | AccountId | Address | string) => isNative
+        ? api.query.system.account(address).pipe(map((v) => {
+          const data = (v as unknown as { data: EqPrimitivesBalanceAccountData }).data;
+
+          return [{
+            amount: data.asV0.lock,
+            id: new U8aFixed(registry),
+            reasons: ''
+          }];
+        }))
+        : of([]));
+    } }
+  };
+}, {});
+
+const definitions: OverrideBundleDefinition = {
+  derives: createDerives(TOKENS),
+  instances: { balances: TOKENS }
+};
+
+export default definitions;

packages/apps-config/src/api/spec/fantour.ts

@@ -0,0 +1,69 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+/* eslint-disable camelcase */
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Properties: 'u8',
+        NFTMetadata: 'Vec<u8>',
+        BlockNumber: 'u32',
+        BlockNumberOf: 'BlockNumber',
+
+        OrderData: {
+          currencyId: 'Compact<CurrencyIdOf>',
+          price: 'Compact<Balance>',
+          deposit: 'Compact<Balance>',
+          deadline: 'Compact<BlockNumberOf>',
+          categoryId: 'Compact<CategoryIdOf>'
+        },
+
+        CategoryId: 'u32',
+        CategoryIdOf: 'CategoryId',
+        CategoryData: {
+          metadata: 'NFTMetadata',
+          nftCount: 'Compact<Balance>'
+        },
+
+        CurrencyId: 'u32',
+        CurrencyIdOf: 'CurrencyId',
+        Amount: 'i128',
+        AmountOf: 'Amount',
+
+        ClassId: 'u32',
+        ClassIdOf: 'ClassId',
+        ClassInfoOf: {
+          metadata: 'NFTMetadata',
+          totalIssuance: 'TokenId',
+          owner: 'AccountId',
+          data: 'ClassData'
+        },
+        ClassData: {
+          deposit: 'Compact<Balance>',
+          properties: 'Properties',
+          name: 'Vec<u8>',
+          description: 'Vec<u8>',
+          createBlock: 'Compact<BlockNumberOf>'
+        },
+
+        TokenId: 'u64',
+        TokenIdOf: 'TokenId',
+        TokenInfoOf: { metadata: 'NFTMetadata', owner: 'AccountId', data: 'TokenData' },
+        TokenData: {
+          deposit: 'Compact<Balance>',
+          createBlock: 'Compact<BlockNumberOf>'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/ferrum.ts

@@ -0,0 +1,31 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        AccountId: 'EthereumAccountId',
+        AccountId20: 'EthereumAccountId',
+        Address: 'AccountId',
+        LookupSource: 'AccountId',
+        Lookup0: 'AccountId',
+        EthereumSignature: {
+          r: 'H256',
+          s: 'H256',
+          v: 'U8'
+        },
+        ExtrinsicSignature: 'EthereumSignature'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/fragnova.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Not used/included in index.ts as of https://github.com/pezkuwi-js/apps/pull/9243
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { options } from '@fragnova/api-augment';
+
+export default {
+  ...options,
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: options.types
+    }
+  ]
+} as OverrideBundleDefinition;

packages/apps-config/src/api/spec/frequency.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { rpc, runtime, signedExtensions, types } from '@frequency-chain/api-augment';
+
+export default {
+  rpc,
+  runtime,
+  signedExtensions,
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types
+    }
+  ]
+} as OverrideBundleDefinition;

packages/apps-config/src/api/spec/galital-parachain.ts

@@ -0,0 +1,70 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'AccountId',
+        LookupSource: 'AccountId',
+        Account: {
+          nonce: 'U256',
+          balance: 'U256'
+        },
+        Transaction: {
+          nonce: 'U256',
+          action: 'String',
+          gas_price: 'u64',
+          gas_limit: 'u64',
+          value: 'U256',
+          input: 'Vec<u8>',
+          signature: 'Signature'
+        },
+        Signature: {
+          v: 'u64',
+          r: 'H256',
+          s: 'H256'
+        },
+        ClassId: 'u64',
+        TokenId: 'u64',
+        ClassData: 'Vec<u8>',
+        TokenData: 'Vec<u8>',
+        ReportReason: {
+          _enum: [
+            'None',
+            'Illigal',
+            'Plagiarism',
+            'Duplicate',
+            'Reported'
+          ]
+        },
+        ClassInfoOf: {
+          metadata: 'Vec<u8>',
+          total_issuance: 'TokenId',
+
+          owner: 'AccountId',
+          class_data: 'ClassData'
+        },
+        ExtendedInfo: {
+          display_flag: 'bool',
+          report: 'ReportReason',
+          frozen: 'bool'
+        },
+        TokenInfoOf: {
+          metadata: 'Vec<u8>',
+          owner: 'AccountId',
+          class_data: 'ClassData'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/galital.ts

@@ -0,0 +1,75 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        AccountInfo: 'AccountInfoWithTripleRefCount',
+        Account: {
+          nonce: 'U256',
+          balance: 'U256'
+        },
+        Transaction: {
+          nonce: 'U256',
+          action: 'String',
+          gas_price: 'u64',
+          gas_limit: 'u64',
+          value: 'U256',
+          input: 'Vec<u8>',
+          signature: 'Signature'
+        },
+        ChainId: 'u8',
+        ResourceId: '[u8; 32]',
+        DepositNonce: 'u64',
+        ProposalVotes: {
+          votes_for: 'Vec<AccountId>',
+          votes_against: 'Vec<AccountId>',
+          status: 'u8',
+          expiry: 'U256'
+        },
+        ClassId: 'u64',
+        TokenId: 'u64',
+        ClassData: 'Vec<u8>',
+        TokenData: 'Vec<u8>',
+        ReportReason: {
+          _enum: [
+            'None',
+            'Illigal',
+            'Plagiarism',
+            'Duplicate',
+            'Reported'
+          ]
+        },
+        ClassInfoOf: {
+          metadata: 'Vec<u8>',
+          total_issuance: 'TokenId',
+
+          owner: 'AccountId',
+          class_data: 'ClassData'
+        },
+        ExtendedInfo: {
+          display_flag: 'bool',
+          report: 'ReportReason',
+          frozen: 'bool'
+        },
+        TokenInfoOf: {
+          metadata: 'Vec<u8>',
+          owner: 'AccountId',
+          class_data: 'ClassData'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/galois.ts

@@ -0,0 +1,52 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        Balance: 'u128',
+        RefCount: 'u32',
+        Account: {
+          nonce: 'U256',
+          balance: 'U256'
+        },
+        AccountServiceEnum: {
+          _enum: {
+            Nickname: 'String',
+            Ethereum: 'H160'
+          }
+        },
+        MultiAddressDetails: {
+          nickname: 'AccountServiceEnum',
+          ethereum: 'AccountServiceEnum'
+        },
+        Nickname: 'String',
+        Ethereum: 'H160',
+        TransferAmountInfo: {
+          date: 'u64',
+          daily_info: 'Balance',
+          monthly_info: 'Balance',
+          yearly_info: 'Balance'
+        },
+        AccountLimit: {
+          daily_limit: 'Balance',
+          monthly_limit: 'Balance',
+          yearly_limit: 'Balance'
+        },
+        Keys: 'SessionKeys2'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/gamepower.ts

@@ -0,0 +1,76 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        AccountInfo: 'AccountInfoWithDualRefCount',
+        AssetId: 'u64',
+        SeriesId: 'u64',
+        ClassId: 'u32',
+        ClassIdOf: 'ClassId',
+        ClassInfoOf: 'ClassInfo',
+        TokenId: 'u64',
+        TokenIdOf: 'TokenId',
+        TokenInfoOf: 'TokenInfo',
+        ClassInfo: {
+          metadata: 'Vec<u8>',
+          total_issuance: 'TokenId',
+          owner: 'AccountId',
+          data: 'NftClassData'
+        },
+        TokenInfo: {
+          metadata: 'Vec<u8>',
+          owner: 'AccountId',
+          data: 'NftAssetData'
+        },
+        NftSeriesData: {
+          name: 'Vec<u8>',
+          owner: 'AccountId',
+          properties: 'Vec<u8>'
+        },
+        NftClassData: {
+          deposit: 'Balance',
+          properties: 'Vec<u8>',
+          token_type: 'TokenType',
+          collection_type: 'CollectionType',
+          total_supply: 'u64',
+          initial_supply: 'u64'
+        },
+        NftAssetData: {
+          deposit: 'Balance',
+          name: 'Vec<u8>',
+          description: 'Vec<u8>',
+          properties: 'Vec<u8>'
+        },
+        TokenType: {
+          _enum: [
+            'Transferrable',
+            'BoundToAddress'
+          ]
+        },
+        CollectionType: {
+          _enum: [
+            'Collectable',
+            'Wearable',
+            'Executable'
+          ]
+        },
+        ClassProperties: {
+          Transferrable: 'bool',
+          Burnable: 'bool'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/genshiro.ts

@@ -0,0 +1,15 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { createDerives } from './equilibrium.js';
+
+const TOKENS = ['gens'];
+
+const definitions: OverrideBundleDefinition = {
+  derives: createDerives(TOKENS),
+  instances: { balances: TOKENS }
+};
+
+export default definitions;

packages/apps-config/src/api/spec/hanonycash.ts

@@ -0,0 +1,31 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Difficulty: 'U256',
+        DifficultyAndTimestamp: {
+          difficulty: 'Difficulty',
+          timestamp: 'Moment'
+        },
+        Era: {
+          genesisBlockHash: 'H256',
+          finalBlockHash: 'H256',
+          finalStateRoot: 'H256'
+        },
+        RefCount: 'u8'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/heima.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'AccountId',
+        LookupSource: 'AccountId'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/hydrate.ts

@@ -0,0 +1,60 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Amount: 'i128',
+        AmountOf: 'Amount',
+        Address: 'AccountId',
+        OrmlAccountData: {
+          free: 'Balance',
+          frozen: 'Balance',
+          reserved: 'Balance'
+        },
+        Fee: {
+          numerator: 'u32',
+          denominator: 'u32'
+        },
+        BalanceInfo: {
+          amount: 'Balance',
+          assetId: 'AssetId'
+        },
+        CurrencyId: 'AssetId',
+        CurrencyIdOf: 'AssetId',
+        Intention: {
+          who: 'AccountId',
+          asset_sell: 'AssetId',
+          asset_buy: 'AssetId',
+          amount: 'Balance',
+          discount: 'bool',
+          sell_or_buy: 'IntentionType'
+        },
+        IntentionId: 'u128',
+        IntentionType: {
+          _enum: [
+            'SELL',
+            'BUY'
+          ]
+        },
+        LookupSource: 'AccountId',
+        OrderedSet: 'Vec<AssetId>',
+        Price: 'Balance',
+        Chain: {
+          genesisHash: 'Vec<u8>',
+          lastBlockHash: 'Vec<u8>'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/hyperbridge.ts

@@ -0,0 +1,12 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { keccakAsU8a } from '@pezkuwi/util-crypto';
+
+const definitions: OverrideBundleDefinition = {
+  hasher: keccakAsU8a
+};
+
+export default definitions;

packages/apps-config/src/api/spec/idavoll.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'AccountId',
+        LookupSource: 'AccountId'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/imbue.ts

@@ -0,0 +1,30 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+const definitions: OverrideBundleDefinition = {
+  rpc: {
+    proposals: {
+      getProjectKitty: {
+        description: 'Get the escrow address associated with a project',
+        params: [{
+          name: 'project_id',
+          type: 'u32'
+        }],
+        type: 'AccountId'
+      }
+    }
+  },
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress'
+      }
+    }]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/index.ts

@@ -0,0 +1,327 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import acala from './acala.js';
+import ajuna from './ajuna.js';
+import altair from './altair.js';
+import apron from './apron.js';
+import aresGladios from './ares-gladios.js';
+import aresTeyrchain from './ares-parachain.js';
+import argon from './argon.js';
+import astar from './astar.js';
+import bajun from './bajun.js';
+import basilisk from './basilisk.js';
+import beresheet from './beresheet.js';
+import bifrost from './bifrost.js';
+import bifrostAsgard from './bifrost-asgard.js';
+import bifrostTeyrchain from './bifrost-parachain.js';
+import bitcountry from './bitcountry.js';
+import bitcountryPioneer from './bitcountry-pioneer.js';
+import bitcountryTeyrchain from './bitcountry-pezkuwichain.js';
+import bittensor from './bittensor.js';
+import centrifuge from './centrifuge.js';
+import centrifugeChain from './centrifuge-chain.js';
+import chainx from './chainx.js';
+import clover from './clover.js';
+import cloverPezkuwiChain from './clover-pezkuwichain.js';
+import coinversation from './coinversation.js';
+import communeai from './communeai.js';
+import competitorsClub from './competitors-club.js';
+import contracts from './contracts.js';
+import crownSterlingChain from './crown-sterling.js';
+import crust from './crust.js';
+import testPara from './cumulus-test-parachain.js';
+import curio from './curio.js';
+import datahighwayTeyrchain from './datahighway.js';
+import dockMainnet from './dock-mainnet.js';
+import dockTestnet from './dock-testnet.js';
+import dotmog from './dotmog.js';
+import eave from './eave.js';
+import edgeware from './edgeware.js';
+import elysium from './elysium.js';
+import encointerNodeNotee from './encointer-node-notee.js';
+import encointerNodeTeeproxy from './encointer-node-teeproxy.js';
+import encointerPara from './encointer-para.js';
+import equilibrium from './equilibrium.js';
+import fantour from './fantour.js';
+// See https://github.com/pezkuwi-js/apps/pull/9243
+// import fragnova from './fragnova.js';
+import ferrum from './ferrum.js';
+import frequency from './frequency.js';
+import galital from './galital.js';
+import galitalTeyrchain from './galital-parachain.js';
+import galois from './galois.js';
+import gamepower from './gamepower.js';
+import genshiro from './genshiro.js';
+import hanonycash from './hanonycash.js';
+import heima from './heima.js';
+import hydrate from './hydrate.js';
+import hyperbridge from './hyperbridge.js';
+import idavoll from './idavoll.js';
+import imbue from './imbue.js';
+import integritee from './integritee.js';
+import interbtc from './interbtc.js';
+import ipse from './ipse.js';
+import jamton from './jamton.js';
+import jupiter from './jupiter.js';
+import jupiterPezkuwiChain from './jupiter-pezkuwichain.js';
+import jur from './jur.js';
+import khala from './khala.js';
+import kilt from './kilt.js';
+import konomi from './konomi.js';
+import kpron from './kpron.js';
+import kulupu from './kulupu.js';
+import kusari from './kusari.js';
+import kylin from './kylin.js';
+import laminar from './laminar.js';
+import logion from './logion.js';
+import logionTeyrchain from './logion-parachain.js';
+import mangata from './mangata.js';
+import manta from './manta.js';
+import mathchain from './mathchain.js';
+import moonbeam from './moonbeam.js';
+import muse from './muse.js';
+import mybank from './mybank.js';
+import mythos from './mythos.js';
+import neatcoin from './neatcoin.js';
+import neuroweb from './neuroweb.js';
+import nftmart from './nftmart.js';
+import nodle from './nodle.js';
+import oak from './oak.js';
+import opal from './opal.js';
+import opportunity from './opportunity.js';
+import parallel from './parallel.js';
+import parami from './parami.js';
+import peaq from './peaq.js';
+import peerplays from './peerplays.js';
+import pendulum from './pendulum.js';
+import phoenix from './phoenix.js';
+import pichiu from './pichiu.js';
+import polkadex from './polkadex.js';
+import polkafoundry from './polkafoundry.js';
+import polymeshMainnet from './polymesh-mainnet.js';
+import polymeshTestnet from './polymesh-testnet.js';
+import pontem from './pontem.js';
+import prism from './prism.js';
+import quartz from './quartz.js';
+import realis from './realis.js';
+import riochain from './riochain.js';
+import robonomics from './robonomics.js';
+import rootnet from './rootnet.js';
+import sapphire from './sapphire.js';
+import shibuya from './shibuya.js';
+import shiden from './shiden.js';
+import snowbridge from './snowbridge.js';
+import soraBizinikiwi from './soraSubstrate.js';
+import spanner from './spanner.js';
+import stafi from './stafi.js';
+import standard from './standard.js';
+import subdao from './subdao.js';
+import subgame from './subgame.js';
+import subsocial from './subsocial.js';
+import subspace from './subspace.js';
+import bizinikiwiContractsNode from './substrateContractsNode.js';
+import swapdex from './swapdex.js';
+import t0rn from './t0rn.js';
+import ternoa from './ternoa.js';
+import torus from './torus.js';
+import trustbase from './trustbase.js';
+import turing from './turing.js';
+import uart from './uart.js';
+import unique from './unique.js';
+import unitnetwork from './unitnetwork.js';
+import unitv from './unitv.js';
+import vln from './vln.js';
+import vlnpezkuwichain from './vln-pezkuwichain.js';
+import vodka from './vodka.js';
+import web3games from './web3games.js';
+import westlake from './westlake.js';
+import zCloak from './zCloak.js';
+import zeitgeist from './zeitgeist.js';
+import zenlink from './zenlink.js';
+import zero from './zero.js';
+
+// NOTE: The mapping is done from specName in state.getRuntimeVersion
+const spec: Record<string, OverrideBundleDefinition> = {
+  Equilibrium: equilibrium,
+  Genshiro: genshiro,
+  VLN: vln,
+  'VLN-PC': vlnpezkuwichain,
+  ...acala,
+  ajuna,
+  altair,
+  amplitude: pendulum,
+  apron,
+  'ares-gladios': aresGladios,
+  'ares-mars': aresTeyrchain,
+  'ares-odyssey': aresTeyrchain,
+  argon,
+  asgard: bifrostAsgard,
+  astar,
+  bajun,
+  basilisk,
+  beresheet,
+  bifrost,
+  'bifrost-teyrchain': bifrostTeyrchain,
+  'bitcountry-node': bitcountry,
+  'bitcountry-teyrchain': bitcountryTeyrchain,
+  bittensor,
+  centrifuge,
+  'centrifuge-chain': centrifugeChain,
+  chainx,
+  'chainx-teyrchain': chainx,
+  clover,
+  'clover-pezkuwichain': cloverPezkuwiChain,
+  coinversation,
+  communeai,
+  'competitors-club': competitorsClub,
+  'continuum-runtime': bitcountryPioneer,
+  contracts,
+  'crown-sterling': crownSterlingChain,
+  crust,
+  'crust-teyrchain': crust,
+  'cumulus-test-teyrchain': testPara,
+  'curio-mainnet': curio,
+  'curio-testnet': curio,
+  datahighway: westlake,
+  'datahighway-teyrchain': datahighwayTeyrchain,
+  dawn: eave,
+  'dev-teyrchain': zenlink,
+  'dock-pos-main-runtime': dockMainnet,
+  'dock-pos-test-runtime': dockTestnet,
+  'dotmog-node': dotmog,
+  edgeware,
+  elysium,
+  'encointer-node-notee': encointerNodeNotee,
+  'encointer-node-teeproxy': encointerNodeTeeproxy,
+  'encointer-teyrchain': encointerPara,
+  fantour,
+  // See https://github.com/pezkuwi-js/apps/pull/9243
+  // fragnova,
+  // 'fragnova-testnet': fragnova,
+  'ferrum-teyrchain': ferrum,
+  foucoco: pendulum,
+  frequency,
+  'frequency-testnet': frequency,
+  galital,
+  'galital-collator': galitalTeyrchain,
+  gamepower,
+  gargantua: hyperbridge,
+  'hack-hydra-dx': hydrate,
+  halongbay: polkafoundry,
+  hanonycash,
+  heiko: parallel,
+  heima,
+  'hydra-dx': hydrate,
+  hyperbridge,
+  idavoll,
+  imbue,
+  'integritee-teyrchain': integritee,
+  'interbtc-teyrchain': interbtc,
+  'interbtc-standalone': interbtc,
+  'interlay-teyrchain': interbtc,
+  'ipse-node': ipse,
+  'jamton-runtime': jamton,
+  'jupiter-prep': jupiter,
+  'jupiter-pezkuwichain': jupiterPezkuwiChain,
+  'jur-chain': jur,
+  'jur-node': jur,
+  kerria: parallel,
+  khala,
+  ...kilt,
+  'kintsugi-teyrchain': interbtc,
+  konomi,
+  kpron,
+  kulupu,
+  kusari,
+  kylin,
+  laminar,
+  logion,
+  'logion-teyrchain': logionTeyrchain,
+  mangata,
+  'mangata-teyrchain': mangata,
+  'manta-node': manta,
+  mathchain,
+  'mathchain-galois': galois,
+  messier: hyperbridge,
+  moonbase: moonbeam,
+  moonbeam,
+  moonriver: moonbeam,
+  moonshadow: moonbeam,
+  muse,
+  'mybank.network Testnet': mybank,
+  mythos,
+  neatcoin,
+  neuroweb,
+  nexus: hyperbridge,
+  nftmart,
+  'node-moonbeam': moonbeam,
+  'node-polkadex': polkadex,
+  'nodle-chain': nodle,
+  oak,
+  opal,
+  opportunity,
+  parallel,
+  parami,
+  'peaq-node': peaq,
+  'peaq-node-dev': peaq,
+  'peaq-node-krest': peaq,
+  peerplays,
+  pendulum,
+  'phoenix-node': phoenix,
+  'phoenix-teyrchain': phoenix,
+  pichiu,
+  'pioneer-runtime': bitcountryPioneer,
+  polymesh_mainnet: polymeshMainnet,
+  polymesh_testnet: polymeshTestnet,
+  'pontem-node': pontem as OverrideBundleDefinition,
+  prism,
+  'quantum-portal-network-teyrchain': ferrum,
+  quartz,
+  realis,
+  'riochain-runtime': riochain,
+  robonomics,
+  root: rootnet,
+  sapphire,
+  shibuya,
+  shiden,
+  snowbridge: snowbridge as OverrideBundleDefinition,
+  'sora-bizinikiwi': soraBizinikiwi,
+  sora_ksm: soraBizinikiwi,
+  'spacewalk-standalone': pendulum,
+  spanner,
+  stafi,
+  standard,
+  steam: eave,
+  subdao,
+  subgame,
+  subsocial: subsocial as OverrideBundleDefinition,
+  subspace,
+  'bizinikiwi-contracts-node': bizinikiwiContractsNode,
+  subzero: zero,
+  swapdex,
+  t0rn,
+  ternoa,
+  'testnet-interlay': interbtc,
+  'testnet-kintsugi': interbtc,
+  torus,
+  trustbase,
+  turing,
+  uart,
+  unique,
+  'unit-node': unitv,
+  'unit-teyrchain': unitv,
+  'unitnetwork-node': unitnetwork,
+  'unitnetwork-teyrchain': unitnetwork,
+  unorthodox: standard,
+  vanilla: parallel,
+  vara: standard,
+  vodka,
+  'web3games-node': web3games,
+  'zcloak-network': zCloak,
+  zeitgeist
+};
+
+export default spec;

packages/apps-config/src/api/spec/integritee.ts

@@ -0,0 +1,33 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        Enclave: {
+          mrenclave: 'Hash',
+          pubkey: 'AccountId',
+          timestamp: 'u64',
+          url: 'Text'
+        },
+        LookupSource: 'MultiAddress',
+        Request: {
+          cyphertext: 'Vec<u8>',
+          shard: 'ShardIdentifier'
+        },
+        ShardIdentifier: 'Hash'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/interbtc.ts

@@ -0,0 +1,80 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment */
+
+import type { Observable } from 'rxjs';
+import type { ApiInterfaceRx } from '@pezkuwi/api/types';
+import type { DeriveBalancesAll } from '@pezkuwi/api-derive/types';
+import type { Balance } from '@pezkuwi/types/interfaces';
+import type { FrameSystemAccountInfo } from '@pezkuwi/types/lookup';
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import interbtc from '@interlay/interbtc-types';
+import { combineLatest, map } from 'rxjs';
+
+import { memo } from '@pezkuwi/api-derive/util';
+import { TypeRegistry, U128 } from '@pezkuwi/types';
+import { BN, formatBalance } from '@pezkuwi/util';
+
+function balanceOf (number: number | string): U128 {
+  return new U128(new TypeRegistry(), number);
+}
+
+function defaultAccountBalance (): DeriveBalancesAll {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return {
+    accountNonce: new BN(1),
+    additional: [],
+    availableBalance: balanceOf(0),
+    freeBalance: balanceOf(0),
+    lockedBalance: balanceOf(0),
+    lockedBreakdown: [],
+    namedReserves: [],
+    reservedBalance: balanceOf(0)
+  } as any;
+}
+
+interface OrmlAccountData {
+  free: Balance,
+  reserved: Balance,
+  frozen: Balance,
+}
+
+export function getBalance (
+  instanceId: string,
+  api: ApiInterfaceRx
+): () => Observable<DeriveBalancesAll> {
+  const nativeToken = api.registry.chainTokens[0] || formatBalance.getDefaults().unit;
+
+  return memo(
+    instanceId,
+    (account: string): Observable<DeriveBalancesAll> =>
+      combineLatest<[any, any]>([api.query.tokens.accounts(account, { Token: nativeToken }), api.query.system.account(account)]).pipe(
+        map(([data, systemAccount]: [OrmlAccountData, FrameSystemAccountInfo]): DeriveBalancesAll => {
+          return {
+            ...defaultAccountBalance(),
+            accountId: api.registry.createType('AccountId', account),
+            accountNonce: systemAccount.nonce,
+            availableBalance: api.registry.createType('Balance', data.free.sub(data.frozen)),
+            freeBalance: data.free,
+            lockedBalance: data.frozen,
+            reservedBalance: data.reserved
+          };
+        })
+      )
+  );
+}
+
+const definitions: OverrideBundleDefinition = {
+  derives: {
+    balances: {
+      account: getBalance,
+      all: getBalance
+    }
+  },
+
+  ...interbtc
+} as any;
+
+export default definitions;

packages/apps-config/src/api/spec/ipse.ts

@@ -0,0 +1,122 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        test: 'u64',
+        Address: 'IndicesLookupSource',
+        LookupSource: 'IndicesLookupSource',
+        GIB: 'u64',
+        Amount: 'u128',
+        Miner: {
+          account_id: 'AccountId',
+          nickname: 'Vec<u8>',
+          region: 'Vec<u8>',
+          url: 'Vec<u8>',
+          public_key: 'Vec<u8>',
+          stash_address: 'AccountId',
+          capacity: 'u128',
+          unit_price: 'Balance',
+          violation_times: 'u64',
+          total_staking: 'Balance',
+          create_ts: 'u64',
+          update_ts: 'u64'
+        },
+        Order: {
+          miner: 'AccountId',
+          label: 'Vec<u8>',
+          hash: '[u8; 46]',
+          size: 'u128',
+          user: 'AccountId',
+          orders: 'Vec<MinerOrder<AccountId, Balance>>',
+          status: 'OrderStatus',
+          create_ts: 'u64',
+          update_ts: 'u64',
+          duration: 'u64'
+        },
+        MinerOrder: {
+          miner: 'AccountId',
+          day_price: 'Balance',
+          total_price: 'Balance',
+          verify_result: 'bool',
+          verify_ts: 'u64',
+          confirm_ts: 'u64',
+          url: 'Option<Vec<u8>>'
+        },
+        OrderStatus: {
+          _enum: [
+            'Created',
+            'Confirmed',
+            'Expired',
+            'Deleted'
+          ]
+        },
+        MiningInfo: {
+          miner: 'Option<AccountId>',
+          best_dl: 'u64',
+          block: 'u64'
+        },
+        Difficulty: {
+          base_target: 'u64',
+          net_difficulty: 'u64',
+          block: 'u64'
+        },
+        MachineInfo: {
+          plot_size: 'u64',
+          numeric_id: 'u128',
+          update_time: 'BlockNumber',
+          is_stop: 'bool',
+          reward_dest: 'AccountId'
+        },
+        StakingInfo: {
+          miner: 'AccountId',
+          miner_proportion: 'Percent',
+          total_staking: 'Balance',
+          others: 'Vec<(AccountId, Balance, Balance)>'
+        },
+        Oprate: {
+          _enum: [
+            'Add',
+            'Sub'
+          ]
+        },
+        MiningHistory: {
+          total_num: 'u64',
+          history: 'Vec<(BlockNumber, Balance)>'
+        },
+        PostTxTransferData: {
+          verify_status: 'u64',
+          irreversible: 'bool',
+          is_post_transfer: 'bool',
+          contract_account: 'Vec<u8>',
+          from: 'Vec<u8>',
+          to: 'Vec<u8>',
+          quantity: 'u64',
+          memo: 'Vec<u8>'
+        },
+        AddressStatus: {
+          _enum: [
+            'active',
+            'inActive'
+          ]
+        },
+        FetchFailedOf: {
+          block_num: 'BlockNumber',
+          tx: 'Vec<u8>',
+          err: 'Vec<u8>'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/jamton.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { rpc, runtime, signedExtensions, types } from '@jamton/teyrchain-ts-interfaces/bundle';
+
+/* eslint-disable sort-keys */
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types
+    }
+  ],
+  runtime,
+  rpc,
+  signedExtensions
+};
+
+export default definitions;

packages/apps-config/src/api/spec/jupiter-pezkuwichain.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        LookupSource: 'MultiAddress',
+        Address: 'MultiAddress'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/jupiter.ts

@@ -0,0 +1,72 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, 2],
+      types: {
+        LookupSource: 'MultiAddress',
+        Address: 'MultiAddress',
+        AccountInfo: 'AccountInfoWithDualRefCount',
+        FullIdentification: 'AccountId',
+        AuthorityState: {
+          _enum: [
+            'Working',
+            'Waiting'
+          ]
+        },
+        EraIndex: 'u32',
+        ActiveEraInfo: {
+          index: 'EraIndex',
+          start: 'Option<u64>'
+        },
+        UnappliedSlash: {
+          validator: 'AccountId',
+          reporters: 'Vec<AccountId>'
+        }
+      }
+    },
+    {
+      // on all versions
+      minmax: [3, undefined],
+      types: {
+        LookupSource: 'MultiAddress',
+        Address: 'MultiAddress',
+        AccountInfo: 'AccountInfoWithTripleRefCount',
+        AliveContractInfo: {
+          trieId: 'TrieId',
+          storageSize: 'u32',
+          pairCount: 'u32',
+          codeHash: 'CodeHash',
+          rentAllowance: 'Balance',
+          rentPayed: 'Balance',
+          deductBlock: 'BlockNumber',
+          lastWrite: 'Option<BlockNumber>',
+          _reserved: 'Option<Null>'
+        },
+        FullIdentification: 'AccountId',
+        AuthorityState: {
+          _enum: ['Working', 'Waiting']
+        },
+        EraIndex: 'u32',
+        ActiveEraInfo: {
+          index: 'EraIndex',
+          start: 'Option<u64>'
+        },
+        UnappliedSlash: {
+          validator: 'AccountId',
+          reporters: 'Vec<AccountId>'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/jur.ts

@@ -0,0 +1,16 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {}
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/khala.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { typesBundle } from '@phala/typedefs';
+
+export default typesBundle as OverrideBundleDefinition;

packages/apps-config/src/api/spec/kilt.ts

@@ -0,0 +1,10 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { typesBundle } from '@kiltprotocol/type-definitions';
+
+if (!typesBundle.spec) {
+  throw new Error('Unable to find chain definitions');
+}
+
+export default typesBundle.spec;

packages/apps-config/src/api/spec/konomi.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'AccountId',
+        LookupSource: 'AccountId'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/kpron.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'AccountId',
+        LookupSource: 'AccountId'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/kulupu.ts

@@ -0,0 +1,65 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        CurvePoint: {
+          start: 'BlockNumber',
+          reward: 'Balance',
+          taxation: 'Perbill'
+        },
+        Difficulty: 'U256',
+        DifficultyAndTimestamp: {
+          difficulty: 'Difficulty',
+          timestamp: 'Moment'
+        },
+        Era: {
+          genesisBlockHash: 'H256',
+          finalBlockHash: 'H256',
+          finalStateRoot: 'H256'
+        }
+      }
+    },
+    {
+      // swap to MultiAddress in runtime 13
+      minmax: [13, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress'
+      }
+    },
+    {
+      // enable pallet-lockdrop in runtime 17
+      minmax: [17, undefined],
+      types: {
+        CampaignIdentifier: '[u8; 4]'
+      }
+    },
+    {
+      // enable pallet-atomic-swap in runtime 24
+      minmax: [24, undefined],
+      types: {
+        HashedProof: '[u8; 32]',
+        PendingSwap: {
+          source: 'AccountId',
+          action: 'SwapAction',
+          endBlock: 'BlockNumber'
+        },
+        SwapAction: {
+          value: 'Balance'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/kusari.ts

@@ -0,0 +1,82 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        EvmAddress: 'H160',
+        EthereumTxHash: 'H256',
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        AccountInfo: 'AccountInfoWithTripleRefCount',
+        Account: {
+          nonce: 'U256',
+          balance: 'U256'
+        },
+        Transaction: {
+          nonce: 'U256',
+          action: 'String',
+          gas_price: 'u64',
+          gas_limit: 'u64',
+          value: 'U256',
+          input: 'Vec<u8>',
+          signature: 'Signature'
+        },
+        Signature: {
+          v: 'u64',
+          r: 'H256',
+          s: 'H256'
+        },
+        ClassId: 'u64',
+        TokenId: 'u64',
+        ClassData: 'Vec<u8>',
+        TokenData: 'Vec<u8>',
+        ReportReason: {
+          _enum: [
+            'None',
+            'Illigal',
+            'Plagiarism',
+            'Duplicate',
+            'Reported'
+          ]
+        },
+        ClassInfoOf: {
+          metadata: 'Vec<u8>',
+          total_issuance: 'TokenId',
+
+          owner: 'AccountId',
+          class_data: 'ClassData'
+        },
+        ExtendedInfo: {
+          display_flag: 'bool',
+          report: 'ReportReason',
+          frozen: 'bool'
+        },
+        TokenInfoOf: {
+          metadata: 'Vec<u8>',
+          owner: 'AccountId',
+          class_data: 'ClassData'
+        },
+        'bridge::ChainId': 'u8',
+        ChainId: 'u8',
+        ResourceId: '[u8; 32]',
+        DepositNonce: 'u64',
+        ProposalVotes: {
+          votes_for: 'Vec<AccountId>',
+          votes_against: 'Vec<AccountId>',
+          status: 'enum'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/kylin.ts

@@ -0,0 +1,34 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        DataRequest: {
+          para_id: 'Option<ParaId>',
+          account_id: 'Option<AccountId>',
+          requested_block_number: 'BlockNumber',
+          processed_block_number: 'Option<BlockNumber>',
+          requested_timestamp: 'u128',
+          processed_timestamp: 'Option<u128>',
+          payload: 'Text',
+          feed_name: 'Text',
+          is_query: 'bool',
+          url: 'Option<Text>'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/laminar.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { typesBundleForPezkuwi } from '@laminar/type-definitions';
+
+export default typesBundleForPezkuwi.spec.laminar as unknown as OverrideBundleDefinition;

packages/apps-config/src/api/spec/logion-parachain.ts

@@ -0,0 +1,108 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const logionDefault = {
+  Address: 'MultiAddress',
+  LookupSource: 'MultiAddress',
+  PeerId: '(Vec<u8>)',
+  AccountInfo: 'AccountInfoWithDualRefCount',
+  TAssetBalance: 'u128',
+  AssetId: 'u64',
+  AssetDetails: {
+    owner: 'AccountId',
+    issuer: 'AccountId',
+    admin: 'AccountId',
+    freezer: 'AccountId',
+    supply: 'Balance',
+    deposit: 'DepositBalance',
+    max_zombies: 'u32',
+    min_balance: 'Balance',
+    zombies: 'u32',
+    accounts: 'u32',
+    is_frozen: 'bool'
+  },
+  AssetMetadata: {
+    deposit: 'DepositBalance',
+    name: 'Vec<u8>',
+    symbol: 'Vec<u8>',
+    decimals: 'u8'
+  },
+  LocId: 'u128',
+  LegalOfficerCaseOf: {
+    owner: 'AccountId',
+    requester: 'Requester',
+    metadata: 'Vec<MetadataItem>',
+    files: 'Vec<File>',
+    closed: 'bool',
+    loc_type: 'LocType',
+    links: 'Vec<LocLink>',
+    void_info: 'Option<LocVoidInfo<LocId>>',
+    replacer_of: 'Option<LocId>',
+    collection_last_block_submission: 'Option<BlockNumber>',
+    collection_max_size: 'Option<CollectionSize>'
+  },
+  MetadataItem: {
+    name: 'Vec<u8>',
+    value: 'Vec<u8>',
+    submitter: 'AccountId'
+  },
+  LocType: {
+    _enum: [
+      'Transaction',
+      'Identity',
+      'Collection'
+    ]
+  },
+  LocLink: {
+    id: 'LocId',
+    nature: 'Vec<u8>'
+  },
+  File: {
+    hash: 'Hash',
+    nature: 'Vec<u8>',
+    submitter: 'AccountId'
+  },
+  LocVoidInfo: {
+    replacer: 'Option<LocId>'
+  },
+  StorageVersion: {
+    _enum: [
+      'V1',
+      'V2MakeLocVoid',
+      'V3RequesterEnum',
+      'V4ItemSubmitter',
+      'V5Collection'
+    ]
+  },
+  Requester: {
+    _enum: {
+      None: null,
+      Account: 'AccountId',
+      Loc: 'LocId'
+    }
+  },
+  CollectionSize: 'u32',
+  CollectionItemId: 'Hash',
+  CollectionItem: {
+    description: 'Vec<u8>'
+  }
+};
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        ...logionDefault
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/logion.ts

@@ -0,0 +1,337 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import logionDefault, { runtime as logionRuntime, session as logionSession } from '@logion/node-api/interfaces/definitions';
+
+const defaultTypesUpTo109 = {
+  Address: 'MultiAddress',
+  LookupSource: 'MultiAddress',
+  PeerId: '(Vec<u8>)',
+  AccountInfo: 'AccountInfoWithDualRefCount',
+  TAssetBalance: 'u128',
+  AssetId: 'u64',
+  AssetDetails: {
+    owner: 'AccountId',
+    issuer: 'AccountId',
+    admin: 'AccountId',
+    freezer: 'AccountId',
+    supply: 'Balance',
+    deposit: 'DepositBalance',
+    max_zombies: 'u32',
+    min_balance: 'Balance',
+    zombies: 'u32',
+    accounts: 'u32',
+    is_frozen: 'bool'
+  },
+  AssetMetadata: {
+    deposit: 'DepositBalance',
+    name: 'Vec<u8>',
+    symbol: 'Vec<u8>',
+    decimals: 'u8'
+  },
+  LocId: 'u128',
+  LegalOfficerCaseOf: {
+    owner: 'AccountId',
+    requester: 'Requester',
+    metadata: 'Vec<MetadataItem>',
+    files: 'Vec<File>',
+    closed: 'bool',
+    loc_type: 'LocType',
+    links: 'Vec<LocLink>',
+    void_info: 'Option<LocVoidInfo<LocId>>',
+    replacer_of: 'Option<LocId>',
+    collection_last_block_submission: 'Option<BlockNumber>',
+    collection_max_size: 'Option<CollectionSize>'
+  },
+  MetadataItem: {
+    name: 'Vec<u8>',
+    value: 'Vec<u8>',
+    submitter: 'AccountId'
+  },
+  LocType: {
+    _enum: [
+      'Transaction',
+      'Identity',
+      'Collection'
+    ]
+  },
+  LocLink: {
+    id: 'LocId',
+    nature: 'Vec<u8>'
+  },
+  File: {
+    hash: 'Hash',
+    nature: 'Vec<u8>',
+    submitter: 'AccountId'
+  },
+  LocVoidInfo: {
+    replacer: 'Option<LocId>'
+  },
+  StorageVersion: {
+    _enum: [
+      'V1',
+      'V2MakeLocVoid',
+      'V3RequesterEnum',
+      'V4ItemSubmitter',
+      'V5Collection'
+    ]
+  },
+  Requester: {
+    _enum: {
+      None: null,
+      Account: 'AccountId',
+      Loc: 'LocId'
+    }
+  },
+  CollectionSize: 'u32',
+  CollectionItemId: 'Hash',
+  CollectionItem: {
+    description: 'Vec<u8>'
+  }
+};
+
+const defaultTypesUpTo111 = {
+  Address: 'MultiAddress',
+  LookupSource: 'MultiAddress',
+  PeerId: '(Vec<u8>)',
+  AccountInfo: 'AccountInfoWithDualRefCount',
+  TAssetBalance: 'u128',
+  AssetId: 'u64',
+  AssetDetails: {
+    owner: 'AccountId',
+    issuer: 'AccountId',
+    admin: 'AccountId',
+    freezer: 'AccountId',
+    supply: 'Balance',
+    deposit: 'DepositBalance',
+    max_zombies: 'u32',
+    min_balance: 'Balance',
+    zombies: 'u32',
+    accounts: 'u32',
+    is_frozen: 'bool'
+  },
+  AssetMetadata: {
+    deposit: 'DepositBalance',
+    name: 'Vec<u8>',
+    symbol: 'Vec<u8>',
+    decimals: 'u8'
+  },
+  LocId: 'u128',
+  LegalOfficerCaseOf: {
+    owner: 'AccountId',
+    requester: 'Requester',
+    metadata: 'Vec<MetadataItem>',
+    files: 'Vec<File>',
+    closed: 'bool',
+    loc_type: 'LocType',
+    links: 'Vec<LocLink>',
+    void_info: 'Option<LocVoidInfo<LocId>>',
+    replacer_of: 'Option<LocId>',
+    collection_last_block_submission: 'Option<BlockNumber>',
+    collection_max_size: 'Option<CollectionSize>',
+    collection_can_upload: 'bool'
+  },
+  MetadataItem: {
+    name: 'Vec<u8>',
+    value: 'Vec<u8>',
+    submitter: 'AccountId'
+  },
+  LocType: {
+    _enum: [
+      'Transaction',
+      'Identity',
+      'Collection'
+    ]
+  },
+  LocLink: {
+    id: 'LocId',
+    nature: 'Vec<u8>'
+  },
+  File: {
+    hash: 'Hash',
+    nature: 'Vec<u8>',
+    submitter: 'AccountId'
+  },
+  LocVoidInfo: {
+    replacer: 'Option<LocId>'
+  },
+  StorageVersion: {
+    _enum: [
+      'V1',
+      'V2MakeLocVoid',
+      'V3RequesterEnum',
+      'V4ItemSubmitter',
+      'V5Collection',
+      'V6ItemUpload'
+    ]
+  },
+  Requester: {
+    _enum: {
+      None: null,
+      Account: 'AccountId',
+      Loc: 'LocId'
+    }
+  },
+  CollectionSize: 'u32',
+  CollectionItemId: 'Hash',
+  CollectionItem: {
+    description: 'Vec<u8>',
+    files: 'Vec<CollectionItemFile<Hash>>'
+  },
+  CollectionItemFile: {
+    name: 'Vec<u8>',
+    content_type: 'Vec<u8>',
+    fileSize: 'u32',
+    hash: 'Hash'
+  }
+};
+
+const defaultTypesUpTo116 = {
+  Address: 'MultiAddress',
+  LookupSource: 'MultiAddress',
+  OpaquePeerId: 'Vec<u8>',
+  AccountInfo: 'AccountInfoWithDualRefCount',
+  TAssetBalance: 'u128',
+  AssetId: 'u64',
+  AssetDetails: {
+    owner: 'AccountId',
+    issuer: 'AccountId',
+    admin: 'AccountId',
+    freezer: 'AccountId',
+    supply: 'Balance',
+    deposit: 'DepositBalance',
+    max_zombies: 'u32',
+    min_balance: 'Balance',
+    zombies: 'u32',
+    accounts: 'u32',
+    is_frozen: 'bool'
+  },
+  AssetMetadata: {
+    deposit: 'DepositBalance',
+    name: 'Vec<u8>',
+    symbol: 'Vec<u8>',
+    decimals: 'u8'
+  },
+  LocId: 'u128',
+  LegalOfficerCaseOf: {
+    owner: 'AccountId',
+    requester: 'Requester',
+    metadata: 'Vec<MetadataItem>',
+    files: 'Vec<File>',
+    closed: 'bool',
+    loc_type: 'LocType',
+    links: 'Vec<LocLink>',
+    void_info: 'Option<LocVoidInfo<LocId>>',
+    replacer_of: 'Option<LocId>',
+    collection_last_block_submission: 'Option<BlockNumber>',
+    collection_max_size: 'Option<CollectionSize>',
+    collection_can_upload: 'bool'
+  },
+  MetadataItem: {
+    name: 'Vec<u8>',
+    value: 'Vec<u8>',
+    submitter: 'AccountId'
+  },
+  LocType: {
+    _enum: [
+      'Transaction',
+      'Identity',
+      'Collection'
+    ]
+  },
+  LocLink: {
+    id: 'LocId',
+    nature: 'Vec<u8>'
+  },
+  File: {
+    hash: 'Hash',
+    nature: 'Vec<u8>',
+    submitter: 'AccountId'
+  },
+  LocVoidInfo: {
+    replacer: 'Option<LocId>'
+  },
+  StorageVersion: {
+    _enum: [
+      'V1',
+      'V2MakeLocVoid',
+      'V3RequesterEnum',
+      'V4ItemSubmitter',
+      'V5Collection',
+      'V6ItemUpload',
+      'V7ItemToken'
+    ]
+  },
+  Requester: {
+    _enum: {
+      None: null,
+      Account: 'AccountId',
+      Loc: 'LocId'
+    }
+  },
+  CollectionSize: 'u32',
+  CollectionItemId: 'Hash',
+  CollectionItem: {
+    description: 'Vec<u8>',
+    files: 'Vec<CollectionItemFile<Hash>>',
+    token: 'Option<CollectionItemToken>',
+    restricted_delivery: 'bool'
+  },
+  CollectionItemFile: {
+    name: 'Vec<u8>',
+    content_type: 'Vec<u8>',
+    fileSize: 'u32',
+    hash: 'Hash'
+  },
+  CollectionItemToken: {
+    token_type: 'Vec<u8>',
+    token_id: 'Vec<u8>'
+  }
+};
+
+const definitions: OverrideBundleDefinition = {
+  alias: {
+    loAuthorityList: {
+      StorageVersion: 'LoAuthorityListStorageVersion'
+    }
+  },
+  types: [
+    {
+      minmax: [0, 109],
+      types: {
+        ...defaultTypesUpTo109,
+        ...logionSession.types
+      }
+    },
+    {
+      minmax: [110, 111],
+      types: {
+        ...defaultTypesUpTo111,
+        ...logionSession.types
+      }
+    },
+    {
+      minmax: [112, 116],
+      types: {
+        ...defaultTypesUpTo116,
+        ...logionSession.types
+      }
+    },
+    {
+      // Latest
+      minmax: [117, undefined],
+      types: {
+        ...logionDefault.types,
+        ...logionRuntime.types,
+        ...logionSession.types
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/mangata.ts

@@ -0,0 +1,79 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+import type { Observable } from 'rxjs';
+import type { ApiInterfaceRx } from '@pezkuwi/api/types';
+import type { DeriveBalancesAll } from '@pezkuwi/api-derive/types';
+import type { Balance } from '@pezkuwi/types/interfaces';
+import type { FrameSystemAccountInfo } from '@pezkuwi/types/lookup';
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { mangataTypesBundleForPolkadotApps } from '@mangata-finance/type-definitions';
+import { combineLatest, map } from 'rxjs';
+
+import { memo } from '@pezkuwi/api-derive/util';
+import { TypeRegistry, U128 } from '@pezkuwi/types';
+import { BN } from '@pezkuwi/util';
+
+function balanceOf (number: number | string): U128 {
+  return new U128(new TypeRegistry(), number);
+}
+
+function defaultAccountBalance (): DeriveBalancesAll {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return {
+    accountNonce: new BN(1),
+    additional: [],
+    availableBalance: balanceOf(0),
+    freeBalance: balanceOf(0),
+    lockedBalance: balanceOf(0),
+    lockedBreakdown: [],
+    namedReserves: [],
+    reservedBalance: balanceOf(0),
+    vestingLocked: balanceOf(0)
+  } as any;
+}
+
+interface OrmlAccountData {
+  free: Balance,
+  reserved: Balance,
+  frozen: Balance,
+}
+
+export function getBalance (
+  instanceId: string,
+  api: ApiInterfaceRx
+): () => Observable<DeriveBalancesAll> {
+  return memo(
+    instanceId,
+    (account: string): Observable<DeriveBalancesAll> =>
+      combineLatest<[any, any]>([api.query.tokens.accounts(account, 0), api.query.system.account(account)]).pipe(
+        map(([data, systemAccount]: [OrmlAccountData, FrameSystemAccountInfo]): DeriveBalancesAll => {
+          return {
+            ...defaultAccountBalance(),
+            accountId: api.registry.createType('AccountId', account),
+            accountNonce: systemAccount.nonce,
+            availableBalance: api.registry.createType('Balance', data.free.sub(data.frozen)),
+            freeBalance: data.free,
+            lockedBalance: data.frozen,
+            reservedBalance: data.reserved
+          };
+        })
+      )
+  );
+}
+
+const definitions: OverrideBundleDefinition = {
+  derives: {
+    balances: {
+      account: getBalance,
+      all: getBalance
+    }
+  },
+  ...mangataTypesBundleForPolkadotApps
+};
+
+export default definitions;

packages/apps-config/src/api/spec/manta.ts

@@ -0,0 +1,30 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types:
+      {
+        CurrencyId: {
+          _enum: [
+            'MA'
+          ]
+        },
+        CurrencyIdOf: 'CurrencyId',
+        Amount: 'i128',
+        AmountOf: 'Amount',
+        AccountInfo: 'AccountInfoWithDualRefCount'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/mathchain.ts

@@ -0,0 +1,52 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        Balance: 'u128',
+        RefCount: 'u32',
+        Account: {
+          nonce: 'U256',
+          balance: 'U256'
+        },
+        AccountServiceEnum: {
+          _enum: {
+            Nickname: 'String',
+            Ethereum: 'H160'
+          }
+        },
+        MultiAddressDetails: {
+          nickname: 'AccountServiceEnum',
+          ethereum: 'AccountServiceEnum'
+        },
+        Nickname: 'String',
+        Ethereum: 'H160',
+        TransferAmountInfo: {
+          date: 'u64',
+          daily_info: 'Balance',
+          monthly_info: 'Balance',
+          yearly_info: 'Balance'
+        },
+        AccountLimit: {
+          daily_limit: 'Balance',
+          monthly_limit: 'Balance',
+          yearly_limit: 'Balance'
+        },
+        Keys: 'SessionKeys2'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/moonbeam.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { moonbeamDefinitions } from '@moonbeam-network/types-bundle';
+
+export default moonbeamDefinitions;

packages/apps-config/src/api/spec/muse.ts

@@ -0,0 +1,23 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        AccountId: 'EthereumAccountId',
+        Address: 'AccountId',
+        LookupSource: 'AccountId'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/mybank.ts

@@ -0,0 +1,83 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Token: 'u8',
+        DEXShare: '(u8, u8)',
+        CurrencyId: {
+          _enum: {
+            Token: 'Token',
+            DEXShare: 'DEXShare'
+          }
+        },
+        TradingPair: '(CurrencyId, CurrencyId)',
+        CurrencyIds: { _: 'Vec<CurrencyId>' },
+        TradingPairProvisionParameters: {
+          min_contribution: '(Balance, Balance)',
+          target_provision: '(Balance, Balance)',
+          accumulated_provision: '(Balance, Balance)',
+          not_before: 'BlockNumber'
+        },
+        TradingPairStatus: {
+          _enum: {
+            NotEnabled: null,
+            Provisioning: 'TradingPairProvisionParameters',
+            Enabled: null
+          }
+        },
+        PoolId: 'CurrencyId',
+        Price: 'FixedU128',
+        OracleKey: 'u8',
+        OracleValue: 'FixedU128',
+        Amount: 'i128',
+        Balance: 'u128',
+        Ratio: 'FixedU128',
+        InterestInfo: {
+          critical_point: 'Ratio',
+          base: 'Ratio',
+          slope_1: 'Ratio',
+          slope_2: 'Ratio'
+        },
+        AssetPoolInfo: {
+          maximum_total_debit_ratio: 'Ratio',
+          minimum_deposit: 'Balance',
+          minimum_debit: 'Balance',
+          health_ratio: 'Ratio',
+          total_deposit: 'Balance',
+          total_debit: 'Balance',
+          deposit_rate: 'Ratio',
+          debit_rate: 'Ratio',
+          deposit_apy: 'Ratio',
+          debit_apy: 'Ratio',
+          reserve_factor: 'Ratio',
+          interest_info: 'InterestInfo'
+        },
+        LoanInfo: {
+          deposit: 'Balance',
+          debit: 'Balance'
+        },
+        TimestampedValue: {
+          value: 'OracleValue',
+          timestamp: 'u64'
+        },
+        PoolInfo: {
+          total_shares: 'Compact<u128>',
+          total_rewards: 'Compact<u128>',
+          total_withdrawn_rewards: 'Compact<u128>'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/mythos.ts

@@ -0,0 +1,23 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        AccountId: 'EthereumAccountId',
+        Address: 'AccountId',
+        LookupSource: 'AccountId'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/neatcoin.ts

@@ -0,0 +1,30 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      minmax: [0, undefined],
+      types: {
+        Label: 'Vec<u8>',
+        Name: 'Vec<Label>',
+        NameHash: 'H256',
+        Value: {
+          _enum: {
+            U32: 'U32',
+            U64: 'U64',
+            U128: 'U128',
+            Bool: 'Bool'
+          }
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/neuroweb.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'AccountId',
+        LookupSource: 'AccountId'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/nftmart.ts

@@ -0,0 +1,147 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+/* eslint-disable camelcase */
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Properties: 'u8',
+        NFTMetadata: 'Vec<u8>',
+        BlockNumber: 'u32',
+        BlockNumberOf: 'BlockNumber',
+        BlockNumberFor: 'BlockNumber',
+        GlobalId: 'u64',
+        CurrencyId: 'u32',
+        CurrencyIdOf: 'CurrencyId',
+        Amount: 'i128',
+        AmountOf: 'Amount',
+        CategoryId: 'GlobalId',
+        CategoryIdOf: 'CategoryId',
+        ClassId: 'u32',
+        ClassIdOf: 'ClassId',
+        TokenId: 'u64',
+        TokenIdOf: 'TokenId',
+
+        OrmlAccountData: {
+          free: 'Balance',
+          reserved: 'Balance',
+          frozen: 'Balance'
+        },
+
+        OrmlBalanceLock: {
+          amount: 'Balance',
+          id: 'LockIdentifier'
+        },
+
+        ClassInfoOf: {
+          metadata: 'NFTMetadata',
+          totalIssuance: 'Compact<TokenId>',
+          owner: 'AccountId',
+          data: 'ClassData'
+        },
+
+        ClassData: {
+          deposit: 'Compact<Balance>',
+          properties: 'Properties',
+          name: 'Vec<u8>',
+          description: 'Vec<u8>',
+          createBlock: 'Compact<BlockNumberOf>',
+          royaltyRate: 'Compact<PerU16>',
+          categoryIds: 'Vec<CategoryId>'
+        },
+
+        TokenInfoOf: {
+          metadata: 'NFTMetadata',
+          data: 'TokenData',
+          quantity: 'Compact<TokenId>'
+        },
+
+        TokenData: {
+          deposit: 'Compact<Balance>',
+          createBlock: 'Compact<BlockNumberOf>',
+          royalty_rate: 'Compact<PerU16>',
+          creator: 'AccountId',
+          royaltyBeneficiary: 'AccountId'
+        },
+
+        AccountToken: {
+          quantity: 'Compact<TokenId>',
+          reserved: 'Compact<TokenId>'
+        },
+
+        CategoryData: {
+          metadata: 'NFTMetadata',
+          nftCount: 'Compact<Balance>'
+        },
+
+        OrderItem: {
+          classId: 'Compact<ClassId>',
+          tokenId: 'Compact<TokenId>',
+          quantity: 'Compact<TokenId>'
+        },
+
+        OrderOf: {
+          currencyId: 'Compact<CurrencyId>',
+          deposit: 'Compact<Balance>',
+          price: 'Compact<Balance>',
+          deadline: 'Compact<BlockNumberOf>',
+          items: 'Vec<OrderItem>',
+          commissionRate: 'Compact<PerU16>'
+        },
+
+        OfferOf: {
+          currencyId: 'Compact<CurrencyId>',
+          price: 'Compact<Balance>',
+          deadline: 'Compact<BlockNumberOf>',
+          items: 'Vec<OrderItem>',
+          commissionRate: 'Compact<PerU16>'
+        },
+
+        BritishAuctionOf: {
+          currencyId: 'Compact<CurrencyId>',
+          hammerPrice: 'Compact<Balance>',
+          minRaise: 'Compact<PerU16>',
+          deposit: 'Compact<Balance>',
+          initPrice: 'Compact<Balance>',
+          deadline: 'Compact<BlockNumberOf>',
+          allowDelay: 'bool',
+          items: 'Vec<OrderItem>',
+          commissionRate: 'Compact<PerU16>'
+        },
+
+        BritishAuctionBidOf: {
+          lastBidPrice: 'Compact<Balance>',
+          lastBidAccount: 'Option<AccountId>',
+          lastBidBlock: 'Compact<BlockNumberOf>',
+          commissionAgent: 'Option<AccountId>',
+          commissionData: 'Option<Vec<u8>>'
+        },
+
+        DutchAuctionOf: {
+          currencyId: 'Compact<CurrencyId>',
+          deposit: 'Compact<Balance>',
+          minPrice: 'Compact<Balance>',
+          maxPrice: 'Compact<Balance>',
+          deadline: 'Compact<BlockNumberOf>',
+          createdBlock: 'Compact<BlockNumberOf>',
+          items: 'Vec<OrderItem>',
+          allowBritishAuction: 'bool',
+          minRaise: 'Compact<PerU16>',
+          commissionRate: 'Compact<PerU16>'
+        },
+
+        DutchAuctionBidOf: 'BritishAuctionBidOf'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/nodle.ts

@@ -0,0 +1,51 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Amendment: 'Call',
+        Application: {
+          candidate: 'AccountId',
+          candidate_deposit: 'Balance',
+          challenged_block: 'BlockNumber',
+          challenger: 'Option<AccountId>',
+          challenger_deposit: 'Option<Balance>',
+          created_block: 'BlockNumber',
+          metadata: 'Vec<u8>',
+          voters_against: 'Vec<(AccountId, Balance)>',
+          voters_for: 'Vec<(AccountId, Balance)>',
+          votes_against: 'Option<Balance>',
+          votes_for: 'Option<Balance>'
+        },
+        CertificateId: 'AccountId',
+        RootCertificate: {
+          child_revocations: 'Vec<CertificateId>',
+          created: 'BlockNumber',
+          key: 'CertificateId',
+          owner: 'AccountId',
+          renewed: 'BlockNumber',
+          revoked: 'bool',
+          validity: 'BlockNumber'
+        },
+        VestingSchedule: {
+          start: 'BlockNumber',
+          period: 'BlockNumber',
+          period_count: 'u32',
+          per_period: 'Balance'
+        },
+        VestingScheduleOf: 'VestingSchedule'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/oak.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {}
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/opal.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import pkg from '@unique-nft/opal-testnet-types/definitions.js';
+
+export default {
+  rpc: {
+    appPromotion: pkg.appPromotion.rpc,
+    unique: pkg.unique.rpc
+  }
+} as OverrideBundleDefinition;

packages/apps-config/src/api/spec/opportunity.ts

@@ -0,0 +1,9 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// @ts-expect-error No definitions provided in package
+import { opportunityTypes } from '@digitalnative/type-definitions';
+
+export default opportunityTypes as OverrideBundleDefinition;

packages/apps-config/src/api/spec/oz-template.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'AccountId',
+        LookupSource: 'AccountId'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/parallel.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { typesBundleForPezkuwi } from '@parallel-finance/type-definitions';
+
+export default typesBundleForPezkuwi.spec.parallel;

packages/apps-config/src/api/spec/parami.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {}
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/peaq.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { typesBundleForPezkuwi } from '@peaqnetwork/type-definitions';
+
+export default (typesBundleForPezkuwi as { spec: { peaq: OverrideBundleDefinition } }).spec.peaq;

packages/apps-config/src/api/spec/peerplays.ts

@@ -0,0 +1,314 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  rpc: {
+    fractionalNft: {
+      wildcardThreshold: {
+        description: 'Get the wildcard threshold',
+        params: [],
+        type: 'WildcardThresholdType'
+      },
+      wildcardCollectionId: {
+        description: 'Get the wildcard threshold',
+        params: [],
+        type: 'CollectionId'
+      },
+      wildcardDistributionMap: {
+        description: 'Get the wildcard distribution map',
+        params: [],
+        type: 'Vec<(BlockNumber, ItemId)>'
+      },
+      totalFnftsMinted: {
+        description: 'Get the total fNFTs minted',
+        params: [],
+        type: 'TotalfNFTsMintedType'
+      },
+      collectionsCount: {
+        description: 'Get the total number of collections',
+        params: [],
+        type: 'CollectionId'
+      },
+      itemsCount: {
+        description: 'Get the total number of items in a collection',
+        params: [
+          {
+            name: 'collection_id',
+            type: 'CollectionId'
+          }
+        ],
+        type: 'ItemId'
+      },
+      nftInfo: {
+        description: 'Get NFT information for a collection',
+        params: [
+          {
+            name: 'collection_id',
+            type: 'CollectionId'
+          }
+        ],
+        type: 'NftInfo'
+      },
+      owner: {
+        description: 'Get the owner of an item in a collection',
+        params: [
+          {
+            name: 'collection_id',
+            type: 'CollectionId'
+          },
+          {
+            name: 'item_id',
+            type: 'ItemId'
+          }
+        ],
+        type: 'Option<AccountId>'
+      }
+    },
+    potential: {
+      getPotential: {
+        description: 'Get the potential of an account',
+        params: [
+          {
+            name: 'account',
+            type: 'AccountId'
+          }
+        ],
+        type: 'Balance'
+      },
+      getMaxSupply: {
+        description: 'Get the maximum supply',
+        params: [],
+        type: 'BalanceOf'
+      },
+      getTotalPotentialMinted: {
+        description: 'Get the total potential minted',
+        params: [],
+        type: 'BalanceOf'
+      },
+      getMonthSupply: {
+        description: 'Get the month supply',
+        params: [],
+        type: 'BalanceOf'
+      },
+      getMonthPotentialMinted: {
+        description: 'Get the current month total potential minted',
+        params: [],
+        type: 'BalanceOf'
+      },
+      getMonthNumber: {
+        description: 'Get the current month number',
+        params: [],
+        type: 'MonthNumber'
+      },
+      getCycleSupply: {
+        description: 'Get the current cycle supply',
+        params: [],
+        type: 'BalanceOf'
+      },
+      getCyclePotentialMinted: {
+        description: 'Get the current cycle total potential minted',
+        params: [],
+        type: 'BalanceOf'
+      },
+      getCycleNumber: {
+        description: 'Get the current cycle number',
+        params: [],
+        type: 'CycleNumber'
+      },
+      defaultActiveReferralShare: {
+        description: 'Get the default active referral share',
+        params: [],
+        type: 'ActiveReferralShareType'
+      },
+      activeReferralShare: {
+        description: 'Get the active referral share of an account',
+        params: [
+          {
+            name: 'account',
+            type: 'AccountId'
+          }
+        ],
+        type: 'ActiveReferralShareType'
+      }
+    },
+    referral: {
+      activeReferralsCount: {
+        description: 'Get count of active referrals for an account',
+        params: [
+          {
+            name: 'account',
+            type: 'AccountId'
+          }
+        ],
+        type: 'u32'
+      },
+      referrer: {
+        description: 'Get referrer of an account',
+        params: [
+          {
+            name: 'account',
+            type: 'AccountId'
+          }
+        ],
+        type: 'Option<AccountId>'
+      },
+      activeReferrals: {
+        description: 'Get active referrals of an account',
+        params: [
+          {
+            name: 'account',
+            type: 'AccountId'
+          }
+        ],
+        type: 'Option<TreeNode<AccountId>>'
+      },
+      blockProducers: {
+        description: 'Get block producers',
+        params: [],
+        type: 'Vec<AccountId>'
+      },
+      pendingReferrals: {
+        description: 'Get pending referrals of an account',
+        params: [
+          {
+            name: 'account',
+            type: 'AccountId'
+          }
+        ],
+        type: 'Vec<AccountId>'
+      }
+    },
+    rewardPool: {
+      accountId: {
+        description: 'Get the account ID of the reward pool',
+        params: [],
+        type: 'AccountId'
+      },
+      balance: {
+        description: 'Get the balance of the reward pool',
+        params: [],
+        type: 'Balance'
+      },
+      collectionIds: {
+        description: 'Get the set of collection IDs associated with the reward pool',
+        params: [],
+        type: 'BTreeSet<CollectionId>'
+      },
+      itemIds: {
+        description: 'Get the set of item IDs for a given collection in the reward pool',
+        params: [
+          {
+            name: 'collection_id',
+            type: 'CollectionId'
+          }
+        ],
+        type: 'BTreeSet<ItemId>'
+      }
+    },
+    techcommitteemanager: {
+      candidates: {
+        description: 'Get the list of technical committee candidates',
+        params: [],
+        type: 'Vec<AccountId>'
+      },
+      selectedCandidates: {
+        description: 'Get the list of selected technical committee candidates',
+        params: [],
+        type: 'Vec<AccountId>'
+      }
+    },
+    validatormanager: {
+      validators: {
+        description: 'Get the list of validator candidates',
+        params: [],
+        type: 'Vec<AccountId>'
+      },
+      selectedValidators: {
+        description: 'Get the list of selected validators',
+        params: [],
+        type: 'Vec<AccountId>'
+      },
+      activeValidators: {
+        description: 'Get the list of active validators',
+        params: [],
+        type: 'Vec<AccountId>'
+      },
+      offlineValidators: {
+        description: 'Get the list of active validators who went offline',
+        params: [],
+        type: 'Vec<(AccountId, AuthIndex, SessionIndex)>'
+      },
+      offenceValidators: {
+        description: 'Get the list of active validators who made the offence',
+        params: [],
+        type: 'Vec<(AccountId, AuthIndex, SessionIndex)>'
+      },
+      validatorNonce: {
+        description: 'Get validator nonce',
+        params: [],
+        type: 'NonceType'
+      },
+      lastMaintenanceIndex: {
+        description: 'Get last maintenance index',
+        params: [],
+        type: 'MaintenanceIndex'
+      },
+      nextMaintenanceIndex: {
+        description: 'Get next maintenance index',
+        params: [],
+        type: 'MaintenanceIndex'
+      }
+    }
+  },
+  types: [
+    {
+      minmax: [0, undefined],
+      types: {
+        AccountId: 'EthereumAccountId',
+        AccountId20: 'EthereumAccountId',
+        AccountId32: 'EthereumAccountId',
+        ActiveReferralShareType: 'u32',
+        Address: 'AccountId',
+        AuthIndex: 'u32',
+        Balance: 'u128',
+        BalanceOf: 'Balance',
+        BlockNumber: 'u32',
+        BTreeSet: 'Vec',
+        CollectionId: 'u32',
+        CycleNumber: 'u32',
+        EthereumSignature: {
+          r: 'H256',
+          s: 'H256',
+          v: 'U8'
+        },
+        ExtrinsicSignature: 'EthereumSignature',
+        ItemId: 'u32',
+        Lookup0: 'AccountId',
+        LookupSource: 'AccountId',
+        MaintenanceIndex: 'u32',
+        MaintenanceType: 'u32',
+        MaxWildcardEntriesType: 'u32',
+        MonthNumber: 'u32',
+        NftInfo: {
+          address: 'H160',
+          token_id: 'U256'
+        },
+        NonceType: 'u32',
+        SessionIndex: 'u32',
+        TotalfNFTsMintedType: 'u32',
+        TreeNode: {
+          parent: 'Option<AccountId>',
+          children: 'Vec<AccountId>'
+        },
+        WildcardThresholdType: 'u32'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/pendulum.ts

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+import { typesBundleForPezkuwi } from '@pendulum-chain/type-definitions';
+
+export default (typesBundleForPezkuwi as { spec: { pendulum: OverrideBundleDefinition } }).spec.pendulum;

packages/apps-config/src/api/spec/phoenix.ts

@@ -0,0 +1,50 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Attestation: {
+          attester: 'AccountId',
+          ctypeHash: 'Hash',
+          delegationId: 'Option<DelegationNodeId>',
+          revoked: 'bool'
+        },
+        Balance: 'u128',
+        DelegationNode: {
+          owner: 'AccountId',
+          parent: 'Option<DelegationNodeId>',
+          permissions: 'Permissions',
+          revoked: 'bool',
+          rootId: 'DelegationNodeId'
+        },
+        DelegationNodeId: 'Hash',
+        DelegationRoot: {
+          ctypeHash: 'Hash',
+          owner: 'AccountId',
+          revoked: 'bool'
+        },
+        DidRecord: {
+          boxKey: 'Hash',
+          docRef: 'Option<Vec<u8>>',
+          signKey: 'Hash'
+        },
+        Index: 'u64',
+        Permissions: 'u32',
+        PublicBoxKey: 'Hash',
+        PublicSigningKey: 'Hash',
+        Signature: 'MultiSignature'
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/pichiu.ts

@@ -0,0 +1,34 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        Address: 'MultiAddress',
+        LookupSource: 'MultiAddress',
+        DataRequest: {
+          para_id: 'Option<ParaId>',
+          account_id: 'Option<AccountId>',
+          requested_block_number: 'BlockNumber',
+          processed_block_number: 'Option<BlockNumber>',
+          requested_timestamp: 'u128',
+          processed_timestamp: 'Option<u128>',
+          payload: 'Text',
+          feed_name: 'Text',
+          is_query: 'bool',
+          url: 'Option<Text>'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;

packages/apps-config/src/api/spec/plasm.ts

@@ -0,0 +1,52 @@
+// Copyright 2017-2025 @pezkuwi/apps-config authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { OverrideBundleDefinition } from '@pezkuwi/types/types';
+
+// structs need to be in order
+/* eslint-disable sort-keys */
+
+const definitions: OverrideBundleDefinition = {
+  types: [
+    {
+      // on all versions
+      minmax: [0, undefined],
+      types: {
+        AccountInfo: 'AccountInfoWithRefCount',
+        AuthorityId: 'AccountId',
+        AuthorityVote: 'u32',
+        Claim: {
+          amount: 'u128',
+          approve: 'BTreeSet<AuthorityId>',
+          complete: 'bool',
+          decline: 'BTreeSet<AuthorityId>',
+          params: 'Lockdrop'
+        },
+        ClaimId: 'H256',
+        ClaimVote: {
+          approve: 'bool',
+          authority: 'u16',
+          claim_id: 'ClaimId'
+        },
+        DollarRate: 'u128',
+        Keys: 'SessionKeys2',
+        Lockdrop: {
+          duration: 'u64',
+          public_key: '[u8; 33]',
+          transaction_hash: 'H256',
+          type: 'u8',
+          value: 'u128'
+        },
+        PredicateHash: 'H256',
+        RefCount: 'u8',
+        TickerRate: {
+          authority: 'u16',
+          btc: 'u128',
+          eth: 'u128'
+        }
+      }
+    }
+  ]
+};
+
+export default definitions;