Ruby Quiz - Challenge #5 - Crypto Mining - Find the Winning Lucky Number - Nonce (=Number used ONCE) for the Proof-of-Work (PoW) Hash (SHA-256)

Hello,

 It's Friday. Ruby Quiz time! Join us. Let's keep going with a new
Ruby Quiz [1] every Friday.
Here we go:


Challenge #5 -Crypto Mining - Find the Winning Lucky Number - Nonce
(=Number used ONCE) for the Proof-of-Work (PoW) Hash (SHA-256)


Let's find the the winning lucky lumber, that is, nonce (=Number used ONCE)
for the proof-of-work (PoW) hash using SHA-256.

---

Aside:  What's a (Crypto) Hash?

Classic Bitcoin uses the SHA256 hash algorithm. Let's try

```
require 'digest'

Digest::SHA256.hexdigest( 'Hello, Cryptos!' )
```

resulting in

```
#=> "33eedea60b0662c66c289ceba71863a864cf84b00e10002ca1069bf58f9362d5"
```

Try some more

```
Digest::SHA256.hexdigest( 'Hello, Cryptos! - Hello, Cryptos! - Hello,
Cryptos!' )
#=> "c4b5e2b9685062ecca5d0f6f6ba605b3f99eafed3a3729d2ae1ccaa2b440b1cc"
Digest::SHA256.hexdigest( 'Your Name Here' )
#=> "39459289c09c33a7b516bef926c1873c6ecd2e6db09218b065d7465b6736f801"
Digest::SHA256.hexdigest( 'Data Data Data Data' )
#=> "a7bbfc531b2ecf641b9abcd7ad8e50267e1c873e5a396d1919f504973090565a"
```

Note: The resulting hash is always 256-bit in size
or 64 hex(adecimal) chars (0-9,a-f) in length
even if the input is less than 256-bit or much bigger than 256-bit.


Trivia Quiz: What's SHA256?

- (A) Still Hacking Anyway
- (B) Secure Hash Algorithm
- (C) Sweet Home Austria
- (D) Super High Aperture

B: SHA256 == Secure Hash Algorithms 256 Bits

SHA256 is a (secure) hashing algorithm designed by the National
Security Agency (NSA)
of the United States of America (USA).

Find out more @ [Secure Hash Algorithms (SHA) @
Wikipedia](https://en.wikipedia.org/wiki/Secure_Hash_Algorithms).

---



The challenge: Code a `compute_nonce` method that passes the
RubyQuizTest :-), that is,
the hash for the nonce plus the data
must start with four leading zeros (`0000`), that is, the "hard-coded"
proof-of-work difficulty in the test:


```
hash = Digest::SHA256.hexdigest( "#{nonce}#{data}" )
## e.g. hash = "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
assert hash.start_with?( "0000" )
```

Note: `data` is a (random) string e.g. `"Hello, Crypto! The epoch time
is now >1541927781<."`
and `compute_nonce` is expected to return
the nonce (=Number used ONCE) as an integer number e.g. `26762` or `68419` etc.

```
def compute_nonce( data )
  # ...
end
```

Start from scratch or, yes, use any library / gem you can find.

To qualify for solving the code challenge / puzzle you must pass the test [2].


Note: The test data for `compute_nonce` is "random", that is,
always changes with every test run (e.g. includes
Epoch time that is, seconds since January 1st, 1970).


---
Aside: What's the mining / proof-of-work difficulty? What's `0000`?

In classic bitcoin you have to compute a hash
that starts with leading zeros (`00`). The more leading zeros the
harder (more difficult) to compute. Let's keep it easy to compute and
let's start with two leading zeros (`00`), that is, 16^2 = 256
possibilities (^1,2).
Three leading zeros (`000`) would be 16^3 = 4 096 possibilities
and four zeros (`0000`) would be 16^4 = 65 536 and so on.

(1): 16 possibilities because it's a hex or hexadecimal or base 16
number, that is, `0` `1` `2` `3` `4` `5` `6` `7` `8` `9` `a` (10) `b`
(11) `c` (12) `d` (13) `e` (14) `f` (15).

(2): A random secure hash algorithm needs on average 256 tries (might
be lets say 305 tries, for example, because it's NOT a perfect
statistic distribution of possibilities).

---


Post your code snippets on the "official" Ruby Quiz Channel,
that is, the ruby-talk mailing list right here.

Happy crypto mining and hashing with Ruby.

[1] https://github.com/planetruby/quiz/tree/master/005
[2] https://github.com/planetruby/quiz/blob/master/005/test.rb

Unsubscribe: <mailto:[email protected]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-talk>