Provably Fair Mechanism

This section explains the provably fair mechanism behind Crypta. The system ensures that every price movement is fair, transparent and cryptographically verifiable.

The system uses a one-way precomputed hash chain of SHA-512 hashes in combination with a future Bitcoin block hash as a salt to generate provably fair, tamper-proof and verifiable random numbers.

Hash Chain Commitment

The chain begins with a secret root hash, denoted H_1.

Each subsequent hash is generated and linked by using the SHA-512 function:

$$H_{(n+1)} = SHA512(H_n)$$

This continues for 100 million iterations, resulting in:

$$H_2=SHA512(H_1)$$

$$H_3=SHA512(H_2)$$

.......

$$H_{100,000,000}=SHA512(H_{99,999,999})$$

Every hash in the chain will be used to generate random movements in the synthetic price chart.

During trading, Crypta uses the hashes in reverse order, starting with H_100,000,000 and ending with the secret root hash H₁.

The final hash H_100,000,000 is published publicly as a commitment and locks in the entire chain.

This ensures that future hashes cannot be derived from previously revealed ones, but each revealed hash can be verified as being part of the chain by checking:

$$SHA512(H_n) = H_{n+1}$$

Bitcoin Block Hash Salt

Crypta commits to incorporating the hash of a future, unmined Bitcoin block as the external and unpredictable salt.

This salt introduces independent entropy beyond the control of any party - including the Crypta team. It is combined with the pre-committed hash chain to generate price movements, ensuring that outcomes cannot be predicted or manipulated in advance.

As a result, once the hash chain is created and committed, even its creator cannot determine or influence future outcomes - preserving full fairness and trust in the system.

Once this block is mined, its hash becomes public and is used by hashing the combined input of H_99,999,999 and the salt to derive a random price movement hash:

$$pmHASH = SHA512(H_{99,999,999} + Salt)$$

This pmHASH is then used to generate random price movements.

Price Movement Generation

Each SHA-512 hash (pmHASH) determines 8 seconds of price movement for the synthetic price using statistical transformations.

1

Extract Uniform Random values

• The first 104 hexadecimal characters from the 128 character hash is used to create 8 blocks of 13 characters with each block converted into a normalized integer.

$$U' = \frac {u} {2^{52}}$$

• This yields 8 uniformly distributed values U'₁ to U'₈ in the range [0,1).

• Thirteen (13) hexadecimal characters (equivalent to 52 bits or 2⁵²) are used to maximize entropy when generating uniform random values in the range [0, 1).

2

Box-Muller Transformation

The values are grouped in four (4) pairs:

$$(U'_1 , U'_2) , (U'_3 , U'_4) , (U'_5 , U'_6) , (U'_7 , U'_8)$$

The Box-Muller Transformation is applied to each pair to generate normally distributed values:

$$Z_0 = \sqrt{-2 \,ln\,U'_1}* cos(2\pi U'_2)$$

$$Z_1 = \sqrt{-2 \,ln\,U'_1}* sin(2\pi U'_2)$$

The normally distributed random variables Z₀ and Z₁ are multiplied by the standard deviation to generate the random price movement:

$$m = Z_0 * \sigma$$

This is repeated for each pair of U', yielding eight (8) random price movements m₁ , m₂ , ... m₈ per hash.

3

Synthetic Price Movement

The eight (8) random price movements are then applied to the synthetic asset price, one per second.

$$P_{t+1} = P_t + m_1$$

$$P_{t+2} = P_{t+1} + m_2$$

......

$$P_{t+8} = P_{t+7} + m_8$$

This process continues every eight (8) seconds, using the next hash in the chain plus the salt to derive a new random price movement hash.

Verifying Fairness

After each hash is used, it is immediately revealed to the public, allowing anyone to verify the results and that the hash is part of the original committed SHA-512 hash chain. This provides a constant stream of tamper-proof, time-released randomness.