252 lines
6.3 KiB
252 lines
6.3 KiB
#!/usr/bin/python |
|
# |
|
# Copyright (c) 2011 The Bitcoin developers |
|
# Distributed under the MIT/X11 software license, see the accompanying |
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php. |
|
# |
|
|
|
import time |
|
import json |
|
import pprint |
|
import hashlib |
|
import struct |
|
import re |
|
import base64 |
|
import httplib |
|
import sys |
|
from multiprocessing import Process |
|
|
|
ERR_SLEEP = 15 |
|
MAX_NONCE = 1000000L |
|
|
|
settings = {} |
|
pp = pprint.PrettyPrinter(indent=4) |
|
|
|
class BitcoinRPC: |
|
OBJID = 1 |
|
|
|
def __init__(self, host, port, username, password): |
|
authpair = "%s:%s" % (username, password) |
|
self.authhdr = "Basic %s" % (base64.b64encode(authpair)) |
|
self.conn = httplib.HTTPConnection(host, port, False, 30) |
|
def rpc(self, method, params=None): |
|
self.OBJID += 1 |
|
obj = { 'version' : '1.1', |
|
'method' : method, |
|
'id' : self.OBJID } |
|
if params is None: |
|
obj['params'] = [] |
|
else: |
|
obj['params'] = params |
|
self.conn.request('POST', '/', json.dumps(obj), |
|
{ 'Authorization' : self.authhdr, |
|
'Content-type' : 'application/json' }) |
|
|
|
resp = self.conn.getresponse() |
|
if resp is None: |
|
print "JSON-RPC: no response" |
|
return None |
|
|
|
body = resp.read() |
|
resp_obj = json.loads(body) |
|
if resp_obj is None: |
|
print "JSON-RPC: cannot JSON-decode body" |
|
return None |
|
if 'error' in resp_obj and resp_obj['error'] != None: |
|
return resp_obj['error'] |
|
if 'result' not in resp_obj: |
|
print "JSON-RPC: no result in object" |
|
return None |
|
|
|
return resp_obj['result'] |
|
def getblockcount(self): |
|
return self.rpc('getblockcount') |
|
def getwork(self, data=None): |
|
return self.rpc('getwork', data) |
|
|
|
def uint32(x): |
|
return x & 0xffffffffL |
|
|
|
def bytereverse(x): |
|
return uint32(( ((x) << 24) | (((x) << 8) & 0x00ff0000) | |
|
(((x) >> 8) & 0x0000ff00) | ((x) >> 24) )) |
|
|
|
def bufreverse(in_buf): |
|
out_words = [] |
|
for i in range(0, len(in_buf), 4): |
|
word = struct.unpack('@I', in_buf[i:i+4])[0] |
|
out_words.append(struct.pack('@I', bytereverse(word))) |
|
return ''.join(out_words) |
|
|
|
def wordreverse(in_buf): |
|
out_words = [] |
|
for i in range(0, len(in_buf), 4): |
|
out_words.append(in_buf[i:i+4]) |
|
out_words.reverse() |
|
return ''.join(out_words) |
|
|
|
class Miner: |
|
def __init__(self, id): |
|
self.id = id |
|
self.max_nonce = MAX_NONCE |
|
|
|
def work(self, datastr, targetstr): |
|
# decode work data hex string to binary |
|
static_data = datastr.decode('hex') |
|
static_data = bufreverse(static_data) |
|
|
|
# the first 76b of 80b do not change |
|
blk_hdr = static_data[:76] |
|
|
|
# decode 256-bit target value |
|
targetbin = targetstr.decode('hex') |
|
targetbin = targetbin[::-1] # byte-swap and dword-swap |
|
targetbin_str = targetbin.encode('hex') |
|
target = long(targetbin_str, 16) |
|
|
|
# pre-hash first 76b of block header |
|
static_hash = hashlib.sha256() |
|
static_hash.update(blk_hdr) |
|
|
|
for nonce in xrange(self.max_nonce): |
|
|
|
# encode 32-bit nonce value |
|
nonce_bin = struct.pack("<I", nonce) |
|
|
|
# hash final 4b, the nonce value |
|
hash1_o = static_hash.copy() |
|
hash1_o.update(nonce_bin) |
|
hash1 = hash1_o.digest() |
|
|
|
# sha256 hash of sha256 hash |
|
hash_o = hashlib.sha256() |
|
hash_o.update(hash1) |
|
hash = hash_o.digest() |
|
|
|
# quick test for winning solution: high 32 bits zero? |
|
if hash[-4:] != '\0\0\0\0': |
|
continue |
|
|
|
# convert binary hash to 256-bit Python long |
|
hash = bufreverse(hash) |
|
hash = wordreverse(hash) |
|
|
|
hash_str = hash.encode('hex') |
|
l = long(hash_str, 16) |
|
|
|
# proof-of-work test: hash < target |
|
if l < target: |
|
print time.asctime(), "PROOF-OF-WORK found: %064x" % (l,) |
|
return (nonce + 1, nonce_bin) |
|
else: |
|
print time.asctime(), "PROOF-OF-WORK false positive %064x" % (l,) |
|
# return (nonce + 1, nonce_bin) |
|
|
|
return (nonce + 1, None) |
|
|
|
def submit_work(self, rpc, original_data, nonce_bin): |
|
nonce_bin = bufreverse(nonce_bin) |
|
nonce = nonce_bin.encode('hex') |
|
solution = original_data[:152] + nonce + original_data[160:256] |
|
param_arr = [ solution ] |
|
result = rpc.getwork(param_arr) |
|
print time.asctime(), "--> Upstream RPC result:", result |
|
|
|
def iterate(self, rpc): |
|
work = rpc.getwork() |
|
if work is None: |
|
time.sleep(ERR_SLEEP) |
|
return |
|
if 'data' not in work or 'target' not in work: |
|
time.sleep(ERR_SLEEP) |
|
return |
|
|
|
time_start = time.time() |
|
|
|
(hashes_done, nonce_bin) = self.work(work['data'], |
|
work['target']) |
|
|
|
time_end = time.time() |
|
time_diff = time_end - time_start |
|
|
|
self.max_nonce = long( |
|
(hashes_done * settings['scantime']) / time_diff) |
|
if self.max_nonce > 0xfffffffaL: |
|
self.max_nonce = 0xfffffffaL |
|
|
|
if settings['hashmeter']: |
|
print "HashMeter(%d): %d hashes, %.2f Khash/sec" % ( |
|
self.id, hashes_done, |
|
(hashes_done / 1000.0) / time_diff) |
|
|
|
if nonce_bin is not None: |
|
self.submit_work(rpc, work['data'], nonce_bin) |
|
|
|
def loop(self): |
|
rpc = BitcoinRPC(settings['host'], settings['port'], |
|
settings['rpcuser'], settings['rpcpass']) |
|
if rpc is None: |
|
return |
|
|
|
while True: |
|
self.iterate(rpc) |
|
|
|
def miner_thread(id): |
|
miner = Miner(id) |
|
miner.loop() |
|
|
|
if __name__ == '__main__': |
|
if len(sys.argv) != 2: |
|
print "Usage: pyminer.py CONFIG-FILE" |
|
sys.exit(1) |
|
|
|
f = open(sys.argv[1]) |
|
for line in f: |
|
# skip comment lines |
|
m = re.search('^\s*#', line) |
|
if m: |
|
continue |
|
|
|
# parse key=value lines |
|
m = re.search('^(\w+)\s*=\s*(\S.*)$', line) |
|
if m is None: |
|
continue |
|
settings[m.group(1)] = m.group(2) |
|
f.close() |
|
|
|
if 'host' not in settings: |
|
settings['host'] = '127.0.0.1' |
|
if 'port' not in settings: |
|
settings['port'] = 8332 |
|
if 'threads' not in settings: |
|
settings['threads'] = 1 |
|
if 'hashmeter' not in settings: |
|
settings['hashmeter'] = 0 |
|
if 'scantime' not in settings: |
|
settings['scantime'] = 30L |
|
if 'rpcuser' not in settings or 'rpcpass' not in settings: |
|
print "Missing username and/or password in cfg file" |
|
sys.exit(1) |
|
|
|
settings['port'] = int(settings['port']) |
|
settings['threads'] = int(settings['threads']) |
|
settings['hashmeter'] = int(settings['hashmeter']) |
|
settings['scantime'] = long(settings['scantime']) |
|
|
|
thr_list = [] |
|
for thr_id in range(settings['threads']): |
|
p = Process(target=miner_thread, args=(thr_id,)) |
|
p.start() |
|
thr_list.append(p) |
|
time.sleep(1) # stagger threads |
|
|
|
print settings['threads'], "mining threads started" |
|
|
|
print time.asctime(), "Miner Starts - %s:%s" % (settings['host'], settings['port']) |
|
try: |
|
for thr_proc in thr_list: |
|
thr_proc.join() |
|
except KeyboardInterrupt: |
|
pass |
|
print time.asctime(), "Miner Stops - %s:%s" % (settings['host'], settings['port']) |
|
|
|
|