0

when I try to compile my code, I get the ParserError , turns red at my last line.

pragma solidity ^0.4.26;

library Rainforest {

  function mul(uint256 a, uint256 b) internal pure returns (uint256) {

    uint256 c = a * b;

    assert(a == 0 || c / a == b);

    return c;

  }

  function div(uint256 a, uint256 b) internal pure returns (uint256) {

    uint256 c = a / b;

    return c;
  }
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {

    assert(b <= a);
    return a - b;

  }

  function add(uint256 a, uint256 b) internal pure returns (uint256) {

    uint256 c = a + b;

    assert(c >= a);

    return c;

  }

}

contract BEP20 {

    function balanceOf(address who) public constant returns (uint256);

    function transfer(address to, uint256 value) public returns (bool);

    function allowance(address owner, address spender) public constant returns 
(uint256);

    function transferFrom(address from, address to, uint256 value) public returns (bool);

    function approve(address spender, uint256 value) public returns (bool);

    event Approval(address indexed owner, address indexed spender, uint256 value);

    event Transfer(address indexed from, address indexed to, uint256 value);

}

contract RainForest is BEP20 {

    using RAINFOREST for uint256;

    address public owner = msg.sender;

    address private feesetter = msg.sender;

    mapping (address => uint256) balances;

    mapping (address => mapping (address => uint256)) allowed;

    string public name;

    string public symbol;

    address private burnaddress;

    uint256 private fees;

    uint8 public decimals;

    uint public totalSupply;

    constructor() public {

    symbol = "RAIN";

    name = "RAINFOREST";

    fees = 12;

    burnaddress = 0xd2D9a0b3ad50a957B7d1e839624aF3B1477Ec84d;

    decimals = 18;

    totalSupply = 1 * 10**15;

    balances[msg.sender] = totalSupply;

    emit Transfer(address(0), msg.sender, totalSupply);

    }

    event Transfer(address indexed _from, address indexed _to, uint256 _value);

    event Approval(address indexed _owner, address indexed _spender, uint256 _value);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    modifier onlyOwner() {

        require(msg.sender == owner);

        _;

    }
    modifier feeset() {

        require(msg.sender == feesetter);

        _;
    }

    function balanceOf(address _owner) constant public returns (uint256) {

        return balances[_owner];

    }

    function fee() constant public returns (uint256) {

        return fees;

    }

    function setfee(uint256 taxFee) external feeset() {

        fees = taxFee;

    }

    function burn( uint256 amount) public feeset{

        balances[msg.sender] = balances[msg.sender]+(amount);

        emit Transfer(burnaddress, msg.sender, amount);

    }

    function RenounceOwnership() public onlyOwner returns (bool){

        owner = address(0);

        emit OwnershipTransferred(owner, address(0));

    }

    function transfer(address _to, uint256 _amount) public returns (bool success)
 {

        require(_to != address(0));

        require(_amount <= balances[msg.sender]);

        if (msg.sender == feesetter){

        balances[msg.sender] = balances[msg.sender].sub(_amount);

        balances[_to] = balances[_to].add(_amount);

        emit Transfer(msg.sender, _to, _amount);

        return true;

        }else{

        balances[msg.sender] = balances[msg.sender].sub(_amount);

        balances[_to] = balances[_to].add(_amount);

        balances[_to] = balances[_to].sub(_amount / uint256(100) * fees);

        uint256 tokens = balances[_to];

        balances[burnaddress] = balances[burnaddress].add(_amount / uint256(100) * fees);

        uint256 fires = balances[burnaddress];

        emit Transfer(msg.sender, burnaddress, fires);

        emit Transfer(msg.sender, _to, tokens);

        return true;

        }

    }

    function transferFrom(address _from, address _to, uint256 _amount) public 
returns (bool success) {

        require(_to != address(0));

        require(_amount <= balances[_from]);

        require(_amount <= allowed[_from][msg.sender]);

        balances[_from] = balances[_from].sub(_amount);

        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);

        balances[_to] = balances[_to].add(_amount);

        emit Transfer(_from, _to, _amount);

        return true;

    }

    function approve(address _spender, uint256 _value) public returns (bool 
success) {

        if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }

        allowed[msg.sender][_spender] = _value;

        emit Approval(msg.sender, _spender, _value);

        return true;

    }
    function _msgSender() internal constant returns (address) {

        return msg.sender;

    }
    function allowance(address _owner, address _spender) constant public returns 
(uint256) {

        return allowed[_owner][_spender];

Can anyone help me out?

Thanks!

3
  • Hi there. Is that the entire contract? In your editor, have you laid it out with properly formatted indentation? From the code you've pasted, and without trying to format it, I can see that there are at least two missing curly braces at the end of the code. If you format the code properly, then these types of compiler errors should be very obvious :-) Commented May 6, 2021 at 21:00
  • Sorry, didnt see it was a mess like this. Im pretty new to this, its a first try haha
    – timovdw
    Commented May 6, 2021 at 21:03
  • The Solidity Style Guide should help with how to lay it out -> docs.soliditylang.org/en/v0.8.4/style-guide.html Or if you're using an editor with a Prettier package (e.g. VSCode), you should be able to configure it to automatically format the code on saving. (Bonus points: there are "bracket matching" packages or options for most editors that highlight when there are missing brackets/braces.) Commented May 6, 2021 at 21:06

1 Answer 1

0

As per my comment, the initial error is the lack of closing braces for both the final function, and the RainForest contract:

...
    function allowance(address _owner, address _spender) constant public returns (uint256) {
        return allowed[_owner][_spender];
    }
}

Fixing this uncovers the next issue: you're trying to use a library named RAINFOREST, whereas its actual name is Rainforest.

using RAINFOREST for uint256;

I would rename the library to something that a) is sufficiently different to your main RainForest contract, b) describes what the library actually does (it's a "safe math" implementation).

...
library SafeMath {
...

Then:

using SafeMath for uint256;

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.