Transfer Assignment

[Mr.Flo]

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

[NetworkP]

Hello, I was in a hurry the other day and didn’t realise that the icon is here. Anyway. My code is below. As mentioned, everything works except the Government function. It does not record the transfer. Thanks

pragma solidity 0.7.5;


import "./Ownable.sol";

//External contract wants to pull transaction data form this(bankOwnable) contract//

interface FinancialInterface {
    function addTransaction (address _from, address _to, uint _amount) external payable; 
    
}

contract bank is Ownable {
    
    
    FinancialInterface FinancialInstance = FinancialInterface(0xf8e81D47203A594245E36C48e151709F0C19fBe8);
    
    
    
    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 onlyOwner 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, "Insufficient balance");
        require(msg.sender != recipient, "Can not send funds to yourself");
        
        uint previousSenderBalance = balance[msg.sender];
        
        _transfer(msg.sender, recipient, amount);
        
        FinancialInstance.addTransaction{value: 1 ether}(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;
        }
    }


pragma solidity 0.7.5;

contract Financial {
    
    struct Transaction {
        address from;
        address to;
        uint amount;
        uint txId;
        
    }
    
    Transaction[] transactionLog;
    
    function addTransaction (address _from, address _to, uint _amount)external payable {
        transactionLog.push( Transaction(_from, _to, _amount, transactionLog.length));
    } 
    
    function getTransaction(uint _index)public view returns(address, address, uint) {
        return (transactionLog[_index].from, transactionLog[_index].to, transactionLog[_index].amount);
    
    }

    function getBalance()public view returns(uint) {
    return address(this).balance;
    }
        
}
type or paste code here

[JonBal]

function withdraw(uint amount) public payable returns (uint) {
        require(balance[msg.sender] >= amount, "Not enough in balance");
        
        uint previousSenderBalance = balance[msg.sender];
        
        balance[msg.sender] -= amount;
        
        msg.sender.transfer(amount);
        
        emit withdrawDone(amount, msg.sender);
        
        return balance[msg.sender];
        
        assert(balance[msg.sender] == previousSenderBalance - amount);
    }

[thecil]

@NetworkP

other day and didn’t realise that the icon is here. Anyway. My code is below. As mentioned, everything works except the Government function. It does not record the transfer.

Hey @NetworkP, hope you are well.

Have you check that the address of the government contract is the same before you deploy the bank contract?

Carlos Z

[NetworkP]

Carlos, thanks for replying. That was the issue! I did not have the bank contract address correct, as I realised that each time we deploy, the contract address changes.

Thank you Brother

[DMT_RAINDROP]

function transferFunds (uint amount) public returns (uint) {

require (balance [msg.sender] >= amount, “Insufficient balance for this transaction”);

uint previousBalance = balance [msg.sender];
msg.sender.transferFunds (amount);
assert (previousBalance == balance [msg.sender] + amount);

[Sieg]

pragma solidity 0.7.5;

contract Bank{
    
    mapping (address => uint) balance; 
    address owner ; 
    
    event movementDone (uint amount, address indexed depositedTo); 
    
    constructor() {
        owner = msg.sender;
    }
    
    modifier OnlyOwner (){
        require(msg.sender == owner); 
        _;
    }
    
    function deposit () public payable returns (uint){
        balance[msg.sender] += msg.value; 
        emit movementDone (msg.value , msg.sender);
        return (balance[msg.sender]); 
    }
    
    function withdraw (uint amount) public returns (uint){
        require (balance[msg.sender]>=amount); 
        msg.sender.transfer(amount); 
        balance[msg.sender] -= amount;
        emit movementDone(-amount, msg.sender);
        return (balance[msg.sender]); 
    }
    
    function getBal() public view returns (uint){
        return balance[msg.sender]; 
    }
    function transferR (address recipient, uint amount) public{
        require (balance[msg.sender]>=amount, "Not enough balance");
        require (msg.sender != recipient, "Don't transfer money to yourself !"); 
        uint preTransferSenderBal = balance[msg.sender]; 
        _transfer(msg.sender,recipient,amount);
        assert(balance[msg.sender] == preTransferSenderBal-amount);
    }
    
    function _transfer (address from, address to, uint amount) private {
        balance[from] -= amount;
        balance[to] += amount;
    }
    
}

[berto]

pragma solidity 0.7.5;

contract Bank{
mapping(address => uint) balance;

address owner;

event depositDone(uint amount, address indexed depositedTo);


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 returns (uint)  {
    require (balance[msg.sender]>=amount);
    msg.sender.transfer(amount);
    balance[msg.sender] -= amount;
    emit depositDone(-amount, msg.sender);
    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 previusSenderBalance = balance[msg.sender];
    transfer(msg.sender, recipient, amount);
    assert(balance[msg.sender] == previusSenderBalance - amount);
}

function transfer(address from, address to, uint amount) private {
    balance[from] -= amount;
    balance[to] += amount;
    }

}

[Durkey_Turkey]

pragma solidity 0.7.5;

contract Bank {

mapping(address => uint) balance;
address owner;

event depositDone(uint amount, address indexed depositedTo);

modifier onlyOwner {
    require(msg.sender == owner);
    _; //run the function
}

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 withdrawl(uint amount) public returns(uint){
    require(balance[msg.sender] >= amount, "insuficient funds");
    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 send 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;
}

}

[MatthiasTay]

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

[alejandravisa]

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

[julcasans]

// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.7.5;

contract Bank {

    mapping (address => uint) balances;
    event depositDone(address, uint);
    
    address public owner;
    
    constructor() {
        owner = msg.sender;
    }
    
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }

    function deposit() public payable returns(uint) {
        balances[msg.sender] += msg.value;
        emit depositDone(msg.sender, msg.value);
        return balances[msg.sender];
    }
    
    function withdraw(uint amount) public returns(uint) {
        require(balances[msg.sender]>=amount);
        msg.sender.transfer(amount);
        balances[msg.sender] -= amount;
        return amount;
    }
    
    function getBalance() public view returns(uint) {
        return balances[msg.sender];
    }
    
    function getBankBalance() public view onlyOwner returns(uint) {
        return address(this).balance;
    }
    
}

[CryptoKnight84]

pragma solidity 0.8.7;


contract E15{
    mapping(address => uint) balance;
    address owner;
    
    constructor(){
        // This way the contract deployer is always the owner
        owner = msg.sender;
    }
    
    // Common modifier for owner
    modifier onlyOwner{
        require(msg.sender==owner, "Access Denied");
        _; // In practice: Run the function; Compiler code in practice it marks the point of editing
    }
    // Assert costs are available
    modifier costs(uint price) {
        require(msg.value >= price);
        _;
    }
    modifier Covered(uint amount) {
        require(balance[msg.sender] >= amount,"Nice try.");
        _;
    }
    
    event balanceAdded(uint amount, address indexed AddedTo);
    event depositDone(uint amount, address indexed AddedTo);
    event withdrawDone(uint amount, address indexed WithdrawnTo);
    
    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 Covered(amount) returns(uint) {
        payable(msg.sender).transfer(amount);
        balance[msg.sender] -= amount;
        emit withdrawDone(amount, msg.sender);
        return balance[msg.sender];
    }
    function addBalance4Owner(uint _toAdd) public onlyOwner returns(uint) {
        return _addBalance(msg.sender, _toAdd);
    }
    
    function addBalance4Other(address _recipient, uint _toAdd) public onlyOwner returns(uint) {
        return _addBalance(_recipient, _toAdd);
    }
    
    function _addBalance(address _recipient, uint _toAdd) private onlyOwner returns(uint) {
        balance[_recipient] += _toAdd;
        emit balanceAdded(_toAdd, _recipient);
        return balance[_recipient];
    }
    function getBalance() public view returns(uint) {
        return balance[msg.sender];
    }
    function transfer(address recipient, uint amount) public {
        // Error handling and check coming up later...
        require(amount <= balance[msg.sender], "Insufficient balance");
        require(msg.sender != recipient, "Cant transfer to self");
        uint PreviousSenderBalance = balance[msg.sender];
        uint PreviousRecipientBalance = balance[recipient];
        _transfer(msg.sender,recipient,amount);
        // Event logs and further checks
        assert(balance[msg.sender] == PreviousSenderBalance - amount);
        assert(balance[recipient] == PreviousRecipientBalance + amount);
        emit balanceAdded(amount,recipient);
    }
    function _transfer(address from, address to, uint amount) private {
        balance[from] -= amount;
        balance[to] += amount;
    }
}

[Leonard_Gohlke]

pragma solidity 0.7.5;

contract Firstcontract {
    
    mapping(address=>uint)balance;
    address owner;
    
    
    event depositDone( uint amount, address depositTo);
    event coinsTransfered (address sentTo, uint amount, address sentFrom);
    
    modifier onlyOwner{
        require(msg.sender == owner );
        _;
        
    }
        
    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 onlyOwner returns(uint){
        
        require(balance[msg.sender]>=amount);
        msg.sender.transfer(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, "dont send money to yourself!");
        
        
        uint previousSenderBalance = balance [msg.sender];
        
        _transfer (msg.sender, recipient, amount);
        
        assert (balance[msg.sender]==previousSenderBalance - amount );
        
        emit coinsTransfered(recipient, amount, msg.sender);
        
        
    }
    
    function _transfer(address from, address to, uint amount) private {
        balance[from]-=amount;
        balance[to]+=amount;
    }
    
        
    
    
    
}

[gaio]

Here’s my withdraw function:

function withdraw(uint amount) public returns (uint) {

        // check balance of sender is sufficient
        require(balance[msg.sender] >= amount,"Balance not sufficient");

        // msg.sender is an address, and address has a method to trasfer 
        msg.sender.transfer(amount);
        
        // adjust balance
        balance[msg.sender] -= amount;

        emit withDrawDone(amount, msg.sender);
        return balance[msg.sender];
    }

[gaio]

I’m missing some more fundamental understanding of what is going on in this assignment. I’m just not really clear how transfers are being made in general.

In the withdraw function, where is the money being withdrawn from?
Is the amount being withdrawn being removed from the address of the contract itself?

And then looking at the deposit function … if msg.sender is adding to his own balance, where is that value coming from? I see no sender in that function. And if the transfer method is fundamental to transferring between any 2 addresses, why is it not involved the the deposit function?

[Austaino]

pragma solidity 0.7.5;

contract Bank {

   mapping(address => uint) balance;
   address owner;
   
   event depositDone(uint amount, address indexed depositedTo);
   
   modifier onlyOwner{
       require (msg.sender == owner);
       _; // run the function.
   }
   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 returns (uint) {
  require (balance[msg.sender] >= amount);
  payable(msg.sender).transfer(amount);
  balance[msg.sender] -= amount;
  emit depositDone(-amount, msg.sender);
  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);
    require(msg.sender != recipient);
    _transfer(msg.sender,recipient, amount);
    
}

function _transfer(address from, address to, uint amount) private {
    
    balance [from] -= amount;
    
    balance [to] += amount; 
}

}

[simfin94]

pragma solidity 0.7.5;

contract Bank {

mapping(address => uint) balance;

address owner;

event depositDone(uint amount, address depositedTo);

//instead of having require in several functions
modifier onlyOwner {
    require(msg.sender == owner);
    _; //run the function
}

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 returns (uint) {
    require(amount <= balance[msg.sender]);
    balance[msg.sender] -= amount;
    //msg.sender is an address
    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 {
    //check balance of msg.sender
    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);
    //event logs and further checks
}

function _transfer(address from, address to, uint amount) private {
    balance[from] -= amount;
    balance[to] += amount;
}

}

[thecil]

Hey @gaio, hope you are well.

@gaio

In the withdraw function, where is the money being withdrawn from?

From the balance of the contract itself, (address(this).balance)

@gaio

if msg.sender is adding to his own balance, where is that value coming from? I see no sender in that function. And if the transfer method is fundamental to transferring between any 2 addresses, why is it not involved the the deposit function?

When a user deposit funds to your contract, through the deposit function which should be payable (to receive funds), then it will do an internal transfer from the user to the contract method deposit.

Carlos Z

[gaio]

Okay, yes, I think I get it now. I had to read up a bunch on msg.sender, msg.value etc … and I have a better concept now. Thanks