@argonprotocol/mainchain 0.0.2 → 0.0.4

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

@@ -3,13 +3,13 @@ import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableE
 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';
+import type { ArgonNodeRuntimeOpaqueSessionKeys, ArgonNodeRuntimeOriginCaller, 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: {
+        balances: {
             /**
              * Burn the specified liquid free balance from the origin account.
              *
@@ -483,6 +483,161 @@ declare module '@polkadot/api-base/types/submittable' {
                 signature?: any;
             } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<ArgonPrimitivesNotebookSignedNotebookHeader>]>;
         };
+        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)
@@ -766,161 +921,6 @@ declare module '@polkadot/api-base/types/submittable' {
                 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.
@@ -1089,6 +1089,102 @@ declare module '@polkadot/api-base/types/submittable' {
              **/
             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: ArgonNodeRuntimeOriginCaller | {
+                system: any;
+            } | {
+                Void: any;
+            } | string | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [ArgonNodeRuntimeOriginCaller, 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 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 bonds from this vault. Will not affect existing bond.