npm - @argonprotocol/mainchain - Versions diffs - 1.4.3-dev.1f0d7a33 → 1.4.3-dev.25eec055 - Mend

@argonprotocol/mainchain 1.4.3-dev.1f0d7a33 → 1.4.3-dev.25eec055

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/browser/index.d.ts +1231 -1464
package/browser/index.js +6860 -91
package/browser/index.js.map +1 -1
package/lib/index.cjs +6990 -162
package/lib/index.cjs.map +1 -1
package/lib/index.d.cts +1231 -1464
package/lib/index.d.ts +1231 -1464
package/lib/index.js +6926 -98
package/lib/index.js.map +1 -1
package/package.json +28 -25
package/src/interfaces/augment-api-consts.ts +610 -0
package/src/interfaces/augment-api-errors.ts +1184 -0
package/src/interfaces/augment-api-events.ts +1831 -0
package/src/interfaces/augment-api-query.ts +1549 -0
package/src/interfaces/augment-api-rpc.ts +1133 -0
package/src/interfaces/augment-api-runtime.ts +305 -0
package/src/interfaces/augment-api-tx.ts +2195 -0
package/src/interfaces/augment-api.ts +9 -0
package/src/interfaces/augment-types.ts +2691 -0
package/src/interfaces/definitions.ts +42 -0
package/src/interfaces/ethereum/index.ts +3 -0
package/src/interfaces/ethereum/types.ts +65 -0
package/src/interfaces/lookup.ts +3797 -0
package/src/interfaces/registry.ts +565 -0
package/src/interfaces/types-lookup.ts +4379 -0

package/src/interfaces/augment-api-tx.ts ADDED Viewed

@@ -0,0 +1,2195 @@
+// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
+/* eslint-disable */
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import type {} from '@polkadot/api-base/types/submittable';
+import type {
+  ApiTypes,
+  AugmentedSubmittable,
+  SubmittableExtrinsic,
+  SubmittableExtrinsicFunction,
+} from '@polkadot/api-base/types';
+import type {
+  Bytes,
+  Compact,
+  Option,
+  U8aFixed,
+  Vec,
+  bool,
+  u128,
+  u16,
+  u32,
+  u64,
+} from '@polkadot/types-codec';
+import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';
+import type { AccountId32, Call, H256, MultiAddress } from '@polkadot/types/interfaces/runtime';
+import type {
+  ArgonPrimitivesBitcoinCompressedBitcoinPubkey,
+  ArgonPrimitivesBitcoinH256Le,
+  ArgonPrimitivesBitcoinOpaqueBitcoinXpub,
+  ArgonPrimitivesBitcoinUtxoRef,
+  ArgonPrimitivesDomainZoneRecord,
+  ArgonPrimitivesEthereumEthereumReceiptLogProofBatch,
+  ArgonPrimitivesInherentsBitcoinUtxoSync,
+  ArgonPrimitivesInherentsBlockSealInherent,
+  ArgonPrimitivesNotaryNotaryMeta,
+  ArgonPrimitivesNotebookSignedNotebookHeader,
+  ArgonPrimitivesVaultVaultTerms,
+  ArgonRuntimeOriginCaller,
+  ArgonRuntimeProxyType,
+  ArgonRuntimeSessionKeys,
+  PalletBalancesAdjustmentDirection,
+  PalletBitcoinLocksLockOptions,
+  PalletCrosschainTransferChainConfig,
+  PalletCrosschainTransferSourceChain,
+  PalletEthereumVerifierBasicOperatingMode,
+  PalletEthereumVerifierCheckpointUpdate,
+  PalletEthereumVerifierExecutionProof,
+  PalletEthereumVerifierForkVersions,
+  PalletEthereumVerifierUpdate,
+  PalletMultisigTimepoint,
+  PalletOperationalAccountsOperationalProgressPatch,
+  PalletOperationalAccountsRegistration,
+  PalletPriceIndexPriceIndex,
+  PalletVaultsVaultConfig,
+  SpConsensusGrandpaEquivocationProof,
+  SpCoreVoid,
+  SpWeightsWeightV2Weight,
+} from '@polkadot/types/lookup';
+export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;
+export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;
+export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> =
+  SubmittableExtrinsicFunction<ApiType>;
+declare module '@polkadot/api-base/types/submittable' {
+  interface AugmentedSubmittables<ApiType extends ApiTypes> {
+    balances: {
+      /**
+       * Burn the specified liquid free balance from the origin account.
+       *
+       * If the origin's account ends up below the existential deposit as a result
+       * of the burn and `keep_alive` is false, the account will be reaped.
+       *
+       * Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible,
+       * this `burn` operation will reduce total issuance by the amount _burned_.
+       **/
+      burn: AugmentedSubmittable<
+        (
+          value: Compact<u128> | AnyNumber | Uint8Array,
+          keepAlive: bool | boolean | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [Compact<u128>, bool]
+      >;
+      /**
+       * Adjust the total issuance in a saturating way.
+       *
+       * Can only be called by root and always needs a positive `delta`.
+       *
+       * # Example
+       **/
+      forceAdjustTotalIssuance: AugmentedSubmittable<
+        (
+          direction:
+            | PalletBalancesAdjustmentDirection
+            | 'Increase'
+            | 'Decrease'
+            | number
+            | Uint8Array,
+          delta: Compact<u128> | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [PalletBalancesAdjustmentDirection, Compact<u128>]
+      >;
+      /**
+       * Set the regular balance of a given account.
+       *
+       * The dispatch origin for this call is `root`.
+       **/
+      forceSetBalance: AugmentedSubmittable<
+        (
+          who:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          newFree: Compact<u128> | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, Compact<u128>]
+      >;
+      /**
+       * Exactly as `transfer_allow_death`, except the origin must be root and the source account
+       * may be specified.
+       **/
+      forceTransfer: AugmentedSubmittable<
+        (
+          source:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          dest:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          value: Compact<u128> | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, MultiAddress, Compact<u128>]
+      >;
+      /**
+       * Unreserve some balance from a user by force.
+       *
+       * Can only be called by ROOT.
+       **/
+      forceUnreserve: AugmentedSubmittable<
+        (
+          who:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          amount: u128 | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, u128]
+      >;
+      /**
+       * Transfer the entire transferable balance from the caller account.
+       *
+       * NOTE: This function only attempts to transfer _transferable_ balances. This means that
+       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be
+       * transferred by this function. To ensure that this function results in a killed account,
+       * you might need to prepare the account by removing any reference counters, storage
+       * deposits, etc...
+       *
+       * The dispatch origin of this call must be Signed.
+       *
+       * - `dest`: The recipient of the transfer.
+       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all
+       * of the funds the account has, causing the sender account to be killed (false), or
+       * transfer everything except at least the existential deposit, which will guarantee to
+       * keep the sender account alive (true).
+       **/
+      transferAll: AugmentedSubmittable<
+        (
+          dest:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          keepAlive: bool | boolean | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, bool]
+      >;
+      /**
+       * Transfer some liquid free balance to another account.
+       *
+       * `transfer_allow_death` will set the `FreeBalance` of the sender and receiver.
+       * If the sender's account is below the existential deposit as a result
+       * of the transfer, the account will be reaped.
+       *
+       * The dispatch origin for this call must be `Signed` by the transactor.
+       **/
+      transferAllowDeath: AugmentedSubmittable<
+        (
+          dest:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          value: Compact<u128> | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, Compact<u128>]
+      >;
+      /**
+       * Same as the [`transfer_allow_death`] call, but with a check that the transfer will not
+       * kill the origin account.
+       *
+       * 99% of the time you want [`transfer_allow_death`] instead.
+       *
+       * [`transfer_allow_death`]: struct.Pallet.html#method.transfer
+       **/
+      transferKeepAlive: AugmentedSubmittable<
+        (
+          dest:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          value: Compact<u128> | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, Compact<u128>]
+      >;
+      /**
+       * Upgrade a specified account.
+       *
+       * - `origin`: Must be `Signed`.
+       * - `who`: The account to be upgraded.
+       *
+       * This will waive the transaction fee if at least all but 10% of the accounts needed to
+       * be upgraded. (We let some not have to be upgraded just in order to allow for the
+       * possibility of churn).
+       **/
+      upgradeAccounts: AugmentedSubmittable<
+        (
+          who: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[],
+        ) => SubmittableExtrinsic<ApiType>,
+        [Vec<AccountId32>]
+      >;
+    };
+    bitcoinLocks: {
+      adminModifyMinimumLockedSats: AugmentedSubmittable<
+        (satoshis: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [u64]
+      >;
+      /**
+       * NOTE: The `signature` parameter is NOT verified on-chain. The orphan record does
+       * not retain the cosign script args needed for verification (they are cleaned up
+       * with the BitcoinLock). The signature is passed through to the
+       * `OrphanedUtxoCosigned` event so the lock owner can construct the Bitcoin release
+       * transaction off-chain. A garbage signature means the owner can't spend — no
+       * on-chain damage. To add on-chain verification, the cosign script args would need
+       * to be stored in `OrphanedUtxo` (storage migration required).
+       **/
+      cosignOrphanedUtxoRelease: AugmentedSubmittable<
+        (
+          orphanOwner: AccountId32 | string | Uint8Array,
+          utxoRef:
+            | ArgonPrimitivesBitcoinUtxoRef
+            | { txid?: any; outputIndex?: any }
+            | string
+            | Uint8Array,
+          signature: Bytes | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [AccountId32, ArgonPrimitivesBitcoinUtxoRef, Bytes]
+      >;
+      /**
+       * Submitted by a Vault operator to cosign the release of a bitcoin utxo. The Bitcoin owner
+       * release fee will be burned, and the lock will be allowed to expire without a penalty.
+       *
+       * This is submitted as a no-fee transaction off chain to allow keys to remain in cold
+       * wallets.
+       **/
+      cosignRelease: AugmentedSubmittable<
+        (
+          utxoId: u64 | AnyNumber | Uint8Array,
+          signature: Bytes | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u64, Bytes]
+      >;
+      increaseSecuritization: AugmentedSubmittable<
+        (
+          utxoId: u64 | AnyNumber | Uint8Array,
+          newSatoshis: Compact<u64> | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u64, Compact<u64>]
+      >;
+      /**
+       * Initialize a bitcoin lock. This will create a LockedBitcoin for the submitting account
+       * and log the Bitcoin Script hash to Events.
+       *
+       * The pubkey submitted here will be used to create a script pubkey that will be used in a
+       * timelock multisig script to lock the bitcoin.
+       *
+       * NOTE: A "lock-er" must send btc to the cosigner UTXO address to "complete" the
+       * LockedBitcoin and be added to the Bitcoin Mint line.
+       **/
+      initialize: AugmentedSubmittable<
+        (
+          vaultId: u32 | AnyNumber | Uint8Array,
+          satoshis: Compact<u64> | AnyNumber | Uint8Array,
+          bitcoinPubkey: ArgonPrimitivesBitcoinCompressedBitcoinPubkey | string | Uint8Array,
+          options:
+            | Option<PalletBitcoinLocksLockOptions>
+            | null
+            | Uint8Array
+            | PalletBitcoinLocksLockOptions
+            | { V1: any }
+            | string,
+        ) => SubmittableExtrinsic<ApiType>,
+        [
+          u32,
+          Compact<u64>,
+          ArgonPrimitivesBitcoinCompressedBitcoinPubkey,
+          Option<PalletBitcoinLocksLockOptions>,
+        ]
+      >;
+      initializeFor: AugmentedSubmittable<
+        (
+          accountId: AccountId32 | string | Uint8Array,
+          vaultId: u32 | AnyNumber | Uint8Array,
+          satoshis: Compact<u64> | AnyNumber | Uint8Array,
+          bitcoinPubkey: ArgonPrimitivesBitcoinCompressedBitcoinPubkey | string | Uint8Array,
+          options:
+            | Option<PalletBitcoinLocksLockOptions>
+            | null
+            | Uint8Array
+            | PalletBitcoinLocksLockOptions
+            | { V1: any }
+            | string,
+        ) => SubmittableExtrinsic<ApiType>,
+        [
+          AccountId32,
+          u32,
+          Compact<u64>,
+          ArgonPrimitivesBitcoinCompressedBitcoinPubkey,
+          Option<PalletBitcoinLocksLockOptions>,
+        ]
+      >;
+      /**
+       * Ratcheting allows a user to change the lock price of their bitcoin lock. This is
+       * functionally the same as releasing and re-initializing, but it allows a user to skip
+       * sending transactions through bitcoin and any associated fees. It also allows you to stay
+       * on your original lock expiration without having to pay the full year of fees again.
+       *
+       * Ratcheting "down" - when the price of bitcoin is lower than your lock price, you pay the
+       * full release price and get added back to the mint queue at the current market rate. You
+       * pocket the difference between the already minted "lock price" and the new market value
+       * (which you just had burned). Your new lock price is set to the market low, so you can
+       * take advantage of ratchets "up" in the future.
+       *
+       * Ratcheting "up" - when the price of bitcoin is higher than your lock price, you pay a
+       * prorated fee for the remainder of your existing lock duration. You are added to the mint
+       * queue for the difference in your new lock price vs the previous lock price.
+       **/
+      ratchet: AugmentedSubmittable<
+        (
+          utxoId: u64 | AnyNumber | Uint8Array,
+          options:
+            | Option<PalletBitcoinLocksLockOptions>
+            | null
+            | Uint8Array
+            | PalletBitcoinLocksLockOptions
+            | { V1: any }
+            | string,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u64, Option<PalletBitcoinLocksLockOptions>]
+      >;
+      requestOrphanedUtxoRelease: AugmentedSubmittable<
+        (
+          utxoRef:
+            | ArgonPrimitivesBitcoinUtxoRef
+            | { txid?: any; outputIndex?: any }
+            | string
+            | Uint8Array,
+          toScriptPubkey: Bytes | string | Uint8Array,
+          bitcoinNetworkFee: u64 | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [ArgonPrimitivesBitcoinUtxoRef, Bytes, u64]
+      >;
+      /**
+       * Submitted by a Bitcoin holder to trigger the release of their Utxo out of the cosign
+       * script. A transaction spending the UTXO should be pre-created so that the sighash
+       * can be submitted here. The vault operator will have 10 days to counter-sign the
+       * transaction. It will be published with the public key as a BitcoinUtxoCosigned Event.
+       *
+       * Owner must submit a script pubkey and also a fee to pay to the bitcoin network.
+       **/
+      requestRelease: AugmentedSubmittable<
+        (
+          utxoId: u64 | AnyNumber | Uint8Array,
+          toScriptPubkey: Bytes | string | Uint8Array,
+          bitcoinNetworkFee: u64 | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u64, Bytes, u64]
+      >;
+    };
+    bitcoinUtxos: {
+      /**
+       * Bind a candidate UTXO ref as the funding UTXO for its lock.
+       * The locks pallet authorizes the promotion; this pallet binds the ref and begins
+       * tracking.
+       **/
+      fundWithUtxoCandidate: AugmentedSubmittable<
+        (
+          utxoId: u64 | AnyNumber | Uint8Array,
+          utxoRef:
+            | ArgonPrimitivesBitcoinUtxoRef
+            | { txid?: any; outputIndex?: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u64, ArgonPrimitivesBitcoinUtxoRef]
+      >;
+      /**
+       * Reject a pending candidate UTXO and materialize it as an orphan through the locks
+       * pallet.
+       **/
+      rejectUtxoCandidate: AugmentedSubmittable<
+        (
+          utxoId: u64 | AnyNumber | Uint8Array,
+          utxoRef:
+            | ArgonPrimitivesBitcoinUtxoRef
+            | { txid?: any; outputIndex?: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u64, ArgonPrimitivesBitcoinUtxoRef]
+      >;
+      /**
+       * Sets the most recent confirmed bitcoin block height (only executable by the Oracle
+       * Operator account)
+       *
+       * # Arguments
+       * * `bitcoin_height` - the latest bitcoin block height to be confirmed
+       **/
+      setConfirmedBlock: AugmentedSubmittable<
+        (
+          bitcoinHeight: u64 | AnyNumber | Uint8Array,
+          bitcoinBlockHash: ArgonPrimitivesBitcoinH256Le | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u64, ArgonPrimitivesBitcoinH256Le]
+      >;
+      /**
+       * Sets the oracle operator account id (only executable by the Root account)
+       *
+       * # Arguments
+       * * `account_id` - the account id of the operator
+       **/
+      setOperator: AugmentedSubmittable<
+        (accountId: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [AccountId32]
+      >;
+      /**
+       * Submitted when a bitcoin UTXO has been moved or confirmed.
+       **/
+      sync: AugmentedSubmittable<
+        (
+          utxoSync:
+            | ArgonPrimitivesInherentsBitcoinUtxoSync
+            | { spent?: any; funded?: any; syncToBlock?: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [ArgonPrimitivesInherentsBitcoinUtxoSync]
+      >;
+    };
+    blockRewards: {
+      setBlockRewardsPaused: AugmentedSubmittable<
+        (paused: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [bool]
+      >;
+    };
+    blockSeal: {
+      apply: AugmentedSubmittable<
+        (
+          seal:
+            | ArgonPrimitivesInherentsBlockSealInherent
+            | { Vote: any }
+            | { Compute: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [ArgonPrimitivesInherentsBlockSealInherent]
+      >;
+    };
+    blockSealSpec: {
+      configure: AugmentedSubmittable<
+        (
+          voteMinimum: Option<u128> | null | Uint8Array | u128 | AnyNumber,
+          computeDifficulty: Option<u128> | null | Uint8Array | u128 | AnyNumber,
+        ) => SubmittableExtrinsic<ApiType>,
+        [Option<u128>, Option<u128>]
+      >;
+    };
+    crosschainTransfer: {
+      proveGatewayActivity: AugmentedSubmittable<
+        (
+          sourceChain: PalletCrosschainTransferSourceChain | 'Ethereum' | number | Uint8Array,
+          previousGatewayActivityNonce: Compact<u64> | AnyNumber | Uint8Array,
+          proofBatch:
+            | ArgonPrimitivesEthereumEthereumReceiptLogProofBatch
+            | { executionBlockProof?: any; blocks?: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [
+          PalletCrosschainTransferSourceChain,
+          Compact<u64>,
+          ArgonPrimitivesEthereumEthereumReceiptLogProofBatch,
+        ]
+      >;
+      setChainConfig: AugmentedSubmittable<
+        (
+          config: PalletCrosschainTransferChainConfig | { Ethereum: any } | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [PalletCrosschainTransferChainConfig]
+      >;
+    };
+    domains: {
+      setZoneRecord: AugmentedSubmittable<
+        (
+          domainHash: H256 | string | Uint8Array,
+          zoneRecord:
+            | ArgonPrimitivesDomainZoneRecord
+            | { paymentAccount?: any; notaryId?: any; versions?: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [H256, ArgonPrimitivesDomainZoneRecord]
+      >;
+    };
+    ethereumVerifier: {
+      /**
+       * Used for pallet initialization and light client resetting. Needs to be called by
+       * the root origin.
+       **/
+      forceCheckpoint: AugmentedSubmittable<
+        (
+          update:
+            | PalletEthereumVerifierCheckpointUpdate
+            | {
+                header?: any;
+                currentSyncCommittee?: any;
+                currentSyncCommitteeBranch?: any;
+                validatorsRoot?: any;
+              }
+            | string
+            | Uint8Array,
+          forkVersions:
+            | PalletEthereumVerifierForkVersions
+            | {
+                genesis?: any;
+                altair?: any;
+                bellatrix?: any;
+                capella?: any;
+                deneb?: any;
+                electra?: any;
+                fulu?: any;
+              }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [PalletEthereumVerifierCheckpointUpdate, PalletEthereumVerifierForkVersions]
+      >;
+      /**
+       * Imports a proven execution header anchor against already-retained beacon state.
+       **/
+      importExecutionHeaderAnchor: AugmentedSubmittable<
+        (
+          executionProof:
+            | PalletEthereumVerifierExecutionProof
+            | { header?: any; executionHeader?: any; executionBranch?: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [PalletEthereumVerifierExecutionProof]
+      >;
+      /**
+       * Halt or resume all pallet operations. May only be called by root.
+       **/
+      setOperatingMode: AugmentedSubmittable<
+        (
+          mode:
+            | PalletEthereumVerifierBasicOperatingMode
+            | 'Normal'
+            | 'Halted'
+            | number
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [PalletEthereumVerifierBasicOperatingMode]
+      >;
+      /**
+       * Submits a new finalized beacon header update. The update may contain the next
+       * sync committee.
+       **/
+      submit: AugmentedSubmittable<
+        (
+          update:
+            | PalletEthereumVerifierUpdate
+            | {
+                attestedHeader?: any;
+                syncAggregate?: any;
+                signatureSlot?: any;
+                nextSyncCommitteeUpdate?: any;
+                finalizedHeader?: any;
+                finalityBranch?: any;
+              }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [PalletEthereumVerifierUpdate]
+      >;
+    };
+    grandpa: {
+      /**
+       * Note that the current authority set of the GRANDPA finality gadget has stalled.
+       *
+       * This will trigger a forced authority set change at the beginning of the next session, to
+       * be enacted `delay` blocks after that. The `delay` should be high enough to safely assume
+       * that the block signalling the forced change will not be re-orged e.g. 1000 blocks.
+       * The block production rate (which may be slowed down because of finality lagging) should
+       * be taken into account when choosing the `delay`. The GRANDPA voters based on the new
+       * authority will start voting on top of `best_finalized_block_number` for new finalized
+       * blocks. `best_finalized_block_number` should be the highest of the latest finalized
+       * block of all validators of the new authority set.
+       *
+       * Only callable by root.
+       **/
+      noteStalled: AugmentedSubmittable<
+        (
+          delay: u32 | AnyNumber | Uint8Array,
+          bestFinalizedBlockNumber: u32 | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u32, u32]
+      >;
+      /**
+       * Report voter equivocation/misbehavior. This method will verify the
+       * equivocation proof and validate the given key ownership proof
+       * against the extracted offender. If both are valid, the offence
+       * will be reported.
+       **/
+      reportEquivocation: AugmentedSubmittable<
+        (
+          equivocationProof:
+            | SpConsensusGrandpaEquivocationProof
+            | { setId?: any; equivocation?: any }
+            | string
+            | Uint8Array,
+          keyOwnerProof: SpCoreVoid | null,
+        ) => SubmittableExtrinsic<ApiType>,
+        [SpConsensusGrandpaEquivocationProof, SpCoreVoid]
+      >;
+      /**
+       * Report voter equivocation/misbehavior. This method will verify the
+       * equivocation proof and validate the given key ownership proof
+       * against the extracted offender. If both are valid, the offence
+       * will be reported.
+       *
+       * This extrinsic must be called unsigned and it is expected that only
+       * block authors will call it (validated in `ValidateUnsigned`), as such
+       * if the block author is defined it will be defined as the equivocation
+       * reporter.
+       **/
+      reportEquivocationUnsigned: AugmentedSubmittable<
+        (
+          equivocationProof:
+            | SpConsensusGrandpaEquivocationProof
+            | { setId?: any; equivocation?: any }
+            | string
+            | Uint8Array,
+          keyOwnerProof: SpCoreVoid | null,
+        ) => SubmittableExtrinsic<ApiType>,
+        [SpConsensusGrandpaEquivocationProof, SpCoreVoid]
+      >;
+    };
+    localchainTransfer: {
+      sendToLocalchain: AugmentedSubmittable<
+        (
+          amount: Compact<u128> | AnyNumber | Uint8Array,
+          notaryId: u32 | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [Compact<u128>, u32]
+      >;
+    };
+    miningSlot: {
+      /**
+       * Submit a bid for a mining slot in the next cohort. Once all spots are filled in the next
+       * cohort, a bidder can be supplanted by supplying a higher bid.
+       *
+       * Each slot has `MaxCohortSize` spots available.
+       *
+       * To be eligible for a slot, you must have the required ownership tokens (argonots) in
+       * this account. The required amount is calculated as a percentage of the total ownership
+       * tokens in the network. This percentage is adjusted before the beginning of each slot.
+       *
+       * If your bid is no longer winning, a `SlotBidderDropped` event will be emitted. By
+       * monitoring for this event, you will be able to ensure your bid is accepted.
+       *
+       * NOTE: bidding for each slot will be closed at a random block within
+       * `mining_config.ticks_before_bid_end_for_vrf_close` blocks of the slot end time.
+       *
+       * The slot duration can be calculated as `BlocksBetweenSlots * MaxMiners / MaxCohortSize`.
+       *
+       * Parameters:
+       * - `bid`: The amount of argons to bid
+       * - `keys`: The session "hot" keys for the slot (BlockSealAuthorityId and GrandpaId).
+       * - `mining_account_id`: This account_id allows you to operate as this miner account id,
+       * but use funding (argonots and bid) from the submitting account
+       **/
+      bid: AugmentedSubmittable<
+        (
+          bid: u128 | AnyNumber | Uint8Array,
+          keys:
+            | ArgonRuntimeSessionKeys
+            | { grandpa?: any; blockSealAuthority?: any }
+            | string
+            | Uint8Array,
+          miningAccountId: Option<AccountId32> | null | Uint8Array | AccountId32 | string,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u128, ArgonRuntimeSessionKeys, Option<AccountId32>]
+      >;
+      /**
+       * Admin function to update the mining slot delay.
+       **/
+      configureMiningSlotDelay: AugmentedSubmittable<
+        (
+          miningSlotDelay: Option<u64> | null | Uint8Array | u64 | AnyNumber,
+          ticksBeforeBidEndForVrfClose: Option<u64> | null | Uint8Array | u64 | AnyNumber,
+        ) => SubmittableExtrinsic<ApiType>,
+        [Option<u64>, Option<u64>]
+      >;
+    };
+    mint: {};
+    multisig: {
+      /**
+       * Register approval for a dispatch to be made from a deterministic composite account if
+       * approved by a total of `threshold - 1` of `other_signatories`.
+       *
+       * **This function will NEVER execute the call, even if the approval threshold is
+       * reached.** It only registers approval. To actually execute the call, `as_multi` must
+       * be called with the full call data by any of the signatories.
+       *
+       * This function is more efficient than `as_multi` for intermediate approvals since it
+       * only requires the call hash, not the full call data.
+       *
+       * Payment: `DepositBase` will be reserved if this is the first approval, plus
+       * `threshold` times `DepositFactor`. It is returned once this dispatch happens or
+       * is cancelled.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       *
+       * - `threshold`: The total number of approvals for this dispatch before it is executed.
+       * - `other_signatories`: The accounts (other than the sender) who can approve this
+       * dispatch. May not be empty.
+       * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is
+       * not the first approval, then it must be `Some`, with the timepoint (block number and
+       * transaction index) of the first approval transaction.
+       * - `call_hash`: The hash of the call to be executed.
+       *
+       * NOTE: To execute the call after approvals are gathered, any signatory must call
+       * `as_multi` with the full call data. This function cannot execute the call.
+       *
+       * ## Complexity
+       * - `O(S)`.
+       * - Up to one balance-reserve or unreserve operation.
+       * - One passthrough operation, one insert, both `O(S)` where `S` is the number of
+       * signatories. `S` is capped by `MaxSignatories`, with weight being proportional.
+       * - One encode & hash, both of complexity `O(S)`.
+       * - Up to one binary search and insert (`O(logS + S)`).
+       * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove.
+       * - One event.
+       * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit
+       * taken for its lifetime of `DepositBase + threshold * DepositFactor`.
+       **/
+      approveAsMulti: AugmentedSubmittable<
+        (
+          threshold: u16 | AnyNumber | Uint8Array,
+          otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[],
+          maybeTimepoint:
+            | Option<PalletMultisigTimepoint>
+            | null
+            | Uint8Array
+            | PalletMultisigTimepoint
+            | { height?: any; index?: any }
+            | string,
+          callHash: U8aFixed | string | Uint8Array,
+          maxWeight:
+            | SpWeightsWeightV2Weight
+            | { refTime?: any; proofSize?: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u16, Vec<AccountId32>, Option<PalletMultisigTimepoint>, U8aFixed, SpWeightsWeightV2Weight]
+      >;
+      /**
+       * Register approval for a dispatch to be made from a deterministic composite account if
+       * approved by a total of `threshold - 1` of `other_signatories`.
+       *
+       * **If the approval threshold is met (including the sender's approval), this will
+       * immediately execute the call.** This is the only way to execute a multisig call -
+       * `approve_as_multi` will never trigger execution.
+       *
+       * Payment: `DepositBase` will be reserved if this is the first approval, plus
+       * `threshold` times `DepositFactor`. It is returned once this dispatch happens or
+       * is cancelled.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       *
+       * - `threshold`: The total number of approvals for this dispatch before it is executed.
+       * - `other_signatories`: The accounts (other than the sender) who can approve this
+       * dispatch. May not be empty.
+       * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is
+       * not the first approval, then it must be `Some`, with the timepoint (block number and
+       * transaction index) of the first approval transaction.
+       * - `call`: The call to be executed.
+       *
+       * NOTE: For intermediate approvals (not the final approval), you should generally use
+       * `approve_as_multi` instead, since it only requires a hash of the call and is more
+       * efficient.
+       *
+       * Result is equivalent to the dispatched result if `threshold` is exactly `1`. Otherwise
+       * on success, result is `Ok` and the result from the interior call, if it was executed,
+       * may be found in the deposited `MultisigExecuted` event.
+       *
+       * ## Complexity
+       * - `O(S + Z + Call)`.
+       * - Up to one balance-reserve or unreserve operation.
+       * - One passthrough operation, one insert, both `O(S)` where `S` is the number of
+       * signatories. `S` is capped by `MaxSignatories`, with weight being proportional.
+       * - One call encode & hash, both of complexity `O(Z)` where `Z` is tx-len.
+       * - One encode & hash, both of complexity `O(S)`.
+       * - Up to one binary search and insert (`O(logS + S)`).
+       * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove.
+       * - One event.
+       * - The weight of the `call`.
+       * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit
+       * taken for its lifetime of `DepositBase + threshold * DepositFactor`.
+       **/
+      asMulti: AugmentedSubmittable<
+        (
+          threshold: u16 | AnyNumber | Uint8Array,
+          otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[],
+          maybeTimepoint:
+            | Option<PalletMultisigTimepoint>
+            | null
+            | Uint8Array
+            | PalletMultisigTimepoint
+            | { height?: any; index?: any }
+            | string,
+          call: Call | IMethod | string | Uint8Array,
+          maxWeight:
+            | SpWeightsWeightV2Weight
+            | { refTime?: any; proofSize?: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u16, Vec<AccountId32>, Option<PalletMultisigTimepoint>, Call, SpWeightsWeightV2Weight]
+      >;
+      /**
+       * Immediately dispatch a multi-signature call using a single approval from the caller.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       *
+       * - `other_signatories`: The accounts (other than the sender) who are part of the
+       * multi-signature, but do not participate in the approval process.
+       * - `call`: The call to be executed.
+       *
+       * Result is equivalent to the dispatched result.
+       *
+       * ## Complexity
+       * O(Z + C) where Z is the length of the call and C its execution weight.
+       **/
+      asMultiThreshold1: AugmentedSubmittable<
+        (
+          otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[],
+          call: Call | IMethod | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [Vec<AccountId32>, Call]
+      >;
+      /**
+       * Cancel a pre-existing, on-going multisig transaction. Any deposit reserved previously
+       * for this operation will be unreserved on success.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       *
+       * - `threshold`: The total number of approvals for this dispatch before it is executed.
+       * - `other_signatories`: The accounts (other than the sender) who can approve this
+       * dispatch. May not be empty.
+       * - `timepoint`: The timepoint (block number and transaction index) of the first approval
+       * transaction for this dispatch.
+       * - `call_hash`: The hash of the call to be executed.
+       *
+       * ## Complexity
+       * - `O(S)`.
+       * - Up to one balance-reserve or unreserve operation.
+       * - One passthrough operation, one insert, both `O(S)` where `S` is the number of
+       * signatories. `S` is capped by `MaxSignatories`, with weight being proportional.
+       * - One encode & hash, both of complexity `O(S)`.
+       * - One event.
+       * - I/O: 1 read `O(S)`, one remove.
+       * - Storage: removes one item.
+       **/
+      cancelAsMulti: AugmentedSubmittable<
+        (
+          threshold: u16 | AnyNumber | Uint8Array,
+          otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[],
+          timepoint: PalletMultisigTimepoint | { height?: any; index?: any } | string | Uint8Array,
+          callHash: U8aFixed | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u16, Vec<AccountId32>, PalletMultisigTimepoint, U8aFixed]
+      >;
+      /**
+       * Poke the deposit reserved for an existing multisig operation.
+       *
+       * The dispatch origin for this call must be _Signed_ and must be the original depositor of
+       * the multisig operation.
+       *
+       * The transaction fee is waived if the deposit amount has changed.
+       *
+       * - `threshold`: The total number of approvals needed for this multisig.
+       * - `other_signatories`: The accounts (other than the sender) who are part of the
+       * multisig.
+       * - `call_hash`: The hash of the call this deposit is reserved for.
+       *
+       * Emits `DepositPoked` if successful.
+       **/
+      pokeDeposit: AugmentedSubmittable<
+        (
+          threshold: u16 | AnyNumber | Uint8Array,
+          otherSignatories: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[],
+          callHash: U8aFixed | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u16, Vec<AccountId32>, U8aFixed]
+      >;
+    };
+    notaries: {
+      activate: AugmentedSubmittable<
+        (operatorAccount: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [AccountId32]
+      >;
+      propose: AugmentedSubmittable<
+        (
+          meta:
+            | ArgonPrimitivesNotaryNotaryMeta
+            | { name?: any; public?: any; hosts?: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [ArgonPrimitivesNotaryNotaryMeta]
+      >;
+      /**
+       * Update the metadata of a notary, to be effective at the given tick height, which must be
+       * >= MetaChangesTickDelay ticks in the future.
+       **/
+      update: AugmentedSubmittable<
+        (
+          notaryId: Compact<u32> | AnyNumber | Uint8Array,
+          meta:
+            | ArgonPrimitivesNotaryNotaryMeta
+            | { name?: any; public?: any; hosts?: any }
+            | string
+            | Uint8Array,
+          effectiveTick: Compact<u64> | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [Compact<u32>, ArgonPrimitivesNotaryNotaryMeta, Compact<u64>]
+      >;
+    };
+    notebook: {
+      submit: AugmentedSubmittable<
+        (
+          notebooks:
+            | Vec<ArgonPrimitivesNotebookSignedNotebookHeader>
+            | (
+                | ArgonPrimitivesNotebookSignedNotebookHeader
+                | { header?: any; signature?: any }
+                | string
+                | Uint8Array
+              )[],
+        ) => SubmittableExtrinsic<ApiType>,
+        [Vec<ArgonPrimitivesNotebookSignedNotebookHeader>]
+      >;
+      unlock: AugmentedSubmittable<
+        (notaryId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [u32]
+      >;
+    };
+    operationalAccounts: {
+      /**
+       * Activate an eligible operational account from any managed account.
+       **/
+      activate: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
+      /**
+       * Claim pending operational rewards to any managed account.
+       **/
+      claimRewards: AugmentedSubmittable<
+        (amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [u128]
+      >;
+      /**
+       * Force-update operational progress markers for an account.
+       **/
+      forceSetProgress: AugmentedSubmittable<
+        (
+          owner: AccountId32 | string | Uint8Array,
+          patch:
+            | PalletOperationalAccountsOperationalProgressPatch
+            | {
+                hasUniswapTransfer?: any;
+                vaultCreated?: any;
+                hasTreasuryPoolParticipation?: any;
+                observedBitcoinTotal?: any;
+                observedMiningSeatTotal?: any;
+              }
+            | string
+            | Uint8Array,
+          updateOperationalProgress: bool | boolean | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [AccountId32, PalletOperationalAccountsOperationalProgressPatch, bool]
+      >;
+      /**
+       * Register vault, mining funding, and bot accounts for an operational account.
+       * Any account in the registration may submit the transaction.
+       * If a referral proof is provided, the registration records the sponsor relationship.
+       **/
+      register: AugmentedSubmittable<
+        (
+          registration: PalletOperationalAccountsRegistration | { V1: any } | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [PalletOperationalAccountsRegistration]
+      >;
+      /**
+       * Store an opaque encrypted sponsor server payload for a sponsored operational account.
+       **/
+      setEncryptedServerForSponsee: AugmentedSubmittable<
+        (
+          sponsee: AccountId32 | string | Uint8Array,
+          encryptedServer: Bytes | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [AccountId32, Bytes]
+      >;
+      /**
+       * Update reward amounts for operational accounts.
+       **/
+      setRewardConfig: AugmentedSubmittable<
+        (
+          operationalReferralReward: u128 | AnyNumber | Uint8Array,
+          referralBonusReward: u128 | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u128, u128]
+      >;
+    };
+    ownership: {
+      /**
+       * Burn the specified liquid free balance from the origin account.
+       *
+       * If the origin's account ends up below the existential deposit as a result
+       * of the burn and `keep_alive` is false, the account will be reaped.
+       *
+       * Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible,
+       * this `burn` operation will reduce total issuance by the amount _burned_.
+       **/
+      burn: AugmentedSubmittable<
+        (
+          value: Compact<u128> | AnyNumber | Uint8Array,
+          keepAlive: bool | boolean | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [Compact<u128>, bool]
+      >;
+      /**
+       * Adjust the total issuance in a saturating way.
+       *
+       * Can only be called by root and always needs a positive `delta`.
+       *
+       * # Example
+       **/
+      forceAdjustTotalIssuance: AugmentedSubmittable<
+        (
+          direction:
+            | PalletBalancesAdjustmentDirection
+            | 'Increase'
+            | 'Decrease'
+            | number
+            | Uint8Array,
+          delta: Compact<u128> | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [PalletBalancesAdjustmentDirection, Compact<u128>]
+      >;
+      /**
+       * Set the regular balance of a given account.
+       *
+       * The dispatch origin for this call is `root`.
+       **/
+      forceSetBalance: AugmentedSubmittable<
+        (
+          who:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          newFree: Compact<u128> | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, Compact<u128>]
+      >;
+      /**
+       * Exactly as `transfer_allow_death`, except the origin must be root and the source account
+       * may be specified.
+       **/
+      forceTransfer: AugmentedSubmittable<
+        (
+          source:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          dest:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          value: Compact<u128> | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, MultiAddress, Compact<u128>]
+      >;
+      /**
+       * Unreserve some balance from a user by force.
+       *
+       * Can only be called by ROOT.
+       **/
+      forceUnreserve: AugmentedSubmittable<
+        (
+          who:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          amount: u128 | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, u128]
+      >;
+      /**
+       * Transfer the entire transferable balance from the caller account.
+       *
+       * NOTE: This function only attempts to transfer _transferable_ balances. This means that
+       * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be
+       * transferred by this function. To ensure that this function results in a killed account,
+       * you might need to prepare the account by removing any reference counters, storage
+       * deposits, etc...
+       *
+       * The dispatch origin of this call must be Signed.
+       *
+       * - `dest`: The recipient of the transfer.
+       * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all
+       * of the funds the account has, causing the sender account to be killed (false), or
+       * transfer everything except at least the existential deposit, which will guarantee to
+       * keep the sender account alive (true).
+       **/
+      transferAll: AugmentedSubmittable<
+        (
+          dest:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          keepAlive: bool | boolean | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, bool]
+      >;
+      /**
+       * Transfer some liquid free balance to another account.
+       *
+       * `transfer_allow_death` will set the `FreeBalance` of the sender and receiver.
+       * If the sender's account is below the existential deposit as a result
+       * of the transfer, the account will be reaped.
+       *
+       * The dispatch origin for this call must be `Signed` by the transactor.
+       **/
+      transferAllowDeath: AugmentedSubmittable<
+        (
+          dest:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          value: Compact<u128> | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, Compact<u128>]
+      >;
+      /**
+       * Same as the [`transfer_allow_death`] call, but with a check that the transfer will not
+       * kill the origin account.
+       *
+       * 99% of the time you want [`transfer_allow_death`] instead.
+       *
+       * [`transfer_allow_death`]: struct.Pallet.html#method.transfer
+       **/
+      transferKeepAlive: AugmentedSubmittable<
+        (
+          dest:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          value: Compact<u128> | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, Compact<u128>]
+      >;
+      /**
+       * Upgrade a specified account.
+       *
+       * - `origin`: Must be `Signed`.
+       * - `who`: The account to be upgraded.
+       *
+       * This will waive the transaction fee if at least all but 10% of the accounts needed to
+       * be upgraded. (We let some not have to be upgraded just in order to allow for the
+       * possibility of churn).
+       **/
+      upgradeAccounts: AugmentedSubmittable<
+        (
+          who: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[],
+        ) => SubmittableExtrinsic<ApiType>,
+        [Vec<AccountId32>]
+      >;
+    };
+    priceIndex: {
+      /**
+       * Sets the operator account id (only executable by the Root account)
+       *
+       * # Arguments
+       * * `account_id` - the account id of the operator
+       **/
+      setOperator: AugmentedSubmittable<
+        (accountId: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [AccountId32]
+      >;
+      /**
+       * Submit the latest price index. Only valid for the configured operator account
+       **/
+      submit: AugmentedSubmittable<
+        (
+          index:
+            | PalletPriceIndexPriceIndex
+            | {
+                btcUsdPrice?: any;
+                argonotUsdPrice?: any;
+                argonUsdPrice?: any;
+                argonUsdTargetPrice?: any;
+                argonTimeWeightedAverageLiquidity?: any;
+                tick?: any;
+              }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [PalletPriceIndexPriceIndex]
+      >;
+    };
+    proxy: {
+      /**
+       * Register a proxy account for the sender that is able to make calls on its behalf.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       *
+       * Parameters:
+       * - `proxy`: The account that the `caller` would like to make a proxy.
+       * - `proxy_type`: The permissions allowed for this proxy account.
+       * - `delay`: The announcement period required of the initial proxy. Will generally be
+       * zero.
+       **/
+      addProxy: AugmentedSubmittable<
+        (
+          delegate:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          proxyType:
+            | ArgonRuntimeProxyType
+            | 'Any'
+            | 'NonTransfer'
+            | 'PriceIndex'
+            | 'MiningBid'
+            | 'MiningBidRealPaysFee'
+            | 'Bitcoin'
+            | 'VaultAdmin'
+            | 'BitcoinInitializeFor'
+            | number
+            | Uint8Array,
+          delay: u32 | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, ArgonRuntimeProxyType, u32]
+      >;
+      /**
+       * Publish the hash of a proxy-call that will be made in the future.
+       *
+       * This must be called some number of blocks before the corresponding `proxy` is attempted
+       * if the delay associated with the proxy relationship is greater than zero.
+       *
+       * No more than `MaxPending` announcements may be made at any one time.
+       *
+       * This will take a deposit of `AnnouncementDepositFactor` as well as
+       * `AnnouncementDepositBase` if there are no other pending announcements.
+       *
+       * The dispatch origin for this call must be _Signed_ and a proxy of `real`.
+       *
+       * Parameters:
+       * - `real`: The account that the proxy will make a call on behalf of.
+       * - `call_hash`: The hash of the call to be made by the `real` account.
+       **/
+      announce: AugmentedSubmittable<
+        (
+          real:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          callHash: H256 | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, H256]
+      >;
+      /**
+       * Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and
+       * initialize it with a proxy of `proxy_type` for `origin` sender.
+       *
+       * Requires a `Signed` origin.
+       *
+       * - `proxy_type`: The type of the proxy that the sender will be registered as over the
+       * new account. This will almost always be the most permissive `ProxyType` possible to
+       * allow for maximum flexibility.
+       * - `index`: A disambiguation index, in case this is called multiple times in the same
+       * transaction (e.g. with `utility::batch`). Unless you're using `batch` you probably just
+       * want to use `0`.
+       * - `delay`: The announcement period required of the initial proxy. Will generally be
+       * zero.
+       *
+       * Fails with `Duplicate` if this has already been called in this transaction, from the
+       * same sender, with the same parameters.
+       *
+       * Fails if there are insufficient funds to pay for deposit.
+       **/
+      createPure: AugmentedSubmittable<
+        (
+          proxyType:
+            | ArgonRuntimeProxyType
+            | 'Any'
+            | 'NonTransfer'
+            | 'PriceIndex'
+            | 'MiningBid'
+            | 'MiningBidRealPaysFee'
+            | 'Bitcoin'
+            | 'VaultAdmin'
+            | 'BitcoinInitializeFor'
+            | number
+            | Uint8Array,
+          delay: u32 | AnyNumber | Uint8Array,
+          index: u16 | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [ArgonRuntimeProxyType, u32, u16]
+      >;
+      /**
+       * Removes a previously spawned pure proxy.
+       *
+       * WARNING: **All access to this account will be lost.** Any funds held in it will be
+       * inaccessible.
+       *
+       * Requires a `Signed` origin, and the sender account must have been created by a call to
+       * `create_pure` with corresponding parameters.
+       *
+       * - `spawner`: The account that originally called `create_pure` to create this account.
+       * - `index`: The disambiguation index originally passed to `create_pure`. Probably `0`.
+       * - `proxy_type`: The proxy type originally passed to `create_pure`.
+       * - `height`: The height of the chain when the call to `create_pure` was processed.
+       * - `ext_index`: The extrinsic index in which the call to `create_pure` was processed.
+       *
+       * Fails with `NoPermission` in case the caller is not a previously created pure
+       * account whose `create_pure` call has corresponding parameters.
+       **/
+      killPure: AugmentedSubmittable<
+        (
+          spawner:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          proxyType:
+            | ArgonRuntimeProxyType
+            | 'Any'
+            | 'NonTransfer'
+            | 'PriceIndex'
+            | 'MiningBid'
+            | 'MiningBidRealPaysFee'
+            | 'Bitcoin'
+            | 'VaultAdmin'
+            | 'BitcoinInitializeFor'
+            | number
+            | Uint8Array,
+          index: u16 | AnyNumber | Uint8Array,
+          height: Compact<u32> | AnyNumber | Uint8Array,
+          extIndex: Compact<u32> | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, ArgonRuntimeProxyType, u16, Compact<u32>, Compact<u32>]
+      >;
+      /**
+       * Poke / Adjust deposits made for proxies and announcements based on current values.
+       * This can be used by accounts to possibly lower their locked amount.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       *
+       * The transaction fee is waived if the deposit amount has changed.
+       *
+       * Emits `DepositPoked` if successful.
+       **/
+      pokeDeposit: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
+      /**
+       * Dispatch the given `call` from an account that the sender is authorised for through
+       * `add_proxy`.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       *
+       * Parameters:
+       * - `real`: The account that the proxy will make a call on behalf of.
+       * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
+       * - `call`: The call to be made by the `real` account.
+       **/
+      proxy: AugmentedSubmittable<
+        (
+          real:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          forceProxyType:
+            | Option<ArgonRuntimeProxyType>
+            | null
+            | Uint8Array
+            | ArgonRuntimeProxyType
+            | 'Any'
+            | 'NonTransfer'
+            | 'PriceIndex'
+            | 'MiningBid'
+            | 'MiningBidRealPaysFee'
+            | 'Bitcoin'
+            | 'VaultAdmin'
+            | 'BitcoinInitializeFor'
+            | number,
+          call: Call | IMethod | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, Option<ArgonRuntimeProxyType>, Call]
+      >;
+      /**
+       * Dispatch the given `call` from an account that the sender is authorized for through
+       * `add_proxy`.
+       *
+       * Removes any corresponding announcement(s).
+       *
+       * The dispatch origin for this call must be _Signed_.
+       *
+       * Parameters:
+       * - `real`: The account that the proxy will make a call on behalf of.
+       * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
+       * - `call`: The call to be made by the `real` account.
+       **/
+      proxyAnnounced: AugmentedSubmittable<
+        (
+          delegate:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          real:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          forceProxyType:
+            | Option<ArgonRuntimeProxyType>
+            | null
+            | Uint8Array
+            | ArgonRuntimeProxyType
+            | 'Any'
+            | 'NonTransfer'
+            | 'PriceIndex'
+            | 'MiningBid'
+            | 'MiningBidRealPaysFee'
+            | 'Bitcoin'
+            | 'VaultAdmin'
+            | 'BitcoinInitializeFor'
+            | number,
+          call: Call | IMethod | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, MultiAddress, Option<ArgonRuntimeProxyType>, Call]
+      >;
+      /**
+       * Remove the given announcement of a delegate.
+       *
+       * May be called by a target (proxied) account to remove a call that one of their delegates
+       * (`delegate`) has announced they want to execute. The deposit is returned.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       *
+       * Parameters:
+       * - `delegate`: The account that previously announced the call.
+       * - `call_hash`: The hash of the call to be made.
+       **/
+      rejectAnnouncement: AugmentedSubmittable<
+        (
+          delegate:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          callHash: H256 | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, H256]
+      >;
+      /**
+       * Remove a given announcement.
+       *
+       * May be called by a proxy account to remove a call they previously announced and return
+       * the deposit.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       *
+       * Parameters:
+       * - `real`: The account that the proxy will make a call on behalf of.
+       * - `call_hash`: The hash of the call to be made by the `real` account.
+       **/
+      removeAnnouncement: AugmentedSubmittable<
+        (
+          real:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          callHash: H256 | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, H256]
+      >;
+      /**
+       * Unregister all proxy accounts for the sender.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       *
+       * WARNING: This may be called on accounts created by `create_pure`, however if done, then
+       * the unreserved fees will be inaccessible. **All access to this account will be lost.**
+       **/
+      removeProxies: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
+      /**
+       * Unregister a proxy account for the sender.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       *
+       * Parameters:
+       * - `proxy`: The account that the `caller` would like to remove as a proxy.
+       * - `proxy_type`: The permissions currently enabled for the removed proxy account.
+       **/
+      removeProxy: AugmentedSubmittable<
+        (
+          delegate:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          proxyType:
+            | ArgonRuntimeProxyType
+            | 'Any'
+            | 'NonTransfer'
+            | 'PriceIndex'
+            | 'MiningBid'
+            | 'MiningBidRealPaysFee'
+            | 'Bitcoin'
+            | 'VaultAdmin'
+            | 'BitcoinInitializeFor'
+            | number
+            | Uint8Array,
+          delay: u32 | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, ArgonRuntimeProxyType, u32]
+      >;
+    };
+    sudo: {
+      /**
+       * Permanently removes the sudo key.
+       *
+       * **This cannot be un-done.**
+       **/
+      removeKey: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
+      /**
+       * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo
+       * key.
+       **/
+      setKey: AugmentedSubmittable<
+        (
+          updated:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress]
+      >;
+      /**
+       * Authenticates the sudo key and dispatches a function call with `Root` origin.
+       **/
+      sudo: AugmentedSubmittable<
+        (call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [Call]
+      >;
+      /**
+       * Authenticates the sudo key and dispatches a function call with `Signed` origin from
+       * a given account.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       **/
+      sudoAs: AugmentedSubmittable<
+        (
+          who:
+            | MultiAddress
+            | { Id: any }
+            | { Index: any }
+            | { Raw: any }
+            | { Address32: any }
+            | { Address20: any }
+            | string
+            | Uint8Array,
+          call: Call | IMethod | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [MultiAddress, Call]
+      >;
+      /**
+       * Authenticates the sudo key and dispatches a function call with `Root` origin.
+       * This function does not check the weight of the call, and instead allows the
+       * Sudo user to specify the weight of the call.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       **/
+      sudoUncheckedWeight: AugmentedSubmittable<
+        (
+          call: Call | IMethod | string | Uint8Array,
+          weight:
+            | SpWeightsWeightV2Weight
+            | { refTime?: any; proofSize?: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [Call, SpWeightsWeightV2Weight]
+      >;
+    };
+    system: {
+      /**
+       * Provide the preimage (runtime binary) `code` for an upgrade that has been authorized.
+       *
+       * If the authorization required a version check, this call will ensure the spec name
+       * remains unchanged and that the spec version has increased.
+       *
+       * Depending on the runtime's `OnSetCode` configuration, this function may directly apply
+       * the new `code` in the same block or attempt to schedule the upgrade.
+       *
+       * All origins are allowed.
+       **/
+      applyAuthorizedUpgrade: AugmentedSubmittable<
+        (code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [Bytes]
+      >;
+      /**
+       * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied
+       * later.
+       *
+       * This call requires Root origin.
+       **/
+      authorizeUpgrade: AugmentedSubmittable<
+        (codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [H256]
+      >;
+      /**
+       * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied
+       * later.
+       *
+       * WARNING: This authorizes an upgrade that will take place without any safety checks, for
+       * example that the spec name remains the same and that the version number increases. Not
+       * recommended for normal use. Use `authorize_upgrade` instead.
+       *
+       * This call requires Root origin.
+       **/
+      authorizeUpgradeWithoutChecks: AugmentedSubmittable<
+        (codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [H256]
+      >;
+      /**
+       * Kill all storage items with a key that starts with the given prefix.
+       *
+       * **NOTE:** We rely on the Root origin to provide us the number of subkeys under
+       * the prefix we are removing to accurately calculate the weight of this function.
+       **/
+      killPrefix: AugmentedSubmittable<
+        (
+          prefix: Bytes | string | Uint8Array,
+          subkeys: u32 | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [Bytes, u32]
+      >;
+      /**
+       * Kill some items from storage.
+       **/
+      killStorage: AugmentedSubmittable<
+        (keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>,
+        [Vec<Bytes>]
+      >;
+      /**
+       * Make some on-chain remark.
+       *
+       * Can be executed by every `origin`.
+       **/
+      remark: AugmentedSubmittable<
+        (remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [Bytes]
+      >;
+      /**
+       * Make some on-chain remark and emit event.
+       **/
+      remarkWithEvent: AugmentedSubmittable<
+        (remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [Bytes]
+      >;
+      /**
+       * Set the new runtime code.
+       **/
+      setCode: AugmentedSubmittable<
+        (code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [Bytes]
+      >;
+      /**
+       * Set the new runtime code without doing any checks of the given `code`.
+       *
+       * Note that runtime upgrades will not run if this is called with a not-increasing spec
+       * version!
+       **/
+      setCodeWithoutChecks: AugmentedSubmittable<
+        (code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [Bytes]
+      >;
+      /**
+       * Set the number of pages in the WebAssembly environment's heap.
+       **/
+      setHeapPages: AugmentedSubmittable<
+        (pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [u64]
+      >;
+      /**
+       * Set some items of storage.
+       **/
+      setStorage: AugmentedSubmittable<
+        (
+          items:
+            | Vec<ITuple<[Bytes, Bytes]>>
+            | [Bytes | string | Uint8Array, Bytes | string | Uint8Array][],
+        ) => SubmittableExtrinsic<ApiType>,
+        [Vec<ITuple<[Bytes, Bytes]>>]
+      >;
+    };
+    ticks: {};
+    timestamp: {
+      /**
+       * Set the current time.
+       *
+       * This call should be invoked exactly once per block. It will panic at the finalization
+       * phase, if this call hasn't been invoked by that time.
+       *
+       * The timestamp should be greater than the previous one by the amount specified by
+       * [`Config::MinimumPeriod`].
+       *
+       * The dispatch origin for this call must be _None_.
+       *
+       * This dispatch class is _Mandatory_ to ensure it gets executed in the block. Be aware
+       * that changing the complexity of this call could result exhausting the resources in a
+       * block to execute any other calls.
+       *
+       * ## Complexity
+       * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)
+       * - 1 storage read and 1 storage mutation (codec `O(1)` because of `DidUpdate::take` in
+       * `on_finalize`)
+       * - 1 event handler `on_timestamp_set`. Must be `O(1)`.
+       **/
+      set: AugmentedSubmittable<
+        (now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [Compact<u64>]
+      >;
+    };
+    treasury: {
+      /**
+       * Buy whole `1 ARGON` bonds for a vault.
+       *
+       * The purchase either enters the accepted list or fails.
+       **/
+      buyBonds: AugmentedSubmittable<
+        (
+          vaultId: u32 | AnyNumber | Uint8Array,
+          bonds: u32 | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u32, u32]
+      >;
+      /**
+       * Liquidate one full bond lot.
+       *
+       * The lot stops participating right away and is released after the delay.
+       **/
+      liquidateBondLot: AugmentedSubmittable<
+        (bondLotId: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [u64]
+      >;
+    };
+    txPause: {
+      /**
+       * Pause a call.
+       *
+       * Can only be called by [`Config::PauseOrigin`].
+       * Emits an [`Event::CallPaused`] event on success.
+       **/
+      pause: AugmentedSubmittable<
+        (
+          fullName:
+            | ITuple<[Bytes, Bytes]>
+            | [Bytes | string | Uint8Array, Bytes | string | Uint8Array],
+        ) => SubmittableExtrinsic<ApiType>,
+        [ITuple<[Bytes, Bytes]>]
+      >;
+      /**
+       * Un-pause a call.
+       *
+       * Can only be called by [`Config::UnpauseOrigin`].
+       * Emits an [`Event::CallUnpaused`] event on success.
+       **/
+      unpause: AugmentedSubmittable<
+        (
+          ident:
+            | ITuple<[Bytes, Bytes]>
+            | [Bytes | string | Uint8Array, Bytes | string | Uint8Array],
+        ) => SubmittableExtrinsic<ApiType>,
+        [ITuple<[Bytes, Bytes]>]
+      >;
+    };
+    utility: {
+      /**
+       * Send a call through an indexed pseudonym of the sender.
+       *
+       * Filter from origin are passed along. The call will be dispatched with an origin which
+       * use the same filter as the origin of this call.
+       *
+       * NOTE: If you need to ensure that any account-based filtering is not honored (i.e.
+       * because you expect `proxy` to have been used prior in the call stack and you do not want
+       * the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1`
+       * in the Multisig pallet instead.
+       *
+       * NOTE: Prior to version *12, this was called `as_limited_sub`.
+       *
+       * The dispatch origin for this call must be _Signed_.
+       **/
+      asDerivative: AugmentedSubmittable<
+        (
+          index: u16 | AnyNumber | Uint8Array,
+          call: Call | IMethod | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u16, Call]
+      >;
+      /**
+       * Send a batch of dispatch calls.
+       *
+       * May be called from any origin except `None`.
+       *
+       * - `calls`: The calls to be dispatched from the same origin. The number of call must not
+       * exceed the constant: `batched_calls_limit` (available in constant metadata).
+       *
+       * If origin is root then the calls are dispatched without checking origin filter. (This
+       * includes bypassing `frame_system::Config::BaseCallFilter`).
+       *
+       * ## Complexity
+       * - O(C) where C is the number of calls to be batched.
+       *
+       * This will return `Ok` in all circumstances. To determine the success of the batch, an
+       * event is deposited. If a call failed and the batch was interrupted, then the
+       * `BatchInterrupted` event is deposited, along with the number of successful calls made
+       * and the error of the failed call. If all were successful, then the `BatchCompleted`
+       * event is deposited.
+       **/
+      batch: AugmentedSubmittable<
+        (
+          calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[],
+        ) => SubmittableExtrinsic<ApiType>,
+        [Vec<Call>]
+      >;
+      /**
+       * Send a batch of dispatch calls and atomically execute them.
+       * The whole transaction will rollback and fail if any of the calls failed.
+       *
+       * May be called from any origin except `None`.
+       *
+       * - `calls`: The calls to be dispatched from the same origin. The number of call must not
+       * exceed the constant: `batched_calls_limit` (available in constant metadata).
+       *
+       * If origin is root then the calls are dispatched without checking origin filter. (This
+       * includes bypassing `frame_system::Config::BaseCallFilter`).
+       *
+       * ## Complexity
+       * - O(C) where C is the number of calls to be batched.
+       **/
+      batchAll: AugmentedSubmittable<
+        (
+          calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[],
+        ) => SubmittableExtrinsic<ApiType>,
+        [Vec<Call>]
+      >;
+      /**
+       * Dispatches a function call with a provided origin.
+       *
+       * The dispatch origin for this call must be _Root_.
+       *
+       * ## Complexity
+       * - O(1).
+       **/
+      dispatchAs: AugmentedSubmittable<
+        (
+          asOrigin: ArgonRuntimeOriginCaller | { system: any } | string | Uint8Array,
+          call: Call | IMethod | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [ArgonRuntimeOriginCaller, Call]
+      >;
+      /**
+       * Dispatches a function call with a provided origin.
+       *
+       * Almost the same as [`Pallet::dispatch_as`] but forwards any error of the inner call.
+       *
+       * The dispatch origin for this call must be _Root_.
+       **/
+      dispatchAsFallible: AugmentedSubmittable<
+        (
+          asOrigin: ArgonRuntimeOriginCaller | { system: any } | string | Uint8Array,
+          call: Call | IMethod | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [ArgonRuntimeOriginCaller, Call]
+      >;
+      /**
+       * Send a batch of dispatch calls.
+       * Unlike `batch`, it allows errors and won't interrupt.
+       *
+       * May be called from any origin except `None`.
+       *
+       * - `calls`: The calls to be dispatched from the same origin. The number of call must not
+       * exceed the constant: `batched_calls_limit` (available in constant metadata).
+       *
+       * If origin is root then the calls are dispatch without checking origin filter. (This
+       * includes bypassing `frame_system::Config::BaseCallFilter`).
+       *
+       * ## Complexity
+       * - O(C) where C is the number of calls to be batched.
+       **/
+      forceBatch: AugmentedSubmittable<
+        (
+          calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[],
+        ) => SubmittableExtrinsic<ApiType>,
+        [Vec<Call>]
+      >;
+      /**
+       * Dispatch a fallback call in the event the main call fails to execute.
+       * May be called from any origin except `None`.
+       *
+       * This function first attempts to dispatch the `main` call.
+       * If the `main` call fails, the `fallback` is attemted.
+       * if the fallback is successfully dispatched, the weights of both calls
+       * are accumulated and an event containing the main call error is deposited.
+       *
+       * In the event of a fallback failure the whole call fails
+       * with the weights returned.
+       *
+       * - `main`: The main call to be dispatched. This is the primary action to execute.
+       * - `fallback`: The fallback call to be dispatched in case the `main` call fails.
+       *
+       * ## Dispatch Logic
+       * - If the origin is `root`, both the main and fallback calls are executed without
+       * applying any origin filters.
+       * - If the origin is not `root`, the origin filter is applied to both the `main` and
+       * `fallback` calls.
+       *
+       * ## Use Case
+       * - Some use cases might involve submitting a `batch` type call in either main, fallback
+       * or both.
+       **/
+      ifElse: AugmentedSubmittable<
+        (
+          main: Call | IMethod | string | Uint8Array,
+          fallback: Call | IMethod | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [Call, Call]
+      >;
+      /**
+       * Dispatch a function call with a specified weight.
+       *
+       * This function does not check the weight of the call, and instead allows the
+       * Root origin to specify the weight of the call.
+       *
+       * The dispatch origin for this call must be _Root_.
+       **/
+      withWeight: AugmentedSubmittable<
+        (
+          call: Call | IMethod | string | Uint8Array,
+          weight:
+            | SpWeightsWeightV2Weight
+            | { refTime?: any; proofSize?: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [Call, SpWeightsWeightV2Weight]
+      >;
+    };
+    vaults: {
+      /**
+       * Stop offering additional bitcoin locks from this vault. Will not affect existing
+       * locks. As funds are returned, they will be released to the vault owner.
+       **/
+      close: AugmentedSubmittable<
+        (vaultId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [u32]
+      >;
+      collect: AugmentedSubmittable<
+        (vaultId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>,
+        [u32]
+      >;
+      create: AugmentedSubmittable<
+        (
+          vaultConfig:
+            | PalletVaultsVaultConfig
+            | {
+                terms?: any;
+                name?: any;
+                securitization?: any;
+                bitcoinXpubkey?: any;
+                securitizationRatio?: any;
+              }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [PalletVaultsVaultConfig]
+      >;
+      /**
+       * Modify funds allocated by the vault. This will not affect issued bitcoin locks, but will
+       * affect the amount of funds available for new ones.
+       *
+       * The securitization percent must be maintained or increased.
+       *
+       * The amount allocated may not go below the existing reserved amounts, but you can release
+       * funds in this vault as bitcoin locks are released. To stop issuing any more bitcoin
+       * locks, use the `close` api.
+       **/
+      modifyFunding: AugmentedSubmittable<
+        (
+          vaultId: u32 | AnyNumber | Uint8Array,
+          securitization: u128 | AnyNumber | Uint8Array,
+          securitizationRatio: u128 | AnyNumber | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u32, u128, u128]
+      >;
+      /**
+       * Change the terms of this vault. The change will be applied at the next mining slot
+       * change that is at least `MinTermsModificationBlockDelay` blocks away.
+       **/
+      modifyTerms: AugmentedSubmittable<
+        (
+          vaultId: u32 | AnyNumber | Uint8Array,
+          terms:
+            | ArgonPrimitivesVaultVaultTerms
+            | { bitcoinAnnualPercentRate?: any; bitcoinBaseFee?: any; treasuryProfitSharing?: any }
+            | string
+            | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u32, ArgonPrimitivesVaultVaultTerms]
+      >;
+      /**
+       * Replace the bitcoin xpubkey for this vault. This will not affect existing bitcoin locks,
+       * but will be used for any locks after this point. Will be rejected if already
+       * used.
+       **/
+      replaceBitcoinXpub: AugmentedSubmittable<
+        (
+          vaultId: u32 | AnyNumber | Uint8Array,
+          bitcoinXpub: ArgonPrimitivesBitcoinOpaqueBitcoinXpub | string | Uint8Array,
+        ) => SubmittableExtrinsic<ApiType>,
+        [u32, ArgonPrimitivesBitcoinOpaqueBitcoinXpub]
+      >;
+      setBitcoinLockDelegate: AugmentedSubmittable<
+        (
+          delegateAccountId: Option<AccountId32> | null | Uint8Array | AccountId32 | string,
+        ) => SubmittableExtrinsic<ApiType>,
+        [Option<AccountId32>]
+      >;
+      setName: AugmentedSubmittable<
+        (name: Option<Bytes> | null | Uint8Array | Bytes | string) => SubmittableExtrinsic<ApiType>,
+        [Option<Bytes>]
+      >;
+    };
+  } // AugmentedSubmittables
+} // declare module