Sending ETH Safely

Now let's complete the withdraw function by actually sending ETH to the user.

Why Not transfer()?

The old way was msg.sender.transfer(amount)

But transfer() only gives 2300 gas, which can fail with smart contract wallets.

Using call() Instead:

(bool success, ) = msg.sender.call{value: amount}("");

This sends ETH with more gas and returns a boolean success status.

The empty ("") means we're not calling a function, just sending ETH.

Checking Success:

Always check if the transfer succeeded:

require(success, "Transfer failed");

The Complete Pattern:

1. Check credits > 0
2. Store amount
3. Zero the balance (prevent reentrancy)
4. Send ETH with call()
5. Require success

Complete the withdraw() function by adding the call() and require.

Complete withdraw with call()

Requirements:

Uses call() to send ETH

Calls msg.sender.call

Includes {value: amount}

Includes empty string ("")

Captures success boolean

Requires success

Require comes after call

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

contract TicTacToe {
    uint64 constant ACCEPT_TIMEOUT = 1 days;
    uint64 constant MOVE_TIMEOUT = 1 days;

    event GameStarted(address indexed playerX, address indexed playerO, uint stake);
    event GameEnded(address indexed winner, bool isDraw);

    address public playerX;
    address public playerO;

    enum Cell { Empty, X, O }

    Cell[9] public board;

    bool public xTurn;
    bool public gameOver;
    address public winner;
    uint public stake;
    bool public gameActive;
    bool public gameAccepted;
    uint64 public acceptDeadline;
    uint64 public lastMoveAt;
    mapping(address => uint256) public credits;

    function startGame(address _opponent) public payable {
        require(!gameActive, "Game already active");
        require(_opponent != address(0), "Invalid opponent");
        require(_opponent != msg.sender, "Cannot play yourself");

        playerX = msg.sender;
        playerO = _opponent;
        xTurn = true;
        gameOver = false;
        winner = address(0);
        stake = msg.value;
        gameActive = true;
        gameAccepted = false;
        acceptDeadline = uint64(block.timestamp) + ACCEPT_TIMEOUT;

        for (uint i = 0; i < 9; i++) {
            board[i] = Cell.Empty;
        }

        emit GameStarted(playerX, playerO, stake);
    }

    function acceptGame() public payable {
        require(msg.value == stake, "Must match stake");
        require(msg.sender == playerO, "Only opponent can accept");
        require(block.timestamp <= acceptDeadline, "Accept period expired");
        require(!gameOver, "Game already over");

        gameAccepted = true;
        lastMoveAt = uint64(block.timestamp);
        stake = msg.value * 2;
    }

    function cancelUnaccepted() public {
        require(msg.sender == playerX, "Only starter can cancel");
        require(block.timestamp > acceptDeadline, "Accept period not expired");
        require(!gameAccepted, "Game already accepted");

        credits[playerX] += stake;
        stake = 0;
        gameActive = false;
    }

    function withdraw() public {
        require(credits[msg.sender] > 0, "No credits");
        uint256 amount = credits[msg.sender];
        credits[msg.sender] = 0;
        // Add call() here to send ETH
    }

    function claimForfeit() public {
        require(gameAccepted, "Game not started");
        require(!gameOver, "Game already over");
        require(block.timestamp > lastMoveAt + MOVE_TIMEOUT, "Timeout not reached");

        if (xTurn) {
            require(msg.sender == playerO, "Not your turn to claim");
        } else {
            require(msg.sender == playerX, "Not your turn to claim");
        }

        credits[msg.sender] += stake * 2;
        gameOver = true;
        winner = msg.sender;
    }

    function makeMove(uint _position) public {
        require(!gameOver, "Game over");
        require(_position < 9, "Invalid position");
        require(board[_position] == Cell.Empty, "Cell already taken");
        require(xTurn ? msg.sender == playerX : msg.sender == playerO, "Not your turn");

        Cell piece = xTurn ? Cell.X : Cell.O;
        board[_position] = piece;
        lastMoveAt = uint64(block.timestamp);

        if (checkWin()) {
            winner = msg.sender;
            gameOver = true;
            emit GameEnded(winner, false);
        } else if (checkDraw()) {
            winner = address(0);
            gameOver = true;
            emit GameEnded(winner, true);
        } else {
            xTurn = !xTurn;
        }
    }

    function checkWin() private view returns (bool) {
        // Check rows
        for (uint i = 0; i < 3; i++) {
            if (board[i*3] != Cell.Empty &&
                board[i*3] == board[i*3+1] &&
                board[i*3] == board[i*3+2]) {
                return true;
            }
        }

        // Check columns
        for (uint i = 0; i < 3; i++) {
            if (board[i] != Cell.Empty &&
                board[i] == board[i+3] &&
                board[i] == board[i+6]) {
                return true;
            }
        }

        // Check diagonals
        if (board[0] != Cell.Empty &&
            board[0] == board[4] &&
            board[0] == board[8]) {
            return true;
        }

        if (board[2] != Cell.Empty &&
            board[2] == board[4] &&
            board[2] == board[6]) {
            return true;
        }

        return false;
    }

    function checkDraw() private view returns (bool) {
        for (uint i = 0; i < 9; i++) {
            if (board[i] == Cell.Empty) {
                return false;
            }
        }
        return true;
    }
}