@bifrost-finance/types
Version:
1,173 lines • 417 kB
TypeScript
import '@polkadot/api-base/types/submittable';
import type { AccountId32, Call, H256, MultiAddress, Perbill, Percent, Permill } from '@bifrost-finance/types/interfaces/runtime';
import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';
import type { Data } from '@polkadot/types';
import type { Bytes, Compact, Option, Struct, U8aFixed, Vec, bool, i128, i32, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';
import type { BifrostAssetRegistryAssetMetadata, BifrostKusamaRuntimeOriginCaller, BifrostKusamaRuntimeProxyType, BifrostKusamaRuntimeSessionKeys, BifrostSalpFundStatus, BifrostSalpLiteFundStatus, BifrostSlpPrimitivesDelays, BifrostSlpPrimitivesLedger, BifrostSlpPrimitivesMinimumsMaximums, BifrostSlpPrimitivesXcmOperation, BifrostSystemMakerInfo, BifrostVestingVestingInfo, BifrostVsbondAuctionOrderType, BifrostVstokenConversionPrimitivesVstokenConversionExchangeFee, BifrostVstokenConversionPrimitivesVstokenConversionExchangeRate, CumulusPrimitivesParachainInherentParachainInherentData, FrameSupportPreimagesBounded, NodePrimitivesCurrencyCurrencyId, NodePrimitivesCurrencyTokenSymbol, NodePrimitivesTimeUnit, PalletDemocracyConviction, PalletDemocracyVoteAccountVote, PalletElectionsPhragmenRenouncing, PalletIdentityBitFlags, PalletIdentityIdentityInfo, PalletIdentityJudgement, PalletMultisigTimepoint, SpWeightsWeightV2Weight, XcmInterfaceXcmInterfaceOperation, XcmV2MultiLocation, XcmV3MultiLocation, XcmV3Response, XcmV3WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm, ZenlinkProtocolPrimitivesAssetId, ZenlinkSwapRouterRoute } 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> {
assetRegistry: {
forceSetMultilocation: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array, location: XcmVersionedMultiLocation | {
V2: any;
} | {
V3: any;
} | string | Uint8Array, weight: SpWeightsWeightV2Weight | {
refTime?: any;
proofSize?: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId, XcmVersionedMultiLocation, SpWeightsWeightV2Weight]>;
registerMultilocation: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array, location: XcmVersionedMultiLocation | {
V2: any;
} | {
V3: any;
} | string | Uint8Array, weight: SpWeightsWeightV2Weight | {
refTime?: any;
proofSize?: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId, XcmVersionedMultiLocation, SpWeightsWeightV2Weight]>;
registerNativeAsset: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array, location: XcmVersionedMultiLocation | {
V2: any;
} | {
V3: any;
} | string | Uint8Array, metadata: BifrostAssetRegistryAssetMetadata | {
name?: any;
symbol?: any;
decimals?: any;
minimalBalance?: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId, XcmVersionedMultiLocation, BifrostAssetRegistryAssetMetadata]>;
registerTokenMetadata: AugmentedSubmittable<(metadata: BifrostAssetRegistryAssetMetadata | {
name?: any;
symbol?: any;
decimals?: any;
minimalBalance?: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [BifrostAssetRegistryAssetMetadata]>;
registerVsbondMetadata: AugmentedSubmittable<(tokenId: u8 | AnyNumber | Uint8Array, paraId: u32 | AnyNumber | Uint8Array, firstSlot: u32 | AnyNumber | Uint8Array, lastSlot: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u8, u32, u32, u32]>;
registerVstokenMetadata: AugmentedSubmittable<(tokenId: u8 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u8]>;
registerVtokenMetadata: AugmentedSubmittable<(tokenId: u8 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u8]>;
updateNativeAsset: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array, location: XcmVersionedMultiLocation | {
V2: any;
} | {
V3: any;
} | string | Uint8Array, metadata: BifrostAssetRegistryAssetMetadata | {
name?: any;
symbol?: any;
decimals?: any;
minimalBalance?: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId, XcmVersionedMultiLocation, BifrostAssetRegistryAssetMetadata]>;
/**
* Generic tx
**/
[key: string]: SubmittableExtrinsicFunction<ApiType>;
};
balances: {
/**
* Exactly as `transfer`, except the origin must be root and the source account may be
* specified.
* # <weight>
* - Same as transfer, but additional read and write because the source account is not
* assumed to be in the overlay.
* # </weight>
**/
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]>;
/**
* Set the balances of a given account.
*
* This will alter `FreeBalance` and `ReservedBalance` in storage. it will
* also alter the total issuance of the system (`TotalIssuance`) appropriately.
* If the new free or reserved balance is below the existential deposit,
* it will reset the account nonce (`frame_system::AccountNonce`).
*
* The dispatch origin for this call is `root`.
**/
setBalance: AugmentedSubmittable<(who: MultiAddress | {
Id: any;
} | {
Index: any;
} | {
Raw: any;
} | {
Address32: any;
} | {
Address20: any;
} | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>, Compact<u128>]>;
/**
* Transfer some liquid free balance to another account.
*
* `transfer` 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.
*
* # <weight>
* - Dependent on arguments but not critical, given proper implementations for input config
* types. See related functions below.
* - It contains a limited number of reads and writes internally and no complex
* computation.
*
* Related functions:
*
* - `ensure_can_withdraw` is always called internally but has a bounded complexity.
* - Transferring balances to accounts that did not exist before will cause
* `T::OnNewAccount::on_new_account` to be called.
* - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.
* - `transfer_keep_alive` works the same way as `transfer`, but has an additional check
* that the transfer will not kill the origin account.
* ---------------------------------
* - Origin account is already in memory, so no DB operations for them.
* # </weight>
**/
transfer: 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>]>;
/**
* 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). # <weight>
* - O(1). Just like transfer, but reading the user's transferable balance first.
* #</weight>
**/
transferAll: AugmentedSubmittable<(dest: MultiAddress | {
Id: any;
} | {
Index: any;
} | {
Raw: any;
} | {
Address32: any;
} | {
Address20: any;
} | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;
/**
* Same as the [`transfer`] call, but with a check that the transfer will not kill the
* origin account.
*
* 99% of the time you want [`transfer`] instead.
*
* [`transfer`]: 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>]>;
/**
* Generic tx
**/
[key: string]: SubmittableExtrinsicFunction<ApiType>;
};
bounties: {
/**
* Accept the curator role for a bounty.
* A deposit will be reserved from curator and refund upon successful payout.
*
* May only be called from the curator.
*
* # <weight>
* - O(1).
* # </weight>
**/
acceptCurator: AugmentedSubmittable<(bountyId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
/**
* Approve a bounty proposal. At a later time, the bounty will be funded and become active
* and the original deposit will be returned.
*
* May only be called from `T::SpendOrigin`.
*
* # <weight>
* - O(1).
* # </weight>
**/
approveBounty: AugmentedSubmittable<(bountyId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
/**
* Award bounty to a beneficiary account. The beneficiary will be able to claim the funds
* after a delay.
*
* The dispatch origin for this call must be the curator of this bounty.
*
* - `bounty_id`: Bounty ID to award.
* - `beneficiary`: The beneficiary account whom will receive the payout.
*
* # <weight>
* - O(1).
* # </weight>
**/
awardBounty: AugmentedSubmittable<(bountyId: Compact<u32> | AnyNumber | Uint8Array, beneficiary: MultiAddress | {
Id: any;
} | {
Index: any;
} | {
Raw: any;
} | {
Address32: any;
} | {
Address20: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, MultiAddress]>;
/**
* Claim the payout from an awarded bounty after payout delay.
*
* The dispatch origin for this call must be the beneficiary of this bounty.
*
* - `bounty_id`: Bounty ID to claim.
*
* # <weight>
* - O(1).
* # </weight>
**/
claimBounty: AugmentedSubmittable<(bountyId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
/**
* Cancel a proposed or active bounty. All the funds will be sent to treasury and
* the curator deposit will be unreserved if possible.
*
* Only `T::RejectOrigin` is able to cancel a bounty.
*
* - `bounty_id`: Bounty ID to cancel.
*
* # <weight>
* - O(1).
* # </weight>
**/
closeBounty: AugmentedSubmittable<(bountyId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
/**
* Extend the expiry time of an active bounty.
*
* The dispatch origin for this call must be the curator of this bounty.
*
* - `bounty_id`: Bounty ID to extend.
* - `remark`: additional information.
*
* # <weight>
* - O(1).
* # </weight>
**/
extendBountyExpiry: AugmentedSubmittable<(bountyId: Compact<u32> | AnyNumber | Uint8Array, remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Bytes]>;
/**
* Propose a new bounty.
*
* The dispatch origin for this call must be _Signed_.
*
* Payment: `TipReportDepositBase` will be reserved from the origin account, as well as
* `DataDepositPerByte` for each byte in `reason`. It will be unreserved upon approval,
* or slashed when rejected.
*
* - `curator`: The curator account whom will manage this bounty.
* - `fee`: The curator fee.
* - `value`: The total payment amount of this bounty, curator fee included.
* - `description`: The description of this bounty.
**/
proposeBounty: AugmentedSubmittable<(value: Compact<u128> | AnyNumber | Uint8Array, description: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, Bytes]>;
/**
* Assign a curator to a funded bounty.
*
* May only be called from `T::SpendOrigin`.
*
* # <weight>
* - O(1).
* # </weight>
**/
proposeCurator: AugmentedSubmittable<(bountyId: Compact<u32> | AnyNumber | Uint8Array, curator: MultiAddress | {
Id: any;
} | {
Index: any;
} | {
Raw: any;
} | {
Address32: any;
} | {
Address20: any;
} | string | Uint8Array, fee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, MultiAddress, Compact<u128>]>;
/**
* Unassign curator from a bounty.
*
* This function can only be called by the `RejectOrigin` a signed origin.
*
* If this function is called by the `RejectOrigin`, we assume that the curator is
* malicious or inactive. As a result, we will slash the curator when possible.
*
* If the origin is the curator, we take this as a sign they are unable to do their job and
* they willingly give up. We could slash them, but for now we allow them to recover their
* deposit and exit without issue. (We may want to change this if it is abused.)
*
* Finally, the origin can be anyone if and only if the curator is "inactive". This allows
* anyone in the community to call out that a curator is not doing their due diligence, and
* we should pick a new curator. In this case the curator should also be slashed.
*
* # <weight>
* - O(1).
* # </weight>
**/
unassignCurator: AugmentedSubmittable<(bountyId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;
/**
* Generic tx
**/
[key: string]: SubmittableExtrinsicFunction<ApiType>;
};
callSwitchgear: {
disableTransfers: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId]>;
enableTransfers: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId]>;
switchoffTransaction: AugmentedSubmittable<(palletName: Bytes | string | Uint8Array, functionName: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Bytes]>;
switchonTransaction: AugmentedSubmittable<(palletName: Bytes | string | Uint8Array, functionName: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Bytes]>;
/**
* Generic tx
**/
[key: string]: SubmittableExtrinsicFunction<ApiType>;
};
council: {
/**
* Close a vote that is either approved, disapproved or whose voting period has ended.
*
* May be called by any signed account in order to finish voting and close the proposal.
*
* If called before the end of the voting period it will only close the vote if it is
* has enough votes to be approved or disapproved.
*
* If called after the end of the voting period abstentions are counted as rejections
* unless there is a prime member set and the prime member cast an approval.
*
* If the close operation completes successfully with disapproval, the transaction fee will
* be waived. Otherwise execution of the approved operation will be charged to the caller.
*
* + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed
* proposal.
* + `length_bound`: The upper bound for the length of the proposal in storage. Checked via
* `storage::read` so it is `size_of::<u32>() == 4` larger than the pure length.
*
* # <weight>
* ## Weight
* - `O(B + M + P1 + P2)` where:
* - `B` is `proposal` size in bytes (length-fee-bounded)
* - `M` is members-count (code- and governance-bounded)
* - `P1` is the complexity of `proposal` preimage.
* - `P2` is proposal-count (code-bounded)
* - DB:
* - 2 storage reads (`Members`: codec `O(M)`, `Prime`: codec `O(1)`)
* - 3 mutations (`Voting`: codec `O(M)`, `ProposalOf`: codec `O(B)`, `Proposals`: codec
* `O(P2)`)
* - any mutations done while executing `proposal` (`P1`)
* - up to 3 events
* # </weight>
**/
close: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, proposalWeightBound: SpWeightsWeightV2Weight | {
refTime?: any;
proofSize?: any;
} | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, SpWeightsWeightV2Weight, Compact<u32>]>;
/**
* Close a vote that is either approved, disapproved or whose voting period has ended.
*
* May be called by any signed account in order to finish voting and close the proposal.
*
* If called before the end of the voting period it will only close the vote if it is
* has enough votes to be approved or disapproved.
*
* If called after the end of the voting period abstentions are counted as rejections
* unless there is a prime member set and the prime member cast an approval.
*
* If the close operation completes successfully with disapproval, the transaction fee will
* be waived. Otherwise execution of the approved operation will be charged to the caller.
*
* + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed
* proposal.
* + `length_bound`: The upper bound for the length of the proposal in storage. Checked via
* `storage::read` so it is `size_of::<u32>() == 4` larger than the pure length.
*
* # <weight>
* ## Weight
* - `O(B + M + P1 + P2)` where:
* - `B` is `proposal` size in bytes (length-fee-bounded)
* - `M` is members-count (code- and governance-bounded)
* - `P1` is the complexity of `proposal` preimage.
* - `P2` is proposal-count (code-bounded)
* - DB:
* - 2 storage reads (`Members`: codec `O(M)`, `Prime`: codec `O(1)`)
* - 3 mutations (`Voting`: codec `O(M)`, `ProposalOf`: codec `O(B)`, `Proposals`: codec
* `O(P2)`)
* - any mutations done while executing `proposal` (`P1`)
* - up to 3 events
* # </weight>
**/
closeOldWeight: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, proposalWeightBound: Compact<u64> | AnyNumber | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, Compact<u64>, Compact<u32>]>;
/**
* Disapprove a proposal, close, and remove it from the system, regardless of its current
* state.
*
* Must be called by the Root origin.
*
* Parameters:
* * `proposal_hash`: The hash of the proposal that should be disapproved.
*
* # <weight>
* Complexity: O(P) where P is the number of max proposals
* DB Weight:
* * Reads: Proposals
* * Writes: Voting, Proposals, ProposalOf
* # </weight>
**/
disapproveProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;
/**
* Dispatch a proposal from a member using the `Member` origin.
*
* Origin must be a member of the collective.
*
* # <weight>
* ## Weight
* - `O(M + P)` where `M` members-count (code-bounded) and `P` complexity of dispatching
* `proposal`
* - DB: 1 read (codec `O(M)`) + DB access of `proposal`
* - 1 event
* # </weight>
**/
execute: AugmentedSubmittable<(proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Compact<u32>]>;
/**
* Add a new proposal to either be voted on or executed directly.
*
* Requires the sender to be member.
*
* `threshold` determines whether `proposal` is executed directly (`threshold < 2`)
* or put up for voting.
*
* # <weight>
* ## Weight
* - `O(B + M + P1)` or `O(B + M + P2)` where:
* - `B` is `proposal` size in bytes (length-fee-bounded)
* - `M` is members-count (code- and governance-bounded)
* - branching is influenced by `threshold` where:
* - `P1` is proposal execution complexity (`threshold < 2`)
* - `P2` is proposals-count (code-bounded) (`threshold >= 2`)
* - DB:
* - 1 storage read `is_member` (codec `O(M)`)
* - 1 storage read `ProposalOf::contains_key` (codec `O(1)`)
* - DB accesses influenced by `threshold`:
* - EITHER storage accesses done by `proposal` (`threshold < 2`)
* - OR proposal insertion (`threshold <= 2`)
* - 1 storage mutation `Proposals` (codec `O(P2)`)
* - 1 storage mutation `ProposalCount` (codec `O(1)`)
* - 1 storage write `ProposalOf` (codec `O(B)`)
* - 1 storage write `Voting` (codec `O(M)`)
* - 1 event
* # </weight>
**/
propose: AugmentedSubmittable<(threshold: Compact<u32> | AnyNumber | Uint8Array, proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Call, Compact<u32>]>;
/**
* Set the collective's membership.
*
* - `new_members`: The new member list. Be nice to the chain and provide it sorted.
* - `prime`: The prime member whose vote sets the default.
* - `old_count`: The upper bound for the previous number of members in storage. Used for
* weight estimation.
*
* Requires root origin.
*
* NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but
* the weight estimations rely on it to estimate dispatchable weight.
*
* # WARNING:
*
* The `pallet-collective` can also be managed by logic outside of the pallet through the
* implementation of the trait [`ChangeMembers`].
* Any call to `set_members` must be careful that the member set doesn't get out of sync
* with other logic managing the member set.
*
* # <weight>
* ## Weight
* - `O(MP + N)` where:
* - `M` old-members-count (code- and governance-bounded)
* - `N` new-members-count (code- and governance-bounded)
* - `P` proposals-count (code-bounded)
* - DB:
* - 1 storage mutation (codec `O(M)` read, `O(N)` write) for reading and writing the
* members
* - 1 storage read (codec `O(P)`) for reading the proposals
* - `P` storage mutations (codec `O(M)`) for updating the votes for each proposal
* - 1 storage write (codec `O(1)`) for deleting the old `prime` and setting the new one
* # </weight>
**/
setMembers: AugmentedSubmittable<(newMembers: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], prime: Option<AccountId32> | null | Uint8Array | AccountId32 | string, oldCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>, Option<AccountId32>, u32]>;
/**
* Add an aye or nay vote for the sender to the given proposal.
*
* Requires the sender to be a member.
*
* Transaction fees will be waived if the member is voting on any particular proposal
* for the first time and the call is successful. Subsequent vote changes will charge a
* fee.
* # <weight>
* ## Weight
* - `O(M)` where `M` is members-count (code- and governance-bounded)
* - DB:
* - 1 storage read `Members` (codec `O(M)`)
* - 1 storage mutation `Voting` (codec `O(M)`)
* - 1 event
* # </weight>
**/
vote: AugmentedSubmittable<(proposal: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, bool]>;
/**
* Generic tx
**/
[key: string]: SubmittableExtrinsicFunction<ApiType>;
};
councilMembership: {
/**
* Add a member `who` to the set.
*
* May only be called from `T::AddOrigin`.
**/
addMember: AugmentedSubmittable<(who: MultiAddress | {
Id: any;
} | {
Index: any;
} | {
Raw: any;
} | {
Address32: any;
} | {
Address20: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;
/**
* Swap out the sending member for some other key `new`.
*
* May only be called from `Signed` origin of a current member.
*
* Prime membership is passed from the origin account to `new`, if extant.
**/
changeKey: AugmentedSubmittable<(updated: MultiAddress | {
Id: any;
} | {
Index: any;
} | {
Raw: any;
} | {
Address32: any;
} | {
Address20: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;
/**
* Remove the prime member if it exists.
*
* May only be called from `T::PrimeOrigin`.
**/
clearPrime: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;
/**
* Remove a member `who` from the set.
*
* May only be called from `T::RemoveOrigin`.
**/
removeMember: AugmentedSubmittable<(who: MultiAddress | {
Id: any;
} | {
Index: any;
} | {
Raw: any;
} | {
Address32: any;
} | {
Address20: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;
/**
* Change the membership to a new set, disregarding the existing membership. Be nice and
* pass `members` pre-sorted.
*
* May only be called from `T::ResetOrigin`.
**/
resetMembers: AugmentedSubmittable<(members: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;
/**
* Set the prime member. Must be a current member.
*
* May only be called from `T::PrimeOrigin`.
**/
setPrime: AugmentedSubmittable<(who: MultiAddress | {
Id: any;
} | {
Index: any;
} | {
Raw: any;
} | {
Address32: any;
} | {
Address20: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;
/**
* Swap out one member `remove` for another `add`.
*
* May only be called from `T::SwapOrigin`.
*
* Prime membership is *not* passed from `remove` to `add`, if extant.
**/
swapMember: AugmentedSubmittable<(remove: MultiAddress | {
Id: any;
} | {
Index: any;
} | {
Raw: any;
} | {
Address32: any;
} | {
Address20: any;
} | string | Uint8Array, add: MultiAddress | {
Id: any;
} | {
Index: any;
} | {
Raw: any;
} | {
Address32: any;
} | {
Address20: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress]>;
/**
* Generic tx
**/
[key: string]: SubmittableExtrinsicFunction<ApiType>;
};
crossInOut: {
addToIssueWhitelist: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array, account: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId, AccountId32]>;
addToRegisterWhitelist: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array, account: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId, AccountId32]>;
changeOuterLinkedAccount: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array, foreignLocation: XcmV2MultiLocation | {
parents?: any;
interior?: any;
} | string | Uint8Array, account: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId, XcmV2MultiLocation, AccountId32]>;
crossIn: AugmentedSubmittable<(location: XcmV2MultiLocation | {
parents?: any;
interior?: any;
} | string | Uint8Array, currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array, remark: Option<Bytes> | null | Uint8Array | Bytes | string) => SubmittableExtrinsic<ApiType>, [XcmV2MultiLocation, NodePrimitivesCurrencyCurrencyId, Compact<u128>, Option<Bytes>]>;
/**
* Destroy some balance from an account and issue cross-out event.
**/
crossOut: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId, Compact<u128>]>;
deregisterCurrencyForCrossInOut: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId]>;
registerCurrencyForCrossInOut: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId]>;
registerLinkedAccount: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array, who: AccountId32 | string | Uint8Array, foreignLocation: XcmV2MultiLocation | {
parents?: any;
interior?: any;
} | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId, AccountId32, XcmV2MultiLocation]>;
removeFromIssueWhitelist: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array, account: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId, AccountId32]>;
removeFromRegisterWhitelist: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array, account: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId, AccountId32]>;
setCrossingMinimumAmount: AugmentedSubmittable<(currencyId: NodePrimitivesCurrencyCurrencyId | {
Native: any;
} | {
VToken: any;
} | {
Token: any;
} | {
Stable: any;
} | {
VSToken: any;
} | {
VSBond: any;
} | {
LPToken: any;
} | {
ForeignAsset: any;
} | {
Token2: any;
} | {
VToken2: any;
} | {
VSToken2: any;
} | {
VSBond2: any;
} | {
StableLpToken: any;
} | string | Uint8Array, crossInMinimum: u128 | AnyNumber | Uint8Array, crossOutMinimum: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [NodePrimitivesCurrencyCurrencyId, u128, u128]>;
/**
* Generic tx
**/
[key: string]: SubmittableExtrinsicFunction<ApiType>;
};
currencies: {
/**
* Transfer some balance to another account under `currency_id`.
*
* The dispatch origin for this call must be `Signed` by the
* transactor.
**/
transfer: AugmentedSubmittable<(dest: MultiAddress | {
Id: any;
} | {
Index: any;
} | {
Raw: any;
} | {
Address32: any;
} | {
Address20: any;
} | st