Ethertote Token Sale

The Ethertote public token sale starts on November 5th 2018 and runs for just 14 days.

4,500,000 TOTE tokens are up for grabs, and ALL unsold tokens from the token sale will be immediately burned.

You often hear this “all unsold tokens will be burned” from a lot of ICO’s, and it’s obviously a good thing for those who purchased tokens, as it further reduces token supply and this usually impacts on token value in a positive way.

But how do you know they will actually do it?

Unfortunately, a lot of these “scam” ICO’s make promises like this, but unfortunately do not provide any proof of the claim they are making. Are you expected to just trust them not to recoup all the tokens that didn’t get sold?

Well here’s the thing. A lot of the tokens on the market are ethereum ERC20 tokens. If they are ERC20 tokens, then the actual token “minting” process was formed as part of a smart contract, one of the biggest (if not THE biggest!) selling points of ethereum.

So if the tokens were generated using a smart contract, and the ICO/token sale process is governed by a smart-contract, then surely the “burning” process of unsold tokens, should also be part of a smart-contract, for all the world to see on the public block-chain right?

Unfortunately a lot of them aren’t. They make bold claims of “all unsold tokens to be burned” but don’t show you the process for burning them. This is how EtherTote is different. Not only do we state, “all unsold tokens will be burned immediately after the token sale ends, but we will actually explain in detail how that is going to happen, as well as explain how it is now out of our hands, and even we cannot reverse this process!

OK lets show you how.

The first thing you’ll need are the smart contract addresses:

The TOTE token contract address that “minted” the tokens to begin with can be found here: 0x740a61ad4fb99af22fb42ca25f548640ae64911d#balances

Click on this link and you will see exactly where all the TOTE tokens are right now.

The next address, which can be seen if you visit the first link I shared, is the actual token sale address. This is the smart contract that will actually accept eth during the sale, and in return will send TOTE tokens back to the buyer immediately.

If you click on the link, you’ll see this smart contract is the Token Sale contract, and if you click on the “ERC20 Token Txns” tab, you will be able to see that the contract currently holds all 4,500,000 of the TOTE tokens that go on public sale.

OK so how does a potential token buyer know that the unsold tokens will get burned?

To do this, we need to explore the actual code of the token sale smart contract. If you open up the “Code” tab, you can see the original solidity programming code that formed this smart contract.

The first line of code I would like to draw your attention to is line 93:

address public tokenBurnAddress = 0xadCa18DC9489C5FE5BdDf1A8a8C2623B66029198;

So the Token Sale smart contract includes a variable “tokenBurnAddress” which is referring to another address, which is in fact the address of the Token Burn contract. I will come back to this in a minute.

OK so the next lines of code to focus on is a function (lines 199–206)

// this function will send any unsold tokens to the null TokenBurn contract address
 // once the crowdsale is finished, anyone can publicly call this function!
 function burnUnsoldTokens() public {
 require(tokenSaleIsPaused == false);
 require(tokenSaleHasFinished() == true);
 token.transfer(tokenBurnAddress, tokenSaleTokenBalance());
 emit TokensBurned(“tokens sent to TokenBurn contract”, now);

The first couple of lines are simply comments. Anything in solidity that begins with // is simply a comment to explain what a section of code does.

OK so we have a function called “burnUnsoldTokens” and the function can be called by anybody, hence the “public” keyword.

In order for anyone to call this function, the function itself needs to adhere to a couple of requirements, indicated by using “require” statements.

The first require statement is as follows:

require(tokenSaleIsPaused == false);

What this is telling us is that the Token sale cannot be in a paused state. It must be false (i.e. not paused) for the function to execute correctly.

The token sale will only be paused in an emergency situation, so aside from exceptional circumstances, this will already be set to false.

The next require statement is as follows:

require(tokenSaleHasFinished() == true);

Hopefully you can immediately see the importance of this statement! The token sale must actually complete (over 7 days) before anyone can burn all the remaining tokens in the contract!

The next line of code is the actual token transfer element. It shows the following:

token.transfer(tokenBurnAddress, tokenSaleTokenBalance());

What this is basically saying is transfer to the “tokenBurnAddress” the entire balance of tokens from this contract. So basically whatever amount of tokens make up the contract balance once the token sale completes (i.e. the unsold tokens) then send them to the “tokenBurnAddress”.

Got that? OK so we now know where the tokens will be sent once the sale ends, but let’s now look at the actual smart contract of the tokenBurnAddress:

This is a very simple smart contract, but it’s still important to explain what it’s doing.

Let me first of all draw your attention to the varaible on line 33:

address public newOwner = 0x0000000000000000000000000000000000000000;

This is a null/void address that nobody can own. So we are assigning the variable of “newOwner” to this null address.

Now let’s have a look at the constructor method. The constructor method is a function that gets called once (and only once!) when the smart contract first gets deployed onto the block-chain. Basically the constructor executes the tasks within the method, and then they are stored on the contract. Let’s look at this constructor method:

// constructor executed upon deployment to the blockchain
 constructor() public {
 thisContractAddress = address(this);
 admin = newOwner;

As already explained the first line is just a comment, indicated by the //

So the constructor method is declared and is a public function.

The first thing it does is assign the address of the smart contract to a variable called “thisContractAddress”

With variable assignment, anything to the right of the = is assigned to the variable on the left-hand side of the =

So “thisContractAddress” is given the actual smart contract address.

The next line is:

admin = newOwner;

Now because we already declared new owner as the null address (0x0000000000000000000000000000000000000000) it means that the admin of this contract is now……well nobody. Nobody can call functions on it, unless they are specified as “public”

Have a closer look at the code for yourself. Can you see any functions relating to “withdrawing” tokens? No? That’s because there aren’t any! So basically now that this smart contract is deployed onto the block-chain, and the owner is the null address, it means that once tokens go into this contract, they NEVER come back out again. They stay there forever. This is how we use the phrase “burned” tokens, because nobody can ever retrieve them.

So now you can see that once the EtherTote token sale ends, all tokens will head off to this Token Burn smart contract and those tokens will be locked away or “burned” forever!.

IF you’d like to participate in our token sale, visit our website