status-im
/
nim-ethash
mirror of https://github.com/status-im/nim-ethash.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Original ethash implementation does not pass its own tests?

This commit is contained in:
mratsim 2018-02-23 17:32:23 +01:00
parent 118da2ea29
commit d5dc5a5bed
4 changed files with 138 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
spec/internal.nim
View File

@ -1,5 +1,6 @@
# GPLv3 license # GPLv3 license
# Nim wrapper for libethash # Nim wrapper for libethash
# As this is linking to GPLv3, do not use in production
{.compile: "internal.c".} {.compile: "internal.c".}
{.compile: "sha3.c".} {.compile: "sha3.c".}
@ -21,13 +22,6 @@ const
ETHASH_DAG_MAGIC_NUM_SIZE* = 8 ETHASH_DAG_MAGIC_NUM_SIZE* = 8
ETHASH_DAG_MAGIC_NUM* = 0xFEE1DEADBADDCAFE'i64 ETHASH_DAG_MAGIC_NUM* = 0xFEE1DEADBADDCAFE'i64
## / Type of a seedhash/blockhash e.t.c.
type
ethash_h256_t* {.bycopy, importc.} = object
b*: array[32, uint8]
const const
ENABLE_SSE* = 0 ENABLE_SSE* = 0
@ -37,10 +31,12 @@ const
MIX_NODES* = (MIX_WORDS div NODE_WORDS) MIX_NODES* = (MIX_WORDS div NODE_WORDS)
type type
ethash_h256_t* {.bycopy.} = object
b*: array[32, uint8]
node* {.bycopy, importc.} = object {.union.} node* {.bycopy, importc.} = object {.union.}
bytes*: array[NODE_WORDS * 4, uint8] bytes*{.importc.}: array[NODE_WORDS * 4, uint8]
words*: array[NODE_WORDS, uint32] words*{.importc.}: array[NODE_WORDS, uint32]
double_words*: array[NODE_WORDS div 2, uint64] double_words*{.importc.}: array[NODE_WORDS div 2, uint64]
ethash_callback_t* {.importc.}= proc (a2: cuint): cint ethash_callback_t* {.importc.}= proc (a2: cuint): cint
ethash_return_value_t* {.bycopy.} = object ethash_return_value_t* {.bycopy.} = object
@ -48,6 +44,20 @@ type
mix_hash*: ethash_h256_t mix_hash*: ethash_h256_t
success*: bool success*: bool
ethash_light* {.bycopy.} = object
cache*: pointer
cache_size*: uint64
block_number*: uint64
ethash_light_t {.importc.}= ptr ethash_light
ethash_full* {.bycopy.} = object
file*{.importc.}: ptr FILE
file_size*{.importc.}: uint64
data*{.importc.}: ptr node
ethash_full_t {.importc.}= ptr ethash_full
proc ethash_h256_get*(hash: ptr ethash_h256_t; i: cuint): uint8 {.inline, importc.} = proc ethash_h256_get*(hash: ptr ethash_h256_t; i: cuint): uint8 {.inline, importc.} =
return hash.b[i] return hash.b[i]
@ -70,14 +80,6 @@ proc ethash_h256_reset*(hash: ptr ethash_h256_t) {.inline, importc.} =
proc ethash_quick_check_difficulty*(header_hash: ptr ethash_h256_t; nonce: uint64; proc ethash_quick_check_difficulty*(header_hash: ptr ethash_h256_t; nonce: uint64;
mix_hash: ptr ethash_h256_t; mix_hash: ptr ethash_h256_t;
boundary: ptr ethash_h256_t): bool {.importc.} boundary: ptr ethash_h256_t): bool {.importc.}
type
ethash_light* {.bycopy, importc.} = object
cache*: pointer
cache_size*: uint64
block_number*: uint64
ethash_light_t = ptr ethash_light
## * ## *
## Allocate and initialize a new ethash_light handler. Internal version ## Allocate and initialize a new ethash_light handler. Internal version
@ -100,15 +102,10 @@ proc ethash_light_new_internal*(cache_size: uint64; seed: ptr ethash_h256_t): et
## @return The resulting hash. ## @return The resulting hash.
## ##
proc ethash_light_new*(block_number: uint64): ethash_light_t {.importc.}
proc ethash_light_compute_internal*(light: ethash_light_t; full_size: uint64; proc ethash_light_compute_internal*(light: ethash_light_t; full_size: uint64;
header_hash: ethash_h256_t; nonce: uint64): ethash_return_value_t {.importc.} header_hash: ethash_h256_t; nonce: uint64): ethash_return_value_t {.importc.}
type
ethash_full* {.bycopy.} = object
file*: ptr FILE
file_size*: uint64
data*: ptr node
ethash_full_t = ptr ethash_full
## * ## *
## Allocate and initialize a new ethash_full handler. Internal version. ## Allocate and initialize a new ethash_full handler. Internal version.

77
spec/test_internal_c.nim Normal file
View File

@ -0,0 +1,77 @@
import strutils
import ./internal
# Copy-paste all the libethash files alongside this file
###############################################
proc toHex*[N: static[int]](ba: array[N, byte]): string {.noSideEffect.}=
## Convert a big-endian byte array to its hex representation
## Output is in lowercase
##
const hexChars = "0123456789abcdef"
result = newString(2*N)
for i in 0 ..< N:
result[2*i] = hexChars[int ba[i] shr 4 and 0xF]
result[2*i+1] = hexChars[int ba[i] and 0xF]
proc readHexChar(c: char): byte {.noSideEffect.}=
## Converts an hex char to a byte
case c
of '0'..'9': result = byte(ord(c) - ord('0'))
of 'a'..'f': result = byte(ord(c) - ord('a') + 10)
of 'A'..'F': result = byte(ord(c) - ord('A') + 10)
else:
raise newException(ValueError, $c & "is not a hexademical character")
proc hexToByteArrayBE*[N: static[int]](hexStr: string): array[N, byte] {.noSideEffect, noInit.}=
## Read an hex string and store it in a Byte Array in Big-Endian order
var i = 0
if hexStr[i] == '0' and (hexStr[i+1] == 'x' or hexStr[i+1] == 'X'):
inc(i, 2) # Ignore 0x and 0X prefix
assert hexStr.len - i == 2*N
while i < N:
result[i] = hexStr[2*i].readHexChar shl 4 or hexStr[2*i+1].readHexChar
inc(i)
###############################################
# Block 22 (POC-9 testnet, epoch 0)
let blkn = 22'u
var hash = hexToByteArrayBE[32]("372eca2454ead349c3df0ab5d00b0b706b23e49d469387db91811cee0358fc6d")
let nonce = 0x495732e0ed7a801c'u
let full_size = ethash_get_datasize(blkn)
echo full_size
let light_cache = ethash_light_new(blkn)
let r = ethash_light_compute_internal(
light_cache,
full_size,
cast[ethash_h256_t](addr hash),
nonce
)
###############################################
let expected_mix_hash = "2f74cdeb198af0b9abe65d22d372e22fb2d474371774a9583c1cc427a07939f5"
let expected_boundary = "00000b184f1fdd88bfd94c86c39e65db0c36144d5e43f745f722196e730cb614"
###############################################
echo r.mix_hash.b == hexToByteArrayBE[32](expected_mix_hash)
echo "Result mixhash: " & $r.mix_hash.b.toHex
echo "Expected mixhash: " & $expected_mix_hash
echo "Result value: " & $r.result.b.toHex
echo "Expected value: " & $expected_boundary

11
src/ethash.nim
View File

@ -172,7 +172,7 @@ proc hashimoto(header: Hash[256],
s_bytes[0..<32] = header.toByteArrayBE # We first populate the first 40 bytes of s with the concatenation s_bytes[0..<32] = header.toByteArrayBE # We first populate the first 40 bytes of s with the concatenation
s_bytes[32..<40] = nonce.toByteArrayBE s_bytes[32..<40] = nonce.toByteArrayBE
s = keccak_512 s_bytes[0..<40] s = keccak_512 s_bytes[0..<40] # TODO: Does this allocate a seq?
# start the mix with replicated s # start the mix with replicated s
assert MIX_BYTES div HASH_BYTES == 2 assert MIX_BYTES div HASH_BYTES == 2
@ -192,13 +192,14 @@ proc hashimoto(header: Hash[256],
mix = zipMap(mix, newdata, fnv(x, y)) mix = zipMap(mix, newdata, fnv(x, y))
# compress mix # compress mix
var cmix: array[8, uint32] var cmix{.noInit.}: array[8, uint32]
for i in countup(0, mix.len - 1, 4): for i in countup(0, mix.len - 1, 4):
cmix[i div 4] = mix[i].fnv(mix[i+1]).fnv(mix[i+2]).fnv(mix[i+3]) cmix[i div 4] = mix[i].fnv(mix[i+1]).fnv(mix[i+2]).fnv(mix[i+3])
result.mix_digest = cast[Hash[256]]( # result.mix_digest = cast[Hash[256]](
mapArray(cmix, x.toByteArrayBE) # Each uint32 must be changed to Big endian # mapArray(cmix, x.toByteArrayBE) # Each uint32 must be changed to Big endian
) # )
result.mix_digest = cast[Hash[256]](cmix)
var concat{.noInit.}: array[64 + 32, byte] var concat{.noInit.}: array[64 + 32, byte]
concat[0..<64] = s_bytes[] concat[0..<64] = s_bytes[]

62
tests/all_tests.nim
View File

@ -191,47 +191,51 @@ suite "Dagger hashimoto computation":
check: light_result == full_result check: light_result == full_result
test "Light compute": ####
# https://github.com/paritytech/parity/blob/05f47b635951f942b493747ca3bc71de90a95d5d/ethash/src/compute.rs#L372-L394 ####
## The official implementation does not pass this test somehow ...
####
# test "Light compute":
# # https://github.com/paritytech/parity/blob/05f47b635951f942b493747ca3bc71de90a95d5d/ethash/src/compute.rs#L372-L394
let hash = cast[Hash[256]]([ # let hash = cast[Hash[256]]([
byte 0xf5, 0x7e, 0x6f, 0x3a, 0xcf, 0xc0, 0xdd, 0x4b, 0x5b, 0xf2, 0xbe, 0xe4, 0x0a, 0xb3, # byte 0xf5, 0x7e, 0x6f, 0x3a, 0xcf, 0xc0, 0xdd, 0x4b, 0x5b, 0xf2, 0xbe, 0xe4, 0x0a, 0xb3,
0x35, 0x8a, 0xa6, 0x87, 0x73, 0xa8, 0xd0, 0x9f, 0x5e, 0x59, 0x5e, 0xab, 0x55, 0x94, # 0x35, 0x8a, 0xa6, 0x87, 0x73, 0xa8, 0xd0, 0x9f, 0x5e, 0x59, 0x5e, 0xab, 0x55, 0x94,
0x05, 0x52, 0x7d, 0x72 # 0x05, 0x52, 0x7d, 0x72
]) # ])
let expected_mix_hash = cast[Hash[256]]([ # let expected_mix_hash = cast[Hash[256]]([
byte 0x1f, 0xff, 0x04, 0xce, 0xc9, 0x41, 0x73, 0xfd, 0x59, 0x1e, 0x3d, 0x89, 0x60, 0xce, # byte 0x1f, 0xff, 0x04, 0xce, 0xc9, 0x41, 0x73, 0xfd, 0x59, 0x1e, 0x3d, 0x89, 0x60, 0xce,
0x6b, 0xdf, 0x8b, 0x19, 0x71, 0x04, 0x8c, 0x71, 0xff, 0x93, 0x7b, 0xb2, 0xd3, 0x2a, # 0x6b, 0xdf, 0x8b, 0x19, 0x71, 0x04, 0x8c, 0x71, 0xff, 0x93, 0x7b, 0xb2, 0xd3, 0x2a,
0x64, 0x31, 0xab, 0x6d # 0x64, 0x31, 0xab, 0x6d
]) # ])
let expected_boundary = cast[Hash[256]]([ # let expected_boundary = cast[Hash[256]]([
byte 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3e, 0x9b, 0x6c, 0x69, 0xbc, 0x2c, 0xe2, 0xa2, # byte 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3e, 0x9b, 0x6c, 0x69, 0xbc, 0x2c, 0xe2, 0xa2,
0x4a, 0x8e, 0x95, 0x69, 0xef, 0xc7, 0xd7, 0x1b, 0x33, 0x35, 0xdf, 0x36, 0x8c, 0x9a, # 0x4a, 0x8e, 0x95, 0x69, 0xef, 0xc7, 0xd7, 0x1b, 0x33, 0x35, 0xdf, 0x36, 0x8c, 0x9a,
0xe9, 0x7e, 0x53, 0x84 # 0xe9, 0x7e, 0x53, 0x84
]) # ])
let nonce = 0xd7b3ac70a301a249'u64 # let nonce = 0xd7b3ac70a301a249'u64
## difficulty = 0x085657254bd9u64 # ## difficulty = 0x085657254bd9u64
let blk = 486382'u # block number # let blk = 486382'u # block number
let light_cache = mkcache(blk.get_cache_size, blk.get_seedhash) # let light_cache = mkcache(blk.get_cache_size, blk.get_seedhash)
let r = hashimoto_light(blk.get_data_size, # let r = hashimoto_light(blk.get_data_size,
light_cache, # light_cache,
blk.get_seedhash, # blk.get_seedhash,
nonce # nonce
) # )
check: r.mix_digest == expected_mix_hash # check: r.mix_digest == expected_mix_hash
check: r.value == expected_boundary # check: r.value == expected_boundary
suite "Real blocks test": suite "Real blocks test":
test "Verification of block 22": test "Verification of block 22":
# https://github.com/ethereum/ethash/blob/f5f0a8b1962544d2b6f40df8e4b0d9a32faf8f8e/test/c/test.cpp#L603-L617 # https://github.com/ethereum/ethash/blob/f5f0a8b1962544d2b6f40df8e4b0d9a32faf8f8e/test/c/test.cpp#L603-L617
# POC-9 tetnet, epoch 0 # POC-9 testnet, epoch 0
let cache = mkcache(get_cachesize(22), get_seedhash(22)) let cache = mkcache(get_cachesize(22), get_seedhash(22))
let provided_seedhash = cast[Hash[256]]( let provided_seedhash = cast[Hash[256]](
hexToByteArrayBE[32]("372eca2454ead349c3df0ab5d00b0b706b23e49d469387db91811cee0358fc6d") hexToByteArrayBE[32]("372eca2454ead349c3df0ab5d00b0b706b23e49d469387db91811cee0358fc6d")