// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
/* eslint-disable */

/* eslint-disable sort-keys */

export default {
  /**
   * Lookup3: frame_system::AccountInfo<Index, pallet_balances::AccountData<Balance>>
   **/
  FrameSystemAccountInfo: {
    nonce: 'u32',
    consumers: 'u32',
    providers: 'u32',
    sufficients: 'u32',
    data: 'PalletBalancesAccountData'
  },
  /**
   * Lookup5: pallet_balances::AccountData<Balance>
   **/
  PalletBalancesAccountData: {
    free: 'u128',
    reserved: 'u128',
    miscFrozen: 'u128',
    feeFrozen: 'u128'
  },
  /**
   * Lookup7: frame_support::weights::PerDispatchClass<T>
   **/
  FrameSupportWeightsPerDispatchClassU64: {
    normal: 'u64',
    operational: 'u64',
    mandatory: 'u64'
  },
  /**
   * Lookup11: sp_runtime::generic::digest::Digest
   **/
  SpRuntimeDigest: {
    logs: 'Vec<SpRuntimeDigestDigestItem>'
  },
  /**
   * Lookup13: 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'
    }
  },
  /**
   * Lookup16: frame_system::EventRecord<interbtc_runtime_standalone::Event, primitive_types::H256>
   **/
  FrameSystemEventRecord: {
    phase: 'FrameSystemPhase',
    event: 'Event',
    topics: 'Vec<H256>'
  },
  /**
   * Lookup18: frame_system::pallet::Event<T>
   **/
  FrameSystemEvent: {
    _enum: {
      ExtrinsicSuccess: {
        dispatchInfo: 'FrameSupportWeightsDispatchInfo',
      },
      ExtrinsicFailed: {
        dispatchError: 'SpRuntimeDispatchError',
        dispatchInfo: 'FrameSupportWeightsDispatchInfo',
      },
      CodeUpdated: 'Null',
      NewAccount: {
        account: 'AccountId32',
      },
      KilledAccount: {
        account: 'AccountId32',
      },
      Remarked: {
        _alias: {
          hash_: 'hash',
        },
        sender: 'AccountId32',
        hash_: 'H256'
      }
    }
  },
  /**
   * Lookup19: frame_support::weights::DispatchInfo
   **/
  FrameSupportWeightsDispatchInfo: {
    weight: 'u64',
    class: 'FrameSupportWeightsDispatchClass',
    paysFee: 'FrameSupportWeightsPays'
  },
  /**
   * Lookup20: frame_support::weights::DispatchClass
   **/
  FrameSupportWeightsDispatchClass: {
    _enum: ['Normal', 'Operational', 'Mandatory']
  },
  /**
   * Lookup21: frame_support::weights::Pays
   **/
  FrameSupportWeightsPays: {
    _enum: ['Yes', 'No']
  },
  /**
   * Lookup22: sp_runtime::DispatchError
   **/
  SpRuntimeDispatchError: {
    _enum: {
      Other: 'Null',
      CannotLookup: 'Null',
      BadOrigin: 'Null',
      Module: 'SpRuntimeModuleError',
      ConsumerRemaining: 'Null',
      NoProviders: 'Null',
      TooManyConsumers: 'Null',
      Token: 'SpRuntimeTokenError',
      Arithmetic: 'SpRuntimeArithmeticError',
      Transactional: 'SpRuntimeTransactionalError'
    }
  },
  /**
   * Lookup23: sp_runtime::ModuleError
   **/
  SpRuntimeModuleError: {
    index: 'u8',
    error: '[u8;4]'
  },
  /**
   * Lookup24: sp_runtime::TokenError
   **/
  SpRuntimeTokenError: {
    _enum: ['NoFunds', 'WouldDie', 'BelowMinimum', 'CannotCreate', 'UnknownAsset', 'Frozen', 'Unsupported']
  },
  /**
   * Lookup25: sp_runtime::ArithmeticError
   **/
  SpRuntimeArithmeticError: {
    _enum: ['Underflow', 'Overflow', 'DivisionByZero']
  },
  /**
   * Lookup26: sp_runtime::TransactionalError
   **/
  SpRuntimeTransactionalError: {
    _enum: ['LimitReached', 'NoLayer']
  },
  /**
   * Lookup27: pallet_sudo::pallet::Event<T>
   **/
  PalletSudoEvent: {
    _enum: {
      Sudid: {
        sudoResult: 'Result<Null, SpRuntimeDispatchError>',
      },
      KeyChanged: {
        oldSudoer: 'Option<AccountId32>',
      },
      SudoAsDone: {
        sudoResult: 'Result<Null, SpRuntimeDispatchError>'
      }
    }
  },
  /**
   * Lookup31: pallet_utility::pallet::Event
   **/
  PalletUtilityEvent: {
    _enum: {
      BatchInterrupted: {
        index: 'u32',
        error: 'SpRuntimeDispatchError',
      },
      BatchCompleted: 'Null',
      BatchCompletedWithErrors: 'Null',
      ItemCompleted: 'Null',
      ItemFailed: {
        error: 'SpRuntimeDispatchError',
      },
      DispatchedAs: {
        result: 'Result<Null, SpRuntimeDispatchError>'
      }
    }
  },
  /**
   * Lookup32: pallet_scheduler::pallet::Event<T>
   **/
  PalletSchedulerEvent: {
    _enum: {
      Scheduled: {
        when: 'u32',
        index: 'u32',
      },
      Canceled: {
        when: 'u32',
        index: 'u32',
      },
      Dispatched: {
        task: '(u32,u32)',
        id: 'Option<Bytes>',
        result: 'Result<Null, SpRuntimeDispatchError>',
      },
      CallLookupFailed: {
        task: '(u32,u32)',
        id: 'Option<Bytes>',
        error: 'FrameSupportScheduleLookupError'
      }
    }
  },
  /**
   * Lookup35: frame_support::traits::schedule::LookupError
   **/
  FrameSupportScheduleLookupError: {
    _enum: ['Unknown', 'BadFormat']
  },
  /**
   * Lookup36: pallet_preimage::pallet::Event<T>
   **/
  PalletPreimageEvent: {
    _enum: {
      Noted: {
        _alias: {
          hash_: 'hash',
        },
        hash_: 'H256',
      },
      Requested: {
        _alias: {
          hash_: 'hash',
        },
        hash_: 'H256',
      },
      Cleared: {
        _alias: {
          hash_: 'hash',
        },
        hash_: 'H256'
      }
    }
  },
  /**
   * Lookup37: pallet_multisig::pallet::Event<T>
   **/
  PalletMultisigEvent: {
    _enum: {
      NewMultisig: {
        approving: 'AccountId32',
        multisig: 'AccountId32',
        callHash: '[u8;32]',
      },
      MultisigApproval: {
        approving: 'AccountId32',
        timepoint: 'PalletMultisigTimepoint',
        multisig: 'AccountId32',
        callHash: '[u8;32]',
      },
      MultisigExecuted: {
        approving: 'AccountId32',
        timepoint: 'PalletMultisigTimepoint',
        multisig: 'AccountId32',
        callHash: '[u8;32]',
        result: 'Result<Null, SpRuntimeDispatchError>',
      },
      MultisigCancelled: {
        cancelling: 'AccountId32',
        timepoint: 'PalletMultisigTimepoint',
        multisig: 'AccountId32',
        callHash: '[u8;32]'
      }
    }
  },
  /**
   * Lookup38: pallet_multisig::Timepoint<BlockNumber>
   **/
  PalletMultisigTimepoint: {
    height: 'u32',
    index: 'u32'
  },
  /**
   * Lookup39: orml_tokens::module::Event<T>
   **/
  OrmlTokensModuleEvent: {
    _enum: {
      Endowed: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        who: 'AccountId32',
        amount: 'u128',
      },
      DustLost: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        who: 'AccountId32',
        amount: 'u128',
      },
      Transfer: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        from: 'AccountId32',
        to: 'AccountId32',
        amount: 'u128',
      },
      Reserved: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        who: 'AccountId32',
        amount: 'u128',
      },
      Unreserved: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        who: 'AccountId32',
        amount: 'u128',
      },
      ReserveRepatriated: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        from: 'AccountId32',
        to: 'AccountId32',
        amount: 'u128',
        status: 'FrameSupportTokensMiscBalanceStatus',
      },
      BalanceSet: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        who: 'AccountId32',
        free: 'u128',
        reserved: 'u128',
      },
      TotalIssuanceSet: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        amount: 'u128',
      },
      Withdrawn: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        who: 'AccountId32',
        amount: 'u128',
      },
      Slashed: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        who: 'AccountId32',
        freeAmount: 'u128',
        reservedAmount: 'u128',
      },
      Deposited: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        who: 'AccountId32',
        amount: 'u128',
      },
      LockSet: {
        lockId: '[u8;8]',
        currencyId: 'InterbtcPrimitivesCurrencyId',
        who: 'AccountId32',
        amount: 'u128',
      },
      LockRemoved: {
        lockId: '[u8;8]',
        currencyId: 'InterbtcPrimitivesCurrencyId',
        who: 'AccountId32'
      }
    }
  },
  /**
   * Lookup40: interbtc_primitives::CurrencyId
   **/
  InterbtcPrimitivesCurrencyId: {
    _enum: {
      Token: 'InterbtcPrimitivesTokenSymbol',
      ForeignAsset: 'u32'
    }
  },
  /**
   * Lookup41: interbtc_primitives::TokenSymbol
   **/
  InterbtcPrimitivesTokenSymbol: {
    _enum: ['DOT', 'IBTC', 'INTR', '__Unused3', '__Unused4', '__Unused5', '__Unused6', '__Unused7', '__Unused8', '__Unused9', 'KSM', 'KBTC', 'KINT']
  },
  /**
   * Lookup42: frame_support::traits::tokens::misc::BalanceStatus
   **/
  FrameSupportTokensMiscBalanceStatus: {
    _enum: ['Free', 'Reserved']
  },
  /**
   * Lookup44: escrow::pallet::Event<T>
   **/
  EscrowEvent: {
    _enum: {
      Deposit: {
        who: 'AccountId32',
        amount: 'u128',
        unlockHeight: 'u32',
      },
      Withdraw: {
        who: 'AccountId32',
        amount: 'u128'
      }
    }
  },
  /**
   * Lookup45: orml_vesting::module::Event<T>
   **/
  OrmlVestingModuleEvent: {
    _enum: {
      VestingScheduleAdded: {
        from: 'AccountId32',
        to: 'AccountId32',
        vestingSchedule: 'OrmlVestingVestingSchedule',
      },
      Claimed: {
        who: 'AccountId32',
        amount: 'u128',
      },
      VestingSchedulesUpdated: {
        who: 'AccountId32'
      }
    }
  },
  /**
   * Lookup46: orml_vesting::VestingSchedule<BlockNumber, Balance>
   **/
  OrmlVestingVestingSchedule: {
    start: 'u32',
    period: 'u32',
    periodCount: 'u32',
    perPeriod: 'Compact<u128>'
  },
  /**
   * Lookup48: orml_asset_registry::module::Event<T>
   **/
  OrmlAssetRegistryModuleEvent: {
    _enum: {
      RegisteredAsset: {
        assetId: 'u32',
        metadata: 'OrmlTraitsAssetRegistryAssetMetadata',
      },
      UpdatedAsset: {
        assetId: 'u32',
        metadata: 'OrmlTraitsAssetRegistryAssetMetadata'
      }
    }
  },
  /**
   * Lookup49: orml_traits::asset_registry::AssetMetadata<Balance, interbtc_primitives::CustomMetadata>
   **/
  OrmlTraitsAssetRegistryAssetMetadata: {
    decimals: 'u32',
    name: 'Bytes',
    symbol: 'Bytes',
    existentialDeposit: 'u128',
    location: 'Option<XcmVersionedMultiLocation>',
    additional: 'InterbtcPrimitivesCustomMetadata'
  },
  /**
   * Lookup50: interbtc_primitives::CustomMetadata
   **/
  InterbtcPrimitivesCustomMetadata: {
    feePerSecond: 'u128',
    coingeckoId: 'Bytes'
  },
  /**
   * Lookup52: xcm::VersionedMultiLocation
   **/
  XcmVersionedMultiLocation: {
    _enum: {
      V0: 'XcmV0MultiLocation',
      V1: 'XcmV1MultiLocation'
    }
  },
  /**
   * Lookup53: xcm::v0::multi_location::MultiLocation
   **/
  XcmV0MultiLocation: {
    _enum: {
      Null: 'Null',
      X1: 'XcmV0Junction',
      X2: '(XcmV0Junction,XcmV0Junction)',
      X3: '(XcmV0Junction,XcmV0Junction,XcmV0Junction)',
      X4: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
      X5: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
      X6: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
      X7: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
      X8: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)'
    }
  },
  /**
   * Lookup54: xcm::v0::junction::Junction
   **/
  XcmV0Junction: {
    _enum: {
      Parent: 'Null',
      Parachain: 'Compact<u32>',
      AccountId32: {
        network: 'XcmV0JunctionNetworkId',
        id: '[u8;32]',
      },
      AccountIndex64: {
        network: 'XcmV0JunctionNetworkId',
        index: 'Compact<u64>',
      },
      AccountKey20: {
        network: 'XcmV0JunctionNetworkId',
        key: '[u8;20]',
      },
      PalletInstance: 'u8',
      GeneralIndex: 'Compact<u128>',
      GeneralKey: 'Bytes',
      OnlyChild: 'Null',
      Plurality: {
        id: 'XcmV0JunctionBodyId',
        part: 'XcmV0JunctionBodyPart'
      }
    }
  },
  /**
   * Lookup56: xcm::v0::junction::NetworkId
   **/
  XcmV0JunctionNetworkId: {
    _enum: {
      Any: 'Null',
      Named: 'Bytes',
      Polkadot: 'Null',
      Kusama: 'Null'
    }
  },
  /**
   * Lookup59: xcm::v0::junction::BodyId
   **/
  XcmV0JunctionBodyId: {
    _enum: {
      Unit: 'Null',
      Named: 'Bytes',
      Index: 'Compact<u32>',
      Executive: 'Null',
      Technical: 'Null',
      Legislative: 'Null',
      Judicial: 'Null'
    }
  },
  /**
   * Lookup60: xcm::v0::junction::BodyPart
   **/
  XcmV0JunctionBodyPart: {
    _enum: {
      Voice: 'Null',
      Members: {
        count: 'Compact<u32>',
      },
      Fraction: {
        nom: 'Compact<u32>',
        denom: 'Compact<u32>',
      },
      AtLeastProportion: {
        nom: 'Compact<u32>',
        denom: 'Compact<u32>',
      },
      MoreThanProportion: {
        nom: 'Compact<u32>',
        denom: 'Compact<u32>'
      }
    }
  },
  /**
   * Lookup61: xcm::v1::multilocation::MultiLocation
   **/
  XcmV1MultiLocation: {
    parents: 'u8',
    interior: 'XcmV1MultilocationJunctions'
  },
  /**
   * Lookup62: xcm::v1::multilocation::Junctions
   **/
  XcmV1MultilocationJunctions: {
    _enum: {
      Here: 'Null',
      X1: 'XcmV1Junction',
      X2: '(XcmV1Junction,XcmV1Junction)',
      X3: '(XcmV1Junction,XcmV1Junction,XcmV1Junction)',
      X4: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
      X5: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
      X6: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
      X7: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
      X8: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)'
    }
  },
  /**
   * Lookup63: xcm::v1::junction::Junction
   **/
  XcmV1Junction: {
    _enum: {
      Parachain: 'Compact<u32>',
      AccountId32: {
        network: 'XcmV0JunctionNetworkId',
        id: '[u8;32]',
      },
      AccountIndex64: {
        network: 'XcmV0JunctionNetworkId',
        index: 'Compact<u64>',
      },
      AccountKey20: {
        network: 'XcmV0JunctionNetworkId',
        key: '[u8;20]',
      },
      PalletInstance: 'u8',
      GeneralIndex: 'Compact<u128>',
      GeneralKey: 'Bytes',
      OnlyChild: 'Null',
      Plurality: {
        id: 'XcmV0JunctionBodyId',
        part: 'XcmV0JunctionBodyPart'
      }
    }
  },
  /**
   * Lookup64: annuity::pallet::Event<T, I>
   **/
  AnnuityEvent: {
    _enum: {
      BlockReward: 'u128'
    }
  },
  /**
   * Lookup65: reward::pallet::Event<T, I>
   **/
  RewardEvent: {
    _enum: {
      DepositStake: {
        rewardId: 'AccountId32',
        amount: 'i128',
      },
      DistributeReward: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        amount: 'i128',
      },
      WithdrawStake: {
        rewardId: 'AccountId32',
        amount: 'i128',
      },
      WithdrawReward: {
        rewardId: 'AccountId32',
        currencyId: 'InterbtcPrimitivesCurrencyId',
        amount: 'i128'
      }
    }
  },
  /**
   * Lookup70: interbtc_primitives::VaultId<sp_core::crypto::AccountId32, interbtc_primitives::CurrencyId>
   **/
  InterbtcPrimitivesVaultId: {
    accountId: 'AccountId32',
    currencies: 'InterbtcPrimitivesVaultCurrencyPair'
  },
  /**
   * Lookup71: interbtc_primitives::VaultCurrencyPair<interbtc_primitives::CurrencyId>
   **/
  InterbtcPrimitivesVaultCurrencyPair: {
    collateral: 'InterbtcPrimitivesCurrencyId',
    wrapped: 'InterbtcPrimitivesCurrencyId'
  },
  /**
   * Lookup72: staking::pallet::Event<T>
   **/
  StakingEvent: {
    _enum: {
      DepositStake: {
        vaultId: 'InterbtcPrimitivesVaultId',
        nominatorId: 'AccountId32',
        amount: 'i128',
      },
      DistributeReward: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        vaultId: 'InterbtcPrimitivesVaultId',
        amount: 'i128',
      },
      WithdrawStake: {
        vaultId: 'InterbtcPrimitivesVaultId',
        nominatorId: 'AccountId32',
        amount: 'i128',
      },
      WithdrawReward: {
        nonce: 'u32',
        currencyId: 'InterbtcPrimitivesCurrencyId',
        vaultId: 'InterbtcPrimitivesVaultId',
        nominatorId: 'AccountId32',
        amount: 'i128',
      },
      ForceRefund: {
        vaultId: 'InterbtcPrimitivesVaultId',
      },
      IncreaseNonce: {
        vaultId: 'InterbtcPrimitivesVaultId',
        newNonce: 'u32'
      }
    }
  },
  /**
   * Lookup73: supply::pallet::Event<T>
   **/
  SupplyEvent: {
    _enum: {
      Inflation: {
        totalInflation: 'u128'
      }
    }
  },
  /**
   * Lookup74: btc_relay::pallet::Event<T>
   **/
  BtcRelayEvent: {
    _enum: {
      Initialized: {
        blockHeight: 'u32',
        blockHash: 'BitcoinH256Le',
        relayerId: 'AccountId32',
      },
      StoreMainChainHeader: {
        blockHeight: 'u32',
        blockHash: 'BitcoinH256Le',
        relayerId: 'AccountId32',
      },
      StoreForkHeader: {
        chainId: 'u32',
        forkHeight: 'u32',
        blockHash: 'BitcoinH256Le',
        relayerId: 'AccountId32',
      },
      ChainReorg: {
        newChainTipHash: 'BitcoinH256Le',
        newChainTipHeight: 'u32',
        forkDepth: 'u32',
      },
      ForkAheadOfMainChain: {
        mainChainHeight: 'u32',
        forkHeight: 'u32',
        forkId: 'u32'
      }
    }
  },
  /**
   * Lookup75: bitcoin::types::H256Le
   **/
  BitcoinH256Le: {
    content: '[u8;32]'
  },
  /**
   * Lookup76: security::pallet::Event<T>
   **/
  SecurityEvent: {
    _enum: {
      RecoverFromErrors: {
        newStatus: 'SecurityStatusCode',
        clearedErrors: 'Vec<SecurityErrorCode>',
      },
      UpdateActiveBlock: {
        blockNumber: 'u32'
      }
    }
  },
  /**
   * Lookup77: security::types::StatusCode
   **/
  SecurityStatusCode: {
    _enum: ['Running', 'Error', 'Shutdown']
  },
  /**
   * Lookup79: security::types::ErrorCode
   **/
  SecurityErrorCode: {
    _enum: ['None', 'OracleOffline']
  },
  /**
   * Lookup80: vault_registry::pallet::Event<T>
   **/
  VaultRegistryEvent: {
    _enum: {
      RegisterVault: {
        vaultId: 'InterbtcPrimitivesVaultId',
        collateral: 'u128',
      },
      DepositCollateral: {
        vaultId: 'InterbtcPrimitivesVaultId',
        newCollateral: 'u128',
        totalCollateral: 'u128',
        freeCollateral: 'u128',
      },
      WithdrawCollateral: {
        vaultId: 'InterbtcPrimitivesVaultId',
        withdrawnAmount: 'u128',
        totalCollateral: 'u128',
      },
      IncreaseLockedCollateral: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        delta: 'u128',
        total: 'u128',
      },
      DecreaseLockedCollateral: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        delta: 'u128',
        total: 'u128',
      },
      UpdatePublicKey: {
        accountId: 'AccountId32',
        publicKey: 'BitcoinAddressPublicKey',
      },
      RegisterAddress: {
        vaultId: 'InterbtcPrimitivesVaultId',
        address: 'BitcoinAddress',
      },
      IncreaseToBeIssuedTokens: {
        vaultId: 'InterbtcPrimitivesVaultId',
        increase: 'u128',
      },
      DecreaseToBeIssuedTokens: {
        vaultId: 'InterbtcPrimitivesVaultId',
        decrease: 'u128',
      },
      IssueTokens: {
        vaultId: 'InterbtcPrimitivesVaultId',
        increase: 'u128',
      },
      IncreaseToBeRedeemedTokens: {
        vaultId: 'InterbtcPrimitivesVaultId',
        increase: 'u128',
      },
      DecreaseToBeRedeemedTokens: {
        vaultId: 'InterbtcPrimitivesVaultId',
        decrease: 'u128',
      },
      IncreaseToBeReplacedTokens: {
        vaultId: 'InterbtcPrimitivesVaultId',
        increase: 'u128',
      },
      DecreaseToBeReplacedTokens: {
        vaultId: 'InterbtcPrimitivesVaultId',
        decrease: 'u128',
      },
      DecreaseTokens: {
        vaultId: 'InterbtcPrimitivesVaultId',
        userId: 'AccountId32',
        decrease: 'u128',
      },
      RedeemTokens: {
        vaultId: 'InterbtcPrimitivesVaultId',
        redeemedAmount: 'u128',
      },
      RedeemTokensPremium: {
        vaultId: 'InterbtcPrimitivesVaultId',
        redeemedAmount: 'u128',
        collateral: 'u128',
        userId: 'AccountId32',
      },
      RedeemTokensLiquidatedVault: {
        vaultId: 'InterbtcPrimitivesVaultId',
        tokens: 'u128',
        collateral: 'u128',
      },
      RedeemTokensLiquidation: {
        redeemerId: 'AccountId32',
        burnedTokens: 'u128',
        transferredCollateral: 'u128',
      },
      ReplaceTokens: {
        oldVaultId: 'InterbtcPrimitivesVaultId',
        newVaultId: 'InterbtcPrimitivesVaultId',
        amount: 'u128',
        additionalCollateral: 'u128',
      },
      LiquidateVault: {
        vaultId: 'InterbtcPrimitivesVaultId',
        issuedTokens: 'u128',
        toBeIssuedTokens: 'u128',
        toBeRedeemedTokens: 'u128',
        toBeReplacedTokens: 'u128',
        backingCollateral: 'u128',
        status: 'VaultRegistryVaultStatus',
        replaceCollateral: 'u128',
      },
      BanVault: {
        vaultId: 'InterbtcPrimitivesVaultId',
        bannedUntil: 'u32',
      },
      NotifyClientRelease: {
        release: 'VaultRegistryClientRelease',
      },
      ApplyClientRelease: {
        release: 'VaultRegistryClientRelease'
      }
    }
  },
  /**
   * Lookup81: bitcoin::address::PublicKey
   **/
  BitcoinAddressPublicKey: '[u8;33]',
  /**
   * Lookup83: bitcoin::address::Address
   **/
  BitcoinAddress: {
    _enum: {
      P2PKH: 'H160',
      P2SH: 'H160',
      P2WPKHv0: 'H160',
      P2WSHv0: 'H256'
    }
  },
  /**
   * Lookup85: vault_registry::types::VaultStatus
   **/
  VaultRegistryVaultStatus: {
    _enum: {
      Active: 'bool',
      Liquidated: 'Null'
    }
  },
  /**
   * Lookup87: vault_registry::types::ClientRelease<primitive_types::H256>
   **/
  VaultRegistryClientRelease: {
    uri: 'Bytes',
    codeHash: 'H256'
  },
  /**
   * Lookup88: oracle::pallet::Event<T>
   **/
  OracleEvent: {
    _enum: {
      FeedValues: {
        oracleId: 'AccountId32',
        values: 'Vec<(InterbtcPrimitivesOracleKey,u128)>',
      },
      AggregateUpdated: {
        values: 'Vec<(InterbtcPrimitivesOracleKey,Option<u128>)>',
      },
      OracleAdded: {
        oracleId: 'AccountId32',
        name: 'Bytes',
      },
      OracleRemoved: {
        oracleId: 'AccountId32'
      }
    }
  },
  /**
   * Lookup91: interbtc_primitives::oracle::Key
   **/
  InterbtcPrimitivesOracleKey: {
    _enum: {
      ExchangeRate: 'InterbtcPrimitivesCurrencyId',
      FeeEstimation: 'Null'
    }
  },
  /**
   * Lookup96: issue::pallet::Event<T>
   **/
  IssueEvent: {
    _enum: {
      RequestIssue: {
        issueId: 'H256',
        requester: 'AccountId32',
        amount: 'u128',
        fee: 'u128',
        griefingCollateral: 'u128',
        vaultId: 'InterbtcPrimitivesVaultId',
        vaultAddress: 'BitcoinAddress',
        vaultPublicKey: 'BitcoinAddressPublicKey',
      },
      IssueAmountChange: {
        issueId: 'H256',
        amount: 'u128',
        fee: 'u128',
        confiscatedGriefingCollateral: 'u128',
      },
      ExecuteIssue: {
        issueId: 'H256',
        requester: 'AccountId32',
        vaultId: 'InterbtcPrimitivesVaultId',
        amount: 'u128',
        fee: 'u128',
      },
      CancelIssue: {
        issueId: 'H256',
        requester: 'AccountId32',
        griefingCollateral: 'u128',
      },
      IssuePeriodChange: {
        period: 'u32'
      }
    }
  },
  /**
   * Lookup97: redeem::pallet::Event<T>
   **/
  RedeemEvent: {
    _enum: {
      RequestRedeem: {
        redeemId: 'H256',
        redeemer: 'AccountId32',
        vaultId: 'InterbtcPrimitivesVaultId',
        amount: 'u128',
        fee: 'u128',
        premium: 'u128',
        btcAddress: 'BitcoinAddress',
        transferFee: 'u128',
      },
      LiquidationRedeem: {
        redeemer: 'AccountId32',
        amount: 'u128',
      },
      ExecuteRedeem: {
        redeemId: 'H256',
        redeemer: 'AccountId32',
        vaultId: 'InterbtcPrimitivesVaultId',
        amount: 'u128',
        fee: 'u128',
        transferFee: 'u128',
      },
      CancelRedeem: {
        redeemId: 'H256',
        redeemer: 'AccountId32',
        vaultId: 'InterbtcPrimitivesVaultId',
        slashedAmount: 'u128',
        status: 'InterbtcPrimitivesRedeemRedeemRequestStatus',
      },
      MintTokensForReimbursedRedeem: {
        redeemId: 'H256',
        vaultId: 'InterbtcPrimitivesVaultId',
        amount: 'u128',
      },
      RedeemPeriodChange: {
        period: 'u32'
      }
    }
  },
  /**
   * Lookup98: interbtc_primitives::redeem::RedeemRequestStatus
   **/
  InterbtcPrimitivesRedeemRedeemRequestStatus: {
    _enum: {
      Pending: 'Null',
      Completed: 'Null',
      Reimbursed: 'bool',
      Retried: 'Null'
    }
  },
  /**
   * Lookup99: replace::pallet::Event<T>
   **/
  ReplaceEvent: {
    _enum: {
      RequestReplace: {
        oldVaultId: 'InterbtcPrimitivesVaultId',
        amount: 'u128',
        griefingCollateral: 'u128',
      },
      WithdrawReplace: {
        oldVaultId: 'InterbtcPrimitivesVaultId',
        withdrawnTokens: 'u128',
        withdrawnGriefingCollateral: 'u128',
      },
      AcceptReplace: {
        replaceId: 'H256',
        oldVaultId: 'InterbtcPrimitivesVaultId',
        newVaultId: 'InterbtcPrimitivesVaultId',
        amount: 'u128',
        collateral: 'u128',
        btcAddress: 'BitcoinAddress',
      },
      ExecuteReplace: {
        replaceId: 'H256',
        oldVaultId: 'InterbtcPrimitivesVaultId',
        newVaultId: 'InterbtcPrimitivesVaultId',
      },
      CancelReplace: {
        replaceId: 'H256',
        newVaultId: 'InterbtcPrimitivesVaultId',
        oldVaultId: 'InterbtcPrimitivesVaultId',
        griefingCollateral: 'u128',
      },
      ReplacePeriodChange: {
        period: 'u32'
      }
    }
  },
  /**
   * Lookup100: refund::pallet::Event<T>
   **/
  RefundEvent: {
    _enum: {
      RequestRefund: {
        refundId: 'H256',
        issuer: 'AccountId32',
        amount: 'u128',
        vaultId: 'InterbtcPrimitivesVaultId',
        btcAddress: 'BitcoinAddress',
        issueId: 'H256',
        fee: 'u128',
        transferFee: 'u128',
      },
      ExecuteRefund: {
        refundId: 'H256',
        issuer: 'AccountId32',
        vaultId: 'InterbtcPrimitivesVaultId',
        amount: 'u128',
        fee: 'u128'
      }
    }
  },
  /**
   * Lookup101: nomination::pallet::Event<T>
   **/
  NominationEvent: {
    _enum: {
      NominationOptIn: {
        vaultId: 'InterbtcPrimitivesVaultId',
      },
      NominationOptOut: {
        vaultId: 'InterbtcPrimitivesVaultId',
      },
      DepositCollateral: {
        vaultId: 'InterbtcPrimitivesVaultId',
        nominatorId: 'AccountId32',
        amount: 'u128',
      },
      WithdrawCollateral: {
        vaultId: 'InterbtcPrimitivesVaultId',
        nominatorId: 'AccountId32',
        amount: 'u128'
      }
    }
  },
  /**
   * Lookup102: pallet_identity::pallet::Event<T>
   **/
  PalletIdentityEvent: {
    _enum: {
      IdentitySet: {
        who: 'AccountId32',
      },
      IdentityCleared: {
        who: 'AccountId32',
        deposit: 'u128',
      },
      IdentityKilled: {
        who: 'AccountId32',
        deposit: 'u128',
      },
      JudgementRequested: {
        who: 'AccountId32',
        registrarIndex: 'u32',
      },
      JudgementUnrequested: {
        who: 'AccountId32',
        registrarIndex: 'u32',
      },
      JudgementGiven: {
        target: 'AccountId32',
        registrarIndex: 'u32',
      },
      RegistrarAdded: {
        registrarIndex: 'u32',
      },
      SubIdentityAdded: {
        sub: 'AccountId32',
        main: 'AccountId32',
        deposit: 'u128',
      },
      SubIdentityRemoved: {
        sub: 'AccountId32',
        main: 'AccountId32',
        deposit: 'u128',
      },
      SubIdentityRevoked: {
        sub: 'AccountId32',
        main: 'AccountId32',
        deposit: 'u128'
      }
    }
  },
  /**
   * Lookup103: democracy::pallet::Event<T>
   **/
  DemocracyEvent: {
    _enum: {
      Proposed: '(u32,u128)',
      Tabled: '(u32,u128,Vec<AccountId32>)',
      Started: '(u32,DemocracyVoteThreshold)',
      FastTrack: 'u32',
      FastTrackReferendum: 'u32',
      Passed: 'u32',
      NotPassed: 'u32',
      Cancelled: 'u32',
      Executed: '(u32,Result<Null, SpRuntimeDispatchError>)',
      PreimageNoted: '(H256,AccountId32,u128)',
      PreimageUsed: '(H256,AccountId32,u128)',
      PreimageInvalid: '(H256,u32)',
      PreimageMissing: '(H256,u32)',
      PreimageReaped: '(H256,AccountId32,u128,AccountId32)'
    }
  },
  /**
   * Lookup105: democracy::vote_threshold::VoteThreshold
   **/
  DemocracyVoteThreshold: {
    _enum: ['SuperMajorityApprove', 'SuperMajorityAgainst', 'SimpleMajority']
  },
  /**
   * Lookup106: pallet_collective::pallet::Event<T, I>
   **/
  PalletCollectiveEvent: {
    _enum: {
      Proposed: {
        account: 'AccountId32',
        proposalIndex: 'u32',
        proposalHash: 'H256',
        threshold: 'u32',
      },
      Voted: {
        account: 'AccountId32',
        proposalHash: 'H256',
        voted: 'bool',
        yes: 'u32',
        no: 'u32',
      },
      Approved: {
        proposalHash: 'H256',
      },
      Disapproved: {
        proposalHash: 'H256',
      },
      Executed: {
        proposalHash: 'H256',
        result: 'Result<Null, SpRuntimeDispatchError>',
      },
      MemberExecuted: {
        proposalHash: 'H256',
        result: 'Result<Null, SpRuntimeDispatchError>',
      },
      Closed: {
        proposalHash: 'H256',
        yes: 'u32',
        no: 'u32'
      }
    }
  },
  /**
   * Lookup107: pallet_membership::pallet::Event<T, I>
   **/
  PalletMembershipEvent: {
    _enum: ['MemberAdded', 'MemberRemoved', 'MembersSwapped', 'MembersReset', 'KeyChanged', 'Dummy']
  },
  /**
   * Lookup108: pallet_treasury::pallet::Event<T, I>
   **/
  PalletTreasuryEvent: {
    _enum: {
      Proposed: {
        proposalIndex: 'u32',
      },
      Spending: {
        budgetRemaining: 'u128',
      },
      Awarded: {
        proposalIndex: 'u32',
        award: 'u128',
        account: 'AccountId32',
      },
      Rejected: {
        proposalIndex: 'u32',
        slashed: 'u128',
      },
      Burnt: {
        burntFunds: 'u128',
      },
      Rollover: {
        rolloverBalance: 'u128',
      },
      Deposit: {
        value: 'u128'
      }
    }
  },
  /**
   * Lookup109: pallet_grandpa::pallet::Event
   **/
  PalletGrandpaEvent: {
    _enum: {
      NewAuthorities: {
        authoritySet: 'Vec<(SpFinalityGrandpaAppPublic,u64)>',
      },
      Paused: 'Null',
      Resumed: 'Null'
    }
  },
  /**
   * Lookup112: sp_finality_grandpa::app::Public
   **/
  SpFinalityGrandpaAppPublic: 'SpCoreEd25519Public',
  /**
   * Lookup113: sp_core::ed25519::Public
   **/
  SpCoreEd25519Public: '[u8;32]',
  /**
   * Lookup114: frame_system::Phase
   **/
  FrameSystemPhase: {
    _enum: {
      ApplyExtrinsic: 'u32',
      Finalization: 'Null',
      Initialization: 'Null'
    }
  },
  /**
   * Lookup117: frame_system::LastRuntimeUpgradeInfo
   **/
  FrameSystemLastRuntimeUpgradeInfo: {
    specVersion: 'Compact<u32>',
    specName: 'Text'
  },
  /**
   * Lookup119: frame_system::pallet::Call<T>
   **/
  FrameSystemCall: {
    _enum: {
      fill_block: {
        ratio: 'Perbill',
      },
      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'
      }
    }
  },
  /**
   * Lookup124: frame_system::limits::BlockWeights
   **/
  FrameSystemLimitsBlockWeights: {
    baseBlock: 'u64',
    maxBlock: 'u64',
    perClass: 'FrameSupportWeightsPerDispatchClassWeightsPerClass'
  },
  /**
   * Lookup125: frame_support::weights::PerDispatchClass<frame_system::limits::WeightsPerClass>
   **/
  FrameSupportWeightsPerDispatchClassWeightsPerClass: {
    normal: 'FrameSystemLimitsWeightsPerClass',
    operational: 'FrameSystemLimitsWeightsPerClass',
    mandatory: 'FrameSystemLimitsWeightsPerClass'
  },
  /**
   * Lookup126: frame_system::limits::WeightsPerClass
   **/
  FrameSystemLimitsWeightsPerClass: {
    baseExtrinsic: 'u64',
    maxExtrinsic: 'Option<u64>',
    maxTotal: 'Option<u64>',
    reserved: 'Option<u64>'
  },
  /**
   * Lookup128: frame_system::limits::BlockLength
   **/
  FrameSystemLimitsBlockLength: {
    max: 'FrameSupportWeightsPerDispatchClassU32'
  },
  /**
   * Lookup129: frame_support::weights::PerDispatchClass<T>
   **/
  FrameSupportWeightsPerDispatchClassU32: {
    normal: 'u32',
    operational: 'u32',
    mandatory: 'u32'
  },
  /**
   * Lookup130: frame_support::weights::RuntimeDbWeight
   **/
  FrameSupportWeightsRuntimeDbWeight: {
    read: 'u64',
    write: 'u64'
  },
  /**
   * Lookup131: sp_version::RuntimeVersion
   **/
  SpVersionRuntimeVersion: {
    specName: 'Text',
    implName: 'Text',
    authoringVersion: 'u32',
    specVersion: 'u32',
    implVersion: 'u32',
    apis: 'Vec<([u8;8],u32)>',
    transactionVersion: 'u32',
    stateVersion: 'u8'
  },
  /**
   * Lookup136: frame_system::pallet::Error<T>
   **/
  FrameSystemError: {
    _enum: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered']
  },
  /**
   * Lookup137: pallet_timestamp::pallet::Call<T>
   **/
  PalletTimestampCall: {
    _enum: {
      set: {
        now: 'Compact<u64>'
      }
    }
  },
  /**
   * Lookup138: pallet_sudo::pallet::Call<T>
   **/
  PalletSudoCall: {
    _enum: {
      sudo: {
        call: 'Call',
      },
      sudo_unchecked_weight: {
        call: 'Call',
        weight: 'u64',
      },
      set_key: {
        _alias: {
          new_: 'new',
        },
        new_: 'AccountId32',
      },
      sudo_as: {
        who: 'AccountId32',
        call: 'Call'
      }
    }
  },
  /**
   * Lookup140: pallet_utility::pallet::Call<T>
   **/
  PalletUtilityCall: {
    _enum: {
      batch: {
        calls: 'Vec<Call>',
      },
      as_derivative: {
        index: 'u16',
        call: 'Call',
      },
      batch_all: {
        calls: 'Vec<Call>',
      },
      dispatch_as: {
        asOrigin: 'InterbtcRuntimeStandaloneOriginCaller',
        call: 'Call',
      },
      force_batch: {
        calls: 'Vec<Call>'
      }
    }
  },
  /**
   * Lookup142: interbtc_runtime_standalone::OriginCaller
   **/
  InterbtcRuntimeStandaloneOriginCaller: {
    _enum: {
      system: 'FrameSupportDispatchRawOrigin',
      __Unused1: 'Null',
      Void: 'SpCoreVoid',
      __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',
      TechnicalCommittee: 'PalletCollectiveRawOrigin'
    }
  },
  /**
   * Lookup143: frame_support::dispatch::RawOrigin<sp_core::crypto::AccountId32>
   **/
  FrameSupportDispatchRawOrigin: {
    _enum: {
      Root: 'Null',
      Signed: 'AccountId32',
      None: 'Null'
    }
  },
  /**
   * Lookup144: pallet_collective::RawOrigin<sp_core::crypto::AccountId32, I>
   **/
  PalletCollectiveRawOrigin: {
    _enum: {
      Members: '(u32,u32)',
      Member: 'AccountId32',
      _Phantom: 'Null'
    }
  },
  /**
   * Lookup145: sp_core::Void
   **/
  SpCoreVoid: 'Null',
  /**
   * Lookup146: pallet_scheduler::pallet::Call<T>
   **/
  PalletSchedulerCall: {
    _enum: {
      schedule: {
        when: 'u32',
        maybePeriodic: 'Option<(u32,u32)>',
        priority: 'u8',
        call: 'FrameSupportScheduleMaybeHashed',
      },
      cancel: {
        when: 'u32',
        index: 'u32',
      },
      schedule_named: {
        id: 'Bytes',
        when: 'u32',
        maybePeriodic: 'Option<(u32,u32)>',
        priority: 'u8',
        call: 'FrameSupportScheduleMaybeHashed',
      },
      cancel_named: {
        id: 'Bytes',
      },
      schedule_after: {
        after: 'u32',
        maybePeriodic: 'Option<(u32,u32)>',
        priority: 'u8',
        call: 'FrameSupportScheduleMaybeHashed',
      },
      schedule_named_after: {
        id: 'Bytes',
        after: 'u32',
        maybePeriodic: 'Option<(u32,u32)>',
        priority: 'u8',
        call: 'FrameSupportScheduleMaybeHashed'
      }
    }
  },
  /**
   * Lookup148: frame_support::traits::schedule::MaybeHashed<interbtc_runtime_standalone::Call, primitive_types::H256>
   **/
  FrameSupportScheduleMaybeHashed: {
    _enum: {
      Value: 'Call',
      Hash: 'H256'
    }
  },
  /**
   * Lookup149: pallet_preimage::pallet::Call<T>
   **/
  PalletPreimageCall: {
    _enum: {
      note_preimage: {
        bytes: 'Bytes',
      },
      unnote_preimage: {
        _alias: {
          hash_: 'hash',
        },
        hash_: 'H256',
      },
      request_preimage: {
        _alias: {
          hash_: 'hash',
        },
        hash_: 'H256',
      },
      unrequest_preimage: {
        _alias: {
          hash_: 'hash',
        },
        hash_: 'H256'
      }
    }
  },
  /**
   * Lookup150: pallet_multisig::pallet::Call<T>
   **/
  PalletMultisigCall: {
    _enum: {
      as_multi_threshold_1: {
        otherSignatories: 'Vec<AccountId32>',
        call: 'Call',
      },
      as_multi: {
        threshold: 'u16',
        otherSignatories: 'Vec<AccountId32>',
        maybeTimepoint: 'Option<PalletMultisigTimepoint>',
        call: 'WrapperKeepOpaque<Call>',
        storeCall: 'bool',
        maxWeight: 'u64',
      },
      approve_as_multi: {
        threshold: 'u16',
        otherSignatories: 'Vec<AccountId32>',
        maybeTimepoint: 'Option<PalletMultisigTimepoint>',
        callHash: '[u8;32]',
        maxWeight: 'u64',
      },
      cancel_as_multi: {
        threshold: 'u16',
        otherSignatories: 'Vec<AccountId32>',
        timepoint: 'PalletMultisigTimepoint',
        callHash: '[u8;32]'
      }
    }
  },
  /**
   * Lookup153: orml_tokens::module::Call<T>
   **/
  OrmlTokensModuleCall: {
    _enum: {
      transfer: {
        dest: 'AccountId32',
        currencyId: 'InterbtcPrimitivesCurrencyId',
        amount: 'Compact<u128>',
      },
      transfer_all: {
        dest: 'AccountId32',
        currencyId: 'InterbtcPrimitivesCurrencyId',
        keepAlive: 'bool',
      },
      transfer_keep_alive: {
        dest: 'AccountId32',
        currencyId: 'InterbtcPrimitivesCurrencyId',
        amount: 'Compact<u128>',
      },
      force_transfer: {
        source: 'AccountId32',
        dest: 'AccountId32',
        currencyId: 'InterbtcPrimitivesCurrencyId',
        amount: 'Compact<u128>',
      },
      set_balance: {
        who: 'AccountId32',
        currencyId: 'InterbtcPrimitivesCurrencyId',
        newFree: 'Compact<u128>',
        newReserved: 'Compact<u128>'
      }
    }
  },
  /**
   * Lookup154: escrow::pallet::Call<T>
   **/
  EscrowCall: {
    _enum: {
      create_lock: {
        amount: 'Compact<u128>',
        unlockHeight: 'u32',
      },
      increase_amount: {
        amount: 'Compact<u128>',
      },
      increase_unlock_height: {
        unlockHeight: 'u32',
      },
      withdraw: 'Null',
      set_account_limit: {
        who: 'AccountId32',
        start: 'u32',
        end: 'u32',
      },
      set_account_block: {
        who: 'AccountId32'
      }
    }
  },
  /**
   * Lookup155: orml_vesting::module::Call<T>
   **/
  OrmlVestingModuleCall: {
    _enum: {
      claim: 'Null',
      vested_transfer: {
        dest: 'AccountId32',
        schedule: 'OrmlVestingVestingSchedule',
      },
      update_vesting_schedules: {
        who: 'AccountId32',
        vestingSchedules: 'Vec<OrmlVestingVestingSchedule>',
      },
      claim_for: {
        dest: 'AccountId32'
      }
    }
  },
  /**
   * Lookup157: orml_asset_registry::module::Call<T>
   **/
  OrmlAssetRegistryModuleCall: {
    _enum: {
      register_asset: {
        metadata: 'OrmlTraitsAssetRegistryAssetMetadata',
        assetId: 'Option<u32>',
      },
      update_asset: {
        assetId: 'u32',
        decimals: 'Option<u32>',
        name: 'Option<Bytes>',
        symbol: 'Option<Bytes>',
        existentialDeposit: 'Option<u128>',
        location: 'Option<Option<XcmVersionedMultiLocation>>',
        additional: 'Option<InterbtcPrimitivesCustomMetadata>'
      }
    }
  },
  /**
   * Lookup162: annuity::pallet::Call<T, I>
   **/
  AnnuityCall: {
    _enum: {
      withdraw_rewards: 'Null',
      update_rewards: 'Null',
      set_reward_per_wrapped: {
        rewardPerWrapped: 'u128'
      }
    }
  },
  /**
   * Lookup164: supply::pallet::Call<T>
   **/
  SupplyCall: {
    _enum: {
      set_start_height_and_inflation: {
        startHeight: 'u32',
        inflation: 'u128'
      }
    }
  },
  /**
   * Lookup165: btc_relay::pallet::Call<T>
   **/
  BtcRelayCall: {
    _enum: {
      initialize: {
        rawBlockHeader: 'BitcoinRawBlockHeader',
        blockHeight: 'u32',
      },
      store_block_header: {
        rawBlockHeader: 'BitcoinRawBlockHeader',
      },
      verify_and_validate_transaction: {
        rawMerkleProof: 'Bytes',
        confirmations: 'Option<u32>',
        rawTx: 'Bytes',
        expectedBtc: 'i64',
        recipientBtcAddress: 'BitcoinAddress',
        opReturnId: 'Option<H256>',
      },
      verify_transaction_inclusion: {
        txId: 'BitcoinH256Le',
        rawMerkleProof: 'Bytes',
        confirmations: 'Option<u32>',
      },
      validate_transaction: {
        rawTx: 'Bytes',
        expectedBtc: 'i64',
        recipientBtcAddress: 'BitcoinAddress',
        opReturnId: 'Option<H256>'
      }
    }
  },
  /**
   * Lookup166: bitcoin::types::RawBlockHeader
   **/
  BitcoinRawBlockHeader: '[u8;80]',
  /**
   * Lookup170: security::pallet::Call<T>
   **/
  SecurityCall: {
    _enum: {
      set_parachain_status: {
        statusCode: 'SecurityStatusCode',
      },
      insert_parachain_error: {
        errorCode: 'SecurityErrorCode',
      },
      remove_parachain_error: {
        errorCode: 'SecurityErrorCode'
      }
    }
  },
  /**
   * Lookup171: vault_registry::pallet::Call<T>
   **/
  VaultRegistryCall: {
    _enum: {
      register_vault: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        collateral: 'Compact<u128>',
      },
      deposit_collateral: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        amount: 'Compact<u128>',
      },
      withdraw_collateral: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        amount: 'Compact<u128>',
      },
      register_public_key: {
        publicKey: 'BitcoinAddressPublicKey',
      },
      accept_new_issues: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        acceptNewIssues: 'bool',
      },
      set_custom_secure_threshold: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        customThreshold: 'Option<u128>',
      },
      report_undercollateralized_vault: {
        vaultId: 'InterbtcPrimitivesVaultId',
      },
      set_minimum_collateral: {
        currencyId: 'InterbtcPrimitivesCurrencyId',
        minimum: 'u128',
      },
      set_system_collateral_ceiling: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        ceiling: 'u128',
      },
      set_secure_collateral_threshold: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        threshold: 'u128',
      },
      set_premium_redeem_threshold: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        threshold: 'u128',
      },
      set_liquidation_collateral_threshold: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        threshold: 'u128',
      },
      set_current_client_release: {
        uri: 'Bytes',
        codeHash: 'H256',
      },
      set_pending_client_release: {
        uri: 'Bytes',
        codeHash: 'H256',
      },
      recover_vault_id: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair'
      }
    }
  },
  /**
   * Lookup172: oracle::pallet::Call<T>
   **/
  OracleCall: {
    _enum: {
      feed_values: {
        values: 'Vec<(InterbtcPrimitivesOracleKey,u128)>',
      },
      insert_authorized_oracle: {
        accountId: 'AccountId32',
        name: 'Bytes',
      },
      remove_authorized_oracle: {
        accountId: 'AccountId32'
      }
    }
  },
  /**
   * Lookup173: issue::pallet::Call<T>
   **/
  IssueCall: {
    _enum: {
      request_issue: {
        amount: 'Compact<u128>',
        vaultId: 'InterbtcPrimitivesVaultId',
      },
      execute_issue: {
        issueId: 'H256',
        merkleProof: 'Bytes',
        rawTx: 'Bytes',
      },
      cancel_issue: {
        issueId: 'H256',
      },
      set_issue_period: {
        period: 'u32'
      }
    }
  },
  /**
   * Lookup174: redeem::pallet::Call<T>
   **/
  RedeemCall: {
    _enum: {
      request_redeem: {
        amountWrapped: 'Compact<u128>',
        btcAddress: 'BitcoinAddress',
        vaultId: 'InterbtcPrimitivesVaultId',
      },
      liquidation_redeem: {
        currencies: 'InterbtcPrimitivesVaultCurrencyPair',
        amountWrapped: 'Compact<u128>',
      },
      execute_redeem: {
        redeemId: 'H256',
        merkleProof: 'Bytes',
        rawTx: 'Bytes',
      },
      cancel_redeem: {
        redeemId: 'H256',
        reimburse: 'bool',
      },
      set_redeem_period: {
        period: 'u32',
      },
      mint_tokens_for_reimbursed_redeem: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        redeemId: 'H256'
      }
    }
  },
  /**
   * Lookup175: replace::pallet::Call<T>
   **/
  ReplaceCall: {
    _enum: {
      request_replace: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        amount: 'Compact<u128>',
      },
      withdraw_replace: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        amount: 'Compact<u128>',
      },
      accept_replace: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
        oldVault: 'InterbtcPrimitivesVaultId',
        amountBtc: 'Compact<u128>',
        collateral: 'Compact<u128>',
        btcAddress: 'BitcoinAddress',
      },
      execute_replace: {
        replaceId: 'H256',
        merkleProof: 'Bytes',
        rawTx: 'Bytes',
      },
      cancel_replace: {
        replaceId: 'H256',
      },
      set_replace_period: {
        period: 'u32'
      }
    }
  },
  /**
   * Lookup176: fee::pallet::Call<T>
   **/
  FeeCall: {
    _enum: {
      withdraw_rewards: {
        vaultId: 'InterbtcPrimitivesVaultId',
        index: 'Option<u32>',
      },
      set_issue_fee: {
        fee: 'u128',
      },
      set_issue_griefing_collateral: {
        griefingCollateral: 'u128',
      },
      set_redeem_fee: {
        fee: 'u128',
      },
      set_refund_fee: {
        fee: 'u128',
      },
      set_premium_redeem_fee: {
        fee: 'u128',
      },
      set_punishment_fee: {
        fee: 'u128',
      },
      set_replace_griefing_collateral: {
        griefingCollateral: 'u128'
      }
    }
  },
  /**
   * Lookup177: refund::pallet::Call<T>
   **/
  RefundCall: {
    _enum: {
      execute_refund: {
        refundId: 'H256',
        merkleProof: 'Bytes',
        rawTx: 'Bytes',
      },
      set_refund_transaction_size: {
        _alias: {
          size_: 'size',
        },
        size_: 'u32'
      }
    }
  },
  /**
   * Lookup178: nomination::pallet::Call<T>
   **/
  NominationCall: {
    _enum: {
      set_nomination_enabled: {
        enabled: 'bool',
      },
      opt_in_to_nomination: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
      },
      opt_out_of_nomination: {
        currencyPair: 'InterbtcPrimitivesVaultCurrencyPair',
      },
      deposit_collateral: {
        vaultId: 'InterbtcPrimitivesVaultId',
        amount: 'u128',
      },
      withdraw_collateral: {
        vaultId: 'InterbtcPrimitivesVaultId',
        amount: 'u128',
        index: 'Option<u32>'
      }
    }
  },
  /**
   * Lookup179: pallet_identity::pallet::Call<T>
   **/
  PalletIdentityCall: {
    _enum: {
      add_registrar: {
        account: 'AccountId32',
      },
      set_identity: {
        info: 'PalletIdentityIdentityInfo',
      },
      set_subs: {
        subs: 'Vec<(AccountId32,Data)>',
      },
      clear_identity: 'Null',
      request_judgement: {
        regIndex: 'Compact<u32>',
        maxFee: 'Compact<u128>',
      },
      cancel_request: {
        regIndex: 'u32',
      },
      set_fee: {
        index: 'Compact<u32>',
        fee: 'Compact<u128>',
      },
      set_account_id: {
        _alias: {
          new_: 'new',
        },
        index: 'Compact<u32>',
        new_: 'AccountId32',
      },
      set_fields: {
        index: 'Compact<u32>',
        fields: 'PalletIdentityBitFlags',
      },
      provide_judgement: {
        regIndex: 'Compact<u32>',
        target: 'AccountId32',
        judgement: 'PalletIdentityJudgement',
      },
      kill_identity: {
        target: 'AccountId32',
      },
      add_sub: {
        sub: 'AccountId32',
        data: 'Data',
      },
      rename_sub: {
        sub: 'AccountId32',
        data: 'Data',
      },
      remove_sub: {
        sub: 'AccountId32',
      },
      quit_sub: 'Null'
    }
  },
  /**
   * Lookup180: pallet_identity::types::IdentityInfo<FieldLimit>
   **/
  PalletIdentityIdentityInfo: {
    additional: 'Vec<(Data,Data)>',
    display: 'Data',
    legal: 'Data',
    web: 'Data',
    riot: 'Data',
    email: 'Data',
    pgpFingerprint: 'Option<[u8;20]>',
    image: 'Data',
    twitter: 'Data'
  },
  /**
   * Lookup217: pallet_identity::types::BitFlags<pallet_identity::types::IdentityField>
   **/
  PalletIdentityBitFlags: {
    _bitLength: 64,
    Display: 1,
    Legal: 2,
    Web: 4,
    Riot: 8,
    Email: 16,
    PgpFingerprint: 32,
    Image: 64,
    Twitter: 128
  },
  /**
   * Lookup218: pallet_identity::types::IdentityField
   **/
  PalletIdentityIdentityField: {
    _enum: ['__Unused0', 'Display', 'Legal', '__Unused3', 'Web', '__Unused5', '__Unused6', '__Unused7', 'Riot', '__Unused9', '__Unused10', '__Unused11', '__Unused12', '__Unused13', '__Unused14', '__Unused15', 'Email', '__Unused17', '__Unused18', '__Unused19', '__Unused20', '__Unused21', '__Unused22', '__Unused23', '__Unused24', '__Unused25', '__Unused26', '__Unused27', '__Unused28', '__Unused29', '__Unused30', '__Unused31', 'PgpFingerprint', '__Unused33', '__Unused34', '__Unused35', '__Unused36', '__Unused37', '__Unused38', '__Unused39', '__Unused40', '__Unused41', '__Unused42', '__Unused43', '__Unused44', '__Unused45', '__Unused46', '__Unused47', '__Unused48', '__Unused49', '__Unused50', '__Unused51', '__Unused52', '__Unused53', '__Unused54', '__Unused55', '__Unused56', '__Unused57', '__Unused58', '__Unused59', '__Unused60', '__Unused61', '__Unused62', '__Unused63', 'Image', '__Unused65', '__Unused66', '__Unused67', '__Unused68', '__Unused69', '__Unused70', '__Unused71', '__Unused72', '__Unused73', '__Unused74', '__Unused75', '__Unused76', '__Unused77', '__Unused78', '__Unused79', '__Unused80', '__Unused81', '__Unused82', '__Unused83', '__Unused84', '__Unused85', '__Unused86', '__Unused87', '__Unused88', '__Unused89', '__Unused90', '__Unused91', '__Unused92', '__Unused93', '__Unused94', '__Unused95', '__Unused96', '__Unused97', '__Unused98', '__Unused99', '__Unused100', '__Unused101', '__Unused102', '__Unused103', '__Unused104', '__Unused105', '__Unused106', '__Unused107', '__Unused108', '__Unused109', '__Unused110', '__Unused111', '__Unused112', '__Unused113', '__Unused114', '__Unused115', '__Unused116', '__Unused117', '__Unused118', '__Unused119', '__Unused120', '__Unused121', '__Unused122', '__Unused123', '__Unused124', '__Unused125', '__Unused126', '__Unused127', 'Twitter']
  },
  /**
   * Lookup219: pallet_identity::types::Judgement<Balance>
   **/
  PalletIdentityJudgement: {
    _enum: {
      Unknown: 'Null',
      FeePaid: 'u128',
      Reasonable: 'Null',
      KnownGood: 'Null',
      OutOfDate: 'Null',
      LowQuality: 'Null',
      Erroneous: 'Null'
    }
  },
  /**
   * Lookup220: democracy::pallet::Call<T>
   **/
  DemocracyCall: {
    _enum: {
      propose: {
        proposalHash: 'H256',
        value: 'Compact<u128>',
      },
      second: {
        proposal: 'Compact<u32>',
        secondsUpperBound: 'Compact<u32>',
      },
      vote: {
        refIndex: 'Compact<u32>',
        vote: 'DemocracyVote',
      },
      fast_track: {
        propIndex: 'Compact<u32>',
        delay: 'u32',
      },
      fast_track_default: {
        propIndex: 'Compact<u32>',
        delay: 'u32',
      },
      fast_track_referendum: {
        refIndex: 'Compact<u32>',
      },
      cancel_referendum: {
        refIndex: 'Compact<u32>',
      },
      cancel_queued: {
        which: 'u32',
      },
      clear_public_proposals: 'Null',
      cancel_proposal: {
        propIndex: 'Compact<u32>',
      },
      note_preimage: {
        encodedProposal: 'Bytes',
      },
      note_imminent_preimage: {
        encodedProposal: 'Bytes',
      },
      reap_preimage: {
        proposalHash: 'H256',
        proposalLenUpperBound: 'Compact<u32>',
      },
      remove_vote: {
        index: 'u32',
      },
      enact_proposal: {
        proposalHash: 'H256',
        index: 'u32'
      }
    }
  },
  /**
   * Lookup221: democracy::types::Vote<Balance>
   **/
  DemocracyVote: {
    aye: 'bool',
    balance: 'u128'
  },
  /**
   * Lookup222: pallet_collective::pallet::Call<T, I>
   **/
  PalletCollectiveCall: {
    _enum: {
      set_members: {
        newMembers: 'Vec<AccountId32>',
        prime: 'Option<AccountId32>',
        oldCount: 'u32',
      },
      execute: {
        proposal: 'Call',
        lengthBound: 'Compact<u32>',
      },
      propose: {
        threshold: 'Compact<u32>',
        proposal: 'Call',
        lengthBound: 'Compact<u32>',
      },
      vote: {
        proposal: 'H256',
        index: 'Compact<u32>',
        approve: 'bool',
      },
      close: {
        proposalHash: 'H256',
        index: 'Compact<u32>',
        proposalWeightBound: 'Compact<u64>',
        lengthBound: 'Compact<u32>',
      },
      disapprove_proposal: {
        proposalHash: 'H256'
      }
    }
  },
  /**
   * Lookup223: pallet_membership::pallet::Call<T, I>
   **/
  PalletMembershipCall: {
    _enum: {
      add_member: {
        who: 'AccountId32',
      },
      remove_member: {
        who: 'AccountId32',
      },
      swap_member: {
        remove: 'AccountId32',
        add: 'AccountId32',
      },
      reset_members: {
        members: 'Vec<AccountId32>',
      },
      change_key: {
        _alias: {
          new_: 'new',
        },
        new_: 'AccountId32',
      },
      set_prime: {
        who: 'AccountId32',
      },
      clear_prime: 'Null'
    }
  },
  /**
   * Lookup224: pallet_treasury::pallet::Call<T, I>
   **/
  PalletTreasuryCall: {
    _enum: {
      propose_spend: {
        value: 'Compact<u128>',
        beneficiary: 'AccountId32',
      },
      reject_proposal: {
        proposalId: 'Compact<u32>',
      },
      approve_proposal: {
        proposalId: 'Compact<u32>',
      },
      remove_approval: {
        proposalId: 'Compact<u32>'
      }
    }
  },
  /**
   * Lookup225: pallet_authorship::pallet::Call<T>
   **/
  PalletAuthorshipCall: {
    _enum: {
      set_uncles: {
        newUncles: 'Vec<SpRuntimeHeader>'
      }
    }
  },
  /**
   * Lookup227: sp_runtime::generic::header::Header<Number, sp_runtime::traits::BlakeTwo256>
   **/
  SpRuntimeHeader: {
    parentHash: 'H256',
    number: 'Compact<u32>',
    stateRoot: 'H256',
    extrinsicsRoot: 'H256',
    digest: 'SpRuntimeDigest'
  },
  /**
   * Lookup228: sp_runtime::traits::BlakeTwo256
   **/
  SpRuntimeBlakeTwo256: 'Null',
  /**
   * Lookup229: pallet_grandpa::pallet::Call<T>
   **/
  PalletGrandpaCall: {
    _enum: {
      report_equivocation: {
        equivocationProof: 'SpFinalityGrandpaEquivocationProof',
        keyOwnerProof: 'SpCoreVoid',
      },
      report_equivocation_unsigned: {
        equivocationProof: 'SpFinalityGrandpaEquivocationProof',
        keyOwnerProof: 'SpCoreVoid',
      },
      note_stalled: {
        delay: 'u32',
        bestFinalizedBlockNumber: 'u32'
      }
    }
  },
  /**
   * Lookup230: sp_finality_grandpa::EquivocationProof<primitive_types::H256, N>
   **/
  SpFinalityGrandpaEquivocationProof: {
    setId: 'u64',
    equivocation: 'SpFinalityGrandpaEquivocation'
  },
  /**
   * Lookup231: sp_finality_grandpa::Equivocation<primitive_types::H256, N>
   **/
  SpFinalityGrandpaEquivocation: {
    _enum: {
      Prevote: 'FinalityGrandpaEquivocationPrevote',
      Precommit: 'FinalityGrandpaEquivocationPrecommit'
    }
  },
  /**
   * Lookup232: finality_grandpa::Equivocation<sp_finality_grandpa::app::Public, finality_grandpa::Prevote<primitive_types::H256, N>, sp_finality_grandpa::app::Signature>
   **/
  FinalityGrandpaEquivocationPrevote: {
    roundNumber: 'u64',
    identity: 'SpFinalityGrandpaAppPublic',
    first: '(FinalityGrandpaPrevote,SpFinalityGrandpaAppSignature)',
    second: '(FinalityGrandpaPrevote,SpFinalityGrandpaAppSignature)'
  },
  /**
   * Lookup233: finality_grandpa::Prevote<primitive_types::H256, N>
   **/
  FinalityGrandpaPrevote: {
    targetHash: 'H256',
    targetNumber: 'u32'
  },
  /**
   * Lookup234: sp_finality_grandpa::app::Signature
   **/
  SpFinalityGrandpaAppSignature: 'SpCoreEd25519Signature',
  /**
   * Lookup235: sp_core::ed25519::Signature
   **/
  SpCoreEd25519Signature: '[u8;64]',
  /**
   * Lookup238: finality_grandpa::Equivocation<sp_finality_grandpa::app::Public, finality_grandpa::Precommit<primitive_types::H256, N>, sp_finality_grandpa::app::Signature>
   **/
  FinalityGrandpaEquivocationPrecommit: {
    roundNumber: 'u64',
    identity: 'SpFinalityGrandpaAppPublic',
    first: '(FinalityGrandpaPrecommit,SpFinalityGrandpaAppSignature)',
    second: '(FinalityGrandpaPrecommit,SpFinalityGrandpaAppSignature)'
  },
  /**
   * Lookup239: finality_grandpa::Precommit<primitive_types::H256, N>
   **/
  FinalityGrandpaPrecommit: {
    targetHash: 'H256',
    targetNumber: 'u32'
  },
  /**
   * Lookup241: pallet_sudo::pallet::Error<T>
   **/
  PalletSudoError: {
    _enum: ['RequireSudo']
  },
  /**
   * Lookup242: pallet_utility::pallet::Error<T>
   **/
  PalletUtilityError: {
    _enum: ['TooManyCalls']
  },
  /**
   * Lookup243: pallet_transaction_payment::Releases
   **/
  PalletTransactionPaymentReleases: {
    _enum: ['V1Ancient', 'V2']
  },
  /**
   * Lookup246: pallet_scheduler::ScheduledV3<frame_support::traits::schedule::MaybeHashed<interbtc_runtime_standalone::Call, primitive_types::H256>, BlockNumber, interbtc_runtime_standalone::OriginCaller, sp_core::crypto::AccountId32>
   **/
  PalletSchedulerScheduledV3: {
    maybeId: 'Option<Bytes>',
    priority: 'u8',
    call: 'FrameSupportScheduleMaybeHashed',
    maybePeriodic: 'Option<(u32,u32)>',
    origin: 'InterbtcRuntimeStandaloneOriginCaller'
  },
  /**
   * Lookup247: pallet_scheduler::pallet::Error<T>
   **/
  PalletSchedulerError: {
    _enum: ['FailedToSchedule', 'NotFound', 'TargetBlockNumberInPast', 'RescheduleNoChange']
  },
  /**
   * Lookup248: pallet_preimage::RequestStatus<sp_core::crypto::AccountId32, Balance>
   **/
  PalletPreimageRequestStatus: {
    _enum: {
      Unrequested: 'Option<(AccountId32,u128)>',
      Requested: 'u32'
    }
  },
  /**
   * Lookup252: pallet_preimage::pallet::Error<T>
   **/
  PalletPreimageError: {
    _enum: ['TooLarge', 'AlreadyNoted', 'NotAuthorized', 'NotNoted', 'Requested', 'NotRequested']
  },
  /**
   * Lookup254: pallet_multisig::Multisig<BlockNumber, Balance, sp_core::crypto::AccountId32>
   **/
  PalletMultisigMultisig: {
    when: 'PalletMultisigTimepoint',
    deposit: 'u128',
    depositor: 'AccountId32',
    approvals: 'Vec<AccountId32>'
  },
  /**
   * Lookup256: pallet_multisig::pallet::Error<T>
   **/
  PalletMultisigError: {
    _enum: ['MinimumThreshold', 'AlreadyApproved', 'NoApprovalsNeeded', 'TooFewSignatories', 'TooManySignatories', 'SignatoriesOutOfOrder', 'SenderInSignatories', 'NotFound', 'NotOwner', 'NoTimepoint', 'WrongTimepoint', 'UnexpectedTimepoint', 'MaxWeightTooLow', 'AlreadyStored']
  },
  /**
   * Lookup257: currency::pallet::Error<T>
   **/
  CurrencyError: {
    _enum: ['ArithmeticOverflow', 'ArithmeticUnderflow', 'TryIntoIntError', 'InvalidCurrency']
  },
  /**
   * Lookup260: orml_tokens::BalanceLock<Balance>
   **/
  OrmlTokensBalanceLock: {
    id: '[u8;8]',
    amount: 'u128'
  },
  /**
   * Lookup262: orml_tokens::AccountData<Balance>
   **/
  OrmlTokensAccountData: {
    free: 'u128',
    reserved: 'u128',
    frozen: 'u128'
  },
  /**
   * Lookup264: orml_tokens::ReserveData<ReserveIdentifier, Balance>
   **/
  OrmlTokensReserveData: {
    id: 'Null',
    amount: 'u128'
  },
  /**
   * Lookup266: orml_tokens::module::Error<T>
   **/
  OrmlTokensModuleError: {
    _enum: ['BalanceTooLow', 'AmountIntoBalanceFailed', 'LiquidityRestrictions', 'MaxLocksExceeded', 'KeepAlive', 'ExistentialDeposit', 'DeadAccount', 'TooManyReserves']
  },
  /**
   * Lookup267: escrow::LockedBalance<Balance, BlockNumber>
   **/
  EscrowLockedBalance: {
    amount: 'u128',
    end: 'u32'
  },
  /**
   * Lookup268: escrow::Point<Balance, BlockNumber>
   **/
  EscrowPoint: {
    bias: 'u128',
    slope: 'u128',
    ts: 'u32'
  },
  /**
   * Lookup270: escrow::pallet::Error<T>
   **/
  EscrowError: {
    _enum: ['InputAmountZero', 'LockFound', 'LockNotFound', 'UnlockHeightNotInTheFuture', 'UnlockHeightTooFarInTheFuture', 'LockAmountZero', 'UnlockHeightMustIncrease', 'LockNotExpired', 'LockHasExpired', 'LockAmountTooLow', 'InsufficientFunds', 'NotSupported']
  },
  /**
   * Lookup272: orml_vesting::module::Error<T>
   **/
  OrmlVestingModuleError: {
    _enum: ['ZeroVestingPeriod', 'ZeroVestingPeriodCount', 'InsufficientBalanceToLock', 'TooManyVestingSchedules', 'AmountLow', 'MaxVestingSchedulesExceeded']
  },
  /**
   * Lookup273: orml_asset_registry::module::Error<T>
   **/
  OrmlAssetRegistryModuleError: {
    _enum: ['AssetNotFound', 'BadVersion', 'InvalidAssetId', 'ConflictingLocation', 'ConflictingAssetId']
  },
  /**
   * Lookup274: frame_support::PalletId
   **/
  FrameSupportPalletId: '[u8;8]',
  /**
   * Lookup275: annuity::pallet::Error<T, I>
   **/
  AnnuityError: 'Null',
  /**
   * Lookup277: reward::pallet::Error<T, I>
   **/
  RewardError: {
    _enum: ['TryIntoIntError', 'InsufficientFunds', 'ZeroTotalStake']
  },
  /**
   * Lookup287: staking::pallet::Error<T>
   **/
  StakingError: {
    _enum: ['TryIntoIntError', 'InsufficientFunds', 'SlashZeroTotalStake']
  },
  /**
   * Lookup288: supply::pallet::Error<T>
   **/
  SupplyError: 'Null',
  /**
   * Lookup289: btc_relay::types::RichBlockHeader<BlockNumber>
   **/
  BtcRelayRichBlockHeader: {
    blockHeader: 'BitcoinBlockHeader',
    blockHeight: 'u32',
    chainId: 'u32',
    paraHeight: 'u32'
  },
  /**
   * Lookup290: bitcoin::types::BlockHeader
   **/
  BitcoinBlockHeader: {
    _alias: {
      hash_: 'hash'
    },
    merkleRoot: 'BitcoinH256Le',
    target: 'U256',
    timestamp: 'u32',
    version: 'i32',
    hash_: 'BitcoinH256Le',
    hashPrevBlock: 'BitcoinH256Le',
    nonce: 'u32'
  },
  /**
   * Lookup294: bitcoin::types::BlockChain
   **/
  BitcoinBlockChain: {
    chainId: 'u32',
    startHeight: 'u32',
    maxHeight: 'u32'
  },
  /**
   * Lookup295: btc_relay::pallet::Error<T>
   **/
  BtcRelayError: {
    _enum: ['AlreadyInitialized', 'InvalidStartHeight', 'MissingBlockHeight', 'InvalidHeaderSize', 'DuplicateBlock', 'PrevBlock', 'InvalidChainID', 'LowDiff', 'DiffTargetHeader', 'MalformedTxid', 'BitcoinConfirmations', 'ParachainConfirmations', 'OngoingFork', 'MalformedMerkleProof', 'InvalidMerkleProof', 'Shutdown', 'InvalidTxid', 'InvalidPaymentAmount', 'MalformedTransaction', 'InvalidPayment', 'InvalidOutputFormat', 'InvalidOpReturn', 'InvalidTxVersion', 'UnknownErrorcode', 'ForkIdNotFound', 'BlockNotFound', 'AlreadyReported', 'UnauthorizedRelayer', 'ChainCounterOverflow', 'BlockHeightOverflow', 'ChainsUnderflow', 'EndOfFile', 'MalformedHeader', 'InvalidBlockVersion', 'MalformedWitnessOutput', 'MalformedP2PKHOutput', 'MalformedP2SHOutput', 'MalformedOpReturnOutput', 'UnsupportedOutputFormat', 'UnsupportedInputFormat', 'InvalidBtcHash', 'InvalidScript', 'InvalidBtcAddress', 'ArithmeticOverflow', 'ArithmeticUnderflow', 'TryIntoIntError', 'InvalidTransaction', 'InvalidOpReturnTransaction', 'InvalidCompact']
  },
  /**
   * Lookup297: security::pallet::Error<T>
   **/
  SecurityError: {
    _enum: ['ParachainNotRunning']
  },
  /**
   * Lookup298: vault_registry::types::SystemVault<Balance, interbtc_primitives::CurrencyId>
   **/
  VaultRegistrySystemVault: {
    toBeIssuedTokens: 'u128',
    issuedTokens: 'u128',
    toBeRedeemedTokens: 'u128',
    collateral: 'u128',
    currencyPair: 'InterbtcPrimitivesVaultCurrencyPair'
  },
  /**
   * Lookup299: vault_registry::types::Vault<sp_core::crypto::AccountId32, BlockNumber, Balance, interbtc_primitives::CurrencyId, sp_arithmetic::fixed_point::FixedU128>
   **/
  VaultRegistryVault: {
    id: 'InterbtcPrimitivesVaultId',
    status: 'VaultRegistryVaultStatus',
    bannedUntil: 'Option<u32>',
    secureCollateralThreshold: 'Option<u128>',
    toBeIssuedTokens: 'u128',
    issuedTokens: 'u128',
    toBeRedeemedTokens: 'u128',
    toBeReplacedTokens: 'u128',
    replaceCollateral: 'u128',
    activeReplaceCollateral: 'u128',
    liquidatedCollateral: 'u128'
  },
  /**
   * Lookup301: vault_registry::types::Version
   **/
  VaultRegistryVersion: {
    _enum: ['V0', 'V1', 'V2', 'V3', 'V4', 'V5', 'V6']
  },
  /**
   * Lookup302: vault_registry::pallet::Error<T>
   **/
  VaultRegistryError: {
    _enum: ['InsufficientCollateral', 'ExceedingVaultLimit', 'InsufficientTokensCommitted', 'VaultBanned', 'InsufficientVaultCollateralAmount', 'VaultAlreadyRegistered', 'VaultNotFound', 'ReservedDepositAddress', 'VaultNotBelowLiquidationThreshold', 'InvalidPublicKey', 'MaxNominationRatioViolation', 'CurrencyCeilingExceeded', 'VaultLiquidated', 'VaultNotRecoverable', 'NoBitcoinPublicKey', 'PublicKeyAlreadyRegistered', 'NoTokensIssued', 'NoVaultWithSufficientCollateral', 'NoVaultWithSufficientTokens', 'NoVaultUnderThePremiumRedeemThreshold', 'InvalidCurrency', 'ThresholdNotSet', 'CeilingNotSet', 'ThresholdNotAboveGlobalThreshold', 'ArithmeticOverflow', 'ArithmeticUnderflow', 'TryIntoIntError']
  },
  /**
   * Lookup304: oracle::TimestampedValue<sp_arithmetic::fixed_point::FixedU128, Moment>
   **/
  OracleTimestampedValue: {
    value: 'u128',
    timestamp: 'u64'
  },
  /**
   * Lookup305: oracle::types::Version
   **/
  OracleVersion: {
    _enum: ['V0', 'V1']
  },
  /**
   * Lookup306: oracle::pallet::Error<T>
   **/
  OracleError: {
    _enum: ['InvalidOracleSource', 'MissingExchangeRate', 'TryIntoIntError', 'ArithmeticOverflow', 'ArithmeticUnderflow']
  },
  /**
   * Lookup307: interbtc_primitives::issue::IssueRequest<sp_core::crypto::AccountId32, BlockNumber, Balance, interbtc_primitives::CurrencyId>
   **/
  InterbtcPrimitivesIssueIssueRequest: {
    vault: 'InterbtcPrimitivesVaultId',
    opentime: 'u32',
    period: 'u32',
    griefingCollateral: 'u128',
    amount: 'u128',
    fee: 'u128',
    requester: 'AccountId32',
    btcAddress: 'BitcoinAddress',
    btcPublicKey: 'BitcoinAddressPublicKey',
    btcHeight: 'u32',
    status: 'InterbtcPrimitivesIssueIssueRequestStatus'
  },
  /**
   * Lookup308: interbtc_primitives::issue::IssueRequestStatus
   **/
  InterbtcPrimitivesIssueIssueRequestStatus: {
    _enum: {
      Pending: 'Null',
      Completed: 'Option<H256>',
      Cancelled: 'Null'
    }
  },
  /**
   * Lookup309: issue::types::Version
   **/
  IssueVersion: {
    _enum: ['V0', 'V1', 'V2', 'V3']
  },
  /**
   * Lookup310: issue::pallet::Error<T>
   **/
  IssueError: {
    _enum: ['IssueIdNotFound', 'CommitPeriodExpired', 'TimeNotExpired', 'IssueCompleted', 'IssueCancelled', 'VaultNotAcceptingNewIssues', 'WaitingForRelayerInitialization', 'InvalidExecutor', 'AmountBelowDustAmount']
  },
  /**
   * Lookup311: interbtc_primitives::redeem::RedeemRequest<sp_core::crypto::AccountId32, BlockNumber, Balance, interbtc_primitives::CurrencyId>
   **/
  InterbtcPrimitivesRedeemRedeemRequest: {
    vault: 'InterbtcPrimitivesVaultId',
    opentime: 'u32',
    period: 'u32',
    fee: 'u128',
    transferFeeBtc: 'u128',
    amountBtc: 'u128',
    premium: 'u128',
    redeemer: 'AccountId32',
    btcAddress: 'BitcoinAddress',
    btcHeight: 'u32',
    status: 'InterbtcPrimitivesRedeemRedeemRequestStatus'
  },
  /**
   * Lookup312: redeem::types::Version
   **/
  RedeemVersion: {
    _enum: ['V0', 'V1', 'V2', 'V3']
  },
  /**
   * Lookup313: redeem::pallet::Error<T>
   **/
  RedeemError: {
    _enum: ['AmountExceedsUserBalance', 'UnauthorizedRedeemer', 'UnauthorizedVault', 'TimeNotExpired', 'RedeemCancelled', 'RedeemCompleted', 'RedeemIdNotFound', 'TryIntoIntError', 'AmountBelowDustAmount']
  },
  /**
   * Lookup314: interbtc_primitives::replace::ReplaceRequest<sp_core::crypto::AccountId32, BlockNumber, Balance, interbtc_primitives::CurrencyId>
   **/
  InterbtcPrimitivesReplaceReplaceRequest: {
    oldVault: 'InterbtcPrimitivesVaultId',
    newVault: 'InterbtcPrimitivesVaultId',
    amount: 'u128',
    griefingCollateral: 'u128',
    collateral: 'u128',
    acceptTime: 'u32',
    period: 'u32',
    btcAddress: 'BitcoinAddress',
    btcHeight: 'u32',
    status: 'InterbtcPrimitivesReplaceReplaceRequestStatus'
  },
  /**
   * Lookup315: interbtc_primitives::replace::ReplaceRequestStatus
   **/
  InterbtcPrimitivesReplaceReplaceRequestStatus: {
    _enum: ['Pending', 'Completed', 'Cancelled']
  },
  /**
   * Lookup316: replace::types::Version
   **/
  ReplaceVersion: {
    _enum: ['V0', 'V1', 'V2', 'V3']
  },
  /**
   * Lookup317: replace::pallet::Error<T>
   **/
  ReplaceError: {
    _enum: ['ReplaceAmountZero', 'AmountBelowDustAmount', 'NoPendingRequest', 'UnauthorizedVault', 'ReplaceSelfNotAllowed', 'VaultHasEnabledNomination', 'ReplacePeriodNotExpired', 'ReplaceCompleted', 'ReplaceCancelled', 'ReplaceIdNotFound', 'InvalidWrappedCurrency']
  },
  /**
   * Lookup318: fee::types::Version
   **/
  FeeVersion: {
    _enum: ['V0', 'V1']
  },
  /**
   * Lookup319: fee::pallet::Error<T>
   **/
  FeeError: {
    _enum: ['TryIntoIntError', 'AboveMaxExpectedValue']
  },
  /**
   * Lookup320: interbtc_primitives::refund::RefundRequest<sp_core::crypto::AccountId32, Balance, interbtc_primitives::CurrencyId>
   **/
  InterbtcPrimitivesRefundRefundRequest: {
    vault: 'InterbtcPrimitivesVaultId',
    amountBtc: 'u128',
    fee: 'u128',
    transferFeeBtc: 'u128',
    issuer: 'AccountId32',
    btcAddress: 'BitcoinAddress',
    issueId: 'H256',
    completed: 'bool'
  },
  /**
   * Lookup321: refund::pallet::Error<T>
   **/
  RefundError: {
    _enum: ['ArithmeticUnderflow', 'ArithmeticOverflow', 'NoRefundFoundForIssueId', 'RefundIdNotFound', 'RefundCompleted', 'TryIntoIntError', 'UnauthorizedVault']
  },
  /**
   * Lookup322: nomination::pallet::Error<T>
   **/
  NominationError: {
    _enum: ['VaultAlreadyOptedInToNomination', 'VaultNotOptedInToNomination', 'VaultNotFound', 'CannotWithdrawCollateral', 'VaultNominationDisabled', 'DepositViolatesMaxNominationRatio', 'CollateralizationTooLow']
  },
  /**
   * Lookup323: pallet_identity::types::Registration<Balance, MaxJudgements, MaxAdditionalFields>
   **/
  PalletIdentityRegistration: {
    judgements: 'Vec<(u32,PalletIdentityJudgement)>',
    deposit: 'u128',
    info: 'PalletIdentityIdentityInfo'
  },
  /**
   * Lookup331: pallet_identity::types::RegistrarInfo<Balance, sp_core::crypto::AccountId32>
   **/
  PalletIdentityRegistrarInfo: {
    account: 'AccountId32',
    fee: 'u128',
    fields: 'PalletIdentityBitFlags'
  },
  /**
   * Lookup333: pallet_identity::pallet::Error<T>
   **/
  PalletIdentityError: {
    _enum: ['TooManySubAccounts', 'NotFound', 'NotNamed', 'EmptyIndex', 'FeeChanged', 'NoIdentity', 'StickyJudgement', 'JudgementGiven', 'InvalidJudgement', 'InvalidIndex', 'InvalidTarget', 'TooManyFields', 'TooManyRegistrars', 'AlreadyClaimed', 'NotSub', 'NotOwned']
  },
  /**
   * Lookup337: democracy::PreimageStatus<sp_core::crypto::AccountId32, Balance, BlockNumber>
   **/
  DemocracyPreimageStatus: {
    _enum: {
      Missing: 'u32',
      Available: {
        data: 'Bytes',
        provider: 'AccountId32',
        deposit: 'u128',
        since: 'u32',
        expiry: 'Option<u32>'
      }
    }
  },
  /**
   * Lookup338: democracy::types::ReferendumInfo<BlockNumber, primitive_types::H256, Balance>
   **/
  DemocracyReferendumInfo: {
    _enum: {
      Ongoing: 'DemocracyReferendumStatus',
      Finished: {
        approved: 'bool',
        end: 'u32'
      }
    }
  },
  /**
   * Lookup339: democracy::types::ReferendumStatus<BlockNumber, primitive_types::H256, Balance>
   **/
  DemocracyReferendumStatus: {
    end: 'u32',
    proposalHash: 'H256',
    threshold: 'DemocracyVoteThreshold',
    delay: 'u32',
    tally: 'DemocracyTally'
  },
  /**
   * Lookup340: democracy::types::Tally<Balance>
   **/
  DemocracyTally: {
    ayes: 'u128',
    nays: 'u128',
    turnout: 'u128'
  },
  /**
   * Lookup341: democracy::types::Voting<Balance>
   **/
  DemocracyVoting: {
    votes: 'Vec<(u32,DemocracyVote)>'
  },
  /**
   * Lookup344: democracy::Releases
   **/
  DemocracyReleases: {
    _enum: ['V1']
  },
  /**
   * Lookup345: democracy::pallet::Error<T>
   **/
  DemocracyError: {
    _enum: ['ValueLow', 'ProposalMissing', 'DuplicateProposal', 'DuplicatePreimage', 'NotImminent', 'TooEarly', 'Imminent', 'PreimageMissing', 'ReferendumInvalid', 'ReferendumFastTrackFailed', 'PreimageInvalid', 'NoneWaiting', 'NotProposer', 'NotVoter', 'InsufficientFunds', 'WrongUpperBound', 'MaxVotesReached', 'TooManyProposals']
  },
  /**
   * Lookup347: pallet_collective::Votes<sp_core::crypto::AccountId32, BlockNumber>
   **/
  PalletCollectiveVotes: {
    index: 'u32',
    threshold: 'u32',
    ayes: 'Vec<AccountId32>',
    nays: 'Vec<AccountId32>',
    end: 'u32'
  },
  /**
   * Lookup348: pallet_collective::pallet::Error<T, I>
   **/
  PalletCollectiveError: {
    _enum: ['NotMember', 'DuplicateProposal', 'ProposalMissing', 'WrongIndex', 'DuplicateVote', 'AlreadyInitialized', 'TooEarly', 'TooManyProposals', 'WrongProposalWeight', 'WrongProposalLength']
  },
  /**
   * Lookup349: pallet_membership::pallet::Error<T, I>
   **/
  PalletMembershipError: {
    _enum: ['AlreadyMember', 'NotMember']
  },
  /**
   * Lookup350: pallet_treasury::Proposal<sp_core::crypto::AccountId32, Balance>
   **/
  PalletTreasuryProposal: {
    proposer: 'AccountId32',
    value: 'u128',
    beneficiary: 'AccountId32',
    bond: 'u128'
  },
  /**
   * Lookup354: pallet_treasury::pallet::Error<T, I>
   **/
  PalletTreasuryError: {
    _enum: ['InsufficientProposersBalance', 'InvalidIndex', 'TooManyApprovals', 'ProposalNotApproved']
  },
  /**
   * Lookup356: pallet_authorship::UncleEntryItem<BlockNumber, primitive_types::H256, sp_core::crypto::AccountId32>
   **/
  PalletAuthorshipUncleEntryItem: {
    _enum: {
      InclusionHeight: 'u32',
      Uncle: '(H256,Option<AccountId32>)'
    }
  },
  /**
   * Lookup357: pallet_authorship::pallet::Error<T>
   **/
  PalletAuthorshipError: {
    _enum: ['InvalidUncleParent', 'UnclesAlreadySet', 'TooManyUncles', 'GenesisUncle', 'TooHighUncle', 'UncleAlreadyIncluded', 'OldUncle']
  },
  /**
   * Lookup358: pallet_grandpa::StoredState<N>
   **/
  PalletGrandpaStoredState: {
    _enum: {
      Live: 'Null',
      PendingPause: {
        scheduledAt: 'u32',
        delay: 'u32',
      },
      Paused: 'Null',
      PendingResume: {
        scheduledAt: 'u32',
        delay: 'u32'
      }
    }
  },
  /**
   * Lookup359: pallet_grandpa::StoredPendingChange<N, Limit>
   **/
  PalletGrandpaStoredPendingChange: {
    scheduledAt: 'u32',
    delay: 'u32',
    nextAuthorities: 'Vec<(SpFinalityGrandpaAppPublic,u64)>',
    forced: 'Option<u32>'
  },
  /**
   * Lookup361: pallet_grandpa::pallet::Error<T>
   **/
  PalletGrandpaError: {
    _enum: ['PauseFailed', 'ResumeFailed', 'ChangePending', 'TooSoon', 'InvalidKeyOwnershipProof', 'InvalidEquivocationProof', 'DuplicateOffenceReport']
  },
  /**
   * Lookup363: sp_runtime::MultiSignature
   **/
  SpRuntimeMultiSignature: {
    _enum: {
      Ed25519: 'SpCoreEd25519Signature',
      Sr25519: 'SpCoreSr25519Signature',
      Ecdsa: 'SpCoreEcdsaSignature'
    }
  },
  /**
   * Lookup364: sp_core::sr25519::Signature
   **/
  SpCoreSr25519Signature: '[u8;64]',
  /**
   * Lookup365: sp_core::ecdsa::Signature
   **/
  SpCoreEcdsaSignature: '[u8;65]',
  /**
   * Lookup368: frame_system::extensions::check_spec_version::CheckSpecVersion<T>
   **/
  FrameSystemExtensionsCheckSpecVersion: 'Null',
  /**
   * Lookup369: frame_system::extensions::check_tx_version::CheckTxVersion<T>
   **/
  FrameSystemExtensionsCheckTxVersion: 'Null',
  /**
   * Lookup370: frame_system::extensions::check_genesis::CheckGenesis<T>
   **/
  FrameSystemExtensionsCheckGenesis: 'Null',
  /**
   * Lookup373: frame_system::extensions::check_nonce::CheckNonce<T>
   **/
  FrameSystemExtensionsCheckNonce: 'Compact<u32>',
  /**
   * Lookup374: frame_system::extensions::check_weight::CheckWeight<T>
   **/
  FrameSystemExtensionsCheckWeight: 'Null',
  /**
   * Lookup375: pallet_transaction_payment::ChargeTransactionPayment<T>
   **/
  PalletTransactionPaymentChargeTransactionPayment: 'Compact<u128>',
  /**
   * Lookup376: interbtc_runtime_standalone::Runtime
   **/
  InterbtcRuntimeStandaloneRuntime: 'Null'
};
