@dedot/chaintypes 0.0.1-next.f5bf4fc2.1 → 0.1.0

package/astar/errors.d.ts

@@ -1,8 +1,8 @@
-// Generated by @dedot/codegen
+// Generated by dedot cli
 
-import type { GenericChainErrors, GenericPalletError } from '@dedot/types';
+import type { GenericChainErrors, GenericPalletError, RpcVersion } from 'dedot/types';
 
-export interface ChainErrors extends GenericChainErrors {
+export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<Rv> {
   /**
    * Pallet `System`'s errors
    **/
@@ -11,40 +11,40 @@ export interface ChainErrors extends GenericChainErrors {
      * The name of specification does not match between the current runtime
      * and the new runtime.
      **/
-    InvalidSpecName: GenericPalletError;
+    InvalidSpecName: GenericPalletError<Rv>;
 
     /**
      * The specification version is not allowed to decrease between the current runtime
      * and the new runtime.
      **/
-    SpecVersionNeedsToIncrease: GenericPalletError;
+    SpecVersionNeedsToIncrease: GenericPalletError<Rv>;
 
     /**
      * Failed to extract the runtime version from the new runtime.
      *
      * Either calling `Core_version` or decoding `RuntimeVersion` failed.
      **/
-    FailedToExtractRuntimeVersion: GenericPalletError;
+    FailedToExtractRuntimeVersion: GenericPalletError<Rv>;
 
     /**
      * Suicide called when the account has non-default composite data.
      **/
-    NonDefaultComposite: GenericPalletError;
+    NonDefaultComposite: GenericPalletError<Rv>;
 
     /**
      * There is a non-zero reference count preventing the account from being purged.
      **/
-    NonZeroRefCount: GenericPalletError;
+    NonZeroRefCount: GenericPalletError<Rv>;
 
     /**
      * The origin filter prevent the call to be dispatched.
      **/
-    CallFiltered: GenericPalletError;
+    CallFiltered: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Utility`'s errors
@@ -53,12 +53,12 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Too many calls batched.
      **/
-    TooManyCalls: GenericPalletError;
+    TooManyCalls: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Identity`'s errors
@@ -67,97 +67,97 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Too many subs-accounts.
      **/
-    TooManySubAccounts: GenericPalletError;
+    TooManySubAccounts: GenericPalletError<Rv>;
 
     /**
      * Account isn't found.
      **/
-    NotFound: GenericPalletError;
+    NotFound: GenericPalletError<Rv>;
 
     /**
      * Account isn't named.
      **/
-    NotNamed: GenericPalletError;
+    NotNamed: GenericPalletError<Rv>;
 
     /**
      * Empty index.
      **/
-    EmptyIndex: GenericPalletError;
+    EmptyIndex: GenericPalletError<Rv>;
 
     /**
      * Fee is changed.
      **/
-    FeeChanged: GenericPalletError;
+    FeeChanged: GenericPalletError<Rv>;
 
     /**
      * No identity found.
      **/
-    NoIdentity: GenericPalletError;
+    NoIdentity: GenericPalletError<Rv>;
 
     /**
      * Sticky judgement.
      **/
-    StickyJudgement: GenericPalletError;
+    StickyJudgement: GenericPalletError<Rv>;
 
     /**
      * Judgement given.
      **/
-    JudgementGiven: GenericPalletError;
+    JudgementGiven: GenericPalletError<Rv>;
 
     /**
      * Invalid judgement.
      **/
-    InvalidJudgement: GenericPalletError;
+    InvalidJudgement: GenericPalletError<Rv>;
 
     /**
      * The index is invalid.
      **/
-    InvalidIndex: GenericPalletError;
+    InvalidIndex: GenericPalletError<Rv>;
 
     /**
      * The target is invalid.
      **/
-    InvalidTarget: GenericPalletError;
+    InvalidTarget: GenericPalletError<Rv>;
 
     /**
      * Too many additional fields.
      **/
-    TooManyFields: GenericPalletError;
+    TooManyFields: GenericPalletError<Rv>;
 
     /**
      * Maximum amount of registrars reached. Cannot add any more.
      **/
-    TooManyRegistrars: GenericPalletError;
+    TooManyRegistrars: GenericPalletError<Rv>;
 
     /**
      * Account ID is already named.
      **/
-    AlreadyClaimed: GenericPalletError;
+    AlreadyClaimed: GenericPalletError<Rv>;
 
     /**
      * Sender is not a sub-account.
      **/
-    NotSub: GenericPalletError;
+    NotSub: GenericPalletError<Rv>;
 
     /**
      * Sub-account isn't owned by sender.
      **/
-    NotOwned: GenericPalletError;
+    NotOwned: GenericPalletError<Rv>;
 
     /**
      * The provided judgement was for a different identity.
      **/
-    JudgementForDifferentIdentity: GenericPalletError;
+    JudgementForDifferentIdentity: GenericPalletError<Rv>;
 
     /**
      * Error that occurs when there is an issue paying for judgement.
      **/
-    JudgementPaymentFailed: GenericPalletError;
+    JudgementPaymentFailed: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Multisig`'s errors
@@ -166,77 +166,77 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Threshold must be 2 or greater.
      **/
-    MinimumThreshold: GenericPalletError;
+    MinimumThreshold: GenericPalletError<Rv>;
 
     /**
      * Call is already approved by this signatory.
      **/
-    AlreadyApproved: GenericPalletError;
+    AlreadyApproved: GenericPalletError<Rv>;
 
     /**
      * Call doesn't need any (more) approvals.
      **/
-    NoApprovalsNeeded: GenericPalletError;
+    NoApprovalsNeeded: GenericPalletError<Rv>;
 
     /**
      * There are too few signatories in the list.
      **/
-    TooFewSignatories: GenericPalletError;
+    TooFewSignatories: GenericPalletError<Rv>;
 
     /**
      * There are too many signatories in the list.
      **/
-    TooManySignatories: GenericPalletError;
+    TooManySignatories: GenericPalletError<Rv>;
 
     /**
      * The signatories were provided out of order; they should be ordered.
      **/
-    SignatoriesOutOfOrder: GenericPalletError;
+    SignatoriesOutOfOrder: GenericPalletError<Rv>;
 
     /**
      * The sender was contained in the other signatories; it shouldn't be.
      **/
-    SenderInSignatories: GenericPalletError;
+    SenderInSignatories: GenericPalletError<Rv>;
 
     /**
      * Multisig operation not found when attempting to cancel.
      **/
-    NotFound: GenericPalletError;
+    NotFound: GenericPalletError<Rv>;
 
     /**
      * Only the account that originally created the multisig is able to cancel it.
      **/
-    NotOwner: GenericPalletError;
+    NotOwner: GenericPalletError<Rv>;
 
     /**
      * No timepoint was given, yet the multisig operation is already underway.
      **/
-    NoTimepoint: GenericPalletError;
+    NoTimepoint: GenericPalletError<Rv>;
 
     /**
      * A different timepoint was given to the multisig operation that is underway.
      **/
-    WrongTimepoint: GenericPalletError;
+    WrongTimepoint: GenericPalletError<Rv>;
 
     /**
      * A timepoint was given, yet no multisig operation is underway.
      **/
-    UnexpectedTimepoint: GenericPalletError;
+    UnexpectedTimepoint: GenericPalletError<Rv>;
 
     /**
      * The maximum weight information provided was too low.
      **/
-    MaxWeightTooLow: GenericPalletError;
+    MaxWeightTooLow: GenericPalletError<Rv>;
 
     /**
      * The data to be stored is already stored.
      **/
-    AlreadyStored: GenericPalletError;
+    AlreadyStored: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Proxy`'s errors
@@ -245,47 +245,47 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * There are too many proxies registered or too many announcements pending.
      **/
-    TooMany: GenericPalletError;
+    TooMany: GenericPalletError<Rv>;
 
     /**
      * Proxy registration not found.
      **/
-    NotFound: GenericPalletError;
+    NotFound: GenericPalletError<Rv>;
 
     /**
      * Sender is not a proxy of the account to be proxied.
      **/
-    NotProxy: GenericPalletError;
+    NotProxy: GenericPalletError<Rv>;
 
     /**
      * A call which is incompatible with the proxy type's filter was attempted.
      **/
-    Unproxyable: GenericPalletError;
+    Unproxyable: GenericPalletError<Rv>;
 
     /**
      * Account is already a proxy.
      **/
-    Duplicate: GenericPalletError;
+    Duplicate: GenericPalletError<Rv>;
 
     /**
      * Call may not be made by proxy because it may escalate its privileges.
      **/
-    NoPermission: GenericPalletError;
+    NoPermission: GenericPalletError<Rv>;
 
     /**
      * Announcement, if made at all, was made too recently.
      **/
-    Unannounced: GenericPalletError;
+    Unannounced: GenericPalletError<Rv>;
 
     /**
      * Cannot add self as proxy.
      **/
-    NoSelfProxy: GenericPalletError;
+    NoSelfProxy: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `ParachainSystem`'s errors
@@ -294,48 +294,48 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Attempt to upgrade validation function while existing upgrade pending.
      **/
-    OverlappingUpgrades: GenericPalletError;
+    OverlappingUpgrades: GenericPalletError<Rv>;
 
     /**
      * Polkadot currently prohibits this parachain from upgrading its validation function.
      **/
-    ProhibitedByPolkadot: GenericPalletError;
+    ProhibitedByPolkadot: GenericPalletError<Rv>;
 
     /**
      * The supplied validation function has compiled into a blob larger than Polkadot is
      * willing to run.
      **/
-    TooBig: GenericPalletError;
+    TooBig: GenericPalletError<Rv>;
 
     /**
      * The inherent which supplies the validation data did not run this block.
      **/
-    ValidationDataNotAvailable: GenericPalletError;
+    ValidationDataNotAvailable: GenericPalletError<Rv>;
 
     /**
      * The inherent which supplies the host configuration did not run this block.
      **/
-    HostConfigurationNotAvailable: GenericPalletError;
+    HostConfigurationNotAvailable: GenericPalletError<Rv>;
 
     /**
      * No validation function upgrade is currently scheduled.
      **/
-    NotScheduled: GenericPalletError;
+    NotScheduled: GenericPalletError<Rv>;
 
     /**
      * No code upgrade has been authorized.
      **/
-    NothingAuthorized: GenericPalletError;
+    NothingAuthorized: GenericPalletError<Rv>;
 
     /**
      * The given code upgrade has not been authorized.
      **/
-    Unauthorized: GenericPalletError;
+    Unauthorized: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Balances`'s errors
@@ -344,57 +344,57 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Vesting balance too high to send value.
      **/
-    VestingBalance: GenericPalletError;
+    VestingBalance: GenericPalletError<Rv>;
 
     /**
      * Account liquidity restrictions prevent withdrawal.
      **/
-    LiquidityRestrictions: GenericPalletError;
+    LiquidityRestrictions: GenericPalletError<Rv>;
 
     /**
      * Balance too low to send value.
      **/
-    InsufficientBalance: GenericPalletError;
+    InsufficientBalance: GenericPalletError<Rv>;
 
     /**
      * Value too low to create account due to existential deposit.
      **/
-    ExistentialDeposit: GenericPalletError;
+    ExistentialDeposit: GenericPalletError<Rv>;
 
     /**
      * Transfer/payment would kill account.
      **/
-    Expendability: GenericPalletError;
+    Expendability: GenericPalletError<Rv>;
 
     /**
      * A vesting schedule already exists for this account.
      **/
-    ExistingVestingSchedule: GenericPalletError;
+    ExistingVestingSchedule: GenericPalletError<Rv>;
 
     /**
      * Beneficiary account must pre-exist.
      **/
-    DeadAccount: GenericPalletError;
+    DeadAccount: GenericPalletError<Rv>;
 
     /**
      * Number of named reserves exceed `MaxReserves`.
      **/
-    TooManyReserves: GenericPalletError;
+    TooManyReserves: GenericPalletError<Rv>;
 
     /**
      * Number of holds exceed `MaxHolds`.
      **/
-    TooManyHolds: GenericPalletError;
+    TooManyHolds: GenericPalletError<Rv>;
 
     /**
      * Number of freezes exceed `MaxFreezes`.
      **/
-    TooManyFreezes: GenericPalletError;
+    TooManyFreezes: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Vesting`'s errors
@@ -403,33 +403,33 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The account given is not vesting.
      **/
-    NotVesting: GenericPalletError;
+    NotVesting: GenericPalletError<Rv>;
 
     /**
      * The account already has `MaxVestingSchedules` count of schedules and thus
      * cannot add another one. Consider merging existing schedules in order to add another.
      **/
-    AtMaxVestingSchedules: GenericPalletError;
+    AtMaxVestingSchedules: GenericPalletError<Rv>;
 
     /**
      * Amount being transferred is too low to create a vesting schedule.
      **/
-    AmountLow: GenericPalletError;
+    AmountLow: GenericPalletError<Rv>;
 
     /**
      * An index was out of bounds of the vesting schedules.
      **/
-    ScheduleIndexOutOfBounds: GenericPalletError;
+    ScheduleIndexOutOfBounds: GenericPalletError<Rv>;
 
     /**
      * Failed to create a new schedule because some parameter was invalid.
      **/
-    InvalidScheduleParams: GenericPalletError;
+    InvalidScheduleParams: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Inflation`'s errors
@@ -438,12 +438,12 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Sum of all parts must be one whole (100%).
      **/
-    InvalidInflationParameters: GenericPalletError;
+    InvalidInflationParameters: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `DappStaking`'s errors
@@ -452,184 +452,189 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Pallet is disabled/in maintenance mode.
      **/
-    Disabled: GenericPalletError;
+    Disabled: GenericPalletError<Rv>;
 
     /**
      * Smart contract already exists within dApp staking protocol.
      **/
-    ContractAlreadyExists: GenericPalletError;
+    ContractAlreadyExists: GenericPalletError<Rv>;
 
     /**
      * Maximum number of smart contracts has been reached.
      **/
-    ExceededMaxNumberOfContracts: GenericPalletError;
+    ExceededMaxNumberOfContracts: GenericPalletError<Rv>;
 
     /**
      * Not possible to assign a new dApp Id.
      * This should never happen since current type can support up to 65536 - 1 unique dApps.
      **/
-    NewDAppIdUnavailable: GenericPalletError;
+    NewDAppIdUnavailable: GenericPalletError<Rv>;
 
     /**
      * Specified smart contract does not exist in dApp staking.
      **/
-    ContractNotFound: GenericPalletError;
+    ContractNotFound: GenericPalletError<Rv>;
 
     /**
      * Call origin is not dApp owner.
      **/
-    OriginNotOwner: GenericPalletError;
+    OriginNotOwner: GenericPalletError<Rv>;
 
     /**
      * Performing locking or staking with 0 amount.
      **/
-    ZeroAmount: GenericPalletError;
+    ZeroAmount: GenericPalletError<Rv>;
 
     /**
      * Total locked amount for staker is below minimum threshold.
      **/
-    LockedAmountBelowThreshold: GenericPalletError;
+    LockedAmountBelowThreshold: GenericPalletError<Rv>;
 
     /**
      * Account is not allowed to participate in dApp staking due to some external reason (e.g. account is already a collator).
      **/
-    AccountNotAvailableForDappStaking: GenericPalletError;
+    AccountNotAvailableForDappStaking: GenericPalletError<Rv>;
 
     /**
      * Cannot add additional unlocking chunks due to capacity limit.
      **/
-    TooManyUnlockingChunks: GenericPalletError;
+    TooManyUnlockingChunks: GenericPalletError<Rv>;
 
     /**
      * Remaining stake prevents entire balance of starting the unlocking process.
      **/
-    RemainingStakePreventsFullUnlock: GenericPalletError;
+    RemainingStakePreventsFullUnlock: GenericPalletError<Rv>;
 
     /**
      * There are no eligible unlocked chunks to claim. This can happen either if no eligible chunks exist, or if user has no chunks at all.
      **/
-    NoUnlockedChunksToClaim: GenericPalletError;
+    NoUnlockedChunksToClaim: GenericPalletError<Rv>;
 
     /**
      * There are no unlocking chunks available to relock.
      **/
-    NoUnlockingChunks: GenericPalletError;
+    NoUnlockingChunks: GenericPalletError<Rv>;
 
     /**
      * The amount being staked is too large compared to what's available for staking.
      **/
-    UnavailableStakeFunds: GenericPalletError;
+    UnavailableStakeFunds: GenericPalletError<Rv>;
 
     /**
      * There are unclaimed rewards remaining from past eras or periods. They should be claimed before attempting any stake modification again.
      **/
-    UnclaimedRewards: GenericPalletError;
+    UnclaimedRewards: GenericPalletError<Rv>;
 
     /**
      * An unexpected error occurred while trying to stake.
      **/
-    InternalStakeError: GenericPalletError;
+    InternalStakeError: GenericPalletError<Rv>;
 
     /**
      * Total staked amount on contract is below the minimum required value.
      **/
-    InsufficientStakeAmount: GenericPalletError;
+    InsufficientStakeAmount: GenericPalletError<Rv>;
 
     /**
      * Stake operation is rejected since period ends in the next era.
      **/
-    PeriodEndsInNextEra: GenericPalletError;
+    PeriodEndsInNextEra: GenericPalletError<Rv>;
 
     /**
      * Unstaking is rejected since the period in which past stake was active has passed.
      **/
-    UnstakeFromPastPeriod: GenericPalletError;
+    UnstakeFromPastPeriod: GenericPalletError<Rv>;
 
     /**
      * Unstake amount is greater than the staked amount.
      **/
-    UnstakeAmountTooLarge: GenericPalletError;
+    UnstakeAmountTooLarge: GenericPalletError<Rv>;
 
     /**
      * Account has no staking information for the contract.
      **/
-    NoStakingInfo: GenericPalletError;
+    NoStakingInfo: GenericPalletError<Rv>;
 
     /**
      * An unexpected error occurred while trying to unstake.
      **/
-    InternalUnstakeError: GenericPalletError;
+    InternalUnstakeError: GenericPalletError<Rv>;
 
     /**
      * Rewards are no longer claimable since they are too old.
      **/
-    RewardExpired: GenericPalletError;
+    RewardExpired: GenericPalletError<Rv>;
 
     /**
      * Reward payout has failed due to an unexpected reason.
      **/
-    RewardPayoutFailed: GenericPalletError;
+    RewardPayoutFailed: GenericPalletError<Rv>;
 
     /**
      * There are no claimable rewards.
      **/
-    NoClaimableRewards: GenericPalletError;
+    NoClaimableRewards: GenericPalletError<Rv>;
 
     /**
      * An unexpected error occurred while trying to claim staker rewards.
      **/
-    InternalClaimStakerError: GenericPalletError;
+    InternalClaimStakerError: GenericPalletError<Rv>;
 
     /**
      * Account is has no eligible stake amount for bonus reward.
      **/
-    NotEligibleForBonusReward: GenericPalletError;
+    NotEligibleForBonusReward: GenericPalletError<Rv>;
 
     /**
      * An unexpected error occurred while trying to claim bonus reward.
      **/
-    InternalClaimBonusError: GenericPalletError;
+    InternalClaimBonusError: GenericPalletError<Rv>;
 
     /**
      * Claim era is invalid - it must be in history, and rewards must exist for it.
      **/
-    InvalidClaimEra: GenericPalletError;
+    InvalidClaimEra: GenericPalletError<Rv>;
 
     /**
      * No dApp tier info exists for the specified era. This can be because era has expired
      * or because during the specified era there were no eligible rewards or protocol wasn't active.
      **/
-    NoDAppTierInfo: GenericPalletError;
+    NoDAppTierInfo: GenericPalletError<Rv>;
 
     /**
      * An unexpected error occurred while trying to claim dApp reward.
      **/
-    InternalClaimDAppError: GenericPalletError;
+    InternalClaimDAppError: GenericPalletError<Rv>;
 
     /**
      * Contract is still active, not unregistered.
      **/
-    ContractStillActive: GenericPalletError;
+    ContractStillActive: GenericPalletError<Rv>;
 
     /**
      * There are too many contract stake entries for the account. This can be cleaned up by either unstaking or cleaning expired entries.
      **/
-    TooManyStakedContracts: GenericPalletError;
+    TooManyStakedContracts: GenericPalletError<Rv>;
 
     /**
      * There are no expired entries to cleanup for the account.
      **/
-    NoExpiredEntries: GenericPalletError;
+    NoExpiredEntries: GenericPalletError<Rv>;
 
     /**
      * Force call is not allowed in production.
      **/
-    ForceNotAllowed: GenericPalletError;
+    ForceNotAllowed: GenericPalletError<Rv>;
+
+    /**
+     * Account doesn't have the freeze inconsistency
+     **/
+    AccountNotInconsistent: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Assets`'s errors
@@ -638,110 +643,153 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Account balance must be greater than or equal to the transfer amount.
      **/
-    BalanceLow: GenericPalletError;
+    BalanceLow: GenericPalletError<Rv>;
 
     /**
      * The account to alter does not exist.
      **/
-    NoAccount: GenericPalletError;
+    NoAccount: GenericPalletError<Rv>;
 
     /**
      * The signing account has no permission to do the operation.
      **/
-    NoPermission: GenericPalletError;
+    NoPermission: GenericPalletError<Rv>;
 
     /**
      * The given asset ID is unknown.
      **/
-    Unknown: GenericPalletError;
+    Unknown: GenericPalletError<Rv>;
 
     /**
      * The origin account is frozen.
      **/
-    Frozen: GenericPalletError;
+    Frozen: GenericPalletError<Rv>;
 
     /**
      * The asset ID is already taken.
      **/
-    InUse: GenericPalletError;
+    InUse: GenericPalletError<Rv>;
 
     /**
      * Invalid witness data given.
      **/
-    BadWitness: GenericPalletError;
+    BadWitness: GenericPalletError<Rv>;
 
     /**
      * Minimum balance should be non-zero.
      **/
-    MinBalanceZero: GenericPalletError;
+    MinBalanceZero: GenericPalletError<Rv>;
 
     /**
      * Unable to increment the consumer reference counters on the account. Either no provider
      * reference exists to allow a non-zero balance of a non-self-sufficient asset, or one
      * fewer then the maximum number of consumers has been reached.
      **/
-    UnavailableConsumer: GenericPalletError;
+    UnavailableConsumer: GenericPalletError<Rv>;
 
     /**
      * Invalid metadata given.
      **/
-    BadMetadata: GenericPalletError;
+    BadMetadata: GenericPalletError<Rv>;
 
     /**
      * No approval exists that would allow the transfer.
      **/
-    Unapproved: GenericPalletError;
+    Unapproved: GenericPalletError<Rv>;
 
     /**
      * The source account would not survive the transfer and it needs to stay alive.
      **/
-    WouldDie: GenericPalletError;
+    WouldDie: GenericPalletError<Rv>;
 
     /**
      * The asset-account already exists.
      **/
-    AlreadyExists: GenericPalletError;
+    AlreadyExists: GenericPalletError<Rv>;
 
     /**
      * The asset-account doesn't have an associated deposit.
      **/
-    NoDeposit: GenericPalletError;
+    NoDeposit: GenericPalletError<Rv>;
 
     /**
      * The operation would result in funds being burned.
      **/
-    WouldBurn: GenericPalletError;
+    WouldBurn: GenericPalletError<Rv>;
 
     /**
      * The asset is a live asset and is actively being used. Usually emit for operations such
      * as `start_destroy` which require the asset to be in a destroying state.
      **/
-    LiveAsset: GenericPalletError;
+    LiveAsset: GenericPalletError<Rv>;
 
     /**
      * The asset is not live, and likely being destroyed.
      **/
-    AssetNotLive: GenericPalletError;
+    AssetNotLive: GenericPalletError<Rv>;
 
     /**
      * The asset status is not the expected status.
      **/
-    IncorrectStatus: GenericPalletError;
+    IncorrectStatus: GenericPalletError<Rv>;
 
     /**
      * The asset should be frozen before the given operation.
      **/
-    NotFrozen: GenericPalletError;
+    NotFrozen: GenericPalletError<Rv>;
 
     /**
      * Callback action resulted in error
      **/
-    CallbackFailed: GenericPalletError;
+    CallbackFailed: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
+  };
+  /**
+   * Pallet `Oracle`'s errors
+   **/
+  oracle: {
+    /**
+     * Sender does not have permission
+     **/
+    NoPermission: GenericPalletError<Rv>;
+
+    /**
+     * Feeder has already feeded at this block
+     **/
+    AlreadyFeeded: GenericPalletError<Rv>;
+
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError<Rv>;
+  };
+  /**
+   * Pallet `OracleMembership`'s errors
+   **/
+  oracleMembership: {
+    /**
+     * Already a member.
+     **/
+    AlreadyMember: GenericPalletError<Rv>;
+
+    /**
+     * Not a member.
+     **/
+    NotMember: GenericPalletError<Rv>;
+
+    /**
+     * Too many members.
+     **/
+    TooManyMembers: GenericPalletError<Rv>;
+
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `CollatorSelection`'s errors
@@ -750,57 +798,57 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Too many candidates
      **/
-    TooManyCandidates: GenericPalletError;
+    TooManyCandidates: GenericPalletError<Rv>;
 
     /**
      * Too few candidates
      **/
-    TooFewCandidates: GenericPalletError;
+    TooFewCandidates: GenericPalletError<Rv>;
 
     /**
      * Unknown error
      **/
-    Unknown: GenericPalletError;
+    Unknown: GenericPalletError<Rv>;
 
     /**
      * Permission issue
      **/
-    Permission: GenericPalletError;
+    Permission: GenericPalletError<Rv>;
 
     /**
      * User is already a candidate
      **/
-    AlreadyCandidate: GenericPalletError;
+    AlreadyCandidate: GenericPalletError<Rv>;
 
     /**
      * User is not a candidate
      **/
-    NotCandidate: GenericPalletError;
+    NotCandidate: GenericPalletError<Rv>;
 
     /**
      * User is already an Invulnerable
      **/
-    AlreadyInvulnerable: GenericPalletError;
+    AlreadyInvulnerable: GenericPalletError<Rv>;
 
     /**
      * Account has no associated validator ID
      **/
-    NoAssociatedValidatorId: GenericPalletError;
+    NoAssociatedValidatorId: GenericPalletError<Rv>;
 
     /**
      * Validator ID is not yet registered
      **/
-    ValidatorNotRegistered: GenericPalletError;
+    ValidatorNotRegistered: GenericPalletError<Rv>;
 
     /**
      * Account is now allowed to be a candidate due to an external reason (e.g. it might be participating in dApp staking)
      **/
-    NotAllowedCandidate: GenericPalletError;
+    NotAllowedCandidate: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Session`'s errors
@@ -809,32 +857,32 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Invalid ownership proof.
      **/
-    InvalidProof: GenericPalletError;
+    InvalidProof: GenericPalletError<Rv>;
 
     /**
      * No associated validator ID for account.
      **/
-    NoAssociatedValidatorId: GenericPalletError;
+    NoAssociatedValidatorId: GenericPalletError<Rv>;
 
     /**
      * Registered duplicate key.
      **/
-    DuplicatedKey: GenericPalletError;
+    DuplicatedKey: GenericPalletError<Rv>;
 
     /**
      * No keys are associated with this account.
      **/
-    NoKeys: GenericPalletError;
+    NoKeys: GenericPalletError<Rv>;
 
     /**
      * Key setting account is not live, so it's impossible to associate keys.
      **/
-    NoAccount: GenericPalletError;
+    NoAccount: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `XcmpQueue`'s errors
@@ -843,32 +891,32 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Failed to send XCM message.
      **/
-    FailedToSend: GenericPalletError;
+    FailedToSend: GenericPalletError<Rv>;
 
     /**
      * Bad XCM origin.
      **/
-    BadXcmOrigin: GenericPalletError;
+    BadXcmOrigin: GenericPalletError<Rv>;
 
     /**
      * Bad XCM data.
      **/
-    BadXcm: GenericPalletError;
+    BadXcm: GenericPalletError<Rv>;
 
     /**
      * Bad overweight index.
      **/
-    BadOverweightIndex: GenericPalletError;
+    BadOverweightIndex: GenericPalletError<Rv>;
 
     /**
      * Provided weight is possibly not enough to execute the message.
      **/
-    WeightOverLimit: GenericPalletError;
+    WeightOverLimit: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `PolkadotXcm`'s errors
@@ -878,109 +926,109 @@ export interface ChainErrors extends GenericChainErrors {
      * The desired destination was unreachable, generally because there is a no way of routing
      * to it.
      **/
-    Unreachable: GenericPalletError;
+    Unreachable: GenericPalletError<Rv>;
 
     /**
-     * There was some other issue (i.e. not to do with routing) in sending the message. Perhaps
-     * a lack of space for buffering the message.
+     * There was some other issue (i.e. not to do with routing) in sending the message.
+     * Perhaps a lack of space for buffering the message.
      **/
-    SendFailure: GenericPalletError;
+    SendFailure: GenericPalletError<Rv>;
 
     /**
      * The message execution fails the filter.
      **/
-    Filtered: GenericPalletError;
+    Filtered: GenericPalletError<Rv>;
 
     /**
      * The message's weight could not be determined.
      **/
-    UnweighableMessage: GenericPalletError;
+    UnweighableMessage: GenericPalletError<Rv>;
 
     /**
      * The destination `MultiLocation` provided cannot be inverted.
      **/
-    DestinationNotInvertible: GenericPalletError;
+    DestinationNotInvertible: GenericPalletError<Rv>;
 
     /**
      * The assets to be sent are empty.
      **/
-    Empty: GenericPalletError;
+    Empty: GenericPalletError<Rv>;
 
     /**
      * Could not re-anchor the assets to declare the fees for the destination chain.
      **/
-    CannotReanchor: GenericPalletError;
+    CannotReanchor: GenericPalletError<Rv>;
 
     /**
      * Too many assets have been attempted for transfer.
      **/
-    TooManyAssets: GenericPalletError;
+    TooManyAssets: GenericPalletError<Rv>;
 
     /**
      * Origin is invalid for sending.
      **/
-    InvalidOrigin: GenericPalletError;
+    InvalidOrigin: GenericPalletError<Rv>;
 
     /**
      * The version of the `Versioned` value used is not able to be interpreted.
      **/
-    BadVersion: GenericPalletError;
+    BadVersion: GenericPalletError<Rv>;
 
     /**
      * The given location could not be used (e.g. because it cannot be expressed in the
      * desired version of XCM).
      **/
-    BadLocation: GenericPalletError;
+    BadLocation: GenericPalletError<Rv>;
 
     /**
      * The referenced subscription could not be found.
      **/
-    NoSubscription: GenericPalletError;
+    NoSubscription: GenericPalletError<Rv>;
 
     /**
      * The location is invalid since it already has a subscription from us.
      **/
-    AlreadySubscribed: GenericPalletError;
+    AlreadySubscribed: GenericPalletError<Rv>;
 
     /**
      * Invalid asset for the operation.
      **/
-    InvalidAsset: GenericPalletError;
+    InvalidAsset: GenericPalletError<Rv>;
 
     /**
      * The owner does not own (all) of the asset that they wish to do the operation on.
      **/
-    LowBalance: GenericPalletError;
+    LowBalance: GenericPalletError<Rv>;
 
     /**
      * The asset owner has too many locks on the asset.
      **/
-    TooManyLocks: GenericPalletError;
+    TooManyLocks: GenericPalletError<Rv>;
 
     /**
      * The given account is not an identifiable sovereign account for any location.
      **/
-    AccountNotSovereign: GenericPalletError;
+    AccountNotSovereign: GenericPalletError<Rv>;
 
     /**
      * The operation required fees to be paid which the initiator could not meet.
      **/
-    FeesNotMet: GenericPalletError;
+    FeesNotMet: GenericPalletError<Rv>;
 
     /**
      * A remote lock with the corresponding data could not be found.
      **/
-    LockNotFound: GenericPalletError;
+    LockNotFound: GenericPalletError<Rv>;
 
     /**
      * The unlock operation cannot succeed because there are still consumers of the lock.
      **/
-    InUse: GenericPalletError;
+    InUse: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `CumulusXcm`'s errors
@@ -989,7 +1037,7 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `DmpQueue`'s errors
@@ -998,17 +1046,17 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The message index given is unknown.
      **/
-    Unknown: GenericPalletError;
+    Unknown: GenericPalletError<Rv>;
 
     /**
      * The amount of weight given is possibly not enough for executing the message.
      **/
-    OverLimit: GenericPalletError;
+    OverLimit: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `XcAssetConfig`'s errors
@@ -1017,22 +1065,22 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Asset is already registered.
      **/
-    AssetAlreadyRegistered: GenericPalletError;
+    AssetAlreadyRegistered: GenericPalletError<Rv>;
 
     /**
      * Asset does not exist (hasn't been registered).
      **/
-    AssetDoesNotExist: GenericPalletError;
+    AssetDoesNotExist: GenericPalletError<Rv>;
 
     /**
      * Failed to convert to latest versioned MultiLocation
      **/
-    MultiLocationNotSupported: GenericPalletError;
+    MultiLocationNotSupported: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `XTokens`'s errors
@@ -1041,105 +1089,105 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Asset has no reserve location.
      **/
-    AssetHasNoReserve: GenericPalletError;
+    AssetHasNoReserve: GenericPalletError<Rv>;
 
     /**
      * Not cross-chain transfer.
      **/
-    NotCrossChainTransfer: GenericPalletError;
+    NotCrossChainTransfer: GenericPalletError<Rv>;
 
     /**
      * Invalid transfer destination.
      **/
-    InvalidDest: GenericPalletError;
+    InvalidDest: GenericPalletError<Rv>;
 
     /**
      * Currency is not cross-chain transferable.
      **/
-    NotCrossChainTransferableCurrency: GenericPalletError;
+    NotCrossChainTransferableCurrency: GenericPalletError<Rv>;
 
     /**
      * The message's weight could not be determined.
      **/
-    UnweighableMessage: GenericPalletError;
+    UnweighableMessage: GenericPalletError<Rv>;
 
     /**
      * XCM execution failed.
      **/
-    XcmExecutionFailed: GenericPalletError;
+    XcmExecutionFailed: GenericPalletError<Rv>;
 
     /**
      * Could not re-anchor the assets to declare the fees for the
      * destination chain.
      **/
-    CannotReanchor: GenericPalletError;
+    CannotReanchor: GenericPalletError<Rv>;
 
     /**
      * Could not get ancestry of asset reserve location.
      **/
-    InvalidAncestry: GenericPalletError;
+    InvalidAncestry: GenericPalletError<Rv>;
 
     /**
      * The MultiAsset is invalid.
      **/
-    InvalidAsset: GenericPalletError;
+    InvalidAsset: GenericPalletError<Rv>;
 
     /**
      * The destination `MultiLocation` provided cannot be inverted.
      **/
-    DestinationNotInvertible: GenericPalletError;
+    DestinationNotInvertible: GenericPalletError<Rv>;
 
     /**
      * The version of the `Versioned` value used is not able to be
      * interpreted.
      **/
-    BadVersion: GenericPalletError;
+    BadVersion: GenericPalletError<Rv>;
 
     /**
      * We tried sending distinct asset and fee but they have different
      * reserve chains.
      **/
-    DistinctReserveForAssetAndFee: GenericPalletError;
+    DistinctReserveForAssetAndFee: GenericPalletError<Rv>;
 
     /**
      * The fee is zero.
      **/
-    ZeroFee: GenericPalletError;
+    ZeroFee: GenericPalletError<Rv>;
 
     /**
      * The transfering asset amount is zero.
      **/
-    ZeroAmount: GenericPalletError;
+    ZeroAmount: GenericPalletError<Rv>;
 
     /**
      * The number of assets to be sent is over the maximum.
      **/
-    TooManyAssetsBeingSent: GenericPalletError;
+    TooManyAssetsBeingSent: GenericPalletError<Rv>;
 
     /**
      * The specified index does not exist in a MultiAssets struct.
      **/
-    AssetIndexNonExistent: GenericPalletError;
+    AssetIndexNonExistent: GenericPalletError<Rv>;
 
     /**
      * Fee is not enough.
      **/
-    FeeNotEnough: GenericPalletError;
+    FeeNotEnough: GenericPalletError<Rv>;
 
     /**
      * Not supported MultiLocation
      **/
-    NotSupportedMultiLocation: GenericPalletError;
+    NotSupportedMultiLocation: GenericPalletError<Rv>;
 
     /**
      * MinXcmFee not registered for certain reserve location
      **/
-    MinXcmFeeNotDefined: GenericPalletError;
+    MinXcmFeeNotDefined: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `EVM`'s errors
@@ -1148,62 +1196,72 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Not enough balance to perform action
      **/
-    BalanceLow: GenericPalletError;
+    BalanceLow: GenericPalletError<Rv>;
 
     /**
      * Calculating total fee overflowed
      **/
-    FeeOverflow: GenericPalletError;
+    FeeOverflow: GenericPalletError<Rv>;
 
     /**
      * Calculating total payment overflowed
      **/
-    PaymentOverflow: GenericPalletError;
+    PaymentOverflow: GenericPalletError<Rv>;
 
     /**
      * Withdraw fee failed
      **/
-    WithdrawFailed: GenericPalletError;
+    WithdrawFailed: GenericPalletError<Rv>;
 
     /**
      * Gas price is too low.
      **/
-    GasPriceTooLow: GenericPalletError;
+    GasPriceTooLow: GenericPalletError<Rv>;
 
     /**
      * Nonce is invalid
      **/
-    InvalidNonce: GenericPalletError;
+    InvalidNonce: GenericPalletError<Rv>;
 
     /**
      * Gas limit is too low.
      **/
-    GasLimitTooLow: GenericPalletError;
+    GasLimitTooLow: GenericPalletError<Rv>;
 
     /**
      * Gas limit is too high.
      **/
-    GasLimitTooHigh: GenericPalletError;
+    GasLimitTooHigh: GenericPalletError<Rv>;
 
     /**
-     * Undefined error.
+     * The chain id is invalid.
      **/
-    Undefined: GenericPalletError;
+    InvalidChainId: GenericPalletError<Rv>;
+
+    /**
+     * the signature is invalid.
+     **/
+    InvalidSignature: GenericPalletError<Rv>;
 
     /**
      * EVM reentrancy
      **/
-    Reentrancy: GenericPalletError;
+    Reentrancy: GenericPalletError<Rv>;
 
     /**
      * EIP-3607,
      **/
-    TransactionMustComeFromEOA: GenericPalletError;
+    TransactionMustComeFromEOA: GenericPalletError<Rv>;
+
+    /**
+     * Undefined error.
+     **/
+    Undefined: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Ethereum`'s errors
@@ -1212,17 +1270,17 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Signature is invalid.
      **/
-    InvalidSignature: GenericPalletError;
+    InvalidSignature: GenericPalletError<Rv>;
 
     /**
      * Pre-log is present, therefore transact is not allowed.
      **/
-    PreLogExists: GenericPalletError;
+    PreLogExists: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `DynamicEvmBaseFee`'s errors
@@ -1231,124 +1289,129 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Specified value is outside of the allowed range.
      **/
-    ValueOutOfBounds: GenericPalletError;
+    ValueOutOfBounds: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Contracts`'s errors
    **/
   contracts: {
     /**
-     * A new schedule must have a greater version than the current one.
+     * Invalid schedule supplied, e.g. with zero weight of a basic operation.
      **/
-    InvalidScheduleVersion: GenericPalletError;
+    InvalidSchedule: GenericPalletError<Rv>;
 
     /**
      * Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`.
      **/
-    InvalidCallFlags: GenericPalletError;
+    InvalidCallFlags: GenericPalletError<Rv>;
 
     /**
      * The executed contract exhausted its gas limit.
      **/
-    OutOfGas: GenericPalletError;
+    OutOfGas: GenericPalletError<Rv>;
 
     /**
      * The output buffer supplied to a contract API call was too small.
      **/
-    OutputBufferTooSmall: GenericPalletError;
+    OutputBufferTooSmall: GenericPalletError<Rv>;
 
     /**
      * Performing the requested transfer failed. Probably because there isn't enough
      * free balance in the sender's account.
      **/
-    TransferFailed: GenericPalletError;
+    TransferFailed: GenericPalletError<Rv>;
 
     /**
      * Performing a call was denied because the calling depth reached the limit
      * of what is specified in the schedule.
      **/
-    MaxCallDepthReached: GenericPalletError;
+    MaxCallDepthReached: GenericPalletError<Rv>;
 
     /**
      * No contract was found at the specified address.
      **/
-    ContractNotFound: GenericPalletError;
+    ContractNotFound: GenericPalletError<Rv>;
 
     /**
      * The code supplied to `instantiate_with_code` exceeds the limit specified in the
      * current schedule.
      **/
-    CodeTooLarge: GenericPalletError;
+    CodeTooLarge: GenericPalletError<Rv>;
 
     /**
      * No code could be found at the supplied code hash.
      **/
-    CodeNotFound: GenericPalletError;
+    CodeNotFound: GenericPalletError<Rv>;
+
+    /**
+     * No code info could be found at the supplied code hash.
+     **/
+    CodeInfoNotFound: GenericPalletError<Rv>;
 
     /**
      * A buffer outside of sandbox memory was passed to a contract API function.
      **/
-    OutOfBounds: GenericPalletError;
+    OutOfBounds: GenericPalletError<Rv>;
 
     /**
      * Input passed to a contract API function failed to decode as expected type.
      **/
-    DecodingFailed: GenericPalletError;
+    DecodingFailed: GenericPalletError<Rv>;
 
     /**
      * Contract trapped during execution.
      **/
-    ContractTrapped: GenericPalletError;
+    ContractTrapped: GenericPalletError<Rv>;
 
     /**
      * The size defined in `T::MaxValueSize` was exceeded.
      **/
-    ValueTooLarge: GenericPalletError;
+    ValueTooLarge: GenericPalletError<Rv>;
 
     /**
      * Termination of a contract is not allowed while the contract is already
      * on the call stack. Can be triggered by `seal_terminate`.
      **/
-    TerminatedWhileReentrant: GenericPalletError;
+    TerminatedWhileReentrant: GenericPalletError<Rv>;
 
     /**
      * `seal_call` forwarded this contracts input. It therefore is no longer available.
      **/
-    InputForwarded: GenericPalletError;
+    InputForwarded: GenericPalletError<Rv>;
 
     /**
      * The subject passed to `seal_random` exceeds the limit.
      **/
-    RandomSubjectTooLong: GenericPalletError;
+    RandomSubjectTooLong: GenericPalletError<Rv>;
 
     /**
      * The amount of topics passed to `seal_deposit_events` exceeds the limit.
      **/
-    TooManyTopics: GenericPalletError;
+    TooManyTopics: GenericPalletError<Rv>;
 
     /**
      * The chain does not provide a chain extension. Calling the chain extension results
      * in this error. Note that this usually shouldn't happen as deploying such contracts
      * is rejected.
      **/
-    NoChainExtension: GenericPalletError;
+    NoChainExtension: GenericPalletError<Rv>;
 
     /**
      * A contract with the same AccountId already exists.
      **/
-    DuplicateContract: GenericPalletError;
+    DuplicateContract: GenericPalletError<Rv>;
 
     /**
      * A contract self destructed in its constructor.
      *
      * This can be triggered by a call to `seal_terminate`.
      **/
-    TerminatedInConstructor: GenericPalletError;
+    TerminatedInConstructor: GenericPalletError<Rv>;
 
     /**
      * A call tried to invoke a contract that is flagged as non-reentrant.
@@ -1356,22 +1419,22 @@ export interface ChainErrors extends GenericChainErrors {
      * into `pallet-contracts`. This would make the whole pallet reentrant with regard to
      * contract code execution which is not supported.
      **/
-    ReentranceDenied: GenericPalletError;
+    ReentranceDenied: GenericPalletError<Rv>;
 
     /**
      * Origin doesn't have enough balance to pay the required storage deposits.
      **/
-    StorageDepositNotEnoughFunds: GenericPalletError;
+    StorageDepositNotEnoughFunds: GenericPalletError<Rv>;
 
     /**
      * More storage was created than allowed by the storage deposit limit.
      **/
-    StorageDepositLimitExhausted: GenericPalletError;
+    StorageDepositLimitExhausted: GenericPalletError<Rv>;
 
     /**
      * Code removal was denied because the code is still in use by at least one contract.
      **/
-    CodeInUse: GenericPalletError;
+    CodeInUse: GenericPalletError<Rv>;
 
     /**
      * The contract ran to completion but decided to revert its storage changes.
@@ -1379,10 +1442,10 @@ export interface ChainErrors extends GenericChainErrors {
      * or via RPC an `Ok` will be returned. In this case the caller needs to inspect the flags
      * to determine whether a reversion has taken place.
      **/
-    ContractReverted: GenericPalletError;
+    ContractReverted: GenericPalletError<Rv>;
 
     /**
-     * The contract's code was found to be invalid during validation or instrumentation.
+     * The contract's code was found to be invalid during validation.
      *
      * The most likely cause of this is that an API was used which is not supported by the
      * node. This happens if an older node is used with a new version of ink!. Try updating
@@ -1391,190 +1454,60 @@ export interface ChainErrors extends GenericChainErrors {
      * A more detailed error can be found on the node console if debug messages are enabled
      * by supplying `-lruntime::contracts=debug`.
      **/
-    CodeRejected: GenericPalletError;
+    CodeRejected: GenericPalletError<Rv>;
 
     /**
      * An indetermistic code was used in a context where this is not permitted.
      **/
-    Indeterministic: GenericPalletError;
+    Indeterministic: GenericPalletError<Rv>;
 
     /**
      * A pending migration needs to complete before the extrinsic can be called.
      **/
-    MigrationInProgress: GenericPalletError;
+    MigrationInProgress: GenericPalletError<Rv>;
 
     /**
      * Migrate dispatch call was attempted but no migration was performed.
      **/
-    NoMigrationPerformed: GenericPalletError;
+    NoMigrationPerformed: GenericPalletError<Rv>;
 
     /**
-     * Generic pallet error
+     * The contract has reached its maximum number of delegate dependencies.
      **/
-    [error: string]: GenericPalletError;
-  };
-  /**
-   * Pallet `Sudo`'s errors
-   **/
-  sudo: {
+    MaxDelegateDependenciesReached: GenericPalletError<Rv>;
+
     /**
-     * Sender must be the Sudo account
+     * The dependency was not found in the contract's delegate dependencies.
      **/
-    RequireSudo: GenericPalletError;
+    DelegateDependencyNotFound: GenericPalletError<Rv>;
 
     /**
-     * Generic pallet error
+     * The contract already depends on the given delegate dependency.
      **/
-    [error: string]: GenericPalletError;
-  };
-  /**
-   * Pallet `StaticPriceProvider`'s errors
-   **/
-  staticPriceProvider: {
+    DelegateDependencyAlreadyExists: GenericPalletError<Rv>;
+
     /**
-     * Zero is invalid value for the price (hopefully).
+     * Can not add a delegate dependency to the code hash of the contract itself.
      **/
-    ZeroPrice: GenericPalletError;
+    CannotAddSelfAsDelegateDependency: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
-   * Pallet `DappsStaking`'s errors
+   * Pallet `Sudo`'s errors
    **/
-  dappsStaking: {
-    /**
-     * Disabled
-     **/
-    Disabled: GenericPalletError;
-
-    /**
-     * No change in maintenance mode
-     **/
-    NoMaintenanceModeChange: GenericPalletError;
-
-    /**
-     * Upgrade is too heavy, reduce the weight parameter.
-     **/
-    UpgradeTooHeavy: GenericPalletError;
-
-    /**
-     * Can not stake with zero value.
-     **/
-    StakingWithNoValue: GenericPalletError;
-
-    /**
-     * Can not stake with value less than minimum staking value
-     **/
-    InsufficientValue: GenericPalletError;
-
-    /**
-     * Number of stakers per contract exceeded.
-     **/
-    MaxNumberOfStakersExceeded: GenericPalletError;
-
-    /**
-     * Targets must be operated contracts
-     **/
-    NotOperatedContract: GenericPalletError;
-
-    /**
-     * Contract isn't staked.
-     **/
-    NotStakedContract: GenericPalletError;
-
-    /**
-     * Contract isn't unregistered.
-     **/
-    NotUnregisteredContract: GenericPalletError;
-
-    /**
-     * Unclaimed rewards should be claimed before withdrawing stake.
-     **/
-    UnclaimedRewardsRemaining: GenericPalletError;
-
-    /**
-     * Unstaking a contract with zero value
-     **/
-    UnstakingWithNoValue: GenericPalletError;
-
-    /**
-     * There are no previously unbonded funds that can be unstaked and withdrawn.
-     **/
-    NothingToWithdraw: GenericPalletError;
-
-    /**
-     * The contract is already registered by other account
-     **/
-    AlreadyRegisteredContract: GenericPalletError;
-
-    /**
-     * This account was already used to register contract
-     **/
-    AlreadyUsedDeveloperAccount: GenericPalletError;
-
-    /**
-     * Smart contract not owned by the account id.
-     **/
-    NotOwnedContract: GenericPalletError;
-
-    /**
-     * Report issue on github if this is ever emitted
-     **/
-    UnknownEraReward: GenericPalletError;
-
-    /**
-     * Report issue on github if this is ever emitted
-     **/
-    UnexpectedStakeInfoEra: GenericPalletError;
-
-    /**
-     * Contract has too many unlocking chunks. Withdraw the existing chunks if possible
-     * or wait for current chunks to complete unlocking process to withdraw them.
-     **/
-    TooManyUnlockingChunks: GenericPalletError;
-
-    /**
-     * Contract already claimed in this era and reward is distributed
-     **/
-    AlreadyClaimedInThisEra: GenericPalletError;
-
-    /**
-     * Era parameter is out of bounds
-     **/
-    EraOutOfBounds: GenericPalletError;
-
-    /**
-     * Too many active `EraStake` values for (staker, contract) pairing.
-     * Claim existing rewards to fix this problem.
-     **/
-    TooManyEraStakeValues: GenericPalletError;
-
-    /**
-     * Account is not actively staking
-     **/
-    NotActiveStaker: GenericPalletError;
-
-    /**
-     * Transfering nomination to the same contract
-     **/
-    NominationTransferToSameContract: GenericPalletError;
-
-    /**
-     * Decommission is in progress so this call is not allowed.
-     **/
-    DecommissionInProgress: GenericPalletError;
-
+  sudo: {
     /**
-     * Delegated claim call is not allowed if both the staker & caller are the same accounts.
+     * Sender must be the Sudo account
      **/
-    ClaimForCallerAccount: GenericPalletError;
+    RequireSudo: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
 }