References for api augmentation (#4346)
* References for api augmentation * Adjust * Progress... let's see where it leads * It compiles... * Adjust * CC ignore
This commit is contained in:
Jaco
@@ -0,0 +1,12 @@
|
||||
// Copyright 2017-2021 @polkadot/api-contract authors & contributors
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
import '@polkadot/types/augment';
|
||||
import './consts';
|
||||
import './errors';
|
||||
import './events';
|
||||
import './query';
|
||||
import './rpc';
|
||||
import './tx';
|
||||
|
||||
export { packageInfo } from './packageInfo';
|
||||
@@ -0,0 +1,959 @@
|
||||
// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
|
||||
/* eslint-disable */
|
||||
|
||||
declare module '@polkadot/api/types/consts' {
|
||||
import type { ApiTypes, AugmentedConst, QueryableModuleConsts } from '@polkadot/api-base/types';
|
||||
import type { U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types';
|
||||
import type { Perbill, Percent, Permill } from '@polkadot/types/interfaces/runtime';
|
||||
import type { FrameSupportPalletId, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, PalletContractsSchedule, SpVersionRuntimeVersion } from '@polkadot/types/lookup';
|
||||
import type { Codec } from '@polkadot/types/types';
|
||||
|
||||
export interface AugmentedConsts<ApiType extends ApiTypes> {
|
||||
assets: {
|
||||
/**
|
||||
* The amount of funds that must be reserved when creating a new approval.
|
||||
**/
|
||||
approvalDeposit: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The basic amount of funds that must be reserved for an asset.
|
||||
**/
|
||||
assetDeposit: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The basic amount of funds that must be reserved when adding metadata to your asset.
|
||||
**/
|
||||
metadataDepositBase: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The additional funds that must be reserved for the number of bytes you store in your
|
||||
* metadata.
|
||||
**/
|
||||
metadataDepositPerByte: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum length of a name or symbol stored on-chain.
|
||||
**/
|
||||
stringLimit: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
authorship: {
|
||||
/**
|
||||
* The number of blocks back we should accept uncles.
|
||||
* This means that we will deal with uncle-parents that are
|
||||
* `UncleGenerations + 1` before `now`.
|
||||
**/
|
||||
uncleGenerations: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
babe: {
|
||||
/**
|
||||
* The amount of time, in slots, that each epoch should last.
|
||||
* NOTE: Currently it is not possible to change the epoch duration after
|
||||
* the chain has started. Attempting to do so will brick block production.
|
||||
**/
|
||||
epochDuration: u64 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The expected average block time at which BABE should be creating
|
||||
* blocks. Since BABE is probabilistic it is not trivial to figure out
|
||||
* what the expected average block time should be based on the slot
|
||||
* duration and the security parameter `c` (where `1 - c` represents
|
||||
* the probability of a slot being empty).
|
||||
**/
|
||||
expectedBlockTime: u64 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Max number of authorities allowed
|
||||
**/
|
||||
maxAuthorities: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
bagsList: {
|
||||
/**
|
||||
* The list of thresholds separating the various bags.
|
||||
*
|
||||
* Ids are separated into unsorted bags according to their vote weight. This specifies the
|
||||
* thresholds separating the bags. An id's bag is the largest bag for which the id's weight
|
||||
* is less than or equal to its upper threshold.
|
||||
*
|
||||
* When ids are iterated, higher bags are iterated completely before lower bags. This means
|
||||
* that iteration is _semi-sorted_: ids of higher weight tend to come before ids of lower
|
||||
* weight, but peer ids within a particular bag are sorted in insertion order.
|
||||
*
|
||||
* # Expressing the constant
|
||||
*
|
||||
* This constant must be sorted in strictly increasing order. Duplicate items are not
|
||||
* permitted.
|
||||
*
|
||||
* There is an implied upper limit of `VoteWeight::MAX`; that value does not need to be
|
||||
* specified within the bag. For any two threshold lists, if one ends with
|
||||
* `VoteWeight::MAX`, the other one does not, and they are otherwise equal, the two lists
|
||||
* will behave identically.
|
||||
*
|
||||
* # Calculation
|
||||
*
|
||||
* It is recommended to generate the set of thresholds in a geometric series, such that
|
||||
* there exists some constant ratio such that `threshold[k + 1] == (threshold[k] *
|
||||
* constant_ratio).max(threshold[k] + 1)` for all `k`.
|
||||
*
|
||||
* The helpers in the `/utils/frame/generate-bags` module can simplify this calculation.
|
||||
*
|
||||
* # Examples
|
||||
*
|
||||
* - If `BagThresholds::get().is_empty()`, then all ids are put into the same bag, and
|
||||
* iteration is strictly in insertion order.
|
||||
* - If `BagThresholds::get().len() == 64`, and the thresholds are determined according to
|
||||
* the procedure given above, then the constant ratio is equal to 2.
|
||||
* - If `BagThresholds::get().len() == 200`, and the thresholds are determined according to
|
||||
* the procedure given above, then the constant ratio is approximately equal to 1.248.
|
||||
* - If the threshold list begins `[1, 2, 3, ...]`, then an id with weight 0 or 1 will fall
|
||||
* into bag 0, an id with weight 2 will fall into bag 1, etc.
|
||||
*
|
||||
* # Migration
|
||||
*
|
||||
* In the event that this list ever changes, a copy of the old bags list must be retained.
|
||||
* With that `List::migrate` can be called, which will perform the appropriate migration.
|
||||
**/
|
||||
bagThresholds: Vec<u64> & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
balances: {
|
||||
/**
|
||||
* The minimum amount required to keep an account open.
|
||||
**/
|
||||
existentialDeposit: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum number of locks that should exist on an account.
|
||||
* Not strictly enforced, but used for weight estimation.
|
||||
**/
|
||||
maxLocks: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum number of named reserves that can exist on an account.
|
||||
**/
|
||||
maxReserves: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
bounties: {
|
||||
/**
|
||||
* Percentage of the curator fee that will be reserved upfront as deposit for bounty
|
||||
* curator.
|
||||
**/
|
||||
bountyCuratorDeposit: Permill & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount held on deposit for placing a bounty proposal.
|
||||
**/
|
||||
bountyDepositBase: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The delay period for which a bounty beneficiary need to wait before claim the payout.
|
||||
**/
|
||||
bountyDepositPayoutDelay: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Bounty duration in blocks.
|
||||
**/
|
||||
bountyUpdatePeriod: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Minimum value for a bounty.
|
||||
**/
|
||||
bountyValueMinimum: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount held on deposit per byte within the tip report reason or bounty description.
|
||||
**/
|
||||
dataDepositPerByte: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Maximum acceptable reason length.
|
||||
*
|
||||
* Benchmarks depend on this value, be sure to update weights file when changing this value
|
||||
**/
|
||||
maximumReasonLength: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
childBounties: {
|
||||
/**
|
||||
* Percentage of child-bounty value to be reserved as curator deposit
|
||||
* when curator fee is zero.
|
||||
**/
|
||||
childBountyCuratorDepositBase: Permill & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Minimum value for a child-bounty.
|
||||
**/
|
||||
childBountyValueMinimum: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Maximum number of child-bounties that can be added to a parent bounty.
|
||||
**/
|
||||
maxActiveChildBountyCount: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
contracts: {
|
||||
/**
|
||||
* The maximum number of tries that can be queued for deletion.
|
||||
**/
|
||||
deletionQueueDepth: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum amount of weight that can be consumed per block for lazy trie removal.
|
||||
**/
|
||||
deletionWeightLimit: u64 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount of balance a caller has to pay for each byte of storage.
|
||||
*
|
||||
* # Note
|
||||
*
|
||||
* Changing this value for an existing chain might need a storage migration.
|
||||
**/
|
||||
depositPerByte: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount of balance a caller has to pay for each storage item.
|
||||
* # Note
|
||||
*
|
||||
* Changing this value for an existing chain might need a storage migration.
|
||||
**/
|
||||
depositPerItem: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Cost schedule and limits.
|
||||
**/
|
||||
schedule: PalletContractsSchedule & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
democracy: {
|
||||
/**
|
||||
* Period in blocks where an external proposal may not be re-submitted after being vetoed.
|
||||
**/
|
||||
cooloffPeriod: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The period between a proposal being approved and enacted.
|
||||
*
|
||||
* It should generally be a little more than the unstake period to ensure that
|
||||
* voting stakers have an opportunity to remove themselves from the system in the case
|
||||
* where they are on the losing side of a vote.
|
||||
**/
|
||||
enactmentPeriod: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Minimum voting period allowed for a fast-track referendum.
|
||||
**/
|
||||
fastTrackVotingPeriod: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Indicator for whether an emergency origin is even allowed to happen. Some chains may
|
||||
* want to set this permanently to `false`, others may want to condition it on things such
|
||||
* as an upgrade having happened recently.
|
||||
**/
|
||||
instantAllowed: bool & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* How often (in blocks) new public referenda are launched.
|
||||
**/
|
||||
launchPeriod: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum number of public proposals that can exist at any time.
|
||||
**/
|
||||
maxProposals: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum number of votes for an account.
|
||||
*
|
||||
* Also used to compute weight, an overly big value can
|
||||
* lead to extrinsic with very big weight: see `delegate` for instance.
|
||||
**/
|
||||
maxVotes: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The minimum amount to be used as a deposit for a public referendum proposal.
|
||||
**/
|
||||
minimumDeposit: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount of balance that must be deposited per byte of preimage stored.
|
||||
**/
|
||||
preimageByteDeposit: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The minimum period of vote locking.
|
||||
*
|
||||
* It should be no shorter than enactment period to ensure that in the case of an approval,
|
||||
* those successful voters are locked into the consequences that their votes entail.
|
||||
**/
|
||||
voteLockingPeriod: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* How often (in blocks) to check for new votes.
|
||||
**/
|
||||
votingPeriod: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
electionProviderMultiPhase: {
|
||||
/**
|
||||
* Maximum length (bytes) that the mined solution should consume.
|
||||
*
|
||||
* The miner will ensure that the total length of the unsigned solution will not exceed
|
||||
* this value.
|
||||
**/
|
||||
minerMaxLength: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Maximum weight that the miner should consume.
|
||||
*
|
||||
* The miner will ensure that the total weight of the unsigned solution will not exceed
|
||||
* this value, based on [`WeightInfo::submit_unsigned`].
|
||||
**/
|
||||
minerMaxWeight: u64 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The priority of the unsigned transaction submitted in the unsigned-phase
|
||||
**/
|
||||
minerTxPriority: u64 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The repeat threshold of the offchain worker.
|
||||
*
|
||||
* For example, if it is 5, that means that at least 5 blocks will elapse between attempts
|
||||
* to submit the worker's solution.
|
||||
**/
|
||||
offchainRepeat: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Base deposit for a signed solution.
|
||||
**/
|
||||
signedDepositBase: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Per-byte deposit for a signed solution.
|
||||
**/
|
||||
signedDepositByte: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Per-weight deposit for a signed solution.
|
||||
**/
|
||||
signedDepositWeight: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Maximum number of signed submissions that can be queued.
|
||||
*
|
||||
* It is best to avoid adjusting this during an election, as it impacts downstream data
|
||||
* structures. In particular, `SignedSubmissionIndices<T>` is bounded on this value. If you
|
||||
* update this value during an election, you _must_ ensure that
|
||||
* `SignedSubmissionIndices.len()` is less than or equal to the new value. Otherwise,
|
||||
* attempts to submit new solutions may cause a runtime panic.
|
||||
**/
|
||||
signedMaxSubmissions: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Maximum weight of a signed solution.
|
||||
*
|
||||
* This should probably be similar to [`Config::MinerMaxWeight`].
|
||||
**/
|
||||
signedMaxWeight: u64 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Duration of the signed phase.
|
||||
**/
|
||||
signedPhase: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Base reward for a signed solution
|
||||
**/
|
||||
signedRewardBase: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The minimum amount of improvement to the solution score that defines a solution as
|
||||
* "better" (in any phase).
|
||||
**/
|
||||
solutionImprovementThreshold: Perbill & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Duration of the unsigned phase.
|
||||
**/
|
||||
unsignedPhase: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum number of voters to put in the snapshot. At the moment, snapshots are only
|
||||
* over a single block, but once multi-block elections are introduced they will take place
|
||||
* over multiple blocks.
|
||||
*
|
||||
* Also, note the data type: If the voters are represented by a `u32` in `type
|
||||
* CompactSolution`, the same `u32` is used here to ensure bounds are respected.
|
||||
**/
|
||||
voterSnapshotPerBlock: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
elections: {
|
||||
/**
|
||||
* How much should be locked up in order to submit one's candidacy.
|
||||
**/
|
||||
candidacyBond: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Number of members to elect.
|
||||
**/
|
||||
desiredMembers: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Number of runners_up to keep.
|
||||
**/
|
||||
desiredRunnersUp: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Identifier for the elections-phragmen pallet's lock
|
||||
**/
|
||||
palletId: U8aFixed & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* How long each seat is kept. This defines the next block number at which an election
|
||||
* round will happen. If set to zero, no elections are ever triggered and the module will
|
||||
* be in passive mode.
|
||||
**/
|
||||
termDuration: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Base deposit associated with voting.
|
||||
*
|
||||
* This should be sensibly high to economically ensure the pallet cannot be attacked by
|
||||
* creating a gigantic number of votes.
|
||||
**/
|
||||
votingBondBase: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount of bond that need to be locked for each vote (32 bytes).
|
||||
**/
|
||||
votingBondFactor: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
gilt: {
|
||||
/**
|
||||
* Portion of the queue which is free from ordering and just a FIFO.
|
||||
*
|
||||
* Must be no greater than `MaxQueueLen`.
|
||||
**/
|
||||
fifoQueueLen: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The number of blocks between consecutive attempts to issue more gilts in an effort to
|
||||
* get to the target amount to be frozen.
|
||||
*
|
||||
* A larger value results in fewer storage hits each block, but a slower period to get to
|
||||
* the target.
|
||||
**/
|
||||
intakePeriod: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum amount of bids that can be turned into issued gilts each block. A larger
|
||||
* value here means less of the block available for transactions should there be a glut of
|
||||
* bids to make into gilts to reach the target.
|
||||
**/
|
||||
maxIntakeBids: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Maximum number of items that may be in each duration queue.
|
||||
**/
|
||||
maxQueueLen: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The minimum amount of funds that may be offered to freeze for a gilt. Note that this
|
||||
* does not actually limit the amount which may be frozen in a gilt since gilts may be
|
||||
* split up in order to satisfy the desired amount of funds under gilts.
|
||||
*
|
||||
* It should be at least big enough to ensure that there is no possible storage spam attack
|
||||
* or queue-filling attack.
|
||||
**/
|
||||
minFreeze: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The base period for the duration queues. This is the common multiple across all
|
||||
* supported freezing durations that can be bid upon.
|
||||
**/
|
||||
period: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Number of duration queues in total. This sets the maximum duration supported, which is
|
||||
* this value multiplied by `Period`.
|
||||
**/
|
||||
queueCount: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
grandpa: {
|
||||
/**
|
||||
* Max Authorities in use
|
||||
**/
|
||||
maxAuthorities: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
identity: {
|
||||
/**
|
||||
* The amount held on deposit for a registered identity
|
||||
**/
|
||||
basicDeposit: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount held on deposit per additional field for a registered identity.
|
||||
**/
|
||||
fieldDeposit: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Maximum number of additional fields that may be stored in an ID. Needed to bound the I/O
|
||||
* required to access an identity, but can be pretty high.
|
||||
**/
|
||||
maxAdditionalFields: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Maxmimum number of registrars allowed in the system. Needed to bound the complexity
|
||||
* of, e.g., updating judgements.
|
||||
**/
|
||||
maxRegistrars: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum number of sub-accounts allowed per identified account.
|
||||
**/
|
||||
maxSubAccounts: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount held on deposit for a registered subaccount. This should account for the fact
|
||||
* that one storage item's value will increase by the size of an account ID, and there will
|
||||
* be another trie item whose value is the size of an account ID plus 32 bytes.
|
||||
**/
|
||||
subAccountDeposit: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
imOnline: {
|
||||
/**
|
||||
* A configuration for base priority of unsigned transactions.
|
||||
*
|
||||
* This is exposed so that it can be tuned for particular runtime, when
|
||||
* multiple pallets send unsigned transactions.
|
||||
**/
|
||||
unsignedPriority: u64 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
indices: {
|
||||
/**
|
||||
* The deposit needed for reserving an index.
|
||||
**/
|
||||
deposit: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
lottery: {
|
||||
/**
|
||||
* The max number of calls available in a single lottery.
|
||||
**/
|
||||
maxCalls: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Number of time we should try to generate a random number that has no modulo bias.
|
||||
* The larger this number, the more potential computation is used for picking the winner,
|
||||
* but also the more likely that the chosen winner is done fairly.
|
||||
**/
|
||||
maxGenerateRandom: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The Lottery's pallet id
|
||||
**/
|
||||
palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
multisig: {
|
||||
/**
|
||||
* The base amount of currency needed to reserve for creating a multisig execution or to
|
||||
* store a dispatch call for later.
|
||||
*
|
||||
* This is held for an additional storage item whose value size is
|
||||
* `4 + sizeof((BlockNumber, Balance, AccountId))` bytes and whose key size is
|
||||
* `32 + sizeof(AccountId)` bytes.
|
||||
**/
|
||||
depositBase: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount of currency needed per unit threshold when creating a multisig execution.
|
||||
*
|
||||
* This is held for adding 32 bytes more into a pre-existing storage value.
|
||||
**/
|
||||
depositFactor: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum amount of signatories allowed in the multisig.
|
||||
**/
|
||||
maxSignatories: u16 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
proxy: {
|
||||
/**
|
||||
* The base amount of currency needed to reserve for creating an announcement.
|
||||
*
|
||||
* This is held when a new storage item holding a `Balance` is created (typically 16
|
||||
* bytes).
|
||||
**/
|
||||
announcementDepositBase: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount of currency needed per announcement made.
|
||||
*
|
||||
* This is held for adding an `AccountId`, `Hash` and `BlockNumber` (typically 68 bytes)
|
||||
* into a pre-existing storage value.
|
||||
**/
|
||||
announcementDepositFactor: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum amount of time-delayed announcements that are allowed to be pending.
|
||||
**/
|
||||
maxPending: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum amount of proxies allowed for a single account.
|
||||
**/
|
||||
maxProxies: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The base amount of currency needed to reserve for creating a proxy.
|
||||
*
|
||||
* This is held for an additional storage item whose value size is
|
||||
* `sizeof(Balance)` bytes and whose key size is `sizeof(AccountId)` bytes.
|
||||
**/
|
||||
proxyDepositBase: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount of currency needed per proxy added.
|
||||
*
|
||||
* This is held for adding 32 bytes plus an instance of `ProxyType` more into a
|
||||
* pre-existing storage value. Thus, when configuring `ProxyDepositFactor` one should take
|
||||
* into account `32 + proxy_type.encode().len()` bytes of data.
|
||||
**/
|
||||
proxyDepositFactor: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
recovery: {
|
||||
/**
|
||||
* The base amount of currency needed to reserve for creating a recovery configuration.
|
||||
*
|
||||
* This is held for an additional storage item whose value size is
|
||||
* `2 + sizeof(BlockNumber, Balance)` bytes.
|
||||
**/
|
||||
configDepositBase: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount of currency needed per additional user when creating a recovery
|
||||
* configuration.
|
||||
*
|
||||
* This is held for adding `sizeof(AccountId)` bytes more into a pre-existing storage
|
||||
* value.
|
||||
**/
|
||||
friendDepositFactor: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum amount of friends allowed in a recovery configuration.
|
||||
**/
|
||||
maxFriends: u16 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The base amount of currency needed to reserve for starting a recovery.
|
||||
*
|
||||
* This is primarily held for deterring malicious recovery attempts, and should
|
||||
* have a value large enough that a bad actor would choose not to place this
|
||||
* deposit. It also acts to fund additional storage item whose value size is
|
||||
* `sizeof(BlockNumber, Balance + T * AccountId)` bytes. Where T is a configurable
|
||||
* threshold.
|
||||
**/
|
||||
recoveryDeposit: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
scheduler: {
|
||||
/**
|
||||
* The maximum weight that may be scheduled per block for any dispatchables of less
|
||||
* priority than `schedule::HARD_DEADLINE`.
|
||||
**/
|
||||
maximumWeight: u64 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum number of scheduled calls in the queue for a single block.
|
||||
* Not strictly enforced, but used for weight estimation.
|
||||
**/
|
||||
maxScheduledPerBlock: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
society: {
|
||||
/**
|
||||
* The minimum amount of a deposit required for a bid to be made.
|
||||
**/
|
||||
candidateDeposit: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The number of blocks between membership challenges.
|
||||
**/
|
||||
challengePeriod: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum number of candidates that we accept per round.
|
||||
**/
|
||||
maxCandidateIntake: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum duration of the payout lock.
|
||||
**/
|
||||
maxLockDuration: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The number of times a member may vote the wrong way (or not at all, when they are a
|
||||
* skeptic) before they become suspended.
|
||||
**/
|
||||
maxStrikes: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The societies's pallet id
|
||||
**/
|
||||
palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount of incentive paid within each period. Doesn't include VoterTip.
|
||||
**/
|
||||
periodSpend: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The number of blocks between candidate/membership rotation periods.
|
||||
**/
|
||||
rotationPeriod: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount of the unpaid reward that gets deducted in the case that either a skeptic
|
||||
* doesn't vote or someone votes in the wrong way.
|
||||
**/
|
||||
wrongSideDeduction: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
staking: {
|
||||
/**
|
||||
* Number of eras that staked funds must remain bonded for.
|
||||
**/
|
||||
bondingDuration: u32 & AugmentedConst<ApiType>;
|
||||
maxNominations: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum number of nominators rewarded for each validator.
|
||||
*
|
||||
* For each validator only the `$MaxNominatorRewardedPerValidator` biggest stakers can
|
||||
* claim their reward. This used to limit the i/o cost for the nominator payout.
|
||||
**/
|
||||
maxNominatorRewardedPerValidator: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Number of sessions per era.
|
||||
**/
|
||||
sessionsPerEra: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Number of eras that slashes are deferred by, after computation.
|
||||
*
|
||||
* This should be less than the bonding duration. Set to 0 if slashes
|
||||
* should be applied immediately, without opportunity for intervention.
|
||||
**/
|
||||
slashDeferDuration: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
system: {
|
||||
/**
|
||||
* Maximum number of block number to block hash mappings to keep (oldest pruned first).
|
||||
**/
|
||||
blockHashCount: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum length of a block (in bytes).
|
||||
**/
|
||||
blockLength: FrameSystemLimitsBlockLength & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Block & extrinsics weights: base values and limits.
|
||||
**/
|
||||
blockWeights: FrameSystemLimitsBlockWeights & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The weight of runtime database operations the runtime can invoke.
|
||||
**/
|
||||
dbWeight: FrameSupportWeightsRuntimeDbWeight & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The designated SS85 prefix of this chain.
|
||||
*
|
||||
* This replaces the "ss58Format" property declared in the chain spec. Reason is
|
||||
* that the runtime should know about the prefix in order to make use of it as
|
||||
* an identifier of the chain.
|
||||
**/
|
||||
ss58Prefix: u16 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Get the chain's current version.
|
||||
**/
|
||||
version: SpVersionRuntimeVersion & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
timestamp: {
|
||||
/**
|
||||
* The minimum period between blocks. Beware that this is different to the *expected*
|
||||
* period that the block production apparatus provides. Your chosen consensus system will
|
||||
* generally work with this to determine a sensible block time. e.g. For Aura, it will be
|
||||
* double this period on default settings.
|
||||
**/
|
||||
minimumPeriod: u64 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
tips: {
|
||||
/**
|
||||
* The amount held on deposit per byte within the tip report reason or bounty description.
|
||||
**/
|
||||
dataDepositPerByte: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Maximum acceptable reason length.
|
||||
*
|
||||
* Benchmarks depend on this value, be sure to update weights file when changing this value
|
||||
**/
|
||||
maximumReasonLength: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The period for which a tip remains open after is has achieved threshold tippers.
|
||||
**/
|
||||
tipCountdown: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The percent of the final tip which goes to the original reporter of the tip.
|
||||
**/
|
||||
tipFindersFee: Percent & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The amount held on deposit for placing a tip report.
|
||||
**/
|
||||
tipReportDepositBase: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
transactionPayment: {
|
||||
/**
|
||||
* A fee mulitplier for `Operational` extrinsics to compute "virtual tip" to boost their
|
||||
* `priority`
|
||||
*
|
||||
* This value is multipled by the `final_fee` to obtain a "virtual tip" that is later
|
||||
* added to a tip component in regular `priority` calculations.
|
||||
* It means that a `Normal` transaction can front-run a similarly-sized `Operational`
|
||||
* extrinsic (with no tip), by including a tip value greater than the virtual tip.
|
||||
*
|
||||
* ```rust,ignore
|
||||
* // For `Normal`
|
||||
* let priority = priority_calc(tip);
|
||||
*
|
||||
* // For `Operational`
|
||||
* let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier;
|
||||
* let priority = priority_calc(tip + virtual_tip);
|
||||
* ```
|
||||
*
|
||||
* Note that since we use `final_fee` the multiplier applies also to the regular `tip`
|
||||
* sent with the transaction. So, not only does the transaction get a priority bump based
|
||||
* on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational`
|
||||
* transactions.
|
||||
**/
|
||||
operationalFeeMultiplier: u8 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The fee to be paid for making a transaction; the per-byte portion.
|
||||
**/
|
||||
transactionByteFee: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The polynomial that is applied in order to derive fee from weight.
|
||||
**/
|
||||
weightToFee: Vec<FrameSupportWeightsWeightToFeeCoefficient> & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
treasury: {
|
||||
/**
|
||||
* Percentage of spare funds (if any) that are burnt per spend period.
|
||||
**/
|
||||
burn: Permill & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum number of approvals that can wait in the spending queue.
|
||||
**/
|
||||
maxApprovals: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The treasury's pallet id, used for deriving its sovereign account ID.
|
||||
**/
|
||||
palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Fraction of a proposal's value that should be bonded in order to place the proposal.
|
||||
* An accepted proposal gets these back. A rejected proposal does not.
|
||||
**/
|
||||
proposalBond: Permill & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Minimum amount of funds that should be placed in a deposit for making a proposal.
|
||||
**/
|
||||
proposalBondMinimum: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Period between successive spends.
|
||||
**/
|
||||
spendPeriod: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
uniques: {
|
||||
/**
|
||||
* The basic amount of funds that must be reserved when adding an attribute to an asset.
|
||||
**/
|
||||
attributeDepositBase: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The basic amount of funds that must be reserved for an asset class.
|
||||
**/
|
||||
classDeposit: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The additional funds that must be reserved for the number of bytes store in metadata,
|
||||
* either "normal" metadata or attribute metadata.
|
||||
**/
|
||||
depositPerByte: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The basic amount of funds that must be reserved for an asset instance.
|
||||
**/
|
||||
instanceDeposit: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum length of an attribute key.
|
||||
**/
|
||||
keyLimit: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The basic amount of funds that must be reserved when adding metadata to your asset.
|
||||
**/
|
||||
metadataDepositBase: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum length of data stored on-chain.
|
||||
**/
|
||||
stringLimit: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The maximum length of an attribute value.
|
||||
**/
|
||||
valueLimit: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
utility: {
|
||||
/**
|
||||
* The limit on the number of batched calls.
|
||||
**/
|
||||
batchedCallsLimit: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
vesting: {
|
||||
maxVestingSchedules: u32 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* The minimum amount transferred to call `vested_transfer`.
|
||||
**/
|
||||
minVestedTransfer: u128 & AugmentedConst<ApiType>;
|
||||
/**
|
||||
* Generic const
|
||||
**/
|
||||
[key: string]: Codec;
|
||||
};
|
||||
} // AugmentedConsts
|
||||
|
||||
export interface QueryableConsts<ApiType extends ApiTypes> extends AugmentedConsts<ApiType> {
|
||||
[key: string]: QueryableModuleConsts;
|
||||
} // QueryableConsts
|
||||
|
||||
} // declare module
|
||||
@@ -0,0 +1,10 @@
|
||||
// Copyright 2017-2021 @polkadot/api-contract authors & contributors
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
import { packageInfo as rpcInfo } from '@polkadot/rpc-core/packageInfo';
|
||||
import { packageInfo as typesInfo } from '@polkadot/types/packageInfo';
|
||||
import { detectPackage } from '@polkadot/util';
|
||||
|
||||
import { packageInfo } from './packageInfo';
|
||||
|
||||
detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname, [rpcInfo, typesInfo]);
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,6 @@
|
||||
// Copyright 2017-2021 @polkadot/api-contract authors & contributors
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
import './detectPackage';
|
||||
|
||||
export * from './bundle';
|
||||
@@ -0,0 +1,6 @@
|
||||
// Copyright 2017-2021 @polkadot/api-augment authors & contributors
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Auto-generated by @polkadot/dev, do not edit
|
||||
|
||||
export const packageInfo = { name: '@polkadot/api-augment', version: '6.12.2-11' };
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,562 @@
|
||||
// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
|
||||
/* eslint-disable */
|
||||
|
||||
declare module '@polkadot/rpc-core/types.jsonrpc' {
|
||||
import type { AugmentedRpc } from '@polkadot/rpc-core/types';
|
||||
import type { Bytes, HashMap, Json, Metadata, Null, Option, StorageKey, Text, U256, U64, Vec, bool, u32, u64 } from '@polkadot/types';
|
||||
import type { ExtrinsicOrHash, ExtrinsicStatus } from '@polkadot/types/interfaces/author';
|
||||
import type { EpochAuthorship } from '@polkadot/types/interfaces/babe';
|
||||
import type { BeefySignedCommitment } from '@polkadot/types/interfaces/beefy';
|
||||
import type { BlockHash } from '@polkadot/types/interfaces/chain';
|
||||
import type { PrefixedStorageKey } from '@polkadot/types/interfaces/childstate';
|
||||
import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
|
||||
import type { ContractCallRequest, ContractExecResult, ContractInstantiateResult, InstantiateRequest } from '@polkadot/types/interfaces/contracts';
|
||||
import type { CreatedBlock } from '@polkadot/types/interfaces/engine';
|
||||
import type { EthAccount, EthCallRequest, EthFilter, EthFilterChanges, EthLog, EthReceipt, EthRichBlock, EthSubKind, EthSubParams, EthSyncStatus, EthTransaction, EthTransactionRequest, EthWork } from '@polkadot/types/interfaces/eth';
|
||||
import type { Extrinsic } from '@polkadot/types/interfaces/extrinsics';
|
||||
import type { EncodedFinalityProofs, JustificationNotification, ReportedRoundStates } from '@polkadot/types/interfaces/grandpa';
|
||||
import type { MmrLeafProof } from '@polkadot/types/interfaces/mmr';
|
||||
import type { StorageKind } from '@polkadot/types/interfaces/offchain';
|
||||
import type { FeeDetails, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
|
||||
import type { RpcMethods } from '@polkadot/types/interfaces/rpc';
|
||||
import type { AccountId, BlockNumber, H160, H256, H64, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime';
|
||||
import type { ReadProof, RuntimeVersion, TraceBlockResponse } from '@polkadot/types/interfaces/state';
|
||||
import type { ApplyExtrinsicResult, ChainProperties, ChainType, Health, NetworkState, NodeRole, PeerInfo, SyncState } from '@polkadot/types/interfaces/system';
|
||||
import type { AnyNumber, Codec, IExtrinsic, Observable } from '@polkadot/types/types';
|
||||
|
||||
export interface RpcInterface {
|
||||
author: {
|
||||
/**
|
||||
* Returns true if the keystore has private keys for the given public key and key type.
|
||||
**/
|
||||
hasKey: AugmentedRpc<(publicKey: Bytes | string | Uint8Array, keyType: Text | string) => Observable<bool>>;
|
||||
/**
|
||||
* Returns true if the keystore has private keys for the given session public keys.
|
||||
**/
|
||||
hasSessionKeys: AugmentedRpc<(sessionKeys: Bytes | string | Uint8Array) => Observable<bool>>;
|
||||
/**
|
||||
* Insert a key into the keystore.
|
||||
**/
|
||||
insertKey: AugmentedRpc<(keyType: Text | string, suri: Text | string, publicKey: Bytes | string | Uint8Array) => Observable<Bytes>>;
|
||||
/**
|
||||
* Returns all pending extrinsics, potentially grouped by sender
|
||||
**/
|
||||
pendingExtrinsics: AugmentedRpc<() => Observable<Vec<Extrinsic>>>;
|
||||
/**
|
||||
* Remove given extrinsic from the pool and temporarily ban it to prevent reimporting
|
||||
**/
|
||||
removeExtrinsic: AugmentedRpc<(bytesOrHash: Vec<ExtrinsicOrHash> | (ExtrinsicOrHash | { Hash: any } | { Extrinsic: any } | string | Uint8Array)[]) => Observable<Vec<Hash>>>;
|
||||
/**
|
||||
* Generate new session keys and returns the corresponding public keys
|
||||
**/
|
||||
rotateKeys: AugmentedRpc<() => Observable<Bytes>>;
|
||||
/**
|
||||
* Submit and subscribe to watch an extrinsic until unsubscribed
|
||||
**/
|
||||
submitAndWatchExtrinsic: AugmentedRpc<(extrinsic: IExtrinsic) => Observable<ExtrinsicStatus>>;
|
||||
/**
|
||||
* Submit a fully formatted extrinsic for block inclusion
|
||||
**/
|
||||
submitExtrinsic: AugmentedRpc<(extrinsic: IExtrinsic) => Observable<Hash>>;
|
||||
};
|
||||
babe: {
|
||||
/**
|
||||
* Returns data about which slots (primary or secondary) can be claimed in the current epoch with the keys in the keystore
|
||||
**/
|
||||
epochAuthorship: AugmentedRpc<() => Observable<HashMap<AuthorityId, EpochAuthorship>>>;
|
||||
};
|
||||
beefy: {
|
||||
/**
|
||||
* Returns the block most recently finalized by BEEFY, alongside side its justification.
|
||||
**/
|
||||
subscribeJustifications: AugmentedRpc<() => Observable<BeefySignedCommitment>>;
|
||||
};
|
||||
chain: {
|
||||
/**
|
||||
* Get header and body of a relay chain block
|
||||
**/
|
||||
getBlock: AugmentedRpc<(hash?: BlockHash | string | Uint8Array) => Observable<SignedBlock>>;
|
||||
/**
|
||||
* Get the block hash for a specific block
|
||||
**/
|
||||
getBlockHash: AugmentedRpc<(blockNumber?: BlockNumber | AnyNumber | Uint8Array) => Observable<BlockHash>>;
|
||||
/**
|
||||
* Get hash of the last finalized block in the canon chain
|
||||
**/
|
||||
getFinalizedHead: AugmentedRpc<() => Observable<BlockHash>>;
|
||||
/**
|
||||
* Retrieves the header for a specific block
|
||||
**/
|
||||
getHeader: AugmentedRpc<(hash?: BlockHash | string | Uint8Array) => Observable<Header>>;
|
||||
/**
|
||||
* Retrieves the newest header via subscription
|
||||
**/
|
||||
subscribeAllHeads: AugmentedRpc<() => Observable<Header>>;
|
||||
/**
|
||||
* Retrieves the best finalized header via subscription
|
||||
**/
|
||||
subscribeFinalizedHeads: AugmentedRpc<() => Observable<Header>>;
|
||||
/**
|
||||
* Retrieves the best header via subscription
|
||||
**/
|
||||
subscribeNewHeads: AugmentedRpc<() => Observable<Header>>;
|
||||
};
|
||||
childstate: {
|
||||
/**
|
||||
* Returns the keys with prefix from a child storage, leave empty to get all the keys
|
||||
**/
|
||||
getKeys: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, prefix: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
|
||||
/**
|
||||
* Returns the keys with prefix from a child storage with pagination support
|
||||
**/
|
||||
getKeysPaged: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, prefix: StorageKey | string | Uint8Array | any, count: u32 | AnyNumber | Uint8Array, startKey?: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
|
||||
/**
|
||||
* Returns a child storage entry at a specific block state
|
||||
**/
|
||||
getStorage: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Option<StorageData>>>;
|
||||
/**
|
||||
* Returns child storage entries for multiple keys at a specific block state
|
||||
**/
|
||||
getStorageEntries: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: Hash | string | Uint8Array) => Observable<Vec<Option<StorageData>>>>;
|
||||
/**
|
||||
* Returns the hash of a child storage entry at a block state
|
||||
**/
|
||||
getStorageHash: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Option<Hash>>>;
|
||||
/**
|
||||
* Returns the size of a child storage entry at a block state
|
||||
**/
|
||||
getStorageSize: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Option<u64>>>;
|
||||
};
|
||||
contracts: {
|
||||
/**
|
||||
* Executes a call to a contract
|
||||
**/
|
||||
call: AugmentedRpc<(callRequest: ContractCallRequest | { origin?: any; dest?: any; value?: any; gasLimit?: any; inputData?: any } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ContractExecResult>>;
|
||||
/**
|
||||
* Returns the value under a specified storage key in a contract
|
||||
**/
|
||||
getStorage: AugmentedRpc<(address: AccountId | string | Uint8Array, key: H256 | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<Option<Bytes>>>;
|
||||
/**
|
||||
* Instantiate a new contract
|
||||
**/
|
||||
instantiate: AugmentedRpc<(request: InstantiateRequest | { origin?: any; value?: any; gasLimit?: any; code?: any; data?: any; salt?: any } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ContractInstantiateResult>>;
|
||||
/**
|
||||
* Returns the projected time a given contract will be able to sustain paying its rent
|
||||
**/
|
||||
rentProjection: AugmentedRpc<(address: AccountId | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<Option<BlockNumber>>>;
|
||||
};
|
||||
engine: {
|
||||
/**
|
||||
* Instructs the manual-seal authorship task to create a new block
|
||||
**/
|
||||
createBlock: AugmentedRpc<(createEmpty: bool | boolean | Uint8Array, finalize: bool | boolean | Uint8Array, parentHash?: BlockHash | string | Uint8Array) => Observable<CreatedBlock>>;
|
||||
/**
|
||||
* Instructs the manual-seal authorship task to finalize a block
|
||||
**/
|
||||
finalizeBlock: AugmentedRpc<(hash: BlockHash | string | Uint8Array, justification?: Justification) => Observable<bool>>;
|
||||
};
|
||||
eth: {
|
||||
/**
|
||||
* Returns accounts list.
|
||||
**/
|
||||
accounts: AugmentedRpc<() => Observable<Vec<H160>>>;
|
||||
/**
|
||||
* Returns the blockNumber
|
||||
**/
|
||||
blockNumber: AugmentedRpc<() => Observable<U256>>;
|
||||
/**
|
||||
* Call contract, returning the output data.
|
||||
**/
|
||||
call: AugmentedRpc<(request: EthCallRequest | { from?: any; to?: any; gasPrice?: any; gas?: any; value?: any; data?: any; nonce?: any } | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<Bytes>>;
|
||||
/**
|
||||
* Returns the chain ID used for transaction signing at the current best block. None is returned if not available.
|
||||
**/
|
||||
chainId: AugmentedRpc<() => Observable<U64>>;
|
||||
/**
|
||||
* Returns block author.
|
||||
**/
|
||||
coinbase: AugmentedRpc<() => Observable<H160>>;
|
||||
/**
|
||||
* Estimate gas needed for execution of given contract.
|
||||
**/
|
||||
estimateGas: AugmentedRpc<(request: EthCallRequest | { from?: any; to?: any; gasPrice?: any; gas?: any; value?: any; data?: any; nonce?: any } | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
|
||||
/**
|
||||
* Returns current gas price.
|
||||
**/
|
||||
gasPrice: AugmentedRpc<() => Observable<U256>>;
|
||||
/**
|
||||
* Returns balance of the given account.
|
||||
**/
|
||||
getBalance: AugmentedRpc<(address: H160 | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
|
||||
/**
|
||||
* Returns block with given hash.
|
||||
**/
|
||||
getBlockByHash: AugmentedRpc<(hash: H256 | string | Uint8Array, full: bool | boolean | Uint8Array) => Observable<Option<EthRichBlock>>>;
|
||||
/**
|
||||
* Returns block with given number.
|
||||
**/
|
||||
getBlockByNumber: AugmentedRpc<(block: BlockNumber | AnyNumber | Uint8Array, full: bool | boolean | Uint8Array) => Observable<Option<EthRichBlock>>>;
|
||||
/**
|
||||
* Returns the number of transactions in a block with given hash.
|
||||
**/
|
||||
getBlockTransactionCountByHash: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<U256>>;
|
||||
/**
|
||||
* Returns the number of transactions in a block with given block number.
|
||||
**/
|
||||
getBlockTransactionCountByNumber: AugmentedRpc<(block: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
|
||||
/**
|
||||
* Returns the code at given address at given time (block number).
|
||||
**/
|
||||
getCode: AugmentedRpc<(address: H160 | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<Bytes>>;
|
||||
/**
|
||||
* Returns filter changes since last poll.
|
||||
**/
|
||||
getFilterChanges: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array) => Observable<EthFilterChanges>>;
|
||||
/**
|
||||
* Returns all logs matching given filter (in a range 'from' - 'to').
|
||||
**/
|
||||
getFilterLogs: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array) => Observable<Vec<EthLog>>>;
|
||||
/**
|
||||
* Returns logs matching given filter object.
|
||||
**/
|
||||
getLogs: AugmentedRpc<(filter: EthFilter | { fromBlock?: any; toBlock?: any; blockHash?: any; address?: any; topics?: any } | string | Uint8Array) => Observable<Vec<EthLog>>>;
|
||||
/**
|
||||
* Returns proof for account and storage.
|
||||
**/
|
||||
getProof: AugmentedRpc<(address: H160 | string | Uint8Array, storageKeys: Vec<H256> | (H256 | string | Uint8Array)[], number: BlockNumber | AnyNumber | Uint8Array) => Observable<EthAccount>>;
|
||||
/**
|
||||
* Returns content of the storage at given address.
|
||||
**/
|
||||
getStorageAt: AugmentedRpc<(address: H160 | string | Uint8Array, index: U256 | AnyNumber | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<H256>>;
|
||||
/**
|
||||
* Returns transaction at given block hash and index.
|
||||
**/
|
||||
getTransactionByBlockHashAndIndex: AugmentedRpc<(hash: H256 | string | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthTransaction>>;
|
||||
/**
|
||||
* Returns transaction by given block number and index.
|
||||
**/
|
||||
getTransactionByBlockNumberAndIndex: AugmentedRpc<(number: BlockNumber | AnyNumber | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthTransaction>>;
|
||||
/**
|
||||
* Get transaction by its hash.
|
||||
**/
|
||||
getTransactionByHash: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<EthTransaction>>;
|
||||
/**
|
||||
* Returns the number of transactions sent from given address at given time (block number).
|
||||
**/
|
||||
getTransactionCount: AugmentedRpc<(hash: H256 | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
|
||||
/**
|
||||
* Returns transaction receipt by transaction hash.
|
||||
**/
|
||||
getTransactionReceipt: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<EthReceipt>>;
|
||||
/**
|
||||
* Returns an uncles at given block and index.
|
||||
**/
|
||||
getUncleByBlockHashAndIndex: AugmentedRpc<(hash: H256 | string | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthRichBlock>>;
|
||||
/**
|
||||
* Returns an uncles at given block and index.
|
||||
**/
|
||||
getUncleByBlockNumberAndIndex: AugmentedRpc<(number: BlockNumber | AnyNumber | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthRichBlock>>;
|
||||
/**
|
||||
* Returns the number of uncles in a block with given hash.
|
||||
**/
|
||||
getUncleCountByBlockHash: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<U256>>;
|
||||
/**
|
||||
* Returns the number of uncles in a block with given block number.
|
||||
**/
|
||||
getUncleCountByBlockNumber: AugmentedRpc<(number: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
|
||||
/**
|
||||
* Returns the hash of the current block, the seedHash, and the boundary condition to be met.
|
||||
**/
|
||||
getWork: AugmentedRpc<() => Observable<EthWork>>;
|
||||
/**
|
||||
* Returns the number of hashes per second that the node is mining with.
|
||||
**/
|
||||
hashrate: AugmentedRpc<() => Observable<U256>>;
|
||||
/**
|
||||
* Returns true if client is actively mining new blocks.
|
||||
**/
|
||||
mining: AugmentedRpc<() => Observable<bool>>;
|
||||
/**
|
||||
* Returns id of new block filter.
|
||||
**/
|
||||
newBlockFilter: AugmentedRpc<() => Observable<U256>>;
|
||||
/**
|
||||
* Returns id of new filter.
|
||||
**/
|
||||
newFilter: AugmentedRpc<(filter: EthFilter | { fromBlock?: any; toBlock?: any; blockHash?: any; address?: any; topics?: any } | string | Uint8Array) => Observable<U256>>;
|
||||
/**
|
||||
* Returns id of new block filter.
|
||||
**/
|
||||
newPendingTransactionFilter: AugmentedRpc<() => Observable<U256>>;
|
||||
/**
|
||||
* Returns protocol version encoded as a string (quotes are necessary).
|
||||
**/
|
||||
protocolVersion: AugmentedRpc<() => Observable<u64>>;
|
||||
/**
|
||||
* Sends signed transaction, returning its hash.
|
||||
**/
|
||||
sendRawTransaction: AugmentedRpc<(bytes: Bytes | string | Uint8Array) => Observable<H256>>;
|
||||
/**
|
||||
* Sends transaction; will block waiting for signer to return the transaction hash
|
||||
**/
|
||||
sendTransaction: AugmentedRpc<(tx: EthTransactionRequest | { from?: any; to?: any; gasPrice?: any; gas?: any; value?: any; data?: any; nonce?: any } | string | Uint8Array) => Observable<H256>>;
|
||||
/**
|
||||
* Used for submitting mining hashrate.
|
||||
**/
|
||||
submitHashrate: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array, hash: H256 | string | Uint8Array) => Observable<bool>>;
|
||||
/**
|
||||
* Used for submitting a proof-of-work solution.
|
||||
**/
|
||||
submitWork: AugmentedRpc<(nonce: H64 | string | Uint8Array, headerHash: H256 | string | Uint8Array, mixDigest: H256 | string | Uint8Array) => Observable<bool>>;
|
||||
/**
|
||||
* Subscribe to Eth subscription.
|
||||
**/
|
||||
subscribe: AugmentedRpc<(kind: EthSubKind | 'newHeads' | 'logs' | 'newPendingTransactions' | 'syncing' | number | Uint8Array, params?: EthSubParams | { None: any } | { Logs: any } | string | Uint8Array) => Observable<Null>>;
|
||||
/**
|
||||
* Returns an object with data about the sync status or false.
|
||||
**/
|
||||
syncing: AugmentedRpc<() => Observable<EthSyncStatus>>;
|
||||
/**
|
||||
* Uninstalls filter.
|
||||
**/
|
||||
uninstallFilter: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array) => Observable<bool>>;
|
||||
};
|
||||
grandpa: {
|
||||
/**
|
||||
* Prove finality for the range (begin; end] hash.
|
||||
**/
|
||||
proveFinality: AugmentedRpc<(begin: BlockHash | string | Uint8Array, end: BlockHash | string | Uint8Array, authoritiesSetId?: u64 | AnyNumber | Uint8Array) => Observable<Option<EncodedFinalityProofs>>>;
|
||||
/**
|
||||
* Returns the state of the current best round state as well as the ongoing background rounds
|
||||
**/
|
||||
roundState: AugmentedRpc<() => Observable<ReportedRoundStates>>;
|
||||
/**
|
||||
* Subscribes to grandpa justifications
|
||||
**/
|
||||
subscribeJustifications: AugmentedRpc<() => Observable<JustificationNotification>>;
|
||||
};
|
||||
mmr: {
|
||||
/**
|
||||
* Generate MMR proof for given leaf index.
|
||||
**/
|
||||
generateProof: AugmentedRpc<(leafIndex: u64 | AnyNumber | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<MmrLeafProof>>;
|
||||
};
|
||||
net: {
|
||||
/**
|
||||
* Returns true if client is actively listening for network connections. Otherwise false.
|
||||
**/
|
||||
listening: AugmentedRpc<() => Observable<bool>>;
|
||||
/**
|
||||
* Returns number of peers connected to node.
|
||||
**/
|
||||
peerCount: AugmentedRpc<() => Observable<Text>>;
|
||||
/**
|
||||
* Returns protocol version.
|
||||
**/
|
||||
version: AugmentedRpc<() => Observable<Text>>;
|
||||
};
|
||||
offchain: {
|
||||
/**
|
||||
* Get offchain local storage under given key and prefix
|
||||
**/
|
||||
localStorageGet: AugmentedRpc<(kind: StorageKind | 'PERSISTENT' | 'LOCAL' | number | Uint8Array, key: Bytes | string | Uint8Array) => Observable<Option<Bytes>>>;
|
||||
/**
|
||||
* Set offchain local storage under given key and prefix
|
||||
**/
|
||||
localStorageSet: AugmentedRpc<(kind: StorageKind | 'PERSISTENT' | 'LOCAL' | number | Uint8Array, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => Observable<Null>>;
|
||||
};
|
||||
payment: {
|
||||
/**
|
||||
* Query the detailed fee of a given encoded extrinsic
|
||||
**/
|
||||
queryFeeDetails: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<FeeDetails>>;
|
||||
/**
|
||||
* Retrieves the fee information for an encoded extrinsic
|
||||
**/
|
||||
queryInfo: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<RuntimeDispatchInfo>>;
|
||||
};
|
||||
rpc: {
|
||||
/**
|
||||
* Retrieves the list of RPC methods that are exposed by the node
|
||||
**/
|
||||
methods: AugmentedRpc<() => Observable<RpcMethods>>;
|
||||
};
|
||||
state: {
|
||||
/**
|
||||
* Perform a call to a builtin on the chain
|
||||
**/
|
||||
call: AugmentedRpc<(method: Text | string, data: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<Bytes>>;
|
||||
/**
|
||||
* Retrieves the keys with prefix of a specific child storage
|
||||
**/
|
||||
getChildKeys: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
|
||||
/**
|
||||
* Returns proof of storage for child key entries at a specific block state.
|
||||
**/
|
||||
getChildReadProof: AugmentedRpc<(childStorageKey: PrefixedStorageKey | string | Uint8Array, keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: BlockHash | string | Uint8Array) => Observable<ReadProof>>;
|
||||
/**
|
||||
* Retrieves the child storage for a key
|
||||
**/
|
||||
getChildStorage: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<StorageData>>;
|
||||
/**
|
||||
* Retrieves the child storage hash
|
||||
**/
|
||||
getChildStorageHash: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Hash>>;
|
||||
/**
|
||||
* Retrieves the child storage size
|
||||
**/
|
||||
getChildStorageSize: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<u64>>;
|
||||
/**
|
||||
* Retrieves the keys with a certain prefix
|
||||
**/
|
||||
getKeys: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
|
||||
/**
|
||||
* Returns the keys with prefix with pagination support.
|
||||
**/
|
||||
getKeysPaged: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, count: u32 | AnyNumber | Uint8Array, startKey?: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
|
||||
/**
|
||||
* Returns the runtime metadata
|
||||
**/
|
||||
getMetadata: AugmentedRpc<(at?: BlockHash | string | Uint8Array) => Observable<Metadata>>;
|
||||
/**
|
||||
* Returns the keys with prefix, leave empty to get all the keys (deprecated: Use getKeysPaged)
|
||||
**/
|
||||
getPairs: AugmentedRpc<(prefix: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<KeyValue>>>;
|
||||
/**
|
||||
* Returns proof of storage entries at a specific block state
|
||||
**/
|
||||
getReadProof: AugmentedRpc<(keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: BlockHash | string | Uint8Array) => Observable<ReadProof>>;
|
||||
/**
|
||||
* Get the runtime version
|
||||
**/
|
||||
getRuntimeVersion: AugmentedRpc<(at?: BlockHash | string | Uint8Array) => Observable<RuntimeVersion>>;
|
||||
/**
|
||||
* Retrieves the storage for a key
|
||||
**/
|
||||
getStorage: AugmentedRpc<<T = Codec>(key: StorageKey | string | Uint8Array | any, block?: Hash | Uint8Array | string) => Observable<T>>;
|
||||
/**
|
||||
* Retrieves the storage hash
|
||||
**/
|
||||
getStorageHash: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Hash>>;
|
||||
/**
|
||||
* Retrieves the storage size
|
||||
**/
|
||||
getStorageSize: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<u64>>;
|
||||
/**
|
||||
* Query historical storage entries (by key) starting from a start block
|
||||
**/
|
||||
queryStorage: AugmentedRpc<<T = Codec[]>(keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], fromBlock?: Hash | Uint8Array | string, toBlock?: Hash | Uint8Array | string) => Observable<[Hash, T][]>>;
|
||||
/**
|
||||
* Query storage entries (by key) starting at block hash given as the second parameter
|
||||
**/
|
||||
queryStorageAt: AugmentedRpc<<T = Codec[]>(keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: Hash | Uint8Array | string) => Observable<T>>;
|
||||
/**
|
||||
* Retrieves the runtime version via subscription
|
||||
**/
|
||||
subscribeRuntimeVersion: AugmentedRpc<() => Observable<RuntimeVersion>>;
|
||||
/**
|
||||
* Subscribes to storage changes for the provided keys
|
||||
**/
|
||||
subscribeStorage: AugmentedRpc<<T = Codec[]>(keys?: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[]) => Observable<T>>;
|
||||
/**
|
||||
* Provides a way to trace the re-execution of a single block
|
||||
**/
|
||||
traceBlock: AugmentedRpc<(block: Hash | string | Uint8Array, targets: Option<Text> | null | object | string | Uint8Array, storageKeys: Option<Text> | null | object | string | Uint8Array, methods: Option<Text> | null | object | string | Uint8Array) => Observable<TraceBlockResponse>>;
|
||||
};
|
||||
syncstate: {
|
||||
/**
|
||||
* Returns the json-serialized chainspec running the node, with a sync state.
|
||||
**/
|
||||
genSyncSpec: AugmentedRpc<(raw: bool | boolean | Uint8Array) => Observable<Json>>;
|
||||
};
|
||||
system: {
|
||||
/**
|
||||
* Retrieves the next accountIndex as available on the node
|
||||
**/
|
||||
accountNextIndex: AugmentedRpc<(accountId: AccountId | string | Uint8Array) => Observable<Index>>;
|
||||
/**
|
||||
* Adds the supplied directives to the current log filter
|
||||
**/
|
||||
addLogFilter: AugmentedRpc<(directives: Text | string) => Observable<Null>>;
|
||||
/**
|
||||
* Adds a reserved peer
|
||||
**/
|
||||
addReservedPeer: AugmentedRpc<(peer: Text | string) => Observable<Text>>;
|
||||
/**
|
||||
* Retrieves the chain
|
||||
**/
|
||||
chain: AugmentedRpc<() => Observable<Text>>;
|
||||
/**
|
||||
* Retrieves the chain type
|
||||
**/
|
||||
chainType: AugmentedRpc<() => Observable<ChainType>>;
|
||||
/**
|
||||
* Dry run an extrinsic at a given block
|
||||
**/
|
||||
dryRun: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ApplyExtrinsicResult>>;
|
||||
/**
|
||||
* Return health status of the node
|
||||
**/
|
||||
health: AugmentedRpc<() => Observable<Health>>;
|
||||
/**
|
||||
* The addresses include a trailing /p2p/ with the local PeerId, and are thus suitable to be passed to addReservedPeer or as a bootnode address for example
|
||||
**/
|
||||
localListenAddresses: AugmentedRpc<() => Observable<Vec<Text>>>;
|
||||
/**
|
||||
* Returns the base58-encoded PeerId of the node
|
||||
**/
|
||||
localPeerId: AugmentedRpc<() => Observable<Text>>;
|
||||
/**
|
||||
* Retrieves the node name
|
||||
**/
|
||||
name: AugmentedRpc<() => Observable<Text>>;
|
||||
/**
|
||||
* Returns current state of the network
|
||||
**/
|
||||
networkState: AugmentedRpc<() => Observable<NetworkState>>;
|
||||
/**
|
||||
* Returns the roles the node is running as
|
||||
**/
|
||||
nodeRoles: AugmentedRpc<() => Observable<Vec<NodeRole>>>;
|
||||
/**
|
||||
* Returns the currently connected peers
|
||||
**/
|
||||
peers: AugmentedRpc<() => Observable<Vec<PeerInfo>>>;
|
||||
/**
|
||||
* Get a custom set of properties as a JSON object, defined in the chain spec
|
||||
**/
|
||||
properties: AugmentedRpc<() => Observable<ChainProperties>>;
|
||||
/**
|
||||
* Remove a reserved peer
|
||||
**/
|
||||
removeReservedPeer: AugmentedRpc<(peerId: Text | string) => Observable<Text>>;
|
||||
/**
|
||||
* Returns the list of reserved peers
|
||||
**/
|
||||
reservedPeers: AugmentedRpc<() => Observable<Vec<Text>>>;
|
||||
/**
|
||||
* Resets the log filter to Substrate defaults
|
||||
**/
|
||||
resetLogFilter: AugmentedRpc<() => Observable<Null>>;
|
||||
/**
|
||||
* Returns the state of the syncing of the node
|
||||
**/
|
||||
syncState: AugmentedRpc<() => Observable<SyncState>>;
|
||||
/**
|
||||
* Retrieves the version of the node
|
||||
**/
|
||||
version: AugmentedRpc<() => Observable<Text>>;
|
||||
};
|
||||
web3: {
|
||||
/**
|
||||
* Returns current client version.
|
||||
**/
|
||||
clientVersion: AugmentedRpc<() => Observable<Text>>;
|
||||
/**
|
||||
* Returns sha3 of the given data
|
||||
**/
|
||||
sha3: AugmentedRpc<(data: Bytes | string | Uint8Array) => Observable<H256>>;
|
||||
};
|
||||
} // RpcInterface
|
||||
|
||||
} // declare module
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user