We are going to work on going with an easier implementation of Argon2d with CPU mining with a Spork to increase memory cost and parallelism once fast-verify is completed.
We will require some time to test and we will report back within the next 48 hours with info.
Binaries will be released and we will be forwarding this code to Bittrex.
So you guys are going to implement Argon2d differently and then change it up later? In an effort to push the release out as soon as possible?
Yes, this is the plan. Argon2d will be CPU only until we have written the new PoW algorithm with much faster verification of blocks than is currently possible. The new algorithm is an improved version of Argon2d that the creator of argon calls Merkle Tree Proof (MTP). It is not yet implemented into code yet, only in math. This is what I will be focusing on until I complete it or if someone else does before me, then awesome. We haven't finalized the details yet but we will be offering bounties for a GPU Miner and also for anyone who wants to try writing a successful, working implementation of MTP.
The paper, Egalitarian Computing by Alex Biryukov and Dmitry Khovratovich, University of Luxembourg, can be found here:
https://www.usenix.org/conference/usenixsecurity16/technical-sessions/presentation/biryukov and there is a nice slideshow there as well.
This is the algorithm that we will be implementing, which can be examined in more detail in the paper found at the link above:
MTP: Merkle-tree based Proof-of-Work.
Provers algorithm
Input: Challenge I, parameters L,d.
1. Compute F(I) and store its T blocks X[1], X[2],
..., X[T] in the memory.
2. Compute the root Φ of the Merkle hash tree (see
Appendix A).
3. Select nonce N.
4. Compute Y0 = H(Φ,N) where G is a cryptographic
hash function.
5. For 1 ≤ j ≤ L:
ij = Yj−1 (mod T);
Yj = H(Yj−1,X[ij]).
6. If YL has d trailing zeros, then (Φ,N,Z ) is the
proof-of-work, where Z is the opening of 2L
blocks {X[ij − 1],X[φ(ij)]}. Otherwise go to Step
3.
Output: Proof (Φ,N,Z ).
The verifier, equipped with F and H, runs Algorithm
2.
Algorithm 2 MTP: Verifiers algorithm
Input: Proof (Φ,N,Z ), parameters L,d.
1. Compute Y0 = H(Φ,N).
2. Verify all block openings using Φ.
3. Compute from Z for 1 ≤ j ≤ L:
X[ij] = F(X[ij −1],X[φ(ij)]);
Yj = G(Yj−1,X[ij]).
4. Check whether YL has t trailing zeros.
Output: Yes/No.