Day 17. Solidity Basic Syntax – Contract Implementation –

We will implement a contract utilizing the knowledge accumulated up to Day 16. As an example, we will create a contract with basic crowdfunding functionality. First, let’s understand the development process for developing a contract and then introduce the actual code.

Development Process

The content explained so far has been primarily about syntax, which is just a part of the coding (programming) process in the overall development workflow. Before even starting to code, it’s essential to decide what to create and how to realize it. In general system development, not limited to web3 development, the following steps are taken.

Coding

Following the process described above, here is an example of the actual implemented code.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;


error Funding__NotOwner();
error Funding__NotEnoughETH();


/**
 * @title A contract for crowdfunding
 * @author simochan
 * @notice This contract is to demo a sample funding contract
 */
contract Funding {
    // State variables
    address[] private s_funders;
    mapping(address => uint256) private s_addressToAmountFunded;
    address private immutable i_owner;

    // Event
    event Funded(address indexed funder, uint256 indexed fundedAmount);

    // Modifiers
    modifier onlyOwner() {
        if (msg.sender != i_owner) {
            revert Funding__NotOwner();
        }
        _;
    }

    constructor() {
        i_owner = msg.sender;
    }

    function fund() public payable {
        if(msg.value <= 100000000000000000) {
            revert Funding__NotEnoughETH();
        }
        s_funders.push(msg.sender);
        s_addressToAmountFunded[msg.sender] += msg.value;
        emit Funded(msg.sender, msg.value);
    }

    function withdraw() public onlyOwner {
        for (uint256 i = 0; i < s_funders.length; i++) {
            address funder = s_funders[i];
            s_addressToAmountFunded[funder] = 0;
        }
        s_funders = new address[](0);
        (bool success, ) = i_owner.call{value: address(this).balance}("");
        require(success);
    }

    function getOwner() public view returns (address) {
        return i_owner;
    }

    function getFunder(uint256 index) public view returns (address) {
        return s_funders[index];
    }

    function getAddressToAmountFunded(address funder) public view returns(uint256) {
        return s_addressToAmountFunded[funder];
    }
}

Testing

Creating test codes using Hardhat and conducting tests with them will be detailed in a later chapter. Here, let’s try manual testing with a contract deployed on Remix’s local network. Specifically, we will consider several cases and check if they work correctly.

1. After deployment, confirm whether the owner information obtained through getOwner matches the address that deployed the contract.
2. Execute funding (contributions) from multiple addresses other than the owner with amounts exceeding 0.1 ETH, and verify that the contract’s ETH balance has increased (assume funding of 1.0 ETH each from Address 1 and Address 2). Also, confirm that the defined event Funded (funding event) is recorded on the console.
3. Execute getFunder with arguments 0 and 1 to retrieve the addresses of the funders and confirm that the addresses used in step 2 are returned.
4. Use the addresses returned in step 3 as arguments to execute getAddressToAmountFunded (retrieve funded amount) and confirm that the funding amount is returned.
5. Execute funding with an amount less than 0.1 ETH, confirm that it is reverted, and an error is displayed on the console.
6. Have the owner execute withdraw and confirm that the contract’s ETH balance has become zero.