@ardier16/q-js-sdk/lib/utils/validator-metrics.js

Typescript Library to interact with Q System Contracts

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ValidatorMetrics = void 0;
const __1 = require("..");
/**
 * Helps calculate delegation efficiency and saturation
 */
class ValidatorMetrics {
    constructor() {
        this.c = new __1.UnitConverter;
    }
    /**
     * @internal
     * Takes snapshot using given data.
     * Used by unit tests.
     * @param validatorsInfo ValidatorInfo struct array
     * @param poolsInfo ValidatorPoolInfo struct array
     * @param stakeDelegationFactor current stake delegation factor
     */
    async setSnapShot(validatorsInfo, poolsInfo, stakeDelegationFactor) {
        if (validatorsInfo.length != poolsInfo.length) {
            throw new RangeError('validatorsInfo length does not equal to poolsInfo length');
        }
        this.validatorsInfo = validatorsInfo;
        this.poolsInfo = poolsInfo;
        this.stakeDelegationFactor = stakeDelegationFactor;
    }
    /**
     * Takes snapshot using registry
     * @param registry Contract registry instance
     */
    async takeSnapshotFromNetwork(registry) {
        await this.takeSnapshot(await registry.validators(), await registry.validationRewardPools(), await registry.epqfiParameters());
    }
    /**
     * @internal
     * Takes snapshot using Validators, ValidationRewardPools and EPQFIParameters instances.
     * Used by takeSnapshotFromNetwork method
     * @param validatorsInstance ValidatorsInstance
     * @param poolsInstance ValidationRewardPoolsInstance
     * @param parameters EPQFIParametersInstance
     */
    async takeSnapshot(validatorsInstance, poolsInstance, parameters) {
        const validators = await validatorsInstance.getShortList();
        const infos = validators.map(v => validatorsInstance.getValidatorInfo(v.address));
        const pools = validators.map(v => poolsInstance.getPoolInfo(v.address));
        const stakeDelegationFactorKey = 'governed.EPQFI.stakeDelegationFactor';
        const stakeDelegationFactor = await parameters.getUint(stakeDelegationFactorKey);
        await this.setSnapShot(await Promise.all(infos), await Promise.all(pools), stakeDelegationFactor);
    }
    /**
     * Returns stored snapshot
     * @returns ValidatorSnapshot struct array
     */
    async getSnapshot() {
        const validatorSnapshots = this.validatorsInfo.map((v, i) => {
            return {
                address: v.address,
                accountableStake: v.accountableStake,
                delegatedStake: v.delegatedStake,
                delegatorsShare: this.poolsInfo[i].delegatorsShare,
                selfStake: v.selfStake,
                totalStake: v.totalStake,
                stakeDelegationFactor: this.stakeDelegationFactor
            };
        });
        return validatorSnapshots;
    }
    /**
     * Calculates delegation efficiency using snapshot
     * @returns Delegation efficiency
     */
    async getDelegationEfficiency() {
        const sum = (items) => {
            return items.reduce((sum, u) => sum + u, 0);
        };
        const validatorsInfo = this.validatorsInfo;
        const poolsInfo = this.poolsInfo;
        const globalAccountableStake = sum(validatorsInfo.map(v => +v.accountableStake));
        if (globalAccountableStake == 0) {
            throw new EvalError('global accountable stake equals to 0');
        }
        let delegationEfficiency = validatorsInfo.map((validatorInfo, index) => {
            const poolInfo = poolsInfo[index];
            const totalAccountableStake = +validatorInfo.accountableStake;
            const delegatedStake = +validatorInfo.delegatedStake;
            const globalStakeShare = totalAccountableStake / globalAccountableStake;
            const delegatorsShare = +poolInfo.delegatorsShare;
            const payoutToDelegator = globalStakeShare * delegatorsShare;
            let payoutPerDelegatedQ = 0;
            if (delegatedStake != 0) {
                payoutPerDelegatedQ = payoutToDelegator / (delegatedStake);
            }
            return {
                address: validatorInfo.address,
                globalStakeShare: globalStakeShare.toString(),
                delegatorShare: delegatorsShare.toString(),
                payoutToDelegators: payoutToDelegator.toString(),
                payoutPerDelegatedQ: payoutPerDelegatedQ.toString(),
                delegationEfficiency: '0'
            };
        });
        const totalPayoutPerDelegatedQ = sum(delegationEfficiency.map(d => +d.payoutPerDelegatedQ));
        if (totalPayoutPerDelegatedQ != 0) {
            delegationEfficiency = delegationEfficiency.map((d) => {
                const delegationEfficiency = +d.payoutPerDelegatedQ * 100 / totalPayoutPerDelegatedQ;
                d.delegationEfficiency = delegationEfficiency.toString();
                return d;
            });
        }
        return delegationEfficiency;
    }
    /**
     * Calculates delegation saturation using snapshot
     * @returns DelegationSaturation
     */
    async getDelegationSaturation() {
        const validatorsInfo = this.validatorsInfo;
        const blockchainPercentageFactor = this.stakeDelegationFactor;
        const stakeDelegationFactor = +this.c.fromSmallestUnit(blockchainPercentageFactor, 29);
        const delegationSaturation = validatorsInfo.map(v => {
            const delegationFactor = v.currentDelegationFactor;
            const saturation = delegationFactor / stakeDelegationFactor;
            return saturation.toString();
        });
        return delegationSaturation;
    }
}
exports.ValidatorMetrics = ValidatorMetrics;
//# sourceMappingURL=validator-metrics.js.map