Solidity Exercise - TimelockEscrow/TripleNestedMapping/...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract TimelockEscrow {
    address public seller;

    /**
     * The goal of this exercise is to create a Time lock escrow.
     * A buyer deposits ether into a contract, and the seller cannot withdraw it until 3 days passes. Before that, the buyer can take it back
     * Assume the owner is the seller
     */

    constructor() {
        seller = msg.sender;
    }

    // creates a buy order between msg.sender and seller
    /**
     * escrows msg.value for 3 days which buyer can withdraw at anytime before 3 days but afterwhich only seller can withdraw
     * should revert if an active escrow still exist or last escrow hasn't been withdrawn
     */
    function createBuyOrder() external payable {
        // your code here
    }

    /**
     * allows seller to withdraw after 3 days of the escrow with @param buyer has passed
     */
    function sellerWithdraw(address buyer) external {
        // your code here
    }

    /**
     * allowa buyer to withdraw at anytime before the end of the escrow (3 days)
     */
    function buyerWithdraw() external {
        // your code here
    }

    // returns the escrowed amount of @param buyer
    function buyerDeposit(address buyer) external view returns (uint256) {
        // your code here
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract TimelockEscrow {
    address public seller;
    struct Order{
        uint256 amount;
        uint256 createdAt;
    }
    mapping(address => Order) orders; // buyer address => Order

    /**
     * The goal of this exercise is to create a Time lock escrow.
     * A buyer deposits ether into a contract, and the seller cannot withdraw it until 3 days passes. Before that, the buyer can take it back
     * Assume the owner is the seller
     */

    constructor() {
        seller = msg.sender;
    }

    // creates a buy order between msg.sender and seller
    /**
     * escrows msg.value for 3 days which buyer can withdraw at anytime before 3 days but afterwhich only seller can withdraw
     * should revert if an active escrow still exist or last escrow hasn't been withdrawn
     */
    function createBuyOrder() external payable {
        // your code here
        require(orders[msg.sender].amount == 0 && orders[msg.sender].createdAt == 0, "you have an active order.");
        orders[msg.sender] = Order(msg.value, block.timestamp);
    }

    /**
     * allows seller to withdraw after 3 days of the escrow with @param buyer has passed
     */
    function sellerWithdraw(address buyer) external {
        // your code here
        Order memory order = orders[buyer];
        require(block.timestamp > (order.createdAt + 3 days), "The seller needs 3 days to withdraw.");
        payable(seller).transfer(order.amount);
    }

    /**
     * allowa buyer to withdraw at anytime before the end of the escrow (3 days)
     */
    function buyerWithdraw() external {
        // your code here
        Order memory order = orders[msg.sender];
        require(block.timestamp < (order.createdAt + 3 days), "The buyer needs widthdraw within 3 days.");
        payable(msg.sender).transfer(order.amount);
    }

    // returns the escrowed amount of @param buyer
    function buyerDeposit(address buyer) external view returns (uint256) {
        // your code here
        return orders[buyer].amount;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract TripleNestedMapping {
    /* 
        This exercise assumes you know how mappings work.
        1. Create a public TRIPLE nested mapping of 
           (string(_name) => uint256(_password) => uint256(_pin) => bool).
        2. The name of the mapping must be `isLoggedIn` and it should be public.
        3. Set the boolean value of the arguments to `true` in the 'setLogin' function.
    */
    mapping(string => mapping(uint256 => mapping(uint256 => bool))) public isLoggedIn;

    function setLogin(
        string memory _name,
        uint256 _password,
        uint256 _pin
    ) public {
        // your code here
        isLoggedIn[_name][_password][_pin] = true;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract Tupledore {
    /* This exercise assumes you know about tuples/struct in solidity.
        1. Create a struct named `UserInfo` with types address 
           and uint256.
        2. Create a variable of type UserInfo, named `userInfo`.
        3. Create a function called `setTuple` that takes in 
           a address and uint256 and sets the all values 
           the `userInfo` variable you created above.
        4. Create a function called `returnTuple`, 
           that returns `userInfo` (as a tuple)
    */
   struct UserInfo{
      address addr;
      uint256 age;
   }
   UserInfo public userInfo;
   function setTuple(address _addr, uint256 _age) public {
      userInfo.addr = _addr;
      userInfo.age = _age;
   }

   function returnTuple() public view returns(UserInfo memory){
      return userInfo;
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

contract Unchecked {
    /*
        This exercise assumes you understand what unchecked keyword is.
        1. The `getNumber` function reverts when called, you need to make the function stop
           reverting and return underflow value.
    */

    function getNumber(uint256 x) public pure returns (uint256) {
        unchecked{
            return x - 100;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.13;

import "forge-std/Test.sol";
import "../src/Unchecked.sol";
import "forge-std/console.sol";

contract UncheckedTest is Test {
    Unchecked public uncheckedContract;

    function setUp() public {
        uncheckedContract = new Unchecked();
    }

    function testUnchecked() external {
        uint256 res = uncheckedContract.getNumber(10);
        console.log("getNumber(10) => ", res);
        uint256 res1 = uncheckedContract.getNumber(0);
        console.log("getNumber(0) => ", res1);
        uint256 res2 = uncheckedContract.getNumber(50);
        console.log("getNumber(50) => ", res2);
        uint256 res3 = uncheckedContract.getNumber(20);
        console.log("getNumber(20) => ", res3);

        uint256 res4 = uncheckedContract.getNumber(120);
        console.log("getNumber(120) => ", res4);
    }
}