One of the most essential aspects of the Nakamoto consensus is proof of work (PoW). Despite the fact that it is inefficient in terms of energy, its simplicity and resilience have attracted worldwide interest. Since the inception of Bitcoin, practically all cryptocurrencies have been influenced by PoW. Some new consensus algorithms, such as PoS and PoA, are even naming their components after it.
PoW has a lot of wonderful qualities, but that doesn't imply it's a panacea for all problems. The so-called 51 percent attack is one of the most significant danger scenarios. It was regarded to be only a notion for a long time, but the situation has altered with time. Cryptographic hash functions are the foundation of Bitcoin and most of its variations. Because such functions could be readily addressed with specialized gear, more and more individuals began mining bitcoins with highly efficient ASICs. The 51 percent assault became a serious concern as a result of this, bringing people together to talk about ASIC resistant algorithms.
Cuckoo cycle
One of the most promising ASIC-resistant architectures is the Cuckoo cycle. It creates random bipartite graphs from a message and attempts to determine whether or not a subgraph with the needed attribute exists. As you may have seen, Cuckoo cycle chooses a cycle as a target, but the algorithm is unaffected by this choice. Predetermined constants dictate the number of vertices and edges, which are deliberately planned to be big enough that the memory need surpasses the capability of a single chip. The graph's edges are formed from a message and indices in a given range, and the conclusion is said to be nearly difficult to anticipate.Unlike other algorithms, proving the work for the Cuckoo cycle is rather different. Normally, just a single integer nonce is necessary to prove work, but the Cuckoo cycle requires two types of nonces. Micro nonces are the seed values for graph edges, whereas macro nonces correspond to nonces in other PoWs. A verifier can fully decide whether the proof is true by presenting both values, using a fraction of the resources required by a prover. It totally fulfills the required feature of a good PoW, which is "difficult to prove but simple to check."
Is it true that it is ASIC-proof?
Memory devices are inherently sluggish. As engineers, we've always hoped for lightning-fast memory access, but normal market products aren't excellent, so we have no alternative but to implement improvements to alleviate bottlenecks. In the area of ASICs, where interface latency is the most critical component in determining overall device speed, the situation is similar. Even with cutting-edge technology, read/write memory performance is still an order of magnitude slower than other computer activities.
Most engineers dislike memory bound functions because they are sluggish, but they might be ideal for solutions that need to purposely slow down calculation speeds. This prompted the adoption of memory constrained functions in PoW, and several current ASIC proof methods use this feature. It's important to realize that simply slowing down ASICs using a memory hard loop isn't adequate. To make ASICs more resistant, 1) memory access should be unexpected, and 2) the needed computation between two memory accesses should be near to zero.
All of these conditions are met by the Cuckoo cycle. A single calculation consumes so much memory that it can't fit on a single chip. Siphash is used to construct graph edges, resulting in unexpected graph access. Furthermore, because siphash is fast enough in most devices, the computation required between two memory accesses may be ignored. The most surprising aspect is that it is simple to get desired memory utilization and difficulty by just altering a few settings. This whitepaper has some recommendations, however you are free to pick whatever values you like!
Of course, some may object that it hasn't been "proved" to be ASIC proof, and I agree. However, I am convinced that those who are skeptical about the technology would reconsider after viewing the primary repository. It's already being utilized by major players like as MimbleWimble, and it's backed by well-known mining companies such as Genesis Mining and Claymore. In addition, there is a considerable reward for developing algorithms that are quicker than existing ones, however only a few people have succeeded in doing so. It's been almost a year since the last algorithm modification, so it's safe to say it's in a good place.