def test_http_ports(self, mock_httplib):
setup_mock_httplib(mock_httplib)
# http:// URL
_ = jsonrpc.ServiceProxy('http://localhost/')
http = MockHTTPConnection.current
assert http.port == 80
assert http.hostname == 'localhost'
assert not http.is_https
# http:// URL with custom port
MockHTTPConnection.current = None
_ = jsonrpc.ServiceProxy('http://example.com:1234/')
http = MockHTTPConnection.current
assert http.port == 1234
assert http.hostname == 'example.com'
assert not http.is_https
# https:// URL
MockHTTPConnection.current = None
_ = jsonrpc.ServiceProxy('https://localhost/')
http = MockHTTPConnection.current
assert http.port == 443
assert http.hostname == 'localhost'
assert http.is_https
# https:// URL with custom port
MockHTTPConnection.current = None
MockHTTPConnection.current = None
_ = jsonrpc.ServiceProxy('https://example.com:4430/')
http = MockHTTPConnection.current
assert http.port == 4430
assert http.hostname == 'example.com'
assert http.is_https
def _prepare(self):
self.access = jsonrpc.ServiceProxy(self.UpstreamURI)
self.currentBlock = (None, None, None)
self.currentMerkleTree = None
self.merkleRoots = deque(maxlen=self.WorkQueueSizeRegular[1])
self.LowestMerkleRoots = self.WorkQueueSizeRegular[1]
if not hasattr(self, 'WorkQueueSizeClear'):
self.WorkQueueSizeClear = self.WorkQueueSizeLongpoll
self._MaxClearSize = max(self.WorkQueueSizeClear[1],
self.WorkQueueSizeLongpoll[1])
self.clearMerkleTree = MerkleTree([self.clearCoinbaseTxn])
self.clearMerkleRoots = Queue(self._MaxClearSize)
self.LowestClearMerkleRoots = self.WorkQueueSizeClear[1]
self.nextMerkleRoots = Queue(self._MaxClearSize)
if not hasattr(self, 'WarningDelay'):
self.WarningDelay = max(15, self.MinimumTxnUpdateWait * 2)
if not hasattr(self, 'WarningDelayTxnLongpoll'):
self.WarningDelayTxnLongpoll = self.WarningDelay
if not hasattr(self, 'WarningDelayMerkleUpdate'):
self.WarningDelayMerkleUpdate = self.WarningDelay
self.lastMerkleUpdate = 0
self.nextMerkleUpdate = 0
global now
now = time()
self.updateMerkleTree()
def _prepare(self):
self.access = jsonrpc.ServiceProxy(self.UpstreamURI)
self.ready = False
self.readyCV = threading.Condition()
self.currentBlock = (None, None, None)
self.lastBlock = (None, None, None)
self.SubsidyAlgo = lambda height: 5000000000 >> (height // 210000)
self.currentMerkleTree = None
self.merkleRoots = deque(maxlen=self.WorkQueueSizeRegular[1])
self.LowestMerkleRoots = self.WorkQueueSizeRegular[1]
if not hasattr(self, 'WorkQueueSizeClear'):
self.WorkQueueSizeClear = self.WorkQueueSizeLongpoll
self._MaxClearSize = max(self.WorkQueueSizeClear[1],
self.WorkQueueSizeLongpoll[1])
self.clearMerkleRoots = Queue(self._MaxClearSize)
self.LowestClearMerkleRoots = self.WorkQueueSizeClear[1]
self.nextMerkleRoots = Queue(self._MaxClearSize)
if not hasattr(self, 'WarningDelay'):
self.WarningDelay = max(15, self.MinimumTxnUpdateWait * 2)
if not hasattr(self, 'WarningDelayTxnLongpoll'):
self.WarningDelayTxnLongpoll = self.WarningDelay
if not hasattr(self, 'WarningDelayMerkleUpdate'):
self.WarningDelayMerkleUpdate = self.WarningDelay
self.lastMerkleUpdate = 0
self.nextMerkleUpdate = 0
def _CallGBT(self, TS):
access = jsonrpc.ServiceProxy(TS['uri'])
self.logger.debug('Requesting new template from \'%s\'' % (TS['name'],))
try:
# First, try BIP 22 standard getblocktemplate :)
MP = access.getblocktemplate(self.GBTReq)
access.OldGMP = False
except:
try:
# Failing that, give BIP 22 draft (2012-02 through 2012-07) getmemorypool a chance
MP = access.getmemorypool(self.GMPReq)
except:
try:
# Finally, fall back to bitcoind 0.5/0.6 getmemorypool
MP = access.getmemorypool()
except:
MP = False
if MP is False:
# This way, we get the error from the BIP22 call if the old one fails too
raise
# Pre-BIP22 server (bitcoind <0.7 or Eloipool <20120513)
if not access.OldGMP:
access.OldGMP = True
self.logger.warning('Upstream \'%s\' is not BIP 22 compatible' % (TS['name'],))
return MP
def __init__(self, config, address, logger=None):
"""
Check that the RPC library can be imported and set up the RPC http server connection
"""
self.logger = logger if logger else logging.getLogger('null')
self.address = address
self.rpc = None
try:
import jsonrpc
except ImportError:
self.logger.warning('NuRPC: jsonrpc library could not be imported')
else:
# rpc connection
self.JSONRPCException = jsonrpc.JSONRPCException
opts = dict(tuple(line.strip().replace(' ', '').split('='))
for line in open(config).readlines() if len(line.split('=')) == 2)
if 'rpcuser' not in opts.keys() or 'rpcpassword' not in opts.keys():
self.logger.error("NuRPC: RPC parameters could not be read")
else:
try:
self.rpc = jsonrpc.ServiceProxy("http://%s:%[email protected]:%s" %
(opts['rpcuser'], opts['rpcpassword'], 14002))
self.txfee = self.rpc.getinfo()['paytxfee']
except:
self.logger.error("NuRPC: RPC connection could not be established")
self.rpc = None
def HandleLP():
global server
# FIXME: get path from gmp!
pool = jsonrpc.ServiceProxy(sys.argv[1].rstrip('/') + '/LP')
while True:
try:
mp = pool.getmemorypool()
break
except socket.timeout:
pass
jsonrpc_getwork._CheckForDupesHACK = {}
makeMRD(mp)
server.wakeLongpoll()
def test_method_call_with_kwargs(self):
s = jsonrpc.ServiceProxy("http://localhost/")
http = MockHTTPConnection.current
http.respdata = '{"result": {"foobar": true},"error":null,"id": 1}'
echo = s.echo_kwargs(foobar=True)
self.assertEquals(MockHTTPConnection.current.postdata,
jsonrpc.dumps({
'id': 1,
'jsonrpc': '2.0',
'method':'echo_kwargs',
'params': {'foobar': True},
}))
self.assertEquals(echo, {'foobar': True})
def test_method_call_with_kwargs(self, mock_httplib):
setup_mock_httplib(mock_httplib)
s = jsonrpc.ServiceProxy("http://localhost/")
http = MockHTTPConnection.current
http.respdata = b'{"result": {"foobar": true},"error": null, "id": 1}'
echo = s.echo_kwargs(foobar=True)
expect = jsonrpc.dumps({
'id': 1,
'jsonrpc': '2.0',
'method': 'echo_kwargs',
'params': {
'foobar': True
},
})
assert expect == MockHTTPConnection.current.postdata
assert echo == {'foobar': True}
def test_MethodCallCallsService(self):
s = jsonrpc.ServiceProxy("http://localhost/")
self.respdata = '{"result":"foobar","error":null,"id":""}'
echo = s.echo("foobar")
self.assertEquals(
self.postdata,
jsonrpc.dumps({
"method": "echo",
'params': ['foobar'],
'id': 'jsonrpc'
}))
self.assertEquals(echo, 'foobar')
self.respdata = '{"result":null,"error":"MethodNotFound","id":""}'
try:
s.echo("foobar")
except jsonrpc.JSONRPCException, e:
self.assertEquals(e.error, "MethodNotFound")
def test_method_call(self):
s = jsonrpc.ServiceProxy("http://localhost/")
http = MockHTTPConnection.current
http.respdata = '{"result":"foobar","error":null,"id": 1}'
echo = s.echo('foobar')
self.assertEquals(MockHTTPConnection.current.postdata,
jsonrpc.dumps({
'id': 1,
'jsonrpc': '2.0',
'method':'echo',
'params': ['foobar'],
}))
self.assertEquals(echo, 'foobar')
http.respdata='{"result":null,"error":"MethodNotFound","id":""}'
try:
s.echo('foobar')
except jsonrpc.JSONRPCException,e:
self.assertEquals(e.error, 'MethodNotFound')
def rootstockSubmissionThread(blkHash, blkHeader, coinbase, merkleHashes,
txnCount, share):
servers = list(
a for b in rootstockSubmissionThread.rootstock.RootstockSources
for a in b)
tries = 0
start_time = None
finish_time = None
while len(servers):
tries += 1
RS = servers.pop(0)
# Don't reuse the same connection object that getWork since we want the solution to be submitted asap
#UpstreamRskdJSONRPC = RS['access']
UpstreamRskdJSONRPC = jsonrpc.ServiceProxy(RS['uri'], timeout=3)
try:
start_time = datetime.now()
# All parameters submitted to mnr_submitBitcoinBlockPartialMerkle must be hex formated
UpstreamRskdJSONRPC.mnr_submitBitcoinBlockPartialMerkle(
blkHash, blkHeader, coinbase, merkleHashes, txnCount)
finish_time = datetime.now()
rootstock.updateRootstock(True)
except BaseException as gbterr:
gbterr_fmt = traceback.format_exc()
if tries > len(servers):
msg = 'Upstream \'{0}\' block submission failed: {1}'.format(
RS['name'], gbterr_fmt)
rootstockSubmissionThread.logger.error(msg)
return
servers.append(RS)
continue
if finish_time is not None:
rootstockSubmissionThread.logger.info(
"ROOTSTOCK: submitBitcoinBlock: {}, {}, {}, {}".format(
start_time, finish_time, share['jobid'],
b2a_hex(share['nonce']).decode('ascii')))
else:
rootstockSubmissionThread.logger.info(
"submitBitcoinBlock failed: {}".format(tries))
def test_method_call(self, mock_httplib):
setup_mock_httplib(mock_httplib)
s = jsonrpc.ServiceProxy("http://localhost/")
http = MockHTTPConnection.current
http.respdata = b'{"result":"foobar","error":null,"id": 1}'
echo = s.echo('foobar')
expect = jsonrpc.dumps({
'id': 1,
'jsonrpc': '2.0',
'method': 'echo',
'params': ['foobar']
})
assert expect == MockHTTPConnection.current.postdata
assert echo == 'foobar'
http.respdata = b'{"result":null,"error":"MethodNotFound","id":""}'
try:
s.echo('foobar')
except jsonrpc.JSONRPCException as e:
assert e.error == 'MethodNotFound'
def __init__(self, connection_string, main_account_name):
self.bitcoind_api = jsonrpc.ServiceProxy(connection_string)
self.account_name = main_account_name
#'space' is how often the simulation outputs a datapoint
space = 100
#I don't remember why I did it this way, just leave 'c' alone unless you know what's up
c = starblk
#Configure RPC
#NUCONFIG='%s/.nu/nu.conf'%os.getenv("HOME")
#If you are windows, comment you the previous line and uncomment the following:
NUCONFIG = r'%s\nu\nu.conf' % os.getenv("APPDATA")
opts = dict(
tuple(line.strip().replace(' ', '').split('='))
for line in open(NUCONFIG).readlines())
try:
rpc = jsonrpc.ServiceProxy(
"http://%s:%[email protected]:%s" %
(opts['rpcuser'], opts['rpcpassword'], opts.pop('rpcport', 14002)))
except:
print "could not connect to nbt daemon"
sys.exit(1)
try:
nsrrpc = jsonrpc.ServiceProxy(
"http://%s:%[email protected]:%s" %
(opts['rpcuser'], opts['rpcpassword'], opts.pop('rpcport', 14001)))
except:
print "could not connect to nsr daemon"
sys.exit(1)
try:
blkcnt = rpc.getblockcount()
except:
print "Issues with RPC"
if len(sys.argv) < 5:
print(\
"""\
Usage: %s <file> <dest addr> <dest amount> {<fee-per-kb>}
Set BTCRPCURL=http://user:pass@localhost:portnum""" % sys.argv[0], file=sys.stderr)
sys.exit()
COIN = 100000000
def unhexstr(str):
return unhexlify(str.encode('utf8'))
proxy = jsonrpc.ServiceProxy(os.environ['BTCRPCURL'])
def select_txins(value):
unspent = list(proxy.listunspent())
random.shuffle(unspent)
r = []
total = 0
for tx in unspent:
total += tx['amount']
r.append(tx)
if total >= value:
break
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import subprocess
import os
import json
from decimal import Decimal
import math
import config
import jsonrpc
rpc_server = jsonrpc.ServiceProxy("http://" + config.RPC_USERNAME + ":" +\
config.RPC_PASSWORD + "@127.0.0.1:" + str(config.RPC_PORT))
try:
for account in config.ACCOUNTS:
if account['coin'] == 'NBT':
s = rpc_server.addmultisigaddress(account['sign_threshold'],
account['pubkeys'],
account['name'])
print "Added multisig address to client, label =", account['name']
if s == account['address']:
print "Multisig address seems valid."
else:
print "Address does not match given public keys (note that order matters)"
except:
print "Error verifying multisig address!"
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/'
import jsonrpc
UpstreamBitcoindJSONRPC = jsonrpc.ServiceProxy(config.UpstreamURI)
try:
import jsonrpc.authproxy
jsonrpc.authproxy.USER_AGENT = 'Eloipool/0.1'
except:
pass
from bitcoin.script import BitcoinScript
from bitcoin.txn import Txn
from base58 import b58decode
from struct import pack
import subprocess
from time import time
#!/usr/bin/python
# Copyright (C) 2016 by Daniel Kraft <*****@*****.**>
# Find information about nearby loot and banks for a player.
import jsonrpc
import sys
name = "domob"
rpc = jsonrpc.ServiceProxy("http://*****:*****@localhost:8399/")
def distLInf(a, b):
"""
Utility method to compute the L-infinity distance between
the given two coordinates.
"""
return max(abs(a[0] - b[0]), abs(a[1] - b[1]))
def pathlen(a, path):
"""
Compute the L-infinity path length from a via the given
list of way points.
"""
if len(path) == 0:
return 0
res = distLInf(a, [path[0], path[1]])
for i in range(2, len(path), 2):
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, blakehash, 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 else: if not hasattr(config, 'DynamicTargetWindow'): config.DynamicTargetWindow = 120 config.DynamicTargetGoal *= config.DynamicTargetWindow / 60 def submitGotwork(info): try: gotwork.gotwork(info) except:
def _callGetWorkFrom(self, RS):
access = jsonrpc.ServiceProxy(RS['uri'], timeout=3)
return access.mnr_getWork()
import jsonrpc
import psycopg2
import time
import socket
rpc_username = "******"
rpc_password = "******"
db = psycopg2.connect(database="bitwallet",
user="******",
password="******")
bitcoin = jsonrpc.ServiceProxy("http://" + rpc_username + ":" + rpc_password +
"@127.0.0.1:8332/")
while True:
try:
c = db.cursor()
c.execute("""
SELECT COUNT(bitcoin_address)
FROM bitcoin_addresses
WHERE user_id IS NULL
""")
result = c.fetchone()
if result:
count = result[0]
if count < 1000:
for x in xrange(1000 - count):
def URI2Access(uri):
if uri not in _URI2Access:
access = jsonrpc.ServiceProxy(uri)
access.OldGMP = False
_URI2Access[uri] = access
return _URI2Access[uri]
# Parse the config file
reserved_sections = ['bitcoind', 'HoldingAddresses']
config = ConfigParser.ConfigParser()
config.read(config_file)
rpchost = config.get('bitcoind', 'rpchost')
rpcport = config.get('bitcoind', 'rpcport')
rpcuser = config.get('bitcoind', 'rpcuser')
rpcpwd = config.get('bitcoind', 'rpcpwd')
# Connect to bitcoind
if len(rpcuser) == 0 and len(rpcpwd) == 0:
bitcoind_connection_string = "http://*****:*****@%s:%s" % (rpcuser, rpcpwd,
rpchost, rpcport)
sp = jsonrpc.ServiceProxy(bitcoind_connection_string)
### End: Create/Read Config
### Start: Address Generation code
# The following code was yoinked from addrgen.py
# Thanks to: Joric/bitcoin-dev, june 2012, public domain
ssl = ctypes.cdll.LoadLibrary(ctypes.util.find_library('ssl') or 'libeay32')
def check_result(val, func, args):
if val == 0: raise ValueError
else: return ctypes.c_void_p(val)
ssl.EC_KEY_new_by_curve_name.restype = ctypes.c_void_p
def test_provides_proxy_method(self):
s = jsonrpc.ServiceProxy("http://localhost/")
self.assert_(callable(s.echo))
def test_provides_proxy_method(self, mock_httplib):
setup_mock_httplib(mock_httplib)
s = jsonrpc.ServiceProxy("http://localhost/")
assert callable(s.echo)
def blockSubmissionThread(payload, blkhash, share):
if config.BlockSubmissions is None:
servers = list(a for b in MM.TemplateSources for a in b)
else:
servers = list(config.BlockSubmissions)
if hasattr(share['merkletree'], 'source_uri'):
servers.insert(0, {
'access': jsonrpc.ServiceProxy(share['merkletree'].source_uri),
'name': share['merkletree'].source,
})
elif not servers:
servers = list(a for b in MM.TemplateSources for a in b)
myblock = (blkhash, payload[4:36])
payload = b2a_hex(payload).decode('ascii')
nexterr = 0
tries = 0
success = False
while len(servers):
tries += 1
TS = servers.pop(0)
UpstreamBitcoindJSONRPC = TS['access']
try:
# BIP 22 standard submitblock
reason = UpstreamBitcoindJSONRPC.submitblock(payload)
except BaseException as gbterr:
gbterr_fmt = traceback.format_exc()
try:
try:
# bitcoind 0.5/0.6 getmemorypool
reason = UpstreamBitcoindJSONRPC.getmemorypool(payload)
except:
# Old BIP 22 draft getmemorypool
reason = UpstreamBitcoindJSONRPC.getmemorypool(payload, {})
if reason is True:
reason = None
elif reason is False:
reason = 'rejected'
except BaseException as gmperr:
now = time()
if now > nexterr:
# FIXME: This will show "Method not found" on pre-BIP22 servers
RaiseRedFlags(gbterr_fmt)
nexterr = now + 5
if MM.currentBlock[0] not in myblock and tries > len(servers):
RBFs.append( (('next block', MM.currentBlock, now, (gbterr, gmperr)), payload, blkhash, share) )
RaiseRedFlags('Giving up on submitting block to upstream \'%s\'' % (TS['name'],))
if share['upstreamRejectReason'] is PendingUpstream:
share['upstreamRejectReason'] = 'GAVE UP'
share['upstreamResult'] = False
logShare(share)
return
servers.append(TS)
continue
# At this point, we have a reason back
if reason:
# FIXME: The returned value could be a list of multiple responses
msg = 'Upstream \'%s\' block submission failed: %s' % (TS['name'], reason,)
if success and reason in ('stale-prevblk', 'bad-prevblk', 'orphan', 'duplicate'):
# no big deal
blockSubmissionThread.logger.debug(msg)
else:
RBFs.append( (('upstream reject', reason, time()), payload, blkhash, share) )
RaiseRedFlags(msg)
else:
blockSubmissionThread.logger.debug('Upstream \'%s\' accepted block' % (TS['name'],))
success = True
if share['upstreamRejectReason'] is PendingUpstream:
share['upstreamRejectReason'] = reason
share['upstreamResult'] = not reason
logShare(share)
import jsonrpc_getwork
import merkletree
import socket
from struct import pack
import sys
import threading
from time import time
from util import RejectedShare
try:
import jsonrpc.authproxy
jsonrpc.authproxy.USER_AGENT = 'gmp-proxy/0.1'
except:
pass
pool = jsonrpc.ServiceProxy(sys.argv[1])
worklog = {}
currentwork = [None, 0, 0]
def makeMRD(mp):
coinbase = bytes.fromhex(mp['coinbasetxn'])
cbtxn = bitcoin.txn.Txn(coinbase)
cbtxn.disassemble()
cbtxn.originalCB = cbtxn.getCoinbase()
txnlist = [
cbtxn,
] + list(map(bitcoin.txn.Txn, map(bytes.fromhex, mp['transactions'])))
merkleTree = merkletree.MerkleTree(txnlist)
merkleRoot = None
import jsonrpc
import json
from ProfitLib import *
daemons=json.loads(open("daemon_config.json").read())
exchanges=json.loads(open("exchange_config.json").read())
pl=ProfitLib(daemons, exchanges)
pl.GetMarketIDs()
balances={}
btcbal=Decimal(0)
for i, coin in enumerate(daemons):
if (daemons[coin]["active"]==1):
url="http://"+daemons[coin]["username"]+":"+daemons[coin]["passwd"]+"@"+daemons[coin]["host"]+":"+str(daemons[coin]["port"])
b=jsonrpc.ServiceProxy(url)
try:
bal=b.getbalance()
if (bal>0):
bid=pl.GetBestBid(coin.split("_")[0])
if (coin!="BTC"):
balances[coin.split("_")[0]]=[str(bal), str((bid[0]*Decimal(bal)).quantize(Decimal("1.00000000"))), bid[1]]
btcbal+=bid[0]*Decimal(bal)
else:
balances[coin.split("_")[0]]=[str(bal), str(bal), ""]
btcbal+=Decimal(bal)
except IOError:
print coin+" offline"
exchtotals={}
for i, coin in enumerate(balances):
def Calculate(self):
self.GetMarketIDs()
for i, coin in enumerate(self.daemons):
if (self.daemons[coin]["active"] == 1
): # only check active configs
url = "http://" + self.daemons[coin][
"username"] + ":" + self.daemons[coin][
"passwd"] + "@" + self.daemons[coin][
"host"] + ":" + str(self.daemons[coin]["port"])
hashrate = Decimal(
self.daemons[coin]["hashespersec"]) # our hashrate
self.out[coin] = {}
# connect to coind
b = jsonrpc.ServiceProxy(url)
# get block reward, including transaction fees
# note #1: Novacoin (and coins derived from it?) report
# 1% of actual value here
# note #2: Namecoin doesn't support getblocktemplate, so get
# coinbase value from last block
# note #3: PPCoin doesn't want any parameters passed to
# getblocktemplate. Bitcoin requires at least
# an empty dictionary to be passed. Others don't
# care.
reward = Decimal(0)
try:
reward = Decimal(b.getblocktemplate()["coinbasevalue"])
except:
pass
if (reward == 0):
try:
reward = Decimal(
b.getblocktemplate({})["coinbasevalue"])
except:
pass
if (reward == 0):
try:
vouts = b.decoderawtransaction(
b.getrawtransaction(
b.getblock(b.getblockhash(
b.getblockcount()))["tx"][0]))["vout"]
for j, vout in enumerate(vouts):
reward += vout["value"]
except:
pass
if (coin == "NVC" or coin == "DEM" or coin == "OSC"
or coin == "PPC"):
reward *= 100
# get proof-of-work difficulty
# try getmininginfo first to minimize RPC calls; only use
# getdifficulty if we must (as with NMC)
algo = self.daemons[coin]["algo"]
if (algo == "sha256"):
algo = "sha256d"
try:
mining_info = b.getmininginfo()
diff = mining_info[
"difficulty_" +
algo] # for MYR & other multi-algo coins
if (type(diff) is dict):
diff = diff["proof-of-work"]
except:
try:
diff = mining_info["difficulty"]
if (type(diff) is dict):
diff = diff["proof-of-work"]
except:
diff = b.getdifficulty()
if (type(diff) is dict):
diff = diff["proof-of-work"]
# get network hashrate
# note 1: Novacoin reports this in MH/s, not H/s
# note 2: Namecoin and Unobtanium don't report network hashrate, so
# return 0 (it's only informational anyway)
try:
nethashrate = mining_info["networkhashps"]
except:
try:
nethashrate = int(mining_info["netmhashps"] * 1000000)
except:
nethashrate = 0
# ported from my C# implementation at
# https://github.com/salfter/CoinProfitability/blob/master/CoinProfitabilityLibrary/Profitability.cs
interval = Decimal(86400) # 1 day
target = Decimal(
((65535 << 208) * 100000000000) / (diff * 100000000000))
revenue = Decimal(interval * target * hashrate * reward /
(1 << 256))
# write to output dictionary
self.out[coin]["reward"] = int(reward)
self.out[coin]["difficulty"] = float(
Decimal(diff).quantize(Decimal("1.00000000")))
self.out[coin]["nethashespersec"] = int(nethashrate)
self.out[coin]["daily_revenue"] = int(revenue)
# if not Bitcoin, get exchange rate and BTC equivalent
if (coin != "BTC"):
bid = self.GetBestBid(coin.split(
"_")[0]) # 30 Jun 15: multi-algo compatibility
self.out[coin]["exchrate"] = float(
Decimal(bid[0]).quantize(Decimal("1.00000000")))
self.out[coin]["exchange"] = bid[1]
self.out[coin]["daily_revenue_btc"] = int(
Decimal(revenue * Decimal(bid[0])))
else:
self.out[coin]["exchrate"] = float(
Decimal(100000000).quantize(Decimal("1.00000000")))
self.out[coin]["exchange"] = "n/a"
self.out[coin]["daily_revenue_btc"] = int(revenue)
# copy these informational values from config dictionary
self.out[coin]["algo"] = self.daemons[coin]["algo"]
self.out[coin]["merged"] = self.daemons[coin]["merged"]
return self.out
