Skip to content

Commit c68956b

Browse files
donosonaumczukdonosonaumczuk
committed
test: ATokenVaultRevenueSplitterOwnerTest tests fixed after changes
1 parent 193eea4 commit c68956b

File tree

1 file changed

+90
-45
lines changed

1 file changed

+90
-45
lines changed

‎test/ATokenVaultRevenueSplitterOwner.t.sol‎

Lines changed: 90 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,10 @@ contract ATokenVaultRevenueSplitterOwnerTest is Test {
3535

3636
ATokenVaultRevenueSplitterOwner revenueSplitterOwner;
3737

38+
uint256 public constant TOTAL_SHARE_IN_BPS = 10_000;
39+
40+
uint256 public constant UNIT_OF_DUST = 1;
41+
3842
function setUp() public {
3943
owner = address(this);
4044

@@ -126,10 +130,12 @@ contract ATokenVaultRevenueSplitterOwnerTest is Test {
126130

127131
assertEq(aToken.balanceOf(address(revenueSplitterOwner)), 0);
128132

129-
vm.expectCall(
130-
address(vault),
131-
abi.encodeWithSelector(IATokenVault.withdrawFees.selector, address(revenueSplitterOwner), amount)
132-
);
133+
if (amount > 0) {
134+
vm.expectCall(
135+
address(vault),
136+
abi.encodeWithSelector(IATokenVault.withdrawFees.selector, address(revenueSplitterOwner), amount)
137+
);
138+
}
133139
revenueSplitterOwner.withdrawFees();
134140

135141
assertEq(aToken.balanceOf(address(revenueSplitterOwner)), amount);
@@ -140,10 +146,12 @@ contract ATokenVaultRevenueSplitterOwnerTest is Test {
140146

141147
assertEq(aToken.balanceOf(address(revenueSplitterOwner)), 0);
142148

143-
vm.expectCall(
144-
address(vault),
145-
abi.encodeWithSelector(IATokenVault.withdrawFees.selector, address(revenueSplitterOwner), amount)
146-
);
149+
if (amount > 0) {
150+
vm.expectCall(
151+
address(vault),
152+
abi.encodeWithSelector(IATokenVault.withdrawFees.selector, address(revenueSplitterOwner), amount)
153+
);
154+
}
147155

148156
vm.prank(msgSender);
149157
revenueSplitterOwner.withdrawFees();
@@ -291,10 +299,12 @@ contract ATokenVaultRevenueSplitterOwnerTest is Test {
291299
abi.encodeWithSelector(IATokenVault.claimRewards.selector, address(revenueSplitterOwner))
292300
);
293301

294-
vm.expectCall(
295-
address(vault),
296-
abi.encodeWithSelector(IATokenVault.withdrawFees.selector, address(revenueSplitterOwner), feesToWithdraw)
297-
);
302+
if (feesToWithdraw > 0) {
303+
vm.expectCall(
304+
address(vault),
305+
abi.encodeWithSelector(IATokenVault.withdrawFees.selector, address(revenueSplitterOwner), feesToWithdraw)
306+
);
307+
}
298308

299309
assertEq(rewardAssetI.balanceOf(address(revenueSplitterOwner)), 0);
300310
assertEq(rewardAssetII.balanceOf(address(revenueSplitterOwner)), 0);
@@ -329,26 +339,33 @@ contract ATokenVaultRevenueSplitterOwnerTest is Test {
329339

330340
function test_splitRevenue_distributesRevenueToAllRecipientsAccordingToTheirShares() public {
331341
MockDAI assetToSplit = new MockDAI();
332-
uint256 amountToSplit = 250_000;
342+
uint256 assetBalance = 250_001;
343+
uint256 amountToSplit = assetBalance - UNIT_OF_DUST;
333344

334345
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), 0);
335346
assertEq(assetToSplit.balanceOf(address(recipientI)), 0);
336347
assertEq(assetToSplit.balanceOf(address(recipientII)), 0);
337348
assertEq(assetToSplit.balanceOf(address(recipientIII)), 0);
338349

339-
assetToSplit.mint(address(revenueSplitterOwner), amountToSplit);
350+
assetToSplit.mint(address(revenueSplitterOwner), assetBalance);
340351

341-
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), amountToSplit);
352+
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), assetBalance);
342353

343354
address[] memory assetsToSplit = new address[](1);
344355
assetsToSplit[0] = address(assetToSplit);
345356

346357
revenueSplitterOwner.splitRevenue(assetsToSplit);
347358

348-
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), 0);
359+
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), UNIT_OF_DUST);
349360
assertEq(assetToSplit.balanceOf(address(recipientI)), 25_000);
350361
assertEq(assetToSplit.balanceOf(address(recipientII)), 50_000);
351362
assertEq(assetToSplit.balanceOf(address(recipientIII)), 175_000);
363+
364+
assertEq(amountToSplit,
365+
assetToSplit.balanceOf(address(recipientI)) +
366+
assetToSplit.balanceOf(address(recipientII)) +
367+
assetToSplit.balanceOf(address(recipientIII))
368+
);
352369
}
353370

354371
function test_splitRevenue_distributesRevenueToAllRecipientsAccordingToTheirShares_MultipleAssets() public {
@@ -369,60 +386,82 @@ contract ATokenVaultRevenueSplitterOwnerTest is Test {
369386
assertEq(assetToSplitII.balanceOf(address(recipientII)), 0);
370387
assertEq(assetToSplitII.balanceOf(address(recipientIII)), 0);
371388

372-
uint256 amountToSplitI = 250_000;
373-
assetToSplitI.mint(address(revenueSplitterOwner), amountToSplitI);
374-
assertEq(assetToSplitI.balanceOf(address(revenueSplitterOwner)), amountToSplitI);
389+
uint256 assetBalanceI = 250_001;
390+
uint256 amountToSplitI = assetBalanceI - UNIT_OF_DUST;
391+
assetToSplitI.mint(address(revenueSplitterOwner), assetBalanceI);
392+
assertEq(assetToSplitI.balanceOf(address(revenueSplitterOwner)), assetBalanceI);
375393

376-
uint256 amountToSplitII = 100_000;
377-
assetToSplitII.mint(address(revenueSplitterOwner), amountToSplitII);
378-
assertEq(assetToSplitII.balanceOf(address(revenueSplitterOwner)), amountToSplitII);
394+
uint256 assetBalanceII = 100_001;
395+
uint256 amountToSplitII = assetBalanceII - UNIT_OF_DUST;
396+
assetToSplitII.mint(address(revenueSplitterOwner), assetBalanceII);
397+
assertEq(assetToSplitII.balanceOf(address(revenueSplitterOwner)), assetBalanceII);
379398

380399
revenueSplitterOwner.splitRevenue(assetsToSplit);
381400

382-
assertEq(assetToSplitI.balanceOf(address(revenueSplitterOwner)), 0);
401+
assertEq(assetToSplitI.balanceOf(address(revenueSplitterOwner)), UNIT_OF_DUST);
383402

384403
assertEq(assetToSplitI.balanceOf(address(recipientI)), 25_000);
385404
assertEq(assetToSplitI.balanceOf(address(recipientII)), 50_000);
386405
assertEq(assetToSplitI.balanceOf(address(recipientIII)), 175_000);
387406

407+
assertEq(amountToSplitI,
408+
assetToSplitI.balanceOf(address(recipientI)) +
409+
assetToSplitI.balanceOf(address(recipientII)) +
410+
assetToSplitI.balanceOf(address(recipientIII))
411+
);
412+
413+
388414
assertEq(assetToSplitII.balanceOf(address(recipientI)), 10_000);
389415
assertEq(assetToSplitII.balanceOf(address(recipientII)), 20_000);
390416
assertEq(assetToSplitII.balanceOf(address(recipientIII)), 70_000);
417+
418+
assertEq(amountToSplitII,
419+
assetToSplitII.balanceOf(address(recipientI)) +
420+
assetToSplitII.balanceOf(address(recipientII)) +
421+
assetToSplitII.balanceOf(address(recipientIII))
422+
);
391423
}
392424

393425
function test_splitRevenue_canBeCalledByAnyone(address msgSender) public {
394426
MockDAI assetToSplit = new MockDAI();
395427
address[] memory assetsToSplit = new address[](1);
396428
assetsToSplit[0] = address(assetToSplit);
397429

398-
uint256 amountToSplit = 1_000;
430+
uint256 assetBalance = 1_001;
431+
uint256 amountToSplit = assetBalance - UNIT_OF_DUST;
399432

400433
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), 0);
401434
assertEq(assetToSplit.balanceOf(address(recipientI)), 0);
402435
assertEq(assetToSplit.balanceOf(address(recipientII)), 0);
403436
assertEq(assetToSplit.balanceOf(address(recipientIII)), 0);
404437

405-
assetToSplit.mint(address(revenueSplitterOwner), amountToSplit);
438+
assetToSplit.mint(address(revenueSplitterOwner), assetBalance);
406439

407-
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), amountToSplit);
440+
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), assetBalance);
408441

409442
vm.prank(msgSender);
410443
revenueSplitterOwner.splitRevenue(assetsToSplit);
411444

412-
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), 0);
445+
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), UNIT_OF_DUST);
413446
assertEq(assetToSplit.balanceOf(address(recipientI)), 100);
414447
assertEq(assetToSplit.balanceOf(address(recipientII)), 200);
415448
assertEq(assetToSplit.balanceOf(address(recipientIII)), 700);
449+
450+
assertEq(assetToSplit.balanceOf(address(recipientI)) +
451+
assetToSplit.balanceOf(address(recipientII)) +
452+
assetToSplit.balanceOf(address(recipientIII)),
453+
amountToSplit
454+
);
416455
}
417456

418457
function test_splitRevenue_emitsExpectedEvents() public {
419458
MockDAI assetToSplit = new MockDAI();
420459
address[] memory assetsToSplit = new address[](1);
421460
assetsToSplit[0] = address(assetToSplit);
422461

423-
uint256 amountToSplit = 1_000;
462+
uint256 assetBalance = 1_001;
424463

425-
assetToSplit.mint(address(revenueSplitterOwner), amountToSplit);
464+
assetToSplit.mint(address(revenueSplitterOwner), assetBalance);
426465

427466
vm.expectEmit(true, true, true, true);
428467
emit RevenueSplitTransferred(address(recipientI), address(assetToSplit), 100);
@@ -435,9 +474,9 @@ contract ATokenVaultRevenueSplitterOwnerTest is Test {
435474
}
436475

437476
function test_splitRevenue_distributesRevenueToAllRecipientsAccordingToTheirShares_FuzzAmount(
438-
uint256 amountToSplit
477+
uint256 contractBalance
439478
) public {
440-
amountToSplit = bound(amountToSplit, 0, type(uint240).max);
479+
contractBalance = bound(contractBalance, 0, type(uint240).max);
441480

442481
MockDAI assetToSplit = new MockDAI();
443482

@@ -446,21 +485,24 @@ contract ATokenVaultRevenueSplitterOwnerTest is Test {
446485
assertEq(assetToSplit.balanceOf(address(recipientII)), 0);
447486
assertEq(assetToSplit.balanceOf(address(recipientIII)), 0);
448487

449-
assetToSplit.mint(address(revenueSplitterOwner), amountToSplit);
488+
assetToSplit.mint(address(revenueSplitterOwner), contractBalance);
450489

451-
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), amountToSplit);
490+
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), contractBalance);
452491

453492
address[] memory assetsToSplit = new address[](1);
454493
assetsToSplit[0] = address(assetToSplit);
455494

456495
revenueSplitterOwner.splitRevenue(assetsToSplit);
457496

458-
assertEq(assetToSplit.balanceOf(address(recipientI)), amountToSplit * shareI / 10_000);
459-
assertEq(assetToSplit.balanceOf(address(recipientII)), amountToSplit * shareII / 10_000);
460-
assertEq(assetToSplit.balanceOf(address(recipientIII)), amountToSplit * shareIII / 10_000);
497+
uint256 amountToSplit = contractBalance > 0 ? contractBalance - UNIT_OF_DUST : 0;
498+
499+
assertEq(assetToSplit.balanceOf(address(recipientI)), amountToSplit * shareI / TOTAL_SHARE_IN_BPS);
500+
assertEq(assetToSplit.balanceOf(address(recipientII)), amountToSplit * shareII / TOTAL_SHARE_IN_BPS);
501+
assertEq(assetToSplit.balanceOf(address(recipientIII)), amountToSplit * shareIII / TOTAL_SHARE_IN_BPS);
461502

462-
// The remaining unsplit amount is capped to the be strictly less than the number of recipients
463-
assertLe(assetToSplit.balanceOf(address(revenueSplitterOwner)), recipients.length - 1);
503+
// The remaining unsplit amount is capped to the be less than the number of recipients for standard ERC-20s,
504+
// and recipients + 1 for aTokens.
505+
assertLe(assetToSplit.balanceOf(address(revenueSplitterOwner)), recipients.length);
464506
}
465507

466508
function test_splitRevenue_distributesRevenueToAllRecipientsAccordingToTheirShares_FuzzShares(
@@ -478,29 +520,32 @@ contract ATokenVaultRevenueSplitterOwnerTest is Test {
478520
// Redeploys the splitter with the new recipients configuration
479521
revenueSplitterOwner = new ATokenVaultRevenueSplitterOwner(address(vault), owner, recipients);
480522

481-
uint256 amountToSplit = 100_000;
523+
uint256 assetBalance = 100_001;
524+
uint256 amountToSplit = assetBalance - UNIT_OF_DUST;
525+
482526
MockDAI assetToSplit = new MockDAI();
483527

484528
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), 0);
485529
assertEq(assetToSplit.balanceOf(address(recipientI)), 0);
486530
assertEq(assetToSplit.balanceOf(address(recipientII)), 0);
487531
assertEq(assetToSplit.balanceOf(address(recipientIII)), 0); // Not set as recipient
488532

489-
assetToSplit.mint(address(revenueSplitterOwner), amountToSplit);
533+
assetToSplit.mint(address(revenueSplitterOwner), assetBalance);
490534

491-
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), amountToSplit);
535+
assertEq(assetToSplit.balanceOf(address(revenueSplitterOwner)), assetBalance);
492536

493537
address[] memory assetsToSplit = new address[](1);
494538
assetsToSplit[0] = address(assetToSplit);
495539

496540
revenueSplitterOwner.splitRevenue(assetsToSplit);
497541

498-
assertEq(assetToSplit.balanceOf(address(recipientI)), amountToSplit * fuzzShareI / 10_000);
499-
assertEq(assetToSplit.balanceOf(address(recipientII)), amountToSplit * fuzzShareII / 10_000);
542+
assertEq(assetToSplit.balanceOf(address(recipientI)), amountToSplit * fuzzShareI / TOTAL_SHARE_IN_BPS);
543+
assertEq(assetToSplit.balanceOf(address(recipientII)), amountToSplit * fuzzShareII / TOTAL_SHARE_IN_BPS);
500544
assertEq(assetToSplit.balanceOf(address(recipientIII)), 0); // Not set as recipient
501545

502-
// The remaining unsplit amount is capped to the be strictly less than the number of recipients
503-
assertLe(assetToSplit.balanceOf(address(revenueSplitterOwner)), recipients.length - 1);
546+
// The remaining unsplit amount is capped to the be less than the number of recipients for standard ERC-20s,
547+
// and recipients + 1 for aTokens.
548+
assertLe(assetToSplit.balanceOf(address(revenueSplitterOwner)), recipients.length);
504549
}
505550

506551
function test_receive_revertsUponNativeTransfer(address msgSender, uint256 amount) public {

0 commit comments

Comments
 (0)