Quantum – Auditing Destruction Events

How to make sure the destruction event worked?

As you know, the biggest value of Quantum tokens comes from its deflationary properties. Quantum Liquidity Pool is used in multiple ways to generate income (you can read more about it on https://www.quantumproject.org/), which is used in monthly destruction events. With our monthly income we buy back Quantum tokens on the market and destroy the tokens by sending them to a black hole address, therefore increasing the value of tokens by decreasing the number of tokens in circulation.

There have been three destruction events by now, decreasing the total number of Quantum tokens for nearly 2 million, decreasing the total. The latest destruction event was the largest by now, destroying over 1,2% of all remaining tokens in circulation.

But how can you know the destruction event worked? The value of Blockchain lies in removing the need of trust between the parties – we can rely on technology to d

o what it was designed to do, creating a cryptographic proof of transaction in the process. That way there is no need for anyone to simply trust our word that we are buying and destroying the tokens – you can always check the records on the blockchain, following the entire process.

Checking Quantum smart contract

You can use any of multiple blockchain explorers, in this article we are going to use etherscan.io. You can view the details of Quantum token on the following address: https://etherscan.io/token/0x671abbe5ce652491985342e85428eb1b07bc6c64. From there, clicking on the contract address will bring you to the details of Quantum’s smart contract, where you can also see all the transactions made until now. What we are interested in is the smart contract’s source code – we have made the source code readable and you can view and analyze it by clicking on the “Contract Source” tab.

First you need to understand some basics of Solidity programming languages – anyone that has been programming in similar languages, like Java, C++, etc., will find Solidity code easy to understand. In multiple functions, you will find references to msg.sender – this is the address of the person calling the contract. With that in mind, inspect the function

burn(uint256 _value):

        function burn(uint256 _value) returns (bool success) {

                    if (balances[msg.sender] < _value) return false;

            balances[msg.sender] -= _value;

            _totalSupply -= _value;

            Burn(msg.sender, _value);

            return true;


You will see that the function effectively destroys a certain amount of tokens from the caller’s wallet – the amount being defined with the parameter _value. The function also triggers an event called “Burn“. If you want to be notified when a destruction events happens, you can subscribe to events from Ethereum smart contracts in different ways, one of them being a simple command line tool you can find here: https://www.npmjs.com/package/ethereum-listener.

How to verify the source of Quantums going into our black hole address?

All the tokens we are regularly buying on the market are sent to a black hole address: https://etherscan.io/token/0x671abbe5ce652491985342e85428eb1b07bc6c64?a=0x04fADdeB0E9a3D2f8969a98D3e87EcF570fe4B46. The black hole address is a standard Ethereum address, but the tokens in the address are being burned at the destruction event at the end of each month. Open the Etherscan link to the black hole address and choose any incoming transaction. By depositing and withdrawing your own QAU to different exchanges, you can clearly get to conclusion that the following addresses belong to these exchanges:

  • 0x208bf0a139ff30814b816e7d8e152afd7260f998 (Hitbtc),
  • 0x524bcf55ea680ca6ac4dd0b45e93e64d36df6498 (Livecoin),
  • 0x3271651c4bbd96d00290675e0db2e6a474bdd937 (Gatehub).

How can you make sure Quantums were destroyed?

Now we can finally check whether – and how many – Quantums were burned in a destruction event. First you would want to get the list of destruction events, available on our website: https://www.quantumproject.org/destruction/. Here you can see transaction links for each of the specific events, linking to Etherscan transaction webpage – click on the link you are interested in. On the bottom of the webpage you can check “Input Data”. We can see the burn function was called in this transaction from our black hole address.

As we earlier inspected the burn function, we know it only has one parameter: the amount of tokens to be burned – the parameter is shown in hexadecimal format (example from our last destruction event): [0]:00000000000000000000000000000000000000000000000000005b68646e6a99. Open any hexadecimal to decimal converter, for example: http://www.binaryhexconverter.com/hex-to-decimal-converter. Delete the leading zeroes from the parameter and paste the remaining number (5b68646e6a99) into the Hex Value field. In our example we get the result 100503919684249. The result represents the integer amount of the smallest indivisible units of a token to be burned. Since Quantum has 8 decimal places you need to divide the result by 100000000. The result (1005039.19684249 QAU) is the amount of Quantums destroyed in this burn() call. Since immutability and transparency are the paramount properties of Ethereum blockchain, anyone in the world can view all historic blockchain transactions. This means the described procedure can be done by anyone in the world for any destruction event in history of Quantum project.