Early glimpse at the Krakin’t solo miner and how it will function. The secret is now revealed… and here is why…

The original idea was to take the BTC model, exactly the way it was designed, and to add the proof of burning instead of the proof of work. The problem is, we need to go back and forward the block numbers, like with some kind of a time-machine. This can be done, but it is relying on math rather than the block-chain executions. As I begun designing the model, first thing I have noticed is that not everything can be calculated using Solidity while maintaining the cheap GAS prices. Math is something we take for granted, since computers are very good at solving it, while doing it on Ethereum would mean wasting a lot of money. That was the first barrier that I have encountered.

Second stage of modelling involved simplifying the math equations into linear equations, using integrals and so on… so I got the simplest math formulas such as :

c-circulating supply
x-block number
r-reward
s-start reward
y-constant

x = (1.0/2.0)*(sqrt(y*((s*s*y) — (4*c))) + (s*y))
r = s — ((2*x)/y)
c = ((s*x*y) — (x*x))/y

It was something I wanted to build the miner with, and hopefully apply for a patent as it becomes more complicated. However, I have found out that the proof of burning is an older concept (cannot be patented) and that miner would stop functioning once the equation for “r” starts giving less awards. In other words, the user would suddenly start losing tokens while mining the new ones. This made no sense at all. A different solution would be to simply stop the miner and say that there is nothing more to be mined… but somehow I didn’t like the idea of distributing the tokens and then stopping the whole thing.

Therefore, I had to redesign the whole thing again and make it even simpler! Since it is so simple (a grade 7 student can design it), I cannot protect it with any patent, and the only thing that I can do is share it.

The idea is to:

1. Burn the tokens
2. Get the current supply (after burning), and subtract it from 21,000,00.0. Lets call it “The Gap”.
3. Calculate and memorize the percentage in comparison to the gap, and call it the mining power, and add it to a total mining power for the user in question.
4. User can get their tokens back, without losses as long as the current supply + returned tokens is not greater than 21,000,000.0. If there were more tokens burned, then the gap is greater and the rewards are given with it. This is how the inflation happens, and this is how new tokens are mined. However, if the mining gives more than 21,000,000.0, then the user can either accept their losses (mining up to 21,000,000.0), or not mine anything at all while waiting for someone to burn more tokens.

Instead of doing the epochs, I really wanted to let the user get their rewards whenever they wanted. Furthermore, I didn’t want the whales to be a bad thing, but rather a device that would normalize the distribution of tokens.

If I made the whole concept a trade without any losses, then new tokens are simply mined by inflating the current supply. This is now very similar to staking mechanisms. However, we are simply regulating the current supply of tokens that exist on the network while everyone either profits or not looses. With this mechanism, we are now entering the domain of stable-coins which regulate their prices by minting and burning a supply. However, we are not introducing a stable-coin but rather a mechanism that makes the market price more precise, depending on a token demand rather than just the exchange trades.

The whales can help us here a lot. If the whale burns their tokens, then the users can stop burning, take the rewards, and not give an opportunity to a whale to get rich and fat. On the other hand, if whale takes their reward, the users with smaller amounts of tokens can either get their tokens back (hopefully with no losses) and sell them on exchange before the whales dump the price. Therefore, the whales are important to Krakin’t Eco-system to ensure the equal distribution of tokens. However, one thing that is difficult to design is… once the whale blocks the possible earnings, users would have to mine their tokens back and repeat the burning, unless they want to wait for enough tokens to be burned so they can begin earning more tokens. What we can do, however, is have the front-end that notifies the user how many tokens need to be burned before they start earning more tokens.

However, this also means that with such a simple design, we can all regulate distribution, lower the amount of the price manipulation, and have some normal market prices.

Now, the only thing remained is to figure how to add fractions in Solidity, but that doesn’t seem to be an issue given all the obstacles I had to avoid so far… I think I already solved it, in hope that 2²⁵⁶ (115 quattuorvigintillion …) will give enough numbers. Otherwise, I will have to lower the number of token decimals, to lets say, 10.

Furthermore, the miner will have a safety stop-button, but that will be discussed much later.

Once this is developed and deployed, we will need some nice front-end tools, portfolio trackers, etc. Next step, of course, will be having a group mining… and that is something I will leave for the future…