Events Assignment

Ethereum Smart Contract Programming 101
#264

Hi @sph73,

Your transfer event and corresponding emit statement are both well coded, and the emit statement logs appropriate data when the transfer() function is successfully executed :ok_hand:

Just one observationā€¦
In general, an emit statement is probably better placed after an assert statement.

Just let us know if you have any questions :slight_smile:

#265

Thank you for clarifying this because I was unsure and I chose before because I thought the assert statement was the final check however in retrospect I see it makes more sense to check first. :pray:

#266 
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;

    event balanceAdded(uint amount, address depositedTo); 

    event transferMade(address recipient, uint amount);

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

    constructor(){
        owner = msg.sender;
    }

    function addBalance(uint _toAdd) public onlyOwner returns (uint){
        balance[msg.sender] += _toAdd;
        emit balanceAdded(_toAdd, 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");
        emit transferMade(recipient, amount);

        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;
    }

}
2 Likes
#267

pragma solidity 0.8.13;

contract Bank_Events{

mapping (address => uint) balance;

address owner; //state variable

//event logs, further cheks, and error handling

event balanceAdded (uint indexed amount, address indexed depositedTo);

event transferedAmount(address indexed from, address indexed to, uint indexed amount);

modifier onlyOwner {

    require(msg.sender == owner);  //A modifier is for restricting permissions like "only employees", "admins", or "owner" etc...

    _;

}

constructor(){

    owner = msg.sender;

}

function addBalance (uint _toAdd) public onlyOwner returns (uint){

    balance[msg.sender] += _toAdd;

    emit balanceAdded (_toAdd, msg.sender);      //log event

    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,"ERROR 1_Insufficient balance to transfer funds.");  //Check balance of msg.sender

    require(msg.sender != recipient,"ERROR 2_The sender cannot be the recipient.");

    uint previousSenderBalance = balance[msg.sender];

    _transfer (msg.sender, recipient, amount);  

    emit transferedAmount(msg.sender, recipient, amount);  //log event

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

       

}

function _transfer(address from, address to, uint amount) private {

    balance[from] -= amount;

    balance[to] += amount;

}

}

2 Likes
#268

pragma solidity 0.8.7;

contract helloBank {

mapping(address => uint) balances;

address owner;

event balanceUpdated(uint prevBalance,uint newBalance, address indexed updatedAccount);

modifier onlyOwner {

    require(msg.sender == owner,"Only SC Owner can Call this");

    //run the real functions, Practically EVM will replace all of function statement here

    _;

}

modifier sufficientBalance(uint _amount){

    require(balances[msg.sender] >= _amount,"Balance Not Sufficient");

    _;

}



constructor(){

    //here owner becomes the creator of SC

    //mostly useful for restricting function access to admins

    owner = msg.sender;

}

// admin function can only be perfromed by owner of SC

function addBalance(address _toAddress, uint _balance2Add) public onlyOwner returns(uint){

    //example admin function can be restricted to owner only

    //commented as using modifier

    //require(msg.sender == owner,"Only SC Owner can Call this");

    uint prevBalance = balances[_toAddress];

    balances[_toAddress] += _balance2Add;

    //emit log

    emit balanceUpdated(prevBalance, balances[_toAddress], _toAddress);

    return balances[_toAddress];

}

function getBalance() public view returns(uint){

    return balances[msg.sender];

}

function transfer(address recipient, uint amount) public sufficientBalance(amount) {

    //checks balance of msg-sender

    //if any of the require condition fails, all operation will be reverted

    //check if balance is sufficient

    //we can also have error statement

    //using modifier so commented here

    //require(balances[msg.sender] >= amount,"Balance Not Sufficient");

   

    //check if recipient is not as sender, unnecessary operation will cost GAS

    require(msg.sender != recipient,"Transfer to Self not Allowed");

    //variable to store previous balance, to be used for assert to check internal error

    uint prevFromBalance = balances[msg.sender];

    uint prevToBalance = balances[recipient];

    _transfer(msg.sender,recipient,amount);

    //check with assert for any internal error

    assert(balances[msg.sender] == prevFromBalance - amount);

    //event logs and further checks

    //from balance event

    emit balanceUpdated(prevFromBalance, balances[msg.sender], msg.sender);

    //to balance event

    emit balanceUpdated(prevToBalance, balances[recipient], recipient);

}

//private function, can be resused by others fn

function _transfer(address from, address to, uint amount) private {

    balances[from] -= amount;

    balances[to] += amount;

}

}

2 Likes
#269 
pragma solidity 0.8.13;

contract Bank{

    //storage - permanent storage of data (state variables)
    //memory - temporary storage used in funtion execution
    //calldate - save arguments/inputs to our functions
    //strings, arrays, mapping, scructs

    mapping(address => uint) balance;
    
    address owner;
    
    event balanceAdded(uint amount, address indexed depositedTo);

    event transfered(uint amount, address recipient);

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

    function addBalance(uint _toAdd) public onlyOwner returns (uint){
        balance[msg.sender] += _toAdd;
        emit balanceAdded(_toAdd, 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, "Dont transfer money to yyourself");

        uint previousSenderBalance = balance[msg.sender];

        _transfer(msg.sender, recipient, amount);

         emit transfered(amount, recipient);
        assert(balance[msg.sender] == previousSenderBalance - amount);
       
    }

    function  _transfer(address from, address to, uint amount) private {
        balance[from] -= amount;
        balance[to] += amount;
    }
}
2 Likes
#270
Event Assignment 
pragma solidity 0.7.5;

contract Bank {

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

    event balanceAdded(uint amount, address indexed depositedTo);
    event trasferComplited(address indexed from, address indexed to, uint amount);

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    constructor(){
        owner = msg.sender;
    }
    
    function addBalance(uint _toAdd) public onlyOwner returns(uint)  {
        balance[msg.sender] += _toAdd;
        emit balanceAdded(_toAdd, 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 previousSenderBalance = balance[msg.sender];
        _transfer(msg.sender, recipient, amount);
        emit trasferComplited(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;
    }
}
2 Likes
#271 
pragma solidity 0.7.5;

contract Bank {

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

    event balanceAdded(uint amount, address indexed depositedTo);
    event tokenTransfer(uint amount, address from, address to);

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

    function addBalance(uint _toAdd) public onlyOwner returns (uint){
        balance[msg.sender] += _toAdd;
        emit balanceAdded(_toAdd, 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, "Insufficient Balance");
        require(msg.sender != recipient, "Don't transfer money to yourself");

        uint previousSenderBalance = balance[msg.sender];
        
        _transfer(msg.sender, recipient, amount);

        emit tokenTransfer(amount, msg.sender, recipient);

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

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

}
2 Likes
#272 
pragma solidity 0.7.5;

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

    event balanceAdded(uint amount, address indexed recipient);
    event balanceTransfered(uint amount, address indexed recipient, address indexed sender);

    modifier onlyOwner () {
        require(msg.sender==owner, "Only the contract creator can add a balance");
        _;
    }

    constructor() {
        owner = msg.sender;
    }

    function addToBalance(uint _toAdd) public onlyOwner() returns (uint) {
        balance[msg.sender] += _toAdd;

        emit balanceAdded(_toAdd, msg.sender);

        return balance[msg.sender];
    }

    function getBalance() public returns(uint) {
        return balance[msg.sender];
    }

    function transfer(address recipient, uint amount) public {
        uint previousSenderBalance = balance[msg.sender];

        emit balanceTransfered(amount, recipient, msg.sender);

        _transfer(msg.sender, recipient, amount);
    }

    function _transfer(address from, address to, uint amount) private {
        balance[from] -= amount;
        balance[to] += amount;
    }
}
2 Likes
#273 
pragma solidity 0.7.5;

contract Bank {

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

    event balanceAdded(uint amount, address indexed depostiedTo);
    event balanceTransfer(uint amount, address indexed recipient, address indexed sender);

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    constructor(){
        owner = msg.sender;
    }

    function addBalance(uint _toAdd) public onlyOwner returns (uint) {
        balance[msg.sender] += _toAdd;
        emit balanceAdded(_toAdd, 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 insufficient");
        require(msg.sender != recipient, "Don't transfer to yourself");
        
        uint previousSenderBalance = balance[msg.sender];

        _transfer(msg.sender, recipient, amount);

        assert(balance[msg.sender] == previousSenderBalance - amount);
        emit balanceTransfer(amount, recipient, msg.sender);
    }

    function _transfer(address from, address to, uint amount) private {
        balance[from] -= amount;
        balance[to] += amount;
    }
}
2 Likes
#274 
pragma solidity 0.7.5;

contract Bank {

    mapping(address => uint) balance;

    address owner;

    event balanceAdded(uint amount, address depositedTo);
    event transferredBalance(uint amount, address recipient, address fromaddress);

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    constructor(){
        owner = msg.sender;
    }

    function addBalance(uint _toAdd) public onlyOwner returns (uint) {
        balance[msg.sender] += _toAdd;
        emit balanceAdded(_toAdd, 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 to yourself");
        uint previousSenderBalance = balance[msg.sender];
        _transfer(msg.sender, recipient, amount);

        assert(balance[msg.sender] == previousSenderBalance - amount);
        emit transferredBalance(amount, recipient, msg.sender);
    }

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

}
2 Likes
#275

Near the beginning of the program define the event as:

event transferSummary(address fromAddress, address toAddress, uint amount);

Then add the emit function to the transfer function

function transfer(address recipient, uint amount) public {
        require(balance[msg.sender] >= amount, "Balance is Insufficient!");
        require(msg.sender != recipient, "Cannot transfer to self.");

        emit transferSummary(msg.sender,recipient,amount);

        uint previousSenderBalance = balance[msg.sender];

        _transfer(msg.sender, recipient, amount);

        assert(balance[msg.sender] == previousSenderBalance - amount);
    }
2 Likes
#276

This was a fun exercise. For whatever reason I was not getting any events in the logs. I switched the version of solidity and then suddenly it worked. I am not sure if the version is the cause or the process of doing that and redeploying the contract made events in logs appear again.

pragma solidity 0.8.14;

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

    address owner;
    event balanceAdded(uint amount, address depositedTo);
    event balanceTransfered(address transferedTo, address daSender, uint amount);

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

    constructor(){
        owner = msg.sender;
    }
    
    
    function addBalance(uint _toAdd) public onlyOwner returns (uint) {
        balance[msg.sender] += _toAdd;
        emit balanceAdded( _toAdd, 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 previousSenderBalance = balance[msg.sender];
        
        _transfer(msg.sender, recipient, amount);
        emit balanceTransfered( recipient, msg.sender, amount);
        assert(balance[msg.sender] == previousSenderBalance - amount);
    }
    
    function _transfer(address from, address to, uint amount) private {
        balance[from] -= amount;
        balance[to] += amount;
    }
    
}
1 Like
#277

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

contract Bank {
mapping(address => uint256) balances;
event Transfer(address from, address to, uint256 amount);
event BalanceAdded(address from, uint256 to);

address owner;

constructor() {
    owner = msg.sender;
}

function addBalance(uint256 _toAdd) public returns (uint256) {
    require(msg.sender == owner, "not owner");
    balances[msg.sender] += _toAdd;
    emit BalanceAdded(msg.sender, _toAdd);
    return balances[msg.sender];
}

function getBalance() public view returns (uint256) {
    return balances[msg.sender];
}

function transfer(address _to, uint256 _amount) public {
    require(balances[msg.sender] >= _amount, "not enough balance");
    _transfer(msg.sender, _to, _amount);
    emit Transfer(msg.sender, _to, _amount);
}

function _transfer(
    address _from,
    address _to,
    uint256 _amount
) private {
    balances[_from] -= _amount;
    balances[_to] += _amount;
}

}

contract Moralis {
struct Person {
uint256 age;
string name;
}
address addr = 0x28B5F14e4D7B2CfF12C97038A06B4f41827b1970;

Person[] people;
mapping(address => uint256) balances;
event Transfer(address from, address to, uint256 amount);
event BalanceAdded(address from, uint256 to);

function getString(string memory text) public pure returns (string memory) {
    return text;
}

function transfer(address _to, uint256 _amount) public {
    require(balances[msg.sender] >= _amount, "not enough balance");
    _transfer(msg.sender, _to, _amount);
    emit Transfer(msg.sender, _to, _amount);
}

function _transfer(
    address _from,
    address _to,
    uint256 _amount
) private {
    balances[_from] -= _amount;
    balances[_to] += _amount;
}

address owner;

constructor() {
    owner = msg.sender;
}

function addBalance(uint256 _toAdd) public returns (uint256) {
    require(msg.sender == owner, "not owner");
    balances[msg.sender] += _toAdd;
    emit BalanceAdded(msg.sender, _toAdd);
    return balances[msg.sender];
}

function getBalance() public view returns (uint256) {
    return balances[msg.sender];
}

function addPerson(uint256 _age, string memory _name) public {
    Person memory newPerson = Person(_age, _name);
    people.push(newPerson);
}

function getPerson(uint256 _index)
    public
    view
    returns (uint256, string memory)
{
    Person memory personToReturn = people[_index];
    return (personToReturn.age, personToReturn.name);
}

// take a number as input and return the number + n
// pure fƶr den endast skickar nyttjar variabler och funktioner inom funktionen
function count(uint256 _number) public pure returns (uint256) {
    // uint256 i = 0;
    // while (i < 10) {
    //     number++;
    //     i++;
    //     console.logUint(i);
    // }
    for (uint256 i = 0; i < 10; i++) {
        _number++;
    }
    return _number;
}

function getNumber(uint256 _number) public pure returns (uint256) {
    return _number;
}

uint256 number;

function setNumber(uint256 _number) public {
    number = _number;
}

uint256[] arr;

function addNumber(uint256 _number) public {
    arr.push(_number);
}

function getNumberA() public view returns (uint256[] memory) {
    return arr;
}

}

1 Like
#278 
pragma solidity 0.7.5;

contract Bank {
    
    mapping(address => uint) balance;
    address owner;
    event balanceAdded (uint amount, address indexed depositedTo);
    event withdrow (address comingFrom, address indexed goingTo, uint amount);
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    constructor() {
        owner = msg.sender;
    }

    function addBalance(uint _toAdd) public onlyOwner returns(uint) {
        balance[msg.sender] += _toAdd;
        emit balanceAdded(_toAdd, 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 send money to yourself");
        
        uint previousSenderBalance = balance[msg.sender];
        
        _transfer(msg.sender, recipient, amount);
        
        assert(balance[msg.sender] == previousSenderBalance - amount);

        emit withdrow(recipient, msg.sender, amount);
    }

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

hi, how is event different from ā€œconsole logā€ in JS

#280

the event is stored on the block where the transaction happens.

console.log is a js method to log something at the run time of the process.

Their use case is completely different.

Carlos Z

#281 
pragma solidity 0.7.5;

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

    address owner;

    event balanceAdded(uint amount, address depositedTo);

    event transferHistory(uint amount, address indexed transferTo, address indexed transferFrom);

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    constructor(){
        owner = msg.sender;
    }

    function addBalance(uint _toAdd) public onlyOwner  returns (uint) {
        balance[msg.sender] += _toAdd;
        emit balanceAdded(_toAdd, 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);

        uint previousSenderBalance = balance[msg.sender];

        _transfer(msg.sender, recipient, amount);

        assert(balance[msg.sender] == previousSenderBalance - amount);
        emit transferHistory(amount, recipient, msg.sender);
    }

    function _transfer(address from, address to, uint amount) private {
        balance[from] -= amount;
        balance[to] += amount;
    }
}
1 Like
#282 
pragma solidity 0.7.5; 

contract Bank {

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

    event balanceAdded(uint amount, address indexed addedTo);
    event transferDone(address indexed recipient, uint amount, address indexed sender);

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    modifier costs(uint price) {
        require(msg.value >= price);
        _;
    }



    constructor(){
        owner = msg.sender;
    }

    function addBalance(uint _toAdd) public onlyOwner returns (uint){
        balance[msg.sender] += _toAdd;
        emit balanceAdded(_toAdd, 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 send money to yourself."
        );

        uint previousSenderBalance = balance[msg.sender];

        _transfer(msg.sender, recipient, amount);
        emit transferDone(recipient, amount, msg.sender);

        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;
    }

}
1 Like
#283 
pragma solidity 0.7.5; 

contract Bank {
    
    mapping (address => uint) balance; 
    address owner; 
    
    event balanceAdded(uint amount, address indexed depositedTo) ;

    event amountExecuted(uint amount, address depositedTo, address depositedFrom); //solution

    modifier onlyOwner {
        
        require(msg.sender == owner);
        _; 
    }
    
    constructor() {
        owner = msg.sender;
    }
    
    function addBalance(uint _toAdd) public onlyOwner returns (uint) {
        
        balance[msg.sender] += _toAdd;
        emit balanceAdded(_toAdd, 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, "Can't transfer money to yourself");
        
        uint previousSenderBalance = balance[msg.sender];
        
        _transfer(msg.sender, recipient, amount);
        
        assert(balance[msg.sender] == previousSenderBalance - amount);
        
        emit amountExecuted(amount, recipient, msg.sender); //Solution
        
    }
    
    function _transfer(address from, address to, uint amount) private {
        
        balance[from] -= amount; 
        balance[to] += amount;
        
    }
    
}
1 Like