Replace Energy Coin was an ERC-20 token which was offered in May 2019. And closed sometime in late June 2019/ The goal was to raise $610,00 USD in funding. The ICO completed and apparently traded on a few obscure exchanges. In September of 2019 it lost all of its value on the fexpro exchange.

As they were touting their IPO they made some very bold claims about the future of this organization: Here are a few:

  • Let’s help to save our planet from Global Warming, Air Pollution, Water Pollution, Hazardous Waste, Resource Mining etc by applying solar panel everywhere. Or by supporting our project of solar energy generator.
  • Replace Energy Coin is going to help our planet by using solar panel to generate energy. Solar energy is radiant light and heat from the Sun that is harnessed using a range of ever-evolving technologies such as solar heating, photovoltaics, solar thermal energy, solar architecture, molten salt power plants and artificial photosynthesis.
  • Replace Energy makes a tremendous amount of profit. 60% will be shared with all REC Token holders and directly transferred to the holders’ account.
  • The main applications of solar energy technologies in Mexico have been for non-electric active solar system applications for space heating, water heating and drying crops. As in most countries, wind power development preceded solar power initially, due to the lower installation cost. Since solar power is not available during the night, and because wind power tends to be complementary to solar, a mix of both can be expected. Both require substantial storage to compensate for days with no wind and no sun. Batteries provide short term storage, and pumped hydroelectricity provides longer term storage. Mexico has been already in solar energy and we’ll make profit here.

Some of the claims were particularly alarming such as the company’s claim that they make a “tremendous amount” of profit. And that they would share 60% transferred directly to the holders account. And clearly from the source code which is included there is no such language in the actual smart contract.

The people behind this ICO is also somewhat mysterious. Some of them just used names like Mr. Michael or Adnan. Some didn’t even list their names at all. They did post some pictures though:

No name: On some of the photos, Seems Legit

Their advisory board was kind of the same. People hiding behind nicknames like Mr. David, Mr. Fahman. The only one with something that looked like a real name was Mario Krenmayr who actually had a facebook page with photos that matched what was on their promotional site.

The company said, “REC mission is to make use of the transparency and fairness of the blockchain to solve these problems, making the flow of investment intended to improve the world more transparent

on CoinCodex it was described as “Replace Energy Coin will help our planet generate energy through the use of solar panels. Solar energy is radiant Sun light and heat harnessed using a variety of ever-changing technologies such as solar heating, photovoltaics, solar thermal energy, solar architecture, molten salt power plants and artificial photosynthesis.

The source code consisted of one solidity contract file. With one commit on github. It was 178 lines of code mostly comments. The source code was as follows:

/**
 * Source Code first verified at https://etherscan.io on Friday, May 10, 2019
 (UTC) */

/**
 * Source Code first verified at https://etherscan.io on Sunday, April 28, 2019
 (UTC) */

pragma solidity ^0.4.4;

contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant returns (uint256 balance) {}

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) returns (bool success) {}

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}

    /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @param _value The amount of wei to be approved for transfer
    /// @return Whether the approval was successful or not
    function approve(address _spender, uint256 _value) returns (bool success) {}

    /// @param _owner The address of the account owning tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens allowed to spent
    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}

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

}

contract StandardToken is Token {

    function transfer(address _to, uint256 _value) returns (bool success) {
        //Default assumes totalSupply can't be over max (2^256 - 1).
        //If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
        //Replace the if with this one instead.
        //if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        if (balances[msg.sender] >= _value && _value > 0) {
            balances[msg.sender] -= _value;
            balances[_to] += _value;
            Transfer(msg.sender, _to, _value);
            return true;
        } else { return false; }
    }

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        //same as above. Replace this line with the following if you want to protect against wrapping uints.
        //if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
            balances[_to] += _value;
            balances[_from] -= _value;
            allowed[_from][msg.sender] -= _value;
            Transfer(_from, _to, _value);
            return true;
        } else { return false; }
    }

    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }

    function approve(address _spender, uint256 _value) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }

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

    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;
    uint256 public totalSupply;
}

contract ReplaceEnergyCoin is StandardToken { 

    /* Public variables of the token */

    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    */
    string public name;                   // Token Name
    uint8 public decimals;                // How many decimals to show. To be standard complicant keep it 18
    string public symbol;                 // An identifier: eg SBX, XPR etc..
    string public version = 'H1.0'; 
    uint256 public unitsOneEthCanBuy;     // How many units of your coin can be bought by 1 ETH?
    uint256 public totalEthInWei;         // WEI is the smallest unit of ETH (the equivalent of cent in USD or satoshi in BTC). We'll store the total ETH raised via our ICO here.  
    address public fundsWallet;           // Where should the raised ETH go?


    // which means the following function name has to match the contract name declared above
    function ReplaceEnergyCoin() {
        balances[msg.sender] = 300000000000000000000000000;
        totalSupply = 300000000000000000000000000;
        name = "ReplaceEnergyCoin";
        decimals = 18;
            symbol = "REC";
        unitsOneEthCanBuy = 160;
        fundsWallet = msg.sender;
    }
    /** 
   *  sale start 
    * ---------------------
    
    * presale
	uint public presaleStartTime = 1537876800; // Saturday, 01 June 2019 19:00:00 GMT+07:00
    uint256 public presalePerEth = 1075268;
    
    * ico
    uint public icoStartTime = 1539190800; // Saturday, 15 June 2019 00:00:00 GMT+07:00
    uint256 public icoPerEth = 1075268;
    
    * ico1
    uint public ico1StartTime = 1540573200; // Monday, 01 July 2019 00:00:00 GMT+07:00
    uint256 public ico1PerEth = 1075268;
    
    * ico2
    uint public ico2StartTime = 1541955600; // Monday, 15 July 2019 00:00:00 GMT+07:00
    uint256 public ico2PerEth = 1075268;
    
    * ico start and end
    uint public icoOpenTime = presaleStartTime;
    uint public icoEndTime = 1543251600; // Thursday, 01 August 2019 00:00:00 GMT+07:00
    
	*/
    
    
    

    function() payable{
        totalEthInWei = totalEthInWei + msg.value;
        uint256 amount = msg.value * unitsOneEthCanBuy;
        require(balances[fundsWallet] >= amount);

        balances[fundsWallet] = balances[fundsWallet] - amount;
        balances[msg.sender] = balances[msg.sender] + amount;

        Transfer(fundsWallet, msg.sender, amount); // Broadcast a message to the blockchain

        //Transfer ether to fundsWallet
        fundsWallet.transfer(msg.value);                               
    }

    /* Approves and then calls the receiving contract */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);

        //call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
        //receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
        //it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
        if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
        return true;
    }
}

Their old website is permanently offline. The github repository is not being updated. Their coin lost almost all of its value 3 months after it started trading, and we don’t know for certain but something tells us to advise holders of the token not to hold your breath on profit distributions from the “tremendous amount” of profits this company has.