03 - Writing Smart Contracts in Solidity

 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

// SPDX-License-Identifier: <license-identifier-here>
// ex. SPDX-License-Identifier: MIT
// ex. SPDX-License-Identifier: GPL-3.0-or-later
// ex. SPDX-License-Identifier: UNLICENSED

// Solidity compiler version
// You can specify more precise version selection bounds by using the syntax
// here: https://docs.npmjs.com/cli/v6/using-npm/semver
pragma solidity ^0.8.4;

// Most of your code will live inside a contract declaration
contract FreeToken {
    // Solidity has a few unique data types, such as mapping, address
    // A mapping is like an associative array, dictionary, or hashmap
    // This mapping maps Ethereum addresses to 256-bit unsigned integers
    mapping (address => uint256) balances;

    // The public access modifier doesn't allow external code to write to this
    // value, only read
    uint256 public totalSupply = 0;

    // External functions can only be called from OUTSIDE the contract, and are
    // disallowed from making internal function calls. Public functions can do
    // both, but are more expensive.
    // This function doesn't modify the state of the contract, so it is marked
    // with the view modifier
    function balanceOf (address _wallet) external view returns (uint256) {
        return balances[_wallet];
    }

    // This function does modify the state of the contract, so no view modifier
    function mint () external {
        // msg.sender gives us the external address that initiated this call
        balances[msg.sender] += 1;
        totalSupply += 1;
    }

    // Could this function be improved?
    function transfer (address _to, uint256 _amount) external {
        // Failed calls to require() revert the transaction, undoing state
        // changes
        require(_amount > 0, "Amount must be nonzero");
        require(balances[msg.sender] >= _amount, "Insufficient balance");

        balances[msg.sender] -= _amount;
        balances[_to] += _amount;
    }
}

 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
59
60
61
62
63
64
65
66
67
68
69
70
71

pragma solidity ^0.8.4;

contract VeryExpensiveToken {
    mapping (address => uint256) public balances;
    uint256 public totalSupply = 0;
    // ETH can be sent to payable addresses
    address payable public owner;

    // Called when the contract is first deployed
    constructor (address payable _owner) {
        owner = _owner;
    }

    // Events appear in logs (e.g. for debugging) and web3 applications can
    // listen for them
    // Indexed parameters are searchable in logs
    event BuyEvent(address indexed buyer, uint256 indexed tokenIndex, uint256 price);

    // Functions marked payable have access to msg.value, which is a quantity of
    // ETH tokens sent along with the function call
    function buy () external payable {
        uint256 _totalSupply = totalSupply;
        require(msg.value >= _nextTokenCost(_totalSupply),
            "Not enough to buy next token");
        totalSupply = _totalSupply + 1;
        balances[msg.sender]++;

        // Emits an event
        emit BuyEvent(msg.sender, _totalSupply, msg.value);
    }

    function nextTokenCost () external view returns (uint256) {
        return _nextTokenCost(totalSupply);
    }

    // Pure functions cannot modify state, like view functions, but it also
    // cannot read state either
    function _nextTokenCost (uint256 _totalSupply) public pure returns (uint256) {
        // There are some nice keywords for pecuniary numbers in Solidity:
        //   1 wei == 1
        //   1 gwei == 1e9
        //   1 ether == 1e18
        // Also for durations:
        //   1 seconds == 1
        //   minutes, hours, days, weeks
        return (2 ** _totalSupply) * 1 ether;
    }

    function withdraw () public {
        assert(msg.sender == owner);

        // Although .send() and .transfer() functions exist for sending ETH,
        // their use is no longer recommended because they rely on a constant
        // gas cost for computations which is no longer a safe assumption
        // https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now
        // !!!WARNING!!!
        // There is potential for even worse bugs or vulnerabilities if this
        // method is not used carefully. Proper usage is covered in the next
        // section.
        (bool success,) = owner.call{ value: address(this).balance }("");
        require(success, "Withdraw failed");
    }

    function balanceOf (address _wallet) external view returns (uint256) {
        return balances[_wallet];
    }

    function transfer (address _to, uint256 _amount) public {
        // ...
    }
}

 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

pragma solidity ^0.8.4;

contract InconspicuousToken {
    mapping (address => uint256) balances;
    uint256 public totalSupply = 0;
    // Constant values are defined at compile time and replaced throughout the
    // contract so they do not incur a storage read cost.
    uint256 constant minimumBuy = 1 gwei;

    function balanceOf (address _wallet) external view returns (uint256) {
        return balances[_wallet];
    }

    // Errors look a little bit like events, but they halt execution when used
    error InsufficientBuy();

    // Custom function modifiers alter function behavior
    modifier enforceMinimumBuy () {
        // Similar to a require(...) call
        if (msg.value < minimumBuy) {
            revert InsufficientBuy();
        }

        // Will be replaced with the modified function's body
        _;
    }

    function contractBalance () external view returns (uint256) {
        return address(this).balance;
    }

    // Uses a custom function modifier to ensure that a condition is met
    function buy () payable external enforceMinimumBuy {
        balances[msg.sender] += msg.value;
        totalSupply += msg.value;
    }

    function sell () external {
        // !!!WARNING!!!
        // This function is vulnerable!

        // Send the user their unwrapped funds
        uint256 balance = balances[msg.sender];
        (bool success,) = payable(msg.sender).call{
            value: balance
        }("");

        // Don't empty their wallet if the transaction failed
        if (success) {
            totalSupply -= balance;
            balances[msg.sender] = 0;
        }
    }

    function transfer (address _to, uint256 _amount) external {
        // ...
    }
}