#!/usr/bin/python3

# Eloipool - Python Bitcoin pool server

# Copyright (C) 2011-2013 Luke Dashjr <luke-jr+eloipool@utopios.org>

# Portions written by Peter Leurs <kinlo@triplemining.com>

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU Affero 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 Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program. If not, see <http://www.gnu.org/licenses/>.

import argparse

import importlib

import struct

import util

argparser = argparse.ArgumentParser()

argparser.add_argument('-c', '--config', help='Config name to load from config_<ARG>.py')

args = argparser.parse_args()

configmod = 'config'

if not args.config is None:

configmod = 'config_%s' % (args.config,)

__import__(configmod)

config = importlib.import_module(configmod)

if not hasattr(config, 'ServerName'):

config.ServerName = 'Unnamed Eloipool'

if not hasattr(config, 'ShareTarget'):

config.ShareTarget = 0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff

if not hasattr(config, 'WorkUpdateInterval'):

config.WorkUpdateInterval = 55

config.StaleWorkTimeout = max(120, config.WorkUpdateInterval * 2)

util.UniqueSessionIdManager._defaultDelay = config.StaleWorkTimeout

import logging

import logging.handlers

rootlogger = logging.getLogger(None)

logformat = getattr(config, 'LogFormat', '%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s')

logformatter = logging.Formatter(logformat)

if len(rootlogger.handlers) == 0:

logging.basicConfig(

format=logformat,

level=logging.DEBUG,

)

for infoOnly in (

'BitcoinRPC',

'checkShare',

'getTarget',

'JSONRPCHandler',

'JSONRPCServer',

'merkleMaker',

'StratumServer',

'Waker for JSONRPCServer',

'Waker for StratumServer',

'WorkLogPruner'

):

logging.getLogger(infoOnly).setLevel(logging.INFO)

if getattr(config, 'LogToSysLog', False):

sysloghandler = logging.handlers.SysLogHandler(address = '/dev/log')

rootlogger.addHandler(sysloghandler)

if hasattr(config, 'LogFile'):

if isinstance(config.LogFile, str):

filehandler = logging.FileHandler(config.LogFile)

else:

filehandler = logging.handlers.TimedRotatingFileHandler(**config.LogFile)

filehandler.setFormatter(logformatter)

rootlogger.addHandler(filehandler)

def RaiseRedFlags(reason):

logging.getLogger('redflag').critical(reason)

return reason

from bitcoin.node import BitcoinLink, BitcoinNode

bcnode = BitcoinNode(config.UpstreamNetworkId)

bcnode.userAgent += b'Eloipool:0.1/'

bcnode.newBlock = lambda blkhash: MM.updateMerkleTree()

import jsonrpc

try:

import jsonrpc.authproxy

jsonrpc.authproxy.USER_AGENT = 'Eloipool/0.1'

except:

pass

from bitcoin.script import BitcoinScript, WitnessMagic

from bitcoin.txn import Txn

from base58 import b58decode

from binascii import b2a_hex

from struct import pack

import subprocess

from time import time

def makeCoinbaseTxn(coinbaseValue, useCoinbaser = True, prevBlockHex = None, witness_commitment = NotImplemented):

return txn

import jsonrpc_getwork

from util import Bits2Target

workLog = {}

userStatus = {}

networkTarget = None

DupeShareHACK = {}

server = None

stratumsrv = None

def updateBlocks():

server.wakeLongpoll()

stratumsrv.updateJob()

def blockChanged():

stratumsrv.updateJob(wantClear=True)

from time import sleep, time

import traceback

def _WorkLogPruner_I(wl):

WorkLogPruner.logger.debug('Pruned %d jobs' % (pruned,))

def WorkLogPruner(wl):

WorkLogPruner.logger.error(traceback.format_exc())

WorkLogPruner.logger = logging.getLogger('WorkLogPruner')

from merklemaker import merkleMaker

MM = merkleMaker()

MM.__dict__.update(config.__dict__)

MM.makeCoinbaseTxn = makeCoinbaseTxn

MM.onBlockChange = blockChanged

MM.onBlockUpdate = updateBlocks

from binascii import b2a_hex

from copy import deepcopy

from math import ceil, log

from merklemaker import MakeBlockHeader

from struct import pack, unpack

import threading

from time import time

from util import PendingUpstream, RejectedShare, bdiff1target, dblsha, PoWHash, LEhash2int, swap32, target2bdiff, target2pdiff

import jsonrpc

import traceback

gotwork = None

if hasattr(config, 'GotWorkURI'):

gotwork = jsonrpc.ServiceProxy(config.GotWorkURI)

if not hasattr(config, 'DelayLogForUpstream'):

config.DelayLogForUpstream = False

if not hasattr(config, 'DynamicTargetting'):

config.DynamicTargetting = 0

config.DynamicTargetQuick = False

else:

if not hasattr(config, 'DynamicTargetWindow'):

config.DynamicTargetWindow = 120

config.DynamicTargetGoal *= config.DynamicTargetWindow / 60

if not hasattr(config, 'DynamicTargetQuick'):

config.DynamicTargetQuick = True

def submitGotwork(info):

checkShare.logger.warning('Failed to submit gotwork\n' + traceback.format_exc())

if not hasattr(config, 'GotWorkTarget'):

config.GotWorkTarget = 0

def clampTarget(target, DTMode):

return target

def getTarget(username, now, DTMode = None, RequestedTarget = None):

return target

getTarget.logger = logging.getLogger('getTarget')

def TopTargets(n = 0x10):

print('%-34s %064x %3d' % (k, tgt, t2d(tgt)))

def RegisterWork(username, wli, wld, RequestedTarget = None):

return target or config.ShareTarget

def getBlockHeader(username):

return (hdr, workLog[username][merkleRoot], target)

def getBlockTemplate(username, p_magic = None, RequestedTarget = None):

return (MC, workLog[username][wli], target)

def getStratumJob(jobid, wantClear = False):

return (MC, workLog[None][jobid])

def getExistingStratumJob(jobid):

wld = workLog[None][jobid]

return (wld[0], wld)

loggersShare = []

authenticators = []

RBDs = []

RBPs = []

from bitcoin.varlen import varlenEncode, varlenDecode

import bitcoin.txn

from merklemaker import assembleBlock

if not hasattr(config, 'BlockSubmissions'):

config.BlockSubmissions = None

RBFs = []

def blockSubmissionThread(payload, blkhash, share):

logShare(share)

blockSubmissionThread.logger = logging.getLogger('blockSubmission')

def checkData(share, wld):

raise RejectedShare('bad-version')

def buildStratumData(share, merkleroot, versionbytes):

return data

def IsJobValid(wli, wluser = None):

return True

def LookupWork(username, wli):

return MWL[wli]

def checkShare(share):

stratumsrv.quickDifficultyUpdate(username)

checkShare.logger = logging.getLogger('checkShare')

def logShare(share):

i.logShare(share)

def checkAuthentication(username, password):

return False

def receiveShare(share):

logShare(share)

def newBlockNotification():

pass

def newBlockNotificationSIGNAL(signum, frame):

thr.start()

from signal import signal, SIGUSR1

signal(SIGUSR1, newBlockNotificationSIGNAL)

import os

import os.path

import pickle

import signal

import sys

from time import sleep

import traceback

if getattr(config, 'SaveStateFilename', None) is None:

config.SaveStateFilename = 'eloipool.worklog'

def stopServers():

os.close(fd)

def stopLoggers():

for i in loggersShare:

if hasattr(i, 'stop'):

i.stop()

def saveState(SAVE_STATE_FILENAME, t = None):

logger.error(('Failed to unlink \'%s\'; resume may have trouble\n' % (SAVE_STATE_FILENAME,)) + traceback.format_exc())

def exit():

sys.exit(0)

def restart():

logging.getLogger('restart').error('Failed to exec\n' + traceback.format_exc())

def restoreState(SAVE_STATE_FILENAME):

logger.info('Total downtime: %g seconds' % (time() - t,))

from jsonrpcserver import JSONRPCListener, JSONRPCServer

import interactivemode

from networkserver import NetworkListener

import threading

import sharelogging

import authentication

from stratumserver import StratumServer

import imp

if __name__ == "__main__":

if not hasattr(config, 'ShareLogging'):

config.ShareLogging = ()

if hasattr(config, 'DbOptions'):

logging.getLogger('backwardCompatibility').warn('DbOptions configuration variable is deprecated; upgrade to ShareLogging var before 2013-03-05')

config.ShareLogging = list(config.ShareLogging)

config.ShareLogging.append( {

'type': 'sql',

'engine': 'postgres',

'dbopts': config.DbOptions,

'statement': "insert into shares (rem_host, username, our_result, upstream_result, reason, solution) values ({Q(remoteHost)}, {username}, {YN(not(rejectReason))}, {YN(upstreamResult)}, {rejectReason}, decode({solution}, 'hex'))",

} )

for i in config.ShareLogging:

if not hasattr(i, 'keys'):

name, parameters = i

logging.getLogger('backwardCompatibility').warn('Using short-term backward compatibility for ShareLogging[\'%s\']; be sure to update config before 2012-04-04' % (name,))

if name == 'postgres':

name = 'sql'

i = {

'engine': 'postgres',

'dbopts': parameters,

}

elif name == 'logfile':

i = {}

i['thropts'] = parameters

if 'filename' in parameters:

i['filename'] = parameters['filename']

i['thropts'] = dict(i['thropts'])

del i['thropts']['filename']

else:

i = parameters

i['type'] = name

name = i['type']

parameters = i

try:

fp, pathname, description = imp.find_module(name, sharelogging.__path__)

m = imp.load_module(name, fp, pathname, description)

lo = getattr(m, name)(**parameters)

loggersShare.append(lo)

except:

logging.getLogger('sharelogging').error("Error setting up share logger %s: %s", name, sys.exc_info())

if not hasattr(config, 'Authentication'):

config.Authentication = ({'module': 'allowall'},)

for i in config.Authentication:

name = i['module']

parameters = i

try:

fp, pathname, description = imp.find_module(name, authentication.__path__)

m = imp.load_module(name, fp, pathname, description)

lo = getattr(m, name)(**parameters)

authenticators.append(lo)

except:

logging.getLogger('authentication').error("Error setting up authentication module %s: %s", name, sys.exc_info())

LSbc = []

if not hasattr(config, 'BitcoinNodeAddresses'):

config.BitcoinNodeAddresses = ()

for a in config.BitcoinNodeAddresses:

LSbc.append(NetworkListener(bcnode, a))

if hasattr(config, 'UpstreamBitcoindNode') and config.UpstreamBitcoindNode:

BitcoinLink(bcnode, dest=config.UpstreamBitcoindNode)

import jsonrpc_getblocktemplate

import jsonrpc_getwork

import jsonrpc_setworkaux

server = JSONRPCServer()

server.tls = threading.local()

server.tls.wantClear = False

if hasattr(config, 'JSONRPCAddress'):

logging.getLogger('backwardCompatibility').warn('JSONRPCAddress configuration variable is deprecated; upgrade to JSONRPCAddresses list before 2013-03-05')

if not hasattr(config, 'JSONRPCAddresses'):

config.JSONRPCAddresses = []

config.JSONRPCAddresses.insert(0, config.JSONRPCAddress)

LS = []

for a in config.JSONRPCAddresses:

LS.append(JSONRPCListener(server, a))

if hasattr(config, 'SecretUser'):

server.SecretUser = config.SecretUser

server.aux = MM.CoinbaseAux

server.getBlockHeader = getBlockHeader

server.getBlockTemplate = getBlockTemplate

server.receiveShare = receiveShare

server.RaiseRedFlags = RaiseRedFlags

server.ShareTarget = config.ShareTarget

server.StaleWorkTimeout = config.StaleWorkTimeout

server.checkAuthentication = checkAuthentication

if hasattr(config, 'TrustedForwarders'):

server.TrustedForwarders = config.TrustedForwarders

server.ServerName = config.ServerName

stratumsrv = StratumServer()

stratumsrv.getStratumJob = getStratumJob

stratumsrv.getExistingStratumJob = getExistingStratumJob

stratumsrv.receiveShare = receiveShare

stratumsrv.RaiseRedFlags = RaiseRedFlags

stratumsrv.getTarget = getTarget

stratumsrv.defaultTarget = config.ShareTarget

stratumsrv.IsJobValid = IsJobValid

stratumsrv.checkAuthentication = checkAuthentication

stratumsrv.WorkUpdateInterval = config.WorkUpdateInterval

if not hasattr(config, 'StratumAddresses'):

config.StratumAddresses = ()

for a in config.StratumAddresses:

NetworkListener(stratumsrv, a)

MM.start()

restoreState(config.SaveStateFilename)

prune_thr = threading.Thread(target=WorkLogPruner, args=(workLog,))

prune_thr.daemon = True

prune_thr.start()

bcnode_thr = threading.Thread(target=bcnode.serve_forever)

bcnode_thr.daemon = True

bcnode_thr.start()

stratum_thr = threading.Thread(target=stratumsrv.serve_forever)

stratum_thr.daemon = True

stratum_thr.start()

server.serve_forever()