Use ethash_blockhash_t in the codebase

ethash.go

@@ -94,7 +94,7 @@ func makeParamsAndCache(chainManager pow.ChainManager, blockNum uint64) (*Params
 
 	powlogger.Infoln("Making Cache")
 	start := time.Now()
-	C.ethash_mkcache(paramsAndCache.cache, paramsAndCache.params, (*C.uint8_t)(unsafe.Pointer(&seedHash[0])))
+	C.ethash_mkcache(paramsAndCache.cache, paramsAndCache.params, (*C.ethash_blockhash_t)(unsafe.Pointer(&seedHash[0])))
 	powlogger.Infoln("Took:", time.Since(start))
 
 	return paramsAndCache, nil
@@ -319,7 +319,7 @@ func (pow *Ethash) Search(block pow.Block, stop <-chan struct{}) (uint64, []byte
 	start := time.Now().UnixNano()
 
 	nonce := uint64(r.Int63())
-	cMiningHash := (*C.uint8_t)(unsafe.Pointer(&miningHash[0]))
+	cMiningHash := (*C.ethash_blockhash_t)(unsafe.Pointer(&miningHash[0]))
 	target := new(big.Int).Div(minDifficulty, diff)
 
 	var ret C.ethash_return_value
@@ -337,11 +337,11 @@ func (pow *Ethash) Search(block pow.Block, stop <-chan struct{}) (uint64, []byte
 			pow.HashRate = int64(hashes)
 
 			C.ethash_full(&ret, pow.dag.dag, pow.dag.paramsAndCache.params, cMiningHash, C.uint64_t(nonce))
-			result := common.Bytes2Big(C.GoBytes(unsafe.Pointer(&ret.result[0]), C.int(32)))
+			result := common.Bytes2Big(C.GoBytes(unsafe.Pointer(&ret.result), C.int(32)))
 
 			// TODO: disagrees with the spec https://github.com/ethereum/wiki/wiki/Ethash#mining
 			if result.Cmp(target) <= 0 {
-				mixDigest := C.GoBytes(unsafe.Pointer(&ret.mix_hash[0]), C.int(32))
+				mixDigest := C.GoBytes(unsafe.Pointer(&ret.mix_hash), C.int(32))
 				seedHash, err := GetSeedHash(block.NumberU64()) // This seedhash is useless
 				if err != nil {
 					panic(err)
@@ -374,7 +374,7 @@ func (pow *Ethash) verify(hash common.Hash, mixDigest common.Hash, difficulty *b
 
 	// First check: make sure header, mixDigest, nonce are correct without hitting the cache
 	// This is to prevent DOS attacks
-	chash := (*C.uint8_t)(unsafe.Pointer(&hash[0]))
+	chash := (*C.ethash_blockhash_t)(unsafe.Pointer(&hash[0]))
 	cnonce := C.uint64_t(nonce)
 	target := new(big.Int).Div(minDifficulty, difficulty)
 
@@ -402,7 +402,7 @@ func (pow *Ethash) verify(hash common.Hash, mixDigest common.Hash, difficulty *b
 
 	C.ethash_light(ret, pAc.cache, pAc.params, chash, cnonce)
 
-	result := common.Bytes2Big(C.GoBytes(unsafe.Pointer(&ret.result[0]), C.int(32)))
+	result := common.Bytes2Big(C.GoBytes(unsafe.Pointer(&ret.result), C.int(32)))
 	return result.Cmp(target) <= 0
 }
 
@@ -418,7 +418,7 @@ func (pow *Ethash) FullHash(nonce uint64, miningHash []byte) []byte {
 	pow.UpdateDAG()
 	pow.dagMutex.Lock()
 	defer pow.dagMutex.Unlock()
-	cMiningHash := (*C.uint8_t)(unsafe.Pointer(&miningHash[0]))
+	cMiningHash := (*C.ethash_blockhash_t)(unsafe.Pointer(&miningHash[0]))
 	cnonce := C.uint64_t(nonce)
 	ret := new(C.ethash_return_value)
 	// pow.hash is the output/return of ethash_full
@@ -428,7 +428,7 @@ func (pow *Ethash) FullHash(nonce uint64, miningHash []byte) []byte {
 }
 
 func (pow *Ethash) LightHash(nonce uint64, miningHash []byte) []byte {
-	cMiningHash := (*C.uint8_t)(unsafe.Pointer(&miningHash[0]))
+	cMiningHash := (*C.ethash_blockhash_t)(unsafe.Pointer(&miningHash[0]))
 	cnonce := C.uint64_t(nonce)
 	ret := new(C.ethash_return_value)
 	C.ethash_light(ret, pow.paramsAndCache.cache, pow.paramsAndCache.params, cMiningHash, cnonce)

setup.py

@@ -1,33 +1,34 @@
 #!/usr/bin/env python
 from distutils.core import setup, Extension
-
-pyethash = Extension('pyethash', 
-        sources = [
-            'src/python/core.c', 
-            'src/libethash/util.c', 
-            'src/libethash/internal.c',
-            'src/libethash/sha3.c'],
-        depends = [
-            'src/libethash/ethash.h',
-            'src/libethash/compiler.h',
-            'src/libethash/data_sizes.h',
-            'src/libethash/endian.h',
-            'src/libethash/ethash.h',
-            'src/libethash/fnv.h',
-            'src/libethash/internal.h',
-            'src/libethash/sha3.h',
-            'src/libethash/util.h'
-            ],
-        extra_compile_args = ["-Isrc/", "-std=gnu99", "-Wall"])
-
-setup (
-       name = 'pyethash',
-       author = "Matthew Wampler-Doty",
-       author_email = "matthew.wampler.doty@gmail.com",
-       license = 'GPL',
-       version = '23',
-       url = 'https://github.com/ethereum/ethash',
-       download_url = 'https://github.com/ethereum/ethash/tarball/v23',
-       description = 'Python wrappers for ethash, the ethereum proof of work hashing function',
-       ext_modules = [pyethash],
-      )
+
+pyethash = Extension('pyethash',
+                     sources=[
+                         'src/python/core.c',
+                         'src/libethash/util.c',
+                         'src/libethash/internal.c',
+                         'src/libethash/sha3.c'],
+                     depends=[
+                         'src/libethash/ethash.h',
+                         'src/libethash/compiler.h',
+                         'src/libethash/data_sizes.h',
+                         'src/libethash/endian.h',
+                         'src/libethash/ethash.h',
+                         'src/libethash/fnv.h',
+                         'src/libethash/internal.h',
+                         'src/libethash/sha3.h',
+                         'src/libethash/util.h'
+                     ],
+                     extra_compile_args=["-Isrc/", "-std=gnu99", "-Wall"])
+
+setup(
+    name='pyethash',
+    author="Matthew Wampler-Doty",
+    author_email="matthew.wampler.doty@gmail.com",
+    license='GPL',
+    version='0.1.23',
+    url='https://github.com/ethereum/ethash',
+    download_url='https://github.com/ethereum/ethash/tarball/v23',
+    description=('Python wrappers for ethash, the ethereum proof of work'
+                 'hashing function'),
+    ext_modules=[pyethash],
+)

src/benchmark/benchmark.cpp

@@ -106,10 +106,11 @@ extern "C" int main(void)
 	//params.full_size = 8209 * 4096;	// 8MBish;
 	//params.cache_size = 8209*4096;
 	//params.cache_size = 2053*4096;
-	uint8_t seed[32], previous_hash[32];
+	ethash_blockhash_t seed;
+	ethash_blockhash_t previous_hash;
 
-	memcpy(seed, hexStringToBytes("9410b944535a83d9adf6bbdcc80e051f30676173c16ca0d32d6f1263fc246466").data(), 32);
-	memcpy(previous_hash, hexStringToBytes("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").data(), 32);
+	memcpy(&seed, hexStringToBytes("9410b944535a83d9adf6bbdcc80e051f30676173c16ca0d32d6f1263fc246466").data(), 32);
+	memcpy(&previous_hash, hexStringToBytes("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").data(), 32);
 
 	// allocate page aligned buffer for dataset
 #ifdef FULL
@@ -128,9 +129,9 @@ extern "C" int main(void)
 		ethash_mkcache(&cache, &params, seed);
 		auto time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
 
-		uint8_t cache_hash[32];
-		SHA3_256(cache_hash, (uint8_t const*)cache_mem, params.cache_size);
-		debugf("ethash_mkcache: %ums, sha3: %s\n", (unsigned)time, bytesToHexString(cache_hash,sizeof(cache_hash)).data());
+		ethash_blockhash_t cache_hash;
+		SHA3_256(&cache_hash, (uint8_t const*)cache_mem, params.cache_size);
+		debugf("ethash_mkcache: %ums, sha3: %s\n", (unsigned)((time*1000)/CLOCKS_PER_SEC), bytesToHexString(cache_hash,sizeof(cache_hash)).data());
 
 		// print a couple of test hashes
 		{

src/libethash-cl/ethash_cl_miner.cpp

@@ -54,15 +54,7 @@ ethash_cl_miner::ethash_cl_miner()
 {
 }
 
-void ethash_cl_miner::finish()
-{
-	if (m_queue())
-	{
-		m_queue.finish();
-	}
-}
-
-bool ethash_cl_miner::init(ethash_params const& params, const uint8_t seed[32], unsigned workgroup_size)
+bool ethash_cl_miner::init(ethash_params const& params, ethash_blockhash_t const *seed, unsigned workgroup_size)
 {
 	// store params
 	m_params = params;

src/libethash-cl/ethash_cl_miner.h

@@ -19,7 +19,7 @@ class ethash_cl_miner
 public:
 	ethash_cl_miner();
 
-	bool init(ethash_params const& params, const uint8_t seed[32], unsigned workgroup_size = 64);
+	bool init(ethash_params const& params, ethash_blockhash_t const *seed, unsigned workgroup_size = 64);
 
 	void finish();
 	void hash(uint8_t* ret, uint8_t const* header, uint64_t nonce, unsigned count);
@@ -42,4 +42,4 @@ class ethash_cl_miner
 	cl::Buffer m_search_buf[c_num_buffers];
 	unsigned m_workgroup_size;
 	bool m_opencl_1_1;
-};
+};

src/libethash/ethash.h

@@ -47,9 +47,26 @@ typedef struct ethash_params {
 	uint64_t cache_size;              // Size of compute cache (in bytes, multiple of node size (64)).
 } ethash_params;
 
+/// Type of a blockhash
+typedef struct ethash_blockhash { uint8_t b[32]; } ethash_blockhash_t;
+static inline uint8_t ethash_blockhash_get(ethash_blockhash_t const* hash, unsigned int i)
+{
+    return hash->b[i];
+}
+
+static inline void ethash_blockhash_set(ethash_blockhash_t *hash, unsigned int i, uint8_t v)
+{
+    hash->b[i] = v;
+}
+
+static inline void ethash_blockhash_reset(ethash_blockhash_t *hash)
+{
+    memset(hash, 0, 32);
+}
+
 typedef struct ethash_return_value {
-	uint8_t result[32];
-	uint8_t mix_hash[32];
+    ethash_blockhash_t result;
+    ethash_blockhash_t mix_hash;
 } ethash_return_value;
 
 uint64_t ethash_get_datasize(const uint32_t block_number);
@@ -65,58 +82,68 @@ typedef struct ethash_cache {
 	void *mem;
 } ethash_cache;
 
-void ethash_mkcache(ethash_cache *cache, ethash_params const *params, const uint8_t seed[32]);
+void ethash_mkcache(ethash_cache *cache, ethash_params const *params, ethash_blockhash_t const *seed);
 void ethash_compute_full_data(void *mem, ethash_params const *params, ethash_cache const *cache);
-void ethash_full(ethash_return_value *ret, void const *full_mem, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce);
-void ethash_light(ethash_return_value *ret, ethash_cache const *cache, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce);
-void ethash_get_seedhash(uint8_t seedhash[32], const uint32_t block_number);
-
-static inline void ethash_prep_light(void *cache, ethash_params const *params, const uint8_t seed[32]) {
-	ethash_cache c;
-	c.mem = cache;
-	ethash_mkcache(&c, params, seed);
+void ethash_full(ethash_return_value *ret,
+                 void const *full_mem,
+                 ethash_params const *params,
+                 ethash_blockhash_t const *header_hash,
+                 const uint64_t nonce);
+void ethash_light(ethash_return_value *ret,
+                  ethash_cache const *cache,
+                  ethash_params const *params,
+                  ethash_blockhash_t const *header_hash,
+                  const uint64_t nonce);
+void ethash_get_seedhash(ethash_blockhash_t *seedhash, const uint32_t block_number);
+
+static inline void ethash_prep_light(void *cache, ethash_params const *params, ethash_blockhash_t const* seed)
+{
+    ethash_cache c;
+    c.mem = cache;
+    ethash_mkcache(&c, params, seed);
 }
 
-static inline void ethash_compute_light(ethash_return_value *ret, void const *cache, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce) {
-	ethash_cache c;
-	c.mem = (void *) cache;
-	ethash_light(ret, &c, params, header_hash, nonce);
+static inline void ethash_compute_light(ethash_return_value *ret, void const *cache, ethash_params const *params, ethash_blockhash_t const *header_hash, const uint64_t nonce)
+{
+    ethash_cache c;
+    c.mem = (void *) cache;
+    ethash_light(ret, &c, params, header_hash, nonce);
 }
 
-static inline void ethash_prep_full(void *full, ethash_params const *params, void const *cache) {
-	ethash_cache c;
-	c.mem = (void *) cache;
-	ethash_compute_full_data(full, params, &c);
+static inline void ethash_prep_full(void *full, ethash_params const *params, void const *cache)
+{
+    ethash_cache c;
+    c.mem = (void *) cache;
+    ethash_compute_full_data(full, params, &c);
 }
 
-static inline void ethash_compute_full(ethash_return_value *ret, void const *full, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce) {
-	ethash_full(ret, full, params, header_hash, nonce);
+static inline void ethash_compute_full(ethash_return_value *ret,
+                                       void const *full,
+                                       ethash_params const *params,
+                                       ethash_blockhash_t const *header_hash,
+                                       const uint64_t nonce)
+{
+    ethash_full(ret, full, params, header_hash, nonce);
 }
 
-/// @brief Compare two s256-bit big-endian values.
-/// @returns 1 if @a a is less than or equal to @a b, 0 otherwise.
-/// Both parameters are 256-bit big-endian values.
-static inline int ethash_leq_be256(const uint8_t a[32], const uint8_t b[32]) {
-	// Boundary is big endian
-	for (int i = 0; i < 32; i++) {
-		if (a[i] == b[i])
-			continue;
-		return a[i] < b[i];
-	}
-	return 1;
+// Returns if hash is less than or equal to difficulty
+static inline int ethash_check_difficulty(ethash_blockhash_t const *hash,
+                                          ethash_blockhash_t const *difficulty)
+{
+    // Difficulty is big endian
+    for (int i = 0; i < 32; i++) {
+        if (ethash_blockhash_get(hash, i) == ethash_blockhash_get(difficulty, i)) {
+            continue;
+        }
+        return ethash_blockhash_get(hash, i) < ethash_blockhash_get(difficulty, i);
+    }
+    return 1;
 }
 
-/// Perofrms a cursory check on the validity of the nonce.
-/// @returns 1 if the nonce may possibly be valid for the given header_hash & boundary.
-/// @p boundary equivalent to 2 ^ 256 / block_difficulty, represented as a 256-bit big-endian.
-int ethash_preliminary_check_boundary(
-	const uint8_t header_hash[32],
-	const uint64_t nonce,
-	const uint8_t mix_hash[32],
-	const uint8_t boundary[32]);
-
-#define ethash_quick_check_difficulty ethash_preliminary_check_boundary
-#define ethash_check_difficulty ethash_leq_be256
+int ethash_quick_check_difficulty(ethash_blockhash_t const *header_hash,
+                                  const uint64_t nonce,
+                                  ethash_blockhash_t const *mix_hash,
+                                  ethash_blockhash_t const *difficulty);
 
 #ifdef __cplusplus
 }