@storagehub/api-augment 0.1.0 → 0.2.2

package/src/solochain-evm/interfaces/lookup.ts

@@ -0,0 +1,3788 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+/* eslint-disable sort-keys */
+
+export default {
+  /**
+   * Lookup3: frame_system::AccountInfo<Nonce, pallet_balances::types::AccountData<Balance>>
+   **/
+  FrameSystemAccountInfo: {
+    nonce: "u32",
+    consumers: "u32",
+    providers: "u32",
+    sufficients: "u32",
+    data: "PalletBalancesAccountData"
+  },
+  /**
+   * Lookup5: pallet_balances::types::AccountData<Balance>
+   **/
+  PalletBalancesAccountData: {
+    free: "u128",
+    reserved: "u128",
+    frozen: "u128",
+    flags: "u128"
+  },
+  /**
+   * Lookup9: frame_support::dispatch::PerDispatchClass<sp_weights::weight_v2::Weight>
+   **/
+  FrameSupportDispatchPerDispatchClassWeight: {
+    normal: "SpWeightsWeightV2Weight",
+    operational: "SpWeightsWeightV2Weight",
+    mandatory: "SpWeightsWeightV2Weight"
+  },
+  /**
+   * Lookup10: sp_weights::weight_v2::Weight
+   **/
+  SpWeightsWeightV2Weight: {
+    refTime: "Compact<u64>",
+    proofSize: "Compact<u64>"
+  },
+  /**
+   * Lookup16: sp_runtime::generic::digest::Digest
+   **/
+  SpRuntimeDigest: {
+    logs: "Vec<SpRuntimeDigestDigestItem>"
+  },
+  /**
+   * Lookup18: sp_runtime::generic::digest::DigestItem
+   **/
+  SpRuntimeDigestDigestItem: {
+    _enum: {
+      Other: "Bytes",
+      __Unused1: "Null",
+      __Unused2: "Null",
+      __Unused3: "Null",
+      Consensus: "([u8;4],Bytes)",
+      Seal: "([u8;4],Bytes)",
+      PreRuntime: "([u8;4],Bytes)",
+      __Unused7: "Null",
+      RuntimeEnvironmentUpdated: "Null"
+    }
+  },
+  /**
+   * Lookup21: frame_system::EventRecord<sh_solochain_evm_runtime::RuntimeEvent, primitive_types::H256>
+   **/
+  FrameSystemEventRecord: {
+    phase: "FrameSystemPhase",
+    event: "Event",
+    topics: "Vec<H256>"
+  },
+  /**
+   * Lookup23: frame_system::pallet::Event<T>
+   **/
+  FrameSystemEvent: {
+    _enum: {
+      ExtrinsicSuccess: {
+        dispatchInfo: "FrameSystemDispatchEventInfo"
+      },
+      ExtrinsicFailed: {
+        dispatchError: "SpRuntimeDispatchError",
+        dispatchInfo: "FrameSystemDispatchEventInfo"
+      },
+      CodeUpdated: "Null",
+      NewAccount: {
+        account: "AccountId20"
+      },
+      KilledAccount: {
+        account: "AccountId20"
+      },
+      Remarked: {
+        _alias: {
+          hash_: "hash"
+        },
+        sender: "AccountId20",
+        hash_: "H256"
+      },
+      UpgradeAuthorized: {
+        codeHash: "H256",
+        checkVersion: "bool"
+      }
+    }
+  },
+  /**
+   * Lookup24: frame_system::DispatchEventInfo
+   **/
+  FrameSystemDispatchEventInfo: {
+    weight: "SpWeightsWeightV2Weight",
+    class: "FrameSupportDispatchDispatchClass",
+    paysFee: "FrameSupportDispatchPays"
+  },
+  /**
+   * Lookup25: frame_support::dispatch::DispatchClass
+   **/
+  FrameSupportDispatchDispatchClass: {
+    _enum: ["Normal", "Operational", "Mandatory"]
+  },
+  /**
+   * Lookup26: frame_support::dispatch::Pays
+   **/
+  FrameSupportDispatchPays: {
+    _enum: ["Yes", "No"]
+  },
+  /**
+   * Lookup27: sp_runtime::DispatchError
+   **/
+  SpRuntimeDispatchError: {
+    _enum: {
+      Other: "Null",
+      CannotLookup: "Null",
+      BadOrigin: "Null",
+      Module: "SpRuntimeModuleError",
+      ConsumerRemaining: "Null",
+      NoProviders: "Null",
+      TooManyConsumers: "Null",
+      Token: "SpRuntimeTokenError",
+      Arithmetic: "SpArithmeticArithmeticError",
+      Transactional: "SpRuntimeTransactionalError",
+      Exhausted: "Null",
+      Corruption: "Null",
+      Unavailable: "Null",
+      RootNotAllowed: "Null",
+      Trie: "SpRuntimeProvingTrieTrieError"
+    }
+  },
+  /**
+   * Lookup28: sp_runtime::ModuleError
+   **/
+  SpRuntimeModuleError: {
+    index: "u8",
+    error: "[u8;4]"
+  },
+  /**
+   * Lookup29: sp_runtime::TokenError
+   **/
+  SpRuntimeTokenError: {
+    _enum: [
+      "FundsUnavailable",
+      "OnlyProvider",
+      "BelowMinimum",
+      "CannotCreate",
+      "UnknownAsset",
+      "Frozen",
+      "Unsupported",
+      "CannotCreateHold",
+      "NotExpendable",
+      "Blocked"
+    ]
+  },
+  /**
+   * Lookup30: sp_arithmetic::ArithmeticError
+   **/
+  SpArithmeticArithmeticError: {
+    _enum: ["Underflow", "Overflow", "DivisionByZero"]
+  },
+  /**
+   * Lookup31: sp_runtime::TransactionalError
+   **/
+  SpRuntimeTransactionalError: {
+    _enum: ["LimitReached", "NoLayer"]
+  },
+  /**
+   * Lookup32: sp_runtime::proving_trie::TrieError
+   **/
+  SpRuntimeProvingTrieTrieError: {
+    _enum: [
+      "InvalidStateRoot",
+      "IncompleteDatabase",
+      "ValueAtIncompleteKey",
+      "DecoderError",
+      "InvalidHash",
+      "DuplicateKey",
+      "ExtraneousNode",
+      "ExtraneousValue",
+      "ExtraneousHashReference",
+      "InvalidChildReference",
+      "ValueMismatch",
+      "IncompleteProof",
+      "RootMismatch",
+      "DecodeError"
+    ]
+  },
+  /**
+   * Lookup33: pallet_balances::pallet::Event<T, I>
+   **/
+  PalletBalancesEvent: {
+    _enum: {
+      Endowed: {
+        account: "AccountId20",
+        freeBalance: "u128"
+      },
+      DustLost: {
+        account: "AccountId20",
+        amount: "u128"
+      },
+      Transfer: {
+        from: "AccountId20",
+        to: "AccountId20",
+        amount: "u128"
+      },
+      BalanceSet: {
+        who: "AccountId20",
+        free: "u128"
+      },
+      Reserved: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      Unreserved: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      ReserveRepatriated: {
+        from: "AccountId20",
+        to: "AccountId20",
+        amount: "u128",
+        destinationStatus: "FrameSupportTokensMiscBalanceStatus"
+      },
+      Deposit: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      Withdraw: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      Slashed: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      Minted: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      Burned: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      Suspended: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      Restored: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      Upgraded: {
+        who: "AccountId20"
+      },
+      Issued: {
+        amount: "u128"
+      },
+      Rescinded: {
+        amount: "u128"
+      },
+      Locked: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      Unlocked: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      Frozen: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      Thawed: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      TotalIssuanceForced: {
+        _alias: {
+          new_: "new"
+        },
+        old: "u128",
+        new_: "u128"
+      }
+    }
+  },
+  /**
+   * Lookup34: frame_support::traits::tokens::misc::BalanceStatus
+   **/
+  FrameSupportTokensMiscBalanceStatus: {
+    _enum: ["Free", "Reserved"]
+  },
+  /**
+   * Lookup35: pallet_offences::pallet::Event
+   **/
+  PalletOffencesEvent: {
+    _enum: {
+      Offence: {
+        kind: "[u8;16]",
+        timeslot: "Bytes"
+      }
+    }
+  },
+  /**
+   * Lookup37: pallet_session::pallet::Event
+   **/
+  PalletSessionEvent: {
+    _enum: {
+      NewSession: {
+        sessionIndex: "u32"
+      }
+    }
+  },
+  /**
+   * Lookup38: pallet_grandpa::pallet::Event
+   **/
+  PalletGrandpaEvent: {
+    _enum: {
+      NewAuthorities: {
+        authoritySet: "Vec<(SpConsensusGrandpaAppPublic,u64)>"
+      },
+      Paused: "Null",
+      Resumed: "Null"
+    }
+  },
+  /**
+   * Lookup41: sp_consensus_grandpa::app::Public
+   **/
+  SpConsensusGrandpaAppPublic: "[u8;32]",
+  /**
+   * Lookup42: pallet_transaction_payment::pallet::Event<T>
+   **/
+  PalletTransactionPaymentEvent: {
+    _enum: {
+      TransactionFeePaid: {
+        who: "AccountId20",
+        actualFee: "u128",
+        tip: "u128"
+      }
+    }
+  },
+  /**
+   * Lookup43: pallet_parameters::pallet::Event<T>
+   **/
+  PalletParametersEvent: {
+    _enum: {
+      Updated: {
+        key: "ShSolochainEvmRuntimeConfigsRuntimeParamsRuntimeParametersKey",
+        oldValue: "Option<ShSolochainEvmRuntimeConfigsRuntimeParamsRuntimeParametersValue>",
+        newValue: "Option<ShSolochainEvmRuntimeConfigsRuntimeParamsRuntimeParametersValue>"
+      }
+    }
+  },
+  /**
+   * Lookup44: sh_solochain_evm_runtime::configs::runtime_params::RuntimeParametersKey
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsRuntimeParametersKey: {
+    _enum: {
+      RuntimeConfig:
+        "ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigParametersKey"
+    }
+  },
+  /**
+   * Lookup45: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::ParametersKey
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigParametersKey: {
+    _enum: [
+      "SlashAmountPerMaxFileSize",
+      "StakeToChallengePeriod",
+      "CheckpointChallengePeriod",
+      "MinChallengePeriod",
+      "SystemUtilisationLowerThresholdPercentage",
+      "SystemUtilisationUpperThresholdPercentage",
+      "MostlyStablePrice",
+      "MaxPrice",
+      "MinPrice",
+      "UpperExponentFactor",
+      "LowerExponentFactor",
+      "ZeroSizeBucketFixedRate",
+      "IdealUtilisationRate",
+      "DecayRate",
+      "MinimumTreasuryCut",
+      "MaximumTreasuryCut",
+      "BspStopStoringFilePenalty",
+      "ProviderTopUpTtl",
+      "BasicReplicationTarget",
+      "StandardReplicationTarget",
+      "HighSecurityReplicationTarget",
+      "SuperHighSecurityReplicationTarget",
+      "UltraHighSecurityReplicationTarget",
+      "MaxReplicationTarget",
+      "TickRangeToMaximumThreshold",
+      "StorageRequestTtl",
+      "MinWaitForStopStoring",
+      "MinSeedPeriod",
+      "StakeToSeedPeriod",
+      "UpfrontTicksToPay"
+    ]
+  },
+  /**
+   * Lookup46: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::SlashAmountPerMaxFileSize
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigSlashAmountPerMaxFileSize:
+    "Null",
+  /**
+   * Lookup47: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::StakeToChallengePeriod
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigStakeToChallengePeriod: "Null",
+  /**
+   * Lookup48: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::CheckpointChallengePeriod
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigCheckpointChallengePeriod:
+    "Null",
+  /**
+   * Lookup49: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::MinChallengePeriod
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMinChallengePeriod: "Null",
+  /**
+   * Lookup50: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::SystemUtilisationLowerThresholdPercentage
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigSystemUtilisationLowerThresholdPercentage:
+    "Null",
+  /**
+   * Lookup51: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::SystemUtilisationUpperThresholdPercentage
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigSystemUtilisationUpperThresholdPercentage:
+    "Null",
+  /**
+   * Lookup52: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::MostlyStablePrice
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMostlyStablePrice: "Null",
+  /**
+   * Lookup53: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::MaxPrice
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMaxPrice: "Null",
+  /**
+   * Lookup54: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::MinPrice
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMinPrice: "Null",
+  /**
+   * Lookup55: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::UpperExponentFactor
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigUpperExponentFactor: "Null",
+  /**
+   * Lookup56: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::LowerExponentFactor
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigLowerExponentFactor: "Null",
+  /**
+   * Lookup57: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::ZeroSizeBucketFixedRate
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigZeroSizeBucketFixedRate:
+    "Null",
+  /**
+   * Lookup58: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::IdealUtilisationRate
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigIdealUtilisationRate: "Null",
+  /**
+   * Lookup59: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::DecayRate
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigDecayRate: "Null",
+  /**
+   * Lookup60: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::MinimumTreasuryCut
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMinimumTreasuryCut: "Null",
+  /**
+   * Lookup61: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::MaximumTreasuryCut
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMaximumTreasuryCut: "Null",
+  /**
+   * Lookup62: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::BspStopStoringFilePenalty
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigBspStopStoringFilePenalty:
+    "Null",
+  /**
+   * Lookup63: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::ProviderTopUpTtl
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigProviderTopUpTtl: "Null",
+  /**
+   * Lookup64: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::BasicReplicationTarget
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigBasicReplicationTarget: "Null",
+  /**
+   * Lookup65: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::StandardReplicationTarget
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigStandardReplicationTarget:
+    "Null",
+  /**
+   * Lookup66: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::HighSecurityReplicationTarget
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigHighSecurityReplicationTarget:
+    "Null",
+  /**
+   * Lookup67: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::SuperHighSecurityReplicationTarget
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigSuperHighSecurityReplicationTarget:
+    "Null",
+  /**
+   * Lookup68: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::UltraHighSecurityReplicationTarget
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigUltraHighSecurityReplicationTarget:
+    "Null",
+  /**
+   * Lookup69: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::MaxReplicationTarget
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMaxReplicationTarget: "Null",
+  /**
+   * Lookup70: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::TickRangeToMaximumThreshold
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigTickRangeToMaximumThreshold:
+    "Null",
+  /**
+   * Lookup71: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::StorageRequestTtl
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigStorageRequestTtl: "Null",
+  /**
+   * Lookup72: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::MinWaitForStopStoring
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMinWaitForStopStoring: "Null",
+  /**
+   * Lookup73: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::MinSeedPeriod
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMinSeedPeriod: "Null",
+  /**
+   * Lookup74: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::StakeToSeedPeriod
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigStakeToSeedPeriod: "Null",
+  /**
+   * Lookup75: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::UpfrontTicksToPay
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigUpfrontTicksToPay: "Null",
+  /**
+   * Lookup77: sh_solochain_evm_runtime::configs::runtime_params::RuntimeParametersValue
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsRuntimeParametersValue: {
+    _enum: {
+      RuntimeConfig:
+        "ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigParametersValue"
+    }
+  },
+  /**
+   * Lookup78: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::ParametersValue
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigParametersValue: {
+    _enum: {
+      SlashAmountPerMaxFileSize: "u128",
+      StakeToChallengePeriod: "u128",
+      CheckpointChallengePeriod: "u32",
+      MinChallengePeriod: "u32",
+      SystemUtilisationLowerThresholdPercentage: "Perbill",
+      SystemUtilisationUpperThresholdPercentage: "Perbill",
+      MostlyStablePrice: "u128",
+      MaxPrice: "u128",
+      MinPrice: "u128",
+      UpperExponentFactor: "u32",
+      LowerExponentFactor: "u32",
+      ZeroSizeBucketFixedRate: "u128",
+      IdealUtilisationRate: "Perbill",
+      DecayRate: "Perbill",
+      MinimumTreasuryCut: "Perbill",
+      MaximumTreasuryCut: "Perbill",
+      BspStopStoringFilePenalty: "u128",
+      ProviderTopUpTtl: "u32",
+      BasicReplicationTarget: "u32",
+      StandardReplicationTarget: "u32",
+      HighSecurityReplicationTarget: "u32",
+      SuperHighSecurityReplicationTarget: "u32",
+      UltraHighSecurityReplicationTarget: "u32",
+      MaxReplicationTarget: "u32",
+      TickRangeToMaximumThreshold: "u32",
+      StorageRequestTtl: "u32",
+      MinWaitForStopStoring: "u32",
+      MinSeedPeriod: "u32",
+      StakeToSeedPeriod: "u128",
+      UpfrontTicksToPay: "u32"
+    }
+  },
+  /**
+   * Lookup80: pallet_sudo::pallet::Event<T>
+   **/
+  PalletSudoEvent: {
+    _enum: {
+      Sudid: {
+        sudoResult: "Result<Null, SpRuntimeDispatchError>"
+      },
+      KeyChanged: {
+        _alias: {
+          new_: "new"
+        },
+        old: "Option<AccountId20>",
+        new_: "AccountId20"
+      },
+      KeyRemoved: "Null",
+      SudoAsDone: {
+        sudoResult: "Result<Null, SpRuntimeDispatchError>"
+      }
+    }
+  },
+  /**
+   * Lookup84: pallet_ethereum::pallet::Event
+   **/
+  PalletEthereumEvent: {
+    _enum: {
+      Executed: {
+        from: "H160",
+        to: "H160",
+        transactionHash: "H256",
+        exitReason: "EvmCoreErrorExitReason",
+        extraData: "Bytes"
+      }
+    }
+  },
+  /**
+   * Lookup86: evm_core::error::ExitReason
+   **/
+  EvmCoreErrorExitReason: {
+    _enum: {
+      Succeed: "EvmCoreErrorExitSucceed",
+      Error: "EvmCoreErrorExitError",
+      Revert: "EvmCoreErrorExitRevert",
+      Fatal: "EvmCoreErrorExitFatal"
+    }
+  },
+  /**
+   * Lookup87: evm_core::error::ExitSucceed
+   **/
+  EvmCoreErrorExitSucceed: {
+    _enum: ["Stopped", "Returned", "Suicided"]
+  },
+  /**
+   * Lookup88: evm_core::error::ExitError
+   **/
+  EvmCoreErrorExitError: {
+    _enum: {
+      StackUnderflow: "Null",
+      StackOverflow: "Null",
+      InvalidJump: "Null",
+      InvalidRange: "Null",
+      DesignatedInvalid: "Null",
+      CallTooDeep: "Null",
+      CreateCollision: "Null",
+      CreateContractLimit: "Null",
+      OutOfOffset: "Null",
+      OutOfGas: "Null",
+      OutOfFund: "Null",
+      PCUnderflow: "Null",
+      CreateEmpty: "Null",
+      Other: "Text",
+      MaxNonce: "Null",
+      InvalidCode: "u8"
+    }
+  },
+  /**
+   * Lookup92: evm_core::error::ExitRevert
+   **/
+  EvmCoreErrorExitRevert: {
+    _enum: ["Reverted"]
+  },
+  /**
+   * Lookup93: evm_core::error::ExitFatal
+   **/
+  EvmCoreErrorExitFatal: {
+    _enum: {
+      NotSupported: "Null",
+      UnhandledInterrupt: "Null",
+      CallErrorAsFatal: "EvmCoreErrorExitError",
+      Other: "Text"
+    }
+  },
+  /**
+   * Lookup94: pallet_evm::pallet::Event<T>
+   **/
+  PalletEvmEvent: {
+    _enum: {
+      Log: {
+        log: "EthereumLog"
+      },
+      Created: {
+        address: "H160"
+      },
+      CreatedFailed: {
+        address: "H160"
+      },
+      Executed: {
+        address: "H160"
+      },
+      ExecutedFailed: {
+        address: "H160"
+      }
+    }
+  },
+  /**
+   * Lookup95: ethereum::log::Log
+   **/
+  EthereumLog: {
+    address: "H160",
+    topics: "Vec<H256>",
+    data: "Bytes"
+  },
+  /**
+   * Lookup97: pallet_storage_providers::pallet::Event<T>
+   **/
+  PalletStorageProvidersEvent: {
+    _enum: {
+      MspRequestSignUpSuccess: {
+        who: "AccountId20",
+        multiaddresses: "Vec<Bytes>",
+        capacity: "u64"
+      },
+      MspSignUpSuccess: {
+        who: "AccountId20",
+        mspId: "H256",
+        multiaddresses: "Vec<Bytes>",
+        capacity: "u64",
+        valueProp: "PalletStorageProvidersValuePropositionWithId"
+      },
+      BspRequestSignUpSuccess: {
+        who: "AccountId20",
+        multiaddresses: "Vec<Bytes>",
+        capacity: "u64"
+      },
+      BspSignUpSuccess: {
+        who: "AccountId20",
+        bspId: "H256",
+        root: "H256",
+        multiaddresses: "Vec<Bytes>",
+        capacity: "u64"
+      },
+      SignUpRequestCanceled: {
+        who: "AccountId20"
+      },
+      MspSignOffSuccess: {
+        who: "AccountId20",
+        mspId: "H256"
+      },
+      BspSignOffSuccess: {
+        who: "AccountId20",
+        bspId: "H256"
+      },
+      CapacityChanged: {
+        who: "AccountId20",
+        providerId: "PalletStorageProvidersStorageProviderId",
+        oldCapacity: "u64",
+        newCapacity: "u64",
+        nextBlockWhenChangeAllowed: "u32"
+      },
+      Slashed: {
+        providerId: "H256",
+        amount: "u128"
+      },
+      AwaitingTopUp: {
+        providerId: "H256",
+        topUpMetadata: "PalletStorageProvidersTopUpMetadata"
+      },
+      TopUpFulfilled: {
+        providerId: "H256",
+        amount: "u128"
+      },
+      FailedToGetOwnerAccountOfInsolventProvider: {
+        providerId: "H256"
+      },
+      FailedToSlashInsolventProvider: {
+        providerId: "H256",
+        amountToSlash: "u128",
+        error: "SpRuntimeDispatchError"
+      },
+      FailedToStopAllCyclesForInsolventBsp: {
+        providerId: "H256",
+        error: "SpRuntimeDispatchError"
+      },
+      FailedToInsertProviderTopUpExpiration: {
+        providerId: "H256",
+        expirationTick: "u32"
+      },
+      ProviderInsolvent: {
+        providerId: "H256"
+      },
+      BucketsOfInsolventMsp: {
+        mspId: "H256",
+        buckets: "Vec<H256>"
+      },
+      BucketRootChanged: {
+        bucketId: "H256",
+        oldRoot: "H256",
+        newRoot: "H256"
+      },
+      MultiAddressAdded: {
+        providerId: "H256",
+        newMultiaddress: "Bytes"
+      },
+      MultiAddressRemoved: {
+        providerId: "H256",
+        removedMultiaddress: "Bytes"
+      },
+      ValuePropAdded: {
+        mspId: "H256",
+        valuePropId: "H256",
+        valueProp: "PalletStorageProvidersValueProposition"
+      },
+      ValuePropUnavailable: {
+        mspId: "H256",
+        valuePropId: "H256"
+      },
+      MspDeleted: {
+        providerId: "H256"
+      },
+      BspDeleted: {
+        providerId: "H256"
+      }
+    }
+  },
+  /**
+   * Lookup101: pallet_storage_providers::types::ValuePropositionWithId<T>
+   **/
+  PalletStorageProvidersValuePropositionWithId: {
+    id: "H256",
+    valueProp: "PalletStorageProvidersValueProposition"
+  },
+  /**
+   * Lookup102: pallet_storage_providers::types::ValueProposition<T>
+   **/
+  PalletStorageProvidersValueProposition: {
+    pricePerGigaUnitOfDataPerBlock: "u128",
+    commitment: "Bytes",
+    bucketDataLimit: "u64",
+    available: "bool"
+  },
+  /**
+   * Lookup104: pallet_storage_providers::types::StorageProviderId<T>
+   **/
+  PalletStorageProvidersStorageProviderId: {
+    _enum: {
+      BackupStorageProvider: "H256",
+      MainStorageProvider: "H256"
+    }
+  },
+  /**
+   * Lookup105: pallet_storage_providers::types::TopUpMetadata<T>
+   **/
+  PalletStorageProvidersTopUpMetadata: {
+    startedAt: "u32",
+    endTickGracePeriod: "u32"
+  },
+  /**
+   * Lookup106: pallet_file_system::pallet::Event<T>
+   **/
+  PalletFileSystemEvent: {
+    _enum: {
+      NewBucket: {
+        who: "AccountId20",
+        mspId: "H256",
+        bucketId: "H256",
+        name: "Bytes",
+        root: "H256",
+        collectionId: "Option<u32>",
+        private: "bool",
+        valuePropId: "H256"
+      },
+      BucketDeleted: {
+        who: "AccountId20",
+        bucketId: "H256",
+        maybeCollectionId: "Option<u32>"
+      },
+      MoveBucketRequested: {
+        who: "AccountId20",
+        bucketId: "H256",
+        newMspId: "H256",
+        newValuePropId: "H256"
+      },
+      BucketPrivacyUpdated: {
+        who: "AccountId20",
+        bucketId: "H256",
+        collectionId: "Option<u32>",
+        private: "bool"
+      },
+      NewCollectionAndAssociation: {
+        who: "AccountId20",
+        bucketId: "H256",
+        collectionId: "u32"
+      },
+      NewStorageRequest: {
+        _alias: {
+          size_: "size"
+        },
+        who: "AccountId20",
+        fileKey: "H256",
+        bucketId: "H256",
+        location: "Bytes",
+        fingerprint: "H256",
+        size_: "u64",
+        peerIds: "Vec<Bytes>",
+        expiresAt: "u32"
+      },
+      MspAcceptedStorageRequest: {
+        fileKey: "H256",
+        fileMetadata: "ShpFileMetadataFileMetadata"
+      },
+      AcceptedBspVolunteer: {
+        _alias: {
+          size_: "size"
+        },
+        bspId: "H256",
+        bucketId: "H256",
+        location: "Bytes",
+        fingerprint: "H256",
+        multiaddresses: "Vec<Bytes>",
+        owner: "AccountId20",
+        size_: "u64"
+      },
+      BspConfirmedStoring: {
+        who: "AccountId20",
+        bspId: "H256",
+        confirmedFileKeys: "Vec<(H256,ShpFileMetadataFileMetadata)>",
+        skippedFileKeys: "Vec<H256>",
+        newRoot: "H256"
+      },
+      StorageRequestFulfilled: {
+        fileKey: "H256"
+      },
+      StorageRequestExpired: {
+        fileKey: "H256"
+      },
+      StorageRequestRevoked: {
+        fileKey: "H256"
+      },
+      StorageRequestRejected: {
+        fileKey: "H256",
+        reason: "PalletFileSystemRejectedStorageRequestReason"
+      },
+      BspRequestedToStopStoring: {
+        bspId: "H256",
+        fileKey: "H256",
+        owner: "AccountId20",
+        location: "Bytes"
+      },
+      BspConfirmStoppedStoring: {
+        bspId: "H256",
+        fileKey: "H256",
+        newRoot: "H256"
+      },
+      PriorityChallengeForFileDeletionQueued: {
+        issuer: "PalletFileSystemEitherAccountIdOrMspId",
+        fileKey: "H256"
+      },
+      SpStopStoringInsolventUser: {
+        spId: "H256",
+        fileKey: "H256",
+        owner: "AccountId20",
+        location: "Bytes",
+        newRoot: "H256"
+      },
+      MspStopStoringBucketInsolventUser: {
+        mspId: "H256",
+        owner: "AccountId20",
+        bucketId: "H256"
+      },
+      FailedToQueuePriorityChallenge: {
+        fileKey: "H256",
+        error: "SpRuntimeDispatchError"
+      },
+      FileDeletionRequest: {
+        user: "AccountId20",
+        fileKey: "H256",
+        fileSize: "u64",
+        bucketId: "H256",
+        mspId: "H256",
+        proofOfInclusion: "bool"
+      },
+      ProofSubmittedForPendingFileDeletionRequest: {
+        user: "AccountId20",
+        fileKey: "H256",
+        fileSize: "u64",
+        bucketId: "H256",
+        mspId: "H256",
+        proofOfInclusion: "bool"
+      },
+      BspChallengeCycleInitialised: {
+        who: "AccountId20",
+        bspId: "H256"
+      },
+      MoveBucketRequestExpired: {
+        bucketId: "H256"
+      },
+      MoveBucketAccepted: {
+        bucketId: "H256",
+        oldMspId: "Option<H256>",
+        newMspId: "H256",
+        valuePropId: "H256"
+      },
+      MoveBucketRejected: {
+        bucketId: "H256",
+        oldMspId: "Option<H256>",
+        newMspId: "H256"
+      },
+      MspStoppedStoringBucket: {
+        mspId: "H256",
+        owner: "AccountId20",
+        bucketId: "H256"
+      },
+      FailedToGetMspOfBucket: {
+        bucketId: "H256",
+        error: "SpRuntimeDispatchError"
+      },
+      FailedToDecreaseMspUsedCapacity: {
+        user: "AccountId20",
+        mspId: "H256",
+        fileKey: "H256",
+        fileSize: "u64",
+        error: "SpRuntimeDispatchError"
+      },
+      UsedCapacityShouldBeZero: {
+        actualUsedCapacity: "u64"
+      },
+      FailedToReleaseStorageRequestCreationDeposit: {
+        fileKey: "H256",
+        owner: "AccountId20",
+        amountToReturn: "u128",
+        error: "SpRuntimeDispatchError"
+      },
+      FailedToTransferDepositFundsToBsp: {
+        fileKey: "H256",
+        owner: "AccountId20",
+        bspId: "H256",
+        amountToTransfer: "u128",
+        error: "SpRuntimeDispatchError"
+      },
+      FileDeletionRequested: {
+        signedDeleteIntention: "PalletFileSystemFileOperationIntention",
+        signature: "FpAccountEthereumSignature"
+      },
+      BucketFileDeletionCompleted: {
+        user: "AccountId20",
+        fileKey: "H256",
+        fileSize: "u64",
+        bucketId: "H256",
+        mspId: "Option<H256>",
+        oldRoot: "H256",
+        newRoot: "H256"
+      },
+      BspFileDeletionCompleted: {
+        user: "AccountId20",
+        fileKey: "H256",
+        fileSize: "u64",
+        bspId: "H256",
+        oldRoot: "H256",
+        newRoot: "H256"
+      },
+      FileDeletedFromIncompleteStorageRequest: {
+        fileKey: "H256",
+        bspId: "Option<H256>"
+      },
+      IncompleteStorageRequest: {
+        fileKey: "H256"
+      }
+    }
+  },
+  /**
+   * Lookup109: shp_file_metadata::FileMetadata
+   **/
+  ShpFileMetadataFileMetadata: {
+    owner: "Bytes",
+    bucketId: "Bytes",
+    location: "Bytes",
+    fileSize: "Compact<u64>",
+    fingerprint: "ShpFileMetadataFingerprint"
+  },
+  /**
+   * Lookup110: shp_file_metadata::Fingerprint
+   **/
+  ShpFileMetadataFingerprint: "[u8;32]",
+  /**
+   * Lookup115: pallet_file_system::types::RejectedStorageRequestReason
+   **/
+  PalletFileSystemRejectedStorageRequestReason: {
+    _enum: [
+      "ReachedMaximumCapacity",
+      "ReceivedInvalidProof",
+      "FileKeyAlreadyStored",
+      "RequestExpired",
+      "InternalError"
+    ]
+  },
+  /**
+   * Lookup116: pallet_file_system::types::EitherAccountIdOrMspId<T>
+   **/
+  PalletFileSystemEitherAccountIdOrMspId: {
+    _enum: {
+      AccountId: "AccountId20",
+      MspId: "H256"
+    }
+  },
+  /**
+   * Lookup118: pallet_file_system::types::FileOperationIntention<T>
+   **/
+  PalletFileSystemFileOperationIntention: {
+    fileKey: "H256",
+    operation: "PalletFileSystemFileOperation"
+  },
+  /**
+   * Lookup119: pallet_file_system::types::FileOperation
+   **/
+  PalletFileSystemFileOperation: {
+    _enum: ["Delete"]
+  },
+  /**
+   * Lookup120: fp_account::EthereumSignature
+   **/
+  FpAccountEthereumSignature: "[u8;65]",
+  /**
+   * Lookup122: pallet_proofs_dealer::pallet::Event<T>
+   **/
+  PalletProofsDealerEvent: {
+    _enum: {
+      NewChallenge: {
+        who: "Option<AccountId20>",
+        keyChallenged: "H256"
+      },
+      NewPriorityChallenge: {
+        who: "Option<AccountId20>",
+        keyChallenged: "H256",
+        shouldRemoveKey: "bool"
+      },
+      ProofAccepted: {
+        providerId: "H256",
+        proof: "PalletProofsDealerProof",
+        lastTickProven: "u32"
+      },
+      NewChallengeSeed: {
+        challengesTicker: "u32",
+        seed: "H256"
+      },
+      NewCheckpointChallenge: {
+        challengesTicker: "u32",
+        challenges: "Vec<PalletProofsDealerCustomChallenge>"
+      },
+      SlashableProvider: {
+        provider: "H256",
+        nextChallengeDeadline: "u32"
+      },
+      NoRecordOfLastSubmittedProof: {
+        provider: "H256"
+      },
+      NewChallengeCycleInitialised: {
+        currentTick: "u32",
+        nextChallengeDeadline: "u32",
+        provider: "H256",
+        maybeProviderAccount: "Option<AccountId20>"
+      },
+      MutationsAppliedForProvider: {
+        providerId: "H256",
+        mutations: "Vec<(H256,ShpTraitsTrieMutation)>",
+        oldRoot: "H256",
+        newRoot: "H256"
+      },
+      MutationsApplied: {
+        mutations: "Vec<(H256,ShpTraitsTrieMutation)>",
+        oldRoot: "H256",
+        newRoot: "H256",
+        eventInfo: "Option<Bytes>"
+      },
+      ChallengesTickerSet: {
+        paused: "bool"
+      }
+    }
+  },
+  /**
+   * Lookup123: pallet_proofs_dealer::types::Proof<T>
+   **/
+  PalletProofsDealerProof: {
+    forestProof: "SpTrieStorageProofCompactProof",
+    keyProofs: "BTreeMap<H256, PalletProofsDealerKeyProof>"
+  },
+  /**
+   * Lookup124: sp_trie::storage_proof::CompactProof
+   **/
+  SpTrieStorageProofCompactProof: {
+    encodedNodes: "Vec<Bytes>"
+  },
+  /**
+   * Lookup127: pallet_proofs_dealer::types::KeyProof<T>
+   **/
+  PalletProofsDealerKeyProof: {
+    proof: "ShpFileKeyVerifierFileKeyProof",
+    challengeCount: "u32"
+  },
+  /**
+   * Lookup128: shp_file_key_verifier::types::FileKeyProof
+   **/
+  ShpFileKeyVerifierFileKeyProof: {
+    fileMetadata: "ShpFileMetadataFileMetadata",
+    proof: "SpTrieStorageProofCompactProof"
+  },
+  /**
+   * Lookup132: pallet_proofs_dealer::types::CustomChallenge<T>
+   **/
+  PalletProofsDealerCustomChallenge: {
+    key: "H256",
+    shouldRemoveKey: "bool"
+  },
+  /**
+   * Lookup136: shp_traits::TrieMutation
+   **/
+  ShpTraitsTrieMutation: {
+    _enum: {
+      Add: "ShpTraitsTrieAddMutation",
+      Remove: "ShpTraitsTrieRemoveMutation"
+    }
+  },
+  /**
+   * Lookup137: shp_traits::TrieAddMutation
+   **/
+  ShpTraitsTrieAddMutation: {
+    value: "Bytes"
+  },
+  /**
+   * Lookup138: shp_traits::TrieRemoveMutation
+   **/
+  ShpTraitsTrieRemoveMutation: {
+    maybeValue: "Option<Bytes>"
+  },
+  /**
+   * Lookup140: pallet_randomness::pallet::Event<T>
+   **/
+  PalletRandomnessEvent: {
+    _enum: {
+      NewOneEpochAgoRandomnessAvailable: {
+        randomnessSeed: "H256",
+        fromEpoch: "u64",
+        validUntilBlock: "u32"
+      }
+    }
+  },
+  /**
+   * Lookup141: pallet_payment_streams::pallet::Event<T>
+   **/
+  PalletPaymentStreamsEvent: {
+    _enum: {
+      FixedRatePaymentStreamCreated: {
+        userAccount: "AccountId20",
+        providerId: "H256",
+        rate: "u128"
+      },
+      FixedRatePaymentStreamUpdated: {
+        userAccount: "AccountId20",
+        providerId: "H256",
+        newRate: "u128"
+      },
+      FixedRatePaymentStreamDeleted: {
+        userAccount: "AccountId20",
+        providerId: "H256"
+      },
+      DynamicRatePaymentStreamCreated: {
+        userAccount: "AccountId20",
+        providerId: "H256",
+        amountProvided: "u64"
+      },
+      DynamicRatePaymentStreamUpdated: {
+        userAccount: "AccountId20",
+        providerId: "H256",
+        newAmountProvided: "u64"
+      },
+      DynamicRatePaymentStreamDeleted: {
+        userAccount: "AccountId20",
+        providerId: "H256"
+      },
+      PaymentStreamCharged: {
+        userAccount: "AccountId20",
+        providerId: "H256",
+        amount: "u128",
+        lastTickCharged: "u32",
+        chargedAtTick: "u32"
+      },
+      UsersCharged: {
+        userAccounts: "Vec<AccountId20>",
+        providerId: "H256",
+        chargedAtTick: "u32"
+      },
+      LastChargeableInfoUpdated: {
+        providerId: "H256",
+        lastChargeableTick: "u32",
+        lastChargeablePriceIndex: "u128"
+      },
+      UserWithoutFunds: {
+        who: "AccountId20"
+      },
+      UserPaidAllDebts: {
+        who: "AccountId20"
+      },
+      UserPaidSomeDebts: {
+        who: "AccountId20"
+      },
+      UserSolvent: {
+        who: "AccountId20"
+      },
+      InconsistentTickProcessing: {
+        lastProcessedTick: "u32",
+        tickToProcess: "u32"
+      }
+    }
+  },
+  /**
+   * Lookup144: pallet_bucket_nfts::pallet::Event<T>
+   **/
+  PalletBucketNftsEvent: {
+    _enum: {
+      AccessShared: {
+        issuer: "AccountId20",
+        recipient: "AccountId20"
+      },
+      ItemReadAccessUpdated: {
+        admin: "AccountId20",
+        bucket: "H256",
+        itemId: "u32"
+      },
+      ItemBurned: {
+        account: "AccountId20",
+        bucket: "H256",
+        itemId: "u32"
+      }
+    }
+  },
+  /**
+   * Lookup145: pallet_nfts::pallet::Event<T, I>
+   **/
+  PalletNftsEvent: {
+    _enum: {
+      Created: {
+        collection: "u32",
+        creator: "AccountId20",
+        owner: "AccountId20"
+      },
+      ForceCreated: {
+        collection: "u32",
+        owner: "AccountId20"
+      },
+      Destroyed: {
+        collection: "u32"
+      },
+      Issued: {
+        collection: "u32",
+        item: "u32",
+        owner: "AccountId20"
+      },
+      Transferred: {
+        collection: "u32",
+        item: "u32",
+        from: "AccountId20",
+        to: "AccountId20"
+      },
+      Burned: {
+        collection: "u32",
+        item: "u32",
+        owner: "AccountId20"
+      },
+      ItemTransferLocked: {
+        collection: "u32",
+        item: "u32"
+      },
+      ItemTransferUnlocked: {
+        collection: "u32",
+        item: "u32"
+      },
+      ItemPropertiesLocked: {
+        collection: "u32",
+        item: "u32",
+        lockMetadata: "bool",
+        lockAttributes: "bool"
+      },
+      CollectionLocked: {
+        collection: "u32"
+      },
+      OwnerChanged: {
+        collection: "u32",
+        newOwner: "AccountId20"
+      },
+      TeamChanged: {
+        collection: "u32",
+        issuer: "Option<AccountId20>",
+        admin: "Option<AccountId20>",
+        freezer: "Option<AccountId20>"
+      },
+      TransferApproved: {
+        collection: "u32",
+        item: "u32",
+        owner: "AccountId20",
+        delegate: "AccountId20",
+        deadline: "Option<u32>"
+      },
+      ApprovalCancelled: {
+        collection: "u32",
+        item: "u32",
+        owner: "AccountId20",
+        delegate: "AccountId20"
+      },
+      AllApprovalsCancelled: {
+        collection: "u32",
+        item: "u32",
+        owner: "AccountId20"
+      },
+      CollectionConfigChanged: {
+        collection: "u32"
+      },
+      CollectionMetadataSet: {
+        collection: "u32",
+        data: "Bytes"
+      },
+      CollectionMetadataCleared: {
+        collection: "u32"
+      },
+      ItemMetadataSet: {
+        collection: "u32",
+        item: "u32",
+        data: "Bytes"
+      },
+      ItemMetadataCleared: {
+        collection: "u32",
+        item: "u32"
+      },
+      Redeposited: {
+        collection: "u32",
+        successfulItems: "Vec<u32>"
+      },
+      AttributeSet: {
+        collection: "u32",
+        maybeItem: "Option<u32>",
+        key: "Bytes",
+        value: "Bytes",
+        namespace: "PalletNftsAttributeNamespace"
+      },
+      AttributeCleared: {
+        collection: "u32",
+        maybeItem: "Option<u32>",
+        key: "Bytes",
+        namespace: "PalletNftsAttributeNamespace"
+      },
+      ItemAttributesApprovalAdded: {
+        collection: "u32",
+        item: "u32",
+        delegate: "AccountId20"
+      },
+      ItemAttributesApprovalRemoved: {
+        collection: "u32",
+        item: "u32",
+        delegate: "AccountId20"
+      },
+      OwnershipAcceptanceChanged: {
+        who: "AccountId20",
+        maybeCollection: "Option<u32>"
+      },
+      CollectionMaxSupplySet: {
+        collection: "u32",
+        maxSupply: "u32"
+      },
+      CollectionMintSettingsUpdated: {
+        collection: "u32"
+      },
+      NextCollectionIdIncremented: {
+        nextId: "Option<u32>"
+      },
+      ItemPriceSet: {
+        collection: "u32",
+        item: "u32",
+        price: "u128",
+        whitelistedBuyer: "Option<AccountId20>"
+      },
+      ItemPriceRemoved: {
+        collection: "u32",
+        item: "u32"
+      },
+      ItemBought: {
+        collection: "u32",
+        item: "u32",
+        price: "u128",
+        seller: "AccountId20",
+        buyer: "AccountId20"
+      },
+      TipSent: {
+        collection: "u32",
+        item: "u32",
+        sender: "AccountId20",
+        receiver: "AccountId20",
+        amount: "u128"
+      },
+      SwapCreated: {
+        offeredCollection: "u32",
+        offeredItem: "u32",
+        desiredCollection: "u32",
+        desiredItem: "Option<u32>",
+        price: "Option<PalletNftsPriceWithDirection>",
+        deadline: "u32"
+      },
+      SwapCancelled: {
+        offeredCollection: "u32",
+        offeredItem: "u32",
+        desiredCollection: "u32",
+        desiredItem: "Option<u32>",
+        price: "Option<PalletNftsPriceWithDirection>",
+        deadline: "u32"
+      },
+      SwapClaimed: {
+        sentCollection: "u32",
+        sentItem: "u32",
+        sentItemOwner: "AccountId20",
+        receivedCollection: "u32",
+        receivedItem: "u32",
+        receivedItemOwner: "AccountId20",
+        price: "Option<PalletNftsPriceWithDirection>",
+        deadline: "u32"
+      },
+      PreSignedAttributesSet: {
+        collection: "u32",
+        item: "u32",
+        namespace: "PalletNftsAttributeNamespace"
+      },
+      PalletAttributeSet: {
+        collection: "u32",
+        item: "Option<u32>",
+        attribute: "PalletNftsPalletAttributes",
+        value: "Bytes"
+      }
+    }
+  },
+  /**
+   * Lookup149: pallet_nfts::types::AttributeNamespace<fp_account::AccountId20>
+   **/
+  PalletNftsAttributeNamespace: {
+    _enum: {
+      Pallet: "Null",
+      CollectionOwner: "Null",
+      ItemOwner: "Null",
+      Account: "AccountId20"
+    }
+  },
+  /**
+   * Lookup151: pallet_nfts::types::PriceWithDirection<Amount>
+   **/
+  PalletNftsPriceWithDirection: {
+    amount: "u128",
+    direction: "PalletNftsPriceDirection"
+  },
+  /**
+   * Lookup152: pallet_nfts::types::PriceDirection
+   **/
+  PalletNftsPriceDirection: {
+    _enum: ["Send", "Receive"]
+  },
+  /**
+   * Lookup153: pallet_nfts::types::PalletAttributes<CollectionId>
+   **/
+  PalletNftsPalletAttributes: {
+    _enum: {
+      UsedToClaim: "u32",
+      TransferDisabled: "Null"
+    }
+  },
+  /**
+   * Lookup154: frame_system::Phase
+   **/
+  FrameSystemPhase: {
+    _enum: {
+      ApplyExtrinsic: "u32",
+      Finalization: "Null",
+      Initialization: "Null"
+    }
+  },
+  /**
+   * Lookup157: frame_system::LastRuntimeUpgradeInfo
+   **/
+  FrameSystemLastRuntimeUpgradeInfo: {
+    specVersion: "Compact<u32>",
+    specName: "Text"
+  },
+  /**
+   * Lookup159: frame_system::CodeUpgradeAuthorization<T>
+   **/
+  FrameSystemCodeUpgradeAuthorization: {
+    codeHash: "H256",
+    checkVersion: "bool"
+  },
+  /**
+   * Lookup160: frame_system::pallet::Call<T>
+   **/
+  FrameSystemCall: {
+    _enum: {
+      remark: {
+        remark: "Bytes"
+      },
+      set_heap_pages: {
+        pages: "u64"
+      },
+      set_code: {
+        code: "Bytes"
+      },
+      set_code_without_checks: {
+        code: "Bytes"
+      },
+      set_storage: {
+        items: "Vec<(Bytes,Bytes)>"
+      },
+      kill_storage: {
+        _alias: {
+          keys_: "keys"
+        },
+        keys_: "Vec<Bytes>"
+      },
+      kill_prefix: {
+        prefix: "Bytes",
+        subkeys: "u32"
+      },
+      remark_with_event: {
+        remark: "Bytes"
+      },
+      __Unused8: "Null",
+      authorize_upgrade: {
+        codeHash: "H256"
+      },
+      authorize_upgrade_without_checks: {
+        codeHash: "H256"
+      },
+      apply_authorized_upgrade: {
+        code: "Bytes"
+      }
+    }
+  },
+  /**
+   * Lookup163: frame_system::limits::BlockWeights
+   **/
+  FrameSystemLimitsBlockWeights: {
+    baseBlock: "SpWeightsWeightV2Weight",
+    maxBlock: "SpWeightsWeightV2Weight",
+    perClass: "FrameSupportDispatchPerDispatchClassWeightsPerClass"
+  },
+  /**
+   * Lookup164: frame_support::dispatch::PerDispatchClass<frame_system::limits::WeightsPerClass>
+   **/
+  FrameSupportDispatchPerDispatchClassWeightsPerClass: {
+    normal: "FrameSystemLimitsWeightsPerClass",
+    operational: "FrameSystemLimitsWeightsPerClass",
+    mandatory: "FrameSystemLimitsWeightsPerClass"
+  },
+  /**
+   * Lookup165: frame_system::limits::WeightsPerClass
+   **/
+  FrameSystemLimitsWeightsPerClass: {
+    baseExtrinsic: "SpWeightsWeightV2Weight",
+    maxExtrinsic: "Option<SpWeightsWeightV2Weight>",
+    maxTotal: "Option<SpWeightsWeightV2Weight>",
+    reserved: "Option<SpWeightsWeightV2Weight>"
+  },
+  /**
+   * Lookup167: frame_system::limits::BlockLength
+   **/
+  FrameSystemLimitsBlockLength: {
+    max: "FrameSupportDispatchPerDispatchClassU32"
+  },
+  /**
+   * Lookup168: frame_support::dispatch::PerDispatchClass<T>
+   **/
+  FrameSupportDispatchPerDispatchClassU32: {
+    normal: "u32",
+    operational: "u32",
+    mandatory: "u32"
+  },
+  /**
+   * Lookup169: sp_weights::RuntimeDbWeight
+   **/
+  SpWeightsRuntimeDbWeight: {
+    read: "u64",
+    write: "u64"
+  },
+  /**
+   * Lookup170: sp_version::RuntimeVersion
+   **/
+  SpVersionRuntimeVersion: {
+    specName: "Text",
+    implName: "Text",
+    authoringVersion: "u32",
+    specVersion: "u32",
+    implVersion: "u32",
+    apis: "Vec<([u8;8],u32)>",
+    transactionVersion: "u32",
+    systemVersion: "u8"
+  },
+  /**
+   * Lookup176: frame_system::pallet::Error<T>
+   **/
+  FrameSystemError: {
+    _enum: [
+      "InvalidSpecName",
+      "SpecVersionNeedsToIncrease",
+      "FailedToExtractRuntimeVersion",
+      "NonDefaultComposite",
+      "NonZeroRefCount",
+      "CallFiltered",
+      "MultiBlockMigrationsOngoing",
+      "NothingAuthorized",
+      "Unauthorized"
+    ]
+  },
+  /**
+   * Lookup179: sp_consensus_babe::app::Public
+   **/
+  SpConsensusBabeAppPublic: "[u8;32]",
+  /**
+   * Lookup182: sp_consensus_babe::digests::NextConfigDescriptor
+   **/
+  SpConsensusBabeDigestsNextConfigDescriptor: {
+    _enum: {
+      __Unused0: "Null",
+      V1: {
+        c: "(u64,u64)",
+        allowedSlots: "SpConsensusBabeAllowedSlots"
+      }
+    }
+  },
+  /**
+   * Lookup184: sp_consensus_babe::AllowedSlots
+   **/
+  SpConsensusBabeAllowedSlots: {
+    _enum: ["PrimarySlots", "PrimaryAndSecondaryPlainSlots", "PrimaryAndSecondaryVRFSlots"]
+  },
+  /**
+   * Lookup188: sp_consensus_babe::digests::PreDigest
+   **/
+  SpConsensusBabeDigestsPreDigest: {
+    _enum: {
+      __Unused0: "Null",
+      Primary: "SpConsensusBabeDigestsPrimaryPreDigest",
+      SecondaryPlain: "SpConsensusBabeDigestsSecondaryPlainPreDigest",
+      SecondaryVRF: "SpConsensusBabeDigestsSecondaryVRFPreDigest"
+    }
+  },
+  /**
+   * Lookup189: sp_consensus_babe::digests::PrimaryPreDigest
+   **/
+  SpConsensusBabeDigestsPrimaryPreDigest: {
+    authorityIndex: "u32",
+    slot: "u64",
+    vrfSignature: "SpCoreSr25519VrfVrfSignature"
+  },
+  /**
+   * Lookup190: sp_core::sr25519::vrf::VrfSignature
+   **/
+  SpCoreSr25519VrfVrfSignature: {
+    preOutput: "[u8;32]",
+    proof: "[u8;64]"
+  },
+  /**
+   * Lookup192: sp_consensus_babe::digests::SecondaryPlainPreDigest
+   **/
+  SpConsensusBabeDigestsSecondaryPlainPreDigest: {
+    authorityIndex: "u32",
+    slot: "u64"
+  },
+  /**
+   * Lookup193: sp_consensus_babe::digests::SecondaryVRFPreDigest
+   **/
+  SpConsensusBabeDigestsSecondaryVRFPreDigest: {
+    authorityIndex: "u32",
+    slot: "u64",
+    vrfSignature: "SpCoreSr25519VrfVrfSignature"
+  },
+  /**
+   * Lookup195: sp_consensus_babe::BabeEpochConfiguration
+   **/
+  SpConsensusBabeBabeEpochConfiguration: {
+    c: "(u64,u64)",
+    allowedSlots: "SpConsensusBabeAllowedSlots"
+  },
+  /**
+   * Lookup199: pallet_babe::pallet::Call<T>
+   **/
+  PalletBabeCall: {
+    _enum: {
+      report_equivocation: {
+        equivocationProof: "SpConsensusSlotsEquivocationProof",
+        keyOwnerProof: "SpSessionMembershipProof"
+      },
+      report_equivocation_unsigned: {
+        equivocationProof: "SpConsensusSlotsEquivocationProof",
+        keyOwnerProof: "SpSessionMembershipProof"
+      },
+      plan_config_change: {
+        config: "SpConsensusBabeDigestsNextConfigDescriptor"
+      }
+    }
+  },
+  /**
+   * Lookup200: sp_consensus_slots::EquivocationProof<sp_runtime::generic::header::Header<Number, Hash>, sp_consensus_babe::app::Public>
+   **/
+  SpConsensusSlotsEquivocationProof: {
+    offender: "SpConsensusBabeAppPublic",
+    slot: "u64",
+    firstHeader: "SpRuntimeHeader",
+    secondHeader: "SpRuntimeHeader"
+  },
+  /**
+   * Lookup201: sp_runtime::generic::header::Header<Number, Hash>
+   **/
+  SpRuntimeHeader: {
+    parentHash: "H256",
+    number: "Compact<u32>",
+    stateRoot: "H256",
+    extrinsicsRoot: "H256",
+    digest: "SpRuntimeDigest"
+  },
+  /**
+   * Lookup202: sp_session::MembershipProof
+   **/
+  SpSessionMembershipProof: {
+    session: "u32",
+    trieNodes: "Vec<Bytes>",
+    validatorCount: "u32"
+  },
+  /**
+   * Lookup203: pallet_babe::pallet::Error<T>
+   **/
+  PalletBabeError: {
+    _enum: [
+      "InvalidEquivocationProof",
+      "InvalidKeyOwnershipProof",
+      "DuplicateOffenceReport",
+      "InvalidConfiguration"
+    ]
+  },
+  /**
+   * Lookup204: pallet_timestamp::pallet::Call<T>
+   **/
+  PalletTimestampCall: {
+    _enum: {
+      set: {
+        now: "Compact<u64>"
+      }
+    }
+  },
+  /**
+   * Lookup206: pallet_balances::types::BalanceLock<Balance>
+   **/
+  PalletBalancesBalanceLock: {
+    id: "[u8;8]",
+    amount: "u128",
+    reasons: "PalletBalancesReasons"
+  },
+  /**
+   * Lookup207: pallet_balances::types::Reasons
+   **/
+  PalletBalancesReasons: {
+    _enum: ["Fee", "Misc", "All"]
+  },
+  /**
+   * Lookup210: pallet_balances::types::ReserveData<ReserveIdentifier, Balance>
+   **/
+  PalletBalancesReserveData: {
+    id: "[u8;8]",
+    amount: "u128"
+  },
+  /**
+   * Lookup213: frame_support::traits::tokens::misc::IdAmount<sh_solochain_evm_runtime::RuntimeHoldReason, Balance>
+   **/
+  FrameSupportTokensMiscIdAmountRuntimeHoldReason: {
+    id: "ShSolochainEvmRuntimeRuntimeHoldReason",
+    amount: "u128"
+  },
+  /**
+   * Lookup214: sh_solochain_evm_runtime::RuntimeHoldReason
+   **/
+  ShSolochainEvmRuntimeRuntimeHoldReason: {
+    _enum: {
+      __Unused0: "Null",
+      __Unused1: "Null",
+      __Unused2: "Null",
+      __Unused3: "Null",
+      __Unused4: "Null",
+      __Unused5: "Null",
+      __Unused6: "Null",
+      __Unused7: "Null",
+      __Unused8: "Null",
+      __Unused9: "Null",
+      __Unused10: "Null",
+      __Unused11: "Null",
+      __Unused12: "Null",
+      __Unused13: "Null",
+      __Unused14: "Null",
+      __Unused15: "Null",
+      __Unused16: "Null",
+      __Unused17: "Null",
+      __Unused18: "Null",
+      __Unused19: "Null",
+      __Unused20: "Null",
+      __Unused21: "Null",
+      __Unused22: "Null",
+      __Unused23: "Null",
+      __Unused24: "Null",
+      __Unused25: "Null",
+      __Unused26: "Null",
+      __Unused27: "Null",
+      __Unused28: "Null",
+      __Unused29: "Null",
+      __Unused30: "Null",
+      __Unused31: "Null",
+      __Unused32: "Null",
+      __Unused33: "Null",
+      __Unused34: "Null",
+      __Unused35: "Null",
+      __Unused36: "Null",
+      __Unused37: "Null",
+      __Unused38: "Null",
+      __Unused39: "Null",
+      __Unused40: "Null",
+      __Unused41: "Null",
+      __Unused42: "Null",
+      __Unused43: "Null",
+      __Unused44: "Null",
+      __Unused45: "Null",
+      __Unused46: "Null",
+      __Unused47: "Null",
+      __Unused48: "Null",
+      __Unused49: "Null",
+      __Unused50: "Null",
+      __Unused51: "Null",
+      __Unused52: "Null",
+      __Unused53: "Null",
+      __Unused54: "Null",
+      __Unused55: "Null",
+      __Unused56: "Null",
+      __Unused57: "Null",
+      __Unused58: "Null",
+      __Unused59: "Null",
+      __Unused60: "Null",
+      __Unused61: "Null",
+      __Unused62: "Null",
+      __Unused63: "Null",
+      __Unused64: "Null",
+      __Unused65: "Null",
+      __Unused66: "Null",
+      __Unused67: "Null",
+      __Unused68: "Null",
+      __Unused69: "Null",
+      __Unused70: "Null",
+      __Unused71: "Null",
+      __Unused72: "Null",
+      __Unused73: "Null",
+      __Unused74: "Null",
+      __Unused75: "Null",
+      __Unused76: "Null",
+      __Unused77: "Null",
+      __Unused78: "Null",
+      __Unused79: "Null",
+      Providers: "PalletStorageProvidersHoldReason",
+      FileSystem: "PalletFileSystemHoldReason",
+      __Unused82: "Null",
+      __Unused83: "Null",
+      PaymentStreams: "PalletPaymentStreamsHoldReason"
+    }
+  },
+  /**
+   * Lookup215: pallet_storage_providers::pallet::HoldReason
+   **/
+  PalletStorageProvidersHoldReason: {
+    _enum: ["StorageProviderDeposit", "BucketDeposit"]
+  },
+  /**
+   * Lookup216: pallet_file_system::pallet::HoldReason
+   **/
+  PalletFileSystemHoldReason: {
+    _enum: ["StorageRequestCreationHold", "FileDeletionRequestHold"]
+  },
+  /**
+   * Lookup217: pallet_payment_streams::pallet::HoldReason
+   **/
+  PalletPaymentStreamsHoldReason: {
+    _enum: ["PaymentStreamDeposit"]
+  },
+  /**
+   * Lookup220: frame_support::traits::tokens::misc::IdAmount<sh_solochain_evm_runtime::RuntimeFreezeReason, Balance>
+   **/
+  FrameSupportTokensMiscIdAmountRuntimeFreezeReason: {
+    id: "ShSolochainEvmRuntimeRuntimeFreezeReason",
+    amount: "u128"
+  },
+  /**
+   * Lookup221: sh_solochain_evm_runtime::RuntimeFreezeReason
+   **/
+  ShSolochainEvmRuntimeRuntimeFreezeReason: "Null",
+  /**
+   * Lookup223: pallet_balances::pallet::Call<T, I>
+   **/
+  PalletBalancesCall: {
+    _enum: {
+      transfer_allow_death: {
+        dest: "AccountId20",
+        value: "Compact<u128>"
+      },
+      __Unused1: "Null",
+      force_transfer: {
+        source: "AccountId20",
+        dest: "AccountId20",
+        value: "Compact<u128>"
+      },
+      transfer_keep_alive: {
+        dest: "AccountId20",
+        value: "Compact<u128>"
+      },
+      transfer_all: {
+        dest: "AccountId20",
+        keepAlive: "bool"
+      },
+      force_unreserve: {
+        who: "AccountId20",
+        amount: "u128"
+      },
+      upgrade_accounts: {
+        who: "Vec<AccountId20>"
+      },
+      __Unused7: "Null",
+      force_set_balance: {
+        who: "AccountId20",
+        newFree: "Compact<u128>"
+      },
+      force_adjust_total_issuance: {
+        direction: "PalletBalancesAdjustmentDirection",
+        delta: "Compact<u128>"
+      },
+      burn: {
+        value: "Compact<u128>",
+        keepAlive: "bool"
+      }
+    }
+  },
+  /**
+   * Lookup225: pallet_balances::types::AdjustmentDirection
+   **/
+  PalletBalancesAdjustmentDirection: {
+    _enum: ["Increase", "Decrease"]
+  },
+  /**
+   * Lookup226: pallet_balances::pallet::Error<T, I>
+   **/
+  PalletBalancesError: {
+    _enum: [
+      "VestingBalance",
+      "LiquidityRestrictions",
+      "InsufficientBalance",
+      "ExistentialDeposit",
+      "Expendability",
+      "ExistingVestingSchedule",
+      "DeadAccount",
+      "TooManyReserves",
+      "TooManyHolds",
+      "TooManyFreezes",
+      "IssuanceDeactivated",
+      "DeltaZero"
+    ]
+  },
+  /**
+   * Lookup227: sp_staking::offence::OffenceDetails<fp_account::AccountId20, Offender>
+   **/
+  SpStakingOffenceOffenceDetails: {
+    offender: "(AccountId20,Null)",
+    reporters: "Vec<AccountId20>"
+  },
+  /**
+   * Lookup233: sh_solochain_evm_runtime::SessionKeys
+   **/
+  ShSolochainEvmRuntimeSessionKeys: {
+    babe: "SpConsensusBabeAppPublic",
+    grandpa: "SpConsensusGrandpaAppPublic"
+  },
+  /**
+   * Lookup235: sp_core::crypto::KeyTypeId
+   **/
+  SpCoreCryptoKeyTypeId: "[u8;4]",
+  /**
+   * Lookup236: pallet_session::pallet::Call<T>
+   **/
+  PalletSessionCall: {
+    _enum: {
+      set_keys: {
+        _alias: {
+          keys_: "keys"
+        },
+        keys_: "ShSolochainEvmRuntimeSessionKeys",
+        proof: "Bytes"
+      },
+      purge_keys: "Null"
+    }
+  },
+  /**
+   * Lookup237: pallet_session::pallet::Error<T>
+   **/
+  PalletSessionError: {
+    _enum: ["InvalidProof", "NoAssociatedValidatorId", "DuplicatedKey", "NoKeys", "NoAccount"]
+  },
+  /**
+   * Lookup238: pallet_grandpa::StoredState<N>
+   **/
+  PalletGrandpaStoredState: {
+    _enum: {
+      Live: "Null",
+      PendingPause: {
+        scheduledAt: "u32",
+        delay: "u32"
+      },
+      Paused: "Null",
+      PendingResume: {
+        scheduledAt: "u32",
+        delay: "u32"
+      }
+    }
+  },
+  /**
+   * Lookup239: pallet_grandpa::StoredPendingChange<N, Limit>
+   **/
+  PalletGrandpaStoredPendingChange: {
+    scheduledAt: "u32",
+    delay: "u32",
+    nextAuthorities: "Vec<(SpConsensusGrandpaAppPublic,u64)>",
+    forced: "Option<u32>"
+  },
+  /**
+   * Lookup241: pallet_grandpa::pallet::Call<T>
+   **/
+  PalletGrandpaCall: {
+    _enum: {
+      report_equivocation: {
+        equivocationProof: "SpConsensusGrandpaEquivocationProof",
+        keyOwnerProof: "SpSessionMembershipProof"
+      },
+      report_equivocation_unsigned: {
+        equivocationProof: "SpConsensusGrandpaEquivocationProof",
+        keyOwnerProof: "SpSessionMembershipProof"
+      },
+      note_stalled: {
+        delay: "u32",
+        bestFinalizedBlockNumber: "u32"
+      }
+    }
+  },
+  /**
+   * Lookup242: sp_consensus_grandpa::EquivocationProof<primitive_types::H256, N>
+   **/
+  SpConsensusGrandpaEquivocationProof: {
+    setId: "u64",
+    equivocation: "SpConsensusGrandpaEquivocation"
+  },
+  /**
+   * Lookup243: sp_consensus_grandpa::Equivocation<primitive_types::H256, N>
+   **/
+  SpConsensusGrandpaEquivocation: {
+    _enum: {
+      Prevote: "FinalityGrandpaEquivocationPrevote",
+      Precommit: "FinalityGrandpaEquivocationPrecommit"
+    }
+  },
+  /**
+   * Lookup244: finality_grandpa::Equivocation<sp_consensus_grandpa::app::Public, finality_grandpa::Prevote<primitive_types::H256, N>, sp_consensus_grandpa::app::Signature>
+   **/
+  FinalityGrandpaEquivocationPrevote: {
+    roundNumber: "u64",
+    identity: "SpConsensusGrandpaAppPublic",
+    first: "(FinalityGrandpaPrevote,SpConsensusGrandpaAppSignature)",
+    second: "(FinalityGrandpaPrevote,SpConsensusGrandpaAppSignature)"
+  },
+  /**
+   * Lookup245: finality_grandpa::Prevote<primitive_types::H256, N>
+   **/
+  FinalityGrandpaPrevote: {
+    targetHash: "H256",
+    targetNumber: "u32"
+  },
+  /**
+   * Lookup246: sp_consensus_grandpa::app::Signature
+   **/
+  SpConsensusGrandpaAppSignature: "[u8;64]",
+  /**
+   * Lookup248: finality_grandpa::Equivocation<sp_consensus_grandpa::app::Public, finality_grandpa::Precommit<primitive_types::H256, N>, sp_consensus_grandpa::app::Signature>
+   **/
+  FinalityGrandpaEquivocationPrecommit: {
+    roundNumber: "u64",
+    identity: "SpConsensusGrandpaAppPublic",
+    first: "(FinalityGrandpaPrecommit,SpConsensusGrandpaAppSignature)",
+    second: "(FinalityGrandpaPrecommit,SpConsensusGrandpaAppSignature)"
+  },
+  /**
+   * Lookup249: finality_grandpa::Precommit<primitive_types::H256, N>
+   **/
+  FinalityGrandpaPrecommit: {
+    targetHash: "H256",
+    targetNumber: "u32"
+  },
+  /**
+   * Lookup251: pallet_grandpa::pallet::Error<T>
+   **/
+  PalletGrandpaError: {
+    _enum: [
+      "PauseFailed",
+      "ResumeFailed",
+      "ChangePending",
+      "TooSoon",
+      "InvalidKeyOwnershipProof",
+      "InvalidEquivocationProof",
+      "DuplicateOffenceReport"
+    ]
+  },
+  /**
+   * Lookup253: pallet_transaction_payment::Releases
+   **/
+  PalletTransactionPaymentReleases: {
+    _enum: ["V1Ancient", "V2"]
+  },
+  /**
+   * Lookup254: pallet_parameters::pallet::Call<T>
+   **/
+  PalletParametersCall: {
+    _enum: {
+      set_parameter: {
+        keyValue: "ShSolochainEvmRuntimeConfigsRuntimeParamsRuntimeParameters"
+      }
+    }
+  },
+  /**
+   * Lookup255: sh_solochain_evm_runtime::configs::runtime_params::RuntimeParameters
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsRuntimeParameters: {
+    _enum: {
+      RuntimeConfig: "ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigParameters"
+    }
+  },
+  /**
+   * Lookup256: sh_solochain_evm_runtime::configs::runtime_params::dynamic_params::runtime_config::Parameters
+   **/
+  ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigParameters: {
+    _enum: {
+      SlashAmountPerMaxFileSize:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigSlashAmountPerMaxFileSize,Option<u128>)",
+      StakeToChallengePeriod:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigStakeToChallengePeriod,Option<u128>)",
+      CheckpointChallengePeriod:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigCheckpointChallengePeriod,Option<u32>)",
+      MinChallengePeriod:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMinChallengePeriod,Option<u32>)",
+      SystemUtilisationLowerThresholdPercentage:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigSystemUtilisationLowerThresholdPercentage,Option<Perbill>)",
+      SystemUtilisationUpperThresholdPercentage:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigSystemUtilisationUpperThresholdPercentage,Option<Perbill>)",
+      MostlyStablePrice:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMostlyStablePrice,Option<u128>)",
+      MaxPrice:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMaxPrice,Option<u128>)",
+      MinPrice:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMinPrice,Option<u128>)",
+      UpperExponentFactor:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigUpperExponentFactor,Option<u32>)",
+      LowerExponentFactor:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigLowerExponentFactor,Option<u32>)",
+      ZeroSizeBucketFixedRate:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigZeroSizeBucketFixedRate,Option<u128>)",
+      IdealUtilisationRate:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigIdealUtilisationRate,Option<Perbill>)",
+      DecayRate:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigDecayRate,Option<Perbill>)",
+      MinimumTreasuryCut:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMinimumTreasuryCut,Option<Perbill>)",
+      MaximumTreasuryCut:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMaximumTreasuryCut,Option<Perbill>)",
+      BspStopStoringFilePenalty:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigBspStopStoringFilePenalty,Option<u128>)",
+      ProviderTopUpTtl:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigProviderTopUpTtl,Option<u32>)",
+      BasicReplicationTarget:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigBasicReplicationTarget,Option<u32>)",
+      StandardReplicationTarget:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigStandardReplicationTarget,Option<u32>)",
+      HighSecurityReplicationTarget:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigHighSecurityReplicationTarget,Option<u32>)",
+      SuperHighSecurityReplicationTarget:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigSuperHighSecurityReplicationTarget,Option<u32>)",
+      UltraHighSecurityReplicationTarget:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigUltraHighSecurityReplicationTarget,Option<u32>)",
+      MaxReplicationTarget:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMaxReplicationTarget,Option<u32>)",
+      TickRangeToMaximumThreshold:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigTickRangeToMaximumThreshold,Option<u32>)",
+      StorageRequestTtl:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigStorageRequestTtl,Option<u32>)",
+      MinWaitForStopStoring:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMinWaitForStopStoring,Option<u32>)",
+      MinSeedPeriod:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigMinSeedPeriod,Option<u32>)",
+      StakeToSeedPeriod:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigStakeToSeedPeriod,Option<u128>)",
+      UpfrontTicksToPay:
+        "(ShSolochainEvmRuntimeConfigsRuntimeParamsDynamicParamsRuntimeConfigUpfrontTicksToPay,Option<u32>)"
+    }
+  },
+  /**
+   * Lookup259: pallet_sudo::pallet::Call<T>
+   **/
+  PalletSudoCall: {
+    _enum: {
+      sudo: {
+        call: "Call"
+      },
+      sudo_unchecked_weight: {
+        call: "Call",
+        weight: "SpWeightsWeightV2Weight"
+      },
+      set_key: {
+        _alias: {
+          new_: "new"
+        },
+        new_: "AccountId20"
+      },
+      sudo_as: {
+        who: "AccountId20",
+        call: "Call"
+      },
+      remove_key: "Null"
+    }
+  },
+  /**
+   * Lookup261: pallet_ethereum::pallet::Call<T>
+   **/
+  PalletEthereumCall: {
+    _enum: {
+      transact: {
+        transaction: "EthereumTransactionTransactionV2"
+      }
+    }
+  },
+  /**
+   * Lookup262: ethereum::transaction::TransactionV2
+   **/
+  EthereumTransactionTransactionV2: {
+    _enum: {
+      Legacy: "EthereumTransactionLegacyLegacyTransaction",
+      EIP2930: "EthereumTransactionEip2930Eip2930Transaction",
+      EIP1559: "EthereumTransactionEip1559Eip1559Transaction"
+    }
+  },
+  /**
+   * Lookup263: ethereum::transaction::legacy::LegacyTransaction
+   **/
+  EthereumTransactionLegacyLegacyTransaction: {
+    nonce: "U256",
+    gasPrice: "U256",
+    gasLimit: "U256",
+    action: "EthereumTransactionLegacyTransactionAction",
+    value: "U256",
+    input: "Bytes",
+    signature: "EthereumTransactionLegacyTransactionSignature"
+  },
+  /**
+   * Lookup266: ethereum::transaction::legacy::TransactionAction
+   **/
+  EthereumTransactionLegacyTransactionAction: {
+    _enum: {
+      Call: "H160",
+      Create: "Null"
+    }
+  },
+  /**
+   * Lookup267: ethereum::transaction::legacy::TransactionSignature
+   **/
+  EthereumTransactionLegacyTransactionSignature: {
+    v: "u64",
+    r: "H256",
+    s: "H256"
+  },
+  /**
+   * Lookup269: ethereum::transaction::eip2930::EIP2930Transaction
+   **/
+  EthereumTransactionEip2930Eip2930Transaction: {
+    chainId: "u64",
+    nonce: "U256",
+    gasPrice: "U256",
+    gasLimit: "U256",
+    action: "EthereumTransactionLegacyTransactionAction",
+    value: "U256",
+    input: "Bytes",
+    accessList: "Vec<EthereumTransactionEip2930AccessListItem>",
+    oddYParity: "bool",
+    r: "H256",
+    s: "H256"
+  },
+  /**
+   * Lookup271: ethereum::transaction::eip2930::AccessListItem
+   **/
+  EthereumTransactionEip2930AccessListItem: {
+    address: "H160",
+    storageKeys: "Vec<H256>"
+  },
+  /**
+   * Lookup272: ethereum::transaction::eip1559::EIP1559Transaction
+   **/
+  EthereumTransactionEip1559Eip1559Transaction: {
+    chainId: "u64",
+    nonce: "U256",
+    maxPriorityFeePerGas: "U256",
+    maxFeePerGas: "U256",
+    gasLimit: "U256",
+    action: "EthereumTransactionLegacyTransactionAction",
+    value: "U256",
+    input: "Bytes",
+    accessList: "Vec<EthereumTransactionEip2930AccessListItem>",
+    oddYParity: "bool",
+    r: "H256",
+    s: "H256"
+  },
+  /**
+   * Lookup273: pallet_evm::pallet::Call<T>
+   **/
+  PalletEvmCall: {
+    _enum: {
+      withdraw: {
+        address: "H160",
+        value: "u128"
+      },
+      call: {
+        source: "H160",
+        target: "H160",
+        input: "Bytes",
+        value: "U256",
+        gasLimit: "u64",
+        maxFeePerGas: "U256",
+        maxPriorityFeePerGas: "Option<U256>",
+        nonce: "Option<U256>",
+        accessList: "Vec<(H160,Vec<H256>)>"
+      },
+      create: {
+        source: "H160",
+        init: "Bytes",
+        value: "U256",
+        gasLimit: "u64",
+        maxFeePerGas: "U256",
+        maxPriorityFeePerGas: "Option<U256>",
+        nonce: "Option<U256>",
+        accessList: "Vec<(H160,Vec<H256>)>"
+      },
+      create2: {
+        source: "H160",
+        init: "Bytes",
+        salt: "H256",
+        value: "U256",
+        gasLimit: "u64",
+        maxFeePerGas: "U256",
+        maxPriorityFeePerGas: "Option<U256>",
+        nonce: "Option<U256>",
+        accessList: "Vec<(H160,Vec<H256>)>"
+      }
+    }
+  },
+  /**
+   * Lookup277: pallet_storage_providers::pallet::Call<T>
+   **/
+  PalletStorageProvidersCall: {
+    _enum: {
+      request_msp_sign_up: {
+        capacity: "u64",
+        multiaddresses: "Vec<Bytes>",
+        valuePropPricePerGigaUnitOfDataPerBlock: "u128",
+        commitment: "Bytes",
+        valuePropMaxDataLimit: "u64",
+        paymentAccount: "AccountId20"
+      },
+      request_bsp_sign_up: {
+        capacity: "u64",
+        multiaddresses: "Vec<Bytes>",
+        paymentAccount: "AccountId20"
+      },
+      confirm_sign_up: {
+        providerAccount: "Option<AccountId20>"
+      },
+      cancel_sign_up: "Null",
+      msp_sign_off: {
+        mspId: "H256"
+      },
+      bsp_sign_off: "Null",
+      change_capacity: {
+        newCapacity: "u64"
+      },
+      add_value_prop: {
+        pricePerGigaUnitOfDataPerBlock: "u128",
+        commitment: "Bytes",
+        bucketDataLimit: "u64"
+      },
+      make_value_prop_unavailable: {
+        valuePropId: "H256"
+      },
+      add_multiaddress: {
+        newMultiaddress: "Bytes"
+      },
+      remove_multiaddress: {
+        multiaddress: "Bytes"
+      },
+      force_msp_sign_up: {
+        who: "AccountId20",
+        mspId: "H256",
+        capacity: "u64",
+        multiaddresses: "Vec<Bytes>",
+        valuePropPricePerGigaUnitOfDataPerBlock: "u128",
+        commitment: "Bytes",
+        valuePropMaxDataLimit: "u64",
+        paymentAccount: "AccountId20"
+      },
+      force_bsp_sign_up: {
+        who: "AccountId20",
+        bspId: "H256",
+        capacity: "u64",
+        multiaddresses: "Vec<Bytes>",
+        paymentAccount: "AccountId20",
+        weight: "Option<u32>"
+      },
+      slash: {
+        providerId: "H256"
+      },
+      top_up_deposit: "Null",
+      delete_provider: {
+        providerId: "H256"
+      },
+      stop_all_cycles: "Null"
+    }
+  },
+  /**
+   * Lookup278: pallet_file_system::pallet::Call<T>
+   **/
+  PalletFileSystemCall: {
+    _enum: {
+      create_bucket: {
+        mspId: "H256",
+        name: "Bytes",
+        private: "bool",
+        valuePropId: "H256"
+      },
+      request_move_bucket: {
+        bucketId: "H256",
+        newMspId: "H256",
+        newValuePropId: "H256"
+      },
+      msp_respond_move_bucket_request: {
+        bucketId: "H256",
+        response: "PalletFileSystemBucketMoveRequestResponse"
+      },
+      update_bucket_privacy: {
+        bucketId: "H256",
+        private: "bool"
+      },
+      create_and_associate_collection_with_bucket: {
+        bucketId: "H256"
+      },
+      delete_bucket: {
+        bucketId: "H256"
+      },
+      issue_storage_request: {
+        _alias: {
+          size_: "size"
+        },
+        bucketId: "H256",
+        location: "Bytes",
+        fingerprint: "H256",
+        size_: "u64",
+        mspId: "H256",
+        peerIds: "Vec<Bytes>",
+        replicationTarget: "PalletFileSystemReplicationTarget"
+      },
+      revoke_storage_request: {
+        fileKey: "H256"
+      },
+      msp_respond_storage_requests_multiple_buckets: {
+        storageRequestMspResponse: "Vec<PalletFileSystemStorageRequestMspBucketResponse>"
+      },
+      msp_stop_storing_bucket: {
+        bucketId: "H256"
+      },
+      bsp_volunteer: {
+        fileKey: "H256"
+      },
+      bsp_confirm_storing: {
+        nonInclusionForestProof: "SpTrieStorageProofCompactProof",
+        fileKeysAndProofs: "Vec<PalletFileSystemFileKeyWithProof>"
+      },
+      bsp_request_stop_storing: {
+        _alias: {
+          size_: "size"
+        },
+        fileKey: "H256",
+        bucketId: "H256",
+        location: "Bytes",
+        owner: "AccountId20",
+        fingerprint: "H256",
+        size_: "u64",
+        canServe: "bool",
+        inclusionForestProof: "SpTrieStorageProofCompactProof"
+      },
+      bsp_confirm_stop_storing: {
+        fileKey: "H256",
+        inclusionForestProof: "SpTrieStorageProofCompactProof"
+      },
+      stop_storing_for_insolvent_user: {
+        _alias: {
+          size_: "size"
+        },
+        fileKey: "H256",
+        bucketId: "H256",
+        location: "Bytes",
+        owner: "AccountId20",
+        fingerprint: "H256",
+        size_: "u64",
+        inclusionForestProof: "SpTrieStorageProofCompactProof"
+      },
+      msp_stop_storing_bucket_for_insolvent_user: {
+        bucketId: "H256"
+      },
+      request_delete_file: {
+        _alias: {
+          size_: "size"
+        },
+        signedIntention: "PalletFileSystemFileOperationIntention",
+        signature: "FpAccountEthereumSignature",
+        bucketId: "H256",
+        location: "Bytes",
+        size_: "u64",
+        fingerprint: "H256"
+      },
+      delete_file: {
+        _alias: {
+          size_: "size"
+        },
+        fileOwner: "AccountId20",
+        signedIntention: "PalletFileSystemFileOperationIntention",
+        signature: "FpAccountEthereumSignature",
+        bucketId: "H256",
+        location: "Bytes",
+        size_: "u64",
+        fingerprint: "H256",
+        bspId: "Option<H256>",
+        forestProof: "SpTrieStorageProofCompactProof"
+      },
+      delete_file_for_incomplete_storage_request: {
+        fileKey: "H256",
+        bspId: "Option<H256>",
+        forestProof: "SpTrieStorageProofCompactProof"
+      }
+    }
+  },
+  /**
+   * Lookup279: pallet_file_system::types::BucketMoveRequestResponse
+   **/
+  PalletFileSystemBucketMoveRequestResponse: {
+    _enum: ["Accepted", "Rejected"]
+  },
+  /**
+   * Lookup280: pallet_file_system::types::ReplicationTarget<T>
+   **/
+  PalletFileSystemReplicationTarget: {
+    _enum: {
+      Basic: "Null",
+      Standard: "Null",
+      HighSecurity: "Null",
+      SuperHighSecurity: "Null",
+      UltraHighSecurity: "Null",
+      Custom: "u32"
+    }
+  },
+  /**
+   * Lookup282: pallet_file_system::types::StorageRequestMspBucketResponse<T>
+   **/
+  PalletFileSystemStorageRequestMspBucketResponse: {
+    bucketId: "H256",
+    accept: "Option<PalletFileSystemStorageRequestMspAcceptedFileKeys>",
+    reject: "Vec<PalletFileSystemRejectedStorageRequest>"
+  },
+  /**
+   * Lookup284: pallet_file_system::types::StorageRequestMspAcceptedFileKeys<T>
+   **/
+  PalletFileSystemStorageRequestMspAcceptedFileKeys: {
+    fileKeysAndProofs: "Vec<PalletFileSystemFileKeyWithProof>",
+    forestProof: "SpTrieStorageProofCompactProof"
+  },
+  /**
+   * Lookup286: pallet_file_system::types::FileKeyWithProof<T>
+   **/
+  PalletFileSystemFileKeyWithProof: {
+    fileKey: "H256",
+    proof: "ShpFileKeyVerifierFileKeyProof"
+  },
+  /**
+   * Lookup288: pallet_file_system::types::RejectedStorageRequest<T>
+   **/
+  PalletFileSystemRejectedStorageRequest: {
+    fileKey: "H256",
+    reason: "PalletFileSystemRejectedStorageRequestReason"
+  },
+  /**
+   * Lookup290: pallet_proofs_dealer::pallet::Call<T>
+   **/
+  PalletProofsDealerCall: {
+    _enum: {
+      challenge: {
+        key: "H256"
+      },
+      submit_proof: {
+        proof: "PalletProofsDealerProof",
+        provider: "Option<H256>"
+      },
+      force_initialise_challenge_cycle: {
+        provider: "H256"
+      },
+      set_paused: {
+        paused: "bool"
+      },
+      priority_challenge: {
+        key: "H256",
+        shouldRemoveKey: "bool"
+      }
+    }
+  },
+  /**
+   * Lookup291: pallet_randomness::pallet::Call<T>
+   **/
+  PalletRandomnessCall: {
+    _enum: ["set_babe_randomness"]
+  },
+  /**
+   * Lookup292: pallet_payment_streams::pallet::Call<T>
+   **/
+  PalletPaymentStreamsCall: {
+    _enum: {
+      create_fixed_rate_payment_stream: {
+        providerId: "H256",
+        userAccount: "AccountId20",
+        rate: "u128"
+      },
+      update_fixed_rate_payment_stream: {
+        providerId: "H256",
+        userAccount: "AccountId20",
+        newRate: "u128"
+      },
+      delete_fixed_rate_payment_stream: {
+        providerId: "H256",
+        userAccount: "AccountId20"
+      },
+      create_dynamic_rate_payment_stream: {
+        providerId: "H256",
+        userAccount: "AccountId20",
+        amountProvided: "u64"
+      },
+      update_dynamic_rate_payment_stream: {
+        providerId: "H256",
+        userAccount: "AccountId20",
+        newAmountProvided: "u64"
+      },
+      delete_dynamic_rate_payment_stream: {
+        providerId: "H256",
+        userAccount: "AccountId20"
+      },
+      charge_payment_streams: {
+        userAccount: "AccountId20"
+      },
+      charge_multiple_users_payment_streams: {
+        userAccounts: "Vec<AccountId20>"
+      },
+      pay_outstanding_debt: {
+        providers: "Vec<H256>"
+      },
+      clear_insolvent_flag: "Null"
+    }
+  },
+  /**
+   * Lookup293: pallet_bucket_nfts::pallet::Call<T>
+   **/
+  PalletBucketNftsCall: {
+    _enum: {
+      share_access: {
+        recipient: "AccountId20",
+        bucket: "H256",
+        itemId: "u32",
+        readAccessRegex: "Option<Bytes>"
+      },
+      update_read_access: {
+        bucket: "H256",
+        itemId: "u32",
+        readAccessRegex: "Option<Bytes>"
+      }
+    }
+  },
+  /**
+   * Lookup295: pallet_nfts::pallet::Call<T, I>
+   **/
+  PalletNftsCall: {
+    _enum: {
+      create: {
+        admin: "AccountId20",
+        config: "PalletNftsCollectionConfig"
+      },
+      force_create: {
+        owner: "AccountId20",
+        config: "PalletNftsCollectionConfig"
+      },
+      destroy: {
+        collection: "u32",
+        witness: "PalletNftsDestroyWitness"
+      },
+      mint: {
+        collection: "u32",
+        item: "u32",
+        mintTo: "AccountId20",
+        witnessData: "Option<PalletNftsMintWitness>"
+      },
+      force_mint: {
+        collection: "u32",
+        item: "u32",
+        mintTo: "AccountId20",
+        itemConfig: "PalletNftsItemConfig"
+      },
+      burn: {
+        collection: "u32",
+        item: "u32"
+      },
+      transfer: {
+        collection: "u32",
+        item: "u32",
+        dest: "AccountId20"
+      },
+      redeposit: {
+        collection: "u32",
+        items: "Vec<u32>"
+      },
+      lock_item_transfer: {
+        collection: "u32",
+        item: "u32"
+      },
+      unlock_item_transfer: {
+        collection: "u32",
+        item: "u32"
+      },
+      lock_collection: {
+        collection: "u32",
+        lockSettings: "u64"
+      },
+      transfer_ownership: {
+        collection: "u32",
+        newOwner: "AccountId20"
+      },
+      set_team: {
+        collection: "u32",
+        issuer: "Option<AccountId20>",
+        admin: "Option<AccountId20>",
+        freezer: "Option<AccountId20>"
+      },
+      force_collection_owner: {
+        collection: "u32",
+        owner: "AccountId20"
+      },
+      force_collection_config: {
+        collection: "u32",
+        config: "PalletNftsCollectionConfig"
+      },
+      approve_transfer: {
+        collection: "u32",
+        item: "u32",
+        delegate: "AccountId20",
+        maybeDeadline: "Option<u32>"
+      },
+      cancel_approval: {
+        collection: "u32",
+        item: "u32",
+        delegate: "AccountId20"
+      },
+      clear_all_transfer_approvals: {
+        collection: "u32",
+        item: "u32"
+      },
+      lock_item_properties: {
+        collection: "u32",
+        item: "u32",
+        lockMetadata: "bool",
+        lockAttributes: "bool"
+      },
+      set_attribute: {
+        collection: "u32",
+        maybeItem: "Option<u32>",
+        namespace: "PalletNftsAttributeNamespace",
+        key: "Bytes",
+        value: "Bytes"
+      },
+      force_set_attribute: {
+        setAs: "Option<AccountId20>",
+        collection: "u32",
+        maybeItem: "Option<u32>",
+        namespace: "PalletNftsAttributeNamespace",
+        key: "Bytes",
+        value: "Bytes"
+      },
+      clear_attribute: {
+        collection: "u32",
+        maybeItem: "Option<u32>",
+        namespace: "PalletNftsAttributeNamespace",
+        key: "Bytes"
+      },
+      approve_item_attributes: {
+        collection: "u32",
+        item: "u32",
+        delegate: "AccountId20"
+      },
+      cancel_item_attributes_approval: {
+        collection: "u32",
+        item: "u32",
+        delegate: "AccountId20",
+        witness: "PalletNftsCancelAttributesApprovalWitness"
+      },
+      set_metadata: {
+        collection: "u32",
+        item: "u32",
+        data: "Bytes"
+      },
+      clear_metadata: {
+        collection: "u32",
+        item: "u32"
+      },
+      set_collection_metadata: {
+        collection: "u32",
+        data: "Bytes"
+      },
+      clear_collection_metadata: {
+        collection: "u32"
+      },
+      set_accept_ownership: {
+        maybeCollection: "Option<u32>"
+      },
+      set_collection_max_supply: {
+        collection: "u32",
+        maxSupply: "u32"
+      },
+      update_mint_settings: {
+        collection: "u32",
+        mintSettings: "PalletNftsMintSettings"
+      },
+      set_price: {
+        collection: "u32",
+        item: "u32",
+        price: "Option<u128>",
+        whitelistedBuyer: "Option<AccountId20>"
+      },
+      buy_item: {
+        collection: "u32",
+        item: "u32",
+        bidPrice: "u128"
+      },
+      pay_tips: {
+        tips: "Vec<PalletNftsItemTip>"
+      },
+      create_swap: {
+        offeredCollection: "u32",
+        offeredItem: "u32",
+        desiredCollection: "u32",
+        maybeDesiredItem: "Option<u32>",
+        maybePrice: "Option<PalletNftsPriceWithDirection>",
+        duration: "u32"
+      },
+      cancel_swap: {
+        offeredCollection: "u32",
+        offeredItem: "u32"
+      },
+      claim_swap: {
+        sendCollection: "u32",
+        sendItem: "u32",
+        receiveCollection: "u32",
+        receiveItem: "u32",
+        witnessPrice: "Option<PalletNftsPriceWithDirection>"
+      },
+      mint_pre_signed: {
+        mintData: "PalletNftsPreSignedMint",
+        signature: "FpAccountEthereumSignature",
+        signer: "AccountId20"
+      },
+      set_attributes_pre_signed: {
+        data: "PalletNftsPreSignedAttributes",
+        signature: "FpAccountEthereumSignature",
+        signer: "AccountId20"
+      }
+    }
+  },
+  /**
+   * Lookup296: pallet_nfts::types::CollectionConfig<Price, BlockNumber, CollectionId>
+   **/
+  PalletNftsCollectionConfig: {
+    settings: "u64",
+    maxSupply: "Option<u32>",
+    mintSettings: "PalletNftsMintSettings"
+  },
+  /**
+   * Lookup298: pallet_nfts::types::CollectionSetting
+   **/
+  PalletNftsCollectionSetting: {
+    _enum: [
+      "__Unused0",
+      "TransferableItems",
+      "UnlockedMetadata",
+      "__Unused3",
+      "UnlockedAttributes",
+      "__Unused5",
+      "__Unused6",
+      "__Unused7",
+      "UnlockedMaxSupply",
+      "__Unused9",
+      "__Unused10",
+      "__Unused11",
+      "__Unused12",
+      "__Unused13",
+      "__Unused14",
+      "__Unused15",
+      "DepositRequired"
+    ]
+  },
+  /**
+   * Lookup299: pallet_nfts::types::MintSettings<Price, BlockNumber, CollectionId>
+   **/
+  PalletNftsMintSettings: {
+    mintType: "PalletNftsMintType",
+    price: "Option<u128>",
+    startBlock: "Option<u32>",
+    endBlock: "Option<u32>",
+    defaultItemSettings: "u64"
+  },
+  /**
+   * Lookup300: pallet_nfts::types::MintType<CollectionId>
+   **/
+  PalletNftsMintType: {
+    _enum: {
+      Issuer: "Null",
+      Public: "Null",
+      HolderOf: "u32"
+    }
+  },
+  /**
+   * Lookup302: pallet_nfts::types::ItemSetting
+   **/
+  PalletNftsItemSetting: {
+    _enum: ["__Unused0", "Transferable", "UnlockedMetadata", "__Unused3", "UnlockedAttributes"]
+  },
+  /**
+   * Lookup303: pallet_nfts::types::DestroyWitness
+   **/
+  PalletNftsDestroyWitness: {
+    itemMetadatas: "Compact<u32>",
+    itemConfigs: "Compact<u32>",
+    attributes: "Compact<u32>"
+  },
+  /**
+   * Lookup305: pallet_nfts::types::MintWitness<ItemId, Balance>
+   **/
+  PalletNftsMintWitness: {
+    ownedItem: "Option<u32>",
+    mintPrice: "Option<u128>"
+  },
+  /**
+   * Lookup306: pallet_nfts::types::ItemConfig
+   **/
+  PalletNftsItemConfig: {
+    settings: "u64"
+  },
+  /**
+   * Lookup307: pallet_nfts::types::CancelAttributesApprovalWitness
+   **/
+  PalletNftsCancelAttributesApprovalWitness: {
+    accountAttributes: "u32"
+  },
+  /**
+   * Lookup309: pallet_nfts::types::ItemTip<CollectionId, ItemId, fp_account::AccountId20, Amount>
+   **/
+  PalletNftsItemTip: {
+    collection: "u32",
+    item: "u32",
+    receiver: "AccountId20",
+    amount: "u128"
+  },
+  /**
+   * Lookup311: pallet_nfts::types::PreSignedMint<CollectionId, ItemId, fp_account::AccountId20, Deadline, Balance>
+   **/
+  PalletNftsPreSignedMint: {
+    collection: "u32",
+    item: "u32",
+    attributes: "Vec<(Bytes,Bytes)>",
+    metadata: "Bytes",
+    onlyAccount: "Option<AccountId20>",
+    deadline: "u32",
+    mintPrice: "Option<u128>"
+  },
+  /**
+   * Lookup312: pallet_nfts::types::PreSignedAttributes<CollectionId, ItemId, fp_account::AccountId20, Deadline>
+   **/
+  PalletNftsPreSignedAttributes: {
+    collection: "u32",
+    item: "u32",
+    attributes: "Vec<(Bytes,Bytes)>",
+    namespace: "PalletNftsAttributeNamespace",
+    deadline: "u32"
+  },
+  /**
+   * Lookup313: pallet_sudo::pallet::Error<T>
+   **/
+  PalletSudoError: {
+    _enum: ["RequireSudo"]
+  },
+  /**
+   * Lookup315: fp_rpc::TransactionStatus
+   **/
+  FpRpcTransactionStatus: {
+    transactionHash: "H256",
+    transactionIndex: "u32",
+    from: "H160",
+    to: "Option<H160>",
+    contractAddress: "Option<H160>",
+    logs: "Vec<EthereumLog>",
+    logsBloom: "EthbloomBloom"
+  },
+  /**
+   * Lookup318: ethbloom::Bloom
+   **/
+  EthbloomBloom: "[u8;256]",
+  /**
+   * Lookup320: ethereum::receipt::ReceiptV3
+   **/
+  EthereumReceiptReceiptV3: {
+    _enum: {
+      Legacy: "EthereumReceiptEip658ReceiptData",
+      EIP2930: "EthereumReceiptEip658ReceiptData",
+      EIP1559: "EthereumReceiptEip658ReceiptData"
+    }
+  },
+  /**
+   * Lookup321: ethereum::receipt::EIP658ReceiptData
+   **/
+  EthereumReceiptEip658ReceiptData: {
+    statusCode: "u8",
+    usedGas: "U256",
+    logsBloom: "EthbloomBloom",
+    logs: "Vec<EthereumLog>"
+  },
+  /**
+   * Lookup322: ethereum::block::Block<ethereum::transaction::TransactionV2>
+   **/
+  EthereumBlock: {
+    header: "EthereumHeader",
+    transactions: "Vec<EthereumTransactionTransactionV2>",
+    ommers: "Vec<EthereumHeader>"
+  },
+  /**
+   * Lookup323: ethereum::header::Header
+   **/
+  EthereumHeader: {
+    parentHash: "H256",
+    ommersHash: "H256",
+    beneficiary: "H160",
+    stateRoot: "H256",
+    transactionsRoot: "H256",
+    receiptsRoot: "H256",
+    logsBloom: "EthbloomBloom",
+    difficulty: "U256",
+    number: "U256",
+    gasLimit: "U256",
+    gasUsed: "U256",
+    timestamp: "u64",
+    extraData: "Bytes",
+    mixHash: "H256",
+    nonce: "EthereumTypesHashH64"
+  },
+  /**
+   * Lookup324: ethereum_types::hash::H64
+   **/
+  EthereumTypesHashH64: "[u8;8]",
+  /**
+   * Lookup329: pallet_ethereum::pallet::Error<T>
+   **/
+  PalletEthereumError: {
+    _enum: ["InvalidSignature", "PreLogExists"]
+  },
+  /**
+   * Lookup330: pallet_evm::CodeMetadata
+   **/
+  PalletEvmCodeMetadata: {
+    _alias: {
+      size_: "size",
+      hash_: "hash"
+    },
+    size_: "u64",
+    hash_: "H256"
+  },
+  /**
+   * Lookup332: pallet_evm::pallet::Error<T>
+   **/
+  PalletEvmError: {
+    _enum: [
+      "BalanceLow",
+      "FeeOverflow",
+      "PaymentOverflow",
+      "WithdrawFailed",
+      "GasPriceTooLow",
+      "InvalidNonce",
+      "GasLimitTooLow",
+      "GasLimitTooHigh",
+      "InvalidChainId",
+      "InvalidSignature",
+      "Reentrancy",
+      "TransactionMustComeFromEOA",
+      "Undefined"
+    ]
+  },
+  /**
+   * Lookup333: pallet_storage_providers::types::SignUpRequest<T>
+   **/
+  PalletStorageProvidersSignUpRequest: {
+    spSignUpRequest: "PalletStorageProvidersSignUpRequestSpParams",
+    at: "u32"
+  },
+  /**
+   * Lookup334: pallet_storage_providers::types::SignUpRequestSpParams<T>
+   **/
+  PalletStorageProvidersSignUpRequestSpParams: {
+    _enum: {
+      BackupStorageProvider: "PalletStorageProvidersBackupStorageProvider",
+      MainStorageProvider: "PalletStorageProvidersMainStorageProviderSignUpRequest"
+    }
+  },
+  /**
+   * Lookup335: pallet_storage_providers::types::BackupStorageProvider<T>
+   **/
+  PalletStorageProvidersBackupStorageProvider: {
+    capacity: "u64",
+    capacityUsed: "u64",
+    multiaddresses: "Vec<Bytes>",
+    root: "H256",
+    lastCapacityChange: "u32",
+    ownerAccount: "AccountId20",
+    paymentAccount: "AccountId20",
+    reputationWeight: "u32",
+    signUpBlock: "u32"
+  },
+  /**
+   * Lookup336: pallet_storage_providers::types::MainStorageProviderSignUpRequest<T>
+   **/
+  PalletStorageProvidersMainStorageProviderSignUpRequest: {
+    mspInfo: "PalletStorageProvidersMainStorageProvider",
+    valueProp: "PalletStorageProvidersValueProposition"
+  },
+  /**
+   * Lookup337: pallet_storage_providers::types::MainStorageProvider<T>
+   **/
+  PalletStorageProvidersMainStorageProvider: {
+    capacity: "u64",
+    capacityUsed: "u64",
+    multiaddresses: "Vec<Bytes>",
+    amountOfBuckets: "u128",
+    amountOfValueProps: "u32",
+    lastCapacityChange: "u32",
+    ownerAccount: "AccountId20",
+    paymentAccount: "AccountId20",
+    signUpBlock: "u32"
+  },
+  /**
+   * Lookup338: pallet_storage_providers::types::Bucket<T>
+   **/
+  PalletStorageProvidersBucket: {
+    _alias: {
+      size_: "size"
+    },
+    root: "H256",
+    userId: "AccountId20",
+    mspId: "Option<H256>",
+    private: "bool",
+    readAccessGroupId: "Option<u32>",
+    size_: "u64",
+    valuePropId: "H256"
+  },
+  /**
+   * Lookup342: pallet_storage_providers::pallet::Error<T>
+   **/
+  PalletStorageProvidersError: {
+    _enum: [
+      "AlreadyRegistered",
+      "SignUpNotRequested",
+      "SignUpRequestPending",
+      "NoMultiAddress",
+      "InvalidMultiAddress",
+      "StorageTooLow",
+      "NotEnoughBalance",
+      "CannotHoldDeposit",
+      "StorageStillInUse",
+      "SignOffPeriodNotPassed",
+      "RandomnessNotValidYet",
+      "SignUpRequestExpired",
+      "NewCapacityLessThanUsedStorage",
+      "NewCapacityEqualsCurrentCapacity",
+      "NewCapacityCantBeZero",
+      "NotEnoughTimePassed",
+      "NewUsedCapacityExceedsStorageCapacity",
+      "DepositTooLow",
+      "NotRegistered",
+      "NoUserId",
+      "NoBucketId",
+      "SpRegisteredButDataNotFound",
+      "BucketNotFound",
+      "BucketAlreadyExists",
+      "BucketNotEmpty",
+      "BucketsMovedAmountMismatch",
+      "AppendBucketToMspFailed",
+      "ProviderNotSlashable",
+      "TopUpNotRequired",
+      "BucketMustHaveMspForOperation",
+      "MultiAddressesMaxAmountReached",
+      "MultiAddressNotFound",
+      "MultiAddressAlreadyExists",
+      "LastMultiAddressCantBeRemoved",
+      "ValuePropositionNotFound",
+      "ValuePropositionAlreadyExists",
+      "ValuePropositionNotAvailable",
+      "CantDeactivateLastValueProp",
+      "ValuePropositionsDeletedAmountMismatch",
+      "FixedRatePaymentStreamNotFound",
+      "MspAlreadyAssignedToBucket",
+      "BucketSizeExceedsLimit",
+      "BucketHasNoValueProposition",
+      "MaxBlockNumberReached",
+      "OperationNotAllowedForInsolventProvider",
+      "DeleteProviderConditionsNotMet",
+      "CannotStopCycleWithNonDefaultRoot",
+      "BspOnlyOperation",
+      "MspOnlyOperation",
+      "InvalidEncodedFileMetadata",
+      "InvalidEncodedAccountId",
+      "PaymentStreamNotFound"
+    ]
+  },
+  /**
+   * Lookup343: pallet_file_system::types::StorageRequestMetadata<T>
+   **/
+  PalletFileSystemStorageRequestMetadata: {
+    _alias: {
+      size_: "size"
+    },
+    requestedAt: "u32",
+    expiresAt: "u32",
+    owner: "AccountId20",
+    bucketId: "H256",
+    location: "Bytes",
+    fingerprint: "H256",
+    size_: "u64",
+    msp: "Option<(H256,bool)>",
+    userPeerIds: "Vec<Bytes>",
+    bspsRequired: "u32",
+    bspsConfirmed: "u32",
+    bspsVolunteered: "u32",
+    depositPaid: "u128"
+  },
+  /**
+   * Lookup346: pallet_file_system::types::StorageRequestBspsMetadata<T>
+   **/
+  PalletFileSystemStorageRequestBspsMetadata: {
+    confirmed: "bool"
+  },
+  /**
+   * Lookup349: pallet_file_system::types::PendingFileDeletionRequest<T>
+   **/
+  PalletFileSystemPendingFileDeletionRequest: {
+    user: "AccountId20",
+    fileKey: "H256",
+    bucketId: "H256",
+    fileSize: "u64",
+    depositPaidForCreation: "u128",
+    queuePriorityChallenge: "bool"
+  },
+  /**
+   * Lookup351: pallet_file_system::types::PendingStopStoringRequest<T>
+   **/
+  PalletFileSystemPendingStopStoringRequest: {
+    tickWhenRequested: "u32",
+    fileOwner: "AccountId20",
+    fileSize: "u64"
+  },
+  /**
+   * Lookup352: pallet_file_system::types::MoveBucketRequestMetadata<T>
+   **/
+  PalletFileSystemMoveBucketRequestMetadata: {
+    requester: "AccountId20",
+    newMspId: "H256",
+    newValuePropId: "H256"
+  },
+  /**
+   * Lookup353: pallet_file_system::types::IncompleteStorageRequestMetadata<T>
+   **/
+  PalletFileSystemIncompleteStorageRequestMetadata: {
+    owner: "AccountId20",
+    bucketId: "H256",
+    location: "Bytes",
+    fileSize: "u64",
+    fingerprint: "H256",
+    pendingBspRemovals: "Vec<H256>",
+    pendingBucketRemoval: "bool"
+  },
+  /**
+   * Lookup355: pallet_file_system::pallet::Error<T>
+   **/
+  PalletFileSystemError: {
+    _enum: [
+      "StorageRequestAlreadyRegistered",
+      "StorageRequestNotFound",
+      "StorageRequestNotRevoked",
+      "StorageRequestExists",
+      "ReplicationTargetCannotBeZero",
+      "ReplicationTargetExceedsMaximum",
+      "MaxReplicationTargetSmallerThanDefault",
+      "NotABsp",
+      "NotAMsp",
+      "NotASp",
+      "BspNotVolunteered",
+      "BspNotConfirmed",
+      "BspAlreadyConfirmed",
+      "StorageRequestBspsRequiredFulfilled",
+      "BspAlreadyVolunteered",
+      "InsufficientAvailableCapacity",
+      "UnexpectedNumberOfRemovedVolunteeredBsps",
+      "BspNotEligibleToVolunteer",
+      "StorageRequestExpiredNoSlotAvailable",
+      "StorageRequestNotAuthorized",
+      "MaxTickNumberReached",
+      "FailedToEncodeBsp",
+      "FailedToEncodeFingerprint",
+      "FailedToDecodeThreshold",
+      "AboveThreshold",
+      "ThresholdArithmeticError",
+      "FailedTypeConversion",
+      "DividedByZero",
+      "ImpossibleFailedToGetValue",
+      "BucketIsNotPrivate",
+      "BucketNotFound",
+      "BucketNotEmpty",
+      "NotBucketOwner",
+      "ValuePropositionNotAvailable",
+      "CollectionNotFound",
+      "ProviderRootNotFound",
+      "ExpectedNonInclusionProof",
+      "ExpectedInclusionProof",
+      "InvalidFileKeyMetadata",
+      "ThresholdBelowAsymptote",
+      "NotFileOwner",
+      "FileKeyAlreadyPendingDeletion",
+      "MaxUserPendingDeletionRequestsReached",
+      "MspNotStoringBucket",
+      "FileKeyNotPendingDeletion",
+      "FileSizeCannotBeZero",
+      "NoGlobalReputationWeightSet",
+      "NoBspReputationWeightSet",
+      "MaximumThresholdCannotBeZero",
+      "TickRangeToMaximumThresholdCannotBeZero",
+      "PendingStopStoringRequestNotFound",
+      "MinWaitForStopStoringNotReached",
+      "PendingStopStoringRequestAlreadyExists",
+      "OperationNotAllowedWithInsolventUser",
+      "UserNotInsolvent",
+      "NotSelectedMsp",
+      "MspAlreadyConfirmed",
+      "RequestWithoutMsp",
+      "MspAlreadyStoringBucket",
+      "MoveBucketRequestNotFound",
+      "BucketIsBeingMoved",
+      "BspAlreadyDataServer",
+      "BspDataServersExceeded",
+      "FileMetadataProcessingQueueFull",
+      "TooManyBatchResponses",
+      "TooManyStorageRequestResponses",
+      "InvalidBucketIdFileKeyPair",
+      "InconsistentStateKeyAlreadyExists",
+      "FixedRatePaymentStreamNotFound",
+      "DynamicRatePaymentStreamNotFound",
+      "CannotHoldDeposit",
+      "FailedToQueryEarliestFileVolunteerTick",
+      "FailedToGetOwnerAccount",
+      "FailedToGetPaymentAccount",
+      "NoFileKeysToConfirm",
+      "RootNotUpdated",
+      "NoPrivacyChange",
+      "OperationNotAllowedForInsolventProvider",
+      "OperationNotAllowedWhileBucketIsNotStoredByMsp",
+      "FailedToComputeFileKey",
+      "FailedToCreateFileMetadata",
+      "InvalidSignature",
+      "ForestProofVerificationFailed",
+      "ProviderNotStoringFile",
+      "InvalidProviderID",
+      "InvalidSignedOperation",
+      "FileKeyMismatch",
+      "IncompleteStorageRequestNotFound"
+    ]
+  },
+  /**
+   * Lookup357: pallet_proofs_dealer::types::ProofSubmissionRecord<T>
+   **/
+  PalletProofsDealerProofSubmissionRecord: {
+    lastTickProven: "u32",
+    nextTickToSubmitProofFor: "u32"
+  },
+  /**
+   * Lookup364: pallet_proofs_dealer::pallet::Error<T>
+   **/
+  PalletProofsDealerError: {
+    _enum: [
+      "NotProvider",
+      "ChallengesQueueOverflow",
+      "PriorityChallengesQueueOverflow",
+      "FeeChargeFailed",
+      "EmptyKeyProofs",
+      "ProviderRootNotFound",
+      "ZeroRoot",
+      "NoRecordOfLastSubmittedProof",
+      "ProviderStakeNotFound",
+      "ZeroStake",
+      "StakeCouldNotBeConverted",
+      "ChallengesTickNotReached",
+      "ChallengesTickTooOld",
+      "ChallengesTickTooLate",
+      "SeedNotFound",
+      "CheckpointChallengesNotFound",
+      "ForestProofVerificationFailed",
+      "IncorrectNumberOfKeyProofs",
+      "KeyProofNotFound",
+      "KeyProofVerificationFailed",
+      "FailedToApplyDelta",
+      "UnexpectedNumberOfRemoveMutations",
+      "FailedToUpdateProviderAfterKeyRemoval",
+      "TooManyValidProofSubmitters"
+    ]
+  },
+  /**
+   * Lookup366: pallet_payment_streams::types::FixedRatePaymentStream<T>
+   **/
+  PalletPaymentStreamsFixedRatePaymentStream: {
+    rate: "u128",
+    lastChargedTick: "u32",
+    userDeposit: "u128",
+    outOfFundsTick: "Option<u32>"
+  },
+  /**
+   * Lookup367: pallet_payment_streams::types::DynamicRatePaymentStream<T>
+   **/
+  PalletPaymentStreamsDynamicRatePaymentStream: {
+    amountProvided: "u64",
+    priceIndexWhenLastCharged: "u128",
+    userDeposit: "u128",
+    outOfFundsTick: "Option<u32>"
+  },
+  /**
+   * Lookup368: pallet_payment_streams::types::ProviderLastChargeableInfo<T>
+   **/
+  PalletPaymentStreamsProviderLastChargeableInfo: {
+    lastChargeableTick: "u32",
+    priceIndex: "u128"
+  },
+  /**
+   * Lookup369: pallet_payment_streams::pallet::Error<T>
+   **/
+  PalletPaymentStreamsError: {
+    _enum: [
+      "PaymentStreamAlreadyExists",
+      "PaymentStreamNotFound",
+      "NotAProvider",
+      "ProviderInconsistencyError",
+      "CannotHoldDeposit",
+      "UpdateRateToSameRate",
+      "UpdateAmountToSameAmount",
+      "RateCantBeZero",
+      "AmountProvidedCantBeZero",
+      "LastChargedGreaterThanLastChargeable",
+      "InvalidLastChargeableBlockNumber",
+      "InvalidLastChargeablePriceIndex",
+      "ChargeOverflow",
+      "UserWithoutFunds",
+      "UserNotFlaggedAsWithoutFunds",
+      "CooldownPeriodNotPassed",
+      "UserHasRemainingDebt",
+      "ProviderInsolvent"
+    ]
+  },
+  /**
+   * Lookup370: pallet_bucket_nfts::pallet::Error<T>
+   **/
+  PalletBucketNftsError: {
+    _enum: [
+      "BucketIsNotPrivate",
+      "NotBucketOwner",
+      "NoCorrespondingCollection",
+      "ConvertBytesToBoundedVec"
+    ]
+  },
+  /**
+   * Lookup371: pallet_nfts::types::CollectionDetails<fp_account::AccountId20, DepositBalance>
+   **/
+  PalletNftsCollectionDetails: {
+    owner: "AccountId20",
+    ownerDeposit: "u128",
+    items: "u32",
+    itemMetadatas: "u32",
+    itemConfigs: "u32",
+    attributes: "u32"
+  },
+  /**
+   * Lookup376: pallet_nfts::types::CollectionRole
+   **/
+  PalletNftsCollectionRole: {
+    _enum: ["__Unused0", "Issuer", "Freezer", "__Unused3", "Admin"]
+  },
+  /**
+   * Lookup377: pallet_nfts::types::ItemDetails<fp_account::AccountId20, pallet_nfts::types::ItemDeposit<DepositBalance, fp_account::AccountId20>, bounded_collections::bounded_btree_map::BoundedBTreeMap<fp_account::AccountId20, Option<T>, S>>
+   **/
+  PalletNftsItemDetails: {
+    owner: "AccountId20",
+    approvals: "BTreeMap<AccountId20, Option<u32>>",
+    deposit: "PalletNftsItemDeposit"
+  },
+  /**
+   * Lookup378: pallet_nfts::types::ItemDeposit<DepositBalance, fp_account::AccountId20>
+   **/
+  PalletNftsItemDeposit: {
+    account: "AccountId20",
+    amount: "u128"
+  },
+  /**
+   * Lookup383: pallet_nfts::types::CollectionMetadata<Deposit, StringLimit>
+   **/
+  PalletNftsCollectionMetadata: {
+    deposit: "u128",
+    data: "Bytes"
+  },
+  /**
+   * Lookup384: pallet_nfts::types::ItemMetadata<pallet_nfts::types::ItemMetadataDeposit<DepositBalance, fp_account::AccountId20>, StringLimit>
+   **/
+  PalletNftsItemMetadata: {
+    deposit: "PalletNftsItemMetadataDeposit",
+    data: "Bytes"
+  },
+  /**
+   * Lookup385: pallet_nfts::types::ItemMetadataDeposit<DepositBalance, fp_account::AccountId20>
+   **/
+  PalletNftsItemMetadataDeposit: {
+    account: "Option<AccountId20>",
+    amount: "u128"
+  },
+  /**
+   * Lookup388: pallet_nfts::types::AttributeDeposit<DepositBalance, fp_account::AccountId20>
+   **/
+  PalletNftsAttributeDeposit: {
+    account: "Option<AccountId20>",
+    amount: "u128"
+  },
+  /**
+   * Lookup392: pallet_nfts::types::PendingSwap<CollectionId, ItemId, pallet_nfts::types::PriceWithDirection<Amount>, Deadline>
+   **/
+  PalletNftsPendingSwap: {
+    desiredCollection: "u32",
+    desiredItem: "Option<u32>",
+    price: "Option<PalletNftsPriceWithDirection>",
+    deadline: "u32"
+  },
+  /**
+   * Lookup394: pallet_nfts::types::PalletFeature
+   **/
+  PalletNftsPalletFeature: {
+    _enum: [
+      "__Unused0",
+      "Trading",
+      "Attributes",
+      "__Unused3",
+      "Approvals",
+      "__Unused5",
+      "__Unused6",
+      "__Unused7",
+      "Swaps"
+    ]
+  },
+  /**
+   * Lookup395: pallet_nfts::pallet::Error<T, I>
+   **/
+  PalletNftsError: {
+    _enum: [
+      "NoPermission",
+      "UnknownCollection",
+      "AlreadyExists",
+      "ApprovalExpired",
+      "WrongOwner",
+      "BadWitness",
+      "CollectionIdInUse",
+      "ItemsNonTransferable",
+      "NotDelegate",
+      "WrongDelegate",
+      "Unapproved",
+      "Unaccepted",
+      "ItemLocked",
+      "LockedItemAttributes",
+      "LockedCollectionAttributes",
+      "LockedItemMetadata",
+      "LockedCollectionMetadata",
+      "MaxSupplyReached",
+      "MaxSupplyLocked",
+      "MaxSupplyTooSmall",
+      "UnknownItem",
+      "UnknownSwap",
+      "MetadataNotFound",
+      "AttributeNotFound",
+      "NotForSale",
+      "BidTooLow",
+      "ReachedApprovalLimit",
+      "DeadlineExpired",
+      "WrongDuration",
+      "MethodDisabled",
+      "WrongSetting",
+      "InconsistentItemConfig",
+      "NoConfig",
+      "RolesNotCleared",
+      "MintNotStarted",
+      "MintEnded",
+      "AlreadyClaimed",
+      "IncorrectData",
+      "WrongOrigin",
+      "WrongSignature",
+      "IncorrectMetadata",
+      "MaxAttributesLimitReached",
+      "WrongNamespace",
+      "CollectionNotEmpty",
+      "WitnessRequired"
+    ]
+  },
+  /**
+   * Lookup398: frame_system::extensions::check_non_zero_sender::CheckNonZeroSender<T>
+   **/
+  FrameSystemExtensionsCheckNonZeroSender: "Null",
+  /**
+   * Lookup399: frame_system::extensions::check_spec_version::CheckSpecVersion<T>
+   **/
+  FrameSystemExtensionsCheckSpecVersion: "Null",
+  /**
+   * Lookup400: frame_system::extensions::check_tx_version::CheckTxVersion<T>
+   **/
+  FrameSystemExtensionsCheckTxVersion: "Null",
+  /**
+   * Lookup401: frame_system::extensions::check_genesis::CheckGenesis<T>
+   **/
+  FrameSystemExtensionsCheckGenesis: "Null",
+  /**
+   * Lookup404: frame_system::extensions::check_nonce::CheckNonce<T>
+   **/
+  FrameSystemExtensionsCheckNonce: "Compact<u32>",
+  /**
+   * Lookup405: frame_system::extensions::check_weight::CheckWeight<T>
+   **/
+  FrameSystemExtensionsCheckWeight: "Null",
+  /**
+   * Lookup406: pallet_transaction_payment::ChargeTransactionPayment<T>
+   **/
+  PalletTransactionPaymentChargeTransactionPayment: "Compact<u128>",
+  /**
+   * Lookup407: frame_metadata_hash_extension::CheckMetadataHash<T>
+   **/
+  FrameMetadataHashExtensionCheckMetadataHash: {
+    mode: "FrameMetadataHashExtensionMode"
+  },
+  /**
+   * Lookup408: frame_metadata_hash_extension::Mode
+   **/
+  FrameMetadataHashExtensionMode: {
+    _enum: ["Disabled", "Enabled"]
+  },
+  /**
+   * Lookup410: sh_solochain_evm_runtime::Runtime
+   **/
+  ShSolochainEvmRuntimeRuntime: "Null"
+};