wearekickback / contracts / 587

pending completion

Build # 587

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/wearekickback/contracts/commit/<a class=hub.com/wearekickback/contracts/commit/262ed5cc8cc036ed5cd92a66863ef8e63d51e3b1">262ed5cc8<a href="https://github.com/wearekickback/contracts/commit/262ed5cc8cc036ed5cd92a66863ef8e63d51e3b1">&quot;&gt;Integration (#53)

* Added function clearAndSend

* clearAndSend() fix and tests

* Tests fix

* Tests fixes, function fixes

* Fixed following PR suggestions

* remain calculation in _clearAndSend

* Fixes tests

* Add contract function and tests [solves #41] (#49)

* Add contract function and tests

* Add SafeMath for safe uint256 sum

* Removed whitespaces

* Various Fixes

* Fix tests

* Various fixes

* Fixing the tests

* Requiring withdrawn equal to attendees to clear contract

* Fixes

* Update Kovan address

* Update rinkeby

* v1.3.0

* Add emit WithdrawEvent

* v1.3.1

* Fix WithdrawEvent

* Bump version

* Add SendAndWithdraw into event list

* v1.3.3

* Add comment regarding bitmap lookup

* Update AbstractConference.sol

* Update AbstractConference.sol

* Rename from SendAndWithdraw to SendAndWithdrawEvent

* Refactoring

* Fix broken test

* Add extra assertion

* Remove changeName and changeDeposit

* Rename from UpdateParticipantLimit to UpdateParticipantLimitEvent

* Revert &amp;quot;Rename from UpdateParticipantLimit to UpdateParticipantLimitEvent&quot;

This reverts commit </a><a class="double-link" href="https://github.com/wearekickback/contracts/commit/<a class="double-link" href="https://github.com/wearekickback/contracts/commit/b271ad15a07fc6f7a945638dccdd15b594ed4e5d">b271ad15a</a>">b271ad15a</a><a href="https://github.com/wearekickback/contracts/commit/262ed5cc8cc036ed5cd92a66863ef8e63d51e3b1">.

* set clearFee on Deployer (#60)

* Add Clear event

* v1.3.8

* Add clearFee and withdrawn

* Grant admins

* Update Rinkeby

* v1.3.9

* v1.4.0

* Add ChangeClearFee event

* v1.4.1

* v1.4.2

* Deploy change to ClearFeeChanged

* Add xdai

* v1.4.3

* Integration xdai (#63)

* Add xdai

* v1.4.3

* emit WithdrawEvent on clearAndSend

* Add into gitignore file

* v1.4.4

* Add xDai contract information into README
... (continued)

Run Details

54 of 58 branches covered (93.1%)

Branch coverage included in aggregate %.

57 of 57 new or added lines in 2 files covered. (100.0%)

142 of 148 relevant lines covered (95.95%)

61.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.88

/contracts/AbstractConference.sol

pragma solidity ^0.5.11;

import './GroupAdmin.sol';
import './Conference.sol';
import 'openzeppelin-solidity/contracts/math/SafeMath.sol';

contract AbstractConference is Conference, GroupAdmin {
    using SafeMath for uint256;

    string public name;
    uint256 public deposit;
    uint256 public limitOfParticipants;
    uint256 public registered;
    bool public ended;
    bool public cancelled;
    uint256 public endedAt;
    uint256 public totalAttended;

    uint256 public coolingPeriod;
    uint256 public payoutAmount;
    uint256[] public attendanceMaps;

    uint256 public clearFee;
    uint256 public lastSent = 0;
    uint256 public withdrawn = 0;

    mapping (address => Participant) public participants;
    mapping (uint256 => address) public participantsIndex;

    struct Participant {
        uint256 index;
        address payable addr;
        bool paid;
    }

    /* Modifiers */
    modifier onlyActive {
        require(!ended, 'already ended');
        _;
    }

    modifier noOneRegistered {
        require(registered == 0, 'people have already registered');
        _;
    }

    modifier onlyEnded {
        require(ended, 'not yet ended');
        _;
    }

    modifier afterCoolingPeriod {
        require(now > endedAt + coolingPeriod, 'still in cooling period');
        _;
    }
    modifier canWithdraw {
        require(payoutAmount > 0, 'payout is 0');
        Participant storage participant = participants[msg.sender];
        require(participant.addr == msg.sender, 'forbidden access');
        require(cancelled || isAttended(msg.sender), 'event still active or you did not attend');
        require(participant.paid == false, 'already withdrawn');
        _;
    }

    /* Public functions */
    /**
     * @dev Construcotr.
     * @param _name The name of the event
     * @param _deposit The amount each participant deposits. The default is set to 0.02 Ether. The amount cannot be changed once deployed.
     * @param _limitOfParticipants The number of participant. The default is set to 20. The number can be changed by the owner of the event.
     * @param _coolingPeriod The period participants should withdraw their deposit after the event ends. After the cooling period, the event owner can claim the remining deposits.
     * @param _owner The owner of the event
     * @param _clearFee the fee for _clearAndSend function in per-mille (e.g. _clearFee = 10 means 1% fees, _clearFee = 1 means 0.1% fees) 
     */
    constructor (
        string memory _name,
        uint256 _deposit,
        uint256 _limitOfParticipants,
        uint256 _coolingPeriod,
        address payable _owner,
        uint256 _clearFee
    ) public {
        require(_owner != address(0), 'owner address is required');
        owner = _owner;
        name = _name;
        deposit = _deposit;
        limitOfParticipants = _limitOfParticipants;
        coolingPeriod = _coolingPeriod;
        clearFee = _clearFee;
    }


    /**
     * @dev Register for the event
     */
    function register() external payable onlyActive {
        require(registered < limitOfParticipants, 'participant limit reached');
        require(!isRegistered(msg.sender), 'already registered');
        doDeposit(msg.sender, deposit);

        registered = registered.add(1);
        participantsIndex[registered] = msg.sender;
        participants[msg.sender] = Participant(registered, msg.sender, false);

        emit RegisterEvent(msg.sender, registered);
    }

    /**
     * @dev Withdraws deposit after the event is over.
     */
    function withdraw() external onlyEnded canWithdraw {
        participants[msg.sender].paid = true;
        withdrawn = withdrawn.add(1);
        doWithdraw(msg.sender, payoutAmount);
        emit WithdrawEvent(msg.sender, payoutAmount);
    }

    /**
    * @dev sendAndWithdraw function allows to split _payoutAmount_ among addresses in _addresses_.
    * 
    * _addresses_ contains ethereum addresses
    * _values_ contains the value of eth/dai to give to addresses
    * 
    * addresses[i] will receive values[i]
    * The function emits the event SendAndWithdrawEvent with the following informations:
    * (addresses, values, participant address, payoutAmount - sum(values), payoutAmount)
    */
    function sendAndWithdraw(address payable[] calldata addresses, uint256[] calldata values) external canWithdraw onlyEnded {
        require(addresses.length == values.length, 'more addresses than values or viceversa');

        participants[msg.sender].paid = true;

        uint256 sumOfValues = 0;
        for(uint i = 0; i < addresses.length; i++) {
            sumOfValues = sumOfValues.add(values[i]);
            
            require(sumOfValues <= payoutAmount, 'payout amount is less than sum of values');

            doWithdraw(addresses[i], values[i]);
        }
                
        uint256 amountLeft = payoutAmount.sub(sumOfValues);
        doWithdraw(msg.sender, amountLeft);
        emit WithdrawEvent(msg.sender, amountLeft);
        emit SendAndWithdrawEvent(addresses, values, msg.sender, amountLeft);
    }

    /* Constants */
    /**
     * @dev Returns total balance of the contract. This function can be deprecated when refactroing front end code.
     * @return The total balance of the contract.
     */
    function totalBalance() view public returns (uint256){
        revert('totalBalance must be impelmented in the child class');
    }

    /**
     * @dev Returns true if the given user is registered.
     * @param _addr The address of a participant.
     * @return True if the address exists in the pariticipant list.
     */
    function isRegistered(address _addr) view public returns (bool){
        return participants[_addr].addr != address(0);
    }

    /**
     * @dev Returns true if the given user is attended.
     * @param _addr The address of a participant.
     * @return True if the user is marked as attended by admin.
     */
    function isAttended(address _addr) public view returns (bool){
        if (!isRegistered(_addr) || !ended) {
            return false;
        }
        // check the attendance maps
        else {
            Participant storage p = participants[_addr];
            uint256 pIndex = p.index.sub(1);
            uint256 map = attendanceMaps[uint256(pIndex.div(256))];
            // Check to see if bit number "pIndex" is set
            return (0 < (map & (2 ** (pIndex.mod(256)))));
        }
    }

    /**
     * @dev Returns true if the given user has withdrawn his/her deposit.
     * @param _addr The address of a participant.
     * @return True if the attendee has withdrawn his/her deposit.
     */
    function isPaid(address _addr) public view returns (bool){
        return isRegistered(_addr) && participants[_addr].paid;
    }

    /* Admin only functions */

    /**
     * @dev Cancels the event by owner. When the event is canceled each participant can withdraw their deposit back.
     */
    function cancel() external onlyAdmin onlyActive {
        payoutAmount = deposit;
        cancelled = true;
        ended = true;
        endedAt = now;
        emit CancelEvent(endedAt);
    }

    /**
    * @dev The event owner transfer the outstanding deposits if there are any unclaimed deposits after cooling period
    */
    function clear() external onlyAdmin onlyEnded afterCoolingPeriod {
        require(withdrawn == totalAttended, 'You can clear the contract only when everybody withdraw!');
        uint256 leftOver = totalBalance();
        doWithdraw(owner, leftOver);
        emit ClearEvent(owner, leftOver);
    }

    /**
    * @dev Anyone that calls the function clear the contract sending 
    * (_payoutAmount_ - fee) to *all* the unpaid attenders. 
    * Fees are aggregated and sent to msg.sender
    */
    function clearAndSend() external onlyEnded afterCoolingPeriod {
        _clearAndSend(totalAttended);
    }

    /**
    * @dev Anyone that calls the function clear the contract sending 
    * (_payoutAmount_ - fee) to the first *_num* unpaid attenders. 
    * Fees are aggregated and sent to msg.sender.
    */
    function clearAndSend(uint256 _num) external onlyEnded afterCoolingPeriod {
        _clearAndSend(_num);
    }


    /**
     * @dev Change the capacity of the event. The owner can change it until event is over.
     * @param _limitOfParticipants the number of the capacity of the event.
     */
    function setLimitOfParticipants(uint256 _limitOfParticipants) external onlyAdmin onlyActive{
        require(registered <= _limitOfParticipants, 'cannot lower than already registered');
        limitOfParticipants = _limitOfParticipants;

        emit UpdateParticipantLimit(limitOfParticipants);
    }


    /**
     * @dev Mark participants as attended and enable payouts. The attendance cannot be undone.
     * @param _maps The attendance status of participants represented by uint256 values.
     */
    function finalize(uint256[] calldata _maps) external onlyAdmin onlyActive {
        uint256 totalBits = _maps.length.mul(256);
        require(totalBits.sub(registered) < 256, 'incorrect no. of bitmaps provided');
        attendanceMaps = _maps;
        ended = true;
        endedAt = now;
        uint256 _totalAttended = 0;
        // calculate total attended
        for (uint256 i = 0; i < attendanceMaps.length; i++) {
            uint256 map = attendanceMaps[i];
            // brian kerninghan bit-counting method - O(log(n))
            while (map != 0) {
                map &= (map.sub(1));
                _totalAttended = _totalAttended.add(1);
            }
        }
        require(_totalAttended <= registered, 'should not have more attendees than registered');
        totalAttended = _totalAttended;

        if (totalAttended > 0) {
            payoutAmount = uint256(totalBalance()).div(totalAttended);
        }

        emit FinalizeEvent(attendanceMaps, payoutAmount, endedAt);
    }

    /**
    * @dev The function clear the contract sending 
    * (_payoutAmount_ - fee) to the first *_num* unpaid attenders.
    * Fees are calculated in this way: (payAmount * clearFee / 1000)
    * Fees are aggregated as (fee * _num) and sent to msg.sender.
    */ 
    function _clearAndSend(uint256 _num) internal onlyEnded afterCoolingPeriod {
        require(withdrawn < totalAttended, 'No more users to clear!');

        uint256 remain = totalAttended - withdrawn;
        _num = (_num < remain) ? _num : remain;

        uint256 fee = payoutAmount.mul(clearFee).div(1000);
        uint256 toAttenders = payoutAmount.sub(fee);

        uint256 totalSent = 0;
        for(uint256 j = lastSent.div(256); totalSent < _num && j < attendanceMaps.length; j++) {
            uint256 map = attendanceMaps[j];
            for(uint256 i = 0; totalSent < _num && i < 256; i++) {
                Participant storage participant = participants[participantsIndex[(j.mul(256).add(i).add(1))]];
                // Check to see if bit number "i" is set but participant has not been paid back
                if(0 < (map & (2 ** i)) && !participant.paid) {
                    participant.paid = true;
                    totalSent = totalSent.add(1);
                    doWithdraw(participant.addr, toAttenders);
                    emit WithdrawEvent(participant.addr, toAttenders);
                }
            }
        }
        lastSent = lastSent.add(totalSent);
        withdrawn = withdrawn.add(totalSent);
        
        uint256 toSender = fee.mul(totalSent);
        doWithdraw(msg.sender, toSender);
        emit ClearEvent(msg.sender, toSender);
    }

    function doDeposit(address /* participant */, uint256 /* amount */ ) internal {
        revert('doDeposit must be impelmented in the child class');
    }

    function doWithdraw(address payable /* participant */ , uint256 /* amount */ ) internal {
        revert('doWithdraw must be impelmented in the child class');
    }

    function tokenAddress() public view returns (address){
        revert('tokenAddress must be impelmented in the child class');
    }

}

1	pragma solidity ^0.5.11;
2
3	import './GroupAdmin.sol';
4	import './Conference.sol';
5	import 'openzeppelin-solidity/contracts/math/SafeMath.sol';
6
7	contract AbstractConference is Conference, GroupAdmin {
8	using SafeMath for uint256;
9
10	string public name;
11	uint256 public deposit;
12	uint256 public limitOfParticipants;
13	uint256 public registered;
14	bool public ended;
15	bool public cancelled;
16	uint256 public endedAt;
17	uint256 public totalAttended;
18
19	uint256 public coolingPeriod;
20	uint256 public payoutAmount;
21	uint256[] public attendanceMaps;
22
23	uint256 public clearFee;
24	uint256 public lastSent = 0;
25	uint256 public withdrawn = 0;
26
27	mapping (address => Participant) public participants;
28	mapping (uint256 => address) public participantsIndex;
29
30	struct Participant {
31	uint256 index;
32	address payable addr;
33	bool paid;
34	}
35
36	/* Modifiers */
37	modifier onlyActive {
38	require(!ended, 'already ended');	328✔
39	_;	312✔
40	}
41
42	modifier noOneRegistered {
43	require(registered == 0, 'people have already registered');	×
44	_;	×
45	}
46
47	modifier onlyEnded {
48	require(ended, 'not yet ended');	136✔
49	_;	124✔
50	}
51
52	modifier afterCoolingPeriod {
53	require(now > endedAt + coolingPeriod, 'still in cooling period');	50✔
54	_;	46✔
55	}
56	modifier canWithdraw {
57	require(payoutAmount > 0, 'payout is 0');	74✔
58	Participant storage participant = participants[msg.sender];	66✔
59	require(participant.addr == msg.sender, 'forbidden access');	66✔
60	require(cancelled \|\| isAttended(msg.sender), 'event still active or you did not attend');	62✔
61	require(participant.paid == false, 'already withdrawn');	54✔
62	_;	42✔
63	}
64
65	/* Public functions */
66	/**
67	* @dev Construcotr.
68	* @param _name The name of the event
69	* @param _deposit The amount each participant deposits. The default is set to 0.02 Ether. The amount cannot be changed once deployed.
70	* @param _limitOfParticipants The number of participant. The default is set to 20. The number can be changed by the owner of the event.
71	* @param _coolingPeriod The period participants should withdraw their deposit after the event ends. After the cooling period, the event owner can claim the remining deposits.
72	* @param _owner The owner of the event
73	* @param _clearFee the fee for _clearAndSend function in per-mille (e.g. _clearFee = 10 means 1% fees, _clearFee = 1 means 0.1% fees)
74	*/
75	constructor (
76	string memory _name,
77	uint256 _deposit,
78	uint256 _limitOfParticipants,
79	uint256 _coolingPeriod,
80	address payable _owner,
81	uint256 _clearFee
82	) public {
83	require(_owner != address(0), 'owner address is required');	107✔
84	owner = _owner;	103✔
85	name = _name;	103✔
86	deposit = _deposit;	103✔
87	limitOfParticipants = _limitOfParticipants;	103✔
88	coolingPeriod = _coolingPeriod;	103✔
89	clearFee = _clearFee;	103✔
90	}
91
92
93	/**
94	* @dev Register for the event
95	*/
96	function register() external payable onlyActive {
97	require(registered < limitOfParticipants, 'participant limit reached');	240✔
98	require(!isRegistered(msg.sender), 'already registered');	236✔
99	doDeposit(msg.sender, deposit);	232✔
100
101	registered = registered.add(1);	224✔
102	participantsIndex[registered] = msg.sender;	224✔
103	participants[msg.sender] = Participant(registered, msg.sender, false);	224✔
104
105	emit RegisterEvent(msg.sender, registered);	224✔
106	}
107
108	/**
109	* @dev Withdraws deposit after the event is over.
110	*/
111	function withdraw() external onlyEnded canWithdraw {
112	participants[msg.sender].paid = true;	28✔
113	withdrawn = withdrawn.add(1);	28✔
114	doWithdraw(msg.sender, payoutAmount);	28✔
115	emit WithdrawEvent(msg.sender, payoutAmount);	28✔
116	}
117
118	/**
119	* @dev sendAndWithdraw function allows to split _payoutAmount_ among addresses in _addresses_.
120	*
121	* _addresses_ contains ethereum addresses
122	* _values_ contains the value of eth/dai to give to addresses
123	*
124	* addresses[i] will receive values[i]
125	* The function emits the event SendAndWithdrawEvent with the following informations:
126	* (addresses, values, participant address, payoutAmount - sum(values), payoutAmount)
127	*/
128	function sendAndWithdraw(address payable[] calldata addresses, uint256[] calldata values) external canWithdraw onlyEnded {
129	require(addresses.length == values.length, 'more addresses than values or viceversa');	14✔
130
131	participants[msg.sender].paid = true;	10✔
132
133	uint256 sumOfValues = 0;	10✔
134	for(uint i = 0; i < addresses.length; i++) {	10✔
135	sumOfValues = sumOfValues.add(values[i]);	10✔
136
137	require(sumOfValues <= payoutAmount, 'payout amount is less than sum of values');	10✔
138
139	doWithdraw(addresses[i], values[i]);	6✔
140	}
141
142	uint256 amountLeft = payoutAmount.sub(sumOfValues);	6✔
143	doWithdraw(msg.sender, amountLeft);	6✔
144	emit WithdrawEvent(msg.sender, amountLeft);	6✔
145	emit SendAndWithdrawEvent(addresses, values, msg.sender, amountLeft);	6✔
146	}
147
148	/* Constants */
149	/**
150	* @dev Returns total balance of the contract. This function can be deprecated when refactroing front end code.
151	* @return The total balance of the contract.
152	*/
153	function totalBalance() view public returns (uint256){
154	revert('totalBalance must be impelmented in the child class');	×
155	}
156
157	/**
158	* @dev Returns true if the given user is registered.
159	* @param _addr The address of a participant.
160	* @return True if the address exists in the pariticipant list.
161	*/
162	function isRegistered(address _addr) view public returns (bool){
163	return participants[_addr].addr != address(0);	312✔
164	}
165
166	/**
167	* @dev Returns true if the given user is attended.
168	* @param _addr The address of a participant.
169	* @return True if the user is marked as attended by admin.
170	*/
171	function isAttended(address _addr) public view returns (bool){
172	if (!isRegistered(_addr) \|\| !ended) {	56✔
173	return false;	4✔
174	}
175	// check the attendance maps
176	else {
177	Participant storage p = participants[_addr];	52✔
178	uint256 pIndex = p.index.sub(1);	52✔
179	uint256 map = attendanceMaps[uint256(pIndex.div(256))];	52✔
180	// Check to see if bit number "pIndex" is set
181	return (0 < (map & (2 ** (pIndex.mod(256)))));	52✔
182	}
183	}
184
185	/**
186	* @dev Returns true if the given user has withdrawn his/her deposit.
187	* @param _addr The address of a participant.
188	* @return True if the attendee has withdrawn his/her deposit.
189	*/
190	function isPaid(address _addr) public view returns (bool){
191	return isRegistered(_addr) && participants[_addr].paid;	10✔
192	}
193
194	/* Admin only functions */
195
196	/**
197	* @dev Cancels the event by owner. When the event is canceled each participant can withdraw their deposit back.
198	*/
199	function cancel() external onlyAdmin onlyActive {
200	payoutAmount = deposit;	20✔
201	cancelled = true;	20✔
202	ended = true;	20✔
203	endedAt = now;	20✔
204	emit CancelEvent(endedAt);	20✔
205	}
206
207	/**
208	* @dev The event owner transfer the outstanding deposits if there are any unclaimed deposits after cooling period
209	*/
210	function clear() external onlyAdmin onlyEnded afterCoolingPeriod {
211	require(withdrawn == totalAttended, 'You can clear the contract only when everybody withdraw!');	6✔
212	uint256 leftOver = totalBalance();	2✔
213	doWithdraw(owner, leftOver);	2✔
214	emit ClearEvent(owner, leftOver);	2✔
215	}
216
217	/**
218	* @dev Anyone that calls the function clear the contract sending
219	* (_payoutAmount_ - fee) to all the unpaid attenders.
220	* Fees are aggregated and sent to msg.sender
221	*/
222	function clearAndSend() external onlyEnded afterCoolingPeriod {
223	_clearAndSend(totalAttended);	6✔
224	}
225
226	/**
227	* @dev Anyone that calls the function clear the contract sending
228	* (_payoutAmount_ - fee) to the first _num unpaid attenders.
229	* Fees are aggregated and sent to msg.sender.
230	*/
231	function clearAndSend(uint256 _num) external onlyEnded afterCoolingPeriod {
232	_clearAndSend(_num);	14✔
233	}
234
235
236	/**
237	* @dev Change the capacity of the event. The owner can change it until event is over.
238	* @param _limitOfParticipants the number of the capacity of the event.
239	*/
240	function setLimitOfParticipants(uint256 _limitOfParticipants) external onlyAdmin onlyActive{
241	require(registered <= _limitOfParticipants, 'cannot lower than already registered');	8✔
242	limitOfParticipants = _limitOfParticipants;	4✔
243
244	emit UpdateParticipantLimit(limitOfParticipants);	4✔
245	}
246
247
248	/**
249	* @dev Mark participants as attended and enable payouts. The attendance cannot be undone.
250	* @param _maps The attendance status of participants represented by uint256 values.
251	*/
252	function finalize(uint256[] calldata _maps) external onlyAdmin onlyActive {
253	uint256 totalBits = _maps.length.mul(256);	44✔
254	require(totalBits.sub(registered) < 256, 'incorrect no. of bitmaps provided');	44!
255	attendanceMaps = _maps;	44✔
256	ended = true;	44✔
257	endedAt = now;	44✔
258	uint256 _totalAttended = 0;	44✔
259	// calculate total attended
260	for (uint256 i = 0; i < attendanceMaps.length; i++) {	44✔
261	uint256 map = attendanceMaps[i];	42✔
262	// brian kerninghan bit-counting method - O(log(n))
263	while (map != 0) {	42✔
264	map &= (map.sub(1));	1,096✔
265	_totalAttended = _totalAttended.add(1);	1,096✔
266	}
267	}
268	require(_totalAttended <= registered, 'should not have more attendees than registered');	44✔
269	totalAttended = _totalAttended;	40✔
270
271	if (totalAttended > 0) {	40✔
272	payoutAmount = uint256(totalBalance()).div(totalAttended);	36✔
273	}
274
275	emit FinalizeEvent(attendanceMaps, payoutAmount, endedAt);	40✔
276	}
277
278	/**
279	* @dev The function clear the contract sending
280	* (_payoutAmount_ - fee) to the first _num unpaid attenders.
281	* Fees are calculated in this way: (payAmount * clearFee / 1000)
282	* Fees are aggregated as (fee * _num) and sent to msg.sender.
283	*/
284	function _clearAndSend(uint256 _num) internal onlyEnded afterCoolingPeriod {
285	require(withdrawn < totalAttended, 'No more users to clear!');	20✔
286
287	uint256 remain = totalAttended - withdrawn;	16✔
288	_num = (_num < remain) ? _num : remain;	16✔
289
290	uint256 fee = payoutAmount.mul(clearFee).div(1000);	16✔
291	uint256 toAttenders = payoutAmount.sub(fee);	16✔
292
293	uint256 totalSent = 0;	16✔
294	for(uint256 j = lastSent.div(256); totalSent < _num && j < attendanceMaps.length; j++) {	16✔
295	uint256 map = attendanceMaps[j];	16✔
296	for(uint256 i = 0; totalSent < _num && i < 256; i++) {	16✔
297	Participant storage participant = participants[participantsIndex[(j.mul(256).add(i).add(1))]];	42✔
298	// Check to see if bit number "i" is set but participant has not been paid back
299	if(0 < (map & (2 ** i)) && !participant.paid) {	42✔
300	participant.paid = true;	22✔
301	totalSent = totalSent.add(1);	22✔
302	doWithdraw(participant.addr, toAttenders);	22✔
303	emit WithdrawEvent(participant.addr, toAttenders);	22✔
304	}
305	}
306	}
307	lastSent = lastSent.add(totalSent);	16✔
308	withdrawn = withdrawn.add(totalSent);	16✔
309
310	uint256 toSender = fee.mul(totalSent);	16✔
311	doWithdraw(msg.sender, toSender);	16✔
312	emit ClearEvent(msg.sender, toSender);	16✔
313	}
314
315	function doDeposit(address /* participant /, uint256 / amount */ ) internal {
316	revert('doDeposit must be impelmented in the child class');	×
317	}
318
319	function doWithdraw(address payable /* participant / , uint256 / amount */ ) internal {
320	revert('doWithdraw must be impelmented in the child class');	×
321	}
322
323	function tokenAddress() public view returns (address){
324	revert('tokenAddress must be impelmented in the child class');	×
325	}
326
327	}

wearekickback / contracts / 587

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous