#!/usr/bin/python3

# Eloipool - Python Bitcoin pool server

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

#

# 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 config

if not hasattr(config, 'ServerName'):

config.ServerName = 'Unnamed Eloipool'

if not hasattr(config, 'ShareTarget'):

config.ShareTarget = 0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff

import logging

if len(logging.root.handlers) == 0:

logging.basicConfig(

format='%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s',

level=logging.DEBUG,

)

for infoOnly in ('checkShare', 'JSONRPCHandler', 'merkleMaker', 'Waker for JSONRPCServer', 'JSONRPCServer'):

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

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/'

import jsonrpc

UpstreamBitcoindJSONRPC = jsonrpc.ServiceProxy(config.UpstreamURI)

from bitcoin.script import BitcoinScript

from bitcoin.txn import Txn

from base58 import b58decode

from struct import pack

import subprocess

from time import time

def makeCoinbaseTxn(coinbaseValue, useCoinbaser = True):

return txn

import jsonrpc_getwork

from util import Bits2Target

workLog = {}

userStatus = {}

networkTarget = None

DupeShareHACK = {}

server = None

def updateBlocks():

server.wakeLongpoll()

def blockChanged():

updateBlocks()

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.clearCoinbaseTxn = makeCoinbaseTxn(5000000000, False) # FIXME

MM.clearCoinbaseTxn.assemble()

MM.makeCoinbaseTxn = makeCoinbaseTxn

MM.onBlockChange = blockChanged

MM.onBlockUpdate = updateBlocks

from binascii import b2a_hex

from copy import deepcopy

from math import log

from merklemaker import MakeBlockHeader

from struct import pack, unpack

import threading

from time import time

from util import RejectedShare, dblsha, hash2int, swap32, target2pdiff

import jsonrpc

import traceback

gotwork = None

if hasattr(config, 'GotWorkURI'):

gotwork = jsonrpc.ServiceProxy(config.GotWorkURI)

if not hasattr(config, 'DynamicTargetting'):

config.DynamicTargetting = 0

else:

if not hasattr(config, 'DynamicTargetWindow'):

config.DynamicTargetWindow = 120

config.DynamicTargetGoal *= config.DynamicTargetWindow / 60

def submitGotwork(info):

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

def getTarget(username, now):

return target

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

def RegisterWork(username, wli, wld):

return target or config.ShareTarget

def getBlockHeader(username):

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

def getBlockTemplate(username):

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

loggersShare = []

RBDs = []

RBPs = []

from bitcoin.varlen import varlenEncode, varlenDecode

import bitcoin.txn

from merklemaker import assembleBlock

RBFs = []

def blockSubmissionThread(payload, blkhash, share):

RaiseRedFlags('Upstream block submission failed: %s' % (rv,))

def checkShare(share):

raise RejectedShare('bad-txns')

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

def receiveShare(share):

i(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

SAVE_STATE_FILENAME = 'eloipool.worklog'

def stopServers():

os.close(fd)

def saveState(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():

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

from jsonrpcserver import JSONRPCListener, JSONRPCServer

import interactivemode

from networkserver import NetworkListener

import threading

import sharelogging

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.logShare)

except:

logging.getLogger('sharelogging').error("Error setting up share logger %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()

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

if hasattr(config, 'TrustedForwarders'):

server.TrustedForwarders = config.TrustedForwarders

server.ServerName = config.ServerName

MM.start()

restoreState()

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()

server.serve_forever()