@argonprotocol/mainchain 0.0.2

package/lib/types/interfaces/augment-api-tx.d.ts

@@ -0,0 +1,1134 @@
+import '@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 { ArgonNodeRuntimeOpaqueSessionKeys, ArgonNodeRuntimeProxyType, ArgonPrimitivesBitcoinCompressedBitcoinPubkey, ArgonPrimitivesBitcoinH256Le, ArgonPrimitivesBitcoinOpaqueBitcoinXpub, ArgonPrimitivesBlockSealRewardDestination, ArgonPrimitivesBondVaultTerms, ArgonPrimitivesDataDomainZoneRecord, ArgonPrimitivesInherentsBitcoinUtxoSync, ArgonPrimitivesInherentsBlockSealInherent, ArgonPrimitivesNotaryNotaryMeta, ArgonPrimitivesNotebookSignedNotebookHeader, PalletBalancesAdjustmentDirection, PalletMiningSlotMiningSlotBid, PalletMultisigTimepoint, PalletPriceIndexPriceIndex, PalletVaultsVaultConfig, SpConsensusGrandpaEquivocationProof, SpSessionMembershipProof, 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> {
+        argonBalances: {
+            /**
+             * 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>]>;
+        };
+        bitcoinUtxos: {
+            /**
+             * 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;
+                verified?: any;
+                invalid?: any;
+                syncToBlock?: any;
+            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [ArgonPrimitivesInherentsBitcoinUtxoSync]>;
+        };
+        blockRewards: {};
+        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>]>;
+        };
+        bonds: {
+            /**
+             * Bond a bitcoin. This will create a bond for the submitting account and log the Bitcoin
+             * Script hash to Events. A bondee must create the UTXO in order to be added to the Bitcoin
+             * Mint line.
+             *
+             * 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.
+             **/
+            bondBitcoin: AugmentedSubmittable<(vaultId: u32 | AnyNumber | Uint8Array, satoshis: Compact<u64> | AnyNumber | Uint8Array, bitcoinPubkey: ArgonPrimitivesBitcoinCompressedBitcoinPubkey | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Compact<u64>, ArgonPrimitivesBitcoinCompressedBitcoinPubkey]>;
+            /**
+             * Submitted by a Vault operator to cosign the unlock of a bitcoin utxo. The Bitcoin owner
+             * unlock fee will be burned, and the bond will be allowed to expire without penalty.
+             *
+             * This is submitted as a no-fee transaction off chain to allow keys to remain in cold
+             * wallets.
+             **/
+            cosignBitcoinUnlock: AugmentedSubmittable<(bondId: u64 | AnyNumber | Uint8Array, signature: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, Bytes]>;
+            /**
+             * Submitted by a Bitcoin holder to trigger the unlock of their Bitcoin. A transaction
+             * spending the UTXO from the given bond 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.
+             **/
+            unlockBitcoinBond: AugmentedSubmittable<(bondId: u64 | AnyNumber | Uint8Array, toScriptPubkey: Bytes | string | Uint8Array, bitcoinNetworkFee: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, Bytes, u64]>;
+        };
+        chainTransfer: {
+            sendToLocalchain: AugmentedSubmittable<(amount: Compact<u128> | AnyNumber | Uint8Array, notaryId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, u32]>;
+        };
+        dataDomain: {
+            setZoneRecord: AugmentedSubmittable<(domainHash: H256 | string | Uint8Array, zoneRecord: ArgonPrimitivesDataDomainZoneRecord | {
+                paymentAccount?: any;
+                notaryId?: any;
+                versions?: any;
+            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, ArgonPrimitivesDataDomainZoneRecord]>;
+        };
+        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: SpSessionMembershipProof | {
+                session?: any;
+                trieNodes?: any;
+                validatorCount?: any;
+            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpConsensusGrandpaEquivocationProof, SpSessionMembershipProof]>;
+            /**
+             * 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: SpSessionMembershipProof | {
+                session?: any;
+                trieNodes?: any;
+                validatorCount?: any;
+            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpConsensusGrandpaEquivocationProof, SpSessionMembershipProof]>;
+        };
+        miningSlot: {
+            /**
+             * Submit a bid for a mining slot in the next cohort. Once all spots are filled in a slot,
+             * a slot can be supplanted by supplying a higher mining bond amount. Bond terms can be
+             * found in the `vaults` pallet. You will supply the bond amount and the vault id to bond
+             * with.
+             *
+             * Each slot has `MaxCohortSize` spots available.
+             *
+             * To be eligible for a slot, you must have the required ownership tokens 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 replaced, a `SlotBidderReplaced` 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
+             * `BlocksBeforeBidEndForVrfClose` blocks of the slot end time.
+             *
+             * The slot duration can be calculated as `BlocksBetweenSlots * MaxMiners / MaxCohortSize`.
+             *
+             * Parameters:
+             * - `bond_info`: The bond information to submit for the bid. If `None`, the bid will be
+             * considered a zero-bid.
+             * - `vault_id`: The vault id to bond with. Terms are taken from the vault at time of bid
+             * inclusion in the block.
+             * - `amount`: The amount to bond with the vault.
+             * - `reward_destination`: The account_id for the mining rewards, or `Owner` for the
+             * submitting user.
+             **/
+            bid: AugmentedSubmittable<(bondInfo: Option<PalletMiningSlotMiningSlotBid> | null | Uint8Array | PalletMiningSlotMiningSlotBid | {
+                vaultId?: any;
+                amount?: any;
+            } | string, rewardDestination: ArgonPrimitivesBlockSealRewardDestination | {
+                Owner: any;
+            } | {
+                Account: any;
+            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<PalletMiningSlotMiningSlotBid>, ArgonPrimitivesBlockSealRewardDestination]>;
+        };
+        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`.
+             *
+             * 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: If this is the final approval, you will want to use `as_multi` instead.
+             *
+             * ## 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 there are enough, then dispatch the call.
+             *
+             * 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: Unless this is the final approval, you will generally want to use
+             * `approve_as_multi` instead, since it only requires a hash of the call.
+             *
+             * 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]>;
+        };
+        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<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, ArgonPrimitivesNotaryNotaryMeta, Compact<u32>]>;
+        };
+        notebook: {
+            submit: AugmentedSubmittable<(notebooks: Vec<ArgonPrimitivesNotebookSignedNotebookHeader> | (ArgonPrimitivesNotebookSignedNotebookHeader | {
+                header?: any;
+                signature?: any;
+            } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<ArgonPrimitivesNotebookSignedNotebookHeader>]>;
+        };
+        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;
+                argonUsdPrice?: any;
+                argonUsdTargetPrice?: 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: ArgonNodeRuntimeProxyType | 'Any' | 'NonTransfer' | 'PriceIndex' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, ArgonNodeRuntimeProxyType, 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: ArgonNodeRuntimeProxyType | 'Any' | 'NonTransfer' | 'PriceIndex' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array, index: u16 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [ArgonNodeRuntimeProxyType, 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
+             * `pure` with corresponding parameters.
+             *
+             * - `spawner`: The account that originally called `pure` to create this account.
+             * - `index`: The disambiguation index originally passed to `pure`. Probably `0`.
+             * - `proxy_type`: The proxy type originally passed to `pure`.
+             * - `height`: The height of the chain when the call to `pure` was processed.
+             * - `ext_index`: The extrinsic index in which the call to `pure` was processed.
+             *
+             * Fails with `NoPermission` in case the caller is not a previously created pure
+             * account whose `pure` call has corresponding parameters.
+             **/
+            killPure: AugmentedSubmittable<(spawner: MultiAddress | {
+                Id: any;
+            } | {
+                Index: any;
+            } | {
+                Raw: any;
+            } | {
+                Address32: any;
+            } | {
+                Address20: any;
+            } | string | Uint8Array, proxyType: ArgonNodeRuntimeProxyType | 'Any' | 'NonTransfer' | 'PriceIndex' | number | Uint8Array, index: u16 | AnyNumber | Uint8Array, height: Compact<u32> | AnyNumber | Uint8Array, extIndex: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, ArgonNodeRuntimeProxyType, u16, Compact<u32>, Compact<u32>]>;
+            /**
+             * 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<ArgonNodeRuntimeProxyType> | null | Uint8Array | ArgonNodeRuntimeProxyType | 'Any' | 'NonTransfer' | 'PriceIndex' | number, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Option<ArgonNodeRuntimeProxyType>, 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<ArgonNodeRuntimeProxyType> | null | Uint8Array | ArgonNodeRuntimeProxyType | 'Any' | 'NonTransfer' | 'PriceIndex' | number, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, Option<ArgonNodeRuntimeProxyType>, 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 `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: ArgonNodeRuntimeProxyType | 'Any' | 'NonTransfer' | 'PriceIndex' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, ArgonNodeRuntimeProxyType, u32]>;
+        };
+        session: {
+            /**
+             * Removes any session key(s) of the function caller.
+             *
+             * This doesn't take effect until the next session.
+             *
+             * The dispatch origin of this function must be Signed and the account must be either be
+             * convertible to a validator ID using the chain's typical addressing system (this usually
+             * means being a controller account) or directly convertible into a validator ID (which
+             * usually means being a stash account).
+             *
+             * ## Complexity
+             * - `O(1)` in number of key types. Actual cost depends on the number of length of
+             * `T::Keys::key_ids()` which is fixed.
+             **/
+            purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
+            /**
+             * Sets the session key(s) of the function caller to `keys`.
+             * Allows an account to set its session key prior to becoming a validator.
+             * This doesn't take effect until the next session.
+             *
+             * The dispatch origin of this function must be signed.
+             *
+             * ## Complexity
+             * - `O(1)`. Actual cost depends on the number of length of `T::Keys::key_ids()` which is
+             * fixed.
+             **/
+            setKeys: AugmentedSubmittable<(keys: ArgonNodeRuntimeOpaqueSessionKeys | {
+                grandpa?: any;
+                blockSealAuthority?: any;
+            } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [ArgonNodeRuntimeOpaqueSessionKeys, Bytes]>;
+        };
+        shareBalances: {
+            /**
+             * 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>]>;
+        };
+        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>]>;
+        };
+        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]>]>;
+        };
+        vaults: {
+            /**
+             * Stop offering additional bonds from this vault. Will not affect existing bond.
+             * As funds are returned, they will be released to the vault owner.
+             **/
+            close: AugmentedSubmittable<(vaultId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;
+            create: AugmentedSubmittable<(vaultConfig: PalletVaultsVaultConfig | {
+                terms?: any;
+                bitcoinAmountAllocated?: any;
+                bitcoinXpubkey?: any;
+                miningAmountAllocated?: any;
+                securitizationPercent?: any;
+            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletVaultsVaultConfig]>;
+            /**
+             * Modify funds offered by the vault. This will not affect existing bonds, but will affect
+             * the amount of funds available for new bonds.
+             *
+             * The securitization percent must be maintained or increased.
+             *
+             * The amount offered may not go below the existing bonded amounts, but you can release
+             * funds in this vault as bonds are released. To stop issuing any more bonds, use the
+             * `close` api.
+             **/
+            modifyFunding: AugmentedSubmittable<(vaultId: u32 | AnyNumber | Uint8Array, totalMiningAmountOffered: u128 | AnyNumber | Uint8Array, totalBitcoinAmountOffered: u128 | AnyNumber | Uint8Array, securitizationPercent: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u128, 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: ArgonPrimitivesBondVaultTerms | {
+                bitcoinAnnualPercentRate?: any;
+                bitcoinBaseFee?: any;
+                miningAnnualPercentRate?: any;
+                miningBaseFee?: any;
+                miningRewardSharingPercentTake?: any;
+            } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, ArgonPrimitivesBondVaultTerms]>;
+            /**
+             * Replace the bitcoin xpubkey for this vault. This will not affect existing bonds, but
+             * will be used for any bonds after this point. Will be rejected if already used.
+             **/
+            replaceBitcoinXpub: AugmentedSubmittable<(vaultId: u32 | AnyNumber | Uint8Array, bitcoinXpub: ArgonPrimitivesBitcoinOpaqueBitcoinXpub | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, ArgonPrimitivesBitcoinOpaqueBitcoinXpub]>;
+        };
+    }
+}