diff --git a/contracts/DrawCalculator.sol b/contracts/DrawCalculator.sol index 9d802b0d..91ac2c71 100644 --- a/contracts/DrawCalculator.sol +++ b/contracts/DrawCalculator.sol @@ -33,8 +33,8 @@ contract DrawCalculator is IDrawCalculator, Ownable { /// @notice The stored history of draw settings. Stored as ring buffer. IPrizeDistributionHistory public immutable prizeDistributionHistory; - /// @notice The distributions array length - uint8 public constant DISTRIBUTIONS_LENGTH = 16; + /// @notice The tiers array length + uint8 public constant TIERS_LENGTH = 16; /* ============ Constructor ============ */ @@ -124,7 +124,7 @@ contract DrawCalculator is IDrawCalculator, Ownable { } /// @inheritdoc IDrawCalculator - function checkPrizeDistributionIndicesForDrawId( + function checkPrizeTierIndexForDrawId( address _user, uint64[] calldata _pickIndices, uint32 _drawId @@ -159,16 +159,15 @@ contract DrawCalculator is IDrawCalculator, Ownable { require(_pickIndices[i] < totalUserPicks, "DrawCalc/insufficient-user-picks"); - uint256 distributionIndex = _calculateDistributionIndex( + uint256 tierIndex = _calculateTierIndex( randomNumberThisPick, _draws[0].winningRandomNumber, masks ); pickPrizes[i] = PickPrize({ - won: distributionIndex < _prizeDistributions[0].distributions.length && - _prizeDistributions[0].distributions[distributionIndex] > 0, - distributionIndex: uint8(distributionIndex) + won: tierIndex < _prizeDistributions[0].tiers.length && _prizeDistributions[0].tiers[tierIndex] > 0, + tierIndex: uint8(tierIndex) }); } @@ -217,7 +216,7 @@ contract DrawCalculator is IDrawCalculator, Ownable { /** * @notice Calculates the number of picks a user gets for a Draw, considering the normalized user balance and the PrizeDistribution. * @dev Divided by 1e18 since the normalized user balance is stored as a fixed point 18 number - * @param _prizeDistribution The prize distribution to consider + * @param _prizeDistribution The PrizeDistribution to consider * @param _normalizedUserBalance The normalized user balances to consider * @return The number of picks a user gets for a Draw */ @@ -232,7 +231,7 @@ contract DrawCalculator is IDrawCalculator, Ownable { * @notice Calculates the normalized balance of a user against the total supply for timestamps * @param _user The user to consider * @param _draws The draws we are looking at - * @param _prizeDistributions The prize distributions to consider (needed for draw timestamp offsets) + * @param _prizeDistributions The prize tiers to consider (needed for draw timestamp offsets) * @return An array of normalized balances */ function _getNormalizedBalancesAt( @@ -294,13 +293,13 @@ contract DrawCalculator is IDrawCalculator, Ownable { DrawLib.PrizeDistribution memory _prizeDistribution ) internal pure returns (uint256) { // prizeCounts stores the number of wins at a distribution index - uint256[] memory prizeCounts = new uint256[](DISTRIBUTIONS_LENGTH); + uint256[] memory prizeCounts = new uint256[](_prizeDistribution.tiers.length); // create bitmasks for the PrizeDistribution uint256[] memory masks = _createBitMasks(_prizeDistribution); uint32 picksLength = uint32(_picks.length); - uint8 maxWinningDistributionIndex = 0; + uint8 maxWinningTierIndex = 0; require( picksLength <= _prizeDistribution.maxPicksPerUser, @@ -320,52 +319,51 @@ contract DrawCalculator is IDrawCalculator, Ownable { keccak256(abi.encode(_userRandomNumber, _picks[index])) ); - uint8 distributionIndex = _calculateDistributionIndex( + uint8 tiersIndex = _calculateTierIndex( randomNumberThisPick, _winningRandomNumber, masks ); - // if there is a prize for this distribution index, - // update the maxWinningDistributionIndex and increment prizeCounts for that distribution index - if (distributionIndex < DISTRIBUTIONS_LENGTH) { - if (distributionIndex > maxWinningDistributionIndex) { - maxWinningDistributionIndex = distributionIndex; + // there is prize for this tier index + if (tiersIndex < TIERS_LENGTH) { + if (tiersIndex > maxWinningTierIndex) { + maxWinningTierIndex = tiersIndex; } - prizeCounts[distributionIndex]++; + prizeCounts[tiersIndex]++; } } // now calculate prizeFraction given prizeCounts uint256 prizeFraction = 0; - uint256[] memory prizeDistributionFractions = _calculatePrizeDistributionFractions( + uint256[] memory prizeTiersFractions = _calculatePrizeTierFractions( _prizeDistribution, - maxWinningDistributionIndex + maxWinningTierIndex ); // multiple the fractions by the prizeCounts and add them up for ( uint256 prizeCountIndex = 0; - prizeCountIndex <= maxWinningDistributionIndex; + prizeCountIndex <= maxWinningTierIndex; prizeCountIndex++ ) { if (prizeCounts[prizeCountIndex] > 0) { prizeFraction += - prizeDistributionFractions[prizeCountIndex] * + prizeTiersFractions[prizeCountIndex] * prizeCounts[prizeCountIndex]; } } - // return the absolute amount of prize - return (prizeFraction * _prizeDistribution.prize) / 1e9; // div by 1e9 as prize distributions are fixed point 1e9 + // return the absolute amount of prize awardable + return (prizeFraction * _prizeDistribution.prize) / 1e9; // div by 1e9 as prize tiers are base 1e9 } - ///@notice Calculates the distribution index given the random numbers and masks - ///@param _randomNumberThisPick Users random number for this Pick - ///@param _winningRandomNumber The winning number for this Draw - ///@param _masks The pre-calculated bitmasks for the PrizeDistribution - ///@return The position within the prize distribution array (0 = top prize, 1 = runner-up prize, etc) - function _calculateDistributionIndex( + ///@notice Calculates the tier index given the random numbers and masks + ///@param _randomNumberThisPick users random number for this Pick + ///@param _winningRandomNumber The winning number for this draw + ///@param _masks The pre-calculate bitmasks for the prizeDistributions + ///@return The position within the prize tier array (0 = top prize, 1 = runner-up prize, etc) + function _calculateTierIndex( uint256 _randomNumberThisPick, uint256 _winningRandomNumber, uint256[] memory _masks @@ -415,42 +413,41 @@ contract DrawCalculator is IDrawCalculator, Ownable { /** * @notice Calculates the expected prize fraction per PrizeDistributions and distributionIndex * @param _prizeDistribution prizeDistribution struct for Draw - * @param _distributionIndex Index of the prize distributions array to calculate - * @return returns the fraction of the total prize (fixed point 1e9) + * @param _prizeTierIndex Index of the prize tiers array to calculate + * @return returns the fraction of the total prize (base 1e18) */ - function _calculatePrizeDistributionFraction( + function _calculatePrizeTierFraction( DrawLib.PrizeDistribution memory _prizeDistribution, - uint256 _distributionIndex + uint256 _prizeTierIndex ) internal pure returns (uint256) { - - // get the distribution at that index - uint256 prizeFraction = _prizeDistribution.distributions[_distributionIndex]; + // get the prize fraction at that index + uint256 prizeFraction = _prizeDistribution.tiers[_prizeTierIndex]; // calculate number of prizes for that index uint256 numberOfPrizesForIndex = _numberOfPrizesForIndex( _prizeDistribution.bitRangeSize, - _distributionIndex + _prizeTierIndex ); return prizeFraction / numberOfPrizesForIndex; } /** - * @notice Generates an array of prize distributions fractions - * @param _prizeDistribution PrizeDistribution struct for Draw - * @param _maxWinningDistributionIndex Max length of the prize distributions array - * @return returns an array of prize distributions fractions + * @notice Generates an array of prize tiers fractions + * @param _prizeDistribution prizeDistribution struct for Draw + * @param maxWinningTierIndex Max length of the prize tiers array + * @return returns an array of prize tiers fractions */ - function _calculatePrizeDistributionFractions( + function _calculatePrizeTierFractions( DrawLib.PrizeDistribution memory _prizeDistribution, - uint8 _maxWinningDistributionIndex + uint8 maxWinningTierIndex ) internal pure returns (uint256[] memory) { uint256[] memory prizeDistributionFractions = new uint256[]( - _maxWinningDistributionIndex + 1 + maxWinningTierIndex + 1 ); - for (uint8 i = 0; i <= _maxWinningDistributionIndex; i++) { - prizeDistributionFractions[i] = _calculatePrizeDistributionFraction( + for (uint8 i = 0; i <= maxWinningTierIndex; i++) { + prizeDistributionFractions[i] = _calculatePrizeTierFraction( _prizeDistribution, i ); @@ -460,22 +457,22 @@ contract DrawCalculator is IDrawCalculator, Ownable { } /** - * @notice Calculates the number of prizes at a distributionIndex - * @param _bitRangeSize bitRangeSize for Draw - * @param _distributionIndex Index of the prize distribution - * @return Returns the number of prizes at a distributionIndex + * @notice Calculates the number of prizes for a given prizeDistributionIndex + * @param _bitRangeSize Bit range size for Draw + * @param _prizeTierIndex Index of the prize tier array to calculate + * @return returns the fraction of the total prize (base 1e18) */ - function _numberOfPrizesForIndex(uint8 _bitRangeSize, uint256 _distributionIndex) + function _numberOfPrizesForIndex(uint8 _bitRangeSize, uint256 _prizeTierIndex) internal pure returns (uint256) { uint256 bitRangeDecimal = 2**uint256(_bitRangeSize); - uint256 numberOfPrizesForIndex = bitRangeDecimal**_distributionIndex; + uint256 numberOfPrizesForIndex = bitRangeDecimal**_prizeTierIndex; - while (_distributionIndex > 0) { - numberOfPrizesForIndex -= bitRangeDecimal**(_distributionIndex - 1); - _distributionIndex--; + while (_prizeTierIndex > 0) { + numberOfPrizesForIndex -= bitRangeDecimal**(_prizeTierIndex - 1); + _prizeTierIndex--; } return numberOfPrizesForIndex; diff --git a/contracts/PrizeDistributionHistory.sol b/contracts/PrizeDistributionHistory.sol index abd9472c..0c5ef7cf 100644 --- a/contracts/PrizeDistributionHistory.sol +++ b/contracts/PrizeDistributionHistory.sol @@ -20,7 +20,7 @@ contract PrizeDistributionHistory is IPrizeDistributionHistory, Manageable { uint256 internal constant MAX_CARDINALITY = 256; - uint256 internal constant DISTRIBUTION_CEILING = 1e9; + uint256 internal constant TIERS_CEILING = 1e9; event Deployed(uint8 cardinality); @@ -189,25 +189,25 @@ contract PrizeDistributionHistory is IPrizeDistributionHistory, Manageable { require(_prizeDistribution.bitRangeSize > 0, "DrawCalc/bitRangeSize-gt-0"); require(_prizeDistribution.maxPicksPerUser > 0, "DrawCalc/maxPicksPerUser-gt-0"); - // ensure that the sum of the distributions are not gt 100% and record number of non-zero distributions entries - uint256 sumTotalDistributions = 0; - uint256 nonZeroDistributions = 0; - uint256 distributionsLength = _prizeDistribution.distributions.length; + // ensure that the sum of the tiers are not gt 100% and record number of non-zero tiers entries + uint256 sumTotalTiers = 0; + uint256 nonZeroTiers = 0; + uint256 tiersLength = _prizeDistribution.tiers.length; - for (uint256 index = 0; index < distributionsLength; index++) { - sumTotalDistributions += _prizeDistribution.distributions[index]; + for (uint256 index = 0; index < tiersLength; index++) { + sumTotalTiers += _prizeDistribution.tiers[index]; - if (_prizeDistribution.distributions[index] > 0) { - nonZeroDistributions++; + if (_prizeDistribution.tiers[index] > 0) { + nonZeroTiers++; } } - // Each distribution amount stored as uint32 - summed can't exceed 1e9 - require(sumTotalDistributions <= DISTRIBUTION_CEILING, "DrawCalc/distributions-gt-100%"); + // Each tier amount stored as uint32 - summed can't exceed 1e9 + require(sumTotalTiers <= TIERS_CEILING, "DrawCalc/tiers-gt-100%"); require( - _prizeDistribution.matchCardinality >= nonZeroDistributions, - "DrawCalc/matchCardinality-gte-distributions" + _prizeDistribution.matchCardinality >= nonZeroTiers, + "DrawCalc/matchCardinality-gte-tiers" ); DrawRingBufferLib.Buffer memory buffer = _prizeDistributionsRingBufferData; diff --git a/contracts/interfaces/IDrawCalculator.sol b/contracts/interfaces/IDrawCalculator.sol index 90b9338c..6ae523fe 100644 --- a/contracts/interfaces/IDrawCalculator.sol +++ b/contracts/interfaces/IDrawCalculator.sol @@ -16,7 +16,7 @@ import "../libraries/DrawLib.sol"; interface IDrawCalculator { struct PickPrize { bool won; - uint8 distributionIndex; + uint8 tierIndex; } ///@notice Emitted when the contract is initialized @@ -65,12 +65,12 @@ interface IDrawCalculator { /** * @notice Returns a users balances expressed as a fraction of the total supply over time. - * @param _user The user for which to calculate the distribution indices + * @param _user The user for which to calculate the tiers indices * @param _pickIndices The users pick indices for a draw - * @param _drawId The draw for which to calculate the distribution indices - * @return List of distributions for Draw.drawId + * @param _drawId The draw for which to calculate the tiers indices + * @return List of PrizePicks for Draw.drawId */ - function checkPrizeDistributionIndicesForDrawId( + function checkPrizeTierIndexForDrawId( address _user, uint64[] calldata _pickIndices, uint32 _drawId diff --git a/contracts/libraries/DrawLib.sol b/contracts/libraries/DrawLib.sol index e90b66ef..5373be0e 100644 --- a/contracts/libraries/DrawLib.sol +++ b/contracts/libraries/DrawLib.sol @@ -17,8 +17,8 @@ library DrawLib { uint32 beaconPeriodSeconds; } - /// @notice Fixed length of distributions within a PrizeDistribution.distributions - uint8 public constant DISTRIBUTIONS_LENGTH = 16; + /// @notice Fixed length of prize tiers within a PrizeDistribution.tiers + uint8 public constant TIERS_LENGTH = 16; ///@notice PrizeDistribution struct created every draw ///@param bitRangeSize Decimal representation of bitRangeSize @@ -27,7 +27,7 @@ library DrawLib { ///@param endTimestampOffset The end time offset in seconds from which Ticket balances are calculated. ///@param maxPicksPerUser Maximum number of picks a user can make in this draw ///@param numberOfPicks Number of picks this draw has (may vary across networks according to how much the network has contributed to the Reserve) - ///@param distributions Array of prize distributions percentages, expressed in fraction form with base 1e9. Ordering: index0: grandPrize, index1: runnerUp, etc. + ///@param tiers Array of prize tiers percentages, expressed in fraction form with base 1e9. Ordering: index0: grandPrize, index1: runnerUp, etc. ///@param prize Total prize amount available in this draw calculator for this draw (may vary from across networks) struct PrizeDistribution { uint8 bitRangeSize; @@ -36,7 +36,7 @@ library DrawLib { uint32 endTimestampOffset; uint32 maxPicksPerUser; uint136 numberOfPicks; - uint32[DISTRIBUTIONS_LENGTH] distributions; + uint32[TIERS_LENGTH] tiers; uint256 prize; } } diff --git a/contracts/test/DrawCalculatorHarness.sol b/contracts/test/DrawCalculatorHarness.sol index 0d95cd18..d5c43021 100644 --- a/contracts/test/DrawCalculatorHarness.sol +++ b/contracts/test/DrawCalculatorHarness.sol @@ -13,12 +13,12 @@ contract DrawCalculatorHarness is DrawCalculator { PrizeDistributionHistory _prizeDistributionHistory ) DrawCalculator(_owner, _ticket, _drawHistory, _prizeDistributionHistory) {} - function calculateDistributionIndex( + function calculateTierIndex( uint256 _randomNumberThisPick, uint256 _winningRandomNumber, uint256[] memory _masks ) public pure returns (uint256) { - return _calculateDistributionIndex(_randomNumberThisPick, _winningRandomNumber, _masks); + return _calculateTierIndex(_randomNumberThisPick, _winningRandomNumber, _masks); } function createBitMasks(DrawLib.PrizeDistribution calldata _prizeDistribution) @@ -29,23 +29,23 @@ contract DrawCalculatorHarness is DrawCalculator { return _createBitMasks(_prizeDistribution); } - ///@notice Calculates the expected prize fraction per prizeDistribution and prizeDistributionIndex + ///@notice Calculates the expected prize fraction per prizeDistribution and prizeTierIndex ///@param _prizeDistribution prizeDistribution struct for Draw - ///@param _prizeDistributionIndex Index of the prize distributions array to calculate + ///@param _prizeTierIndex Index of the prize tiers array to calculate ///@return returns the fraction of the total prize - function calculatePrizeDistributionFraction( + function calculatePrizeTierFraction( DrawLib.PrizeDistribution calldata _prizeDistribution, - uint256 _prizeDistributionIndex + uint256 _prizeTierIndex ) external pure returns (uint256) { - return _calculatePrizeDistributionFraction(_prizeDistribution, _prizeDistributionIndex); + return _calculatePrizeTierFraction(_prizeDistribution, _prizeTierIndex); } - function numberOfPrizesForIndex(uint8 _bitRangeSize, uint256 _prizeDistributionIndex) + function numberOfPrizesForIndex(uint8 _bitRangeSize, uint256 _prizeTierIndex) external pure returns (uint256) { - return _numberOfPrizesForIndex(_bitRangeSize, _prizeDistributionIndex); + return _numberOfPrizesForIndex(_bitRangeSize, _prizeTierIndex); } function calculateNumberOfUserPicks( diff --git a/hardhat/prizeDistributions.js b/hardhat/prizeDistributions.js index 5177c804..851f2abb 100644 --- a/hardhat/prizeDistributions.js +++ b/hardhat/prizeDistributions.js @@ -1,10 +1,10 @@ const { utils } = require('ethers'); -const distributions = [ +const tiers = [ utils.parseEther('0.9'), utils.parseEther('0.1'), utils.parseEther('0.1'), utils.parseEther('0.1'), ]; -module.exports = distributions; +module.exports = tiers; diff --git a/hardhat/tsunami-tasks.js b/hardhat/tsunami-tasks.js index 5ce46652..2a54351b 100644 --- a/hardhat/tsunami-tasks.js +++ b/hardhat/tsunami-tasks.js @@ -1,5 +1,5 @@ const { BigNumber, constants } = require('ethers'); -const distributions = require('./prizeDistributions'); +const tiers = require('./prizeDistributions'); task('deposit-to') .addPositionalParam('address', 'PrizePool address') @@ -48,7 +48,7 @@ task('set-draw-settings') matchCardinality: BigNumber.from(matchCardinality), numberOfPicks: BigNumber.from(utils.parseEther(`${numberOfPicks}`)), prize: ethers.utils.parseEther(`${prize}`), - distributions: distributions, + tiers: tiers, }); console.log(`Draw Setings updated: ${address}`); }); diff --git a/test/DrawCalculator.test.ts b/test/DrawCalculator.test.ts index 21cbdf6f..d920f1cc 100644 --- a/test/DrawCalculator.test.ts +++ b/test/DrawCalculator.test.ts @@ -2,8 +2,8 @@ import { expect } from 'chai'; import { deployMockContract, MockContract } from 'ethereum-waffle'; import { utils, Contract, BigNumber } from 'ethers'; import { ethers, artifacts } from 'hardhat'; -import { Draw, PrizeDistributionSettings } from './types'; -import { fillPrizeDistributionsWithZeros } from './helpers/fillPrizeDistributionsWithZeros'; +import { Draw, PrizeDistribution } from './types'; +import { fillPrizeTiersWithZeros } from './helpers/fillPrizeTiersWithZeros'; const { getSigners } = ethers; @@ -39,22 +39,22 @@ export async function deployDrawCalculator( function calculateNumberOfWinnersAtIndex( bitRangeSize: number, - distributionIndex: number, + tierIndex: number, ): BigNumber { // Prize Count = (2**bitRange)**(cardinality-numberOfMatches) // if not grand prize: - (2^bitRange)**(cardinality-numberOfMatches-1) - ... (2^bitRange)**(0) - let prizeCount = BigNumber.from(2).pow(bitRangeSize).pow(distributionIndex); + let prizeCount = BigNumber.from(2).pow(bitRangeSize).pow(tierIndex); - if (distributionIndex > 0) { - while (distributionIndex > 0) { + if (tierIndex > 0) { + while (tierIndex > 0) { prizeCount = prizeCount.sub( BigNumber.from( BigNumber.from(2) .pow(BigNumber.from(bitRangeSize)) - .pow(distributionIndex - 1), + .pow(tierIndex - 1), ), ); - distributionIndex--; + tierIndex--; } } @@ -151,13 +151,13 @@ describe('DrawCalculator', () => { }); }); - describe('calculateDistributionIndex()', () => { - let prizeDistribution: PrizeDistributionSettings; + describe('calculateTierIndex()', () => { + let prizeDistribution: PrizeDistribution; beforeEach(async () => { prizeDistribution = { matchCardinality: BigNumber.from(5), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.6', 9), ethers.utils.parseUnits('0.1', 9), ethers.utils.parseUnits('0.1', 9), @@ -171,24 +171,24 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); await prizeDistributionHistory.mock.getPrizeDistributions.returns([prizeDistribution]); }); it('grand prize gets the full fraction at index 0', async () => { - const amount = await drawCalculator.calculatePrizeDistributionFraction( + const amount = await drawCalculator.calculatePrizeTierFraction( prizeDistribution, BigNumber.from(0), ); - expect(amount).to.equal(prizeDistribution.distributions[0]); + expect(amount).to.equal(prizeDistribution.tiers[0]); }); it('runner up gets part of the fraction at index 1', async () => { - const amount = await drawCalculator.calculatePrizeDistributionFraction( + const amount = await drawCalculator.calculatePrizeTierFraction( prizeDistribution, BigNumber.from(1), ); @@ -198,33 +198,33 @@ describe('DrawCalculator', () => { 1, ); - const expectedPrizeFraction = prizeDistribution.distributions[1].div(prizeCount); + const expectedPrizeFraction = prizeDistribution.tiers[1].div(prizeCount); expect(amount).to.equal(expectedPrizeFraction); }); - it('all distribution indexes', async () => { + it('all prize tier indexes', async () => { for ( let numberOfMatches = 0; - numberOfMatches < prizeDistribution.distributions.length; + numberOfMatches < prizeDistribution.tiers.length; numberOfMatches++ ) { - const distributionIndex = BigNumber.from( - prizeDistribution.distributions.length - numberOfMatches - 1, + const tierIndex = BigNumber.from( + prizeDistribution.tiers.length - numberOfMatches - 1, ); // minus one because we start at 0 - const fraction = await drawCalculator.calculatePrizeDistributionFraction( + const fraction = await drawCalculator.calculatePrizeTierFraction( prizeDistribution, - distributionIndex, + tierIndex, ); let prizeCount: BigNumber = calculateNumberOfWinnersAtIndex( prizeDistribution.bitRangeSize.toNumber(), - distributionIndex.toNumber(), + tierIndex.toNumber(), ); const expectedPrizeFraction = - prizeDistribution.distributions[distributionIndex.toNumber()].div(prizeCount); + prizeDistribution.tiers[tierIndex.toNumber()].div(prizeCount); expect(fraction).to.equal(expectedPrizeFraction); } @@ -232,7 +232,7 @@ describe('DrawCalculator', () => { }); describe('numberOfPrizesForIndex()', () => { - it('calculates the number of prizes at distribution index 0', async () => { + it('calculates the number of prizes at tiers index 0', async () => { const bitRangeSize = 2; const result = await drawCalculator.numberOfPrizesForIndex( @@ -243,7 +243,7 @@ describe('DrawCalculator', () => { expect(result).to.equal(1); // grand prize }); - it('calculates the number of prizes at distribution index 1', async () => { + it('calculates the number of prizes at tiers index 1', async () => { const bitRangeSize = 3; const result = await drawCalculator.numberOfPrizesForIndex( @@ -255,10 +255,10 @@ describe('DrawCalculator', () => { expect(result).to.equal(7); }); - it('calculates the number of prizes at distribution index 3', async () => { + it('calculates the number of prizes at tiers index 3', async () => { const bitRangeSize = 3; - // numberOfPrizesForIndex(uint8 _bitRangeSize, uint256 _prizeDistributionIndex) - // prizeDistributionIndex = matchCardinality - numberOfMatches + // numberOfPrizesForIndex(uint8 _bitRangeSize, uint256 _prizetierIndex) + // prizetierIndex = matchCardinality - numberOfMatches // matchCardinality = 5, numberOfMatches = 2 const result = await drawCalculator.numberOfPrizesForIndex( @@ -270,10 +270,10 @@ describe('DrawCalculator', () => { expect(result).to.equal(439); }); - it('calculates the number of prizes at all distribution indices', async () => { - let prizeDistribution: PrizeDistributionSettings = { + it('calculates the number of prizes at all tiers indices', async () => { + let prizeDistribution: PrizeDistribution = { matchCardinality: BigNumber.from(5), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.5', 9), ethers.utils.parseUnits('0.1', 9), ethers.utils.parseUnits('0.1', 9), @@ -288,18 +288,18 @@ describe('DrawCalculator', () => { }; for ( - let distributionIndex = 0; - distributionIndex < prizeDistribution.distributions.length; - distributionIndex++ + let tierIndex = 0; + tierIndex < prizeDistribution.tiers.length; + tierIndex++ ) { const result = await drawCalculator.numberOfPrizesForIndex( prizeDistribution.bitRangeSize, - distributionIndex, + tierIndex, ); const expectedNumberOfWinners = calculateNumberOfWinnersAtIndex( prizeDistribution.bitRangeSize.toNumber(), - distributionIndex, + tierIndex, ); expect(result).to.equal(expectedNumberOfWinners); @@ -307,11 +307,11 @@ describe('DrawCalculator', () => { }); }); - describe('calculatePrizeDistributionFraction()', () => { - it('calculates distribution index 0', async () => { - const prizeDistribution: PrizeDistributionSettings = { + describe('calculatePrizeTiersFraction()', () => { + it('calculates tiers index 0', async () => { + const prizeDistribution: PrizeDistribution = { matchCardinality: BigNumber.from(5), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.6', 9), ethers.utils.parseUnits('0.1', 9), ethers.utils.parseUnits('0.1', 9), @@ -325,8 +325,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); const bitMasks = await drawCalculator.createBitMasks(prizeDistribution); @@ -337,21 +337,21 @@ describe('DrawCalculator', () => { const userRandomNumber = '0x369ddb959b07c1d22a9bada1f3420961d0e0252f73c0f5b2173d7f7c6fe12b70'; // intentionally same as winning random number - const prizeDistributionIndex: BigNumber = - await drawCalculator.calculateDistributionIndex( + const prizetierIndex: BigNumber = + await drawCalculator.calculateTierIndex( userRandomNumber, winningRandomNumber, bitMasks, ); // all numbers match so grand prize! - expect(prizeDistributionIndex).to.eq(BigNumber.from(0)); + expect(prizetierIndex).to.eq(BigNumber.from(0)); }); - it('calculates distribution index 1', async () => { - const prizeDistribution: PrizeDistributionSettings = { + it('calculates tiers index 1', async () => { + const prizeDistribution: PrizeDistribution = { matchCardinality: BigNumber.from(2), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.6', 9), ethers.utils.parseUnits('0.1', 9), ethers.utils.parseUnits('0.1', 9), @@ -365,8 +365,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); // 252: 1111 1100 @@ -377,17 +377,17 @@ describe('DrawCalculator', () => { expect(bitMasks.length).to.eq(2); // same as length of matchCardinality expect(bitMasks[0]).to.eq(BigNumber.from(15)); - const prizeDistributionIndex: BigNumber = - await drawCalculator.calculateDistributionIndex(252, 255, bitMasks); + const prizetierIndex: BigNumber = + await drawCalculator.calculateTierIndex(252, 255, bitMasks); - // since the first 4 bits do not match the distribution index will be: (matchCardinality - numberOfMatches )= 2-0 = 2 - expect(prizeDistributionIndex).to.eq(prizeDistribution.matchCardinality); + // since the first 4 bits do not match the tiers index will be: (matchCardinality - numberOfMatches )= 2-0 = 2 + expect(prizetierIndex).to.eq(prizeDistribution.matchCardinality); }); - it('calculates distribution index 1', async () => { - const prizeDistribution: PrizeDistributionSettings = { + it('calculates tiers index 1', async () => { + const prizeDistribution: PrizeDistribution = { matchCardinality: BigNumber.from(3), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.6', 9), ethers.utils.parseUnits('0.1', 9), ethers.utils.parseUnits('0.1', 9), @@ -401,8 +401,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); // 527: 0010 0000 1111 @@ -413,19 +413,19 @@ describe('DrawCalculator', () => { expect(bitMasks.length).to.eq(3); // same as length of matchCardinality expect(bitMasks[0]).to.eq(BigNumber.from(15)); - const prizeDistributionIndex: BigNumber = - await drawCalculator.calculateDistributionIndex(527, 271, bitMasks); + const prizetierIndex: BigNumber = + await drawCalculator.calculateTierIndex(527, 271, bitMasks); - // since the first 4 bits do not match the distribution index will be: (matchCardinality - numberOfMatches )= 3-2 = 1 - expect(prizeDistributionIndex).to.eq(BigNumber.from(1)); + // since the first 4 bits do not match the tiers index will be: (matchCardinality - numberOfMatches )= 3-2 = 1 + expect(prizetierIndex).to.eq(BigNumber.from(1)); }); }); describe('createBitMasks()', () => { it('creates correct 6 bit masks', async () => { - const prizeDistribution: PrizeDistributionSettings = { + const prizeDistribution: PrizeDistribution = { matchCardinality: BigNumber.from(2), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.6', 9), ethers.utils.parseUnits('0.1', 9), ethers.utils.parseUnits('0.1', 9), @@ -439,8 +439,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); const bitMasks = await drawCalculator.createBitMasks(prizeDistribution); @@ -450,9 +450,9 @@ describe('DrawCalculator', () => { }); it('creates correct 4 bit masks', async () => { - const prizeDistribution: PrizeDistributionSettings = { + const prizeDistribution: PrizeDistribution = { matchCardinality: BigNumber.from(2), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.6', 9), ethers.utils.parseUnits('0.1', 9), ethers.utils.parseUnits('0.1', 9), @@ -466,8 +466,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); const bitMasks = await drawCalculator.createBitMasks(prizeDistribution); @@ -479,9 +479,9 @@ describe('DrawCalculator', () => { describe('calculateNumberOfUserPicks()', () => { it('calculates the correct number of user picks', async () => { - const prizeDistribution: PrizeDistributionSettings = { + const prizeDistribution: PrizeDistribution = { matchCardinality: BigNumber.from(5), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.6', 9), ethers.utils.parseUnits('0.1', 9), ethers.utils.parseUnits('0.1', 9), @@ -495,8 +495,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); const normalizedUsersBalance = utils.parseEther('0.05'); // has 5% of the total supply @@ -508,9 +508,9 @@ describe('DrawCalculator', () => { expect(userPicks).to.eq(BigNumber.from(5)); }); it('calculates the correct number of user picks', async () => { - const prizeDistribution: PrizeDistributionSettings = { + const prizeDistribution: PrizeDistribution = { matchCardinality: BigNumber.from(5), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.6', 9), ethers.utils.parseUnits('0.1', 9), ethers.utils.parseUnits('0.1', 9), @@ -524,8 +524,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); const normalizedUsersBalance = utils.parseEther('0.1'); // has 10% of the total supply const userPicks = await drawCalculator.calculateNumberOfUserPicks( @@ -537,10 +537,10 @@ describe('DrawCalculator', () => { }); }); - describe('checkPrizeDistributionIndicesForDrawId()', () => { - const prizeDistribution: PrizeDistributionSettings = { + describe('checkPrizeTierIndexForDrawId()', () => { + const prizeDistribution: PrizeDistribution = { matchCardinality: BigNumber.from(5), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.6', 9), ethers.utils.parseUnits('0.1', 9), ethers.utils.parseUnits('0.1', 9), @@ -554,11 +554,11 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(10), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); - it('calculates the grand prize distributions index', async () => { + it('calculates the grand prize tier index', async () => { const timestamps = [42]; const offsetStartTimestamps = modifyTimestampsWithOffset( timestamps, @@ -596,14 +596,14 @@ describe('DrawCalculator', () => { .withArgs(offsetStartTimestamps, offsetEndTimestamps) .returns([utils.parseEther('100'), utils.parseEther('600')]); - const result = await drawCalculator.checkPrizeDistributionIndicesForDrawId( + const result = await drawCalculator.checkPrizeTierIndexForDrawId( wallet1.address, [1], draw.drawId, ); expect(result[0].won).to.be.true; - expect(result[0].distributionIndex).to.equal(0); + expect(result[0].tierIndex).to.equal(0); }); it('no matches to return won = false', async () => { @@ -644,14 +644,14 @@ describe('DrawCalculator', () => { .withArgs(offsetStartTimestamps, offsetEndTimestamps) .returns([utils.parseEther('100'), utils.parseEther('600')]); - const result = await drawCalculator.checkPrizeDistributionIndicesForDrawId( + const result = await drawCalculator.checkPrizeTierIndexForDrawId( wallet1.address, [1], draw.drawId, ); expect(result[0].won).to.be.false; - expect(result[0].distributionIndex).to.equal( + expect(result[0].tierIndex).to.equal( prizeDistribution.matchCardinality.toNumber(), ); }); @@ -696,7 +696,7 @@ describe('DrawCalculator', () => { // 20pc of the total supply, 10 picks in the draw = 2 picks trying with 3 picks await expect( - drawCalculator.checkPrizeDistributionIndicesForDrawId( + drawCalculator.checkPrizeTierIndexForDrawId( wallet1.address, [1, 2, 3], draw.drawId, @@ -709,9 +709,9 @@ describe('DrawCalculator', () => { it('calculates the correct normalized balance', async () => { const timestamps = [42, 77]; - const prizeDistribution: PrizeDistributionSettings = { + const prizeDistribution: PrizeDistribution = { matchCardinality: BigNumber.from(5), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.6', 9), ethers.utils.parseUnits('0.1', 9), ethers.utils.parseUnits('0.1', 9), @@ -725,8 +725,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); const offsetStartTimestamps = modifyTimestampsWithOffset( @@ -777,9 +777,9 @@ describe('DrawCalculator', () => { it('reverts when totalSupply is zero', async () => { const timestamps = [42, 77]; - const prizeDistribution: PrizeDistributionSettings = { + const prizeDistribution: PrizeDistribution = { matchCardinality: BigNumber.from(5), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.6', 9), ethers.utils.parseUnits('0.1', 9), ethers.utils.parseUnits('0.1', 9), @@ -793,8 +793,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); const offsetStartTimestamps = modifyTimestampsWithOffset( @@ -841,9 +841,9 @@ describe('DrawCalculator', () => { it('returns zero when the balance is very small', async () => { const timestamps = [42]; - const prizeDistribution: PrizeDistributionSettings = { + const prizeDistribution: PrizeDistribution = { matchCardinality: BigNumber.from(5), - distributions: [ethers.utils.parseUnits('0.6', 9)], + tiers: [ethers.utils.parseUnits('0.6', 9)], numberOfPicks: BigNumber.from('100000'), bitRangeSize: BigNumber.from(4), prize: ethers.utils.parseEther('1'), @@ -852,8 +852,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); const draw1: Draw = newDraw({ @@ -895,11 +895,11 @@ describe('DrawCalculator', () => { const debug = newDebug('pt:DrawCalculator.test.ts:calculate()'); context('with draw 1 set', () => { - let prizeDistribution: PrizeDistributionSettings; + let prizeDistribution: PrizeDistribution; beforeEach(async () => { prizeDistribution = { - distributions: [ + tiers: [ ethers.utils.parseUnits('0.8', 9), ethers.utils.parseUnits('0.2', 9), ], @@ -912,8 +912,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); await prizeDistributionHistory.mock.getPrizeDistributions @@ -1086,7 +1086,7 @@ describe('DrawCalculator', () => { ); }); - it('should match all numbers but prize distribution is 0 at index 0', async () => { + it('should match all numbers but prize tiers is 0 at index 0', async () => { const winningNumber = utils.solidityKeccak256(['address'], [wallet1.address]); const winningRandomNumber = utils.solidityKeccak256( ['bytes32', 'uint256'], @@ -1095,14 +1095,14 @@ describe('DrawCalculator', () => { prizeDistribution = { ...prizeDistribution, - distributions: [ + tiers: [ ethers.utils.parseUnits('0', 9), // NOTE ZERO here ethers.utils.parseUnits('0.2', 9), ], }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); await prizeDistributionHistory.mock.getPrizeDistributions @@ -1149,20 +1149,20 @@ describe('DrawCalculator', () => { expect(prizesAwardable[0]).to.equal(utils.parseEther('0')); }); - it('should match all numbers but prize distribution is 0 at index 1', async () => { + it('should match all numbers but prize tiers is 0 at index 1', async () => { prizeDistribution = { ...prizeDistribution, bitRangeSize: BigNumber.from(2), matchCardinality: BigNumber.from(3), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.1', 9), // NOTE ZERO here ethers.utils.parseUnits('0', 9), ethers.utils.parseUnits('0.2', 9), ], }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); await prizeDistributionHistory.mock.getPrizeDistributions @@ -1260,8 +1260,8 @@ describe('DrawCalculator', () => { .withArgs(offsetStartTimestamps, offsetEndTimestamps) .returns([totalSupply1, totalSupply2]); - const prizeDistribution2: PrizeDistributionSettings = { - distributions: [ + const prizeDistribution2: PrizeDistribution = { + tiers: [ ethers.utils.parseUnits('0.8', 9), ethers.utils.parseUnits('0.2', 9), ], @@ -1274,8 +1274,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution2.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution2.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); debug(`pushing settings for draw 2...`); @@ -1321,8 +1321,8 @@ describe('DrawCalculator', () => { const pickIndices = encoder.encode(['uint256[][]'], [[['1'], ['2']]]); const ticketBalance = ethers.utils.parseEther('6'); // they had 6pc of all tickets - const prizeDistribution: PrizeDistributionSettings = { - distributions: [ + const prizeDistribution: PrizeDistribution = { + tiers: [ ethers.utils.parseUnits('0.8', 9), ethers.utils.parseUnits('0.2', 9), ], @@ -1335,8 +1335,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); const offsetStartTimestamps = modifyTimestampsWithOffset( @@ -1398,8 +1398,8 @@ describe('DrawCalculator', () => { const pickIndices = encoder.encode(['uint256[][]'], [[['1', '2', '3']]]); const ticketBalance = ethers.utils.parseEther('6'); - const prizeDistribution: PrizeDistributionSettings = { - distributions: [ + const prizeDistribution: PrizeDistribution = { + tiers: [ ethers.utils.parseUnits('0.8', 9), ethers.utils.parseUnits('0.2', 9), ], @@ -1412,8 +1412,8 @@ describe('DrawCalculator', () => { maxPicksPerUser: BigNumber.from(2), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); const offsetStartTimestamps = modifyTimestampsWithOffset( diff --git a/test/PrizeDistributionHistory.test.ts b/test/PrizeDistributionHistory.test.ts index 18ee14d6..cf96a612 100644 --- a/test/PrizeDistributionHistory.test.ts +++ b/test/PrizeDistributionHistory.test.ts @@ -2,8 +2,8 @@ import { expect } from 'chai'; import { ethers } from 'hardhat'; import { BigNumber, Contract, ContractFactory } from 'ethers'; import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers'; -import { PrizeDistributionSettings } from './types'; -import { fillPrizeDistributionsWithZeros } from './helpers/fillPrizeDistributionsWithZeros'; +import { PrizeDistribution } from './types'; +import { fillPrizeTiersWithZeros } from './helpers/fillPrizeTiersWithZeros'; const { getSigners } = ethers; @@ -13,10 +13,10 @@ describe('PrizeDistributionHistory', () => { let wallet3: SignerWithAddress; let prizeDistributionHistory: Contract; - const prizeDistribution: PrizeDistributionSettings = { + const prizeDistribution: PrizeDistribution = { matchCardinality: BigNumber.from(5), numberOfPicks: ethers.utils.parseEther('1'), - distributions: [ethers.utils.parseUnits('0.5', 9)], + tiers: [ethers.utils.parseUnits('0.5', 9)], bitRangeSize: BigNumber.from(3), prize: ethers.utils.parseEther('100'), startTimestampOffset: BigNumber.from(0), @@ -24,8 +24,8 @@ describe('PrizeDistributionHistory', () => { maxPicksPerUser: BigNumber.from(10), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); function newPrizeDistribution(cardinality: number = 5): any { @@ -46,8 +46,8 @@ describe('PrizeDistributionHistory', () => { prizeDistributionHistory = await prizeDistributionHistoryFactory.deploy(wallet1.address, 3); - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); await prizeDistributionHistory.setManager(wallet1.address); @@ -136,12 +136,12 @@ describe('PrizeDistributionHistory', () => { describe('pushPrizeDistribution()', () => { context('sanity checks', () => { - let prizeDistribution: PrizeDistributionSettings; + let prizeDistribution: PrizeDistribution; beforeEach(async () => { prizeDistribution = { matchCardinality: BigNumber.from(5), - distributions: [ + tiers: [ ethers.utils.parseUnits('0.6', 9), ethers.utils.parseUnits('0.1', 9), ethers.utils.parseUnits('0.1', 9), @@ -155,8 +155,8 @@ describe('PrizeDistributionHistory', () => { maxPicksPerUser: BigNumber.from(1001), }; - prizeDistribution.distributions = fillPrizeDistributionsWithZeros( - prizeDistribution.distributions, + prizeDistribution.tiers = fillPrizeTiersWithZeros( + prizeDistribution.tiers, ); }); @@ -165,7 +165,7 @@ describe('PrizeDistributionHistory', () => { await expect( prizeDistributionHistory.pushPrizeDistribution(1, prizeDistribution), - ).to.be.revertedWith('DrawCalc/matchCardinality-gte-distributions'); + ).to.be.revertedWith('DrawCalc/matchCardinality-gte-tiers'); }); it('should require a sane bit range', async () => { @@ -177,12 +177,12 @@ describe('PrizeDistributionHistory', () => { ).to.be.revertedWith('DrawCalc/bitRangeSize-too-large'); }); - it('cannot set over 100pc of prize for distribution', async () => { - prizeDistribution.distributions[0] = ethers.utils.parseUnits('1', 9); + it('cannot set over 100pc of prize for tiers', async () => { + prizeDistribution.tiers[0] = ethers.utils.parseUnits('1', 9); await expect( prizeDistributionHistory.pushPrizeDistribution(1, prizeDistribution), - ).to.be.revertedWith('DrawCalc/distributions-gt-100%'); + ).to.be.revertedWith('DrawCalc/tiers-gt-100%'); }); it('cannot set bitRangeSize = 0', async () => { diff --git a/test/features/oracle.test.js b/test/features/oracle.test.js index d5111dfe..b27de08d 100644 --- a/test/features/oracle.test.js +++ b/test/features/oracle.test.js @@ -1,6 +1,6 @@ const { PoolEnv } = require('./support/PoolEnv'); const ethers = require('ethers'); -const { fillPrizeDistributionsWithZeros } = require('../helpers/fillPrizeDistributionsWithZeros'); +const { fillPrizeTiersWithZeros } = require('../helpers/fillPrizeTiersWithZeros'); const toWei = (val) => ethers.utils.parseEther('' + val); @@ -23,8 +23,8 @@ describe('Oracle jobs', () => { bitRangeSize = 2; matchCardinality = 2; numberOfPicks = toWei(1); - distributions = [ethers.utils.parseUnits('1', 9)]; - distributions = fillPrizeDistributionsWithZeros(distributions); + tiers = [ethers.utils.parseUnits('1', 9)]; + tiers = fillPrizeTiersWithZeros(tiers); prize = toWei(10); startTimestampOffset = 1; endTimestampOffset = 2; @@ -37,7 +37,7 @@ describe('Oracle jobs', () => { startTimestampOffset, endTimestampOffset, numberOfPicks, - distributions, + tiers, prize, maxPicksPerUser, }); diff --git a/test/features/support/PoolEnv.js b/test/features/support/PoolEnv.js index 147f84e4..6309a422 100644 --- a/test/features/support/PoolEnv.js +++ b/test/features/support/PoolEnv.js @@ -179,7 +179,7 @@ function PoolEnv() { endTimestampOffset, matchCardinality, numberOfPicks, - distributions, + tiers, prize, maxPicksPerUser, }) { @@ -191,7 +191,7 @@ function PoolEnv() { startTimestampOffset, endTimestampOffset, numberOfPicks, - distributions, + tiers, prize, maxPicksPerUser, }; diff --git a/test/features/ticket.test.js b/test/features/ticket.test.js index f5ec04aa..311e8119 100644 --- a/test/features/ticket.test.js +++ b/test/features/ticket.test.js @@ -52,7 +52,7 @@ describe('Tickets', () => { bitRangeSize: ethers.BigNumber.from(4), matchCardinality: ethers.BigNumber.from(5), numberOfPicks: toWei('1'), - distributions: [ethers.utils.parseUnits('0.8', 9), ethers.utils.parseUnits('0.2', 9)], + tiers: [ethers.utils.parseUnits('0.8', 9), ethers.utils.parseUnits('0.2', 9)], prize: toWei('10'), startTimestampOffset: 5, endTimestampOffset: 10, diff --git a/test/helpers/fillPrizeDistributionsWithZeros.ts b/test/helpers/fillPrizeDistributionsWithZeros.ts deleted file mode 100644 index dc7e4ca6..00000000 --- a/test/helpers/fillPrizeDistributionsWithZeros.ts +++ /dev/null @@ -1,7 +0,0 @@ -import { BigNumber } from 'ethers'; - -export function fillPrizeDistributionsWithZeros(distributions: BigNumber[]): BigNumber[]{ - const existingLength = distributions.length - const lengthOfZeroesRequired = 16 - existingLength - return [...distributions, ...Array(lengthOfZeroesRequired).fill(BigNumber.from(0))] -} diff --git a/test/helpers/fillPrizeTiersWithZeros.ts b/test/helpers/fillPrizeTiersWithZeros.ts new file mode 100644 index 00000000..27e4e1fa --- /dev/null +++ b/test/helpers/fillPrizeTiersWithZeros.ts @@ -0,0 +1,7 @@ +import { BigNumber } from 'ethers'; + +export function fillPrizeTiersWithZeros(tiers: BigNumber[]): BigNumber[]{ + const existingLength = tiers.length + const lengthOfZeroesRequired = 16 - existingLength + return [...tiers, ...Array(lengthOfZeroesRequired).fill(BigNumber.from(0))] +} diff --git a/test/types.ts b/test/types.ts index 0ed23de8..f03adde1 100644 --- a/test/types.ts +++ b/test/types.ts @@ -1,9 +1,9 @@ import { BigNumber } from 'ethers' -export type PrizeDistributionSettings = { +export type PrizeDistribution = { matchCardinality: BigNumber; numberOfPicks: BigNumber; - distributions: BigNumber[]; + tiers: BigNumber[]; bitRangeSize: BigNumber; prize: BigNumber; startTimestampOffset: BigNumber;