@broxus/js-core/dist/esm/models/gauge/GaugeUtils.js

MobX-based JavaScript Core library

import { DEFAULT_NATIVE_CURRENCY_DECIMALS } from '../../constants';
import { gaugeContract } from '../../models/gauge/contracts';
import { getFullContractState, resolveTvmAddress, toInt } from '../../utils';
export class GaugeUtils {
    static async setExtraFarmEndTime(connection, address, params, args) {
        return gaugeContract(connection, address)
            .methods.setExtraFarmEndTime({
            farm_end_times: params.farmEndTimes,
            ids: params.ids,
            meta: {
                call_id: params.meta.callId,
                nonce: params.meta.nonce,
                send_gas_to: resolveTvmAddress(params.meta.sendGasTo),
            },
        })
            .sendDelayed({
            amount: toInt(1, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: true,
            from: resolveTvmAddress(params.meta.sendGasTo),
            ...args,
        });
    }
    static async calcSyncData(connection, gaugeAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, gaugeAddress);
        const result = await gaugeContract(connection, gaugeAddress)
            .methods.calcSyncData()
            .call({ cachedState: state });
        return {
            depositSupply: result.value0.depositSupply,
            depositSupplyAverage: result.value0.depositSupplyAverage,
            depositSupplyAveragePeriod: Number(result.value0.depositSupplyAveragePeriod),
            extraRewardRounds: result.value0.extraRewardRounds.map(rounds => rounds.map(round => ({
                ...round,
                endTime: Number(round.endTime),
                startTime: Number(round.startTime),
            }))),
            poolLastRewardTime: Number(result.value0.poolLastRewardTime),
            qubeRewardRounds: result.value0.qubeRewardRounds.map(round => ({
                ...round,
                endTime: Number(round.endTime),
                startTime: Number(round.startTime),
            })),
        };
    }
    static async calculateBoostedAmount(connection, gaugeAddress, params, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, gaugeAddress);
        const result = await gaugeContract(connection, gaugeAddress)
            .methods.calculateBoostedAmount({ amount: params.amount, lock_time: params.lockTime })
            .call({ cachedState: state });
        return result.boosted_amount;
    }
    static async calculateRewardData(connection, gaugeAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, gaugeAddress);
        const result = await gaugeContract(connection, gaugeAddress)
            .methods.calculateRewardData()
            .call({ cachedState: state });
        return {
            extraRewardRounds: result._extraRewardRounds.map(rounds => rounds.map(round => ({
                ...round,
                endTime: Number(round.endTime),
                startTime: Number(round.startTime),
            }))),
            extraSyncIdx: result._extra_sync_idx.map(Number),
            lastRewardTime: Number(result._lastRewardTime),
            qubeRewardRounds: result._qubeRewardRounds.map(round => ({
                ...round,
                endTime: Number(round.endTime),
                startTime: Number(round.startTime),
            })),
            qubeSyncIdx: Number(result._qube_sync_idx),
        };
    }
    static async calculateSupplyAverage(connection, gaugeAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, gaugeAddress);
        const result = await gaugeContract(connection, gaugeAddress)
            .methods.calculateSupplyAverage()
            .call({ cachedState: state });
        return {
            lastAverageUpdateTime: Number(result._lastAverageUpdateTime),
            lockBoostedSupplyAverage: result._lockBoostedSupplyAverage,
            lockBoostedSupplyAveragePeriod: Number(result._lockBoostedSupplyAveragePeriod),
            supplyAverage: result._supplyAverage,
            supplyAveragePeriod: Number(result._supplyAveragePeriod),
        };
    }
    static async getDetails(connection, gaugeAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, gaugeAddress);
        const result = await gaugeContract(connection, gaugeAddress)
            .methods.getDetails()
            .call({ cachedState: state });
        return {
            initialized: result._initialized,
            lastAverageUpdateTime: Number(result._lastAverageUpdateTime),
            lastExtraRewardRoundIdx: result._lastExtraRewardRoundIdx.map(Number),
            lastQubeRewardRoundIdx: Number(result._lastQubeRewardRoundIdx),
            lastRewardTime: Number(result._lastRewardTime),
            lockBoostedSupply: result._lockBoostedSupply,
            maxBoost: Number(result._maxBoost),
            maxLockTime: Number(result._maxLockTime),
            owner: result._owner,
            totalBoostedSupply: result._totalBoostedSupply,
            voteEscrow: result._voteEscrow,
        };
    }
    static async getRewardDetails(connection, gaugeAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, gaugeAddress);
        const result = await gaugeContract(connection, gaugeAddress)
            .methods.getRewardDetails()
            .call({ cachedState: state });
        return {
            extraRewardEnded: result._extraRewardEnded,
            extraRewardRounds: result._extraRewardRounds.map(rounds => rounds.map(round => ({
                ...round,
                endTime: Number(round.endTime),
                startTime: Number(round.startTime),
            }))),
            extraVestingPeriods: result._extraVestingPeriods.map(Number),
            extraVestingRatios: result._extraVestingRatios.map(Number),
            qubeRewardRounds: result._qubeRewardRounds.map(round => ({
                ...round,
                endTime: Number(round.endTime),
                startTime: Number(round.startTime),
            })),
            qubeVestingPeriod: Number(result._qubeVestingPeriod),
            qubeVestingRatio: Number(result._qubeVestingRatio),
            withdrawAllLockPeriod: Number(result._withdrawAllLockPeriod),
        };
    }
    static async getTokenDetails(connection, gaugeAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, gaugeAddress);
        const result = await gaugeContract(connection, gaugeAddress)
            .methods.getTokenDetails()
            .call({ cachedState: state });
        return {
            depositTokenData: result._depositTokenData,
            extraTokenData: result._extraTokenData,
            qubeTokenData: result._qubeTokenData,
        };
    }
    static async getGaugeAccountAddress(connection, gaugeAddress, userAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, gaugeAddress);
        const result = await gaugeContract(connection, gaugeAddress)
            .methods.getGaugeAccountAddress({ answerId: 0, user: resolveTvmAddress(userAddress) })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    static async getVoteEscrowAccountAddress(connection, gaugeAddress, userAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, gaugeAddress);
        const result = await gaugeContract(connection, gaugeAddress)
            .methods.getVoteEscrowAccountAddress({ answerId: 0, user: resolveTvmAddress(userAddress) })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    static async encodeDepositPayload(connection, gaugeAddress, params, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, gaugeAddress);
        const result = await gaugeContract(connection, gaugeAddress)
            .methods.encodeDepositPayload(params)
            .call({ cachedState: state });
        return result.deposit_payload;
    }
    static async encodeRewardDepositPayload(connection, gaugeAddress, params, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, gaugeAddress);
        const result = await gaugeContract(connection, gaugeAddress)
            .methods.encodeRewardDepositPayload(params)
            .call({ cachedState: state });
        return result.reward_deposit_payload;
    }
    static async decodeRewardDepositPayload(connection, gaugeAddress, params, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, gaugeAddress);
        const result = await gaugeContract(connection, gaugeAddress)
            .methods.decodeRewardDepositPayload(params)
            .call({ cachedState: state });
        return {
            callId: result.call_id,
            correct: result.correct,
            nonce: result.nonce,
        };
    }
    static async decodeDepositPayload(connection, gaugeAddress, params, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, gaugeAddress);
        const result = await gaugeContract(connection, gaugeAddress)
            .methods.decodeDepositPayload(params)
            .call({ cachedState: state });
        return {
            callId: result.call_id,
            claim: result.claim,
            correct: result.correct,
            depositOwner: result.deposit_owner,
            lockTime: Number(result.lock_time),
            nonce: result.nonce,
        };
    }
}