Transfer Assignment

dan-i · March 3, 2021, 10:00pm

If for whatever reason the transfer method fails, the function reverts.
A good lecture from you: https://vomtom.at/solidity-send-vs-transfer/

Cheers,
Dani

mervxxgotti · March 3, 2021, 10:55pm

clarified! thank you!

Omas · March 5, 2021, 3:08pm

To ensure that the user cannot withdraw more than their balance, we have to require that his balance is greater than or equal to the amount withdrawn.
See code below;
function withdraw(uint amount) public returns (uint){
require(balance[msg.sender] >= amount, "Balance not up to amount);//checks user
//balance is adequate
balance[msg.sender] -= amount;//deducts amount from user balance
msg.sender.transfer(amount);//transfers the amount
return balance[msg.sender];//retrieves the user balance after transfer
}

marsrvr · March 5, 2021, 5:48pm

Adding the necessary require() to insure a user cannot withdraw more than we think they’re entitled to. Also note the “Checks–>Effects -->Interactions” pattern is in play:

function withdraw(uint amount) public returns (uint){
        require(balance[msg.sender] >= amount,"Insuficient Funds");
        balance[msg.sender] -= amount;
        msg.sender.transfer(amount);
        return balance[msg.sender];
    }

leemac · March 6, 2021, 3:03pm

    function withdraw(uint amount) public returns (uint) {
        require(balance[msg.sender] >= amount, "Not enough funds");
        balance[msg.sender] -= amount;
        msg.sender.transfer(amount);
        return balance[msg.sender];
    }

Mehdi369 · March 6, 2021, 3:58pm

require(balance[msg.sender] >= amount

Neeraj_Nerlekar · March 7, 2021, 4:04pm

pragma solidity 0.7.5;

contract Bank {
   
    mapping(address => uint) balance;
    address owner;
    
    constructor() {
        owner = msg.sender;
    }
    
    event depositDone(uint amount, address indexed depositedTo);
    
    modifier onlyOwner {
        require(msg.sender == owner, 'only owner can add balance');
        _;
    }
    
    function deposit() public payable returns (uint) {
        balance[msg.sender] += msg.value;
        emit depositDone(msg.value, msg.sender);
        return balance[msg.sender];
    }
    
    function withdraw(uint amount) public returns(uint) {
        require(balance[msg.sender] >= amount, 'cannot exceed your own balance');
        msg.sender.transfer(amount);
        balance[msg.sender] -= amount;
        return balance[msg.sender];
    }
    
    function getBalance() public view returns(uint) {
        return balance[msg.sender];
    }
    
    function transfer(address recipient, uint amount) public {
        require(balance[msg.sender] >= amount,'amount cannot exceed balance');
        require(msg.sender != recipient);
        _transfer(msg.sender, recipient, amount);
    }
    
    function _transfer(address from, address to, uint amount) private {
        balance[from] -= amount;
        balance[to] += amount;
    }
}

Neeraj_Nerlekar · March 7, 2021, 4:09pm

msg.sender.transfer(amount);
balance[msg.sender] -= amount;

@filip I checked the solution you posted. The order of these two statements matter? It’s the opposite in your solution.

thecil · March 8, 2021, 5:30pm

check this answer, which play a patter that will be explained to you in the next lessons.

Carlos Z

RichJamo · March 8, 2021, 1:02pm

function withdraw(uint amount) public returns (uint){
require (balance[msg.sender] >= amount, “Balance not sufficient”); //make sure this address has sufficient balance at this contract
msg.sender.transfer(amount); //transfer function has in-built error throwing
balance[msg.sender] -= amount;
}

Christopher · March 8, 2021, 1:48pm

  function withdraw(uint amount) public returns (uint){
        require(balance[msg.sender] >= amount, 'Balance not sufficient');
        msg.sender.transfer(amount);
        balance[msg.sender] -= amount;
        return balance[msg.sender];
    }

n1g3 · March 8, 2021, 5:28pm

    function withdraw(uint amount) public returns (uint){
        //msg.sender is an address (payable by default)
        //address payable toSend = 0x1aE0EA34a72D944a8C7603FfB3eC30a6669E454C
        require(balance[msg.sender] >= amount, "You have insufficient funds!");
        msg.sender.transfer(amount);
        balance[msg.sender] -= amount;
    }

n1g3 · March 8, 2021, 5:31pm

       return balance[msg.sender];

Baidis · March 9, 2021, 12:01pm

I got this to work but I was trying to get rid of the additional function. I don’t understand why the effect on memory vs storage is different by adding function.

pragma solidity 0.7.5;
contract Bank {
    
    //storage - permanent storage of data (state variables)
    //memory - temporary storage used in function execution
    //calldata - save arguments/inputs to our functions
    //strings, arrays, mappings, structs

    mapping(address => uint) balance;
    
    address owner;
    
    modifier onlyOwner {
        require(msg.sender == owner);
        _; //run the function
    }
    
    event depositDone(uint amount, address indexed depositedTo);
    event transfers(address transferFrom, address transferTo, uint amount);
    
    constructor(){
        owner = msg.sender;
    }
    
    function deposit() public payable returns (uint) {
        balance[msg.sender] += msg.value;
        emit depositDone(msg.value, msg.sender);
        return balance[msg.sender];
    }
    
    function withdraw(uint amount) public payable returns (uint){
        //msg.sender is an address
        require(balance[msg.sender] >= amount, "Balance not sufficient");
        msg.sender.transfer(amount);
        
        uint previousSenderBalance = balance[msg.sender];
        
        _withdraw(msg.sender, amount);
        
        assert(balance[msg.sender] == previousSenderBalance - amount);
        
    }
    
    function _withdraw(address from, uint amount) private {
        balance[from] -= amount;
    }
    
    function getBalance() public view returns (uint){
        return balance[msg.sender];
    }
    
    function transfer(address recipient, uint amount) public {
        require(balance[msg.sender] >= amount, "Balance not sufficient");
        require(msg.sender != recipient, "Don't transfer money to yourself");
        
        uint previousSenderBalance = balance[msg.sender];
        
        _transfer(msg.sender, recipient, amount);
        
        assert(balance[msg.sender] == previousSenderBalance - amount);
        emit transfers(msg.sender, recipient, amount);
    }
    
    function _transfer(address from, address to, uint amount) private {
        balance[from] -= amount;
        balance[to] += amount;
    }
    

}

kdivus · March 9, 2021, 12:59pm

pragma solidity 0.7.5;

contract Bank {
    
    mapping(address => uint) balance;
    
    event depositDone(uint amount, address indexed depositedTo);
    
    function deposit() public payable returns (uint)  {
        balance[msg.sender] += msg.value;
        emit depositDone(msg.value, msg.sender);
        return balance[msg.sender];
    }
    
    function withdraw(uint amount) public returns (uint){
        require(balance[msg.sender] >= amount);
        balance[msg.sender] -= amount;
        msg.sender.transfer(amount);
        return balance[msg.sender];
    }
    
    function getBalance() public view returns (uint){
        return balance[msg.sender];
    }
    
    function transfer(address recipient, uint amount) public {
        require(balance[msg.sender] >= amount, "Balance not sufficient");
        require(msg.sender != recipient, "Don't transfer money to yourself");
        
        uint previousSenderBalance = balance[msg.sender];
        
        _transfer(msg.sender, recipient, amount);
                
        assert(balance[msg.sender] == previousSenderBalance - amount);
    }
    
    function _transfer(address from, address to, uint amount) private {
        balance[from] -= amount;
        balance[to] += amount;
    }
    
}

Yeleva · March 10, 2021, 11:38am

Here’s my solution:

    function withdraw(uint a_amount) public returns(uint){
        require(balances[msg.sender] >= a_amount, "Insufficient Balance");
        balances[msg.sender] -= a_amount;
        msg.sender.transfer(a_amount);
        return balances[msg.sender];
    }

I’d particularly like to commend @marsrvr for referencing the Checks Effects Interactions pattern which is well demonstrated here. By executing the transfer last, reentrant code can’t abuse internal state because the effect of the withdrawal (namely the mutation of the mapping) has already been applied.

santiago · March 10, 2021, 10:26pm

Implemented require function to check if the amount input is valid. Also added an assert function to check that the balance got adjusted correctly.
Question to this: would this assert function actually add security to my contract or is it unnecessary?

function withdraw(uint amount) public returns (uint) {
            require(amount <= balance[msg.sender], "Insufficient balance");
            uint previousSenderBalance = balance[msg.sender];
            balance[msg.sender] -= amount;

            msg.sender.transfer(amount);

            assert(balance[msg.sender] == previousSenderBalance - amount);
            return balance[msg.sender];
        }

dan-i · March 11, 2021, 8:04am

Hey @Santiago

The assert statement is unnecessary here as the whole function would revert in case the .trasfer method fails.

Cheers,
Dani

chrisd · March 13, 2021, 5:47pm

First check if the balance is >= then the amount you want to withdraw
then subtract the amount from the balance
as last return the balance

function withdraw(uint amount) public returns (uint){
        require(balance[msg.sender] >= amount, 'Balance insufficient');
        msg.sender.transfer(amount);
        balance[msg.sender] -= amount;
        return balance[msg.sender];
    }

CryptoPhoenix · March 12, 2021, 12:21am

The require amount > 0 is just to reduce gas fees if user accidentally withdraws 0–otherwise it isn’t needed to solve this problem.

function withdraw(uint amount) public returns (uint) {
    require(balance[msg.sender] >= amount, "Insufficient funds!");
    require(amount > 0, "Must withdraw more than 0!");
    uint initialBalance = balance[msg.sender];

    msg.sender.transfer(amount);
    balance[msg.sender] -= amount;
    
    assert(initialBalance > balance[msg.sender]);
}