@argonprotocol/mainchain 1.4.3-dev.1523df53 → 1.4.3-dev.25eec055

package/src/interfaces/lookup.ts

@@ -0,0 +1,3797 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+
+export default {
+  /**
+   * Lookup3: frame_system::AccountInfo<Nonce, pallet_balances::types::AccountData<Balance>>
+   **/
+  FrameSystemAccountInfo: {
+    nonce: 'u32',
+    consumers: 'u32',
+    providers: 'u32',
+    sufficients: 'u32',
+    data: 'PalletBalancesAccountData',
+  },
+  /**
+   * Lookup5: pallet_balances::types::AccountData<Balance>
+   **/
+  PalletBalancesAccountData: {
+    free: 'u128',
+    reserved: 'u128',
+    frozen: 'u128',
+    flags: 'u128',
+  },
+  /**
+   * Lookup9: frame_support::dispatch::PerDispatchClass<sp_weights::weight_v2::Weight>
+   **/
+  FrameSupportDispatchPerDispatchClassWeight: {
+    normal: 'SpWeightsWeightV2Weight',
+    operational: 'SpWeightsWeightV2Weight',
+    mandatory: 'SpWeightsWeightV2Weight',
+  },
+  /**
+   * Lookup10: sp_weights::weight_v2::Weight
+   **/
+  SpWeightsWeightV2Weight: {
+    refTime: 'Compact<u64>',
+    proofSize: 'Compact<u64>',
+  },
+  /**
+   * Lookup15: sp_runtime::generic::digest::Digest
+   **/
+  SpRuntimeDigest: {
+    logs: 'Vec<SpRuntimeDigestDigestItem>',
+  },
+  /**
+   * Lookup17: 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',
+    },
+  },
+  /**
+   * Lookup20: frame_system::EventRecord<argon_runtime::RuntimeEvent, primitive_types::H256>
+   **/
+  FrameSystemEventRecord: {
+    phase: 'FrameSystemPhase',
+    event: 'Event',
+    topics: 'Vec<H256>',
+  },
+  /**
+   * Lookup22: frame_system::pallet::Event<T>
+   **/
+  FrameSystemEvent: {
+    _enum: {
+      ExtrinsicSuccess: {
+        dispatchInfo: 'FrameSystemDispatchEventInfo',
+      },
+      ExtrinsicFailed: {
+        dispatchError: 'SpRuntimeDispatchError',
+        dispatchInfo: 'FrameSystemDispatchEventInfo',
+      },
+      CodeUpdated: 'Null',
+      NewAccount: {
+        account: 'AccountId32',
+      },
+      KilledAccount: {
+        account: 'AccountId32',
+      },
+      Remarked: {
+        _alias: {
+          hash_: 'hash',
+        },
+        sender: 'AccountId32',
+        hash_: 'H256',
+      },
+      UpgradeAuthorized: {
+        codeHash: 'H256',
+        checkVersion: 'bool',
+      },
+      RejectedInvalidAuthorizedUpgrade: {
+        codeHash: 'H256',
+        error: 'SpRuntimeDispatchError',
+      },
+    },
+  },
+  /**
+   * Lookup23: frame_system::DispatchEventInfo
+   **/
+  FrameSystemDispatchEventInfo: {
+    weight: 'SpWeightsWeightV2Weight',
+    class: 'FrameSupportDispatchDispatchClass',
+    paysFee: 'FrameSupportDispatchPays',
+  },
+  /**
+   * Lookup24: frame_support::dispatch::DispatchClass
+   **/
+  FrameSupportDispatchDispatchClass: {
+    _enum: ['Normal', 'Operational', 'Mandatory'],
+  },
+  /**
+   * Lookup25: frame_support::dispatch::Pays
+   **/
+  FrameSupportDispatchPays: {
+    _enum: ['Yes', 'No'],
+  },
+  /**
+   * Lookup26: sp_runtime::DispatchError
+   **/
+  SpRuntimeDispatchError: {
+    _enum: {
+      Other: 'Null',
+      CannotLookup: 'Null',
+      BadOrigin: 'Null',
+      Module: 'SpRuntimeModuleError',
+      ConsumerRemaining: 'Null',
+      NoProviders: 'Null',
+      TooManyConsumers: 'Null',
+      Token: 'SpRuntimeTokenError',
+      Arithmetic: 'SpArithmeticArithmeticError',
+      Transactional: 'SpRuntimeTransactionalError',
+      Exhausted: 'Null',
+      Corruption: 'Null',
+      Unavailable: 'Null',
+      RootNotAllowed: 'Null',
+      Trie: 'SpRuntimeProvingTrieTrieError',
+    },
+  },
+  /**
+   * Lookup27: sp_runtime::ModuleError
+   **/
+  SpRuntimeModuleError: {
+    index: 'u8',
+    error: '[u8;4]',
+  },
+  /**
+   * Lookup28: sp_runtime::TokenError
+   **/
+  SpRuntimeTokenError: {
+    _enum: [
+      'FundsUnavailable',
+      'OnlyProvider',
+      'BelowMinimum',
+      'CannotCreate',
+      'UnknownAsset',
+      'Frozen',
+      'Unsupported',
+      'CannotCreateHold',
+      'NotExpendable',
+      'Blocked',
+    ],
+  },
+  /**
+   * Lookup29: sp_arithmetic::ArithmeticError
+   **/
+  SpArithmeticArithmeticError: {
+    _enum: ['Underflow', 'Overflow', 'DivisionByZero'],
+  },
+  /**
+   * Lookup30: sp_runtime::TransactionalError
+   **/
+  SpRuntimeTransactionalError: {
+    _enum: ['LimitReached', 'NoLayer'],
+  },
+  /**
+   * Lookup31: sp_runtime::proving_trie::TrieError
+   **/
+  SpRuntimeProvingTrieTrieError: {
+    _enum: [
+      'InvalidStateRoot',
+      'IncompleteDatabase',
+      'ValueAtIncompleteKey',
+      'DecoderError',
+      'InvalidHash',
+      'DuplicateKey',
+      'ExtraneousNode',
+      'ExtraneousValue',
+      'ExtraneousHashReference',
+      'InvalidChildReference',
+      'ValueMismatch',
+      'IncompleteProof',
+      'RootMismatch',
+      'DecodeError',
+    ],
+  },
+  /**
+   * Lookup32: pallet_digests::pallet::Event<T>
+   **/
+  PalletDigestsEvent: 'Null',
+  /**
+   * Lookup33: 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]',
+      },
+      DepositPoked: {
+        who: 'AccountId32',
+        callHash: '[u8;32]',
+        oldDeposit: 'u128',
+        newDeposit: 'u128',
+      },
+    },
+  },
+  /**
+   * Lookup34: pallet_multisig::Timepoint<BlockNumber>
+   **/
+  PalletMultisigTimepoint: {
+    height: 'u32',
+    index: 'u32',
+  },
+  /**
+   * Lookup37: pallet_proxy::pallet::Event<T>
+   **/
+  PalletProxyEvent: {
+    _enum: {
+      ProxyExecuted: {
+        result: 'Result<Null, SpRuntimeDispatchError>',
+      },
+      PureCreated: {
+        pure: 'AccountId32',
+        who: 'AccountId32',
+        proxyType: 'ArgonRuntimeProxyType',
+        disambiguationIndex: 'u16',
+        at: 'u32',
+        extrinsicIndex: 'u32',
+      },
+      PureKilled: {
+        pure: 'AccountId32',
+        spawner: 'AccountId32',
+        proxyType: 'ArgonRuntimeProxyType',
+        disambiguationIndex: 'u16',
+      },
+      Announced: {
+        real: 'AccountId32',
+        proxy: 'AccountId32',
+        callHash: 'H256',
+      },
+      ProxyAdded: {
+        delegator: 'AccountId32',
+        delegatee: 'AccountId32',
+        proxyType: 'ArgonRuntimeProxyType',
+        delay: 'u32',
+      },
+      ProxyRemoved: {
+        delegator: 'AccountId32',
+        delegatee: 'AccountId32',
+        proxyType: 'ArgonRuntimeProxyType',
+        delay: 'u32',
+      },
+      DepositPoked: {
+        who: 'AccountId32',
+        kind: 'PalletProxyDepositKind',
+        oldDeposit: 'u128',
+        newDeposit: 'u128',
+      },
+    },
+  },
+  /**
+   * Lookup38: argon_runtime::ProxyType
+   **/
+  ArgonRuntimeProxyType: {
+    _enum: [
+      'Any',
+      'NonTransfer',
+      'PriceIndex',
+      'MiningBid',
+      'MiningBidRealPaysFee',
+      'Bitcoin',
+      'VaultAdmin',
+      'BitcoinInitializeFor',
+    ],
+  },
+  /**
+   * Lookup40: pallet_proxy::DepositKind
+   **/
+  PalletProxyDepositKind: {
+    _enum: ['Proxies', 'Announcements'],
+  },
+  /**
+   * Lookup41: pallet_mining_slot::pallet::Event<T>
+   **/
+  PalletMiningSlotEvent: {
+    _enum: {
+      NewMiners: {
+        newMiners: 'Vec<ArgonPrimitivesBlockSealMiningRegistration>',
+        releasedMiners: 'u32',
+        frameId: 'u64',
+      },
+      SlotBidderAdded: {
+        accountId: 'AccountId32',
+        bidAmount: 'u128',
+        index: 'u32',
+      },
+      SlotBidderDropped: {
+        accountId: 'AccountId32',
+        preservedArgonotHold: 'bool',
+      },
+      ReleaseMinerSeatError: {
+        accountId: 'AccountId32',
+        error: 'SpRuntimeDispatchError',
+      },
+      MiningConfigurationUpdated: {
+        ticksBeforeBidEndForVrfClose: 'u64',
+        ticksBetweenSlots: 'u64',
+        slotBiddingStartAfterTicks: 'u64',
+      },
+      MiningBidsClosed: {
+        frameId: 'u64',
+      },
+      ReleaseBidError: {
+        accountId: 'AccountId32',
+        error: 'SpRuntimeDispatchError',
+      },
+    },
+  },
+  /**
+   * Lookup43: argon_primitives::block_seal::MiningRegistration<sp_core::crypto::AccountId32, Balance, argon_runtime::SessionKeys>
+   **/
+  ArgonPrimitivesBlockSealMiningRegistration: {
+    accountId: 'AccountId32',
+    externalFundingAccount: 'Option<AccountId32>',
+    bid: 'Compact<u128>',
+    argonots: 'Compact<u128>',
+    authorityKeys: 'ArgonRuntimeSessionKeys',
+    startingFrameId: 'Compact<u64>',
+    bidAtTick: 'Compact<u64>',
+  },
+  /**
+   * Lookup44: argon_runtime::SessionKeys
+   **/
+  ArgonRuntimeSessionKeys: {
+    grandpa: 'SpConsensusGrandpaAppPublic',
+    blockSealAuthority: 'ArgonPrimitivesBlockSealAppPublic',
+  },
+  /**
+   * Lookup45: sp_consensus_grandpa::app::Public
+   **/
+  SpConsensusGrandpaAppPublic: '[u8;32]',
+  /**
+   * Lookup46: argon_primitives::block_seal::app::Public
+   **/
+  ArgonPrimitivesBlockSealAppPublic: '[u8;32]',
+  /**
+   * Lookup50: pallet_bitcoin_utxos::pallet::Event<T>
+   **/
+  PalletBitcoinUtxosEvent: {
+    _enum: {
+      UtxoVerified: {
+        utxoId: 'u64',
+        satoshisReceived: 'u64',
+      },
+      UtxoRejected: {
+        utxoId: 'u64',
+        utxoRef: 'ArgonPrimitivesBitcoinUtxoRef',
+        rejectedReason: 'ArgonPrimitivesBitcoinBitcoinRejectedReason',
+        satoshisReceived: 'u64',
+      },
+      UtxoSpent: {
+        utxoId: 'u64',
+        blockHeight: 'u64',
+      },
+      UtxoUnwatched: {
+        utxoId: 'u64',
+      },
+      UtxoSpentError: {
+        utxoId: 'u64',
+        error: 'SpRuntimeDispatchError',
+      },
+      UtxoVerifiedError: {
+        utxoId: 'u64',
+        error: 'SpRuntimeDispatchError',
+      },
+      UtxoRejectedError: {
+        utxoId: 'u64',
+        error: 'SpRuntimeDispatchError',
+      },
+    },
+  },
+  /**
+   * Lookup51: argon_primitives::bitcoin::UtxoRef
+   **/
+  ArgonPrimitivesBitcoinUtxoRef: {
+    txid: 'ArgonPrimitivesBitcoinH256Le',
+    outputIndex: 'Compact<u32>',
+  },
+  /**
+   * Lookup52: argon_primitives::bitcoin::H256Le
+   **/
+  ArgonPrimitivesBitcoinH256Le: '[u8;32]',
+  /**
+   * Lookup54: argon_primitives::bitcoin::BitcoinRejectedReason
+   **/
+  ArgonPrimitivesBitcoinBitcoinRejectedReason: {
+    _enum: ['SatoshisOutsideAcceptedRange', 'Spent', 'VerificationExpired', 'AlreadyVerified'],
+  },
+  /**
+   * Lookup55: pallet_vaults::pallet::Event<T>
+   **/
+  PalletVaultsEvent: {
+    _enum: {
+      VaultCreated: {
+        vaultId: 'u32',
+        securitization: 'u128',
+        securitizationRatio: 'u128',
+        operatorAccountId: 'AccountId32',
+        openedTick: 'u64',
+      },
+      VaultModified: {
+        vaultId: 'u32',
+        securitization: 'u128',
+        securitizationTarget: 'u128',
+        securitizationRatio: 'u128',
+      },
+      VaultTermsChangeScheduled: {
+        vaultId: 'u32',
+        changeTick: 'u64',
+      },
+      VaultTermsChanged: {
+        vaultId: 'u32',
+      },
+      VaultClosed: {
+        vaultId: 'u32',
+        securitizationRemaining: 'u128',
+        securitizationReleased: 'u128',
+      },
+      VaultBitcoinXpubChange: {
+        vaultId: 'u32',
+      },
+      VaultRevenueUncollected: {
+        vaultId: 'u32',
+        frameId: 'u64',
+        amount: 'u128',
+      },
+      VaultCollected: {
+        vaultId: 'u32',
+        revenue: 'u128',
+      },
+      FundsLocked: {
+        vaultId: 'u32',
+        locker: 'AccountId32',
+        liquidityPromised: 'u128',
+        isRatchet: 'bool',
+        feeRevenue: 'u128',
+        didUseFeeCoupon: 'bool',
+      },
+      FundLockCanceled: {
+        vaultId: 'u32',
+        amount: 'u128',
+      },
+      FundsScheduledForRelease: {
+        vaultId: 'u32',
+        securitization: 'u128',
+        releaseHeight: 'u64',
+      },
+      LostBitcoinCompensated: {
+        vaultId: 'u32',
+        beneficiary: 'AccountId32',
+        toBeneficiary: 'u128',
+        burned: 'u128',
+      },
+      FundsReleased: {
+        vaultId: 'u32',
+        securitization: 'u128',
+      },
+      FundsReleasedError: {
+        vaultId: 'u32',
+        error: 'SpRuntimeDispatchError',
+      },
+      TreasuryRecordingError: {
+        vaultId: 'u32',
+        frameId: 'u64',
+        vaultEarnings: 'u128',
+        error: 'SpRuntimeDispatchError',
+      },
+    },
+  },
+  /**
+   * Lookup57: pallet_bitcoin_locks::pallet::Event<T>
+   **/
+  PalletBitcoinLocksEvent: {
+    _enum: {
+      BitcoinLockCreated: {
+        utxoId: 'u64',
+        vaultId: 'u32',
+        liquidityPromised: 'u128',
+        securitization: 'u128',
+        lockedTargetPrice: 'u128',
+        accountId: 'AccountId32',
+        securityFee: 'u128',
+      },
+      BitcoinLockRatcheted: {
+        utxoId: 'u64',
+        vaultId: 'u32',
+        liquidityPromised: 'u128',
+        oldTargetPrice: 'u128',
+        securityFee: 'u128',
+        newTargetPrice: 'u128',
+        amountBurned: 'u128',
+        accountId: 'AccountId32',
+      },
+      BitcoinLockBurned: {
+        utxoId: 'u64',
+        vaultId: 'u32',
+        wasUtxoSpent: 'bool',
+      },
+      BitcoinUtxoCosignRequested: {
+        utxoId: 'u64',
+        vaultId: 'u32',
+      },
+      BitcoinUtxoCosigned: {
+        utxoId: 'u64',
+        vaultId: 'u32',
+        signature: 'Bytes',
+      },
+      BitcoinSpentAfterRelease: {
+        utxoId: 'u64',
+        vaultId: 'u32',
+      },
+      BitcoinCosignPastDue: {
+        utxoId: 'u64',
+        vaultId: 'u32',
+        compensationAmount: 'u128',
+        compensatedAccountId: 'AccountId32',
+      },
+      CosignOverdueError: {
+        utxoId: 'u64',
+        error: 'SpRuntimeDispatchError',
+      },
+      LockExpirationError: {
+        utxoId: 'u64',
+        error: 'SpRuntimeDispatchError',
+      },
+      OrphanedUtxoReceived: {
+        utxoId: 'u64',
+        utxoRef: 'ArgonPrimitivesBitcoinUtxoRef',
+        vaultId: 'u32',
+        satoshis: 'u64',
+      },
+      OrphanedUtxoReleaseRequested: {
+        utxoId: 'u64',
+        utxoRef: 'ArgonPrimitivesBitcoinUtxoRef',
+        vaultId: 'u32',
+        accountId: 'AccountId32',
+      },
+      OrphanedUtxoCosigned: {
+        utxoId: 'u64',
+        utxoRef: 'ArgonPrimitivesBitcoinUtxoRef',
+        vaultId: 'u32',
+        accountId: 'AccountId32',
+        signature: 'Bytes',
+      },
+      UtxoFundedFromCandidate: {
+        utxoId: 'u64',
+        utxoRef: 'ArgonPrimitivesBitcoinUtxoRef',
+        vaultId: 'u32',
+        accountId: 'AccountId32',
+      },
+      SecuritizationIncreased: {
+        utxoId: 'u64',
+        vaultId: 'u32',
+        newSatoshis: 'u64',
+        accountId: 'AccountId32',
+      },
+    },
+  },
+  /**
+   * Lookup60: pallet_notaries::pallet::Event<T>
+   **/
+  PalletNotariesEvent: {
+    _enum: {
+      NotaryProposed: {
+        operatorAccount: 'AccountId32',
+        meta: 'ArgonPrimitivesNotaryNotaryMeta',
+        expires: 'u32',
+      },
+      NotaryActivated: {
+        notary: 'ArgonPrimitivesNotaryNotaryRecord',
+      },
+      NotaryMetaUpdateQueued: {
+        notaryId: 'u32',
+        meta: 'ArgonPrimitivesNotaryNotaryMeta',
+        effectiveTick: 'u64',
+      },
+      NotaryMetaUpdated: {
+        notaryId: 'u32',
+        meta: 'ArgonPrimitivesNotaryNotaryMeta',
+      },
+      NotaryMetaUpdateError: {
+        notaryId: 'u32',
+        error: 'SpRuntimeDispatchError',
+        meta: 'ArgonPrimitivesNotaryNotaryMeta',
+      },
+    },
+  },
+  /**
+   * Lookup61: argon_primitives::notary::NotaryMeta<MaxHosts>
+   **/
+  ArgonPrimitivesNotaryNotaryMeta: {
+    name: 'Bytes',
+    public: '[u8;32]',
+    hosts: 'Vec<Bytes>',
+  },
+  /**
+   * Lookup68: argon_primitives::notary::NotaryRecord<sp_core::crypto::AccountId32, BlockNumber, MaxHosts>
+   **/
+  ArgonPrimitivesNotaryNotaryRecord: {
+    notaryId: 'Compact<u32>',
+    operatorAccountId: 'AccountId32',
+    activatedBlock: 'Compact<u32>',
+    metaUpdatedBlock: 'Compact<u32>',
+    metaUpdatedTick: 'Compact<u64>',
+    meta: 'ArgonPrimitivesNotaryNotaryMeta',
+  },
+  /**
+   * Lookup69: pallet_notebook::pallet::Event<T>
+   **/
+  PalletNotebookEvent: {
+    _enum: {
+      NotebookSubmitted: {
+        notaryId: 'u32',
+        notebookNumber: 'u32',
+      },
+      NotebookAuditFailure: {
+        notaryId: 'u32',
+        notebookNumber: 'u32',
+        notebookHash: 'H256',
+        firstFailureReason: 'ArgonNotaryAuditErrorVerifyError',
+      },
+      NotebookReadyForReprocess: {
+        notaryId: 'u32',
+        notebookNumber: 'u32',
+      },
+    },
+  },
+  /**
+   * Lookup70: argon_notary_audit::error::VerifyError
+   **/
+  ArgonNotaryAuditErrorVerifyError: {
+    _enum: {
+      MissingAccountOrigin: {
+        accountId: 'AccountId32',
+        accountType: 'ArgonPrimitivesAccountAccountType',
+      },
+      HistoryLookupError: {
+        source: 'ArgonNotaryAuditAccountHistoryLookupError',
+      },
+      InvalidAccountChangelist: 'Null',
+      InvalidChainTransfersList: 'Null',
+      InvalidBalanceChangeRoot: 'Null',
+      InvalidHeaderTaxRecorded: 'Null',
+      InvalidPreviousNonce: 'Null',
+      InvalidPreviousBalance: 'Null',
+      InvalidPreviousAccountOrigin: 'Null',
+      InvalidPreviousBalanceChangeNotebook: 'Null',
+      InvalidBalanceChange: 'Null',
+      InvalidBalanceChangeSignature: {
+        changeIndex: 'u16',
+      },
+      InvalidNoteRecipients: 'Null',
+      BalanceChangeError: {
+        changeIndex: 'u16',
+        noteIndex: 'u16',
+        message: 'Bytes',
+      },
+      InvalidNetBalanceChangeset: 'Null',
+      InsufficientBalance: {
+        balance: 'u128',
+        amount: 'u128',
+        noteIndex: 'u16',
+        changeIndex: 'u16',
+      },
+      ExceededMaxBalance: {
+        balance: 'u128',
+        amount: 'u128',
+        noteIndex: 'u16',
+        changeIndex: 'u16',
+      },
+      BalanceChangeMismatch: {
+        changeIndex: 'u16',
+        providedBalance: 'u128',
+        calculatedBalance: 'i128',
+      },
+      BalanceChangeNotNetZero: {
+        sent: 'u128',
+        claimed: 'u128',
+      },
+      InvalidDomainLeaseAllocation: 'Null',
+      TaxBalanceChangeNotNetZero: {
+        sent: 'u128',
+        claimed: 'u128',
+      },
+      MissingBalanceProof: 'Null',
+      InvalidPreviousBalanceProof: 'Null',
+      InvalidNotebookHash: 'Null',
+      InvalidNotebookHeaderHash: 'Null',
+      InvalidNotebookVersion: 'Null',
+      DuplicateChainTransfer: 'Null',
+      DuplicatedAccountOriginUid: 'Null',
+      InvalidNotarySignature: 'Null',
+      InvalidSecretProvided: 'Null',
+      NotebookTooOld: 'Null',
+      CatchupNotebooksMissing: 'Null',
+      DecodeError: 'Null',
+      AccountChannelHoldDoesntExist: 'Null',
+      AccountAlreadyHasChannelHold: 'Null',
+      ChannelHoldNotReadyForClaim: {
+        currentTick: 'u64',
+        claimTick: 'u64',
+      },
+      AccountLocked: 'Null',
+      MissingChannelHoldNote: 'Null',
+      InvalidChannelHoldNote: 'Null',
+      InvalidChannelHoldClaimers: 'Null',
+      ChannelHoldNoteBelowMinimum: 'Null',
+      InvalidTaxNoteAccount: 'Null',
+      InvalidTaxOperation: 'Null',
+      InsufficientTaxIncluded: {
+        taxSent: 'u128',
+        taxOwed: 'u128',
+        accountId: 'AccountId32',
+      },
+      InsufficientBlockVoteTax: 'Null',
+      IneligibleTaxVoter: 'Null',
+      BlockVoteInvalidSignature: 'Null',
+      InvalidBlockVoteAllocation: 'Null',
+      InvalidBlockVoteRoot: 'Null',
+      InvalidBlockVotesCount: 'Null',
+      InvalidBlockVotingPower: 'Null',
+      InvalidBlockVoteList: 'Null',
+      InvalidComputeProof: 'Null',
+      InvalidBlockVoteSource: 'Null',
+      InsufficientBlockVoteMinimum: 'Null',
+      InvalidBlockVoteTick: {
+        tick: 'u64',
+        notebookTick: 'u64',
+      },
+      InvalidDefaultBlockVote: 'Null',
+      InvalidDefaultBlockVoteAuthor: {
+        author: 'AccountId32',
+        expected: 'AccountId32',
+      },
+      NoDefaultBlockVote: 'Null',
+    },
+  },
+  /**
+   * Lookup71: argon_primitives::account::AccountType
+   **/
+  ArgonPrimitivesAccountAccountType: {
+    _enum: ['Tax', 'Deposit'],
+  },
+  /**
+   * Lookup72: argon_notary_audit::AccountHistoryLookupError
+   **/
+  ArgonNotaryAuditAccountHistoryLookupError: {
+    _enum: [
+      'RootNotFound',
+      'LastChangeNotFound',
+      'InvalidTransferToLocalchain',
+      'BlockSpecificationNotFound',
+    ],
+  },
+  /**
+   * Lookup76: pallet_localchain_transfer::pallet::Event<T>
+   **/
+  PalletLocalchainTransferEvent: {
+    _enum: {
+      TransferToLocalchain: {
+        accountId: 'AccountId32',
+        amount: 'u128',
+        transferId: 'u32',
+        notaryId: 'u32',
+        expirationTick: 'u64',
+      },
+      TransferToLocalchainExpired: {
+        accountId: 'AccountId32',
+        transferId: 'u32',
+        notaryId: 'u32',
+      },
+      TransferFromLocalchain: {
+        accountId: 'AccountId32',
+        amount: 'u128',
+        notaryId: 'u32',
+      },
+      TransferFromLocalchainError: {
+        accountId: 'AccountId32',
+        amount: 'u128',
+        notaryId: 'u32',
+        notebookNumber: 'u32',
+        error: 'SpRuntimeDispatchError',
+      },
+      TransferToLocalchainRefundError: {
+        accountId: 'AccountId32',
+        transferId: 'u32',
+        notaryId: 'u32',
+        notebookNumber: 'u32',
+        error: 'SpRuntimeDispatchError',
+      },
+      PossibleInvalidLocalchainTransferAllowed: {
+        transferId: 'u32',
+        notaryId: 'u32',
+        notebookNumber: 'u32',
+      },
+      TaxationError: {
+        notaryId: 'u32',
+        notebookNumber: 'u32',
+        tax: 'u128',
+        error: 'SpRuntimeDispatchError',
+      },
+    },
+  },
+  /**
+   * Lookup77: pallet_block_seal_spec::pallet::Event<T>
+   **/
+  PalletBlockSealSpecEvent: {
+    _enum: {
+      VoteMinimumAdjusted: {
+        expectedBlockVotes: 'u128',
+        actualBlockVotes: 'u128',
+        startVoteMinimum: 'u128',
+        newVoteMinimum: 'u128',
+      },
+      ComputeDifficultyAdjusted: {
+        expectedBlockTime: 'u64',
+        actualBlockTime: 'u64',
+        startDifficulty: 'u128',
+        newDifficulty: 'u128',
+      },
+    },
+  },
+  /**
+   * Lookup78: pallet_domains::pallet::Event<T>
+   **/
+  PalletDomainsEvent: {
+    _enum: {
+      ZoneRecordUpdated: {
+        domainHash: 'H256',
+        zoneRecord: 'ArgonPrimitivesDomainZoneRecord',
+      },
+      DomainRegistered: {
+        domainHash: 'H256',
+        registration: 'PalletDomainsDomainRegistration',
+      },
+      DomainRenewed: {
+        domainHash: 'H256',
+      },
+      DomainExpired: {
+        domainHash: 'H256',
+      },
+      DomainRegistrationCanceled: {
+        domainHash: 'H256',
+        registration: 'PalletDomainsDomainRegistration',
+      },
+      DomainRegistrationError: {
+        domainHash: 'H256',
+        accountId: 'AccountId32',
+        error: 'SpRuntimeDispatchError',
+      },
+    },
+  },
+  /**
+   * Lookup79: argon_primitives::domain::ZoneRecord<sp_core::crypto::AccountId32>
+   **/
+  ArgonPrimitivesDomainZoneRecord: {
+    paymentAccount: 'AccountId32',
+    notaryId: 'u32',
+    versions: 'BTreeMap<ArgonPrimitivesDomainSemver, ArgonPrimitivesDomainVersionHost>',
+  },
+  /**
+   * Lookup81: argon_primitives::domain::Semver
+   **/
+  ArgonPrimitivesDomainSemver: {
+    major: 'u32',
+    minor: 'u32',
+    patch: 'u32',
+  },
+  /**
+   * Lookup82: argon_primitives::domain::VersionHost
+   **/
+  ArgonPrimitivesDomainVersionHost: {
+    datastoreId: 'Bytes',
+    host: 'Bytes',
+  },
+  /**
+   * Lookup87: pallet_domains::DomainRegistration<sp_core::crypto::AccountId32>
+   **/
+  PalletDomainsDomainRegistration: {
+    accountId: 'AccountId32',
+    registeredAtTick: 'u64',
+  },
+  /**
+   * Lookup88: pallet_price_index::pallet::Event<T>
+   **/
+  PalletPriceIndexEvent: {
+    _enum: {
+      NewIndex: 'Null',
+      OperatorChanged: {
+        operatorId: 'AccountId32',
+      },
+    },
+  },
+  /**
+   * Lookup89: pallet_grandpa::pallet::Event
+   **/
+  PalletGrandpaEvent: {
+    _enum: {
+      NewAuthorities: {
+        authoritySet: 'Vec<(SpConsensusGrandpaAppPublic,u64)>',
+      },
+      Paused: 'Null',
+      Resumed: 'Null',
+    },
+  },
+  /**
+   * Lookup92: pallet_block_rewards::pallet::Event<T>
+   **/
+  PalletBlockRewardsEvent: {
+    _enum: {
+      RewardCreated: {
+        rewards: 'Vec<ArgonPrimitivesBlockSealBlockPayout>',
+      },
+      RewardCreateError: {
+        accountId: 'AccountId32',
+        argons: 'Option<u128>',
+        ownership: 'Option<u128>',
+        error: 'SpRuntimeDispatchError',
+      },
+    },
+  },
+  /**
+   * Lookup94: argon_primitives::block_seal::BlockPayout<sp_core::crypto::AccountId32, Balance>
+   **/
+  ArgonPrimitivesBlockSealBlockPayout: {
+    accountId: 'AccountId32',
+    ownership: 'Compact<u128>',
+    argons: 'Compact<u128>',
+    rewardType: 'ArgonPrimitivesBlockSealBlockRewardType',
+    blockSealAuthority: 'Option<ArgonPrimitivesBlockSealAppPublic>',
+  },
+  /**
+   * Lookup95: argon_primitives::block_seal::BlockRewardType
+   **/
+  ArgonPrimitivesBlockSealBlockRewardType: {
+    _enum: ['Miner', 'Voter', 'ProfitShare'],
+  },
+  /**
+   * Lookup98: pallet_mint::pallet::Event<T>
+   **/
+  PalletMintEvent: {
+    _enum: {
+      BitcoinMint: {
+        accountId: 'AccountId32',
+        utxoId: 'Option<u64>',
+        amount: 'u128',
+      },
+      MiningMint: {
+        amount: 'u128',
+        perMiner: 'u128',
+        argonCpi: 'i128',
+        liquidity: 'u128',
+      },
+      MintError: {
+        mintType: 'PalletMintMintType',
+        accountId: 'AccountId32',
+        utxoId: 'Option<u64>',
+        amount: 'u128',
+        error: 'SpRuntimeDispatchError',
+      },
+    },
+  },
+  /**
+   * Lookup101: pallet_mint::pallet::MintType
+   **/
+  PalletMintMintType: {
+    _enum: ['Bitcoin', 'Mining'],
+  },
+  /**
+   * Lookup102: pallet_balances::pallet::Event<T, I>
+   **/
+  PalletBalancesEvent: {
+    _enum: {
+      Endowed: {
+        account: 'AccountId32',
+        freeBalance: 'u128',
+      },
+      DustLost: {
+        account: 'AccountId32',
+        amount: 'u128',
+      },
+      Transfer: {
+        from: 'AccountId32',
+        to: 'AccountId32',
+        amount: 'u128',
+      },
+      BalanceSet: {
+        who: 'AccountId32',
+        free: 'u128',
+      },
+      Reserved: {
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      Unreserved: {
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      ReserveRepatriated: {
+        from: 'AccountId32',
+        to: 'AccountId32',
+        amount: 'u128',
+        destinationStatus: 'FrameSupportTokensMiscBalanceStatus',
+      },
+      Deposit: {
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      Withdraw: {
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      Slashed: {
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      Minted: {
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      MintedCredit: {
+        amount: 'u128',
+      },
+      Burned: {
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      BurnedDebt: {
+        amount: 'u128',
+      },
+      Suspended: {
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      Restored: {
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      Upgraded: {
+        who: 'AccountId32',
+      },
+      Issued: {
+        amount: 'u128',
+      },
+      Rescinded: {
+        amount: 'u128',
+      },
+      Locked: {
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      Unlocked: {
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      Frozen: {
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      Thawed: {
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      TotalIssuanceForced: {
+        _alias: {
+          new_: 'new',
+        },
+        old: 'u128',
+        new_: 'u128',
+      },
+      Held: {
+        reason: 'ArgonRuntimeRuntimeHoldReason',
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      BurnedHeld: {
+        reason: 'ArgonRuntimeRuntimeHoldReason',
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      TransferOnHold: {
+        reason: 'ArgonRuntimeRuntimeHoldReason',
+        source: 'AccountId32',
+        dest: 'AccountId32',
+        amount: 'u128',
+      },
+      TransferAndHold: {
+        reason: 'ArgonRuntimeRuntimeHoldReason',
+        source: 'AccountId32',
+        dest: 'AccountId32',
+        transferred: 'u128',
+      },
+      Released: {
+        reason: 'ArgonRuntimeRuntimeHoldReason',
+        who: 'AccountId32',
+        amount: 'u128',
+      },
+      Unexpected: 'PalletBalancesUnexpectedKind',
+    },
+  },
+  /**
+   * Lookup103: frame_support::traits::tokens::misc::BalanceStatus
+   **/
+  FrameSupportTokensMiscBalanceStatus: {
+    _enum: ['Free', 'Reserved'],
+  },
+  /**
+   * Lookup104: argon_runtime::RuntimeHoldReason
+   **/
+  ArgonRuntimeRuntimeHoldReason: {
+    _enum: {
+      __Unused0: 'Null',
+      __Unused1: 'Null',
+      __Unused2: 'Null',
+      __Unused3: 'Null',
+      __Unused4: 'Null',
+      __Unused5: 'Null',
+      MiningSlot: 'PalletMiningSlotHoldReason',
+      __Unused7: 'Null',
+      Vaults: 'PalletVaultsHoldReason',
+      BitcoinLocks: 'PalletBitcoinLocksHoldReason',
+      __Unused10: 'Null',
+      __Unused11: 'Null',
+      __Unused12: 'Null',
+      __Unused13: 'Null',
+      __Unused14: 'Null',
+      __Unused15: 'Null',
+      __Unused16: 'Null',
+      __Unused17: 'Null',
+      __Unused18: 'Null',
+      BlockRewards: 'PalletBlockRewardsHoldReason',
+      __Unused20: 'Null',
+      __Unused21: 'Null',
+      __Unused22: 'Null',
+      __Unused23: 'Null',
+      __Unused24: 'Null',
+      __Unused25: 'Null',
+      __Unused26: 'Null',
+      __Unused27: 'Null',
+      __Unused28: 'Null',
+      __Unused29: 'Null',
+      __Unused30: 'Null',
+      Treasury: 'PalletTreasuryHoldReason',
+    },
+  },
+  /**
+   * Lookup105: pallet_mining_slot::pallet::HoldReason
+   **/
+  PalletMiningSlotHoldReason: {
+    _enum: ['RegisterAsMiner'],
+  },
+  /**
+   * Lookup106: pallet_vaults::pallet::HoldReason
+   **/
+  PalletVaultsHoldReason: {
+    _enum: ['EnterVault', 'ObligationFee', 'PendingCollect'],
+  },
+  /**
+   * Lookup107: pallet_bitcoin_locks::pallet::HoldReason
+   **/
+  PalletBitcoinLocksHoldReason: {
+    _enum: ['ReleaseBitcoinLock'],
+  },
+  /**
+   * Lookup108: pallet_block_rewards::pallet::HoldReason
+   **/
+  PalletBlockRewardsHoldReason: {
+    _enum: ['MaturationPeriod'],
+  },
+  /**
+   * Lookup109: pallet_treasury::pallet::HoldReason
+   **/
+  PalletTreasuryHoldReason: {
+    _enum: ['ContributedToTreasury'],
+  },
+  /**
+   * Lookup110: pallet_balances::pallet::UnexpectedKind
+   **/
+  PalletBalancesUnexpectedKind: {
+    _enum: ['BalanceUpdated', 'FailedToMutateAccount'],
+  },
+  /**
+   * Lookup112: pallet_tx_pause::pallet::Event<T>
+   **/
+  PalletTxPauseEvent: {
+    _enum: {
+      CallPaused: {
+        fullName: '(Bytes,Bytes)',
+      },
+      CallUnpaused: {
+        fullName: '(Bytes,Bytes)',
+      },
+    },
+  },
+  /**
+   * Lookup115: pallet_transaction_payment::pallet::Event<T>
+   **/
+  PalletTransactionPaymentEvent: {
+    _enum: {
+      TransactionFeePaid: {
+        who: 'AccountId32',
+        actualFee: 'u128',
+        tip: 'u128',
+      },
+    },
+  },
+  /**
+   * Lookup116: 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>',
+      },
+      IfElseMainSuccess: 'Null',
+      IfElseFallbackCalled: {
+        mainError: 'SpRuntimeDispatchError',
+      },
+    },
+  },
+  /**
+   * Lookup117: pallet_sudo::pallet::Event<T>
+   **/
+  PalletSudoEvent: {
+    _enum: {
+      Sudid: {
+        sudoResult: 'Result<Null, SpRuntimeDispatchError>',
+      },
+      KeyChanged: {
+        _alias: {
+          new_: 'new',
+        },
+        old: 'Option<AccountId32>',
+        new_: 'AccountId32',
+      },
+      KeyRemoved: 'Null',
+      SudoAsDone: {
+        sudoResult: 'Result<Null, SpRuntimeDispatchError>',
+      },
+    },
+  },
+  /**
+   * Lookup118: pallet_treasury::pallet::Event<T>
+   **/
+  PalletTreasuryEvent: {
+    _enum: {
+      CouldNotDistributeEarningsToBondLot: {
+        frameId: 'u64',
+        vaultId: 'u32',
+        bondLotId: 'u64',
+        accountId: 'AccountId32',
+        amount: 'u128',
+        dispatchError: 'SpRuntimeDispatchError',
+      },
+      CouldNotTransferToTreasuryReserves: {
+        frameId: 'u64',
+        amount: 'u128',
+        dispatchError: 'SpRuntimeDispatchError',
+      },
+      FrameEarningsDistributed: {
+        frameId: 'u64',
+        bidPoolDistributed: 'u128',
+        treasuryReserves: 'u128',
+        participatingVaults: 'u32',
+      },
+      FrameVaultCapitalLocked: {
+        frameId: 'u64',
+        totalEligibleBonds: 'u128',
+        participatingVaults: 'u32',
+      },
+      CouldNotReleaseBondLot: {
+        frameId: 'u64',
+        vaultId: 'u32',
+        bondLotId: 'u64',
+        amount: 'u128',
+        accountId: 'AccountId32',
+        dispatchError: 'SpRuntimeDispatchError',
+      },
+      BondLotPurchased: {
+        vaultId: 'u32',
+        bondLotId: 'u64',
+        accountId: 'AccountId32',
+        bonds: 'u32',
+      },
+      BondLotReleaseScheduled: {
+        vaultId: 'u32',
+        bondLotId: 'u64',
+        accountId: 'AccountId32',
+        bonds: 'u32',
+        releaseFrameId: 'u64',
+        reason: 'PalletTreasuryBondReleaseReason',
+      },
+      BondLotReleased: {
+        frameId: 'u64',
+        vaultId: 'u32',
+        bondLotId: 'u64',
+        accountId: 'AccountId32',
+        bonds: 'u32',
+      },
+    },
+  },
+  /**
+   * Lookup119: pallet_treasury::pallet::BondReleaseReason
+   **/
+  PalletTreasuryBondReleaseReason: {
+    _enum: ['UserLiquidation', 'Bumped', 'VaultClosed'],
+  },
+  /**
+   * Lookup120: pallet_fee_control::pallet::Event<T>
+   **/
+  PalletFeeControlEvent: {
+    _enum: {
+      FeeSkipped: {
+        origin: 'ArgonRuntimeOriginCaller',
+      },
+      FeeDelegated: {
+        origin: 'ArgonRuntimeOriginCaller',
+        from: 'AccountId32',
+        to: 'AccountId32',
+      },
+    },
+  },
+  /**
+   * Lookup121: argon_runtime::OriginCaller
+   **/
+  ArgonRuntimeOriginCaller: {
+    _enum: {
+      system: 'FrameSupportDispatchRawOrigin',
+    },
+  },
+  /**
+   * Lookup122: frame_support::dispatch::RawOrigin<sp_core::crypto::AccountId32>
+   **/
+  FrameSupportDispatchRawOrigin: {
+    _enum: {
+      Root: 'Null',
+      Signed: 'AccountId32',
+      None: 'Null',
+      Authorized: 'Null',
+    },
+  },
+  /**
+   * Lookup123: pallet_operational_accounts::pallet::Event<T>
+   **/
+  PalletOperationalAccountsEvent: {
+    _enum: {
+      OperationalAccountRegistered: {
+        operationalAccount: 'AccountId32',
+        vaultAccount: 'AccountId32',
+        miningFundingAccount: 'AccountId32',
+        miningBotAccount: 'AccountId32',
+        sponsor: 'Option<AccountId32>',
+      },
+      AccountWentOperational: {
+        account: 'AccountId32',
+      },
+      OperationalRewardEarned: {
+        account: 'AccountId32',
+        rewardKind: 'ArgonPrimitivesProvidersOperationalRewardKind',
+        amount: 'u128',
+      },
+      OperationalRewardsClaimed: {
+        operationalAccount: 'AccountId32',
+        claimant: 'AccountId32',
+        amount: 'u128',
+        remainingPending: 'u128',
+      },
+      RewardsConfigUpdated: {
+        operationalReferralReward: 'u128',
+        referralBonusReward: 'u128',
+      },
+      OperationalProgressForced: {
+        account: 'AccountId32',
+        updateOperationalProgress: 'bool',
+        hasUniswapTransfer: 'bool',
+        vaultCreated: 'bool',
+        hasTreasuryPoolParticipation: 'bool',
+        observedBitcoinTotal: 'u128',
+        observedMiningSeatTotal: 'u32',
+      },
+      EncryptedServerUpdated: {
+        sponsor: 'AccountId32',
+        sponsee: 'AccountId32',
+      },
+    },
+  },
+  /**
+   * Lookup124: argon_primitives::providers::OperationalRewardKind
+   **/
+  ArgonPrimitivesProvidersOperationalRewardKind: {
+    _enum: ['Activation', 'ReferralBonus'],
+  },
+  /**
+   * Lookup125: pallet_ethereum_verifier::pallet::Event<T>
+   **/
+  PalletEthereumVerifierEvent: {
+    _enum: {
+      BeaconHeaderImported: {
+        blockHash: 'H256',
+        slot: 'u64',
+      },
+      ExecutionHeaderAnchorImported: {
+        blockHash: 'H256',
+        blockNumber: 'u64',
+      },
+      SyncCommitteeUpdated: {
+        period: 'u64',
+      },
+      OperatingModeChanged: {
+        mode: 'PalletEthereumVerifierBasicOperatingMode',
+      },
+    },
+  },
+  /**
+   * Lookup126: pallet_ethereum_verifier::types::BasicOperatingMode
+   **/
+  PalletEthereumVerifierBasicOperatingMode: {
+    _enum: ['Normal', 'Halted'],
+  },
+  /**
+   * Lookup127: pallet_crosschain_transfer::pallet::Event<T>
+   **/
+  PalletCrosschainTransferEvent: {
+    _enum: {
+      TransferToArgonSettled: {
+        sourceChain: 'PalletCrosschainTransferSourceChain',
+        transfer: 'PalletCrosschainTransferTransferToArgonActivity',
+      },
+      GatewayStateAdvanced: {
+        sourceChain: 'PalletCrosschainTransferSourceChain',
+        gatewayState: 'PalletCrosschainTransferGatewayState',
+      },
+    },
+  },
+  /**
+   * Lookup128: pallet_crosschain_transfer::pallet::SourceChain
+   **/
+  PalletCrosschainTransferSourceChain: {
+    _enum: ['Ethereum'],
+  },
+  /**
+   * Lookup129: pallet_crosschain_transfer::pallet::TransferToArgonActivity<T>
+   **/
+  PalletCrosschainTransferTransferToArgonActivity: {
+    gatewayActivityNonce: 'Compact<u64>',
+    from: 'H160',
+    asset: 'PalletCrosschainTransferAssetKind',
+    to: 'AccountId32',
+    amount: 'Compact<u128>',
+  },
+  /**
+   * Lookup132: pallet_crosschain_transfer::pallet::AssetKind
+   **/
+  PalletCrosschainTransferAssetKind: {
+    _enum: ['Argon', 'Argonot'],
+  },
+  /**
+   * Lookup133: pallet_crosschain_transfer::pallet::GatewayState<T>
+   **/
+  PalletCrosschainTransferGatewayState: {
+    gatewayActivityNonce: 'Compact<u64>',
+    argonApprovalsNonce: 'Compact<u64>',
+    argonCirculation: 'u128',
+    argonotCirculation: 'u128',
+  },
+  /**
+   * Lookup134: frame_system::Phase
+   **/
+  FrameSystemPhase: {
+    _enum: {
+      ApplyExtrinsic: 'u32',
+      Finalization: 'Null',
+      Initialization: 'Null',
+    },
+  },
+  /**
+   * Lookup138: frame_system::LastRuntimeUpgradeInfo
+   **/
+  FrameSystemLastRuntimeUpgradeInfo: {
+    specVersion: 'Compact<u32>',
+    specName: 'Text',
+  },
+  /**
+   * Lookup141: frame_system::CodeUpgradeAuthorization<T>
+   **/
+  FrameSystemCodeUpgradeAuthorization: {
+    codeHash: 'H256',
+    checkVersion: 'bool',
+  },
+  /**
+   * Lookup142: frame_system::pallet::Call<T>
+   **/
+  FrameSystemCall: {
+    _enum: {
+      remark: {
+        remark: 'Bytes',
+      },
+      set_heap_pages: {
+        pages: 'u64',
+      },
+      set_code: {
+        code: 'Bytes',
+      },
+      set_code_without_checks: {
+        code: 'Bytes',
+      },
+      set_storage: {
+        items: 'Vec<(Bytes,Bytes)>',
+      },
+      kill_storage: {
+        _alias: {
+          keys_: 'keys',
+        },
+        keys_: 'Vec<Bytes>',
+      },
+      kill_prefix: {
+        prefix: 'Bytes',
+        subkeys: 'u32',
+      },
+      remark_with_event: {
+        remark: 'Bytes',
+      },
+      __Unused8: 'Null',
+      authorize_upgrade: {
+        codeHash: 'H256',
+      },
+      authorize_upgrade_without_checks: {
+        codeHash: 'H256',
+      },
+      apply_authorized_upgrade: {
+        code: 'Bytes',
+      },
+    },
+  },
+  /**
+   * Lookup146: frame_system::limits::BlockWeights
+   **/
+  FrameSystemLimitsBlockWeights: {
+    baseBlock: 'SpWeightsWeightV2Weight',
+    maxBlock: 'SpWeightsWeightV2Weight',
+    perClass: 'FrameSupportDispatchPerDispatchClassWeightsPerClass',
+  },
+  /**
+   * Lookup147: frame_support::dispatch::PerDispatchClass<frame_system::limits::WeightsPerClass>
+   **/
+  FrameSupportDispatchPerDispatchClassWeightsPerClass: {
+    normal: 'FrameSystemLimitsWeightsPerClass',
+    operational: 'FrameSystemLimitsWeightsPerClass',
+    mandatory: 'FrameSystemLimitsWeightsPerClass',
+  },
+  /**
+   * Lookup148: frame_system::limits::WeightsPerClass
+   **/
+  FrameSystemLimitsWeightsPerClass: {
+    baseExtrinsic: 'SpWeightsWeightV2Weight',
+    maxExtrinsic: 'Option<SpWeightsWeightV2Weight>',
+    maxTotal: 'Option<SpWeightsWeightV2Weight>',
+    reserved: 'Option<SpWeightsWeightV2Weight>',
+  },
+  /**
+   * Lookup150: frame_system::limits::BlockLength
+   **/
+  FrameSystemLimitsBlockLength: {
+    max: 'FrameSupportDispatchPerDispatchClassU32',
+    maxHeaderSize: 'Option<u32>',
+  },
+  /**
+   * Lookup151: frame_support::dispatch::PerDispatchClass<T>
+   **/
+  FrameSupportDispatchPerDispatchClassU32: {
+    normal: 'u32',
+    operational: 'u32',
+    mandatory: 'u32',
+  },
+  /**
+   * Lookup153: sp_weights::RuntimeDbWeight
+   **/
+  SpWeightsRuntimeDbWeight: {
+    read: 'u64',
+    write: 'u64',
+  },
+  /**
+   * Lookup154: sp_version::RuntimeVersion
+   **/
+  SpVersionRuntimeVersion: {
+    specName: 'Text',
+    implName: 'Text',
+    authoringVersion: 'u32',
+    specVersion: 'u32',
+    implVersion: 'u32',
+    apis: 'Vec<([u8;8],u32)>',
+    transactionVersion: 'u32',
+    systemVersion: 'u8',
+  },
+  /**
+   * Lookup159: frame_system::pallet::Error<T>
+   **/
+  FrameSystemError: {
+    _enum: [
+      'InvalidSpecName',
+      'SpecVersionNeedsToIncrease',
+      'FailedToExtractRuntimeVersion',
+      'NonDefaultComposite',
+      'NonZeroRefCount',
+      'CallFiltered',
+      'MultiBlockMigrationsOngoing',
+      'NothingAuthorized',
+      'Unauthorized',
+    ],
+  },
+  /**
+   * Lookup160: argon_primitives::digests::Digestset<argon_notary_audit::error::VerifyError, sp_core::crypto::AccountId32>
+   **/
+  ArgonPrimitivesDigestsDigestset: {
+    author: 'AccountId32',
+    blockVote: 'ArgonPrimitivesDigestsBlockVoteDigest',
+    votingKey: 'Option<ArgonPrimitivesDigestsParentVotingKeyDigest>',
+    forkPower: 'Option<ArgonPrimitivesForkPower>',
+    frameInfo: 'Option<ArgonPrimitivesDigestsFrameInfo>',
+    tick: 'u64',
+    notebooks: 'ArgonPrimitivesDigestsNotebookDigest',
+  },
+  /**
+   * Lookup161: argon_primitives::digests::BlockVoteDigest
+   **/
+  ArgonPrimitivesDigestsBlockVoteDigest: {
+    votingPower: 'Compact<u128>',
+    votesCount: 'Compact<u32>',
+  },
+  /**
+   * Lookup163: argon_primitives::digests::ParentVotingKeyDigest
+   **/
+  ArgonPrimitivesDigestsParentVotingKeyDigest: {
+    parentVotingKey: 'Option<H256>',
+  },
+  /**
+   * Lookup166: argon_primitives::fork_power::ForkPower
+   **/
+  ArgonPrimitivesForkPower: {
+    isLatestVote: 'bool',
+    notebooks: 'Compact<u64>',
+    votingPower: 'U256',
+    sealStrength: 'U256',
+    totalComputeDifficulty: 'U256',
+    voteCreatedBlocks: 'Compact<u128>',
+    minerNonceScore: 'Option<U256>',
+  },
+  /**
+   * Lookup171: argon_primitives::digests::FrameInfo
+   **/
+  ArgonPrimitivesDigestsFrameInfo: {
+    frameId: 'Compact<u64>',
+    frameRewardTicksRemaining: 'Compact<u32>',
+    isNewFrame: 'bool',
+  },
+  /**
+   * Lookup173: argon_primitives::digests::NotebookDigest<argon_notary_audit::error::VerifyError>
+   **/
+  ArgonPrimitivesDigestsNotebookDigest: {
+    notebooks: 'Vec<ArgonPrimitivesNotebookNotebookAuditResult>',
+  },
+  /**
+   * Lookup175: argon_primitives::notebook::NotebookAuditResult<argon_notary_audit::error::VerifyError>
+   **/
+  ArgonPrimitivesNotebookNotebookAuditResult: {
+    notaryId: 'Compact<u32>',
+    notebookNumber: 'Compact<u32>',
+    tick: 'Compact<u64>',
+    auditFirstFailure: 'Option<ArgonNotaryAuditErrorVerifyError>',
+  },
+  /**
+   * Lookup178: pallet_digests::pallet::Error<T>
+   **/
+  PalletDigestsError: {
+    _enum: [
+      'DuplicateBlockVoteDigest',
+      'DuplicateAuthorDigest',
+      'DuplicateTickDigest',
+      'DuplicateParentVotingKeyDigest',
+      'DuplicateNotebookDigest',
+      'DuplicateForkPowerDigest',
+      'MissingBlockVoteDigest',
+      'MissingAuthorDigest',
+      'MissingTickDigest',
+      'MissingParentVotingKeyDigest',
+      'MissingNotebookDigest',
+      'CouldNotDecodeDigest',
+      'DuplicateFrameInfoDigest',
+    ],
+  },
+  /**
+   * Lookup179: pallet_timestamp::pallet::Call<T>
+   **/
+  PalletTimestampCall: {
+    _enum: {
+      set: {
+        now: 'Compact<u64>',
+      },
+    },
+  },
+  /**
+   * Lookup181: pallet_multisig::Multisig<BlockNumber, Balance, sp_core::crypto::AccountId32, MaxApprovals>
+   **/
+  PalletMultisigMultisig: {
+    when: 'PalletMultisigTimepoint',
+    deposit: 'u128',
+    depositor: 'AccountId32',
+    approvals: 'Vec<AccountId32>',
+  },
+  /**
+   * Lookup184: 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: 'Call',
+        maxWeight: 'SpWeightsWeightV2Weight',
+      },
+      approve_as_multi: {
+        threshold: 'u16',
+        otherSignatories: 'Vec<AccountId32>',
+        maybeTimepoint: 'Option<PalletMultisigTimepoint>',
+        callHash: '[u8;32]',
+        maxWeight: 'SpWeightsWeightV2Weight',
+      },
+      cancel_as_multi: {
+        threshold: 'u16',
+        otherSignatories: 'Vec<AccountId32>',
+        timepoint: 'PalletMultisigTimepoint',
+        callHash: '[u8;32]',
+      },
+      poke_deposit: {
+        threshold: 'u16',
+        otherSignatories: 'Vec<AccountId32>',
+        callHash: '[u8;32]',
+      },
+    },
+  },
+  /**
+   * Lookup186: pallet_proxy::pallet::Call<T>
+   **/
+  PalletProxyCall: {
+    _enum: {
+      proxy: {
+        real: 'MultiAddress',
+        forceProxyType: 'Option<ArgonRuntimeProxyType>',
+        call: 'Call',
+      },
+      add_proxy: {
+        delegate: 'MultiAddress',
+        proxyType: 'ArgonRuntimeProxyType',
+        delay: 'u32',
+      },
+      remove_proxy: {
+        delegate: 'MultiAddress',
+        proxyType: 'ArgonRuntimeProxyType',
+        delay: 'u32',
+      },
+      remove_proxies: 'Null',
+      create_pure: {
+        proxyType: 'ArgonRuntimeProxyType',
+        delay: 'u32',
+        index: 'u16',
+      },
+      kill_pure: {
+        spawner: 'MultiAddress',
+        proxyType: 'ArgonRuntimeProxyType',
+        index: 'u16',
+        height: 'Compact<u32>',
+        extIndex: 'Compact<u32>',
+      },
+      announce: {
+        real: 'MultiAddress',
+        callHash: 'H256',
+      },
+      remove_announcement: {
+        real: 'MultiAddress',
+        callHash: 'H256',
+      },
+      reject_announcement: {
+        delegate: 'MultiAddress',
+        callHash: 'H256',
+      },
+      proxy_announced: {
+        delegate: 'MultiAddress',
+        real: 'MultiAddress',
+        forceProxyType: 'Option<ArgonRuntimeProxyType>',
+        call: 'Call',
+      },
+      poke_deposit: 'Null',
+    },
+  },
+  /**
+   * Lookup190: pallet_ticks::pallet::Call<T>
+   **/
+  PalletTicksCall: 'Null',
+  /**
+   * Lookup191: pallet_mining_slot::pallet::Call<T>
+   **/
+  PalletMiningSlotCall: {
+    _enum: {
+      bid: {
+        _alias: {
+          keys_: 'keys',
+        },
+        bid: 'u128',
+        keys_: 'ArgonRuntimeSessionKeys',
+        miningAccountId: 'Option<AccountId32>',
+      },
+      configure_mining_slot_delay: {
+        miningSlotDelay: 'Option<u64>',
+        ticksBeforeBidEndForVrfClose: 'Option<u64>',
+      },
+    },
+  },
+  /**
+   * Lookup192: pallet_bitcoin_utxos::pallet::Call<T>
+   **/
+  PalletBitcoinUtxosCall: {
+    _enum: {
+      sync: {
+        utxoSync: 'ArgonPrimitivesInherentsBitcoinUtxoSync',
+      },
+      set_confirmed_block: {
+        bitcoinHeight: 'u64',
+        bitcoinBlockHash: 'ArgonPrimitivesBitcoinH256Le',
+      },
+      set_operator: {
+        accountId: 'AccountId32',
+      },
+      fund_with_utxo_candidate: {
+        utxoId: 'u64',
+        utxoRef: 'ArgonPrimitivesBitcoinUtxoRef',
+      },
+      reject_utxo_candidate: {
+        utxoId: 'u64',
+        utxoRef: 'ArgonPrimitivesBitcoinUtxoRef',
+      },
+    },
+  },
+  /**
+   * Lookup193: argon_primitives::inherents::BitcoinUtxoSync
+   **/
+  ArgonPrimitivesInherentsBitcoinUtxoSync: {
+    spent: 'Vec<ArgonPrimitivesInherentsBitcoinUtxoSpend>',
+    funded: 'Vec<ArgonPrimitivesInherentsBitcoinUtxoFunding>',
+    syncToBlock: 'ArgonPrimitivesBitcoinBitcoinBlock',
+  },
+  /**
+   * Lookup195: argon_primitives::inherents::BitcoinUtxoSpend
+   **/
+  ArgonPrimitivesInherentsBitcoinUtxoSpend: {
+    utxoId: 'Compact<u64>',
+    utxoRef: 'Option<ArgonPrimitivesBitcoinUtxoRef>',
+    bitcoinHeight: 'Compact<u64>',
+  },
+  /**
+   * Lookup198: argon_primitives::inherents::BitcoinUtxoFunding
+   **/
+  ArgonPrimitivesInherentsBitcoinUtxoFunding: {
+    utxoId: 'Compact<u64>',
+    utxoRef: 'ArgonPrimitivesBitcoinUtxoRef',
+    satoshis: 'Compact<u64>',
+    expectedSatoshis: 'Compact<u64>',
+    bitcoinHeight: 'Compact<u64>',
+  },
+  /**
+   * Lookup199: argon_primitives::bitcoin::BitcoinBlock
+   **/
+  ArgonPrimitivesBitcoinBitcoinBlock: {
+    blockHeight: 'Compact<u64>',
+    blockHash: 'ArgonPrimitivesBitcoinH256Le',
+  },
+  /**
+   * Lookup200: pallet_vaults::pallet::Call<T>
+   **/
+  PalletVaultsCall: {
+    _enum: {
+      create: {
+        vaultConfig: 'PalletVaultsVaultConfig',
+      },
+      modify_funding: {
+        vaultId: 'u32',
+        securitization: 'u128',
+        securitizationRatio: 'u128',
+      },
+      modify_terms: {
+        vaultId: 'u32',
+        terms: 'ArgonPrimitivesVaultVaultTerms',
+      },
+      close: {
+        vaultId: 'u32',
+      },
+      replace_bitcoin_xpub: {
+        vaultId: 'u32',
+        bitcoinXpub: 'ArgonPrimitivesBitcoinOpaqueBitcoinXpub',
+      },
+      collect: {
+        vaultId: 'u32',
+      },
+      set_bitcoin_lock_delegate: {
+        delegateAccountId: 'Option<AccountId32>',
+      },
+      set_name: {
+        name: 'Option<Bytes>',
+      },
+    },
+  },
+  /**
+   * Lookup201: pallet_vaults::pallet::VaultConfig<Balance>
+   **/
+  PalletVaultsVaultConfig: {
+    terms: 'ArgonPrimitivesVaultVaultTerms',
+    name: 'Option<Bytes>',
+    securitization: 'Compact<u128>',
+    bitcoinXpubkey: 'ArgonPrimitivesBitcoinOpaqueBitcoinXpub',
+    securitizationRatio: 'Compact<u128>',
+  },
+  /**
+   * Lookup202: argon_primitives::vault::VaultTerms<Balance>
+   **/
+  ArgonPrimitivesVaultVaultTerms: {
+    bitcoinAnnualPercentRate: 'Compact<u128>',
+    bitcoinBaseFee: 'Compact<u128>',
+    treasuryProfitSharing: 'Compact<Permill>',
+  },
+  /**
+   * Lookup208: argon_primitives::bitcoin::OpaqueBitcoinXpub
+   **/
+  ArgonPrimitivesBitcoinOpaqueBitcoinXpub: '[u8;78]',
+  /**
+   * Lookup210: pallet_bitcoin_locks::pallet::Call<T>
+   **/
+  PalletBitcoinLocksCall: {
+    _enum: {
+      initialize: {
+        vaultId: 'u32',
+        satoshis: 'Compact<u64>',
+        bitcoinPubkey: 'ArgonPrimitivesBitcoinCompressedBitcoinPubkey',
+        options: 'Option<PalletBitcoinLocksLockOptions>',
+      },
+      request_release: {
+        utxoId: 'u64',
+        toScriptPubkey: 'Bytes',
+        bitcoinNetworkFee: 'u64',
+      },
+      cosign_release: {
+        utxoId: 'u64',
+        signature: 'Bytes',
+      },
+      ratchet: {
+        utxoId: 'u64',
+        options: 'Option<PalletBitcoinLocksLockOptions>',
+      },
+      admin_modify_minimum_locked_sats: {
+        satoshis: 'u64',
+      },
+      request_orphaned_utxo_release: {
+        utxoRef: 'ArgonPrimitivesBitcoinUtxoRef',
+        toScriptPubkey: 'Bytes',
+        bitcoinNetworkFee: 'u64',
+      },
+      cosign_orphaned_utxo_release: {
+        orphanOwner: 'AccountId32',
+        utxoRef: 'ArgonPrimitivesBitcoinUtxoRef',
+        signature: 'Bytes',
+      },
+      __Unused7: 'Null',
+      initialize_for: {
+        accountId: 'AccountId32',
+        vaultId: 'u32',
+        satoshis: 'Compact<u64>',
+        bitcoinPubkey: 'ArgonPrimitivesBitcoinCompressedBitcoinPubkey',
+        options: 'Option<PalletBitcoinLocksLockOptions>',
+      },
+      increase_securitization: {
+        utxoId: 'u64',
+        newSatoshis: 'Compact<u64>',
+      },
+    },
+  },
+  /**
+   * Lookup211: argon_primitives::bitcoin::CompressedBitcoinPubkey
+   **/
+  ArgonPrimitivesBitcoinCompressedBitcoinPubkey: '[u8;33]',
+  /**
+   * Lookup214: pallet_bitcoin_locks::pallet::LockOptions<T>
+   **/
+  PalletBitcoinLocksLockOptions: {
+    _enum: {
+      V1: {
+        microgonsAtTargetPerBtc: 'Option<u128>',
+      },
+    },
+  },
+  /**
+   * Lookup217: pallet_notaries::pallet::Call<T>
+   **/
+  PalletNotariesCall: {
+    _enum: {
+      propose: {
+        meta: 'ArgonPrimitivesNotaryNotaryMeta',
+      },
+      activate: {
+        operatorAccount: 'AccountId32',
+      },
+      update: {
+        notaryId: 'Compact<u32>',
+        meta: 'ArgonPrimitivesNotaryNotaryMeta',
+        effectiveTick: 'Compact<u64>',
+      },
+    },
+  },
+  /**
+   * Lookup218: pallet_notebook::pallet::Call<T>
+   **/
+  PalletNotebookCall: {
+    _enum: {
+      submit: {
+        notebooks: 'Vec<ArgonPrimitivesNotebookSignedNotebookHeader>',
+      },
+      unlock: {
+        notaryId: 'u32',
+      },
+    },
+  },
+  /**
+   * Lookup220: argon_primitives::notebook::SignedNotebookHeader
+   **/
+  ArgonPrimitivesNotebookSignedNotebookHeader: {
+    header: 'ArgonPrimitivesNotebookNotebookHeader',
+    signature: '[u8;64]',
+  },
+  /**
+   * Lookup221: argon_primitives::notebook::NotebookHeader
+   **/
+  ArgonPrimitivesNotebookNotebookHeader: {
+    version: 'Compact<u16>',
+    notebookNumber: 'Compact<u32>',
+    tick: 'Compact<u64>',
+    tax: 'Compact<u128>',
+    notaryId: 'Compact<u32>',
+    chainTransfers: 'Vec<ArgonPrimitivesNotebookChainTransfer>',
+    changedAccountsRoot: 'H256',
+    changedAccountOrigins: 'Vec<ArgonPrimitivesBalanceChangeAccountOrigin>',
+    blockVotesRoot: 'H256',
+    blockVotesCount: 'Compact<u32>',
+    blocksWithVotes: 'Vec<H256>',
+    blockVotingPower: 'Compact<u128>',
+    secretHash: 'H256',
+    parentSecret: 'Option<H256>',
+    domains: 'Vec<(H256,AccountId32)>',
+  },
+  /**
+   * Lookup224: argon_primitives::notebook::ChainTransfer
+   **/
+  ArgonPrimitivesNotebookChainTransfer: {
+    _enum: {
+      ToMainchain: {
+        accountId: 'AccountId32',
+        amount: 'Compact<u128>',
+      },
+      ToLocalchain: {
+        transferId: 'Compact<u32>',
+      },
+    },
+  },
+  /**
+   * Lookup227: argon_primitives::balance_change::AccountOrigin
+   **/
+  ArgonPrimitivesBalanceChangeAccountOrigin: {
+    notebookNumber: 'Compact<u32>',
+    accountUid: 'Compact<u32>',
+  },
+  /**
+   * Lookup234: pallet_localchain_transfer::pallet::Call<T>
+   **/
+  PalletLocalchainTransferCall: {
+    _enum: {
+      send_to_localchain: {
+        amount: 'Compact<u128>',
+        notaryId: 'u32',
+      },
+    },
+  },
+  /**
+   * Lookup235: pallet_block_seal_spec::pallet::Call<T>
+   **/
+  PalletBlockSealSpecCall: {
+    _enum: {
+      configure: {
+        voteMinimum: 'Option<u128>',
+        computeDifficulty: 'Option<u128>',
+      },
+    },
+  },
+  /**
+   * Lookup236: pallet_domains::pallet::Call<T>
+   **/
+  PalletDomainsCall: {
+    _enum: {
+      set_zone_record: {
+        domainHash: 'H256',
+        zoneRecord: 'ArgonPrimitivesDomainZoneRecord',
+      },
+    },
+  },
+  /**
+   * Lookup237: pallet_price_index::pallet::Call<T>
+   **/
+  PalletPriceIndexCall: {
+    _enum: {
+      submit: {
+        index: 'PalletPriceIndexPriceIndex',
+      },
+      set_operator: {
+        accountId: 'AccountId32',
+      },
+    },
+  },
+  /**
+   * Lookup238: pallet_price_index::PriceIndex
+   **/
+  PalletPriceIndexPriceIndex: {
+    btcUsdPrice: 'Compact<u128>',
+    argonotUsdPrice: 'u128',
+    argonUsdPrice: 'Compact<u128>',
+    argonUsdTargetPrice: 'u128',
+    argonTimeWeightedAverageLiquidity: 'u128',
+    tick: 'Compact<u64>',
+  },
+  /**
+   * Lookup239: pallet_grandpa::pallet::Call<T>
+   **/
+  PalletGrandpaCall: {
+    _enum: {
+      report_equivocation: {
+        equivocationProof: 'SpConsensusGrandpaEquivocationProof',
+        keyOwnerProof: 'SpCoreVoid',
+      },
+      report_equivocation_unsigned: {
+        equivocationProof: 'SpConsensusGrandpaEquivocationProof',
+        keyOwnerProof: 'SpCoreVoid',
+      },
+      note_stalled: {
+        delay: 'u32',
+        bestFinalizedBlockNumber: 'u32',
+      },
+    },
+  },
+  /**
+   * Lookup240: sp_consensus_grandpa::EquivocationProof<primitive_types::H256, N>
+   **/
+  SpConsensusGrandpaEquivocationProof: {
+    setId: 'u64',
+    equivocation: 'SpConsensusGrandpaEquivocation',
+  },
+  /**
+   * Lookup241: sp_consensus_grandpa::Equivocation<primitive_types::H256, N>
+   **/
+  SpConsensusGrandpaEquivocation: {
+    _enum: {
+      Prevote: 'FinalityGrandpaEquivocationPrevote',
+      Precommit: 'FinalityGrandpaEquivocationPrecommit',
+    },
+  },
+  /**
+   * Lookup242: finality_grandpa::Equivocation<sp_consensus_grandpa::app::Public, finality_grandpa::Prevote<primitive_types::H256, N>, sp_consensus_grandpa::app::Signature>
+   **/
+  FinalityGrandpaEquivocationPrevote: {
+    roundNumber: 'u64',
+    identity: 'SpConsensusGrandpaAppPublic',
+    first: '(FinalityGrandpaPrevote,SpConsensusGrandpaAppSignature)',
+    second: '(FinalityGrandpaPrevote,SpConsensusGrandpaAppSignature)',
+  },
+  /**
+   * Lookup243: finality_grandpa::Prevote<primitive_types::H256, N>
+   **/
+  FinalityGrandpaPrevote: {
+    targetHash: 'H256',
+    targetNumber: 'u32',
+  },
+  /**
+   * Lookup244: sp_consensus_grandpa::app::Signature
+   **/
+  SpConsensusGrandpaAppSignature: '[u8;64]',
+  /**
+   * Lookup246: finality_grandpa::Equivocation<sp_consensus_grandpa::app::Public, finality_grandpa::Precommit<primitive_types::H256, N>, sp_consensus_grandpa::app::Signature>
+   **/
+  FinalityGrandpaEquivocationPrecommit: {
+    roundNumber: 'u64',
+    identity: 'SpConsensusGrandpaAppPublic',
+    first: '(FinalityGrandpaPrecommit,SpConsensusGrandpaAppSignature)',
+    second: '(FinalityGrandpaPrecommit,SpConsensusGrandpaAppSignature)',
+  },
+  /**
+   * Lookup247: finality_grandpa::Precommit<primitive_types::H256, N>
+   **/
+  FinalityGrandpaPrecommit: {
+    targetHash: 'H256',
+    targetNumber: 'u32',
+  },
+  /**
+   * Lookup249: sp_core::Void
+   **/
+  SpCoreVoid: 'Null',
+  /**
+   * Lookup250: pallet_block_seal::pallet::Call<T>
+   **/
+  PalletBlockSealCall: {
+    _enum: {
+      apply: {
+        seal: 'ArgonPrimitivesInherentsBlockSealInherent',
+      },
+    },
+  },
+  /**
+   * Lookup251: argon_primitives::inherents::BlockSealInherent
+   **/
+  ArgonPrimitivesInherentsBlockSealInherent: {
+    _enum: {
+      Vote: {
+        sealStrength: 'U256',
+        notaryId: 'Compact<u32>',
+        sourceNotebookNumber: 'Compact<u32>',
+        sourceNotebookProof: 'ArgonPrimitivesBalanceChangeMerkleProof',
+        blockVote: 'ArgonPrimitivesBlockVoteBlockVoteT',
+        minerNonceScore: 'Option<U256>',
+      },
+      Compute: 'Null',
+    },
+  },
+  /**
+   * Lookup252: argon_primitives::balance_change::MerkleProof
+   **/
+  ArgonPrimitivesBalanceChangeMerkleProof: {
+    proof: 'Vec<H256>',
+    numberOfLeaves: 'Compact<u32>',
+    leafIndex: 'Compact<u32>',
+  },
+  /**
+   * Lookup254: argon_primitives::block_vote::BlockVoteT<primitive_types::H256>
+   **/
+  ArgonPrimitivesBlockVoteBlockVoteT: {
+    accountId: 'AccountId32',
+    blockHash: 'H256',
+    index: 'Compact<u32>',
+    power: 'Compact<u128>',
+    signature: 'SpRuntimeMultiSignature',
+    blockRewardsAccountId: 'AccountId32',
+    tick: 'Compact<u64>',
+  },
+  /**
+   * Lookup255: sp_runtime::MultiSignature
+   **/
+  SpRuntimeMultiSignature: {
+    _enum: {
+      Ed25519: '[u8;64]',
+      Sr25519: '[u8;64]',
+      Ecdsa: '[u8;65]',
+      Eth: '[u8;65]',
+    },
+  },
+  /**
+   * Lookup257: pallet_block_rewards::pallet::Call<T>
+   **/
+  PalletBlockRewardsCall: {
+    _enum: {
+      set_block_rewards_paused: {
+        paused: 'bool',
+      },
+    },
+  },
+  /**
+   * Lookup258: pallet_mint::pallet::Call<T>
+   **/
+  PalletMintCall: 'Null',
+  /**
+   * Lookup259: pallet_balances::pallet::Call<T, I>
+   **/
+  PalletBalancesCall: {
+    _enum: {
+      transfer_allow_death: {
+        dest: 'MultiAddress',
+        value: 'Compact<u128>',
+      },
+      __Unused1: 'Null',
+      force_transfer: {
+        source: 'MultiAddress',
+        dest: 'MultiAddress',
+        value: 'Compact<u128>',
+      },
+      transfer_keep_alive: {
+        dest: 'MultiAddress',
+        value: 'Compact<u128>',
+      },
+      transfer_all: {
+        dest: 'MultiAddress',
+        keepAlive: 'bool',
+      },
+      force_unreserve: {
+        who: 'MultiAddress',
+        amount: 'u128',
+      },
+      upgrade_accounts: {
+        who: 'Vec<AccountId32>',
+      },
+      __Unused7: 'Null',
+      force_set_balance: {
+        who: 'MultiAddress',
+        newFree: 'Compact<u128>',
+      },
+      force_adjust_total_issuance: {
+        direction: 'PalletBalancesAdjustmentDirection',
+        delta: 'Compact<u128>',
+      },
+      burn: {
+        value: 'Compact<u128>',
+        keepAlive: 'bool',
+      },
+    },
+  },
+  /**
+   * Lookup260: pallet_balances::types::AdjustmentDirection
+   **/
+  PalletBalancesAdjustmentDirection: {
+    _enum: ['Increase', 'Decrease'],
+  },
+  /**
+   * Lookup262: pallet_tx_pause::pallet::Call<T>
+   **/
+  PalletTxPauseCall: {
+    _enum: {
+      pause: {
+        fullName: '(Bytes,Bytes)',
+      },
+      unpause: {
+        ident: '(Bytes,Bytes)',
+      },
+    },
+  },
+  /**
+   * Lookup263: 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: 'ArgonRuntimeOriginCaller',
+        call: 'Call',
+      },
+      force_batch: {
+        calls: 'Vec<Call>',
+      },
+      with_weight: {
+        call: 'Call',
+        weight: 'SpWeightsWeightV2Weight',
+      },
+      if_else: {
+        main: 'Call',
+        fallback: 'Call',
+      },
+      dispatch_as_fallible: {
+        asOrigin: 'ArgonRuntimeOriginCaller',
+        call: 'Call',
+      },
+    },
+  },
+  /**
+   * Lookup265: pallet_sudo::pallet::Call<T>
+   **/
+  PalletSudoCall: {
+    _enum: {
+      sudo: {
+        call: 'Call',
+      },
+      sudo_unchecked_weight: {
+        call: 'Call',
+        weight: 'SpWeightsWeightV2Weight',
+      },
+      set_key: {
+        _alias: {
+          new_: 'new',
+        },
+        new_: 'MultiAddress',
+      },
+      sudo_as: {
+        who: 'MultiAddress',
+        call: 'Call',
+      },
+      remove_key: 'Null',
+    },
+  },
+  /**
+   * Lookup266: pallet_treasury::pallet::Call<T>
+   **/
+  PalletTreasuryCall: {
+    _enum: {
+      __Unused0: 'Null',
+      __Unused1: 'Null',
+      __Unused2: 'Null',
+      __Unused3: 'Null',
+      buy_bonds: {
+        vaultId: 'u32',
+        bonds: 'u32',
+      },
+      liquidate_bond_lot: {
+        bondLotId: 'u64',
+      },
+    },
+  },
+  /**
+   * Lookup267: pallet_operational_accounts::pallet::Call<T>
+   **/
+  PalletOperationalAccountsCall: {
+    _enum: {
+      register: {
+        registration: 'PalletOperationalAccountsRegistration',
+      },
+      __Unused1: 'Null',
+      set_reward_config: {
+        operationalReferralReward: 'u128',
+        referralBonusReward: 'u128',
+      },
+      force_set_progress: {
+        owner: 'AccountId32',
+        patch: 'PalletOperationalAccountsOperationalProgressPatch',
+        updateOperationalProgress: 'bool',
+      },
+      set_encrypted_server_for_sponsee: {
+        sponsee: 'AccountId32',
+        encryptedServer: 'Bytes',
+      },
+      activate: 'Null',
+      claim_rewards: {
+        amount: 'u128',
+      },
+    },
+  },
+  /**
+   * Lookup268: pallet_operational_accounts::pallet::Registration<T>
+   **/
+  PalletOperationalAccountsRegistration: {
+    _enum: {
+      V1: 'PalletOperationalAccountsRegistrationV1',
+    },
+  },
+  /**
+   * Lookup269: pallet_operational_accounts::pallet::RegistrationV1<T>
+   **/
+  PalletOperationalAccountsRegistrationV1: {
+    operationalAccount: 'AccountId32',
+    encryptionPubkey: 'PalletOperationalAccountsOpaqueEncryptionPubkey',
+    operationalAccountProof: 'PalletOperationalAccountsAccountOwnershipProof',
+    vaultAccount: 'AccountId32',
+    miningFundingAccount: 'AccountId32',
+    miningBotAccount: 'AccountId32',
+    vaultAccountProof: 'PalletOperationalAccountsAccountOwnershipProof',
+    miningFundingAccountProof: 'PalletOperationalAccountsAccountOwnershipProof',
+    miningBotAccountProof: 'PalletOperationalAccountsAccountOwnershipProof',
+    referralProof: 'Option<PalletOperationalAccountsReferralProof>',
+  },
+  /**
+   * Lookup270: pallet_operational_accounts::pallet::OpaqueEncryptionPubkey
+   **/
+  PalletOperationalAccountsOpaqueEncryptionPubkey: '[u8;32]',
+  /**
+   * Lookup271: pallet_operational_accounts::pallet::AccountOwnershipProof
+   **/
+  PalletOperationalAccountsAccountOwnershipProof: {
+    signature: 'SpRuntimeMultiSignature',
+  },
+  /**
+   * Lookup273: pallet_operational_accounts::pallet::ReferralProof<sp_core::crypto::AccountId32>
+   **/
+  PalletOperationalAccountsReferralProof: {
+    referralCode: '[u8;32]',
+    referralSignature: '[u8;64]',
+    sponsor: 'AccountId32',
+    expiresAtFrame: 'Compact<u64>',
+    sponsorSignature: 'SpRuntimeMultiSignature',
+  },
+  /**
+   * Lookup274: pallet_operational_accounts::pallet::OperationalProgressPatch<Balance>
+   **/
+  PalletOperationalAccountsOperationalProgressPatch: {
+    hasUniswapTransfer: 'Option<bool>',
+    vaultCreated: 'Option<bool>',
+    hasTreasuryPoolParticipation: 'Option<bool>',
+    observedBitcoinTotal: 'Option<u128>',
+    observedMiningSeatTotal: 'Option<u32>',
+  },
+  /**
+   * Lookup276: pallet_ethereum_verifier::pallet::Call<T>
+   **/
+  PalletEthereumVerifierCall: {
+    _enum: {
+      force_checkpoint: {
+        update: 'PalletEthereumVerifierCheckpointUpdate',
+        forkVersions: 'PalletEthereumVerifierForkVersions',
+      },
+      submit: {
+        update: 'PalletEthereumVerifierUpdate',
+      },
+      import_execution_header_anchor: {
+        executionProof: 'PalletEthereumVerifierExecutionProof',
+      },
+      set_operating_mode: {
+        mode: 'PalletEthereumVerifierBasicOperatingMode',
+      },
+    },
+  },
+  /**
+   * Lookup277: pallet_ethereum_verifier::types::CheckpointUpdate
+   **/
+  PalletEthereumVerifierCheckpointUpdate: {
+    header: 'SnowbridgeBeaconPrimitivesBeaconHeader',
+    currentSyncCommittee: 'PalletEthereumVerifierSyncCommittee',
+    currentSyncCommitteeBranch: 'Vec<H256>',
+    validatorsRoot: 'H256',
+  },
+  /**
+   * Lookup278: snowbridge_beacon_primitives::types::BeaconHeader
+   **/
+  SnowbridgeBeaconPrimitivesBeaconHeader: {
+    slot: 'u64',
+    proposerIndex: 'u64',
+    parentRoot: 'H256',
+    stateRoot: 'H256',
+    bodyRoot: 'H256',
+  },
+  /**
+   * Lookup279: pallet_ethereum_verifier::types::SyncCommittee
+   **/
+  PalletEthereumVerifierSyncCommittee: {
+    pubkeys: 'Vec<SnowbridgeBeaconPrimitivesPublicKey>',
+    aggregatePubkey: 'SnowbridgeBeaconPrimitivesPublicKey',
+  },
+  /**
+   * Lookup281: snowbridge_beacon_primitives::types::PublicKey
+   **/
+  SnowbridgeBeaconPrimitivesPublicKey: '[u8;48]',
+  /**
+   * Lookup285: pallet_ethereum_verifier::types::ForkVersions
+   **/
+  PalletEthereumVerifierForkVersions: {
+    genesis: 'PalletEthereumVerifierFork',
+    altair: 'PalletEthereumVerifierFork',
+    bellatrix: 'PalletEthereumVerifierFork',
+    capella: 'PalletEthereumVerifierFork',
+    deneb: 'PalletEthereumVerifierFork',
+    electra: 'PalletEthereumVerifierFork',
+    fulu: 'PalletEthereumVerifierFork',
+  },
+  /**
+   * Lookup286: pallet_ethereum_verifier::types::Fork
+   **/
+  PalletEthereumVerifierFork: {
+    version: '[u8;4]',
+    epoch: 'Compact<u64>',
+  },
+  /**
+   * Lookup287: pallet_ethereum_verifier::types::Update
+   **/
+  PalletEthereumVerifierUpdate: {
+    attestedHeader: 'SnowbridgeBeaconPrimitivesBeaconHeader',
+    syncAggregate: 'PalletEthereumVerifierSyncAggregate',
+    signatureSlot: 'Compact<u64>',
+    nextSyncCommitteeUpdate: 'Option<PalletEthereumVerifierNextSyncCommitteeUpdate>',
+    finalizedHeader: 'SnowbridgeBeaconPrimitivesBeaconHeader',
+    finalityBranch: 'Vec<H256>',
+  },
+  /**
+   * Lookup288: pallet_ethereum_verifier::types::SyncAggregate
+   **/
+  PalletEthereumVerifierSyncAggregate: {
+    syncCommitteeBits: 'Bytes',
+    syncCommitteeSignature: 'SnowbridgeBeaconPrimitivesSignature',
+  },
+  /**
+   * Lookup290: snowbridge_beacon_primitives::types::Signature
+   **/
+  SnowbridgeBeaconPrimitivesSignature: '[u8;96]',
+  /**
+   * Lookup293: pallet_ethereum_verifier::types::NextSyncCommitteeUpdate
+   **/
+  PalletEthereumVerifierNextSyncCommitteeUpdate: {
+    nextSyncCommittee: 'PalletEthereumVerifierSyncCommittee',
+    nextSyncCommitteeBranch: 'Vec<H256>',
+  },
+  /**
+   * Lookup294: pallet_ethereum_verifier::types::ExecutionProof
+   **/
+  PalletEthereumVerifierExecutionProof: {
+    header: 'SnowbridgeBeaconPrimitivesBeaconHeader',
+    executionHeader: 'SnowbridgeBeaconPrimitivesVersionedExecutionPayloadHeader',
+    executionBranch: 'Vec<H256>',
+  },
+  /**
+   * Lookup295: snowbridge_beacon_primitives::types::VersionedExecutionPayloadHeader
+   **/
+  SnowbridgeBeaconPrimitivesVersionedExecutionPayloadHeader: {
+    _enum: {
+      Capella: 'SnowbridgeBeaconPrimitivesExecutionPayloadHeader',
+      Deneb: 'SnowbridgeBeaconPrimitivesDenebExecutionPayloadHeader',
+    },
+  },
+  /**
+   * Lookup296: snowbridge_beacon_primitives::types::ExecutionPayloadHeader
+   **/
+  SnowbridgeBeaconPrimitivesExecutionPayloadHeader: {
+    parentHash: 'H256',
+    feeRecipient: 'H160',
+    stateRoot: 'H256',
+    receiptsRoot: 'H256',
+    logsBloom: 'Bytes',
+    prevRandao: 'H256',
+    blockNumber: 'u64',
+    gasLimit: 'u64',
+    gasUsed: 'u64',
+    timestamp: 'u64',
+    extraData: 'Bytes',
+    baseFeePerGas: 'U256',
+    blockHash: 'H256',
+    transactionsRoot: 'H256',
+    withdrawalsRoot: 'H256',
+  },
+  /**
+   * Lookup297: snowbridge_beacon_primitives::types::deneb::ExecutionPayloadHeader
+   **/
+  SnowbridgeBeaconPrimitivesDenebExecutionPayloadHeader: {
+    parentHash: 'H256',
+    feeRecipient: 'H160',
+    stateRoot: 'H256',
+    receiptsRoot: 'H256',
+    logsBloom: 'Bytes',
+    prevRandao: 'H256',
+    blockNumber: 'u64',
+    gasLimit: 'u64',
+    gasUsed: 'u64',
+    timestamp: 'u64',
+    extraData: 'Bytes',
+    baseFeePerGas: 'U256',
+    blockHash: 'H256',
+    transactionsRoot: 'H256',
+    withdrawalsRoot: 'H256',
+    blobGasUsed: 'u64',
+    excessBlobGas: 'u64',
+  },
+  /**
+   * Lookup298: pallet_crosschain_transfer::pallet::Call<T>
+   **/
+  PalletCrosschainTransferCall: {
+    _enum: {
+      set_chain_config: {
+        config: 'PalletCrosschainTransferChainConfig',
+      },
+      prove_gateway_activity: {
+        sourceChain: 'PalletCrosschainTransferSourceChain',
+        previousGatewayActivityNonce: 'Compact<u64>',
+        proofBatch: 'ArgonPrimitivesEthereumEthereumReceiptLogProofBatch',
+      },
+    },
+  },
+  /**
+   * Lookup299: pallet_crosschain_transfer::pallet::ChainConfig
+   **/
+  PalletCrosschainTransferChainConfig: {
+    _enum: {
+      Ethereum: {
+        gateway: 'H160',
+        argonToken: 'H160',
+        argonotToken: 'H160',
+      },
+    },
+  },
+  /**
+   * Lookup300: argon_primitives::ethereum::EthereumReceiptLogProofBatch<MaxProofBlocks, MaxReceiptLogs>
+   **/
+  ArgonPrimitivesEthereumEthereumReceiptLogProofBatch: {
+    executionBlockProof: 'ArgonPrimitivesEthereumEthereumExecutionBlockProof',
+    blocks: 'Vec<ArgonPrimitivesEthereumEthereumReceiptLogProofBlock>',
+  },
+  /**
+   * Lookup301: argon_primitives::ethereum::EthereumExecutionBlockProof
+   **/
+  ArgonPrimitivesEthereumEthereumExecutionBlockProof: {
+    anchorBlockHash: 'H256',
+    targetToAnchorHeaderChain: 'Vec<ArgonPrimitivesEthereumEthereumExecutionHeader>',
+  },
+  /**
+   * Lookup303: argon_primitives::ethereum::EthereumExecutionHeader
+   **/
+  ArgonPrimitivesEthereumEthereumExecutionHeader: {
+    rlp: 'Bytes',
+  },
+  /**
+   * Lookup307: argon_primitives::ethereum::EthereumReceiptLogProofBlock<MaxReceiptLogs>
+   **/
+  ArgonPrimitivesEthereumEthereumReceiptLogProofBlock: {
+    targetBlockNumber: 'Compact<u64>',
+    receiptProof: 'ArgonPrimitivesEthereumEthereumCombinedReceiptProof',
+    receiptLogs: 'Vec<ArgonPrimitivesEthereumEthereumReceiptLog>',
+  },
+  /**
+   * Lookup308: argon_primitives::ethereum::EthereumCombinedReceiptProof
+   **/
+  ArgonPrimitivesEthereumEthereumCombinedReceiptProof: {
+    nodes: 'Vec<Bytes>',
+    receipts: 'Vec<ArgonPrimitivesEthereumEthereumReceiptProofReceipt>',
+  },
+  /**
+   * Lookup312: argon_primitives::ethereum::EthereumReceiptProofReceipt
+   **/
+  ArgonPrimitivesEthereumEthereumReceiptProofReceipt: {
+    transactionIndex: 'Compact<u64>',
+    nodeIndexes: 'Vec<u16>',
+  },
+  /**
+   * Lookup317: argon_primitives::ethereum::EthereumReceiptLog
+   **/
+  ArgonPrimitivesEthereumEthereumReceiptLog: {
+    transactionIndex: 'Compact<u64>',
+    eventLog: 'ArgonPrimitivesEthereumEthereumLog',
+  },
+  /**
+   * Lookup318: argon_primitives::ethereum::EthereumLog
+   **/
+  ArgonPrimitivesEthereumEthereumLog: {
+    address: 'H160',
+    topics: 'Vec<H256>',
+    data: 'Bytes',
+  },
+  /**
+   * Lookup324: pallet_multisig::pallet::Error<T>
+   **/
+  PalletMultisigError: {
+    _enum: [
+      'MinimumThreshold',
+      'AlreadyApproved',
+      'NoApprovalsNeeded',
+      'TooFewSignatories',
+      'TooManySignatories',
+      'SignatoriesOutOfOrder',
+      'SenderInSignatories',
+      'NotFound',
+      'NotOwner',
+      'NoTimepoint',
+      'WrongTimepoint',
+      'UnexpectedTimepoint',
+      'MaxWeightTooLow',
+      'AlreadyStored',
+    ],
+  },
+  /**
+   * Lookup327: pallet_proxy::ProxyDefinition<sp_core::crypto::AccountId32, argon_runtime::ProxyType, BlockNumber>
+   **/
+  PalletProxyProxyDefinition: {
+    delegate: 'AccountId32',
+    proxyType: 'ArgonRuntimeProxyType',
+    delay: 'u32',
+  },
+  /**
+   * Lookup331: pallet_proxy::Announcement<sp_core::crypto::AccountId32, primitive_types::H256, BlockNumber>
+   **/
+  PalletProxyAnnouncement: {
+    real: 'AccountId32',
+    callHash: 'H256',
+    height: 'u32',
+  },
+  /**
+   * Lookup333: pallet_proxy::pallet::Error<T>
+   **/
+  PalletProxyError: {
+    _enum: [
+      'TooMany',
+      'NotFound',
+      'NotProxy',
+      'Unproxyable',
+      'Duplicate',
+      'NoPermission',
+      'Unannounced',
+      'NoSelfProxy',
+    ],
+  },
+  /**
+   * Lookup334: argon_primitives::tick::Ticker
+   **/
+  ArgonPrimitivesTickTicker: {
+    tickDurationMillis: 'Compact<u64>',
+    channelHoldExpirationTicks: 'Compact<u64>',
+  },
+  /**
+   * Lookup336: pallet_ticks::pallet::Error<T>
+   **/
+  PalletTicksError: 'Null',
+  /**
+   * Lookup339: pallet_mining_slot::MinerNonceScoring<T>
+   **/
+  PalletMiningSlotMinerNonceScoring: {
+    nonce: 'U256',
+    lastWinBlock: 'Option<u32>',
+    blocksWonInFrame: 'u16',
+    frameStartBlocksWonSurplus: 'i16',
+  },
+  /**
+   * Lookup351: argon_primitives::block_seal::MiningBidStats
+   **/
+  ArgonPrimitivesBlockSealMiningBidStats: {
+    bidsCount: 'u32',
+    bidAmountMin: 'u128',
+    bidAmountMax: 'u128',
+    bidAmountSum: 'u128',
+  },
+  /**
+   * Lookup355: argon_primitives::block_seal::MiningSlotConfig
+   **/
+  ArgonPrimitivesBlockSealMiningSlotConfig: {
+    ticksBeforeBidEndForVrfClose: 'Compact<u64>',
+    ticksBetweenSlots: 'Compact<u64>',
+    slotBiddingStartAfterTicks: 'Compact<u64>',
+  },
+  /**
+   * Lookup366: pallet_mining_slot::pallet::Error<T>
+   **/
+  PalletMiningSlotError: {
+    _enum: [
+      'SlotNotTakingBids',
+      'TooManyBlockRegistrants',
+      'InsufficientOwnershipTokens',
+      'BidTooLow',
+      'CannotRegisterOverlappingSessions',
+      'CannotChangeFundingAccount',
+      'InsufficientFunds',
+      'BidCannotBeReduced',
+      'InvalidBidAmount',
+      'UnrecoverableHold',
+    ],
+  },
+  /**
+   * Lookup367: argon_primitives::bitcoin::UtxoValue
+   **/
+  ArgonPrimitivesBitcoinUtxoValue: {
+    utxoId: 'u64',
+    scriptPubkey: 'ArgonPrimitivesBitcoinBitcoinCosignScriptPubkey',
+    satoshis: 'Compact<u64>',
+    submittedAtHeight: 'Compact<u64>',
+    watchForSpentUntilHeight: 'Compact<u64>',
+  },
+  /**
+   * Lookup368: argon_primitives::bitcoin::BitcoinCosignScriptPubkey
+   **/
+  ArgonPrimitivesBitcoinBitcoinCosignScriptPubkey: {
+    _enum: {
+      P2WSH: {
+        wscriptHash: 'H256',
+      },
+    },
+  },
+  /**
+   * Lookup377: argon_primitives::bitcoin::BitcoinNetwork
+   **/
+  ArgonPrimitivesBitcoinBitcoinNetwork: {
+    _enum: ['Bitcoin', 'Testnet', 'Signet', 'Regtest'],
+  },
+  /**
+   * Lookup378: pallet_bitcoin_utxos::pallet::Error<T>
+   **/
+  PalletBitcoinUtxosError: {
+    _enum: [
+      'NoPermissions',
+      'NoBitcoinConfirmedBlock',
+      'InsufficientBitcoinAmount',
+      'NoBitcoinPricesAvailable',
+      'ScriptPubkeyConflict',
+      'UtxoNotLocked',
+      'RedemptionsUnavailable',
+      'InvalidBitcoinSyncHeight',
+      'BitcoinHeightNotConfirmed',
+      'MaxUtxosExceeded',
+      'InvalidBitcoinScript',
+      'DuplicateUtxoId',
+      'MaxCandidateUtxosExceeded',
+      'UtxoNotCandidate',
+      'LockAlreadyFunded',
+    ],
+  },
+  /**
+   * Lookup379: argon_primitives::vault::Vault<sp_core::crypto::AccountId32, Balance>
+   **/
+  ArgonPrimitivesVault: {
+    operatorAccountId: 'AccountId32',
+    bitcoinLockDelegateAccount: 'Option<AccountId32>',
+    name: 'Option<Bytes>',
+    lastNameChangeTick: 'Option<u64>',
+    securitization: 'Compact<u128>',
+    securitizationTarget: 'Compact<u128>',
+    securitizationLocked: 'Compact<u128>',
+    securitizationPendingActivation: 'Compact<u128>',
+    lockedSatoshis: 'Compact<u64>',
+    securitizedSatoshis: 'Compact<u64>',
+    securitizationReleaseSchedule: 'BTreeMap<u64, u128>',
+    securitizationRatio: 'Compact<u128>',
+    isClosed: 'bool',
+    terms: 'ArgonPrimitivesVaultVaultTerms',
+    pendingTerms: 'Option<(u64,ArgonPrimitivesVaultVaultTerms)>',
+    openedTick: 'Compact<u64>',
+    operationalMinimumReleaseTick: 'Option<u64>',
+  },
+  /**
+   * Lookup387: argon_primitives::bitcoin::BitcoinXPub
+   **/
+  ArgonPrimitivesBitcoinBitcoinXPub: {
+    publicKey: 'ArgonPrimitivesBitcoinCompressedBitcoinPubkey',
+    depth: 'Compact<u8>',
+    parentFingerprint: '[u8;4]',
+    childNumber: 'Compact<u32>',
+    chainCode: '[u8;32]',
+    network: 'ArgonPrimitivesBitcoinNetworkKind',
+  },
+  /**
+   * Lookup389: argon_primitives::bitcoin::NetworkKind
+   **/
+  ArgonPrimitivesBitcoinNetworkKind: {
+    _enum: ['Main', 'Test'],
+  },
+  /**
+   * Lookup398: pallet_vaults::pallet::VaultFrameRevenue<T>
+   **/
+  PalletVaultsVaultFrameRevenue: {
+    frameId: 'Compact<u64>',
+    bitcoinLockFeeRevenue: 'Compact<u128>',
+    bitcoinLockFeeCouponValueUsed: 'Compact<u128>',
+    bitcoinLocksCreated: 'Compact<u32>',
+    bitcoinLocksNewLiquidityPromised: 'Compact<u128>',
+    bitcoinLocksReleasedLiquidity: 'Compact<u128>',
+    bitcoinLocksAddedSatoshis: 'Compact<u64>',
+    bitcoinLocksReleasedSatoshis: 'Compact<u64>',
+    securitizationActivated: 'Compact<u128>',
+    securitizationRelockable: 'Compact<u128>',
+    securitization: 'Compact<u128>',
+    treasuryVaultEarnings: 'Compact<u128>',
+    treasuryTotalEarnings: 'Compact<u128>',
+    treasuryVaultCapital: 'Compact<u128>',
+    treasuryExternalCapital: 'Compact<u128>',
+    uncollectedRevenue: 'Compact<u128>',
+  },
+  /**
+   * Lookup401: pallet_vaults::pallet::RecentCapacityDrop<Balance, BlockNumber>
+   **/
+  PalletVaultsRecentCapacityDrop: {
+    blockNumber: 'Compact<u32>',
+    availableBeforeDrop: 'Compact<u128>',
+    availableAfterDrop: 'Compact<u128>',
+    noFeeFailuresUsed: 'Compact<u32>',
+  },
+  /**
+   * Lookup403: pallet_vaults::pallet::Error<T>
+   **/
+  PalletVaultsError: {
+    _enum: [
+      'NoMoreVaultIds',
+      'InsufficientFunds',
+      'InsufficientVaultFunds',
+      'AccountBelowMinimumBalance',
+      'VaultClosed',
+      'InvalidVaultAmount',
+      'VaultReductionBelowSecuritization',
+      'InvalidSecuritization',
+      'ReusedVaultBitcoinXpub',
+      'InvalidBitcoinScript',
+      'InvalidXpubkey',
+      'WrongXpubNetwork',
+      'UnsafeXpubkey',
+      'UnableToDeriveVaultXpubChild',
+      'BitcoinConversionFailed',
+      'NoPermissions',
+      'HoldUnexpectedlyModified',
+      'UnrecoverableHold',
+      'VaultNotFound',
+      'VaultNotYetActive',
+      'NoVaultBitcoinPubkeysAvailable',
+      'TermsModificationOverflow',
+      'TermsChangeAlreadyScheduled',
+      'InternalError',
+      'UnableToGenerateVaultBitcoinPubkey',
+      'FundingChangeAlreadyScheduled',
+      'InvalidVaultName',
+      'PendingCosignsBeforeCollect',
+      'PendingOrphanedUtxoCosignsBeforeCollect',
+      'AccountAlreadyHasVault',
+    ],
+  },
+  /**
+   * Lookup404: pallet_bitcoin_locks::pallet::LockedBitcoin<T>
+   **/
+  PalletBitcoinLocksLockedBitcoin: {
+    vaultId: 'Compact<u32>',
+    liquidityPromised: 'Compact<u128>',
+    lockedTargetPrice: 'Compact<u128>',
+    ownerAccount: 'AccountId32',
+    securitizationRatio: 'u128',
+    securityFees: 'Compact<u128>',
+    couponPaidFees: 'Compact<u128>',
+    satoshis: 'Compact<u64>',
+    utxoSatoshis: 'Option<u64>',
+    vaultPubkey: 'ArgonPrimitivesBitcoinCompressedBitcoinPubkey',
+    vaultClaimPubkey: 'ArgonPrimitivesBitcoinCompressedBitcoinPubkey',
+    vaultXpubSources: '([u8;4],u32,u32)',
+    ownerPubkey: 'ArgonPrimitivesBitcoinCompressedBitcoinPubkey',
+    vaultClaimHeight: 'Compact<u64>',
+    openClaimHeight: 'Compact<u64>',
+    createdAtHeight: 'Compact<u64>',
+    utxoScriptPubkey: 'ArgonPrimitivesBitcoinBitcoinCosignScriptPubkey',
+    isFunded: 'bool',
+    fundHoldExtensions: 'BTreeMap<u64, u128>',
+    createdAtArgonBlock: 'Compact<u32>',
+  },
+  /**
+   * Lookup407: pallet_bitcoin_locks::pallet::LockReleaseRequest<Balance>
+   **/
+  PalletBitcoinLocksLockReleaseRequest: {
+    utxoId: 'Compact<u64>',
+    vaultId: 'Compact<u32>',
+    bitcoinNetworkFee: 'Compact<u64>',
+    cosignDueFrame: 'Compact<u64>',
+    toScriptPubkey: 'Bytes',
+    redemptionAmount: 'Compact<u128>',
+  },
+  /**
+   * Lookup409: pallet_bitcoin_locks::pallet::OrphanedUtxo<BlockNumber>
+   **/
+  PalletBitcoinLocksOrphanedUtxo: {
+    utxoId: 'Compact<u64>',
+    vaultId: 'Compact<u32>',
+    satoshis: 'Compact<u64>',
+    recordedArgonBlockNumber: 'Compact<u32>',
+    cosignRequest: 'Option<PalletBitcoinLocksOrphanedUtxoCosignRequest>',
+  },
+  /**
+   * Lookup411: pallet_bitcoin_locks::pallet::OrphanedUtxoCosignRequest<BlockNumber>
+   **/
+  PalletBitcoinLocksOrphanedUtxoCosignRequest: {
+    bitcoinNetworkFee: 'u64',
+    toScriptPubkey: 'Bytes',
+    createdAtArgonBlockNumber: 'u32',
+  },
+  /**
+   * Lookup418: pallet_bitcoin_locks::pallet::Error<T>
+   **/
+  PalletBitcoinLocksError: {
+    _enum: {
+      InsufficientFunds: 'Null',
+      InsufficientVaultFunds: 'Null',
+      AccountWouldGoBelowMinimumBalance: 'Null',
+      VaultClosed: 'Null',
+      InvalidVaultAmount: 'Null',
+      RedemptionNotLocked: 'Null',
+      BitcoinReleaseInitiationDeadlinePassed: 'Null',
+      BitcoinFeeTooHigh: 'Null',
+      BitcoinUtxoNotFound: 'Null',
+      BitcoinUnableToBeDecodedForRelease: 'Null',
+      BitcoinSignatureUnableToBeDecoded: 'Null',
+      BitcoinPubkeyUnableToBeDecoded: 'Null',
+      BitcoinInvalidCosignature: 'Null',
+      InsufficientSatoshisLocked: 'Null',
+      NoBitcoinPricesAvailable: 'Null',
+      InvalidBitcoinScript: 'Null',
+      NoPermissions: 'Null',
+      HoldUnexpectedlyModified: 'Null',
+      UnrecoverableHold: 'Null',
+      VaultNotFound: 'Null',
+      GenericVaultError: 'ArgonPrimitivesVaultVaultError',
+      LockNotFound: 'Null',
+      NoVaultBitcoinPubkeysAvailable: 'Null',
+      UnableToGenerateVaultBitcoinPubkey: 'Null',
+      VaultNotYetActive: 'Null',
+      ExpirationAtBlockOverflow: 'Null',
+      NoRatchetingAvailable: 'Null',
+      LockInProcessOfRelease: 'Null',
+      LockPendingFunding: 'Null',
+      OverflowError: 'Null',
+      IneligibleMicrogonRateRequested: 'Null',
+      OrphanedUtxoFundingConflict: 'Null',
+      OrphanedUtxoReleaseRequested: 'Null',
+      FundingUtxoCannotBeReleased: 'Null',
+      MaxOrphanedUtxoReleaseRequestsExceeded: 'Null',
+    },
+  },
+  /**
+   * Lookup419: argon_primitives::vault::VaultError
+   **/
+  ArgonPrimitivesVaultVaultError: {
+    _enum: [
+      'VaultClosed',
+      'AccountWouldBeBelowMinimum',
+      'InsufficientFunds',
+      'InsufficientVaultFunds',
+      'HoldUnexpectedlyModified',
+      'UnrecoverableHold',
+      'VaultNotFound',
+      'NoVaultBitcoinPubkeysAvailable',
+      'UnableToGenerateVaultBitcoinPubkey',
+      'InvalidBitcoinScript',
+      'InternalError',
+      'VaultNotYetActive',
+    ],
+  },
+  /**
+   * Lookup431: pallet_notaries::pallet::Error<T>
+   **/
+  PalletNotariesError: {
+    _enum: [
+      'ProposalNotFound',
+      'MaxNotariesExceeded',
+      'MaxProposalsPerBlockExceeded',
+      'NotAnActiveNotary',
+      'InvalidNotaryOperator',
+      'NoMoreNotaryIds',
+      'EffectiveTickTooSoon',
+      'TooManyKeys',
+      'InvalidNotary',
+    ],
+  },
+  /**
+   * Lookup435: argon_primitives::notary::NotaryNotebookKeyDetails
+   **/
+  ArgonPrimitivesNotaryNotaryNotebookKeyDetails: {
+    notebookNumber: 'Compact<u32>',
+    tick: 'Compact<u64>',
+    blockVotesRoot: 'H256',
+    secretHash: 'H256',
+    parentSecret: 'Option<H256>',
+  },
+  /**
+   * Lookup438: pallet_notebook::pallet::Error<T>
+   **/
+  PalletNotebookError: {
+    _enum: [
+      'DuplicateNotebookNumber',
+      'MissingNotebookNumber',
+      'NotebookTickAlreadyUsed',
+      'InvalidNotebookSignature',
+      'InvalidSecretProvided',
+      'CouldNotDecodeNotebook',
+      'DuplicateNotebookDigest',
+      'MissingNotebookDigest',
+      'InvalidNotebookDigest',
+      'MultipleNotebookInherentsProvided',
+      'InternalError',
+      'NotebookSubmittedForLockedNotary',
+      'InvalidReprocessNotebook',
+      'InvalidNotaryOperator',
+      'InvalidNotebookSubmissionTick',
+    ],
+  },
+  /**
+   * Lookup439: pallet_localchain_transfer::QueuedTransferOut<sp_core::crypto::AccountId32, Balance>
+   **/
+  PalletLocalchainTransferQueuedTransferOut: {
+    accountId: 'AccountId32',
+    amount: 'u128',
+    expirationTick: 'u64',
+    notaryId: 'u32',
+  },
+  /**
+   * Lookup441: frame_support::PalletId
+   **/
+  FrameSupportPalletId: '[u8;8]',
+  /**
+   * Lookup442: pallet_localchain_transfer::pallet::Error<T>
+   **/
+  PalletLocalchainTransferError: {
+    _enum: [
+      'MaxBlockTransfersExceeded',
+      'InsufficientFunds',
+      'InsufficientNotarizedFunds',
+      'InvalidOrDuplicatedLocalchainTransfer',
+      'NotebookIncludesExpiredLocalchainTransfer',
+      'InvalidNotaryUsedForTransfer',
+      'NotaryLockedForTransfer',
+      'NoAvailableTransferId',
+    ],
+  },
+  /**
+   * Lookup446: argon_primitives::notary::NotaryNotebookVoteDigestDetails
+   **/
+  ArgonPrimitivesNotaryNotaryNotebookVoteDigestDetails: {
+    notaryId: 'Compact<u32>',
+    notebookNumber: 'Compact<u32>',
+    tick: 'Compact<u64>',
+    blockVotesCount: 'Compact<u32>',
+    blockVotingPower: 'Compact<u128>',
+  },
+  /**
+   * Lookup451: pallet_block_seal_spec::pallet::Error<T>
+   **/
+  PalletBlockSealSpecError: {
+    _enum: ['MaxNotebooksAtTickExceeded'],
+  },
+  /**
+   * Lookup453: pallet_domains::pallet::Error<T>
+   **/
+  PalletDomainsError: {
+    _enum: [
+      'DomainNotRegistered',
+      'NotDomainOwner',
+      'FailedToAddToAddressHistory',
+      'FailedToAddExpiringDomain',
+      'AccountDecodingError',
+    ],
+  },
+  /**
+   * Lookup455: pallet_price_index::CpiMeasurementBucket
+   **/
+  PalletPriceIndexCpiMeasurementBucket: {
+    tickRange: '(u64,u64)',
+    totalCpi: 'i128',
+    measurementsCount: 'u32',
+  },
+  /**
+   * Lookup457: pallet_price_index::pallet::Error<T>
+   **/
+  PalletPriceIndexError: {
+    _enum: [
+      'NotAuthorizedOperator',
+      'MissingValue',
+      'PricesTooOld',
+      'MaxPriceChangePerTickExceeded',
+    ],
+  },
+  /**
+   * Lookup458: pallet_grandpa::StoredState<N>
+   **/
+  PalletGrandpaStoredState: {
+    _enum: {
+      Live: 'Null',
+      PendingPause: {
+        scheduledAt: 'u32',
+        delay: 'u32',
+      },
+      Paused: 'Null',
+      PendingResume: {
+        scheduledAt: 'u32',
+        delay: 'u32',
+      },
+    },
+  },
+  /**
+   * Lookup459: pallet_grandpa::StoredPendingChange<N, Limit>
+   **/
+  PalletGrandpaStoredPendingChange: {
+    scheduledAt: 'u32',
+    delay: 'u32',
+    nextAuthorities: 'Vec<(SpConsensusGrandpaAppPublic,u64)>',
+    forced: 'Option<u32>',
+  },
+  /**
+   * Lookup461: pallet_grandpa::pallet::Error<T>
+   **/
+  PalletGrandpaError: {
+    _enum: [
+      'PauseFailed',
+      'ResumeFailed',
+      'ChangePending',
+      'TooSoon',
+      'InvalidKeyOwnershipProof',
+      'InvalidEquivocationProof',
+      'DuplicateOffenceReport',
+    ],
+  },
+  /**
+   * Lookup462: argon_primitives::providers::BlockSealerInfo<sp_core::crypto::AccountId32, argon_primitives::block_seal::app::Public>
+   **/
+  ArgonPrimitivesProvidersBlockSealerInfo: {
+    blockAuthorAccountId: 'AccountId32',
+    blockVoteRewardsAccount: 'Option<AccountId32>',
+    blockSealAuthority: 'Option<ArgonPrimitivesBlockSealAppPublic>',
+  },
+  /**
+   * Lookup464: pallet_block_seal::pallet::Error<T>
+   **/
+  PalletBlockSealError: {
+    _enum: [
+      'InvalidVoteSealStrength',
+      'InvalidSubmitter',
+      'UnableToDecodeVoteAccount',
+      'UnregisteredBlockAuthor',
+      'InvalidBlockVoteProof',
+      'NoGrandparentVoteMinimum',
+      'DuplicateBlockSealProvided',
+      'InsufficientVotingPower',
+      'ParentVotingKeyNotFound',
+      'InvalidVoteGrandparentHash',
+      'IneligibleNotebookUsed',
+      'NoEligibleVotingRoot',
+      'CouldNotDecodeVote',
+      'MaxNotebooksAtTickExceeded',
+      'NoClosestMinerFoundForVote',
+      'BlockVoteInvalidSignature',
+      'InvalidForkPowerParent',
+      'BlockSealDecodeError',
+      'InvalidComputeBlockTick',
+      'InvalidMinerNonceScore',
+      'DuplicateVoteBlockAtTick',
+    ],
+  },
+  /**
+   * Lookup468: pallet_block_rewards::pallet::Error<T>
+   **/
+  PalletBlockRewardsError: 'Null',
+  /**
+   * Lookup474: pallet_mint::pallet::MintAction<B>
+   **/
+  PalletMintMintAction: {
+    argonBurned: 'u128',
+    argonMinted: 'u128',
+    bitcoinMinted: 'u128',
+  },
+  /**
+   * Lookup475: pallet_mint::pallet::Error<T>
+   **/
+  PalletMintError: {
+    _enum: ['TooManyPendingMints'],
+  },
+  /**
+   * Lookup477: pallet_balances::types::BalanceLock<Balance>
+   **/
+  PalletBalancesBalanceLock: {
+    id: '[u8;8]',
+    amount: 'u128',
+    reasons: 'PalletBalancesReasons',
+  },
+  /**
+   * Lookup478: pallet_balances::types::Reasons
+   **/
+  PalletBalancesReasons: {
+    _enum: ['Fee', 'Misc', 'All'],
+  },
+  /**
+   * Lookup481: pallet_balances::types::ReserveData<ReserveIdentifier, Balance>
+   **/
+  PalletBalancesReserveData: {
+    id: '[u8;8]',
+    amount: 'u128',
+  },
+  /**
+   * Lookup484: frame_support::traits::tokens::misc::IdAmount<argon_runtime::RuntimeHoldReason, Balance>
+   **/
+  FrameSupportTokensMiscIdAmountRuntimeHoldReason: {
+    id: 'ArgonRuntimeRuntimeHoldReason',
+    amount: 'u128',
+  },
+  /**
+   * Lookup487: frame_support::traits::tokens::misc::IdAmount<argon_runtime::RuntimeFreezeReason, Balance>
+   **/
+  FrameSupportTokensMiscIdAmountRuntimeFreezeReason: {
+    id: 'ArgonRuntimeRuntimeFreezeReason',
+    amount: 'u128',
+  },
+  /**
+   * Lookup488: argon_runtime::RuntimeFreezeReason
+   **/
+  ArgonRuntimeRuntimeFreezeReason: {
+    _enum: {
+      __Unused0: 'Null',
+      __Unused1: 'Null',
+      __Unused2: 'Null',
+      __Unused3: 'Null',
+      __Unused4: 'Null',
+      __Unused5: 'Null',
+      __Unused6: 'Null',
+      __Unused7: 'Null',
+      __Unused8: 'Null',
+      __Unused9: 'Null',
+      __Unused10: 'Null',
+      __Unused11: 'Null',
+      __Unused12: 'Null',
+      __Unused13: 'Null',
+      __Unused14: 'Null',
+      __Unused15: 'Null',
+      __Unused16: 'Null',
+      __Unused17: 'Null',
+      __Unused18: 'Null',
+      BlockRewards: 'PalletBlockRewardsFreezeReason',
+    },
+  },
+  /**
+   * Lookup489: pallet_block_rewards::pallet::FreezeReason
+   **/
+  PalletBlockRewardsFreezeReason: {
+    _enum: ['MaturationPeriod'],
+  },
+  /**
+   * Lookup491: pallet_balances::pallet::Error<T, I>
+   **/
+  PalletBalancesError: {
+    _enum: [
+      'VestingBalance',
+      'LiquidityRestrictions',
+      'InsufficientBalance',
+      'ExistentialDeposit',
+      'Expendability',
+      'ExistingVestingSchedule',
+      'DeadAccount',
+      'TooManyReserves',
+      'TooManyHolds',
+      'TooManyFreezes',
+      'IssuanceDeactivated',
+      'DeltaZero',
+    ],
+  },
+  /**
+   * Lookup493: pallet_tx_pause::pallet::Error<T>
+   **/
+  PalletTxPauseError: {
+    _enum: ['IsPaused', 'IsUnpaused', 'Unpausable', 'NotFound'],
+  },
+  /**
+   * Lookup494: pallet_transaction_payment::Releases
+   **/
+  PalletTransactionPaymentReleases: {
+    _enum: ['V1Ancient', 'V2'],
+  },
+  /**
+   * Lookup495: frame_support::traits::storage::NoDrop<frame_support::traits::tokens::fungible::imbalance::Imbalance<B, OnDrop, OppositeOnDrop>>
+   **/
+  FrameSupportStorageNoDrop: 'FrameSupportTokensFungibleImbalance',
+  /**
+   * Lookup496: frame_support::traits::tokens::fungible::imbalance::Imbalance<B, OnDrop, OppositeOnDrop>
+   **/
+  FrameSupportTokensFungibleImbalance: {
+    amount: 'u128',
+  },
+  /**
+   * Lookup497: pallet_utility::pallet::Error<T>
+   **/
+  PalletUtilityError: {
+    _enum: ['TooManyCalls'],
+  },
+  /**
+   * Lookup498: pallet_sudo::pallet::Error<T>
+   **/
+  PalletSudoError: {
+    _enum: ['RequireSudo'],
+  },
+  /**
+   * Lookup499: pallet_treasury::pallet::FrameVaultCapital<T>
+   **/
+  PalletTreasuryFrameVaultCapital: {
+    frameId: 'Compact<u64>',
+    vaults: 'BTreeMap<u32, PalletTreasuryVaultCapital>',
+  },
+  /**
+   * Lookup501: pallet_treasury::pallet::VaultCapital<T>
+   **/
+  PalletTreasuryVaultCapital: {
+    bondLotAllocations: 'Vec<PalletTreasuryBondLotAllocation>',
+    eligibleBonds: 'Compact<u32>',
+    vaultSharingPercent: 'Compact<Permill>',
+  },
+  /**
+   * Lookup503: pallet_treasury::pallet::BondLotAllocation
+   **/
+  PalletTreasuryBondLotAllocation: {
+    bondLotId: 'Compact<u64>',
+    prorata: 'u128',
+  },
+  /**
+   * Lookup508: pallet_treasury::pallet::BondLot<T>
+   **/
+  PalletTreasuryBondLot: {
+    owner: 'AccountId32',
+    vaultId: 'Compact<u32>',
+    bonds: 'Compact<u32>',
+    createdFrameId: 'Compact<u64>',
+    participatedFrames: 'Compact<u32>',
+    lastFrameEarningsFrameId: 'Option<u64>',
+    lastFrameEarnings: 'Option<u128>',
+    cumulativeEarnings: 'Compact<u128>',
+    releaseFrameId: 'Option<u64>',
+    releaseReason: 'Option<PalletTreasuryBondReleaseReason>',
+  },
+  /**
+   * Lookup513: pallet_treasury::pallet::BondLotSummary
+   **/
+  PalletTreasuryBondLotSummary: {
+    bondLotId: 'Compact<u64>',
+    bonds: 'Compact<u32>',
+  },
+  /**
+   * Lookup515: pallet_treasury::pallet::Error<T>
+   **/
+  PalletTreasuryError: {
+    _enum: [
+      'BondPurchaseRejected',
+      'VaultNotAcceptingBondPurchases',
+      'BondPurchaseBelowMinimum',
+      'InternalError',
+      'MaxAcceptedBondLotsExceeded',
+      'MaxPendingBondReleasesExceeded',
+      'BondLotNotFound',
+      'NotBondLotOwner',
+      'BondLotAlreadyReleasing',
+      'BondPurchaseAboveSecurity',
+    ],
+  },
+  /**
+   * Lookup516: pallet_fee_control::pallet::Error<T>
+   **/
+  PalletFeeControlError: {
+    _enum: ['SponsoredFeeTooHigh'],
+  },
+  /**
+   * Lookup517: pallet_operational_accounts::pallet::OperationalAccount<T>
+   **/
+  PalletOperationalAccountsOperationalAccount: {
+    vaultAccount: 'AccountId32',
+    miningFundingAccount: 'AccountId32',
+    miningBotAccount: 'AccountId32',
+    encryptionPubkey: 'PalletOperationalAccountsOpaqueEncryptionPubkey',
+    sponsor: 'Option<AccountId32>',
+    hasUniswapTransfer: 'bool',
+    vaultCreated: 'bool',
+    bitcoinAccrual: 'u128',
+    bitcoinAppliedTotal: 'u128',
+    hasTreasuryPoolParticipation: 'bool',
+    miningSeatAccrual: 'Compact<u32>',
+    miningSeatAppliedTotal: 'Compact<u32>',
+    operationalReferralsCount: 'Compact<u32>',
+    referralPending: 'bool',
+    availableReferrals: 'Compact<u32>',
+    rewardsEarnedCount: 'Compact<u32>',
+    rewardsEarnedAmount: 'u128',
+    rewardsCollectedAmount: 'u128',
+    isOperational: 'bool',
+  },
+  /**
+   * Lookup519: pallet_operational_accounts::pallet::RewardsConfig<Balance>
+   **/
+  PalletOperationalAccountsRewardsConfig: {
+    operationalReferralReward: 'Compact<u128>',
+    referralBonusReward: 'Compact<u128>',
+  },
+  /**
+   * Lookup521: pallet_operational_accounts::pallet::Error<T>
+   **/
+  PalletOperationalAccountsError: {
+    _enum: [
+      'AlreadyRegistered',
+      'InvalidRegistrationSubmitter',
+      'AccountAlreadyLinked',
+      'InvalidAccountProof',
+      'NotOperationalAccount',
+      'InvalidReferralProof',
+      'ReferralProofExpired',
+      'NoProgressUpdateProvided',
+      'EncryptedServerTooLong',
+      'NotSponsorOfSponsee',
+      'NoPendingRewards',
+      'RewardClaimBelowMinimum',
+      'RewardClaimNotWholeArgon',
+      'RewardClaimExceedsPending',
+      'TreasuryInsufficientFunds',
+      'AlreadyOperational',
+      'NotEligibleForActivation',
+    ],
+  },
+  /**
+   * Lookup522: pallet_ethereum_verifier::types::FinalizedBeaconHeaderState
+   **/
+  PalletEthereumVerifierFinalizedBeaconHeaderState: {
+    slot: 'Compact<u64>',
+  },
+  /**
+   * Lookup523: pallet_ethereum_verifier::types::ExecutionHeaderAnchor
+   **/
+  PalletEthereumVerifierExecutionHeaderAnchor: {
+    blockNumber: 'Compact<u64>',
+    blockHash: 'H256',
+    parentHash: 'H256',
+    receiptsRoot: 'H256',
+  },
+  /**
+   * Lookup524: pallet_ethereum_verifier::types::SyncCommitteePrepared
+   **/
+  PalletEthereumVerifierSyncCommitteePrepared: {
+    root: 'H256',
+    pubkeys: 'Vec<SnowbridgeMilagroBlsKeysPublicKey>',
+    aggregatePubkey: 'SnowbridgeMilagroBlsKeysPublicKey',
+  },
+  /**
+   * Lookup526: snowbridge_milagro_bls::keys::PublicKey
+   **/
+  SnowbridgeMilagroBlsKeysPublicKey: {
+    point: 'SnowbridgeAmclBls381Ecp',
+  },
+  /**
+   * Lookup527: snowbridge_amcl::bls381::ecp::ECP
+   **/
+  SnowbridgeAmclBls381Ecp: {
+    x: 'SnowbridgeAmclBls381Fp',
+    y: 'SnowbridgeAmclBls381Fp',
+    z: 'SnowbridgeAmclBls381Fp',
+  },
+  /**
+   * Lookup528: snowbridge_amcl::bls381::fp::FP
+   **/
+  SnowbridgeAmclBls381Fp: {
+    x: 'SnowbridgeAmclBls381Big',
+    xes: 'i32',
+  },
+  /**
+   * Lookup529: snowbridge_amcl::bls381::big::Big
+   **/
+  SnowbridgeAmclBls381Big: {
+    w: '[i32;14]',
+  },
+  /**
+   * Lookup533: argon_primitives::ethereum::EthereumBeaconPreset
+   **/
+  ArgonPrimitivesEthereumEthereumBeaconPreset: {
+    _enum: ['Mainnet', 'Minimal'],
+  },
+  /**
+   * Lookup534: pallet_ethereum_verifier::pallet::Error<T>
+   **/
+  PalletEthereumVerifierError: {
+    _enum: [
+      'SkippedSyncCommitteePeriod',
+      'SyncCommitteeUpdateRequired',
+      'IrrelevantUpdate',
+      'NotBootstrapped',
+      'SyncCommitteeParticipantsNotSupermajority',
+      'InvalidHeaderMerkleProof',
+      'InvalidSyncCommitteeMerkleProof',
+      'InvalidExecutionHeaderProof',
+      'InvalidFinalizedHeaderGap',
+      'HeaderHashTreeRootFailed',
+      'BlockBodyHashTreeRootFailed',
+      'SyncCommitteeHashTreeRootFailed',
+      'SigningRootHashTreeRootFailed',
+      'ForkDataHashTreeRootFailed',
+      'ExpectedFinalizedHeaderNotStored',
+      'BLSPreparePublicKeysFailed',
+      'BLSVerificationFailed',
+      'UnexpectedBeaconPreset',
+      'InvalidUpdateSlot',
+      'InvalidSyncCommitteeUpdate',
+      'Halted',
+    ],
+  },
+  /**
+   * Lookup535: pallet_crosschain_transfer::pallet::Error<T>
+   **/
+  PalletCrosschainTransferError: {
+    _enum: [
+      'InvalidTransferToArgonActivity',
+      'NoGatewayProofBlocksProvided',
+      'NoGatewayActivitiesProvided',
+      'InvalidProof',
+      'InvalidRecipient',
+      'UnsupportedSource',
+      'UnsupportedGateway',
+      'UnsupportedToken',
+      'UnexpectedPreviousGatewayActivityNonce',
+      'UnexpectedGatewayActivityNonce',
+      'InvalidChainConfig',
+      'InsufficientLiquidity',
+    ],
+  },
+  /**
+   * Lookup538: frame_system::extensions::authorize_call::AuthorizeCall<T>
+   **/
+  FrameSystemExtensionsAuthorizeCall: 'Null',
+  /**
+   * Lookup539: frame_system::extensions::check_non_zero_sender::CheckNonZeroSender<T>
+   **/
+  FrameSystemExtensionsCheckNonZeroSender: 'Null',
+  /**
+   * Lookup540: frame_system::extensions::check_spec_version::CheckSpecVersion<T>
+   **/
+  FrameSystemExtensionsCheckSpecVersion: 'Null',
+  /**
+   * Lookup541: frame_system::extensions::check_tx_version::CheckTxVersion<T>
+   **/
+  FrameSystemExtensionsCheckTxVersion: 'Null',
+  /**
+   * Lookup542: frame_system::extensions::check_genesis::CheckGenesis<T>
+   **/
+  FrameSystemExtensionsCheckGenesis: 'Null',
+  /**
+   * Lookup545: frame_system::extensions::check_nonce::CheckNonce<T>
+   **/
+  FrameSystemExtensionsCheckNonce: 'Compact<u32>',
+  /**
+   * Lookup546: frame_system::extensions::check_weight::CheckWeight<T>
+   **/
+  FrameSystemExtensionsCheckWeight: 'Null',
+  /**
+   * Lookup547: pallet_transaction_payment::ChargeTransactionPayment<T>
+   **/
+  PalletTransactionPaymentChargeTransactionPayment: 'Compact<u128>',
+  /**
+   * Lookup548: frame_metadata_hash_extension::CheckMetadataHash<T>
+   **/
+  FrameMetadataHashExtensionCheckMetadataHash: {
+    mode: 'FrameMetadataHashExtensionMode',
+  },
+  /**
+   * Lookup549: frame_metadata_hash_extension::Mode
+   **/
+  FrameMetadataHashExtensionMode: {
+    _enum: ['Disabled', 'Enabled'],
+  },
+  /**
+   * Lookup550: frame_system::extensions::weight_reclaim::WeightReclaim<T>
+   **/
+  FrameSystemExtensionsWeightReclaim: 'Null',
+  /**
+   * Lookup552: argon_runtime::Runtime
+   **/
+  ArgonRuntimeRuntime: 'Null',
+};