@cessnetwork/api/dist/chain/staking.js

CESS Chain Interface Implementation in TypeScript

import { isApiReady } from "../utils/tx";
import { SDKError } from "../utils";
import * as staking from '../pallets/staking';
export function Staking(Base) {
    return class extends Base {
        async queryValidatorAndNominatorTotalCount(block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryValidatorAndNominatorTotalCount(this.api, block);
        }
        async queryCurrentValidatorCount(block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryCurrentValidatorCount(this.api, block);
        }
        async queryTotalStakeByEraNumber(era, block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryTotalStakeByEraNumber(this.api, era, block);
        }
        async queryCurrentEraNumber(block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryCurrentEraNumber(this.api, block);
        }
        async queryRewardPointByEraNumber(era, block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryRewardPointByEraNumber(this.api, era, block);
        }
        async queryAllBonded(accountId, block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryBonded(this.api, accountId, block);
        }
        async queryValidatorCommission(accountId, block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryValidatorCommission(this.api, accountId, block);
        }
        async queryValidatorRewardByEraNumber(era, block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryValidatorRewardByEraNumber(this.api, era, block);
        }
        async queryLedger(accountId, block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryLedger(this.api, accountId, block);
        }
        async queryStakeByEraNumber(era, accountId, block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryStakerByEraNumber(this.api, era, accountId, block);
        }
        async queryAllErasStakePaged(era, accountId, pageIndex, block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryAllErasStakerPaged(this.api, era, accountId, pageIndex, block);
        }
        async queryStakeOverviewByEra(era, accountId, block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryStakerOverviewByEra(this.api, era, accountId, block);
        }
        async queryNominator(accountId, block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryNominator(this.api, accountId, block);
        }
        async queryMinimumActiveStake(block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryMinimumActiveStake(this.api, block);
        }
        async queryMinimumValidatorCount(block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryMinimumValidatorCount(this.api, block);
        }
        async queryActiveEra(block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryActiveEra(this.api, block);
        }
        async queryCanceledSlashPayout(block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryCanceledSlashPayout(this.api, block);
        }
        async queryClaimedRewards(era, accountId, block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryClaimedReward(this.api, era, accountId, block);
        }
        async queryCurrentPlannedSession(block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryCurrentPlannedSession(this.api, block);
        }
        async queryDisabledValidators(block) {
            if (!isApiReady(this.api)) {
                throw new SDKError('API Client is not ready', 'INVALID_API_CLIENT');
            }
            return staking.queryDisabledValidators(this.api, block);
        }
    };
}
//# sourceMappingURL=staking.js.map