From f027202ac949888ae0711767468b6e3d094c6497 Mon Sep 17 00:00:00 2001
From: Kevin Froman <beardog@firemail.cc>
Date: Sun, 8 Jul 2018 02:51:23 -0500
Subject: [PATCH] * Pretty much done with new POW format

---
 onionr/communicator2.py |  2 +-
 onionr/core.py          |  4 +++-
 onionr/onionrcrypto.py  | 14 +++++---------
 onionr/onionrproofs.py  | 18 ++++++++++--------
 4 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/onionr/communicator2.py b/onionr/communicator2.py
index 1e844083..4003cb79 100755
--- a/onionr/communicator2.py
+++ b/onionr/communicator2.py
@@ -168,7 +168,7 @@ class OnionrCommunicatorDaemon:
                     metadata = metas[0]
                     meta = metas[1]
                     if self._core._utils.validateMetadata(metadata): # check if metadata is valid
-                        if self._core._crypto.verifyPow(metas[2], metadata): # check if POW is enough/correct
+                        if self._core._crypto.verifyPow(content): # check if POW is enough/correct
                             logger.info('Block passed proof, saving.')
                             self._core.setData(content)
                             self._core.addToBlockDB(blockHash, dataSaved=True)
diff --git a/onionr/core.py b/onionr/core.py
index b32b0db3..3cfa41d7 100644
--- a/onionr/core.py
+++ b/onionr/core.py
@@ -733,7 +733,9 @@ class Core:
         metadata['signer'] = signer
         metadata['time'] = str(self._utils.getEpoch())
 
-        payload  = onionrproofs.POW(metadata, data)
+        # send block data (and metadata) to POW module to get tokenized block data
+        proof = onionrproofs.POW(metadata, data)
+        payload = proof.waitForResult()
         
         retData = self.setData(payload)
         self.addToBlockDB(retData, selfInsert=True, dataSaved=True)
diff --git a/onionr/onionrcrypto.py b/onionr/onionrcrypto.py
index a8b67f22..394bea7f 100644
--- a/onionr/onionrcrypto.py
+++ b/onionr/onionrcrypto.py
@@ -249,31 +249,27 @@ class OnionrCrypto:
             pass
         return nacl.hash.blake2b(data)
 
-    def verifyPow(self, blockContent, metadata):
+    def verifyPow(self, blockContent):
         '''
             Verifies the proof of work associated with a block
         '''
         retData = False
 
-        if not 'powRandomToken' in metadata:
-            logger.warn('No powRandomToken')
-            return False
-
         dataLen = len(blockContent)
 
-        expectedHash = self.blake2bHash(base64.b64decode(metadata['powRandomToken']) + self.blake2bHash(blockContent.encode()))
-        difficulty = 0
         try:
-            expectedHash = expectedHash.decode()
+            blockContent = blockContent.encode()
         except AttributeError:
             pass
 
+        blockHash = self.sha3Hash(blockContent)
+
         difficulty = math.floor(dataLen / 1000000)
 
         mainHash = '0000000000000000000000000000000000000000000000000000000000000000'#nacl.hash.blake2b(nacl.utils.random()).decode()
         puzzle = mainHash[:difficulty]
 
-        if metadata['powRandomToken'][:difficulty] == puzzle:
+        if blockHash[:difficulty] == puzzle:
             # logger.debug('Validated block pow')
             retData = True
         else:
diff --git a/onionr/onionrproofs.py b/onionr/onionrproofs.py
index 7f65bff7..89278a65 100644
--- a/onionr/onionrproofs.py
+++ b/onionr/onionrproofs.py
@@ -18,17 +18,18 @@
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 '''
 
-import nacl.encoding, nacl.hash, nacl.utils, time, math, threading, binascii, logger, sys, base64
+import nacl.encoding, nacl.hash, nacl.utils, time, math, threading, binascii, logger, sys, base64, json
 import core
 
 class POW:
-    def __init__(self, data, threadCount = 5):
+    def __init__(self, metadata, data, threadCount = 5):
         self.foundHash = False
         self.difficulty = 0
         self.data = data
+        self.metadata = metadata
         self.threadCount = threadCount
 
-        dataLen = sys.getsizeof(data)
+        dataLen = len(data) + len(json.dumps(metadata))
         self.difficulty = math.floor(dataLen / 1000000)
         if self.difficulty <= 2:
             self.difficulty = 4
@@ -38,11 +39,9 @@ class POW:
         except AttributeError:
             pass
         
-        self.data = nacl.hash.blake2b(self.data)
-
         logger.info('Computing POW (difficulty: %s)...' % self.difficulty)
 
-        self.mainHash = '0' * 70
+        self.mainHash = '0' * 64
         self.puzzle = self.mainHash[0:min(self.difficulty, len(self.mainHash))]
         
         myCore = core.Core()
@@ -63,11 +62,15 @@ class POW:
         
         while self.hashing:
             rand = nacl.utils.random()
-            token = nacl.hash.blake2b(rand + self.data).decode()
+            #token = nacl.hash.blake2b(rand + self.data).decode()
+            self.metadata['powRandomToken'] = base64.b64encode(rand).decode()
+            payload = json.dumps(self.metadata).encode() + b'\n' + self.data
+            token = myCore._crypto.sha3Hash(payload)
             #print(token)
             if self.puzzle == token[0:self.difficulty]:
                 self.hashing = False
                 iFound = True
+                self.result = payload
                 break
                 
         if iFound:
@@ -75,7 +78,6 @@ class POW:
             if self.reporting:
                 logger.debug('Found token after %s seconds: %s' % (endTime - startTime, token), timestamp=True)
                 logger.debug('Random value was: %s' % base64.b64encode(rand).decode())
-            self.result = (token, rand)
 
     def shutdown(self):
         self.hashing = False