Dev Release 30 | BDAG Miner Official

Hey BlockDAG Community,

Today was all about exploring more mining algorithm techniques for BlockDAG. BlockDAG with their unique structures, require robust mechanisms to ensure data integrity and validate transactions. SHA-3 (Secure Hash Algorithm 3) emerges as a compelling contender for the hashing function within the BlockDAG mining process. Let’s delve deeper into how SHA-3 integrates with BlockDAG’s Proof-of-Work (PoW) consensus mechanism.

SHA-3: A Sponge for Secure Hashing

SHA-3 stands out for its sponge function capability. In essence, it can act in two modes:

Hashing: Takes data of any size and produces a fixed-length output string (hash). This one-way property is crucial for ensuring data integrity in BlockDAG.
Extending: Allows for incremental data incorporation, making it adaptable to the potentially varying data sizes encountered during BlockDAG mining.

SHA-3 in Proof-of-Work (PoW)

The core concept behind SHA-3’s role in mining lies in Proof-of-Work (PoW) consensus mechanisms. Here’s the gist:

Block Construction: Miners prepare a block containing transaction data and a reference to the previous block’s hash (ensuring immutability).
Nonce Introduction: A nonce (number used once) is added to the block data.
Hashing Challenge: The entire block data, including the nonce, is fed into the SHA-3 function.
Mining the Hash: Miners iterate through different nonce values, re-hashing the block data each time. The goal is to find a hash that falls within a specific target range (often achieved by adding leading zeroes).

Pseudocode for BlockDAG Mining with SHA-3

function MineBlock(blockData, difficulty):

while True:

nonce = GenerateRandomNonce()

dataToHash = Concatenate(blockData, nonce)

hash = SHA3(dataToHash)

if CheckHashValidity(hash, difficulty):

return blockData, nonce # Block is valid, return data and nonce

else:

continue # Hash doesn’t meet difficulty, loop again

Explanation:

The MineBlock function takes the block data and mining difficulty as input.
A loop iterates until a valid hash is found.
Inside the loop, a random nonce is generated.
The block data and nonce are concatenated to form the data to be hashed.
The SHA-3 function is used to hash the data.
The CheckHashValidity function (not shown here) compares the hash with the difficulty target. This typically involves checking for a certain number of leading zeroes in the hash string.
If the hash meets the difficulty criteria, the block data and nonce are returned, indicating a successful mining operation.
If the hash fails the check, the loop continues, and a new nonce is attempted.

high-level look at the algorithm

During the implementing process of SHA-3 within our BlockDAG blockchain several steps will be included, which are hashing transactions or blocks for security and integrity within the chain. Below is a simplified pseudocode example of how SHA-3 will be implemented in our blockchain system:

function calculateSHA3(data):

// This function calculates the SHA-3 hash of the given data

// Step 1: Initialize the SHA-3 hashing algorithm

hash_instance = initializeSHA3()

// Step 2: Update the hash with the data

hash_instance.update(data)

// Step 3: Finalize the hash and obtain the digest

digest = hash_instance.finalize()

// Return the hexadecimal representation of the digest

return hexadecimalRepresentation(digest)

function mineBlock(transactions, previousBlockHash, targetDifficulty):

// This function is responsible for mining a new block in the DAG-based blockchain

nonce = 0

blockData = concatenate(transactions, previousBlockHash, nonce)

while true:

blockHash = calculateSHA3(blockData)

// Check if the block hash meets the target difficulty

if meetsDifficulty(blockHash, targetDifficulty):

break // Found a valid block hash that satisfies the PoW condition

// Increment the nonce and update the block data

nonce = nonce + 1

blockData = concatenate(transactions, previousBlockHash, nonce)

// Return the valid block hash and nonce

return blockHash, nonce

// Example usage:

// Assume transactions and previousBlockHash are defined elsewhere targetDifficulty = “0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF”

// Mine a new block

validBlockHash, nonce = mineBlock(transactions, previousBlockHash, targetDifficulty)

Here’s why we are now considering SHA-3 over RandomX:

Security: SHA-3 boasts a robust design, addressing potential vulnerabilities in older SHA versions.
Efficiency: It offers competitive hashing speeds compared to other secure algorithms.

Next steps

SHA-3 presents a promising avenue for BlockDAG security. However, ongoing research and development are crucial. Here’s what to consider:

Real-World Implementation: More BlockDAG projects need to adopt SHA-3 to solidify its position in the BlockDAG security landscape.
ASIC Resistance: The debate regarding SHA-3’s impact on Application-Specific Integrated Circuits (ASICs) in mining continues. Staying updated on this evolving landscape is essential.