From 711e2e6277a812324027c6c345f53c66e8df2be4 Mon Sep 17 00:00:00 2001 From: smol-ninja Date: Sat, 15 Feb 2025 15:51:54 +0000 Subject: [PATCH] test(refactor): move all constants into CONSTANT contract test: remove redundant functions from Defaults --- tests/Base.t.sol | 55 +++++++-- tests/fork/Fork.t.sol | 5 +- .../fork/merkle-campaign/MerkleInstant.t.sol | 10 +- tests/fork/merkle-campaign/MerkleLL.t.sol | 28 ++--- tests/fork/merkle-campaign/MerkleLT.t.sol | 22 ++-- tests/fork/merkle-campaign/MerkleVCA.t.sol | 10 +- tests/integration/Integration.t.sol | 80 ++++++------- .../factory/collect-fees/collectFees.t.sol | 8 +- .../createMerkleInstant.t.sol | 17 ++- .../create-merkle-ll/createMerkleLL.t.sol | 19 ++- .../create-merkle-lt/createMerkleLT.t.sol | 23 ++-- .../create-merkle-vca/createMerkleVCA.t.sol | 80 +++++-------- .../concrete/factory/get-fee/getFee.t.sol | 2 +- .../set-minimum-fee/setMinimumFee.t.sol | 9 +- .../concrete/instant/claim/claim.t.sol | 10 +- .../concrete/instant/constructor.t.sol | 10 +- .../integration/concrete/ll/claim/claim.t.sol | 61 ++++------ .../integration/concrete/ll/constructor.t.sol | 109 ++++------------- .../integration/concrete/lt/claim/claim.t.sol | 59 ++++----- .../integration/concrete/lt/constructor.t.sol | 113 +++--------------- .../concrete/shared/claim/claim.t.sol | 54 +++------ .../concrete/shared/clawback/clawback.t.sol | 7 +- .../shared/collect-fees/collectFees.t.sol | 2 +- .../shared/has-claimed/hasClaimed.t.sol | 4 +- .../shared/has-expired/hasExpired.t.sol | 4 +- .../concrete/vca/claim/claim.t.sol | 40 +++---- .../concrete/vca/constructor.t.sol | 14 +-- tests/utils/Constants.sol | 36 ++++++ tests/utils/Defaults.sol | 108 +---------------- 29 files changed, 368 insertions(+), 631 deletions(-) diff --git a/tests/Base.t.sol b/tests/Base.t.sol index c8959c08..a5c748ad 100644 --- a/tests/Base.t.sol +++ b/tests/Base.t.sol @@ -2,9 +2,11 @@ pragma solidity >=0.8.22 <0.9.0; import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import { Arrays } from "@openzeppelin/contracts/utils/Arrays.sol"; import { ISablierLockup } from "@sablier/lockup/src/interfaces/ISablierLockup.sol"; import { LockupNFTDescriptor } from "@sablier/lockup/src/LockupNFTDescriptor.sol"; import { SablierLockup } from "@sablier/lockup/src/SablierLockup.sol"; +import { Merkle } from "murky/src/Merkle.sol"; import { ISablierMerkleBase } from "src/interfaces/ISablierMerkleBase.sol"; import { ISablierMerkleFactory } from "src/interfaces/ISablierMerkleFactory.sol"; import { ISablierMerkleInstant } from "src/interfaces/ISablierMerkleInstant.sol"; @@ -22,11 +24,14 @@ import { Assertions } from "./utils/Assertions.sol"; import { Constants } from "./utils/Constants.sol"; import { Defaults } from "./utils/Defaults.sol"; import { DeployOptimized } from "./utils/DeployOptimized.sol"; +import { MerkleBuilder } from "./utils/MerkleBuilder.sol"; import { Modifiers } from "./utils/Modifiers.sol"; import { Users } from "./utils/Types.sol"; /// @notice Base test contract with common logic needed by all tests. -abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers { +abstract contract Base_Test is Assertions, Constants, DeployOptimized, Merkle, Modifiers { + using MerkleBuilder for uint256[]; + /*////////////////////////////////////////////////////////////////////////// VARIABLES //////////////////////////////////////////////////////////////////////////*/ @@ -72,7 +77,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers deployMerkleFactoryConditionally(); // Set the minimum fee on the Merkle factory. - merkleFactory.setMinimumFee(defaults.MINIMUM_FEE()); + merkleFactory.setMinimumFee(MINIMUM_FEE); // Create users for testing. users.campaignOwner = createUser("CampaignOwner"); @@ -84,8 +89,8 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers users.recipient4 = createUser("Recipient4"); users.sender = createUser("Sender"); - defaults.setUsers(users); - defaults.initMerkleTree(); + // Initialize the Merkle tree. + initMerkleTree(); // Set the variables in Modifiers contract. setVariables(defaults, users); @@ -127,6 +132,43 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers vm.label({ account: address(merkleFactory), newLabel: "MerkleFactory" }); } + /*////////////////////////////////////////////////////////////////////////// + MERKLE-BUILDER + //////////////////////////////////////////////////////////////////////////*/ + + function index1Proof() public view returns (bytes32[] memory) { + return indexProof(INDEX1, users.recipient1); + } + + function index2Proof() public view returns (bytes32[] memory) { + return indexProof(INDEX2, users.recipient2); + } + + function index3Proof() public view returns (bytes32[] memory) { + return indexProof(INDEX3, users.recipient3); + } + + function index4Proof() public view returns (bytes32[] memory) { + return indexProof(INDEX4, users.recipient4); + } + + function indexProof(uint256 index, address recipient) public view returns (bytes32[] memory) { + uint256 leaf = MerkleBuilder.computeLeaf(index, recipient, CLAIM_AMOUNT); + uint256 pos = Arrays.findUpperBound(LEAVES, leaf); + return getProof(LEAVES.toBytes32(), pos); + } + + /// @dev We need a separate function to initialize the Merkle tree because, at the construction time, the users are + /// not yet set. + function initMerkleTree() public { + LEAVES[0] = MerkleBuilder.computeLeaf(INDEX1, users.recipient1, CLAIM_AMOUNT); + LEAVES[1] = MerkleBuilder.computeLeaf(INDEX2, users.recipient2, CLAIM_AMOUNT); + LEAVES[2] = MerkleBuilder.computeLeaf(INDEX3, users.recipient3, CLAIM_AMOUNT); + LEAVES[3] = MerkleBuilder.computeLeaf(INDEX4, users.recipient4, CLAIM_AMOUNT); + MerkleBuilder.sortLeaves(LEAVES); + MERKLE_ROOT = getRoot(LEAVES.toBytes32()); + } + /*////////////////////////////////////////////////////////////////////////// CALL EXPECTS - IERC20 //////////////////////////////////////////////////////////////////////////*/ @@ -171,10 +213,7 @@ abstract contract Base_Test is Assertions, Constants, DeployOptimized, Modifiers vm.expectCall( merkleLockup, msgValue, - abi.encodeCall( - ISablierMerkleBase.claim, - (defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT(), defaults.index1Proof()) - ) + abi.encodeCall(ISablierMerkleBase.claim, (INDEX1, users.recipient1, CLAIM_AMOUNT, index1Proof())) ); } diff --git a/tests/fork/Fork.t.sol b/tests/fork/Fork.t.sol index e4a80c98..eb18dae6 100644 --- a/tests/fork/Fork.t.sol +++ b/tests/fork/Fork.t.sol @@ -3,13 +3,12 @@ pragma solidity >=0.8.22 <0.9.0; import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import { ISablierLockup } from "@sablier/lockup/src/interfaces/ISablierLockup.sol"; -import { Merkle } from "murky/src/Merkle.sol"; import { Base_Test } from "../Base.t.sol"; import { Defaults } from "../utils/Defaults.sol"; /// @notice Common logic needed by all fork tests. -abstract contract Fork_Test is Base_Test, Merkle { +abstract contract Fork_Test is Base_Test { /*////////////////////////////////////////////////////////////////////////// STATE VARIABLES //////////////////////////////////////////////////////////////////////////*/ @@ -46,6 +45,6 @@ abstract contract Fork_Test is Base_Test, Merkle { // Set the minimum fee for campaign. resetPrank({ msgSender: factoryAdmin }); - merkleFactory.setMinimumFee(defaults.MINIMUM_FEE()); + merkleFactory.setMinimumFee(MINIMUM_FEE); } } diff --git a/tests/fork/merkle-campaign/MerkleInstant.t.sol b/tests/fork/merkle-campaign/MerkleInstant.t.sol index fb954fb2..2ca38859 100644 --- a/tests/fork/merkle-campaign/MerkleInstant.t.sol +++ b/tests/fork/merkle-campaign/MerkleInstant.t.sol @@ -124,7 +124,7 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test { params: vars.params, aggregateAmount: vars.aggregateAmount, recipientCount: vars.recipientCount, - fee: defaults.MINIMUM_FEE() + fee: MINIMUM_FEE }); vars.merkleInstant = merkleFactory.createMerkleInstant(vars.params, vars.aggregateAmount, vars.recipientCount); @@ -175,7 +175,7 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test { expectCallToClaimWithData({ merkleLockup: address(vars.merkleInstant), - fee: defaults.MINIMUM_FEE(), + fee: MINIMUM_FEE, index: vars.indexes[params.posBeforeSort], recipient: vars.recipients[params.posBeforeSort], amount: vars.amounts[params.posBeforeSort], @@ -188,7 +188,7 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test { value: vars.amounts[params.posBeforeSort] }); - vars.merkleInstant.claim{ value: defaults.MINIMUM_FEE() }({ + vars.merkleInstant.claim{ value: MINIMUM_FEE }({ index: vars.indexes[params.posBeforeSort], recipient: vars.recipients[params.posBeforeSort], amount: vars.amounts[params.posBeforeSort], @@ -226,11 +226,11 @@ abstract contract MerkleInstant_Fork_Test is Fork_Test { emit ISablierMerkleFactory.CollectFees({ admin: factoryAdmin, merkleBase: vars.merkleInstant, - feeAmount: defaults.MINIMUM_FEE() + feeAmount: MINIMUM_FEE }); merkleFactory.collectFees({ merkleBase: vars.merkleInstant }); assertEq(address(vars.merkleInstant).balance, 0, "merkleInstant ETH balance"); - assertEq(factoryAdmin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance"); + assertEq(factoryAdmin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance"); } } diff --git a/tests/fork/merkle-campaign/MerkleLL.t.sol b/tests/fork/merkle-campaign/MerkleLL.t.sol index 074c77a2..6461460b 100644 --- a/tests/fork/merkle-campaign/MerkleLL.t.sol +++ b/tests/fork/merkle-campaign/MerkleLL.t.sol @@ -130,7 +130,7 @@ abstract contract MerkleLL_Fork_Test is Fork_Test { params: vars.params, aggregateAmount: vars.aggregateAmount, recipientCount: vars.recipientCount, - fee: defaults.MINIMUM_FEE() + fee: MINIMUM_FEE }); vars.merkleLL = merkleFactory.createMerkleLL(vars.params, vars.aggregateAmount, vars.recipientCount); @@ -180,14 +180,14 @@ abstract contract MerkleLL_Fork_Test is Fork_Test { expectCallToClaimWithData({ merkleLockup: address(vars.merkleLL), - fee: defaults.MINIMUM_FEE(), + fee: MINIMUM_FEE, index: vars.indexes[params.posBeforeSort], recipient: vars.recipients[params.posBeforeSort], amount: vars.amounts[params.posBeforeSort], merkleProof: vars.merkleProof }); - vars.merkleLL.claim{ value: defaults.MINIMUM_FEE() }({ + vars.merkleLL.claim{ value: MINIMUM_FEE }({ index: vars.indexes[params.posBeforeSort], recipient: vars.recipients[params.posBeforeSort], amount: vars.amounts[params.posBeforeSort], @@ -195,18 +195,16 @@ abstract contract MerkleLL_Fork_Test is Fork_Test { }); vars.expectedUnlockAmounts.start = - ud60x18(vars.amounts[params.posBeforeSort]).mul(defaults.START_PERCENTAGE().intoUD60x18()).intoUint128(); + ud60x18(vars.amounts[params.posBeforeSort]).mul(START_PERCENTAGE.intoUD60x18()).intoUint128(); vars.expectedUnlockAmounts.cliff = - ud60x18(vars.amounts[params.posBeforeSort]).mul(defaults.CLIFF_PERCENTAGE().intoUD60x18()).intoUint128(); + ud60x18(vars.amounts[params.posBeforeSort]).mul(CLIFF_PERCENTAGE.intoUD60x18()).intoUint128(); // Assert that the stream has been created successfully. - assertEq( - lockup.getCliffTime(vars.expectedStreamId), getBlockTimestamp() + defaults.CLIFF_DURATION(), "cliff time" - ); + assertEq(lockup.getCliffTime(vars.expectedStreamId), getBlockTimestamp() + CLIFF_DURATION, "cliff time"); assertEq( lockup.getDepositedAmount(vars.expectedStreamId), vars.amounts[params.posBeforeSort], "deposited amount" ); - assertEq(lockup.getEndTime(vars.expectedStreamId), getBlockTimestamp() + defaults.TOTAL_DURATION(), "end time"); + assertEq(lockup.getEndTime(vars.expectedStreamId), getBlockTimestamp() + TOTAL_DURATION, "end time"); assertEq(lockup.getLockupModel(vars.expectedStreamId), Lockup.Model.LOCKUP_LINEAR); assertEq(lockup.getRecipient(vars.expectedStreamId), vars.recipients[params.posBeforeSort], "recipient"); assertEq(lockup.getRefundedAmount(vars.expectedStreamId), 0, "refunded amount"); @@ -224,10 +222,10 @@ abstract contract MerkleLL_Fork_Test is Fork_Test { "unlock amounts start" ); assertEq(lockup.getWithdrawnAmount(vars.expectedStreamId), 0, "withdrawn amount"); - assertEq(lockup.isCancelable(vars.expectedStreamId), defaults.CANCELABLE(), "is cancelable"); + assertEq(lockup.isCancelable(vars.expectedStreamId), CANCELABLE, "is cancelable"); assertEq(lockup.isDepleted(vars.expectedStreamId), false, "is depleted"); assertEq(lockup.isStream(vars.expectedStreamId), true, "is stream"); - assertEq(lockup.isTransferable(vars.expectedStreamId), defaults.TRANSFERABLE(), "is transferable"); + assertEq(lockup.isTransferable(vars.expectedStreamId), TRANSFERABLE, "is transferable"); assertEq(lockup.wasCanceled(vars.expectedStreamId), false, "was canceled"); assertTrue(vars.merkleLL.hasClaimed(vars.indexes[params.posBeforeSort])); @@ -258,14 +256,10 @@ abstract contract MerkleLL_Fork_Test is Fork_Test { //////////////////////////////////////////////////////////////////////////*/ vm.expectEmit({ emitter: address(merkleFactory) }); - emit ISablierMerkleFactory.CollectFees({ - admin: factoryAdmin, - merkleBase: vars.merkleLL, - feeAmount: defaults.MINIMUM_FEE() - }); + emit ISablierMerkleFactory.CollectFees({ admin: factoryAdmin, merkleBase: vars.merkleLL, feeAmount: MINIMUM_FEE }); merkleFactory.collectFees({ merkleBase: vars.merkleLL }); assertEq(address(vars.merkleLL).balance, 0, "merkleLL ETH balance"); - assertEq(factoryAdmin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance"); + assertEq(factoryAdmin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance"); } } diff --git a/tests/fork/merkle-campaign/MerkleLT.t.sol b/tests/fork/merkle-campaign/MerkleLT.t.sol index b69fae43..b91926e7 100644 --- a/tests/fork/merkle-campaign/MerkleLT.t.sol +++ b/tests/fork/merkle-campaign/MerkleLT.t.sol @@ -128,8 +128,8 @@ abstract contract MerkleLT_Fork_Test is Fork_Test { params: vars.params, aggregateAmount: vars.aggregateAmount, recipientCount: vars.recipientCount, - totalDuration: defaults.TOTAL_DURATION(), - fee: defaults.MINIMUM_FEE() + totalDuration: TOTAL_DURATION, + fee: MINIMUM_FEE }); vars.merkleLT = merkleFactory.createMerkleLT(vars.params, vars.aggregateAmount, vars.recipientCount); @@ -178,14 +178,14 @@ abstract contract MerkleLT_Fork_Test is Fork_Test { expectCallToClaimWithData({ merkleLockup: address(vars.merkleLT), - fee: defaults.MINIMUM_FEE(), + fee: MINIMUM_FEE, index: vars.indexes[params.posBeforeSort], recipient: vars.recipients[params.posBeforeSort], amount: vars.amounts[params.posBeforeSort], merkleProof: vars.merkleProof }); - vars.merkleLT.claim{ value: defaults.MINIMUM_FEE() }({ + vars.merkleLT.claim{ value: MINIMUM_FEE }({ index: vars.indexes[params.posBeforeSort], recipient: vars.recipients[params.posBeforeSort], amount: vars.amounts[params.posBeforeSort], @@ -196,7 +196,7 @@ abstract contract MerkleLT_Fork_Test is Fork_Test { assertEq( lockup.getDepositedAmount(vars.expectedStreamId), vars.amounts[params.posBeforeSort], "deposited amount" ); - assertEq(lockup.getEndTime(vars.expectedStreamId), getBlockTimestamp() + defaults.TOTAL_DURATION(), "end time"); + assertEq(lockup.getEndTime(vars.expectedStreamId), getBlockTimestamp() + TOTAL_DURATION, "end time"); assertEq(lockup.getLockupModel(vars.expectedStreamId), Lockup.Model.LOCKUP_TRANCHED); assertEq(lockup.getRecipient(vars.expectedStreamId), vars.recipients[params.posBeforeSort], "recipient"); assertEq(lockup.getRefundedAmount(vars.expectedStreamId), 0, "refunded amount"); @@ -208,10 +208,10 @@ abstract contract MerkleLT_Fork_Test is Fork_Test { ); assertEq(lockup.getUnderlyingToken(vars.expectedStreamId), FORK_TOKEN, "token"); assertEq(lockup.getWithdrawnAmount(vars.expectedStreamId), 0, "withdrawn amount"); - assertEq(lockup.isCancelable(vars.expectedStreamId), defaults.CANCELABLE(), "is cancelable"); + assertEq(lockup.isCancelable(vars.expectedStreamId), CANCELABLE, "is cancelable"); assertEq(lockup.isDepleted(vars.expectedStreamId), false, "is depleted"); assertEq(lockup.isStream(vars.expectedStreamId), true, "is stream"); - assertEq(lockup.isTransferable(vars.expectedStreamId), defaults.TRANSFERABLE(), "is transferable"); + assertEq(lockup.isTransferable(vars.expectedStreamId), TRANSFERABLE, "is transferable"); assertEq(lockup.wasCanceled(vars.expectedStreamId), false, "was canceled"); assertTrue(vars.merkleLT.hasClaimed(vars.indexes[params.posBeforeSort])); @@ -243,14 +243,10 @@ abstract contract MerkleLT_Fork_Test is Fork_Test { //////////////////////////////////////////////////////////////////////////*/ vm.expectEmit({ emitter: address(merkleFactory) }); - emit ISablierMerkleFactory.CollectFees({ - admin: factoryAdmin, - merkleBase: vars.merkleLT, - feeAmount: defaults.MINIMUM_FEE() - }); + emit ISablierMerkleFactory.CollectFees({ admin: factoryAdmin, merkleBase: vars.merkleLT, feeAmount: MINIMUM_FEE }); merkleFactory.collectFees({ merkleBase: vars.merkleLT }); assertEq(address(vars.merkleLT).balance, 0, "merkleLT ETH balance"); - assertEq(factoryAdmin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance"); + assertEq(factoryAdmin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance"); } } diff --git a/tests/fork/merkle-campaign/MerkleVCA.t.sol b/tests/fork/merkle-campaign/MerkleVCA.t.sol index 9c408cbf..e8a9142d 100644 --- a/tests/fork/merkle-campaign/MerkleVCA.t.sol +++ b/tests/fork/merkle-campaign/MerkleVCA.t.sol @@ -138,7 +138,7 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test { params: vars.params, aggregateAmount: vars.aggregateAmount, recipientCount: vars.recipientCount, - fee: defaults.MINIMUM_FEE() + fee: MINIMUM_FEE }); vars.merkleVCA = merkleFactory.createMerkleVCA(vars.params, vars.aggregateAmount, vars.recipientCount); @@ -195,7 +195,7 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test { expectCallToClaimWithData({ merkleLockup: address(vars.merkleVCA), - fee: defaults.MINIMUM_FEE(), + fee: MINIMUM_FEE, index: vars.indexes[params.posBeforeSort], recipient: vars.recipients[params.posBeforeSort], amount: vars.amounts[params.posBeforeSort], @@ -208,7 +208,7 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test { value: vars.claimableAmount }); - vars.merkleVCA.claim{ value: defaults.MINIMUM_FEE() }({ + vars.merkleVCA.claim{ value: MINIMUM_FEE }({ index: vars.indexes[params.posBeforeSort], recipient: vars.recipients[params.posBeforeSort], amount: vars.amounts[params.posBeforeSort], @@ -246,11 +246,11 @@ abstract contract MerkleVCA_Fork_Test is Fork_Test { emit ISablierMerkleFactory.CollectFees({ admin: factoryAdmin, merkleBase: vars.merkleVCA, - feeAmount: defaults.MINIMUM_FEE() + feeAmount: MINIMUM_FEE }); merkleFactory.collectFees({ merkleBase: vars.merkleVCA }); assertEq(address(vars.merkleVCA).balance, 0, "merkleVCA ETH balance"); - assertEq(factoryAdmin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance"); + assertEq(factoryAdmin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance"); } } diff --git a/tests/integration/Integration.t.sol b/tests/integration/Integration.t.sol index a72ebdd7..46f2dfd8 100644 --- a/tests/integration/Integration.t.sol +++ b/tests/integration/Integration.t.sol @@ -44,10 +44,10 @@ contract Integration_Test is Base_Test { merkleVCA = createMerkleVCA(); // Fund the contracts. - deal({ token: address(dai), to: address(merkleInstant), give: defaults.AGGREGATE_AMOUNT() }); - deal({ token: address(dai), to: address(merkleLL), give: defaults.AGGREGATE_AMOUNT() }); - deal({ token: address(dai), to: address(merkleLT), give: defaults.AGGREGATE_AMOUNT() }); - deal({ token: address(dai), to: address(merkleVCA), give: defaults.AGGREGATE_AMOUNT() }); + deal({ token: address(dai), to: address(merkleInstant), give: AGGREGATE_AMOUNT }); + deal({ token: address(dai), to: address(merkleLL), give: AGGREGATE_AMOUNT }); + deal({ token: address(dai), to: address(merkleLT), give: AGGREGATE_AMOUNT }); + deal({ token: address(dai), to: address(merkleVCA), give: AGGREGATE_AMOUNT }); } /*////////////////////////////////////////////////////////////////////////// @@ -55,11 +55,11 @@ contract Integration_Test is Base_Test { //////////////////////////////////////////////////////////////////////////*/ function claim() internal { - merkleBase.claim{ value: defaults.MINIMUM_FEE() }({ - index: defaults.INDEX1(), + merkleBase.claim{ value: MINIMUM_FEE }({ + index: INDEX1, recipient: users.recipient1, - amount: defaults.CLAIM_AMOUNT(), - merkleProof: defaults.index1Proof() + amount: CLAIM_AMOUNT, + merkleProof: index1Proof() }); } @@ -72,17 +72,17 @@ contract Integration_Test is Base_Test { campaignCreator: users.campaignOwner, campaignOwner: campaignOwner, expiration: expiration, - merkleRoot: defaults.MERKLE_ROOT(), + merkleRoot: MERKLE_ROOT, token_: dai }); } function createMerkleInstant() internal returns (ISablierMerkleInstant) { - return createMerkleInstant(users.campaignOwner, defaults.EXPIRATION()); + return createMerkleInstant(users.campaignOwner, EXPIRATION); } function createMerkleInstant(address campaignOwner) internal returns (ISablierMerkleInstant) { - return createMerkleInstant(campaignOwner, defaults.EXPIRATION()); + return createMerkleInstant(campaignOwner, EXPIRATION); } function createMerkleInstant(uint40 expiration) internal returns (ISablierMerkleInstant) { @@ -94,16 +94,16 @@ contract Integration_Test is Base_Test { defaults.merkleInstantConstructorParams({ campaignOwner: campaignOwner, expiration: expiration, - merkleRoot: defaults.MERKLE_ROOT(), + merkleRoot: MERKLE_ROOT, token_: dai }), - defaults.AGGREGATE_AMOUNT(), - defaults.RECIPIENT_COUNT() + AGGREGATE_AMOUNT, + RECIPIENT_COUNT ); } function merkleInstantConstructorParams() public view returns (MerkleInstant.ConstructorParams memory) { - return merkleInstantConstructorParams(users.campaignOwner, defaults.EXPIRATION()); + return merkleInstantConstructorParams(users.campaignOwner, EXPIRATION); } function merkleInstantConstructorParams( @@ -117,7 +117,7 @@ contract Integration_Test is Base_Test { return defaults.merkleInstantConstructorParams({ campaignOwner: campaignOwner, expiration: expiration, - merkleRoot: defaults.MERKLE_ROOT(), + merkleRoot: MERKLE_ROOT, token_: dai }); } @@ -131,17 +131,17 @@ contract Integration_Test is Base_Test { campaignCreator: users.campaignOwner, campaignOwner: campaignOwner, expiration: expiration, - merkleRoot: defaults.MERKLE_ROOT(), + merkleRoot: MERKLE_ROOT, token_: dai }); } function createMerkleLL() internal returns (ISablierMerkleLL) { - return createMerkleLL(users.campaignOwner, defaults.EXPIRATION()); + return createMerkleLL(users.campaignOwner, EXPIRATION); } function createMerkleLL(address campaignOwner) internal returns (ISablierMerkleLL) { - return createMerkleLL(campaignOwner, defaults.EXPIRATION()); + return createMerkleLL(campaignOwner, EXPIRATION); } function createMerkleLL(uint40 expiration) internal returns (ISablierMerkleLL) { @@ -154,16 +154,16 @@ contract Integration_Test is Base_Test { campaignOwner: campaignOwner, expiration: expiration, lockup: lockup, - merkleRoot: defaults.MERKLE_ROOT(), + merkleRoot: MERKLE_ROOT, token_: dai }), - defaults.AGGREGATE_AMOUNT(), - defaults.RECIPIENT_COUNT() + AGGREGATE_AMOUNT, + RECIPIENT_COUNT ); } function merkleLLConstructorParams() public view returns (MerkleLL.ConstructorParams memory) { - return merkleLLConstructorParams(users.campaignOwner, defaults.EXPIRATION()); + return merkleLLConstructorParams(users.campaignOwner, EXPIRATION); } function merkleLLConstructorParams( @@ -178,7 +178,7 @@ contract Integration_Test is Base_Test { campaignOwner: campaignOwner, expiration: expiration, lockup: lockup, - merkleRoot: defaults.MERKLE_ROOT(), + merkleRoot: MERKLE_ROOT, token_: dai }); } @@ -192,17 +192,17 @@ contract Integration_Test is Base_Test { campaignCreator: users.campaignOwner, campaignOwner: campaignOwner, expiration: expiration, - merkleRoot: defaults.MERKLE_ROOT(), + merkleRoot: MERKLE_ROOT, token_: dai }); } function createMerkleLT() internal returns (ISablierMerkleLT) { - return createMerkleLT(users.campaignOwner, defaults.EXPIRATION()); + return createMerkleLT(users.campaignOwner, EXPIRATION); } function createMerkleLT(address campaignOwner) internal returns (ISablierMerkleLT) { - return createMerkleLT(campaignOwner, defaults.EXPIRATION()); + return createMerkleLT(campaignOwner, EXPIRATION); } function createMerkleLT(uint40 expiration) internal returns (ISablierMerkleLT) { @@ -215,16 +215,16 @@ contract Integration_Test is Base_Test { campaignOwner: campaignOwner, expiration: expiration, lockup: lockup, - merkleRoot: defaults.MERKLE_ROOT(), + merkleRoot: MERKLE_ROOT, token_: dai }), - defaults.AGGREGATE_AMOUNT(), - defaults.RECIPIENT_COUNT() + AGGREGATE_AMOUNT, + RECIPIENT_COUNT ); } function merkleLTConstructorParams() public view returns (MerkleLT.ConstructorParams memory) { - return merkleLTConstructorParams(users.campaignOwner, defaults.EXPIRATION()); + return merkleLTConstructorParams(users.campaignOwner, EXPIRATION); } function merkleLTConstructorParams( @@ -239,7 +239,7 @@ contract Integration_Test is Base_Test { campaignOwner: campaignOwner, expiration: expiration, lockup: lockup, - merkleRoot: defaults.MERKLE_ROOT(), + merkleRoot: MERKLE_ROOT, token_: dai }); } @@ -253,18 +253,18 @@ contract Integration_Test is Base_Test { campaignCreator: users.campaignOwner, campaignOwner: campaignOwner, expiration: expiration, - merkleRoot: defaults.MERKLE_ROOT(), + merkleRoot: MERKLE_ROOT, token_: dai, vesting: defaults.merkleVCAVesting() }); } function createMerkleVCA() internal returns (ISablierMerkleVCA) { - return createMerkleVCA(users.campaignOwner, defaults.EXPIRATION()); + return createMerkleVCA(users.campaignOwner, EXPIRATION); } function createMerkleVCA(address campaignOwner) internal returns (ISablierMerkleVCA) { - return createMerkleVCA(campaignOwner, defaults.EXPIRATION()); + return createMerkleVCA(campaignOwner, EXPIRATION); } function createMerkleVCA(uint40 expiration) internal returns (ISablierMerkleVCA) { @@ -276,17 +276,17 @@ contract Integration_Test is Base_Test { defaults.merkleVCAConstructorParams({ campaignOwner: campaignOwner, expiration: expiration, - merkleRoot: defaults.MERKLE_ROOT(), + merkleRoot: MERKLE_ROOT, token_: dai, vesting: defaults.merkleVCAVesting() }), - defaults.AGGREGATE_AMOUNT(), - defaults.RECIPIENT_COUNT() + AGGREGATE_AMOUNT, + RECIPIENT_COUNT ); } function merkleVCAConstructorParams() public view returns (MerkleVCA.ConstructorParams memory) { - return merkleVCAConstructorParams(users.campaignOwner, defaults.EXPIRATION()); + return merkleVCAConstructorParams(users.campaignOwner, EXPIRATION); } function merkleVCAConstructorParams( @@ -300,7 +300,7 @@ contract Integration_Test is Base_Test { return defaults.merkleVCAConstructorParams({ campaignOwner: campaignOwner, expiration: expiration, - merkleRoot: defaults.MERKLE_ROOT(), + merkleRoot: MERKLE_ROOT, token_: dai, vesting: defaults.merkleVCAVesting() }); diff --git a/tests/integration/concrete/factory/collect-fees/collectFees.t.sol b/tests/integration/concrete/factory/collect-fees/collectFees.t.sol index 9eeba149..65557091 100644 --- a/tests/integration/concrete/factory/collect-fees/collectFees.t.sol +++ b/tests/integration/concrete/factory/collect-fees/collectFees.t.sol @@ -68,11 +68,7 @@ contract CollectFees_Integration_Test is Integration_Test { // It should emit a {CollectFees} event. vm.expectEmit({ emitter: address(merkleFactory) }); - emit ISablierMerkleFactory.CollectFees({ - admin: admin, - merkleBase: merkleBase, - feeAmount: defaults.MINIMUM_FEE() - }); + emit ISablierMerkleFactory.CollectFees({ admin: admin, merkleBase: merkleBase, feeAmount: MINIMUM_FEE }); // Make Alice the caller. resetPrank({ msgSender: users.eve }); @@ -83,6 +79,6 @@ contract CollectFees_Integration_Test is Integration_Test { assertEq(address(merkleBase).balance, 0, "merkle lockup ETH balance"); // It should transfer fee to the factory admin. - assertEq(admin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance"); + assertEq(admin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance"); } } diff --git a/tests/integration/concrete/factory/create-merkle-instant/createMerkleInstant.t.sol b/tests/integration/concrete/factory/create-merkle-instant/createMerkleInstant.t.sol index fd2f8150..1f7c4b58 100644 --- a/tests/integration/concrete/factory/create-merkle-instant/createMerkleInstant.t.sol +++ b/tests/integration/concrete/factory/create-merkle-instant/createMerkleInstant.t.sol @@ -12,12 +12,9 @@ contract CreateMerkleInstant_Integration_Test is Integration_Test { function test_RevertGiven_CampaignAlreadyExists() external { MerkleInstant.ConstructorParams memory params = merkleInstantConstructorParams(); - uint256 aggregateAmount = defaults.AGGREGATE_AMOUNT(); - uint256 recipientCount = defaults.RECIPIENT_COUNT(); - // Expect a revert due to CREATE2. vm.expectRevert(); - merkleFactory.createMerkleInstant(params, aggregateAmount, recipientCount); + merkleFactory.createMerkleInstant(params, AGGREGATE_AMOUNT, AGGREGATE_AMOUNT); } function test_GivenCustomFeeSet( @@ -40,8 +37,8 @@ contract CreateMerkleInstant_Integration_Test is Integration_Test { emit ISablierMerkleFactory.CreateMerkleInstant({ merkleInstant: ISablierMerkleInstant(expectedMerkleInstant), params: merkleInstantConstructorParams(campaignOwner, expiration), - aggregateAmount: defaults.AGGREGATE_AMOUNT(), - recipientCount: defaults.RECIPIENT_COUNT(), + aggregateAmount: AGGREGATE_AMOUNT, + recipientCount: RECIPIENT_COUNT, fee: customFee }); @@ -66,9 +63,9 @@ contract CreateMerkleInstant_Integration_Test is Integration_Test { emit ISablierMerkleFactory.CreateMerkleInstant({ merkleInstant: ISablierMerkleInstant(expectedMerkleInstant), params: merkleInstantConstructorParams(campaignOwner, expiration), - aggregateAmount: defaults.AGGREGATE_AMOUNT(), - recipientCount: defaults.RECIPIENT_COUNT(), - fee: defaults.MINIMUM_FEE() + aggregateAmount: AGGREGATE_AMOUNT, + recipientCount: RECIPIENT_COUNT, + fee: MINIMUM_FEE }); ISablierMerkleInstant actualInstant = createMerkleInstant(campaignOwner, expiration); @@ -78,7 +75,7 @@ contract CreateMerkleInstant_Integration_Test is Integration_Test { ); // It should create the campaign with custom fee. - assertEq(actualInstant.MINIMUM_FEE(), defaults.MINIMUM_FEE(), "minimum fee"); + assertEq(actualInstant.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee"); // It should set the current factory address. assertEq(actualInstant.FACTORY(), address(merkleFactory), "factory"); diff --git a/tests/integration/concrete/factory/create-merkle-ll/createMerkleLL.t.sol b/tests/integration/concrete/factory/create-merkle-ll/createMerkleLL.t.sol index 3466dd1c..5c5e056e 100644 --- a/tests/integration/concrete/factory/create-merkle-ll/createMerkleLL.t.sol +++ b/tests/integration/concrete/factory/create-merkle-ll/createMerkleLL.t.sol @@ -12,12 +12,9 @@ contract CreateMerkleLL_Integration_Test is Integration_Test { function test_RevertGiven_CampaignAlreadyExists() external { MerkleLL.ConstructorParams memory params = merkleLLConstructorParams(); - uint256 aggregateAmount = defaults.AGGREGATE_AMOUNT(); - uint256 recipientCount = defaults.RECIPIENT_COUNT(); - // Expect a revert due to CREATE2. vm.expectRevert(); - merkleFactory.createMerkleLL(params, aggregateAmount, recipientCount); + merkleFactory.createMerkleLL(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT); } function test_GivenCustomFeeSet( @@ -40,8 +37,8 @@ contract CreateMerkleLL_Integration_Test is Integration_Test { emit ISablierMerkleFactory.CreateMerkleLL({ merkleLL: ISablierMerkleLL(expectedLL), params: merkleLLConstructorParams(campaignOwner, expiration), - aggregateAmount: defaults.AGGREGATE_AMOUNT(), - recipientCount: defaults.RECIPIENT_COUNT(), + aggregateAmount: AGGREGATE_AMOUNT, + recipientCount: RECIPIENT_COUNT, fee: customFee }); @@ -64,9 +61,9 @@ contract CreateMerkleLL_Integration_Test is Integration_Test { emit ISablierMerkleFactory.CreateMerkleLL({ merkleLL: ISablierMerkleLL(expectedLL), params: merkleLLConstructorParams(campaignOwner, expiration), - aggregateAmount: defaults.AGGREGATE_AMOUNT(), - recipientCount: defaults.RECIPIENT_COUNT(), - fee: defaults.MINIMUM_FEE() + aggregateAmount: AGGREGATE_AMOUNT, + recipientCount: RECIPIENT_COUNT, + fee: MINIMUM_FEE }); ISablierMerkleLL actualLL = createMerkleLL(campaignOwner, expiration); @@ -74,10 +71,10 @@ contract CreateMerkleLL_Integration_Test is Integration_Test { assertEq(address(actualLL), expectedLL, "MerkleLL contract does not match computed address"); // It should set the correct shape. - assertEq(actualLL.shape(), defaults.SHAPE(), "shape"); + assertEq(actualLL.shape(), SHAPE, "shape"); // It should create the campaign with custom fee. - assertEq(actualLL.MINIMUM_FEE(), defaults.MINIMUM_FEE(), "minimum fee"); + assertEq(actualLL.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee"); // It should set the current factory address. assertEq(actualLL.FACTORY(), address(merkleFactory), "factory"); diff --git a/tests/integration/concrete/factory/create-merkle-lt/createMerkleLT.t.sol b/tests/integration/concrete/factory/create-merkle-lt/createMerkleLT.t.sol index c5f19f3d..5ac9e51d 100644 --- a/tests/integration/concrete/factory/create-merkle-lt/createMerkleLT.t.sol +++ b/tests/integration/concrete/factory/create-merkle-lt/createMerkleLT.t.sol @@ -11,12 +11,9 @@ contract CreateMerkleLT_Integration_Test is Integration_Test { /// @dev This test reverts because a default MerkleLT contract is deployed in {Integration_Test.setUp} function test_RevertGiven_CampaignAlreadyExists() external { MerkleLT.ConstructorParams memory params = merkleLTConstructorParams(); - uint256 aggregateAmount = defaults.AGGREGATE_AMOUNT(); - uint256 recipientCount = defaults.RECIPIENT_COUNT(); - // Expect a revert due to CREATE2. vm.expectRevert(); - merkleFactory.createMerkleLT(params, aggregateAmount, recipientCount); + merkleFactory.createMerkleLT(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT); } function test_GivenCustomFeeSet( @@ -39,9 +36,9 @@ contract CreateMerkleLT_Integration_Test is Integration_Test { emit ISablierMerkleFactory.CreateMerkleLT({ merkleLT: ISablierMerkleLT(expectedLT), params: merkleLTConstructorParams(campaignOwner, expiration), - aggregateAmount: defaults.AGGREGATE_AMOUNT(), - recipientCount: defaults.RECIPIENT_COUNT(), - totalDuration: defaults.TOTAL_DURATION(), + aggregateAmount: AGGREGATE_AMOUNT, + recipientCount: RECIPIENT_COUNT, + totalDuration: TOTAL_DURATION, fee: customFee }); @@ -62,10 +59,10 @@ contract CreateMerkleLT_Integration_Test is Integration_Test { emit ISablierMerkleFactory.CreateMerkleLT({ merkleLT: ISablierMerkleLT(expectedLT), params: merkleLTConstructorParams(campaignOwner, expiration), - aggregateAmount: defaults.AGGREGATE_AMOUNT(), - recipientCount: defaults.RECIPIENT_COUNT(), - totalDuration: defaults.TOTAL_DURATION(), - fee: defaults.MINIMUM_FEE() + aggregateAmount: AGGREGATE_AMOUNT, + recipientCount: RECIPIENT_COUNT, + totalDuration: TOTAL_DURATION, + fee: MINIMUM_FEE }); ISablierMerkleLT actualLT = createMerkleLT(campaignOwner, expiration); @@ -73,10 +70,10 @@ contract CreateMerkleLT_Integration_Test is Integration_Test { assertEq(address(actualLT), expectedLT, "MerkleLT contract does not match computed address"); // It should set the correct shape. - assertEq(actualLT.shape(), defaults.SHAPE(), "shape"); + assertEq(actualLT.shape(), SHAPE, "shape"); // It should create the campaign with custom fee. - assertEq(actualLT.MINIMUM_FEE(), defaults.MINIMUM_FEE(), "minimum fee"); + assertEq(actualLT.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee"); // It should set the current factory address. assertEq(actualLT.FACTORY(), address(merkleFactory), "factory"); } diff --git a/tests/integration/concrete/factory/create-merkle-vca/createMerkleVCA.t.sol b/tests/integration/concrete/factory/create-merkle-vca/createMerkleVCA.t.sol index 9f796fa3..9c97686f 100644 --- a/tests/integration/concrete/factory/create-merkle-vca/createMerkleVCA.t.sol +++ b/tests/integration/concrete/factory/create-merkle-vca/createMerkleVCA.t.sol @@ -11,16 +11,6 @@ import { Integration_Test } from "../../../Integration.t.sol"; /// @dev Some of the tests use `users.sender` as the campaign owner to avoid collision with the default MerkleVCA /// contract deployed in {Integration_Test.setUp}. contract CreateMerkleVCA_Integration_Test is Integration_Test { - uint256 internal aggregateAmount; - uint256 internal recipientCount; - - function setUp() public override { - Integration_Test.setUp(); - - aggregateAmount = defaults.AGGREGATE_AMOUNT(); - recipientCount = defaults.RECIPIENT_COUNT(); - } - /// @dev This test reverts because a default MerkleVCA contract is deployed in {Integration_Test.setUp} function test_RevertGiven_CampaignAlreadyExists() external { // This test fails @@ -30,8 +20,8 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test { vm.expectRevert(); merkleFactory.createMerkleVCA({ params: params, - aggregateAmount: aggregateAmount, - recipientCount: recipientCount + aggregateAmount: AGGREGATE_AMOUNT, + recipientCount: RECIPIENT_COUNT }); } @@ -43,8 +33,8 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test { vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleVCA_VestingTimeZero.selector, 0, params.vesting.end)); merkleFactory.createMerkleVCA({ params: params, - aggregateAmount: aggregateAmount, - recipientCount: recipientCount + aggregateAmount: AGGREGATE_AMOUNT, + recipientCount: RECIPIENT_COUNT }); } @@ -58,8 +48,8 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test { ); merkleFactory.createMerkleVCA({ params: params, - aggregateAmount: aggregateAmount, - recipientCount: recipientCount + aggregateAmount: AGGREGATE_AMOUNT, + recipientCount: RECIPIENT_COUNT }); } @@ -71,7 +61,7 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test { { MerkleVCA.ConstructorParams memory params = merkleVCAConstructorParams(); // Set the end time to be less than the start time. - params.vesting.end = defaults.RANGED_STREAM_START_TIME() - 1; + params.vesting.end = RANGED_STREAM_START_TIME - 1; // It should revert. vm.expectRevert( @@ -83,8 +73,8 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test { ); merkleFactory.createMerkleVCA({ params: params, - aggregateAmount: aggregateAmount, - recipientCount: recipientCount + aggregateAmount: AGGREGATE_AMOUNT, + recipientCount: RECIPIENT_COUNT }); } @@ -102,15 +92,15 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test { emit ISablierMerkleFactory.CreateMerkleVCA({ merkleVCA: ISablierMerkleVCA(address(expectedMerkleVCA)), params: merkleVCAConstructorParams({ campaignOwner: users.sender, expiration: 0 }), - aggregateAmount: defaults.AGGREGATE_AMOUNT(), - recipientCount: defaults.RECIPIENT_COUNT(), - fee: defaults.MINIMUM_FEE() + aggregateAmount: AGGREGATE_AMOUNT, + recipientCount: RECIPIENT_COUNT, + fee: MINIMUM_FEE }); ISablierMerkleVCA actualVCA = createMerkleVCA({ campaignOwner: users.sender, expiration: 0 }); // It should create the campaign with custom fee. - assertEq(actualVCA.MINIMUM_FEE(), defaults.MINIMUM_FEE(), "minimum fee"); + assertEq(actualVCA.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee"); // It should set the current factory address. assertEq(actualVCA.FACTORY(), address(merkleFactory), "factory"); @@ -119,8 +109,8 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test { assertEq(actualVCA.EXPIRATION(), 0, "expiration"); // It should set return the correct vesting schedule. - assertEq(actualVCA.vestingSchedule().start, defaults.RANGED_STREAM_START_TIME(), "vesting start"); - assertEq(actualVCA.vestingSchedule().end, defaults.RANGED_STREAM_END_TIME(), "vesting end"); + assertEq(actualVCA.vestingSchedule().start, RANGED_STREAM_START_TIME, "vesting start"); + assertEq(actualVCA.vestingSchedule().end, RANGED_STREAM_END_TIME, "vesting end"); } function test_RevertWhen_ExpiryNotExceedOneWeekFromEndTime() @@ -132,7 +122,7 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test { whenNotZeroExpiry { MerkleVCA.ConstructorParams memory params = merkleVCAConstructorParams(); - params.expiration = defaults.RANGED_STREAM_END_TIME() + 1 weeks - 1; + params.expiration = RANGED_STREAM_END_TIME + 1 weeks - 1; // It should revert. vm.expectRevert( @@ -140,7 +130,7 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test { Errors.SablierMerkleVCA_ExpiryWithinOneWeekOfVestingEnd.selector, params.vesting.end, params.expiration ) ); - merkleFactory.createMerkleVCA(params, aggregateAmount, recipientCount); + merkleFactory.createMerkleVCA(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT); } function test_GivenCustomFeeSet() @@ -157,21 +147,19 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test { merkleFactory.setCustomFee(users.campaignOwner, 0); resetPrank(users.campaignOwner); - address expectedMerkleVCA = - computeMerkleVCAAddress({ campaignOwner: users.sender, expiration: defaults.EXPIRATION() }); + address expectedMerkleVCA = computeMerkleVCAAddress({ campaignOwner: users.sender, expiration: EXPIRATION }); // It should emit a {CreateMerkleVCA} event. vm.expectEmit(address(merkleFactory)); emit ISablierMerkleFactory.CreateMerkleVCA({ merkleVCA: ISablierMerkleVCA(address(expectedMerkleVCA)), - params: merkleVCAConstructorParams({ campaignOwner: users.sender, expiration: defaults.EXPIRATION() }), - aggregateAmount: defaults.AGGREGATE_AMOUNT(), - recipientCount: defaults.RECIPIENT_COUNT(), + params: merkleVCAConstructorParams({ campaignOwner: users.sender, expiration: EXPIRATION }), + aggregateAmount: AGGREGATE_AMOUNT, + recipientCount: RECIPIENT_COUNT, fee: 0 }); - ISablierMerkleVCA actualVCA = - createMerkleVCA({ campaignOwner: users.sender, expiration: defaults.EXPIRATION() }); + ISablierMerkleVCA actualVCA = createMerkleVCA({ campaignOwner: users.sender, expiration: EXPIRATION }); assertGt(address(actualVCA).code.length, 0, "MerkleVCA contract not created"); assertEq(address(actualVCA), expectedMerkleVCA, "MerkleVCA contract does not match computed address"); @@ -182,8 +170,8 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test { assertEq(actualVCA.FACTORY(), address(merkleFactory), "factory"); // It should set return the correct vesting schedule. - assertEq(actualVCA.vestingSchedule().start, defaults.RANGED_STREAM_START_TIME(), "vesting start"); - assertEq(actualVCA.vestingSchedule().end, defaults.RANGED_STREAM_END_TIME(), "vesting end"); + assertEq(actualVCA.vestingSchedule().start, RANGED_STREAM_START_TIME, "vesting start"); + assertEq(actualVCA.vestingSchedule().end, RANGED_STREAM_END_TIME, "vesting end"); } function test_GivenCustomFeeNotSet() @@ -195,32 +183,30 @@ contract CreateMerkleVCA_Integration_Test is Integration_Test { whenNotZeroExpiry whenExpiryNotExceedOneWeekFromEndTime { - address expectedMerkleVCA = - computeMerkleVCAAddress({ campaignOwner: users.sender, expiration: defaults.EXPIRATION() }); + address expectedMerkleVCA = computeMerkleVCAAddress({ campaignOwner: users.sender, expiration: EXPIRATION }); // It should emit a {CreateMerkleVCA} event. vm.expectEmit(address(merkleFactory)); emit ISablierMerkleFactory.CreateMerkleVCA({ merkleVCA: ISablierMerkleVCA(address(expectedMerkleVCA)), - params: merkleVCAConstructorParams({ campaignOwner: users.sender, expiration: defaults.EXPIRATION() }), - aggregateAmount: defaults.AGGREGATE_AMOUNT(), - recipientCount: defaults.RECIPIENT_COUNT(), - fee: defaults.MINIMUM_FEE() + params: merkleVCAConstructorParams({ campaignOwner: users.sender, expiration: EXPIRATION }), + aggregateAmount: AGGREGATE_AMOUNT, + recipientCount: RECIPIENT_COUNT, + fee: MINIMUM_FEE }); - ISablierMerkleVCA actualVCA = - createMerkleVCA({ campaignOwner: users.sender, expiration: defaults.EXPIRATION() }); + ISablierMerkleVCA actualVCA = createMerkleVCA({ campaignOwner: users.sender, expiration: EXPIRATION }); assertGt(address(actualVCA).code.length, 0, "MerkleVCA contract not created"); assertEq(address(actualVCA), expectedMerkleVCA, "MerkleVCA contract does not match computed address"); // It should create the campaign with custom fee. - assertEq(actualVCA.MINIMUM_FEE(), defaults.MINIMUM_FEE(), "minimum fee"); + assertEq(actualVCA.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee"); // It should set the current factory address. assertEq(actualVCA.FACTORY(), address(merkleFactory), "factory"); // It should set return the correct vesting schedule. - assertEq(actualVCA.vestingSchedule().start, defaults.RANGED_STREAM_START_TIME(), "vesting start"); - assertEq(actualVCA.vestingSchedule().end, defaults.RANGED_STREAM_END_TIME(), "vesting end"); + assertEq(actualVCA.vestingSchedule().start, RANGED_STREAM_START_TIME, "vesting start"); + assertEq(actualVCA.vestingSchedule().end, RANGED_STREAM_END_TIME, "vesting end"); } } diff --git a/tests/integration/concrete/factory/get-fee/getFee.t.sol b/tests/integration/concrete/factory/get-fee/getFee.t.sol index 57bea1fb..ea6b2489 100644 --- a/tests/integration/concrete/factory/get-fee/getFee.t.sol +++ b/tests/integration/concrete/factory/get-fee/getFee.t.sol @@ -6,7 +6,7 @@ import { Integration_Test } from "../../../Integration.t.sol"; contract GetFee_Integration_Test is Integration_Test { function test_GivenCustomFeeNotSet() external view { // It should return minimum fee. - assertEq(merkleFactory.getFee(users.campaignOwner), defaults.MINIMUM_FEE(), "minimum fee"); + assertEq(merkleFactory.getFee(users.campaignOwner), MINIMUM_FEE, "minimum fee"); } function test_GivenCustomFeeSet() external { diff --git a/tests/integration/concrete/factory/set-minimum-fee/setMinimumFee.t.sol b/tests/integration/concrete/factory/set-minimum-fee/setMinimumFee.t.sol index 5efc9fdf..38540d89 100644 --- a/tests/integration/concrete/factory/set-minimum-fee/setMinimumFee.t.sol +++ b/tests/integration/concrete/factory/set-minimum-fee/setMinimumFee.t.sol @@ -7,10 +7,9 @@ import { Integration_Test } from "./../../../Integration.t.sol"; contract SetMinimumFee_Integration_Test is Integration_Test { function test_RevertWhen_CallerNotAdmin() external { - uint256 minimumFee = defaults.MINIMUM_FEE(); resetPrank({ msgSender: users.eve }); vm.expectRevert(abi.encodeWithSelector(Errors.CallerNotAdmin.selector, users.admin, users.eve)); - merkleFactory.setMinimumFee({ minimumFee: minimumFee }); + merkleFactory.setMinimumFee({ minimumFee: MINIMUM_FEE }); } function test_WhenCallerAdmin() external { @@ -18,11 +17,11 @@ contract SetMinimumFee_Integration_Test is Integration_Test { // It should emit a {SetMinimumFee} event. vm.expectEmit({ emitter: address(merkleFactory) }); - emit ISablierMerkleFactory.SetMinimumFee({ admin: users.admin, minimumFee: defaults.MINIMUM_FEE() }); + emit ISablierMerkleFactory.SetMinimumFee({ admin: users.admin, minimumFee: MINIMUM_FEE }); - merkleFactory.setMinimumFee({ minimumFee: defaults.MINIMUM_FEE() }); + merkleFactory.setMinimumFee({ minimumFee: MINIMUM_FEE }); // It should set the minimum fee. - assertEq(merkleFactory.minimumFee(), defaults.MINIMUM_FEE(), "minimum fee"); + assertEq(merkleFactory.minimumFee(), MINIMUM_FEE, "minimum fee"); } } diff --git a/tests/integration/concrete/instant/claim/claim.t.sol b/tests/integration/concrete/instant/claim/claim.t.sol index 176e5c51..7f1b5503 100644 --- a/tests/integration/concrete/instant/claim/claim.t.sol +++ b/tests/integration/concrete/instant/claim/claim.t.sol @@ -24,14 +24,14 @@ contract Claim_MerkleInstant_Integration_Test is Claim_Integration_Test, MerkleI uint256 previousFeeAccrued = address(merkleInstant).balance; vm.expectEmit({ emitter: address(merkleInstant) }); - emit ISablierMerkleInstant.Claim(defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT()); + emit ISablierMerkleInstant.Claim(INDEX1, users.recipient1, CLAIM_AMOUNT); - expectCallToTransfer({ to: users.recipient1, value: defaults.CLAIM_AMOUNT() }); - expectCallToClaimWithMsgValue(address(merkleInstant), defaults.MINIMUM_FEE()); + expectCallToTransfer({ to: users.recipient1, value: CLAIM_AMOUNT }); + expectCallToClaimWithMsgValue(address(merkleInstant), MINIMUM_FEE); claim(); - assertTrue(merkleInstant.hasClaimed(defaults.INDEX1()), "not claimed"); + assertTrue(merkleInstant.hasClaimed(INDEX1), "not claimed"); - assertEq(address(merkleInstant).balance, previousFeeAccrued + defaults.MINIMUM_FEE(), "fee collected"); + assertEq(address(merkleInstant).balance, previousFeeAccrued + MINIMUM_FEE, "fee collected"); } } diff --git a/tests/integration/concrete/instant/constructor.t.sol b/tests/integration/concrete/instant/constructor.t.sol index 6b000623..fb274a2e 100644 --- a/tests/integration/concrete/instant/constructor.t.sol +++ b/tests/integration/concrete/instant/constructor.t.sol @@ -14,12 +14,12 @@ contract Constructor_MerkleInstant_Integration_Test is Integration_Test { new SablierMerkleInstant(merkleInstantConstructorParams(), users.campaignOwner); assertEq(constructedInstant.admin(), users.campaignOwner, "admin"); - assertEq(constructedInstant.campaignName(), defaults.CAMPAIGN_NAME(), "campaign name"); - assertEq(constructedInstant.EXPIRATION(), defaults.EXPIRATION(), "expiration"); + assertEq(constructedInstant.campaignName(), CAMPAIGN_NAME, "campaign name"); + assertEq(constructedInstant.EXPIRATION(), EXPIRATION, "expiration"); assertEq(constructedInstant.FACTORY(), address(merkleFactory), "factory"); - assertEq(constructedInstant.MINIMUM_FEE(), defaults.MINIMUM_FEE(), "minimum fee"); - assertEq(constructedInstant.ipfsCID(), defaults.IPFS_CID(), "ipfsCID"); - assertEq(constructedInstant.MERKLE_ROOT(), defaults.MERKLE_ROOT(), "merkleRoot"); + assertEq(constructedInstant.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee"); + assertEq(constructedInstant.ipfsCID(), IPFS_CID, "ipfsCID"); + assertEq(constructedInstant.MERKLE_ROOT(), MERKLE_ROOT, "merkleRoot"); assertEq(address(constructedInstant.TOKEN()), address(dai), "token"); } } diff --git a/tests/integration/concrete/ll/claim/claim.t.sol b/tests/integration/concrete/ll/claim/claim.t.sol index 2f1ad75d..1a35a7f3 100644 --- a/tests/integration/concrete/ll/claim/claim.t.sol +++ b/tests/integration/concrete/ll/claim/claim.t.sol @@ -17,36 +17,31 @@ contract Claim_MerkleLL_Integration_Test is Claim_Integration_Test, MerkleLL_Int } function test_RevertWhen_TotalPercentageGreaterThan100() external whenMerkleProofValid { - uint256 fee = defaults.MINIMUM_FEE(); - MerkleLL.ConstructorParams memory params = merkleLLConstructorParams(); // Crate a MerkleLL campaign with a total percentage greater than 100. params.schedule.startPercentage = ud2x18(0.5e18); params.schedule.cliffPercentage = ud2x18(0.6e18); - merkleLL = merkleFactory.createMerkleLL(params, defaults.AGGREGATE_AMOUNT(), defaults.RECIPIENT_COUNT()); - - uint128 depositAmount = defaults.CLAIM_AMOUNT(); - uint128 startUnlockAmount = ud60x18(depositAmount).mul(ud60x18(0.5e18)).intoUint128(); - uint128 cliffUnlockAmount = ud60x18(depositAmount).mul(ud60x18(0.6e18)).intoUint128(); - bytes32[] memory merkleProof = defaults.index1Proof(); + merkleLL = merkleFactory.createMerkleLL(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT); + uint128 startUnlockAmount = ud60x18(CLAIM_AMOUNT).mul(ud60x18(0.5e18)).intoUint128(); + uint128 cliffUnlockAmount = ud60x18(CLAIM_AMOUNT).mul(ud60x18(0.6e18)).intoUint128(); vm.expectRevert( abi.encodeWithSelector( LockupErrors.SablierHelpers_UnlockAmountsSumTooHigh.selector, - depositAmount, + CLAIM_AMOUNT, startUnlockAmount, cliffUnlockAmount ) ); // Claim the airdrop. - merkleLL.claim{ value: fee }({ + merkleLL.claim{ value: MINIMUM_FEE }({ index: 1, recipient: users.recipient1, - amount: depositAmount, - merkleProof: merkleProof + amount: CLAIM_AMOUNT, + merkleProof: index1Proof() }); } @@ -60,7 +55,7 @@ contract Claim_MerkleLL_Integration_Test is Claim_Integration_Test, MerkleLL_Int params.schedule.cliffDuration = 0; params.schedule.cliffPercentage = ud2x18(0); - merkleLL = merkleFactory.createMerkleLL(params, defaults.AGGREGATE_AMOUNT(), defaults.RECIPIENT_COUNT()); + merkleLL = merkleFactory.createMerkleLL(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT); // It should create a stream with block.timestamp as start time. // It should create a stream with cliff as zero. @@ -75,62 +70,56 @@ contract Claim_MerkleLL_Integration_Test is Claim_Integration_Test, MerkleLL_Int { // It should create a stream with block.timestamp as start time. // It should create a stream with cliff as start time + cliff duration. - _test_Claim({ startTime: getBlockTimestamp(), cliffTime: getBlockTimestamp() + defaults.CLIFF_DURATION() }); + _test_Claim({ startTime: getBlockTimestamp(), cliffTime: getBlockTimestamp() + CLIFF_DURATION }); } function test_WhenScheduledStartTimeNotZero() external whenMerkleProofValid whenTotalPercentageNotGreaterThan100 { MerkleLL.ConstructorParams memory params = merkleLLConstructorParams(); - params.schedule.startTime = defaults.RANGED_STREAM_START_TIME(); + params.schedule.startTime = RANGED_STREAM_START_TIME; - merkleLL = merkleFactory.createMerkleLL(params, defaults.AGGREGATE_AMOUNT(), defaults.RECIPIENT_COUNT()); + merkleLL = merkleFactory.createMerkleLL(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT); // It should create a stream with scheduled start time as start time. - _test_Claim({ - startTime: defaults.RANGED_STREAM_START_TIME(), - cliffTime: defaults.RANGED_STREAM_START_TIME() + defaults.CLIFF_DURATION() - }); + _test_Claim({ startTime: RANGED_STREAM_START_TIME, cliffTime: RANGED_STREAM_START_TIME + CLIFF_DURATION }); } /// @dev Helper function to test claim. function _test_Claim(uint40 startTime, uint40 cliffTime) private { - uint256 fee = defaults.MINIMUM_FEE(); - deal({ token: address(dai), to: address(merkleLL), give: defaults.AGGREGATE_AMOUNT() }); + deal({ token: address(dai), to: address(merkleLL), give: AGGREGATE_AMOUNT }); uint256 expectedStreamId = lockup.nextStreamId(); uint256 previousFeeAccrued = address(merkleLL).balance; // It should emit a {Claim} event. vm.expectEmit({ emitter: address(merkleLL) }); - emit ISablierMerkleLockup.Claim(defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT(), expectedStreamId); + emit ISablierMerkleLockup.Claim(INDEX1, users.recipient1, CLAIM_AMOUNT, expectedStreamId); - expectCallToTransferFrom({ from: address(merkleLL), to: address(lockup), value: defaults.CLAIM_AMOUNT() }); - expectCallToClaimWithMsgValue(address(merkleLL), fee); + expectCallToTransferFrom({ from: address(merkleLL), to: address(lockup), value: CLAIM_AMOUNT }); + expectCallToClaimWithMsgValue(address(merkleLL), MINIMUM_FEE); // Claim the airstream. - merkleLL.claim{ value: fee }( - defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT(), defaults.index1Proof() - ); + merkleLL.claim{ value: MINIMUM_FEE }(INDEX1, users.recipient1, CLAIM_AMOUNT, index1Proof()); - uint128 expectedCliffAmount = cliffTime > 0 ? defaults.CLIFF_AMOUNT() : 0; + uint128 expectedCliffAmount = cliffTime > 0 ? CLIFF_AMOUNT : 0; // Assert that the stream has been created successfully. assertEq(lockup.getCliffTime(expectedStreamId), cliffTime, "cliff time"); - assertEq(lockup.getDepositedAmount(expectedStreamId), defaults.CLAIM_AMOUNT(), "depositedAmount"); - assertEq(lockup.getEndTime(expectedStreamId), startTime + defaults.TOTAL_DURATION(), "end time"); + assertEq(lockup.getDepositedAmount(expectedStreamId), CLAIM_AMOUNT, "depositedAmount"); + assertEq(lockup.getEndTime(expectedStreamId), startTime + TOTAL_DURATION, "end time"); assertEq(lockup.getRecipient(expectedStreamId), users.recipient1, "recipient"); assertEq(lockup.getSender(expectedStreamId), users.campaignOwner, "sender"); assertEq(lockup.getStartTime(expectedStreamId), startTime, "start time"); assertEq(lockup.getUnderlyingToken(expectedStreamId), dai, "token"); assertEq(lockup.getUnlockAmounts(expectedStreamId).cliff, expectedCliffAmount, "unlock amount cliff"); - assertEq(lockup.getUnlockAmounts(expectedStreamId).start, defaults.START_AMOUNT(), "unlock amount start"); - assertEq(lockup.isCancelable(expectedStreamId), defaults.CANCELABLE(), "is cancelable"); + assertEq(lockup.getUnlockAmounts(expectedStreamId).start, START_AMOUNT, "unlock amount start"); + assertEq(lockup.isCancelable(expectedStreamId), CANCELABLE, "is cancelable"); assertEq(lockup.isDepleted(expectedStreamId), false, "is depleted"); assertEq(lockup.isStream(expectedStreamId), true, "is stream"); - assertEq(lockup.isTransferable(expectedStreamId), defaults.TRANSFERABLE(), "is transferable"); + assertEq(lockup.isTransferable(expectedStreamId), TRANSFERABLE, "is transferable"); assertEq(lockup.wasCanceled(expectedStreamId), false, "was canceled"); - assertTrue(merkleLL.hasClaimed(defaults.INDEX1()), "not claimed"); + assertTrue(merkleLL.hasClaimed(INDEX1), "not claimed"); - assertEq(address(merkleLL).balance, previousFeeAccrued + defaults.MINIMUM_FEE(), "fee collected"); + assertEq(address(merkleLL).balance, previousFeeAccrued + MINIMUM_FEE, "fee collected"); } } diff --git a/tests/integration/concrete/ll/constructor.t.sol b/tests/integration/concrete/ll/constructor.t.sol index d735b9cf..0e0c82ec 100644 --- a/tests/integration/concrete/ll/constructor.t.sol +++ b/tests/integration/concrete/ll/constructor.t.sol @@ -7,98 +7,33 @@ import { MerkleLL } from "src/types/DataTypes.sol"; import { Integration_Test } from "../../Integration.t.sol"; contract Constructor_MerkleLL_Integration_Test is Integration_Test { - /// @dev Needed to prevent "Stack too deep" error - struct Vars { - address actualAdmin; - uint256 actualAllowance; - string actualCampaignName; - uint40 actualExpiration; - address actualFactory; - uint256 actualFee; - string actualIpfsCID; - address actualLockup; - bytes32 actualMerkleRoot; - MerkleLL.Schedule actualSchedule; - bool actualStreamCancelable; - bool actualStreamTransferable; - address actualToken; - address expectedAdmin; - uint256 expectedAllowance; - string expectedCampaignName; - uint40 expectedExpiration; - address expectedFactory; - uint256 expectedFee; - string expectedIpfsCID; - address expectedLockup; - bytes32 expectedMerkleRoot; - bool expectedStreamCancelable; - bool expectedStreamTransferable; - address expectedToken; - } - function test_Constructor() external { // Make Factory the caller for the constructor test. resetPrank(address(merkleFactory)); SablierMerkleLL constructedLL = new SablierMerkleLL(merkleLLConstructorParams(), users.campaignOwner); - Vars memory vars; - - vars.actualAdmin = constructedLL.admin(); - vars.expectedAdmin = users.campaignOwner; - assertEq(vars.actualAdmin, vars.expectedAdmin, "admin"); - - vars.actualAllowance = dai.allowance(address(constructedLL), address(lockup)); - vars.expectedAllowance = MAX_UINT256; - assertEq(vars.actualAllowance, vars.expectedAllowance, "allowance"); - - vars.actualCampaignName = constructedLL.campaignName(); - vars.expectedCampaignName = defaults.CAMPAIGN_NAME(); - assertEq(vars.actualCampaignName, vars.expectedCampaignName, "campaign name"); - - vars.actualExpiration = constructedLL.EXPIRATION(); - vars.expectedExpiration = defaults.EXPIRATION(); - assertEq(vars.actualExpiration, vars.expectedExpiration, "expiration"); - - vars.actualFactory = constructedLL.FACTORY(); - vars.expectedFactory = address(merkleFactory); - assertEq(vars.actualFactory, vars.expectedFactory, "factory"); - - vars.actualFee = constructedLL.MINIMUM_FEE(); - vars.expectedFee = defaults.MINIMUM_FEE(); - assertEq(vars.actualFee, vars.expectedFee, "minimum fee"); - - vars.actualIpfsCID = constructedLL.ipfsCID(); - vars.expectedIpfsCID = defaults.IPFS_CID(); - assertEq(vars.actualIpfsCID, vars.expectedIpfsCID, "ipfsCID"); - - vars.actualLockup = address(constructedLL.LOCKUP()); - vars.expectedLockup = address(lockup); - assertEq(vars.actualLockup, vars.expectedLockup, "lockup"); - - vars.actualMerkleRoot = constructedLL.MERKLE_ROOT(); - vars.expectedMerkleRoot = defaults.MERKLE_ROOT(); - assertEq(vars.actualMerkleRoot, vars.expectedMerkleRoot, "merkleRoot"); - - vars.actualSchedule = constructedLL.getSchedule(); - assertEq(vars.actualSchedule.startTime, ZERO, "schedule.startTime"); - assertEq(vars.actualSchedule.startPercentage, defaults.START_PERCENTAGE(), "schedule.startPercentage"); - assertEq(vars.actualSchedule.cliffDuration, defaults.CLIFF_DURATION(), "schedule.cliffDuration"); - assertEq(vars.actualSchedule.cliffPercentage, defaults.CLIFF_PERCENTAGE(), "schedule.cliffPercentage"); - assertEq(vars.actualSchedule.totalDuration, defaults.TOTAL_DURATION(), "schedule.totalDuration"); - - assertEq(constructedLL.shape(), defaults.SHAPE(), "shape"); - - vars.actualStreamCancelable = constructedLL.STREAM_CANCELABLE(); - vars.expectedStreamCancelable = defaults.CANCELABLE(); - assertEq(vars.actualStreamCancelable, vars.expectedStreamCancelable, "stream cancelable"); - - vars.actualStreamTransferable = constructedLL.STREAM_TRANSFERABLE(); - vars.expectedStreamTransferable = defaults.TRANSFERABLE(); - assertEq(vars.actualStreamTransferable, vars.expectedStreamTransferable, "stream transferable"); - - vars.actualToken = address(constructedLL.TOKEN()); - vars.expectedToken = address(dai); - assertEq(vars.actualToken, vars.expectedToken, "token"); + uint256 actualAllowance = dai.allowance(address(constructedLL), address(lockup)); + assertEq(actualAllowance, MAX_UINT256, "allowance"); + + assertEq(constructedLL.admin(), users.campaignOwner, "admin"); + assertEq(constructedLL.campaignName(), CAMPAIGN_NAME, "campaign name"); + assertEq(constructedLL.EXPIRATION(), EXPIRATION, "expiration"); + assertEq(constructedLL.FACTORY(), address(merkleFactory), "factory"); + assertEq(constructedLL.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee"); + assertEq(constructedLL.ipfsCID(), IPFS_CID, "ipfsCID"); + assertEq(address(constructedLL.LOCKUP()), address(lockup), "lockup"); + assertEq(constructedLL.MERKLE_ROOT(), MERKLE_ROOT, "merkleRoot"); + assertEq(constructedLL.shape(), SHAPE, "shape"); + assertEq(constructedLL.STREAM_CANCELABLE(), CANCELABLE, "stream cancelable"); + assertEq(constructedLL.STREAM_TRANSFERABLE(), TRANSFERABLE, "stream transferable"); + assertEq(address(constructedLL.TOKEN()), address(dai), "token"); + + MerkleLL.Schedule memory actualSchedule = constructedLL.getSchedule(); + assertEq(actualSchedule.startTime, ZERO, "schedule.startTime"); + assertEq(actualSchedule.startPercentage, START_PERCENTAGE, "schedule.startPercentage"); + assertEq(actualSchedule.cliffDuration, CLIFF_DURATION, "schedule.cliffDuration"); + assertEq(actualSchedule.cliffPercentage, CLIFF_PERCENTAGE, "schedule.cliffPercentage"); + assertEq(actualSchedule.totalDuration, TOTAL_DURATION, "schedule.totalDuration"); } } diff --git a/tests/integration/concrete/lt/claim/claim.t.sol b/tests/integration/concrete/lt/claim/claim.t.sol index 7ca3db8f..56469299 100644 --- a/tests/integration/concrete/lt/claim/claim.t.sol +++ b/tests/integration/concrete/lt/claim/claim.t.sol @@ -16,50 +16,40 @@ contract Claim_MerkleLT_Integration_Test is Claim_Integration_Test, MerkleLT_Int } function test_RevertWhen_TotalPercentageLessThan100() external whenMerkleProofValid whenTotalPercentageNot100 { - uint256 fee = defaults.MINIMUM_FEE(); - MerkleLT.ConstructorParams memory params = merkleLTConstructorParams(); // Create a MerkleLT campaign with a total percentage less than 100. params.tranchesWithPercentages[0].unlockPercentage = ud2x18(0.05e18); params.tranchesWithPercentages[1].unlockPercentage = ud2x18(0.2e18); - merkleLT = merkleFactory.createMerkleLT(params, defaults.AGGREGATE_AMOUNT(), defaults.RECIPIENT_COUNT()); - - // Claim the airdrop. - bytes32[] memory merkleProof = defaults.index1Proof(); + merkleLT = merkleFactory.createMerkleLT(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT); vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleLT_TotalPercentageNotOneHundred.selector, 0.25e18)); - merkleLT.claim{ value: fee }({ + merkleLT.claim{ value: MINIMUM_FEE }({ index: 1, recipient: users.recipient1, amount: 10_000e18, - merkleProof: merkleProof + merkleProof: index1Proof() }); } function test_RevertWhen_TotalPercentageGreaterThan100() external whenMerkleProofValid whenTotalPercentageNot100 { - uint256 fee = defaults.MINIMUM_FEE(); - MerkleLT.ConstructorParams memory params = merkleLTConstructorParams(); // Create a MerkleLT campaign with a total percentage less than 100. params.tranchesWithPercentages[0].unlockPercentage = ud2x18(0.75e18); params.tranchesWithPercentages[1].unlockPercentage = ud2x18(0.8e18); - merkleLT = merkleFactory.createMerkleLT(params, defaults.AGGREGATE_AMOUNT(), defaults.RECIPIENT_COUNT()); - - // Claim the airdrop. - bytes32[] memory merkleProof = defaults.index1Proof(); + merkleLT = merkleFactory.createMerkleLT(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT); vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleLT_TotalPercentageNotOneHundred.selector, 1.55e18)); - merkleLT.claim{ value: fee }({ + merkleLT.claim{ value: MINIMUM_FEE }({ index: 1, recipient: users.recipient1, amount: 10_000e18, - merkleProof: merkleProof + merkleProof: index1Proof() }); } @@ -70,58 +60,51 @@ contract Claim_MerkleLT_Integration_Test is Claim_Integration_Test, MerkleLT_Int function test_WhenStreamStartTimeNotZero() external whenMerkleProofValid whenTotalPercentage100 { MerkleLT.ConstructorParams memory params = merkleLTConstructorParams(); - params.streamStartTime = defaults.RANGED_STREAM_START_TIME(); + params.streamStartTime = RANGED_STREAM_START_TIME; - merkleLT = merkleFactory.createMerkleLT(params, defaults.AGGREGATE_AMOUNT(), defaults.RECIPIENT_COUNT()); + merkleLT = merkleFactory.createMerkleLT(params, AGGREGATE_AMOUNT, RECIPIENT_COUNT); // It should create a stream with `STREAM_START_TIME` as start time. - _test_Claim({ - streamStartTime: defaults.RANGED_STREAM_START_TIME(), - startTime: defaults.RANGED_STREAM_START_TIME() - }); + _test_Claim({ streamStartTime: RANGED_STREAM_START_TIME, startTime: RANGED_STREAM_START_TIME }); } /// @dev Helper function to test claim. function _test_Claim(uint40 streamStartTime, uint40 startTime) private { - uint256 fee = defaults.MINIMUM_FEE(); - - deal({ token: address(dai), to: address(merkleLT), give: defaults.AGGREGATE_AMOUNT() }); + deal({ token: address(dai), to: address(merkleLT), give: AGGREGATE_AMOUNT }); uint256 expectedStreamId = lockup.nextStreamId(); uint256 previousFeeAccrued = address(merkleLL).balance; // It should emit a {Claim} event. vm.expectEmit({ emitter: address(merkleLT) }); - emit ISablierMerkleLockup.Claim(defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT(), expectedStreamId); + emit ISablierMerkleLockup.Claim(INDEX1, users.recipient1, CLAIM_AMOUNT, expectedStreamId); - expectCallToTransferFrom({ from: address(merkleLT), to: address(lockup), value: defaults.CLAIM_AMOUNT() }); - expectCallToClaimWithMsgValue(address(merkleLT), fee); + expectCallToTransferFrom({ from: address(merkleLT), to: address(lockup), value: CLAIM_AMOUNT }); + expectCallToClaimWithMsgValue(address(merkleLT), MINIMUM_FEE); // Claim the airstream. - merkleLT.claim{ value: fee }( - defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT(), defaults.index1Proof() - ); + merkleLT.claim{ value: MINIMUM_FEE }(INDEX1, users.recipient1, CLAIM_AMOUNT, index1Proof()); // Assert that the stream has been created successfully. - assertEq(lockup.getDepositedAmount(expectedStreamId), defaults.CLAIM_AMOUNT(), "depositedAmount"); - assertEq(lockup.getEndTime(expectedStreamId), startTime + defaults.TOTAL_DURATION(), "end time"); + assertEq(lockup.getDepositedAmount(expectedStreamId), CLAIM_AMOUNT, "depositedAmount"); + assertEq(lockup.getEndTime(expectedStreamId), startTime + TOTAL_DURATION, "end time"); assertEq(lockup.getRecipient(expectedStreamId), users.recipient1, "recipient"); assertEq(lockup.getSender(expectedStreamId), users.campaignOwner, "sender"); assertEq(lockup.getStartTime(expectedStreamId), startTime, "start time"); // It should create a stream with `STREAM_START_TIME` as start time. assertEq( lockup.getTranches(expectedStreamId), - defaults.tranchesMerkleLT({ streamStartTime: streamStartTime, totalAmount: defaults.CLAIM_AMOUNT() }) + defaults.tranchesMerkleLT({ streamStartTime: streamStartTime, totalAmount: CLAIM_AMOUNT }) ); assertEq(lockup.getUnderlyingToken(expectedStreamId), dai, "token"); - assertEq(lockup.isCancelable(expectedStreamId), defaults.CANCELABLE(), "is cancelable"); + assertEq(lockup.isCancelable(expectedStreamId), CANCELABLE, "is cancelable"); assertEq(lockup.isDepleted(expectedStreamId), false, "is depleted"); assertEq(lockup.isStream(expectedStreamId), true, "is stream"); - assertEq(lockup.isTransferable(expectedStreamId), defaults.TRANSFERABLE(), "is transferable"); + assertEq(lockup.isTransferable(expectedStreamId), TRANSFERABLE, "is transferable"); assertEq(lockup.wasCanceled(expectedStreamId), false, "was canceled"); - assertTrue(merkleLT.hasClaimed(defaults.INDEX1()), "not claimed"); + assertTrue(merkleLT.hasClaimed(INDEX1), "not claimed"); - assertEq(address(merkleLT).balance, previousFeeAccrued + defaults.MINIMUM_FEE(), "fee collected"); + assertEq(address(merkleLT).balance, previousFeeAccrued + MINIMUM_FEE, "fee collected"); } } diff --git a/tests/integration/concrete/lt/constructor.t.sol b/tests/integration/concrete/lt/constructor.t.sol index 81218c57..10351fb4 100644 --- a/tests/integration/concrete/lt/constructor.t.sol +++ b/tests/integration/concrete/lt/constructor.t.sol @@ -7,39 +7,6 @@ import { MerkleLT } from "src/types/DataTypes.sol"; import { Integration_Test } from "../../Integration.t.sol"; contract Constructor_MerkleLT_Integration_Test is Integration_Test { - /// @dev Needed to prevent "Stack too deep" error - struct Vars { - address actualAdmin; - uint256 actualAllowance; - string actualCampaignName; - uint40 actualExpiration; - address actualFactory; - string actualIpfsCID; - address actualLockup; - bytes32 actualMerkleRoot; - uint256 actualFee; - bool actualStreamCancelable; - uint40 actualStreamStartTime; - bool actualStreamTransferable; - address actualToken; - uint64 actualTotalPercentage; - MerkleLT.TrancheWithPercentage[] actualTranchesWithPercentages; - address expectedAdmin; - uint256 expectedAllowance; - string expectedCampaignName; - uint40 expectedExpiration; - address expectedFactory; - string expectedIpfsCID; - address expectedLockup; - bytes32 expectedMerkleRoot; - uint256 expectedFee; - bool expectedStreamCancelable; - bool expectedStreamTransferable; - address expectedToken; - uint64 expectedTotalPercentage; - MerkleLT.TrancheWithPercentage[] expectedTranchesWithPercentages; - } - function test_Constructor() external { // Make Factory the caller for the constructor test. resetPrank(address(merkleFactory)); @@ -48,67 +15,23 @@ contract Constructor_MerkleLT_Integration_Test is Integration_Test { SablierMerkleLT constructedLT = new SablierMerkleLT(params, users.campaignOwner); - Vars memory vars; - - vars.actualAdmin = constructedLT.admin(); - vars.expectedAdmin = users.campaignOwner; - assertEq(vars.actualAdmin, vars.expectedAdmin, "admin"); - - vars.actualAllowance = dai.allowance(address(constructedLT), address(lockup)); - vars.expectedAllowance = MAX_UINT256; - assertEq(vars.actualAllowance, vars.expectedAllowance, "allowance"); - - vars.actualCampaignName = constructedLT.campaignName(); - vars.expectedCampaignName = defaults.CAMPAIGN_NAME(); - assertEq(vars.actualCampaignName, vars.expectedCampaignName, "campaign name"); - - vars.actualExpiration = constructedLT.EXPIRATION(); - vars.expectedExpiration = defaults.EXPIRATION(); - assertEq(vars.actualExpiration, vars.expectedExpiration, "expiration"); - - vars.actualFactory = constructedLT.FACTORY(); - vars.expectedFactory = address(merkleFactory); - assertEq(vars.actualFactory, vars.expectedFactory, "factory"); - - vars.actualFee = constructedLT.MINIMUM_FEE(); - vars.expectedFee = defaults.MINIMUM_FEE(); - assertEq(vars.actualFee, vars.expectedFee, "minimum fee"); - - vars.actualIpfsCID = constructedLT.ipfsCID(); - vars.expectedIpfsCID = defaults.IPFS_CID(); - assertEq(vars.actualIpfsCID, vars.expectedIpfsCID, "ipfsCID"); - - vars.actualLockup = address(constructedLT.LOCKUP()); - vars.expectedLockup = address(lockup); - assertEq(vars.actualLockup, vars.expectedLockup, "lockup"); - - vars.actualMerkleRoot = constructedLT.MERKLE_ROOT(); - vars.expectedMerkleRoot = defaults.MERKLE_ROOT(); - assertEq(vars.actualMerkleRoot, vars.expectedMerkleRoot, "merkleRoot"); - - assertEq(constructedLT.shape(), defaults.SHAPE(), "shape"); - - vars.actualStreamCancelable = constructedLT.STREAM_CANCELABLE(); - vars.expectedStreamCancelable = defaults.CANCELABLE(); - assertEq(vars.actualStreamCancelable, vars.expectedStreamCancelable, "stream cancelable"); - - vars.actualStreamStartTime = constructedLT.STREAM_START_TIME(); - assertEq(vars.actualStreamStartTime, ZERO, "stream start time"); - - vars.actualStreamTransferable = constructedLT.STREAM_TRANSFERABLE(); - vars.expectedStreamTransferable = defaults.TRANSFERABLE(); - assertEq(vars.actualStreamTransferable, vars.expectedStreamTransferable, "stream transferable"); - - vars.actualToken = address(constructedLT.TOKEN()); - vars.expectedToken = address(dai); - assertEq(vars.actualToken, vars.expectedToken, "token"); - - vars.actualTotalPercentage = constructedLT.TOTAL_PERCENTAGE(); - vars.expectedTotalPercentage = defaults.TOTAL_PERCENTAGE(); - assertEq(vars.actualTotalPercentage, vars.expectedTotalPercentage, "totalPercentage"); - - vars.actualTranchesWithPercentages = constructedLT.getTranchesWithPercentages(); - vars.expectedTranchesWithPercentages = params.tranchesWithPercentages; - assertEq(vars.actualTranchesWithPercentages, vars.expectedTranchesWithPercentages); + uint256 actualAllowance = dai.allowance(address(constructedLT), address(lockup)); + assertEq(actualAllowance, MAX_UINT256, "allowance"); + + assertEq(constructedLT.admin(), users.campaignOwner, "admin"); + assertEq(constructedLT.campaignName(), CAMPAIGN_NAME, "campaign name"); + assertEq(constructedLT.EXPIRATION(), EXPIRATION, "expiration"); + assertEq(constructedLT.FACTORY(), address(merkleFactory), "factory"); + assertEq(constructedLT.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee"); + assertEq(constructedLT.ipfsCID(), IPFS_CID, "ipfsCID"); + assertEq(address(constructedLT.LOCKUP()), address(lockup), "lockup"); + assertEq(constructedLT.MERKLE_ROOT(), MERKLE_ROOT, "merkleRoot"); + assertEq(constructedLT.shape(), SHAPE, "shape"); + assertEq(constructedLT.STREAM_CANCELABLE(), CANCELABLE, "stream cancelable"); + assertEq(constructedLT.STREAM_START_TIME(), ZERO, "stream start time"); + assertEq(constructedLT.STREAM_TRANSFERABLE(), TRANSFERABLE, "stream transferable"); + assertEq(address(constructedLT.TOKEN()), address(dai), "token"); + assertEq(constructedLT.TOTAL_PERCENTAGE(), defaults.TOTAL_PERCENTAGE(), "totalPercentage"); + assertEq(constructedLT.getTranchesWithPercentages(), params.tranchesWithPercentages); } } diff --git a/tests/integration/concrete/shared/claim/claim.t.sol b/tests/integration/concrete/shared/claim/claim.t.sol index 3464bcf7..0e19fe75 100644 --- a/tests/integration/concrete/shared/claim/claim.t.sol +++ b/tests/integration/concrete/shared/claim/claim.t.sol @@ -7,33 +7,29 @@ import { Integration_Test } from "../../../Integration.t.sol"; abstract contract Claim_Integration_Test is Integration_Test { function test_RevertGiven_CampaignExpired() external { - uint40 expiration = defaults.EXPIRATION(); - uint256 fee = defaults.MINIMUM_FEE(); - uint256 warpTime = expiration + 1 seconds; + uint256 warpTime = EXPIRATION + 1 seconds; bytes32[] memory merkleProof; vm.warp({ newTimestamp: warpTime }); - vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_CampaignExpired.selector, warpTime, expiration)); - merkleBase.claim{ value: fee }({ index: 1, recipient: users.recipient1, amount: 1, merkleProof: merkleProof }); + vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_CampaignExpired.selector, warpTime, EXPIRATION)); + merkleBase.claim{ value: MINIMUM_FEE }({ + index: 1, + recipient: users.recipient1, + amount: 1, + merkleProof: merkleProof + }); } function test_RevertGiven_MsgValueLessThanFee() external givenCampaignNotExpired { - uint256 index1 = defaults.INDEX1(); - uint128 amount = defaults.CLAIM_AMOUNT(); - bytes32[] memory merkleProof = defaults.index1Proof(); - uint256 fee = defaults.MINIMUM_FEE(); - - vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_InsufficientFeePayment.selector, 0, fee)); - merkleBase.claim{ value: 0 }(index1, users.recipient1, amount, merkleProof); + vm.expectRevert( + abi.encodeWithSelector(Errors.SablierMerkleBase_InsufficientFeePayment.selector, 0, MINIMUM_FEE) + ); + merkleBase.claim{ value: 0 }(INDEX1, users.recipient1, CLAIM_AMOUNT, index1Proof()); } function test_RevertGiven_RecipientClaimed() external givenCampaignNotExpired givenMsgValueNotLessThanFee { claim(); - uint256 index1 = defaults.INDEX1(); - uint128 amount = defaults.CLAIM_AMOUNT(); - uint256 fee = defaults.MINIMUM_FEE(); - bytes32[] memory merkleProof = defaults.index1Proof(); - vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_StreamClaimed.selector, index1)); - merkleBase.claim{ value: fee }(index1, users.recipient1, amount, merkleProof); + vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_StreamClaimed.selector, INDEX1)); + merkleBase.claim{ value: MINIMUM_FEE }(INDEX1, users.recipient1, CLAIM_AMOUNT, index1Proof()); } function test_RevertWhen_IndexNotValid() @@ -43,11 +39,8 @@ abstract contract Claim_Integration_Test is Integration_Test { givenRecipientNotClaimed { uint256 invalidIndex = 1337; - uint128 amount = defaults.CLAIM_AMOUNT(); - uint256 fee = defaults.MINIMUM_FEE(); - bytes32[] memory merkleProof = defaults.index1Proof(); vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_InvalidProof.selector)); - merkleBase.claim{ value: fee }(invalidIndex, users.recipient1, amount, merkleProof); + merkleBase.claim{ value: MINIMUM_FEE }(invalidIndex, users.recipient1, CLAIM_AMOUNT, index1Proof()); } function test_RevertWhen_RecipientNotValid() @@ -57,13 +50,9 @@ abstract contract Claim_Integration_Test is Integration_Test { givenRecipientNotClaimed whenIndexValid { - uint256 index1 = defaults.INDEX1(); address invalidRecipient = address(1337); - uint128 amount = defaults.CLAIM_AMOUNT(); - uint256 fee = defaults.MINIMUM_FEE(); - bytes32[] memory merkleProof = defaults.index1Proof(); vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_InvalidProof.selector)); - merkleBase.claim{ value: fee }(index1, invalidRecipient, amount, merkleProof); + merkleBase.claim{ value: MINIMUM_FEE }(INDEX1, invalidRecipient, CLAIM_AMOUNT, index1Proof()); } function test_RevertWhen_AmountNotValid() @@ -74,12 +63,9 @@ abstract contract Claim_Integration_Test is Integration_Test { whenIndexValid whenRecipientValid { - uint256 index1 = defaults.INDEX1(); uint128 invalidAmount = 1337; - uint256 fee = defaults.MINIMUM_FEE(); - bytes32[] memory merkleProof = defaults.index1Proof(); vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_InvalidProof.selector)); - merkleBase.claim{ value: fee }(index1, users.recipient1, invalidAmount, merkleProof); + merkleBase.claim{ value: MINIMUM_FEE }(INDEX1, users.recipient1, invalidAmount, index1Proof()); } function test_RevertWhen_MerkleProofNotValid() @@ -91,12 +77,8 @@ abstract contract Claim_Integration_Test is Integration_Test { whenRecipientValid whenAmountValid { - uint256 index1 = defaults.INDEX1(); - uint128 amount = defaults.CLAIM_AMOUNT(); - uint256 fee = defaults.MINIMUM_FEE(); - bytes32[] memory invalidMerkleProof = defaults.index2Proof(); vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleBase_InvalidProof.selector)); - merkleBase.claim{ value: fee }(index1, users.recipient1, amount, invalidMerkleProof); + merkleBase.claim{ value: MINIMUM_FEE }(INDEX1, users.recipient1, CLAIM_AMOUNT, index2Proof()); } /// @dev Since the implementation of `_claim()` differs in each Merkle campaign, we declare this dummy test and diff --git a/tests/integration/concrete/shared/clawback/clawback.t.sol b/tests/integration/concrete/shared/clawback/clawback.t.sol index 1f6e9cb4..b313c548 100644 --- a/tests/integration/concrete/shared/clawback/clawback.t.sol +++ b/tests/integration/concrete/shared/clawback/clawback.t.sol @@ -39,10 +39,7 @@ abstract contract Clawback_Integration_Test is Integration_Test { { vm.expectRevert( abi.encodeWithSelector( - Errors.SablierMerkleBase_ClawbackNotAllowed.selector, - getBlockTimestamp(), - defaults.EXPIRATION(), - defaults.FIRST_CLAIM_TIME() + Errors.SablierMerkleBase_ClawbackNotAllowed.selector, getBlockTimestamp(), EXPIRATION, FIRST_CLAIM_TIME ) ); merkleBase.clawback({ to: users.campaignOwner, amount: 1 }); @@ -54,7 +51,7 @@ abstract contract Clawback_Integration_Test is Integration_Test { whenFirstClaimMade givenSevenDaysPassed { - vm.warp({ newTimestamp: defaults.EXPIRATION() + 1 seconds }); + vm.warp({ newTimestamp: EXPIRATION + 1 seconds }); vm.assume(to != address(0)); test_Clawback(to); } diff --git a/tests/integration/concrete/shared/collect-fees/collectFees.t.sol b/tests/integration/concrete/shared/collect-fees/collectFees.t.sol index 757a26ab..01d5fec1 100644 --- a/tests/integration/concrete/shared/collect-fees/collectFees.t.sol +++ b/tests/integration/concrete/shared/collect-fees/collectFees.t.sol @@ -69,6 +69,6 @@ abstract contract CollectFees_Integration_Test is Integration_Test { // It should set the ETH balance to 0. assertEq(address(merkleBase).balance, 0, "merkle lockup ETH balance"); // It should transfer fee collected in ETH to the factory admin. - assertEq(admin.balance, initialAdminBalance + defaults.MINIMUM_FEE(), "admin ETH balance"); + assertEq(admin.balance, initialAdminBalance + MINIMUM_FEE, "admin ETH balance"); } } diff --git a/tests/integration/concrete/shared/has-claimed/hasClaimed.t.sol b/tests/integration/concrete/shared/has-claimed/hasClaimed.t.sol index d9f77889..e98be716 100644 --- a/tests/integration/concrete/shared/has-claimed/hasClaimed.t.sol +++ b/tests/integration/concrete/shared/has-claimed/hasClaimed.t.sol @@ -11,7 +11,7 @@ abstract contract HasClaimed_Integration_Test is Integration_Test { function test_GivenRecipientNotClaimed() external whenIndexInMerkleTree { // It should return false. - assertFalse(merkleBase.hasClaimed(defaults.INDEX1()), "claimed"); + assertFalse(merkleBase.hasClaimed(INDEX1), "claimed"); } function test_GivenRecipientClaimed() external whenIndexInMerkleTree { @@ -19,6 +19,6 @@ abstract contract HasClaimed_Integration_Test is Integration_Test { claim(); // It should return true. - assertTrue(merkleBase.hasClaimed(defaults.INDEX1()), "not claimed"); + assertTrue(merkleBase.hasClaimed(INDEX1), "not claimed"); } } diff --git a/tests/integration/concrete/shared/has-expired/hasExpired.t.sol b/tests/integration/concrete/shared/has-expired/hasExpired.t.sol index 2fd4de0e..80d37750 100644 --- a/tests/integration/concrete/shared/has-expired/hasExpired.t.sol +++ b/tests/integration/concrete/shared/has-expired/hasExpired.t.sol @@ -16,12 +16,12 @@ abstract contract HasExpired_Integration_Test is Integration_Test { } function test_WhenTheExpirationInPresent() external whenExpirationNotZero { - vm.warp({ newTimestamp: defaults.EXPIRATION() }); + vm.warp({ newTimestamp: EXPIRATION }); assertTrue(merkleBase.hasExpired(), "campaign not expired"); } function test_WhenTheExpirationInFuture() external whenExpirationNotZero { - vm.warp({ newTimestamp: defaults.EXPIRATION() + 1 seconds }); + vm.warp({ newTimestamp: EXPIRATION + 1 seconds }); assertTrue(merkleBase.hasExpired(), "campaign not expired"); } } diff --git a/tests/integration/concrete/vca/claim/claim.t.sol b/tests/integration/concrete/vca/claim/claim.t.sol index b074b7e5..a34d3ed5 100644 --- a/tests/integration/concrete/vca/claim/claim.t.sol +++ b/tests/integration/concrete/vca/claim/claim.t.sol @@ -13,10 +13,6 @@ contract Claim_MerkleVCA_Integration_Test is Claim_Integration_Test, MerkleVCA_I } function test_RevertWhen_VestingStartTimeInFuture() external whenMerkleProofValid { - uint256 fee = defaults.MINIMUM_FEE(); - uint128 claimAmount = defaults.CLAIM_AMOUNT(); - bytes32[] memory merkleProof = defaults.index1Proof(); - // Move back in time so that the vesting start time is in the future. vm.warp({ newTimestamp: JULY_1_2024 - 1 weeks }); @@ -24,33 +20,31 @@ contract Claim_MerkleVCA_Integration_Test is Claim_Integration_Test, MerkleVCA_I vm.expectRevert(abi.encodeWithSelector(Errors.SablierMerkleVCA_ClaimNotStarted.selector)); // Claim the airdrop. - merkleVCA.claim{ value: fee }({ + merkleVCA.claim{ value: MINIMUM_FEE }({ index: 1, recipient: users.recipient1, - amount: claimAmount, - merkleProof: merkleProof + amount: CLAIM_AMOUNT, + merkleProof: index1Proof() }); } function test_WhenVestingEndTimeInPast() external whenMerkleProofValid whenVestingStartTimeNotInFuture { // Forward in time so that the vesting end time is in the past. - vm.warp({ newTimestamp: defaults.RANGED_STREAM_END_TIME() }); + vm.warp({ newTimestamp: RANGED_STREAM_END_TIME }); // It should emit a {Claim} event. vm.expectEmit({ emitter: address(merkleVCA) }); - emit ISablierMerkleVCA.Claim( - defaults.INDEX1(), users.recipient1, defaults.CLAIM_AMOUNT(), defaults.CLAIM_AMOUNT() - ); + emit ISablierMerkleVCA.Claim(INDEX1, users.recipient1, CLAIM_AMOUNT, CLAIM_AMOUNT); // It should transfer the full amount. - expectCallToTransfer({ to: users.recipient1, value: defaults.CLAIM_AMOUNT() }); - expectCallToClaimWithMsgValue(address(merkleVCA), defaults.MINIMUM_FEE()); + expectCallToTransfer({ to: users.recipient1, value: CLAIM_AMOUNT }); + expectCallToClaimWithMsgValue(address(merkleVCA), MINIMUM_FEE); - merkleVCA.claim{ value: defaults.MINIMUM_FEE() }({ + merkleVCA.claim{ value: MINIMUM_FEE }({ index: 1, recipient: users.recipient1, - amount: defaults.CLAIM_AMOUNT(), - merkleProof: defaults.index1Proof() + amount: CLAIM_AMOUNT, + merkleProof: index1Proof() }); // It should not update forgone amount. @@ -58,24 +52,24 @@ contract Claim_MerkleVCA_Integration_Test is Claim_Integration_Test, MerkleVCA_I } function test_WhenVestingEndTimeNotInPast() external whenMerkleProofValid whenVestingStartTimeNotInFuture { - uint128 claimableAmount = (defaults.CLAIM_AMOUNT() * 2 days) / defaults.TOTAL_DURATION(); + uint128 claimableAmount = (CLAIM_AMOUNT * 2 days) / TOTAL_DURATION; // It should emit a {Claim} event. vm.expectEmit({ emitter: address(merkleVCA) }); - emit ISablierMerkleVCA.Claim(defaults.INDEX1(), users.recipient1, claimableAmount, defaults.CLAIM_AMOUNT()); + emit ISablierMerkleVCA.Claim(INDEX1, users.recipient1, claimableAmount, CLAIM_AMOUNT); // It should transfer a portion of the amount. expectCallToTransfer({ to: users.recipient1, value: claimableAmount }); - expectCallToClaimWithMsgValue(address(merkleVCA), defaults.MINIMUM_FEE()); + expectCallToClaimWithMsgValue(address(merkleVCA), MINIMUM_FEE); - merkleVCA.claim{ value: defaults.MINIMUM_FEE() }({ + merkleVCA.claim{ value: MINIMUM_FEE }({ index: 1, recipient: users.recipient1, - amount: defaults.CLAIM_AMOUNT(), - merkleProof: defaults.index1Proof() + amount: CLAIM_AMOUNT, + merkleProof: index1Proof() }); // It should update forgone amount. - assertEq(merkleVCA.forgoneAmount(), defaults.CLAIM_AMOUNT() - claimableAmount, "forgone amount"); + assertEq(merkleVCA.forgoneAmount(), CLAIM_AMOUNT - claimableAmount, "forgone amount"); } } diff --git a/tests/integration/concrete/vca/constructor.t.sol b/tests/integration/concrete/vca/constructor.t.sol index 4718593a..2b4ea58a 100644 --- a/tests/integration/concrete/vca/constructor.t.sol +++ b/tests/integration/concrete/vca/constructor.t.sol @@ -13,15 +13,15 @@ contract Constructor_MerkleVCA_Integration_Test is Integration_Test { SablierMerkleVCA actualMerkleVCA = new SablierMerkleVCA(merkleVCAConstructorParams(), users.campaignOwner); assertEq(actualMerkleVCA.admin(), users.campaignOwner, "admin"); - assertEq(actualMerkleVCA.campaignName(), defaults.CAMPAIGN_NAME(), "campaign name"); - assertEq(actualMerkleVCA.EXPIRATION(), defaults.EXPIRATION(), "expiration"); + assertEq(actualMerkleVCA.campaignName(), CAMPAIGN_NAME, "campaign name"); + assertEq(actualMerkleVCA.EXPIRATION(), EXPIRATION, "expiration"); assertEq(actualMerkleVCA.FACTORY(), address(merkleFactory), "factory"); - assertEq(actualMerkleVCA.MINIMUM_FEE(), defaults.MINIMUM_FEE(), "minimum fee"); - assertEq(actualMerkleVCA.ipfsCID(), defaults.IPFS_CID(), "ipfsCID"); - assertEq(actualMerkleVCA.MERKLE_ROOT(), defaults.MERKLE_ROOT(), "merkleRoot"); + assertEq(actualMerkleVCA.MINIMUM_FEE(), MINIMUM_FEE, "minimum fee"); + assertEq(actualMerkleVCA.ipfsCID(), IPFS_CID, "ipfsCID"); + assertEq(actualMerkleVCA.MERKLE_ROOT(), MERKLE_ROOT, "merkleRoot"); assertEq(actualMerkleVCA.forgoneAmount(), 0, "forgoneAmount"); - assertEq(actualMerkleVCA.vestingSchedule().start, defaults.RANGED_STREAM_START_TIME(), "vesting start"); - assertEq(actualMerkleVCA.vestingSchedule().end, defaults.RANGED_STREAM_END_TIME(), "vesting end"); + assertEq(actualMerkleVCA.vestingSchedule().start, RANGED_STREAM_START_TIME, "vesting start"); + assertEq(actualMerkleVCA.vestingSchedule().end, RANGED_STREAM_END_TIME, "vesting end"); assertEq(address(actualMerkleVCA.TOKEN()), address(dai), "token"); } } diff --git a/tests/utils/Constants.sol b/tests/utils/Constants.sol index 67d03dfa..7a5698a2 100644 --- a/tests/utils/Constants.sol +++ b/tests/utils/Constants.sol @@ -1,10 +1,46 @@ // SPDX-License-Identifier: GPL-3.0-or-later pragma solidity >=0.8.22; +import { UD2x18, uUNIT } from "@prb/math/src/UD2x18.sol"; +import { ud } from "@prb/math/src/UD60x18.sol"; + abstract contract Constants { + // Amounts + uint256 public constant AGGREGATE_AMOUNT = CLAIM_AMOUNT * RECIPIENT_COUNT; + uint128 public constant CLAIM_AMOUNT = 10_000e18; + uint128 public constant CLIFF_AMOUNT = (CLAIM_AMOUNT * CLIFF_DURATION) / TOTAL_DURATION; + UD2x18 public immutable CLIFF_PERCENTAGE = (ud(CLIFF_AMOUNT).div(ud(CLAIM_AMOUNT)).intoUD2x18()); + uint256 public constant MINIMUM_FEE = 0.005e18; + uint128 public constant START_AMOUNT = 100e18; + UD2x18 public immutable START_PERCENTAGE = (ud(START_AMOUNT).div(ud(CLAIM_AMOUNT)).intoUD2x18()); + + // Durations and Timestamps + uint40 public constant CLIFF_DURATION = 2 days; + uint40 public immutable EXPIRATION = JULY_1_2024 + 12 weeks; + uint40 public constant FIRST_CLAIM_TIME = JULY_1_2024; + uint40 public immutable RANGED_STREAM_START_TIME = JULY_1_2024 - 2 days; + uint40 public immutable RANGED_STREAM_END_TIME = RANGED_STREAM_START_TIME + TOTAL_DURATION; + uint40 public constant TOTAL_DURATION = 10 days; + + // Merkle Campaigns + string public CAMPAIGN_NAME = "Airdrop Campaign"; + bool public constant CANCELABLE = false; + uint256 public constant INDEX1 = 1; + uint256 public constant INDEX2 = 2; + uint256 public constant INDEX3 = 3; + uint256 public constant INDEX4 = 4; + string public constant IPFS_CID = "QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR"; + uint256[] public LEAVES = new uint256[](RECIPIENT_COUNT); + uint256 public constant RECIPIENT_COUNT = 4; + bytes32 public MERKLE_ROOT; + string public SHAPE = "A custom stream shape"; + bool public constant TRANSFERABLE = false; + + // Global uint40 internal constant JULY_1_2024 = 1_719_792_000; uint128 internal constant MAX_UINT128 = type(uint128).max; uint256 internal constant MAX_UINT256 = type(uint256).max; uint40 internal constant MAX_UNIX_TIMESTAMP = 2_147_483_647; // 2^31 - 1 + uint64 public constant TOTAL_PERCENTAGE = uUNIT; uint40 internal constant ZERO = 0; } diff --git a/tests/utils/Defaults.sol b/tests/utils/Defaults.sol index 5edf6313..cbd98b44 100644 --- a/tests/utils/Defaults.sol +++ b/tests/utils/Defaults.sol @@ -2,119 +2,17 @@ pragma solidity >=0.8.22; import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import { Arrays } from "@openzeppelin/contracts/utils/Arrays.sol"; -import { ud2x18, UD2x18, uUNIT } from "@prb/math/src/UD2x18.sol"; +import { ud2x18 } from "@prb/math/src/UD2x18.sol"; import { ud } from "@prb/math/src/UD60x18.sol"; import { ISablierLockup } from "@sablier/lockup/src/interfaces/ISablierLockup.sol"; import { LockupTranched } from "@sablier/lockup/src/types/DataTypes.sol"; -import { Merkle } from "murky/src/Merkle.sol"; import { MerkleInstant, MerkleLL, MerkleLT, MerkleVCA } from "../../src/types/DataTypes.sol"; import { Constants } from "./Constants.sol"; -import { MerkleBuilder } from "./MerkleBuilder.sol"; -import { Users } from "./Types.sol"; - -/// @notice Contract with default values used throughout the tests. -contract Defaults is Constants, Merkle { - using MerkleBuilder for uint256[]; - - /*////////////////////////////////////////////////////////////////////////// - GENERICS - //////////////////////////////////////////////////////////////////////////*/ - - uint128 public immutable CLIFF_AMOUNT; - uint40 public constant CLIFF_DURATION = 2 days; - uint128 public constant START_AMOUNT = 100e18; - uint40 public constant TOTAL_DURATION = 10 days; - - /*////////////////////////////////////////////////////////////////////////// - MERKLE-LOCKUP - //////////////////////////////////////////////////////////////////////////*/ - - uint256 public constant AGGREGATE_AMOUNT = CLAIM_AMOUNT * RECIPIENT_COUNT; - string public CAMPAIGN_NAME = "Airdrop Campaign"; - bool public constant CANCELABLE = false; - uint128 public constant CLAIM_AMOUNT = 10_000e18; - UD2x18 public immutable CLIFF_PERCENTAGE; - uint40 public immutable EXPIRATION; - uint40 public constant FIRST_CLAIM_TIME = JULY_1_2024; - uint256 public constant INDEX1 = 1; - uint256 public constant INDEX2 = 2; - uint256 public constant INDEX3 = 3; - uint256 public constant INDEX4 = 4; - string public constant IPFS_CID = "QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR"; - uint256[] public LEAVES = new uint256[](RECIPIENT_COUNT); - uint256 public constant MINIMUM_FEE = 0.005e18; - uint256 public constant RECIPIENT_COUNT = 4; - bytes32 public MERKLE_ROOT; - string public SHAPE = "A custom stream shape"; - UD2x18 public immutable START_PERCENTAGE; - uint40 public constant RANGED_STREAM_START_TIME = JULY_1_2024 - 2 days; - uint40 public immutable RANGED_STREAM_END_TIME; - uint64 public constant TOTAL_PERCENTAGE = uUNIT; - bool public constant TRANSFERABLE = false; - - /*////////////////////////////////////////////////////////////////////////// - VARIABLES - //////////////////////////////////////////////////////////////////////////*/ - - IERC20 private token; - Users private users; - - /*////////////////////////////////////////////////////////////////////////// - CONSTRUCTOR - //////////////////////////////////////////////////////////////////////////*/ - - constructor() { - CLIFF_AMOUNT = (CLAIM_AMOUNT * CLIFF_DURATION) / TOTAL_DURATION; - CLIFF_PERCENTAGE = (ud(CLIFF_AMOUNT).div(ud(CLAIM_AMOUNT)).intoUD2x18()); // 20% of the claim amount - EXPIRATION = JULY_1_2024 + 12 weeks; - RANGED_STREAM_END_TIME = RANGED_STREAM_START_TIME + TOTAL_DURATION; - START_PERCENTAGE = (ud(START_AMOUNT).div(ud(CLAIM_AMOUNT)).intoUD2x18()); // 1% of the claim amount - } - - /*////////////////////////////////////////////////////////////////////////// - HELPERS - //////////////////////////////////////////////////////////////////////////*/ - - function index1Proof() public view returns (bytes32[] memory) { - return indexProof(INDEX1, users.recipient1); - } - - function index2Proof() public view returns (bytes32[] memory) { - return indexProof(INDEX2, users.recipient2); - } - - function index3Proof() public view returns (bytes32[] memory) { - return indexProof(INDEX3, users.recipient3); - } - - function index4Proof() public view returns (bytes32[] memory) { - return indexProof(INDEX4, users.recipient4); - } - - function indexProof(uint256 index, address recipient) public view returns (bytes32[] memory) { - uint256 leaf = MerkleBuilder.computeLeaf(index, recipient, CLAIM_AMOUNT); - uint256 pos = Arrays.findUpperBound(LEAVES, leaf); - return getProof(LEAVES.toBytes32(), pos); - } - - /// @dev We need a separate function to initialize the Merkle tree because, at the construction time, the users are - /// not yet set. - function initMerkleTree() public { - LEAVES[0] = MerkleBuilder.computeLeaf(INDEX1, users.recipient1, CLAIM_AMOUNT); - LEAVES[1] = MerkleBuilder.computeLeaf(INDEX2, users.recipient2, CLAIM_AMOUNT); - LEAVES[2] = MerkleBuilder.computeLeaf(INDEX3, users.recipient3, CLAIM_AMOUNT); - LEAVES[3] = MerkleBuilder.computeLeaf(INDEX4, users.recipient4, CLAIM_AMOUNT); - MerkleBuilder.sortLeaves(LEAVES); - MERKLE_ROOT = getRoot(LEAVES.toBytes32()); - } - - function setUsers(Users memory users_) public { - users = users_; - } +/// @notice Contract with default functions used throughout the tests. +contract Defaults is Constants { /*////////////////////////////////////////////////////////////////////////// MERKLE-INSTANT //////////////////////////////////////////////////////////////////////////*/