750 lines
36 KiB
TypeScript
750 lines
36 KiB
TypeScript
import {
|
|
blockchainTests,
|
|
constants,
|
|
expect,
|
|
filterLogsToArguments,
|
|
hexRandom,
|
|
Numberish,
|
|
shortZip,
|
|
} from '@0x/contracts-test-utils';
|
|
import { StakingRevertErrors } from '@0x/order-utils';
|
|
import { BigNumber } from '@0x/utils';
|
|
import { LogEntry } from 'ethereum-types';
|
|
import * as _ from 'lodash';
|
|
|
|
import {
|
|
artifacts,
|
|
IStakingEventsEpochEndedEventArgs,
|
|
IStakingEventsEpochFinalizedEventArgs,
|
|
IStakingEventsEvents,
|
|
IStakingEventsRewardsPaidEventArgs,
|
|
TestFinalizerContract,
|
|
TestFinalizerDepositStakingPoolRewardsEventArgs as DepositStakingPoolRewardsEventArgs,
|
|
TestFinalizerEvents,
|
|
TestFinalizerRecordStakingPoolRewardsEventArgs as RecordStakingPoolRewardsEventArgs,
|
|
} from '../../src';
|
|
import {
|
|
assertRoughlyEquals as _assertIntegerRoughlyEquals,
|
|
getRandomInteger,
|
|
toBaseUnitAmount,
|
|
} from '../utils/number_utils';
|
|
|
|
blockchainTests.resets('finalizer unit tests', env => {
|
|
const { ZERO_AMOUNT } = constants;
|
|
const INITIAL_EPOCH = 0;
|
|
const INITIAL_BALANCE = toBaseUnitAmount(32);
|
|
let operatorRewardsReceiver: string;
|
|
let membersRewardsReceiver: string;
|
|
let testContract: TestFinalizerContract;
|
|
|
|
before(async () => {
|
|
operatorRewardsReceiver = hexRandom(constants.ADDRESS_LENGTH);
|
|
membersRewardsReceiver = hexRandom(constants.ADDRESS_LENGTH);
|
|
testContract = await TestFinalizerContract.deployFrom0xArtifactAsync(
|
|
artifacts.TestFinalizer,
|
|
env.provider,
|
|
env.txDefaults,
|
|
artifacts,
|
|
operatorRewardsReceiver,
|
|
membersRewardsReceiver,
|
|
);
|
|
// Give the contract a balance.
|
|
await sendEtherAsync(testContract.address, INITIAL_BALANCE);
|
|
});
|
|
|
|
async function sendEtherAsync(to: string, amount: Numberish): Promise<void> {
|
|
await env.web3Wrapper.awaitTransactionSuccessAsync(
|
|
await env.web3Wrapper.sendTransactionAsync({
|
|
from: (await env.getAccountAddressesAsync())[0],
|
|
to,
|
|
value: new BigNumber(amount),
|
|
}),
|
|
);
|
|
}
|
|
|
|
interface ActivePoolOpts {
|
|
poolId: string;
|
|
operatorShare: number;
|
|
feesCollected: Numberish;
|
|
membersStake: Numberish;
|
|
weightedStake: Numberish;
|
|
}
|
|
|
|
async function addActivePoolAsync(opts?: Partial<ActivePoolOpts>): Promise<ActivePoolOpts> {
|
|
const maxAmount = toBaseUnitAmount(1e9);
|
|
const _opts = {
|
|
poolId: hexRandom(),
|
|
operatorShare: Math.floor(Math.random() * constants.PPM_DENOMINATOR) / constants.PPM_DENOMINATOR,
|
|
feesCollected: getRandomInteger(0, maxAmount),
|
|
membersStake: getRandomInteger(0, maxAmount),
|
|
weightedStake: getRandomInteger(0, maxAmount),
|
|
...opts,
|
|
};
|
|
await testContract.addActivePool.awaitTransactionSuccessAsync(
|
|
_opts.poolId,
|
|
new BigNumber(_opts.operatorShare * constants.PPM_DENOMINATOR).integerValue(),
|
|
new BigNumber(_opts.feesCollected),
|
|
new BigNumber(_opts.membersStake),
|
|
new BigNumber(_opts.weightedStake),
|
|
);
|
|
return _opts;
|
|
}
|
|
|
|
interface FinalizationState {
|
|
balance: Numberish;
|
|
currentEpoch: number;
|
|
closingEpoch: number;
|
|
numActivePoolsThisEpoch: number;
|
|
totalFeesCollectedThisEpoch: Numberish;
|
|
totalWeightedStakeThisEpoch: Numberish;
|
|
unfinalizedPoolsRemaining: number;
|
|
unfinalizedRewardsAvailable: Numberish;
|
|
unfinalizedTotalFeesCollected: Numberish;
|
|
unfinalizedTotalWeightedStake: Numberish;
|
|
}
|
|
|
|
async function getFinalizationStateAsync(): Promise<FinalizationState> {
|
|
const r = await testContract.getFinalizationState.callAsync();
|
|
return {
|
|
balance: r[0],
|
|
currentEpoch: r[1].toNumber(),
|
|
closingEpoch: r[2].toNumber(),
|
|
numActivePoolsThisEpoch: r[3].toNumber(),
|
|
totalFeesCollectedThisEpoch: r[4],
|
|
totalWeightedStakeThisEpoch: r[5],
|
|
unfinalizedPoolsRemaining: r[6].toNumber(),
|
|
unfinalizedRewardsAvailable: r[7],
|
|
unfinalizedTotalFeesCollected: r[8],
|
|
unfinalizedTotalWeightedStake: r[9],
|
|
};
|
|
}
|
|
|
|
async function assertFinalizationStateAsync(expected: Partial<FinalizationState>): Promise<void> {
|
|
const actual = await getFinalizationStateAsync();
|
|
assertEqualNumberFields(actual, expected);
|
|
}
|
|
|
|
function assertEpochEndedEvent(logs: LogEntry[], args: Partial<IStakingEventsEpochEndedEventArgs>): void {
|
|
const events = getEpochEndedEvents(logs);
|
|
expect(events.length).to.eq(1);
|
|
assertEqualNumberFields(events[0], args);
|
|
}
|
|
|
|
function assertEpochFinalizedEvent(logs: LogEntry[], args: Partial<IStakingEventsEpochFinalizedEventArgs>): void {
|
|
const events = getEpochFinalizedEvents(logs);
|
|
expect(events.length).to.eq(1);
|
|
assertEqualNumberFields(events[0], args);
|
|
}
|
|
|
|
function assertRoughlyEquals(actual: Numberish, expected: Numberish): void {
|
|
_assertIntegerRoughlyEquals(actual, expected, 5);
|
|
}
|
|
|
|
function assertEqualNumberFields<T>(actual: T, expected: Partial<T>): void {
|
|
for (const key of Object.keys(actual)) {
|
|
const a = (actual as any)[key] as BigNumber;
|
|
const e = (expected as any)[key] as Numberish;
|
|
if (e !== undefined) {
|
|
expect(a, key).to.bignumber.eq(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
async function assertFinalizationLogsAndBalancesAsync(
|
|
rewardsAvailable: Numberish,
|
|
activePools: ActivePoolOpts[],
|
|
finalizationLogs: LogEntry[],
|
|
): Promise<void> {
|
|
const currentEpoch = await getCurrentEpochAsync();
|
|
// Compute the expected rewards for each pool.
|
|
const poolsWithStake = activePools.filter(p => !new BigNumber(p.weightedStake).isZero());
|
|
const poolRewards = await calculatePoolRewardsAsync(rewardsAvailable, poolsWithStake);
|
|
const totalRewards = BigNumber.sum(...poolRewards);
|
|
const rewardsRemaining = new BigNumber(rewardsAvailable).minus(totalRewards);
|
|
const [totalOperatorRewards, totalMembersRewards] = getTotalSplitRewards(activePools, poolRewards);
|
|
|
|
// Assert the `RewardsPaid` logs.
|
|
const rewardsPaidEvents = getRewardsPaidEvents(finalizationLogs);
|
|
expect(rewardsPaidEvents.length).to.eq(poolsWithStake.length);
|
|
for (const i of _.times(rewardsPaidEvents.length)) {
|
|
const event = rewardsPaidEvents[i];
|
|
const pool = poolsWithStake[i];
|
|
const reward = poolRewards[i];
|
|
const [operatorReward, membersReward] = splitRewards(pool, reward);
|
|
expect(event.epoch).to.bignumber.eq(currentEpoch);
|
|
assertRoughlyEquals(event.operatorReward, operatorReward);
|
|
assertRoughlyEquals(event.membersReward, membersReward);
|
|
}
|
|
|
|
// Assert the `RecordStakingPoolRewards` logs.
|
|
const recordStakingPoolRewardsEvents = getRecordStakingPoolRewardsEvents(finalizationLogs);
|
|
expect(recordStakingPoolRewardsEvents.length).to.eq(poolsWithStake.length);
|
|
for (const i of _.times(recordStakingPoolRewardsEvents.length)) {
|
|
const event = recordStakingPoolRewardsEvents[i];
|
|
const pool = poolsWithStake[i];
|
|
const reward = poolRewards[i];
|
|
expect(event.poolId).to.eq(pool.poolId);
|
|
assertRoughlyEquals(event.totalReward, reward);
|
|
assertRoughlyEquals(event.membersStake, pool.membersStake);
|
|
}
|
|
|
|
// Assert the `DepositStakingPoolRewards` logs.
|
|
// Make sure they all sum up to the totals.
|
|
const depositStakingPoolRewardsEvents = getDepositStakingPoolRewardsEvents(finalizationLogs);
|
|
if (depositStakingPoolRewardsEvents.length > 0) {
|
|
const totalDepositedOperatorRewards = BigNumber.sum(
|
|
...depositStakingPoolRewardsEvents.map(e => e.operatorReward),
|
|
);
|
|
const totalDepositedMembersRewards = BigNumber.sum(
|
|
...depositStakingPoolRewardsEvents.map(e => e.membersReward),
|
|
);
|
|
assertRoughlyEquals(totalDepositedOperatorRewards, totalOperatorRewards);
|
|
assertRoughlyEquals(totalDepositedMembersRewards, totalMembersRewards);
|
|
}
|
|
|
|
// Assert the `EpochFinalized` logs.
|
|
const epochFinalizedEvents = getEpochFinalizedEvents(finalizationLogs);
|
|
expect(epochFinalizedEvents.length).to.eq(1);
|
|
expect(epochFinalizedEvents[0].epoch).to.bignumber.eq(currentEpoch - 1);
|
|
assertRoughlyEquals(epochFinalizedEvents[0].rewardsPaid, totalRewards);
|
|
assertRoughlyEquals(epochFinalizedEvents[0].rewardsRemaining, rewardsRemaining);
|
|
|
|
// Assert the receiver balances.
|
|
await assertReceiverBalancesAsync(totalOperatorRewards, totalMembersRewards);
|
|
}
|
|
|
|
async function assertReceiverBalancesAsync(operatorRewards: Numberish, membersRewards: Numberish): Promise<void> {
|
|
const operatorRewardsBalance = await getBalanceOfAsync(operatorRewardsReceiver);
|
|
assertRoughlyEquals(operatorRewardsBalance, operatorRewards);
|
|
const membersRewardsBalance = await getBalanceOfAsync(membersRewardsReceiver);
|
|
assertRoughlyEquals(membersRewardsBalance, membersRewards);
|
|
}
|
|
|
|
async function calculatePoolRewardsAsync(
|
|
rewardsAvailable: Numberish,
|
|
activePools: ActivePoolOpts[],
|
|
): Promise<BigNumber[]> {
|
|
const totalFees = BigNumber.sum(...activePools.map(p => p.feesCollected));
|
|
const totalStake = BigNumber.sum(...activePools.map(p => p.weightedStake));
|
|
const poolRewards = _.times(activePools.length, () => constants.ZERO_AMOUNT);
|
|
for (const i of _.times(activePools.length)) {
|
|
const pool = activePools[i];
|
|
const feesCollected = new BigNumber(pool.feesCollected);
|
|
if (feesCollected.isZero()) {
|
|
continue;
|
|
}
|
|
poolRewards[i] = await testContract.cobbDouglas.callAsync(
|
|
new BigNumber(rewardsAvailable),
|
|
new BigNumber(feesCollected),
|
|
new BigNumber(totalFees),
|
|
new BigNumber(pool.weightedStake),
|
|
new BigNumber(totalStake),
|
|
);
|
|
}
|
|
return poolRewards;
|
|
}
|
|
|
|
function splitRewards(pool: ActivePoolOpts, totalReward: Numberish): [BigNumber, BigNumber] {
|
|
if (new BigNumber(pool.membersStake).isZero()) {
|
|
return [new BigNumber(totalReward), ZERO_AMOUNT];
|
|
}
|
|
const operatorShare = new BigNumber(totalReward).times(pool.operatorShare).integerValue(BigNumber.ROUND_DOWN);
|
|
const membersShare = new BigNumber(totalReward).minus(operatorShare);
|
|
return [operatorShare, membersShare];
|
|
}
|
|
|
|
// Calculates the split rewards for every pool and returns the operator
|
|
// and member sums.
|
|
function getTotalSplitRewards(pools: ActivePoolOpts[], rewards: Numberish[]): [BigNumber, BigNumber] {
|
|
const _rewards = _.times(pools.length).map(i => splitRewards(pools[i], rewards[i]));
|
|
const totalOperatorRewards = BigNumber.sum(..._rewards.map(([o]) => o));
|
|
const totalMembersRewards = BigNumber.sum(..._rewards.map(([, m]) => m));
|
|
return [totalOperatorRewards, totalMembersRewards];
|
|
}
|
|
|
|
function getEpochEndedEvents(logs: LogEntry[]): IStakingEventsEpochEndedEventArgs[] {
|
|
return filterLogsToArguments<IStakingEventsEpochEndedEventArgs>(logs, IStakingEventsEvents.EpochEnded);
|
|
}
|
|
|
|
function getEpochFinalizedEvents(logs: LogEntry[]): IStakingEventsEpochFinalizedEventArgs[] {
|
|
return filterLogsToArguments<IStakingEventsEpochFinalizedEventArgs>(logs, IStakingEventsEvents.EpochFinalized);
|
|
}
|
|
|
|
function getRecordStakingPoolRewardsEvents(logs: LogEntry[]): RecordStakingPoolRewardsEventArgs[] {
|
|
return filterLogsToArguments<RecordStakingPoolRewardsEventArgs>(
|
|
logs,
|
|
TestFinalizerEvents.RecordStakingPoolRewards,
|
|
);
|
|
}
|
|
|
|
function getDepositStakingPoolRewardsEvents(logs: LogEntry[]): DepositStakingPoolRewardsEventArgs[] {
|
|
return filterLogsToArguments<DepositStakingPoolRewardsEventArgs>(
|
|
logs,
|
|
TestFinalizerEvents.DepositStakingPoolRewards,
|
|
);
|
|
}
|
|
|
|
function getRewardsPaidEvents(logs: LogEntry[]): IStakingEventsRewardsPaidEventArgs[] {
|
|
return filterLogsToArguments<IStakingEventsRewardsPaidEventArgs>(logs, IStakingEventsEvents.RewardsPaid);
|
|
}
|
|
|
|
async function getCurrentEpochAsync(): Promise<number> {
|
|
return (await testContract.currentEpoch.callAsync()).toNumber();
|
|
}
|
|
|
|
async function getBalanceOfAsync(whom: string): Promise<BigNumber> {
|
|
return env.web3Wrapper.getBalanceInWeiAsync(whom);
|
|
}
|
|
|
|
describe('endEpoch()', () => {
|
|
it('advances the epoch', async () => {
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const currentEpoch = await testContract.currentEpoch.callAsync();
|
|
expect(currentEpoch).to.bignumber.eq(INITIAL_EPOCH + 1);
|
|
});
|
|
|
|
it('emits an `EpochEnded` event', async () => {
|
|
const receipt = await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
assertEpochEndedEvent(receipt.logs, {
|
|
epoch: new BigNumber(INITIAL_EPOCH),
|
|
numActivePools: ZERO_AMOUNT,
|
|
rewardsAvailable: INITIAL_BALANCE,
|
|
totalFeesCollected: ZERO_AMOUNT,
|
|
totalWeightedStake: ZERO_AMOUNT,
|
|
});
|
|
});
|
|
|
|
it('immediately finalizes if there are no active pools', async () => {
|
|
const receipt = await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
assertEpochFinalizedEvent(receipt.logs, {
|
|
epoch: new BigNumber(INITIAL_EPOCH),
|
|
rewardsPaid: ZERO_AMOUNT,
|
|
rewardsRemaining: INITIAL_BALANCE,
|
|
});
|
|
});
|
|
|
|
it('does not immediately finalize if there is an active pool', async () => {
|
|
await addActivePoolAsync();
|
|
const receipt = await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const events = filterLogsToArguments<IStakingEventsEpochFinalizedEventArgs>(
|
|
receipt.logs,
|
|
IStakingEventsEvents.EpochFinalized,
|
|
);
|
|
expect(events).to.deep.eq([]);
|
|
});
|
|
|
|
it("clears the next epoch's finalization state", async () => {
|
|
// Add a pool so there is state to clear.
|
|
await addActivePoolAsync();
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
return assertFinalizationStateAsync({
|
|
currentEpoch: INITIAL_EPOCH + 1,
|
|
closingEpoch: INITIAL_EPOCH,
|
|
numActivePoolsThisEpoch: 0,
|
|
totalFeesCollectedThisEpoch: 0,
|
|
totalWeightedStakeThisEpoch: 0,
|
|
});
|
|
});
|
|
|
|
it('prepares finalization state', async () => {
|
|
// Add a pool so there is state to clear.
|
|
const pool = await addActivePoolAsync();
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
return assertFinalizationStateAsync({
|
|
unfinalizedPoolsRemaining: 1,
|
|
unfinalizedRewardsAvailable: INITIAL_BALANCE,
|
|
unfinalizedTotalFeesCollected: pool.feesCollected,
|
|
unfinalizedTotalWeightedStake: pool.weightedStake,
|
|
});
|
|
});
|
|
|
|
it('reverts if the prior epoch is unfinalized', async () => {
|
|
await addActivePoolAsync();
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const tx = testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const expectedError = new StakingRevertErrors.PreviousEpochNotFinalizedError(INITIAL_EPOCH, 1);
|
|
return expect(tx).to.revertWith(expectedError);
|
|
});
|
|
});
|
|
|
|
describe('finalizePools()', () => {
|
|
it('does nothing if there were no active pools', async () => {
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const poolId = hexRandom();
|
|
const receipt = await testContract.finalizePools.awaitTransactionSuccessAsync([poolId]);
|
|
expect(receipt.logs).to.deep.eq([]);
|
|
});
|
|
|
|
it('does nothing if no pools are passed in', async () => {
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const receipt = await testContract.finalizePools.awaitTransactionSuccessAsync([]);
|
|
expect(receipt.logs).to.deep.eq([]);
|
|
});
|
|
|
|
it('can finalize a single pool', async () => {
|
|
const pool = await addActivePoolAsync();
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const receipt = await testContract.finalizePools.awaitTransactionSuccessAsync([pool.poolId]);
|
|
return assertFinalizationLogsAndBalancesAsync(INITIAL_BALANCE, [pool], receipt.logs);
|
|
});
|
|
|
|
it('can finalize multiple pools', async () => {
|
|
const pools = await Promise.all(_.times(3, async () => addActivePoolAsync()));
|
|
const poolIds = pools.map(p => p.poolId);
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const receipt = await testContract.finalizePools.awaitTransactionSuccessAsync(poolIds);
|
|
return assertFinalizationLogsAndBalancesAsync(INITIAL_BALANCE, pools, receipt.logs);
|
|
});
|
|
|
|
it('can finalize multiple pools over multiple transactions', async () => {
|
|
const pools = await Promise.all(_.times(2, async () => addActivePoolAsync()));
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const receipts = await Promise.all(
|
|
pools.map(pool => testContract.finalizePools.awaitTransactionSuccessAsync([pool.poolId])),
|
|
);
|
|
const allLogs = _.flatten(receipts.map(r => r.logs));
|
|
return assertFinalizationLogsAndBalancesAsync(INITIAL_BALANCE, pools, allLogs);
|
|
});
|
|
|
|
it('can finalize with no rewards', async () => {
|
|
await testContract.drainBalance.awaitTransactionSuccessAsync();
|
|
const pools = await Promise.all(_.times(2, async () => addActivePoolAsync()));
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const receipts = await Promise.all(
|
|
pools.map(pool => testContract.finalizePools.awaitTransactionSuccessAsync([pool.poolId])),
|
|
);
|
|
const allLogs = _.flatten(receipts.map(r => r.logs));
|
|
return assertFinalizationLogsAndBalancesAsync(0, pools, allLogs);
|
|
});
|
|
|
|
it('ignores a non-active pool', async () => {
|
|
const pools = await Promise.all(_.times(3, async () => addActivePoolAsync()));
|
|
const nonActivePoolId = hexRandom();
|
|
const poolIds = _.shuffle([...pools.map(p => p.poolId), nonActivePoolId]);
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const receipt = await testContract.finalizePools.awaitTransactionSuccessAsync(poolIds);
|
|
const rewardsPaidEvents = getRewardsPaidEvents(receipt.logs);
|
|
expect(rewardsPaidEvents.length).to.eq(pools.length);
|
|
for (const event of rewardsPaidEvents) {
|
|
expect(event.poolId).to.not.eq(nonActivePoolId);
|
|
}
|
|
});
|
|
|
|
it('ignores a finalized pool', async () => {
|
|
const pools = await Promise.all(_.times(3, async () => addActivePoolAsync()));
|
|
const poolIds = pools.map(p => p.poolId);
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const [finalizedPool] = _.sampleSize(pools, 1);
|
|
await testContract.finalizePools.awaitTransactionSuccessAsync([finalizedPool.poolId]);
|
|
const receipt = await testContract.finalizePools.awaitTransactionSuccessAsync(poolIds);
|
|
const rewardsPaidEvents = getRewardsPaidEvents(receipt.logs);
|
|
expect(rewardsPaidEvents.length).to.eq(pools.length - 1);
|
|
for (const event of rewardsPaidEvents) {
|
|
expect(event.poolId).to.not.eq(finalizedPool.poolId);
|
|
}
|
|
});
|
|
|
|
it('resets pool state after finalizing it', async () => {
|
|
const pools = await Promise.all(_.times(3, async () => addActivePoolAsync()));
|
|
const pool = _.sample(pools) as ActivePoolOpts;
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
await testContract.finalizePools.awaitTransactionSuccessAsync([pool.poolId]);
|
|
const poolState = await testContract.getActivePoolFromEpoch.callAsync(
|
|
new BigNumber(INITIAL_EPOCH),
|
|
pool.poolId,
|
|
);
|
|
expect(poolState.feesCollected).to.bignumber.eq(0);
|
|
expect(poolState.weightedStake).to.bignumber.eq(0);
|
|
expect(poolState.membersStake).to.bignumber.eq(0);
|
|
});
|
|
|
|
it('`rewardsPaid` is the sum of all pool rewards', async () => {
|
|
const pools = await Promise.all(_.times(3, async () => addActivePoolAsync()));
|
|
const poolIds = pools.map(p => p.poolId);
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const receipt = await testContract.finalizePools.awaitTransactionSuccessAsync(poolIds);
|
|
const rewardsPaidEvents = getRewardsPaidEvents(receipt.logs);
|
|
const expectedTotalRewardsPaid = BigNumber.sum(
|
|
...rewardsPaidEvents.map(e => e.membersReward.plus(e.operatorReward)),
|
|
);
|
|
const { rewardsPaid: totalRewardsPaid } = getEpochFinalizedEvents(receipt.logs)[0];
|
|
expect(totalRewardsPaid).to.bignumber.eq(expectedTotalRewardsPaid);
|
|
});
|
|
|
|
it('`rewardsPaid` <= `rewardsAvailable` <= contract balance at the end of the epoch', async () => {
|
|
const pools = await Promise.all(_.times(3, async () => addActivePoolAsync()));
|
|
const poolIds = pools.map(p => p.poolId);
|
|
let receipt = await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const { rewardsAvailable } = getEpochEndedEvents(receipt.logs)[0];
|
|
expect(rewardsAvailable).to.bignumber.lte(INITIAL_BALANCE);
|
|
receipt = await testContract.finalizePools.awaitTransactionSuccessAsync(poolIds);
|
|
const { rewardsPaid } = getEpochFinalizedEvents(receipt.logs)[0];
|
|
expect(rewardsPaid).to.bignumber.lte(rewardsAvailable);
|
|
});
|
|
|
|
it('`rewardsPaid` <= `rewardsAvailable` with two equal pools', async () => {
|
|
const pool1 = await addActivePoolAsync();
|
|
const pool2 = await addActivePoolAsync(_.omit(pool1, 'poolId'));
|
|
const poolIds = [pool1, pool2].map(p => p.poolId);
|
|
let receipt = await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const { rewardsAvailable } = getEpochEndedEvents(receipt.logs)[0];
|
|
receipt = await testContract.finalizePools.awaitTransactionSuccessAsync(poolIds);
|
|
const { rewardsPaid } = getEpochFinalizedEvents(receipt.logs)[0];
|
|
expect(rewardsPaid).to.bignumber.lte(rewardsAvailable);
|
|
});
|
|
|
|
blockchainTests.optional('`rewardsPaid` fuzzing', async () => {
|
|
const numTests = 32;
|
|
for (const i of _.times(numTests)) {
|
|
const numPools = _.random(1, 32);
|
|
it(`${i + 1}/${numTests} \`rewardsPaid\` <= \`rewardsAvailable\` (${numPools} pools)`, async () => {
|
|
const pools = await Promise.all(_.times(numPools, async () => addActivePoolAsync()));
|
|
const poolIds = pools.map(p => p.poolId);
|
|
let receipt = await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const { rewardsAvailable } = getEpochEndedEvents(receipt.logs)[0];
|
|
receipt = await testContract.finalizePools.awaitTransactionSuccessAsync(poolIds);
|
|
const { rewardsPaid } = getEpochFinalizedEvents(receipt.logs)[0];
|
|
expect(rewardsPaid).to.bignumber.lte(rewardsAvailable);
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('_finalizePool()', () => {
|
|
it('does nothing if there were no active pools', async () => {
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const poolId = hexRandom();
|
|
const receipt = await testContract.finalizePool.awaitTransactionSuccessAsync(poolId);
|
|
expect(receipt.logs).to.deep.eq([]);
|
|
});
|
|
|
|
it('can finalize a pool', async () => {
|
|
const pool = await addActivePoolAsync();
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const receipt = await testContract.finalizePool.awaitTransactionSuccessAsync(pool.poolId);
|
|
return assertFinalizationLogsAndBalancesAsync(INITIAL_BALANCE, [pool], receipt.logs);
|
|
});
|
|
|
|
it('can finalize multiple pools over multiple transactions', async () => {
|
|
const pools = await Promise.all(_.times(2, async () => addActivePoolAsync()));
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const receipts = await Promise.all(
|
|
pools.map(pool => testContract.finalizePool.awaitTransactionSuccessAsync(pool.poolId)),
|
|
);
|
|
const allLogs = _.flatten(receipts.map(r => r.logs));
|
|
return assertFinalizationLogsAndBalancesAsync(INITIAL_BALANCE, pools, allLogs);
|
|
});
|
|
|
|
it('ignores a finalized pool', async () => {
|
|
const pools = await Promise.all(_.times(3, async () => addActivePoolAsync()));
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const [finalizedPool] = _.sampleSize(pools, 1);
|
|
await testContract.finalizePool.awaitTransactionSuccessAsync(finalizedPool.poolId);
|
|
const receipt = await testContract.finalizePool.awaitTransactionSuccessAsync(finalizedPool.poolId);
|
|
const rewardsPaidEvents = getRewardsPaidEvents(receipt.logs);
|
|
expect(rewardsPaidEvents).to.deep.eq([]);
|
|
});
|
|
|
|
it('resets pool state after finalizing it', async () => {
|
|
const pools = await Promise.all(_.times(3, async () => addActivePoolAsync()));
|
|
const pool = _.sample(pools) as ActivePoolOpts;
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
await testContract.finalizePool.awaitTransactionSuccessAsync(pool.poolId);
|
|
const poolState = await testContract.getActivePoolFromEpoch.callAsync(
|
|
new BigNumber(INITIAL_EPOCH),
|
|
pool.poolId,
|
|
);
|
|
expect(poolState.feesCollected).to.bignumber.eq(0);
|
|
expect(poolState.weightedStake).to.bignumber.eq(0);
|
|
expect(poolState.membersStake).to.bignumber.eq(0);
|
|
});
|
|
|
|
it('`rewardsPaid` <= `rewardsAvailable` <= contract balance at the end of the epoch', async () => {
|
|
const pools = await Promise.all(_.times(3, async () => addActivePoolAsync()));
|
|
const receipt = await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const { rewardsAvailable } = getEpochEndedEvents(receipt.logs)[0];
|
|
expect(rewardsAvailable).to.bignumber.lte(INITIAL_BALANCE);
|
|
const receipts = await Promise.all(
|
|
pools.map(p => testContract.finalizePool.awaitTransactionSuccessAsync(p.poolId)),
|
|
);
|
|
const allLogs = _.flatten(receipts.map(r => r.logs));
|
|
const { rewardsPaid } = getEpochFinalizedEvents(allLogs)[0];
|
|
expect(rewardsPaid).to.bignumber.lte(rewardsAvailable);
|
|
});
|
|
|
|
it('`rewardsPaid` <= `rewardsAvailable` with two equal pools', async () => {
|
|
const pool1 = await addActivePoolAsync();
|
|
const pool2 = await addActivePoolAsync(_.omit(pool1, 'poolId'));
|
|
const receipt = await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const { rewardsAvailable } = getEpochEndedEvents(receipt.logs)[0];
|
|
const receipts = await Promise.all(
|
|
[pool1, pool2].map(p => testContract.finalizePool.awaitTransactionSuccessAsync(p.poolId)),
|
|
);
|
|
const allLogs = _.flatten(receipts.map(r => r.logs));
|
|
const { rewardsPaid } = getEpochFinalizedEvents(allLogs)[0];
|
|
expect(rewardsPaid).to.bignumber.lte(rewardsAvailable);
|
|
});
|
|
|
|
blockchainTests.optional('`rewardsPaid` fuzzing', async () => {
|
|
const numTests = 32;
|
|
for (const i of _.times(numTests)) {
|
|
const numPools = _.random(1, 32);
|
|
it(`${i + 1}/${numTests} \`rewardsPaid\` <= \`rewardsAvailable\` (${numPools} pools)`, async () => {
|
|
const pools = await Promise.all(_.times(numPools, async () => addActivePoolAsync()));
|
|
const receipt = await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const { rewardsAvailable } = getEpochEndedEvents(receipt.logs)[0];
|
|
const receipts = await Promise.all(
|
|
pools.map(p => testContract.finalizePool.awaitTransactionSuccessAsync(p.poolId)),
|
|
);
|
|
const allLogs = _.flatten(receipts.map(r => r.logs));
|
|
const { rewardsPaid } = getEpochFinalizedEvents(allLogs)[0];
|
|
expect(rewardsPaid).to.bignumber.lte(rewardsAvailable);
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('lifecycle', () => {
|
|
it('can advance the epoch after the prior epoch is finalized', async () => {
|
|
const pool = await addActivePoolAsync();
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
await testContract.finalizePools.awaitTransactionSuccessAsync([pool.poolId]);
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
return expect(getCurrentEpochAsync()).to.become(INITIAL_EPOCH + 2);
|
|
});
|
|
|
|
it('does not reward a pool that was only active 2 epochs ago', async () => {
|
|
const pool1 = await addActivePoolAsync();
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
await testContract.finalizePools.awaitTransactionSuccessAsync([pool1.poolId]);
|
|
await addActivePoolAsync();
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
expect(getCurrentEpochAsync()).to.become(INITIAL_EPOCH + 2);
|
|
const receipt = await testContract.finalizePools.awaitTransactionSuccessAsync([pool1.poolId]);
|
|
const rewardsPaidEvents = getRewardsPaidEvents(receipt.logs);
|
|
expect(rewardsPaidEvents).to.deep.eq([]);
|
|
});
|
|
|
|
it('does not reward a pool that was only active 3 epochs ago', async () => {
|
|
const pool1 = await addActivePoolAsync();
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
await testContract.finalizePools.awaitTransactionSuccessAsync([pool1.poolId]);
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
await addActivePoolAsync();
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
expect(getCurrentEpochAsync()).to.become(INITIAL_EPOCH + 3);
|
|
const receipt = await testContract.finalizePools.awaitTransactionSuccessAsync([pool1.poolId]);
|
|
const rewardsPaidEvents = getRewardsPaidEvents(receipt.logs);
|
|
expect(rewardsPaidEvents).to.deep.eq([]);
|
|
});
|
|
|
|
it('rolls over leftover rewards into th next epoch', async () => {
|
|
const poolIds = _.times(3, () => hexRandom());
|
|
await Promise.all(poolIds.map(async id => addActivePoolAsync({ poolId: id })));
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
let receipt = await testContract.finalizePools.awaitTransactionSuccessAsync(poolIds);
|
|
const { rewardsRemaining: rolledOverRewards } = getEpochFinalizedEvents(receipt.logs)[0];
|
|
await Promise.all(poolIds.map(async id => addActivePoolAsync({ poolId: id })));
|
|
receipt = await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const { rewardsAvailable } = getEpochEndedEvents(receipt.logs)[0];
|
|
expect(rewardsAvailable).to.bignumber.eq(rolledOverRewards);
|
|
});
|
|
});
|
|
|
|
interface FinalizedPoolRewards {
|
|
totalReward: Numberish;
|
|
membersStake: Numberish;
|
|
}
|
|
|
|
async function assertUnfinalizedPoolRewardsAsync(
|
|
poolId: string,
|
|
expected: Partial<FinalizedPoolRewards>,
|
|
): Promise<void> {
|
|
const actual = await testContract.getUnfinalizedPoolRewards.callAsync(poolId);
|
|
if (expected.totalReward !== undefined) {
|
|
expect(actual.totalReward).to.bignumber.eq(expected.totalReward);
|
|
}
|
|
if (expected.membersStake !== undefined) {
|
|
expect(actual.membersStake).to.bignumber.eq(expected.membersStake);
|
|
}
|
|
}
|
|
|
|
describe('_getUnfinalizedPoolReward()', () => {
|
|
const ZERO_REWARDS = {
|
|
totalReward: 0,
|
|
membersStake: 0,
|
|
};
|
|
|
|
it('returns empty if epoch is 0', async () => {
|
|
const poolId = hexRandom();
|
|
return assertUnfinalizedPoolRewardsAsync(poolId, ZERO_REWARDS);
|
|
});
|
|
|
|
it('returns empty if pool was not active', async () => {
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const poolId = hexRandom();
|
|
return assertUnfinalizedPoolRewardsAsync(poolId, ZERO_REWARDS);
|
|
});
|
|
|
|
it('returns empty if pool is active only in the current epoch', async () => {
|
|
const pool = await addActivePoolAsync();
|
|
return assertUnfinalizedPoolRewardsAsync(pool.poolId, ZERO_REWARDS);
|
|
});
|
|
|
|
it('returns empty if pool was only active in the 2 epochs ago', async () => {
|
|
const pool = await addActivePoolAsync();
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
await testContract.finalizePools.awaitTransactionSuccessAsync([pool.poolId]);
|
|
return assertUnfinalizedPoolRewardsAsync(pool.poolId, ZERO_REWARDS);
|
|
});
|
|
|
|
it('returns empty if pool was already finalized', async () => {
|
|
const pools = await Promise.all(_.times(3, async () => addActivePoolAsync()));
|
|
const [pool] = _.sampleSize(pools, 1);
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
await testContract.finalizePools.awaitTransactionSuccessAsync([pool.poolId]);
|
|
return assertUnfinalizedPoolRewardsAsync(pool.poolId, ZERO_REWARDS);
|
|
});
|
|
|
|
it('computes one reward among one pool', async () => {
|
|
const pool = await addActivePoolAsync();
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const expectedTotalRewards = INITIAL_BALANCE;
|
|
return assertUnfinalizedPoolRewardsAsync(pool.poolId, {
|
|
totalReward: expectedTotalRewards,
|
|
membersStake: pool.membersStake,
|
|
});
|
|
});
|
|
|
|
it('computes one reward among multiple pools', async () => {
|
|
const pools = await Promise.all(_.times(3, async () => addActivePoolAsync()));
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
const expectedPoolRewards = await calculatePoolRewardsAsync(INITIAL_BALANCE, pools);
|
|
const [pool, reward] = _.sampleSize(shortZip(pools, expectedPoolRewards), 1)[0];
|
|
return assertUnfinalizedPoolRewardsAsync(pool.poolId, {
|
|
totalReward: (reward as any) as BigNumber,
|
|
membersStake: pool.membersStake,
|
|
});
|
|
});
|
|
|
|
it('computes a reward with 0% operatorShare', async () => {
|
|
const pool = await addActivePoolAsync({ operatorShare: 0 });
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
return assertUnfinalizedPoolRewardsAsync(pool.poolId, {
|
|
totalReward: INITIAL_BALANCE,
|
|
membersStake: pool.membersStake,
|
|
});
|
|
});
|
|
|
|
it('computes a reward with 100% operatorShare', async () => {
|
|
const pool = await addActivePoolAsync({ operatorShare: 1 });
|
|
await testContract.endEpoch.awaitTransactionSuccessAsync();
|
|
return assertUnfinalizedPoolRewardsAsync(pool.poolId, {
|
|
totalReward: INITIAL_BALANCE,
|
|
membersStake: pool.membersStake,
|
|
});
|
|
});
|
|
});
|
|
});
|
|
// tslint:disable: max-file-line-count
|