111 lines
4.0 KiB
Python
111 lines
4.0 KiB
Python
'''
|
|
Onionr - P2P Microblogging Platform & Social network
|
|
|
|
Proof of work module
|
|
'''
|
|
'''
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
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
|
|
import btc, core
|
|
|
|
class POW:
|
|
def pow(self, reporting = False):
|
|
startTime = math.floor(time.time())
|
|
self.hashing = True
|
|
self.reporting = reporting
|
|
iFound = False # if current thread is the one that found the answer
|
|
answer = ''
|
|
heartbeat = 200000
|
|
hbCount = 0
|
|
blockCheck = 300000 # How often the hasher should check if the bitcoin block is updated (slows hashing but prevents less wasted work)
|
|
blockCheckCount = 0
|
|
block = '' #self.bitcoinNode.getBlockHash(self.bitcoinNode.getLastBlockHeight())
|
|
#logger.debug('thread started')
|
|
myCore = core.Core()
|
|
while self.hashing:
|
|
'''
|
|
if blockCheckCount == blockCheck:
|
|
if self.reporting:
|
|
logger.debug('Refreshing Bitcoin block')
|
|
block = '' #self.bitcoinNode.getBlockHash(self.bitcoinNode.getLastBlockHeight())
|
|
blockCheckCount = 0
|
|
blockCheckCount += 1
|
|
hbCount += 1
|
|
'''
|
|
rand = nacl.utils.random()
|
|
token = nacl.hash.blake2b(rand + self.data).decode()
|
|
#print(token)
|
|
if self.puzzle == token[0:self.difficulty]:
|
|
self.hashing = False
|
|
iFound = True
|
|
break
|
|
else:
|
|
logger.debug('POW thread exiting, another thread found result')
|
|
if iFound:
|
|
endTime = math.floor(time.time())
|
|
if self.reporting:
|
|
logger.info('Found token ' + token, timestamp=True)
|
|
logger.info('took ' + str(endTime - startTime) + ' seconds', timestamp=True)
|
|
self.result = (token, rand)
|
|
|
|
def __init__(self, data, bitcoinNode=''):
|
|
self.foundHash = False
|
|
self.difficulty = 0
|
|
self.data = data
|
|
|
|
dataLen = sys.getsizeof(data)
|
|
self.difficulty = math.floor(dataLen/1000000)
|
|
if self.difficulty <= 2:
|
|
self.difficulty = 4
|
|
|
|
try:
|
|
self.data = self.data.encode()
|
|
except AttributeError:
|
|
pass
|
|
self.data = nacl.hash.blake2b(self.data)
|
|
|
|
logger.debug('Computing difficulty of ' + str(self.difficulty))
|
|
|
|
self.mainHash = '0000000000000000000000000000000000000000000000000000000000000000'#nacl.hash.blake2b(nacl.utils.random()).decode()
|
|
self.puzzle = self.mainHash[0:self.difficulty]
|
|
self.bitcoinNode = bitcoinNode
|
|
#logger.debug('trying to find ' + str(self.mainHash))
|
|
tOne = threading.Thread(name='one', target=self.pow, args=(True,))
|
|
tTwo = threading.Thread(name='two', target=self.pow, args=(True,))
|
|
tThree = threading.Thread(name='three', target=self.pow, args=(True,))
|
|
tOne.start()
|
|
tTwo.start()
|
|
tThree.start()
|
|
return
|
|
|
|
def shutdown(self):
|
|
self.hashing = False
|
|
self.puzzle = ''
|
|
|
|
def changeDifficulty(self, newDiff):
|
|
self.difficulty = newDiff
|
|
|
|
def getResult(self):
|
|
'''
|
|
Returns the result then sets to false, useful to automatically clear the result
|
|
'''
|
|
try:
|
|
retVal = self.result
|
|
except AttributeError:
|
|
retVal = False
|
|
self.result = False
|
|
return retVal
|