@exromany/lido-csm-sdk/dist/esm/rewards-sdk/get-validators-rewards.js

[](https://github.com/lidofinance/lido-csm-sdk/blob/main/LICENSE.txt) [](h

import { ERROR_CODE, SDKError } from '@lidofinance/lido-ethereum-sdk';
import { isRewardsReportV1, isRewardsReportV2 } from './parse-report.js';
const DEFAULT_REWARD_SHARE = 1;
const getBaseFields = (report) => ({
    blockNumber: report.blockstamp.block_number,
    refSlot: report.blockstamp.ref_slot,
    frame: report.frame,
});
export const getValidatorsRewardsV1 = (nodeOperatorId, report) => {
    const operator = report.operators[`${nodeOperatorId}`];
    if (!operator)
        return [];
    const threshold = report.threshold;
    const totalDistributed = BigInt(operator.distributed.toString());
    const validators = Object.entries(operator.validators).map(([validatorIndex, { perf, slashed }]) => {
        const performance = perf.assigned > 0 ? perf.included / perf.assigned : 0;
        return {
            validatorIndex: validatorIndex,
            slashed,
            performance,
            isEligible: !slashed && performance >= threshold && performance > 0,
        };
    });
    const eligibleCount = validators.filter((v) => v.isEligible).length;
    const rewardPerValidator = eligibleCount > 0 ? totalDistributed / BigInt(eligibleCount) : 0n;
    return validators.map((v, indexInReport) => ({
        ...getBaseFields(report),
        indexInReport,
        validatorIndex: v.validatorIndex,
        performance: v.performance,
        slashed: v.slashed,
        threshold,
        receivedShares: v.isEligible ? rewardPerValidator : 0n,
        rewardShare: DEFAULT_REWARD_SHARE,
    }));
};
export const getValidatorsRewardsV2 = (nodeOperatorId, report) => {
    const operator = report.operators[`${nodeOperatorId}`];
    if (!operator)
        return [];
    return Object.entries(operator.validators).map(([validatorIndex, validatorData], indexInReport) => ({
        ...getBaseFields(report),
        indexInReport,
        validatorIndex: validatorIndex,
        performance: validatorData.performance,
        threshold: validatorData.threshold,
        slashed: validatorData.slashed,
        receivedShares: validatorData.distributed_rewards,
        rewardShare: validatorData.rewards_share,
    }));
};
export const getValidatorsRewards = (nodeOperatorId, report) => {
    if (isRewardsReportV1(report)) {
        return getValidatorsRewardsV1(nodeOperatorId, report);
    }
    else if (isRewardsReportV2(report)) {
        return getValidatorsRewardsV2(nodeOperatorId, report);
    }
    else {
        throw new SDKError({
            code: ERROR_CODE.NOT_SUPPORTED,
            message: 'Unknown rewards report version',
        });
    }
};
//# sourceMappingURL=get-validators-rewards.js.map