Here is my solution to the problem:
function withdraw (uint amount) public returns(uint){
//Check balance:
require(balance[msg.sender] >= amount, “Balance not sufficient for withdrawal”);
//Save current balance:
uint previousBalance = balance[msg.sender];
//Withdrawal:
msg.sender.transfer(amount);
//Deduct amount from balance:
balance[msg.sender] = previousBalance - amount;
//Return balance:
return balance[msg.sender];
}function withdraw(uint amount) public returns (uint) {
require(balance[msg.sender] >= amount, "you do not have enough funds in your balance to withdraw this amount!");
//msg.sender is an address where you can withdraw funds to.
payable(msg.sender).transfer(amount);
balance[msg.sender] -= amount;
return balance[msg.sender];
}function withdraw(uint amount) public returns (uint) {
require(balance[msg.sender] >= amount, "You do not have that balance");
msg.sender.transfer(amount);
balance[msg.sender] -= amount;
return balance[msg.sender];
}
pragma solidity 0.7.5;
contract Bank {
mapping(address => uint) balance;
event depositDone(uint amount, address indexed depositedTo);
event withdrawDone(uint amount, address indexed withdrawedTo);
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 assigned to your address is not sufficient.");
msg.sender.transfer(amount);
balance[msg.sender] -= amount;
emit withdrawDone(amount, msg.sender);
return balance[msg.sender];
}
function getBalance() public view returns (uint) {
return balance[msg.sender];
}
}
function withdraw(uint amount) public returns (uint) {
require(balance[msg.sender] >= amount, "You need money");
uint _previousBalance = balance[msg.sender];
msg.sender.transfer(amount);
balance[msg.sender] -= amount;
assert(balance[msg.sender] == _previousBalance - amount);
emit withdrawalExecuted(balance[msg.sender],msg.sender);
return amount;
}
function withdraw(uint amount) public returns(uint){
require(balance [msg.sender]>=amount);
msg.sender.transfer(amount);
balance[msg.sender] -= amount;
return balance[msg.sender];
}
pragma solidity ^0.7.5;
contract Bank {
address owner;
mapping(address => uint256) balances;
event depositMade(address account, uint256 amount);
event withdrawalMade(address account, uint256 amount);
modifier onlyOwner {
require(msg.sender == owner, "Only owner can access this feature.");
_;
}
constructor() {
owner = msg.sender;
}
function deposit() public payable {
balances[msg.sender] += msg.value;
emit depositMade(msg.sender, msg.value);
}
function withdraw() public payable {
require(msg.value <= balances[msg.sender], "You don't have enough deposited.");
balances[msg.sender] -= msg.value;
msg.sender.transfer(msg.value);
emit withdrawalMade(msg.sender, msg.value);
}
function bal() public view returns(uint256) {
return balances[msg.sender];
}
}
function withdraw(uint amount) public returns (uint){
// Add this statement to ensure they have he proper amount of funds to withdraw.
require(balance[msg.sender] >= amount, "Withdraw amount greater than balance.");
msg.sender.transfer(amount);
//Must add this to correctly update our version of balance, transfer doesn't work because they are sending to their same address
balance[msg.sender] -= amount;
return balance[msg.sender];
}
function getBalance() public view returns (uint){
return balance[msg.sender];
}pragma solidity 0.7.5;
contract Bank{
mapping(address => uint) balance;
address owner;
event depositDone(uint amount, address depositedTo);
event tokenTransfer(address from, address to, uint amount);
modifier onlyOwner {
require(msg.sender == owner, "not 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 returns(uint) {
require(balance[msg.sender] >= amount, "Balance Insufficient");
uint prevBalance = balance[msg.sender];
msg.sender.transfer(amount);
balance[msg.sender] = prevBalance - amount;
return(balance[msg.sender]);
}
function getBalance() public view returns(uint){
return balance[msg.sender];
}
function transfer(address receipient, uint amount) public{
require(balance[msg.sender] >= amount, "Balance Insufficient");
require(msg.sender != receipient);
uint prevSenderBalance = balance[msg.sender];
_transfer(msg.sender, receipient, amount);
assert(balance[msg.sender] == prevSenderBalance - amount);
emit tokenTransfer(msg.sender, receipient, amount);
}
function _transfer(address from, address to, uint amount) private{
balance[from] -= amount;
balance[to] += amount;
}
}
function withdraw(uint amount) public returns(uint) {
require(balance[msg.sender] >= amount, “You cannot afford that, silly!”);
msg.sender.transfer(amount); // transfer function has built-in error handling
balance[msg.sender] -= amount;
}
After 1 hour I’ve eventually gotten the desired result!! 
pragma solidity 0.7.5;
contract tokenTrasfer{
mapping (address => uint) balance;
address owner;
constructor(){
owner = msg.sender;
}
modifier onlyOwner{
require(msg.sender == owner);
_;
}
event depositDone(uint amount, address indexed depositedTo);
event withdrawDone(uint amount, address indexed withdrawedBy);
function getBalance() public view returns(uint){
return balance[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]);
uint PreviousBalance = balance[msg.sender];
msg.sender.transfer(amount);
balance[msg.sender] -= amount;
assert(balance[msg.sender] == PreviousBalance - amount);
emit withdrawDone(amount, msg.sender);
return(balance[msg.sender]);
}
}
pragma solidity 0.7.5;
contract TransferAssignment {
mapping(address => uint) balance;
address owner;
event depositDone(uint amount, address indexed despositedTo);
event transactionComplete(address indexed sender, address indexed recipient, uint amount);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier minmumBalance(uint minimumRequiredBalance) {
require(balance[msg.sender] >= minimumRequiredBalance, "Insufficient balance.");
_;
}
modifier notSelf(address recipientAddress) {
require(msg.sender != recipientAddress, "Don't transfer money to yourself.");
_;
}
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 minmumBalance(amount) returns (uint) {
msg.sender.transfer(amount);
balance[msg.sender] -= amount;
return balance[msg.sender];
}
function getBalance() public view returns (uint) {
return balance[msg.sender];
}
function transferTo(address toRecipient, uint amount) public minmumBalance(amount) notSelf(toRecipient) {
_transfer(msg.sender, toRecipient, amount);
balance[toRecipient] += amount;
//event logs and further checkes
emit transactionComplete(msg.sender, toRecipient, amount);
}
function _transfer(address _fromAddress, address _recipientAddress, uint amount) private {
balance[_fromAddress] -= amount;
balance[_recipientAddress] += amount;
}
}
function withdraw (uint _amountToWithdraw) public returns (uint){
require(_amountToWithdraw <= balance[msg.sender], “OI YOU DON’T HAVE THAT MUCH”);
msg.sender.transfer(_amountToWithdraw);
balance[msg.sender] -= _amountToWithdraw;
}
@filip Sir, thank you so much Sir! Thank you
pragma solidity 0.7.5;
contract etherbank {
mapping(address => uint) balance;
address owner;
event depositDone(uint amount, address indexed depositedTo);
event transactionDone(address indexed fromSender, address indexed toRecipient, uint amount);
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 payable returns(uint){
msg.sender.transfer(amount);
require (balance[msg.sender] >= amount, "balance not sufficeint");
balance[msg.sender] -= amount;
}
}
Solution for the withdraw function to remove only the value that the user has placed into the contract.
function withDraw(uint amount) public returns (uint){
require(balance[msg.sender] >= amount, "Balance not sufficient");
msg.sender.transfer(amount);
balance[msg.sender]-= amount;
}Hey @Bogdan_Manzar, hope you are ok.
You should always have the conditionals first (requires), you function will first send the value (.transfer) and then verify the require condition.
If you have any more questions, please let us know so we can help you! 
Carlos Z.
pragma solidity 0.7.5;
contract withdraw_example {
mapping(address => uint) balance; // Key -> Value Pair in ()
address owner;
event no_withdrawal(uint amount, address indexed withdrawnTo); // indexed allows us to query these parameters //
modifier onlyOwner {
require(msg.sender == owner, "Only Owner can perform this function");
_; // run the function //
}
constructor(){
owner = msg.sender;
}
function deposit() public payable returns (uint){
// only the owner of this address can add to the balance written in header with modifier onlyOwner //
// want this to return the new balance //
balance[msg.sender] += msg.value; // also = msg.sender + _toAdd - same thing //
return balance[msg.sender]; // after _toAdd has been added to balance[msg.sender] //
}
function withdraw(uint amount) public payable returns (uint){
//msg.sender is an address - do a check to determine what the balance is and not allow them to withdraw any more than the balance. //
require(msg.sender.balance >= amount, "Balance is not sufficient for this withdrawal"); // If balance >= amount do transfer, if not, error thrown //
msg.sender.transfer(amount);
balance[msg.sender] -= amount; // subtract amount withdrawn from msg.senders balance //
emit no_withdrawal (msg.value, msg.sender);
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, "The receipient and sender address are the same");
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;
}
}
Hello, this is my code. It is not possible to withdraw more money than you have, if you try to do it, it gives an error message. It also updates balance. I am very happy about this assignment, that I was able to figure it out on my own and in such a short time. Thank you Filip for a very good course!
pragma solidity 0.7.5;
contract Bank {
mapping(address => uint) balance;
address owner;
event depositDone(uint amount, address 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; //this is for ourselves to keep track
emit depositDone(msg.value, msg.sender);
return balance[msg.sender];
}
function withdraw(uint amount) public returns (uint){
require(balance[msg.sender] >= amount, "Balance not sufficient"); // checks balance of msg.sender
msg.sender.transfer(amount);
balance[msg.sender] -= 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"); // checks balance of msg.sender
require(msg.sender != recipient, "Don't transfer money to yourself"); // you should not 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;
}
}
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);
_;
}
modifier costs(uint price){
require(msg.value >= price);
_; // run the function
}
function deposit() public payable onlyOwner returns (uint){
balance[msg.sender] += msg.value;
emit depositDone(msg.value, msg.sender);
return balance[msg.sender];
}
function getBalance() public view returns(uint){
return balance[msg.sender];
}
function withdraw(uint amount) public returns(uint){
require(balance[msg.sender] >= amount, "You can't withdraw more money than you have!");
balance[msg.sender] -= amount;
msg.sender.transfer(amount);
return balance[msg.sender];
}
function transfer(address recipient, uint amount) public payable costs(100){
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(previousSenderBalance - amount == balance[msg.sender]);
}
function _transfer(address from, address to, uint amount) private {
balance[from] -= amount;
balance[to] += amount;
}
}
pragma solidity 0.7.5;
contract Transferable {
mapping(address => uint) balance;
event deposited(uint amount, address indexed depositor);
event withdrawn(uint amount, address indexed withdrawer);
function deposit() public payable returns (uint) {
balance[msg.sender]+=msg.value;
emit deposited(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 withdrawn(amount, msg.sender);
return balance[msg.sender];
}
}