feat: we split ?

Author: QGarchery

script/DeploySpleth.sol

@@ -2,11 +2,11 @@
 pragma solidity ^0.8.13;
 
 import "forge-std/Script.sol";
-import "../src/Spleth.sol";
+import "../src/WeSplit.sol";
 
 contract DeploySpleth is Script {
     function run() public {
         vm.broadcast();
-        new Spleth();
+        new WeSplit();
     }
 }

src/Spleth.sol renamed to src/WeSplit.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.13;
 import "openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol";
 import "./Arith.sol";
 
-contract Spleth {
+contract WeSplit {
     using Arith for uint256;
 
     uint256 public nextId;

test/TestArith.sol

@@ -5,7 +5,6 @@ import "forge-std/Vm.sol";
 import "forge-std/console.sol";
 import "forge-std/Test.sol";
 
-import "../src/Spleth.sol";
 import "../src/Arith.sol";
 
 contract TestArith is Test {
@@ -21,5 +20,4 @@ contract TestArith is Test {
         assertEq(x.divUp(2), 7);
         assertEq(x.divUp(3), 5);
     }
-
 }

test/TestSpleth.sol

@@ -6,13 +6,13 @@ import "../lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
 import "forge-std/Test.sol";
 import "forge-std/Vm.sol";
 import "forge-std/console.sol";
-import "../src/Spleth.sol";
+import "../src/WeSplit.sol";
 import "../src/Arith.sol";
 
 contract TestSpleth is Test {
     using Arith for uint256;
 
-    Spleth public spleth;
+    WeSplit public weSplit;
     address user1 = address(123);
     address user2 = address(978);
     address DAI = address(0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063);
@@ -21,7 +21,7 @@ contract TestSpleth is Test {
     address[] users = new address[](2);
 
     function setUp() public {
-        spleth = new Spleth();
+        weSplit = new WeSplit();
         users[0] = user1;
         users[1] = user2;
         for (uint256 i; i < users.length; i++) setUpUser(users[i]);
@@ -32,71 +32,71 @@ contract TestSpleth is Test {
         deal(DAI, user, 1000 ether);
         deal(USDC, user, 1000 * 1e6);
         vm.startPrank(user);
-        IERC20(DAI).approve(address(spleth), type(uint256).max);
-        IERC20(USDC).approve(address(spleth), type(uint256).max);
+        IERC20(DAI).approve(address(weSplit), type(uint256).max);
+        IERC20(USDC).approve(address(weSplit), type(uint256).max);
         vm.stopPrank();
     }
 
     function testCreate() public {
         vm.prank(user1);
-        uint256 splitId = spleth.create(users);
-        assertEq(spleth.participantsLength(splitId), 2);
-        assertEq(spleth.participant(splitId, 0), user1);
-        assertEq(spleth.participant(splitId, 1), user2);
+        uint256 splitId = weSplit.create(users);
+        assertEq(weSplit.participantsLength(splitId), 2);
+        assertEq(weSplit.participant(splitId, 0), user1);
+        assertEq(weSplit.participant(splitId, 1), user2);
     }
 
     function testInitialize() public {
         uint256 amount = 14 ether;
         vm.startPrank(user1);
-        uint256 splitId = spleth.create(users);
-        spleth.initialize(splitId, DAI, amount, receiver);
+        uint256 splitId = weSplit.create(users);
+        weSplit.initialize(splitId, DAI, amount, receiver);
         vm.stopPrank();
 
-        assertEq(spleth.token(splitId), DAI, "running token");
-        assertEq(spleth.amount(splitId), uint256(amount), "running amount");
-        assertEq(spleth.receiver(splitId), receiver, "running receiver");
+        assertEq(weSplit.token(splitId), DAI, "running token");
+        assertEq(weSplit.amount(splitId), uint256(amount), "running amount");
+        assertEq(weSplit.receiver(splitId), receiver, "running receiver");
     }
 
     function testPartialApproval() public {
         uint256 amount = 1 ether;
         vm.prank(user1);
-        uint256 splitId = spleth.createInitializeApprove(users, DAI, amount, receiver);
+        uint256 splitId = weSplit.createInitializeApprove(users, DAI, amount, receiver);
 
-        assertTrue(spleth.approval(splitId, user1), "has approve");
-        assertEq(IERC20(DAI).balanceOf(address(spleth)), amount / 2, "balance spleth");
+        assertTrue(weSplit.approval(splitId, user1), "has approve");
+        assertEq(IERC20(DAI).balanceOf(address(weSplit)), amount / 2, "balance weSplit");
     }
 
     function testSend() public {
         uint256 amount = 3 ether + 1;
         vm.startPrank(user1);
-        uint256 splitId = spleth.create(users);
-        assertEq(spleth.token(splitId), address(0));
-        spleth.initializeApprove(splitId, DAI, amount, receiver);
+        uint256 splitId = weSplit.create(users);
+        assertEq(weSplit.token(splitId), address(0));
+        weSplit.initializeApprove(splitId, DAI, amount, receiver);
         vm.stopPrank();
 
         vm.prank(user2);
-        spleth.approve(splitId);
+        weSplit.approve(splitId);
 
         uint256 balanceReceiver = IERC20(DAI).balanceOf(receiver);
-        uint256 balanceSpleth = IERC20(DAI).balanceOf(address(spleth));
+        uint256 balanceSpleth = IERC20(DAI).balanceOf(address(weSplit));
 
         assertEq(balanceReceiver, amount, "transferred amount");
         assertEq(balanceSpleth, 2 * amount.divUp(2) - amount, "dust amount");
         // split amount is reset at the end of the function:
-        assertEq(spleth.amount(splitId), 0);
+        assertEq(weSplit.amount(splitId), 0);
 
         // split properties will be overwritten/reset at the start of a new tx:
-        assertEq(spleth.approvalCount(splitId), 2);
-        assertEq(spleth.token(splitId), DAI);
-        assertEq(spleth.receiver(splitId), receiver);
+        assertEq(weSplit.approvalCount(splitId), 2);
+        assertEq(weSplit.token(splitId), DAI);
+        assertEq(weSplit.receiver(splitId), receiver);
         //
         vm.prank(user1);
-        spleth.initialize(splitId, USDC, amount / 4, address(1000));
+        weSplit.initialize(splitId, USDC, amount / 4, address(1000));
         //
-        assertEq(spleth.approvalCount(splitId), 0);
-        assertEq(spleth.token(splitId), USDC);
-        assertEq(spleth.receiver(splitId), address(1000));
-        assertEq(spleth.amount(splitId), amount / 4);
+        assertEq(weSplit.approvalCount(splitId), 0);
+        assertEq(weSplit.token(splitId), USDC);
+        assertEq(weSplit.receiver(splitId), address(1000));
+        assertEq(weSplit.amount(splitId), amount / 4);
     }
 
     function testTwoGroups() public {
@@ -105,18 +105,18 @@ contract TestSpleth is Test {
         uint256 balanceReceiverBefore = IERC20(DAI).balanceOf(receiver);
 
         vm.prank(user1);
-        uint256 firstSplitId = spleth.createInitializeApprove(users, DAI, amount, receiver);
+        uint256 firstSplitId = weSplit.createInitializeApprove(users, DAI, amount, receiver);
 
         vm.prank(user2);
-        uint256 secondSplitId = spleth.createInitializeApprove(users, DAI, amount, receiver);
+        uint256 secondSplitId = weSplit.createInitializeApprove(users, DAI, amount, receiver);
 
         assertFalse(firstSplitId == secondSplitId, "split ids should be different");
 
         vm.prank(user1);
-        spleth.approve(secondSplitId);
+        weSplit.approve(secondSplitId);
 
         vm.prank(user2);
-        spleth.approve(firstSplitId);
+        weSplit.approve(firstSplitId);
 
         uint256 balanceReceiverAfter = IERC20(DAI).balanceOf(receiver);