def get_service_status():
"""
Retrieve user configuration, and status of wallet's rpc server, transaction index, and gpg's installation.
"""
conf = get_config()
if 'rpcpassword' in conf and conf['rpcpassword']:
conf['rpcpassword'] = "******"
try:
rpc_raw = AuthServiceProxy(get_rpc_url())
rpc_raw.getblockcount()
conf['wallet_connected_status'] = "good"
except:
conf['wallet_connected_status'] = "bad"
try:
if not os.path.exists(peerapps.settings.BASE_DIR+"/test_gpg_setup"):
os.mkdir(peerapps.settings.BASE_DIR+"/test_gpg_setup")
gnupg.GPG(gnupghome=peerapps.settings.BASE_DIR+"/test_gpg_setup")
shutil.rmtree(peerapps.settings.BASE_DIR+"/test_gpg_setup", ignore_errors=True)
conf['gpg_suite_installed'] = "good"
except:
conf['gpg_suite_installed'] = "bad"
return conf
def main(max_items):
db = anydbm.open(DB_FILENAME,'c')
twister = AuthServiceProxy(RPC_URL)
for feed_url in FEEDS:
logging.info(feed_url)
feed = feedparser.parse(feed_url)
n_items = 0
for e in feed.entries:
eid = '{0}|{1}'.format(feed_url,e.id)
if db.has_key(eid): # been there, done that (or not - for a reason)
logging.debug('Skipping duplicate {0}'.format(eid))
else: # format as a <=140 character string
if len(e.link)<=MAX_URL_LENGTH:
msg = u'{0} {1}'.format(e.link,e.title)
if len(msg)>140: # Truncate (and hope it's still meaningful)
msg = msg[:137]+u'...'
else: # Link too long. Not enough space left for text :(
msg = ''
utfmsg = truncated_utf8(msg,140)# limit is 140 utf-8 bytes (not chars)
msg = unicode(utfmsg,'utf-8') # AuthServiceProxy needs unicode [we just needed to know where to truncate, and that's utf-8]
db[eid] = utfmsg # anydbm, on the other hand, can't handle unicode, so it's a good thing we've also kept the utf-8 :)
if not msg: # We've marked it as "posted", but no sense really posting it.
logging.warn(u'Link too long at {0}'.format(eid))
continue
if n_items>=max_items: # Avoid accidental flooding
logging.warn(u'Skipping "over quota" item: {0}'.format(msg))
continue
logging.info(u'posting {0}'.format(msg))
try:
twister.newpostmsg(USERNAME,get_next_k(twister,USERNAME),msg)
except Exception,e:
logging.error(`e`) # usually not very informative :(
n_items+=1
def query_transactions(ticker=None):
if not ticker:
for c in Currency.objects.all():
query_transactions.delay(c.ticker)
return
currency = Currency.objects.select_for_update().get(ticker=ticker)
coin = AuthServiceProxy(currency.api_url)
current_block = coin.getblockcount()
processed_transactions = []
block_hash = coin.getblockhash(currency.last_block)
transactions = coin.listsinceblock(block_hash)['transactions']
for tx in transactions:
if tx['txid'] in processed_transactions:
continue
if tx['category'] not in ('receive', 'generate', 'immature'):
continue
process_deposite_transaction(tx, ticker)
processed_transactions.append(tx['txid'])
currency.last_block = current_block
currency.save()
for tx in Transaction.objects.filter(processed=False, currency=currency):
query_transaction(ticker, tx.txid)
class JsonRpc:
def __init__(self, conn):
self.conn = AuthServiceProxy(conn)
def getTransactions(self, address):
return self.conn.searchrawtransactions(address, 1, 0, 2000)
def getTransaction(self, tx_id):
return self.conn.getrawtransaction(tx_id, 1)
def getInBalance(self, txs, address):
inBalance = 0
for tx in txs:
for inputs in tx["vin"]:
input_tx = self.getTransaction(inputs["txid"])
vout = inputs["vout"]
for outputs in input_tx["vout"]:
if outputs["n"] == vout and outputs["scriptPubKey"]["addresses"].__contains__(address):
inBalance += int(outputs["value"] * 10**8)
return inBalance
def getOutBalance(self, txs, address):
outBalance = 0
for tx in txs:
for output in tx["vout"]:
if output["scriptPubKey"]["addresses"].__contains__(address):
outBalance += int(output["value"] * 10**8)
return outBalance
def start_node(i, dirname, extra_args=None, rpchost=None, timewait=None, binary=None):
"""
Start a bitcoind and return RPC connection to it
"""
datadir = os.path.join(dirname, "node"+str(i))
if binary is None:
binary = os.getenv("BITCOIND", "bitcoind")
args = [ binary, "-datadir="+datadir, "-keypool=1", "-discover=0", "-rest" ]
if extra_args is not None: args.extend(extra_args)
bitcoind_processes[i] = subprocess.Popen(args)
devnull = open("/dev/null", "w+")
if os.getenv("PYTHON_DEBUG", ""):
print "start_node: bitcoind started, calling bitcoin-cli -rpcwait getblockcount"
subprocess.check_call([ os.getenv("BITCOINCLI", "bitcoin-cli"), "-datadir="+datadir] +
_rpchost_to_args(rpchost) +
["-rpcwait", "getblockcount"], stdout=devnull)
if os.getenv("PYTHON_DEBUG", ""):
print "start_node: calling bitcoin-cli -rpcwait getblockcount returned"
devnull.close()
url = "http://*****:*****@%s:%d" % (rpchost or '127.0.0.1', rpc_port(i))
if timewait is not None:
proxy = AuthServiceProxy(url, timeout=timewait)
else:
proxy = AuthServiceProxy(url)
proxy.url = url # store URL on proxy for info
return proxy
def __init__(self, server=NAMECOIND_SERVER, port=NAMECOIND_PORT,
user=NAMECOIND_USER, passwd=NAMECOIND_PASSWD,
use_https=NAMECOIND_USE_HTTPS,
passphrase=NAMECOIND_WALLET_PASSPHRASE):
global create_ssl_authproxy, do_wrap_socket
if use_https:
http_string = 'https://'
else:
http_string = 'http://'
authproxy_config_uri = http_string + user + ':' + passwd + '@' + server + ':' + str(port)
self.passphrase = passphrase
self.server = server
if do_wrap_socket:
# ssl._create_unverified_context and ssl.create_default_context are not supported.
# wrap the socket directly
connection = NamecoindConnection( server, int(port) )
self.obj = AuthServiceProxy(authproxy_config_uri, connection=connection)
elif create_ssl_authproxy:
# ssl has _create_unverified_context, so we're good to go
self.obj = AuthServiceProxy(authproxy_config_uri)
else:
# have to set up an unverified context ourselves
ssl_ctx = ssl.create_default_context()
ssl_ctx.check_hostname = False
ssl_ctx.verify_mode = ssl.CERT_NONE
connection = httplib.HTTPSConnection( server, int(port), context=ssl_ctx )
self.obj = AuthServiceProxy(authproxy_config_uri, connection=connection)
def getOrCreateAddress(self, subpath_number):
try:
return Address.objects.get(wallet=self, subpath_number=subpath_number)
except Address.DoesNotExist:
pass
new_address_full_path = self.path + [subpath_number]
new_address_full_path_str = '/'.join([str(i) for i in new_address_full_path])
# Create raw bitcoin address and key
key = Key.from_text(settings.MASTERWALLET_BIP32_KEY)
subkey = key.subkeys(new_address_full_path_str).next()
btc_address = subkey.address(use_uncompressed=False)
btc_private_key = subkey.wif(use_uncompressed=False)
# Make sure private key is stored to the database of bitcoind
rpc = AuthServiceProxy('http://' + settings.BITCOIN_RPC_USERNAME + ':' + settings.BITCOIN_RPC_PASSWORD + '@' + settings.BITCOIN_RPC_IP + ':' + str(settings.BITCOIN_RPC_PORT))
try:
rpc.importprivkey(btc_private_key, '', False)
except:
raise Exception('Unable to store Bitcoin address to Bitcoin node!')
# Create new Address and return it
new_address = Address(wallet=self, subpath_number=subpath_number, address=btc_address)
new_address.save()
return new_address
def query_transaction(ticker, txid):
# logger.info("Execute Query Transaction")
currency = Currency.objects.select_for_update().get(ticker=ticker)
coin = AuthServiceProxy(currency.api_url)
for txdict in normalise_txifno(coin.gettransaction(txid)):
# logger.info("Process deposit TX: {}".format(txdict))
process_deposite_transaction(txdict, ticker)
def service_thread(ws_server, evt):
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
from bitrisk.bitcoind_config import read_default_config
import json
import decimal
config = read_default_config()
testnet = ''
if config.has_key('testnet'):
testnet = config['testnet']
rpc_user = config['rpcuser']
rpc_password = config['rpcpassword']
rpc_connection = AuthServiceProxy("http://%s:%s@%s:%s8332"%(rpc_user, rpc_password, host, testnet))
conn = sqlite3.connect(db_filename)
while not evt.wait(5):
txs = get_db_txs(conn)
for tx in txs:
print 'tx:', tx
tx = rpc_connection.gettransaction(tx)
for details in tx['details']:
addr = details['address']
if ws_server.watched_addresses.has_key(addr):
def decimal_default(obj):
if isinstance(obj, decimal.Decimal):
return float(obj)
raise TypeError
msg = json.dumps(tx, default=decimal_default)
for client in ws_server.watched_addresses[addr]:
ws_server.send_message(client, msg)
blocks = get_db_blocks(conn)
for block in blocks:
print 'block:', block
for client in ws_server.block_watchers:
ws_server.send_message(client, block)
def payouts():
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
from bitrisk.bitcoind_config import read_default_config
config = read_default_config()
testnet = ''
if config.has_key('testnet'):
testnet = config['testnet']
rpc_user = config['rpcuser']
rpc_password = config['rpcpassword']
host = os.getenv('HOST', '127.0.0.1')
rpc_connection = AuthServiceProxy("http://%s:%s@%s:%s8332"%(rpc_user, rpc_password, host, testnet))
while not evt.wait(1 * 60):
print 'process payouts/refunds'
balance = rpc_connection.getbalance(bitrisk.BETS, 1)
print 'balance:', balance
print 'payouts:'
payouts = conn.execute('select * from payout').fetchall()
for payout in payouts:
if not payout['processed']:
process_payout(rpc_connection, payout)
print 'refunds:'
refunds = conn.execute('select * from refund').fetchall()
for refund in refunds:
if not refund['processed']:
process_refund(rpc_connection, refund)
def local_push(tx, rpc_user=None, rpc_password=None):
""" Pushes a bitcoin transaction to the network using a local rpc server.
:param tx: transaction to be pushed.
:type tx: hex str
:param rpc_user: rpc user (could be set in bitcoin.conf).
:type rpc_user: str
:param rpc_password: rpc password ((could be set in bitcoin.conf).
:type rpc_password: str
:return: The response of the rpc server, corresponding to the transaction id and a 200 code if its correctly pushed. None and code 500 otherwise
:rtype: str, int
"""
rpc_connection = AuthServiceProxy("http://"+rpc_user+":"+rpc_password+"@127.0.0.1:18332")
try:
tx_hash = rpc_connection.sendrawtransaction(tx)
code = 200
print "Transaction broadcast " + tx_hash
except JSONRPCException as e:
print e.message
tx_hash = None
code = 500
return tx_hash, code
def getAccountAddress(self, acc=""):
global walletProcess
global rpc_conn
if not walletProcess or not walletProcess.is_running():
self.__copyMyriadcoinConf()
self.openWallet(shell=False)
count = 0
walletAddress = None
MAX_ITER = 60
while not walletAddress and count < MAX_ITER:
try:
rpc_conn = AuthServiceProxy("http://%s:%[email protected]:%s"%(USER, self.password, PORT))
walletAddress = rpc_conn.getaccountaddress('MyriadSwitcher_' + acc)
#walletAddress = rpc_conn.getaccountaddress("Myriad_Switcher")
except:
pass
count += 1
time.sleep(1)
return walletAddress
def runbackup():
access = AuthServiceProxy("http://*****:*****@127.0.0.1:8709")
file_name = strftime("%Y%m%d%H%M%S", gmtime()) + '.bak'
home_dir = '/home/pi/'
usb = '/mnt/usb'
move = 'sudo mv ' + home_dir + file_name + usb
saved_file = usb + file_name
if not os.path.exists(usb):
os.system('sudo mkdir ' + usb)
try:
lcd_init()
signal_success() # Flash drive located, starting to backup
if os.path.exists("/dev/sda1"):
lcd_byte(LCD_LINE_1, LCD_CMD)
lcd_string("Pi Wallet", 2)
lcd_byte(LCD_LINE_2, LCD_CMD)
lcd_string("Backing Up", 2)
os.system("sudo umount /dev/sda1")
os.system("sudo mount -t vfat /dev/sda1 " + usb)
sleep(1)
access.backupwallet(home_dir + file_name)
os.system(move)
sleep(1)
if os.path.exists(saved_file):
lcd_byte(LCD_LINE_1, LCD_CMD)
lcd_string("Backup Complete", 2)
lcd_byte(LCD_LINE_2, LCD_CMD)
lcd_string("Remove USB", 2)
else:
lcd_byte(LCD_LINE_1, LCD_CMD)
lcd_string("Backup Failed", 2)
lcd_byte(LCD_LINE_2, LCD_CMD)
lcd_string("Check USB", 2)
else:
lcd_byte(LCD_LINE_1, LCD_CMD)
lcd_string("Backup Failed", 2)
lcd_byte(LCD_LINE_2, LCD_CMD)
lcd_string("No USB Detected", 2)
sleep(2)
except:
lcd_byte(LCD_LINE_1, LCD_CMD)
lcd_string("Backup Failed", 2)
lcd_byte(LCD_LINE_2, LCD_CMD)
lcd_string("Check Wallet", 2)
os.system('sudo umount ' + usb)
sleep(2)
def handle(self, *args, **options):
rpc = AuthServiceProxy('http://' + settings.BITCOIN_RPC_USERNAME + ':' + settings.BITCOIN_RPC_PASSWORD + '@' + settings.BITCOIN_RPC_IP + ':' + str(settings.BITCOIN_RPC_PORT))
private_keys_imported = False
for address in Address.objects.all():
address_found = True
try:
rpc.dumpprivkey(address.address)
except JSONRPCException as e:
if e.code == -4:
# Address is not found
print 'Address ' + address.address + ' was not found. Importing it...'
# Do some key magic
new_address_full_path = address.wallet.path + [address.subpath_number]
new_address_full_path_str = '/'.join([str(i) for i in new_address_full_path])
key = Key.from_text(settings.MASTERWALLET_BIP32_KEY)
subkey = key.subkeys(new_address_full_path_str).next()
# Check address and form the private key
btc_address = subkey.address(use_uncompressed=False)
assert btc_address == address.address
btc_private_key = subkey.wif(use_uncompressed=False)
# Do the importing
rpc.importprivkey(btc_private_key, '', False)
private_keys_imported = True
if private_keys_imported:
print 'Note! Private keys were added, but they were not scanned! Please restart bitcoin with -rescan option!'
def process_withdraw_transactions(ticker=None):
if not ticker:
for c in Currency.objects.all():
process_withdraw_transactions.delay(c.ticker)
return
currency = Currency.objects.select_for_update().get(ticker=ticker)
coin = AuthServiceProxy(currency.api_url)
wtxs = WithdrawTransaction.objects.select_for_update().select_related('wallet').filter(currency=currency, txid=None).order_by('wallet')
transaction_hash = {}
for tx in wtxs:
if tx.address in transaction_hash:
transaction_hash[tx.address] += tx.amount
else:
transaction_hash[tx.address] = tx.amount
if currency.dust > Decimal('0'):
for address, amount in transaction_hash.items():
if amount < currency.dust:
wtxs = wtxs.exclude(currency=currency, address=address)
del transaction_hash[address]
if not transaction_hash:
return
txid = coin.sendmany(settings.CC_ACCOUNT, transaction_hash)
if not txid:
return
fee = coin.gettransaction(txid).get('fee', 0) * -1
if not fee:
fee_per_tx = 0
else:
fee_per_tx = (fee / len(wtxs))
fee_hash = defaultdict(lambda : {'fee': Decimal("0"), 'amount': Decimal('0')})
for tx in wtxs:
fee_hash[tx.wallet]['fee'] += fee_per_tx
fee_hash[tx.wallet]['amount'] += tx.amount
for (wallet, data) in fee_hash.iteritems():
Operation.objects.create(
wallet=wallet,
holded=-data['amount'],
balance=-data['fee'],
description='Network fee',
reason=tx
)
wallet = Wallet.objects.get(id=tx.wallet.id)
wallet.balance -= data['fee']
wallet.holded -= data['amount']
wallet.save()
wtxs.update(txid=txid, fee=fee_per_tx)
def save(self, *args, **kwargs):
if self.pk is None:
if not self.currency in settings.CONNECTION_STRING:
raise Exception("Connection string for %s is not defined" % self.currency)
try:
access = AuthServiceProxy(settings.CONNECTION_STRING[self.currency])
self.addr = access.getnewaddress(settings.GENERATED_ADDRESSES_ACCOUNT)
except Exception, e:
raise Exception("Could not connect to crypto coin daemon")
def checkAddress(self, address):
global rpc_conn
if not rpc_conn:
rpc_conn = AuthServiceProxy("http://%s:%[email protected]:%s"%(USER, self.password, PORT))
validateData = rpc_conn.validateaddress(address)
return validateData['isvalid'] and validateData['ismine']
def api_decodebyclaim(claimid):
connection_string = get_lbrycrdd_connection_details(os.path.expanduser("~")+"/.lbrycrd/lbrycrd.conf")
rpc = AuthServiceProxy(connection_string)
claim = rpc.getvalueforname(claimid)
if claim:
converted = ''.join([chr(ord(i)) for i in claim['value']])
decoded = smart_decode(converted)
claim['value'] = decoded.claim_dict
return json.dumps(claim)
def refill_addresses_queue():
for currency in Currency.objects.all():
coin = AuthServiceProxy(currency.api_url)
count = Address.objects.filter(currency=currency, active=True, wallet=None).count()
if count < settings.CC_ADDRESS_QUEUE:
for i in range(count, settings.CC_ADDRESS_QUEUE):
try:
Address.objects.create(address=coin.getnewaddress(settings.CC_ACCOUNT), currency=currency)
except (socket_error, CannotSendRequest) :
pass
def main():
# rpc_user and rpc_password are set in the bitcoin.conf file
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332" % (rpc_user, rpc_password))
best_block_hash = rpc_connection.getbestblockhash()
print(rpc_connection.getblock(best_block_hash))
# batch support : print timestamps of blocks 0 to 99 in 2 RPC round-trips:
commands = [["getblockhash", height] for height in range(100)]
block_hashes = rpc_connection.batch_(commands)
blocks = rpc_connection.batch_([["getblock", h] for h in block_hashes])
block_times = [block["time"] for block in blocks]
print(block_times)
class LongpollThread(threading.Thread):
def __init__(self, node):
threading.Thread.__init__(self)
# query current longpollid
templat = node.getblocktemplate()
self.longpollid = templat['longpollid']
# create a new connection to the node, we can't use the same
# connection from two threads
self.node = AuthServiceProxy(node.url, timeout=600)
def run(self):
self.node.getblocktemplate({'longpollid':self.longpollid})
def getLastBlock(cfg):
blk = 0
while not done:
try: # this tries to talk to bitcoind despite it being comatose
rpc = AuthServiceProxy(cfg['rpc'], timeout=120)
if blk == 0:
blkinfo = rpc.getblockchaininfo()
blk = blkinfo['blocks'] - 60
blkhash = rpc.getblockhash(blk) # trailing by 60 to avoid reorg problems
return blk,blkhash
except Exception, e:
log( 'Blkdat rpc ' + str(e) + ' trying again' )
sleep(5)
def rpc_loop(ncurses_q, json_q):
config = ConfigParser.ConfigParser()
config.read('bitcoind-ncurses.conf')
rpcuser = config.get('rpc', 'rpcuser')
rpcpassword = config.get('rpc', 'rpcpassword')
rpcip = config.get('rpc', 'rpcip')
rpcport = config.get('rpc', 'rpcport')
rpcurl = "http://" + rpcuser + ":" + rpcpassword + "@" + rpcip + ":" + rpcport
rpchandle = AuthServiceProxy(rpcurl, None, 500)
last_blockcount = 0 # ensures block info is updated initially
last_update = time.time() - 2
while 1:
try: s = json_q.get(False)
except: s = {}
if 'blockheight' in s:
blockhash = rpchandle.getblockhash(s['blockheight'])
blockinfo = rpchandle.getblock(blockhash)
ncurses_q.put(blockinfo)
last_blockcount = cur_blockcount
elif 'txid' in s:
raw_tx = rpchandle.getrawtransaction(s['txid'])
decoded_tx = rpchandle.decoderawtransaction(raw_tx)
ncurses_q.put(decoded_tx)
if (time.time() - last_update) > 2:
info = rpchandle.getinfo()
ncurses_q.put(info)
nettotals = rpchandle.getnettotals()
ncurses_q.put(nettotals)
walletinfo = rpchandle.getwalletinfo()
ncurses_q.put(walletinfo)
cur_blockcount = info['blocks']
if (cur_blockcount != last_blockcount): # minimise RPC calls
#if (last_blockcount == 0):
lastblocktime = {'lastblocktime': time.time()}
ncurses_q.put(lastblocktime)
blockhash = rpchandle.getblockhash(cur_blockcount)
blockinfo = rpchandle.getblock(blockhash)
ncurses_q.put(blockinfo)
last_blockcount = cur_blockcount
last_update = time.time()
time.sleep(0.5) # minimise RPC calls
class BitcoinService:
def __init__(self):
self.access = AuthServiceProxy("http://*****:*****@[email protected]:8332")
def getInfo(self):
return self.access.getinfo()
def getlistreceivedbyaddress(self, num):
return self.access.listreceivedbyaddress(num)
def getBalance(self):
return self.access.getbalance()
def isValidAddress(self, addr):
return self.access.validateaddress(addr)
def generateAddress(self):
return self.access.getnewaddress()
def getAccount(self, addr):
return self.access.getaccount(addr)
def getAccountAddr(self, account):
return self.access.getaccountaddress(account)
def getreceivedbyaddress(self, addr):
return self.access.getreceivedbyaddress(addr)
def sendtoaddress(self, addr, amount, comment=""):
return self.acccess.sendtoaddress(addr, amount, comment)
def api_decode(txid, nout):
connection_string = get_lbrycrdd_connection_details(os.path.expanduser("~")+"/.lbrycrd/lbrycrd.conf")
rpc = AuthServiceProxy(connection_string)
result = rpc.getclaimsfortx(txid)
claim = None
for claim_out in result:
if claim_out['nOut'] == int(nout):
claim = claim_out
break
if claim:
converted = ''.join([chr(ord(i)) for i in claim['value']])
decoded = smart_decode(converted)
claim['value'] = decoded.claim_dict
return json.dumps(claim)
def connect_JSON(self, connect, passphrase):
"""Connect to a bitcoin JSON-RPC server"""
try:
result = AuthServiceProxy(connect)
# ServiceProxy is lazy-connect, so send an RPC command mostly to catch connection errors,
# but also make sure the bitcoind we're talking to is/isn't testnet:
if result.getmininginfo()['testnet']:
self.logger.info("Connected to testnet")
else:
self.logger.info("Connected to mainnet")
result.passphrase = passphrase
return result
except:
raise
def main():
access = ServiceProxy("http://*****:*****@127.0.0.1:8332")
txid = sys.argv[1]
# print txid
txinfo = access.gettransaction(txid)
pprint.pprint(txinfo)
# Check the details to make sure it's an incoming transaction
# Ensure everything is incoming, to avoid
# mirroring change/consolidation transactions.
myaddresses = set()
for details in txinfo["details"]:
# print details
if details["category"] != "receive":
return
myaddresses.add(details["address"])
tx = access.decoderawtransaction(txinfo["hex"])
pprint.pprint(tx)
# Now gather all the outputs to send back
newtx_inputs = []
total_amount = Decimal(0)
for vout in tx["vout"]:
for address in vout["scriptPubKey"]["addresses"]:
if address in myaddresses:
newtx_inputs.append({"txid":txid,"vout":vout["n"]})
total_amount += vout["value"]
break
print newtx_inputs
print total_amount
# Now find the sendign addresses, and choose one at random
# to receive the funds.
total_inputs = Decimal("0")
addresses = []
for vin in tx["vin"]:
intxid = vin["txid"]
invout = vin["vout"]
# Get the outputs of the input transaction
intx = access.getrawtransaction(intxid,1)
# print intxid, invout
vout = intx["vout"][invout]
# pprint.pprint(vout)
total_inputs += vout["value"]
addresses.extend(vout["scriptPubKey"]["addresses"])
print "Total inputs: %f" % total_inputs
print addresses
to_address = random.choice(addresses)
# Build a transaction with the output of the original transaction as input
# and to_address as output.
newtx_hex = access.createrawtransaction(newtx_inputs,{to_address:float(total_amount)})
newtx_hex = access.signrawtransaction(newtx_hex)["hex"]
print newtx_hex
# print >>open("/home/user/a.txt","a"), access.decoderawtransaction(newtx_hex)
access.sendrawtransaction(newtx_hex)
def connect(self):
"Connect to RPC endpoint"
self.log.info("DogeRPC: Connecting to dogecoind")
self.con = AuthServiceProxy("http://%s:%s@%s:%s" % (self.config["username"], self.config["password"],
self.config["host"], self.config["port"]))
self.con.getinfo()
self.log.info("DogeRPC: Connected to %s:%s" % (self.config["host"], self.config["port"]))
def run_allowip_test(tmpdir, allow_ips, rpchost, rpcport):
"""
Start a node with rpcwallow IP, and request getinfo
at a non-localhost IP.
"""
base_args = ["-disablewallet", "-nolisten"] + ["-rpcallowip=" + x for x in allow_ips]
nodes = start_nodes(1, tmpdir, [base_args])
try:
# connect to node through non-loopback interface
url = "http://*****:*****@%s:%d" % (rpchost, rpcport)
node = AuthServiceProxy(url)
node.getinfo()
finally:
node = None # make sure connection will be garbage collected and closed
stop_nodes(nodes)
wait_bitcoinds()
def run_allowip_test(tmpdir, allow_ips, rpchost):
'''
Start a node with rpcwallow IP, and request getinfo
at a non-localhost IP.
'''
base_args = ['-disablewallet', '-nolisten'] + ['-rpcallowip='+x for x in allow_ips]
nodes = start_nodes(1, tmpdir, [base_args])
try:
# connect to node through non-loopback interface
url = "http://*****:*****@%s:%d" % (rpchost, START_RPC_PORT,)
node = AuthServiceProxy(url)
node.getinfo()
finally:
node = None # make sure connection will be garbage collected and closed
stop_nodes(nodes)
wait_creditsds()
def rpc_conn(user=rpc_user, password=rpc_password):
rpc_conn = AuthServiceProxy("http://%s:%s@localhost:19998" %
(user, password))
return rpc_conn
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
import pprint
import struct
bitcoin = AuthServiceProxy("http://*****:*****@127.0.0.1:8332")
mikes = "mgsUnLsMhphUyFiiCDBa6UWqhDivWaNwSe"
mine = "mpbJSfca2Z5vwB5ogMhPTJ3DBx2fZDMkGz"
pubkeymike = "03985457b91195038af91c1c7b09c693e9a141681319b683c46871b2dbf1beb09d"
pubkeymine = "03133255e240ded2cd1d0b8fa5b659fd7713b74f6ea074f4a80e3cb1f0677df061"
multiaddress = "2NC9uL5Qcnt4awdTBi3jB6ADPVdvwP9iR8L"
redeemscript = "522103133255e240ded2cd1d0b8fa5b659fd7713b74f6ea074f4a80e3cb1f0677df0612103985457b91195038af91c1c7b09c693e9a141681319b683c46871b2dbf1beb09d52ae"
random = "mrTRKLaDF86gLdKnacjxkXJdRFS6S8poTY"
txtorandom = "bdad390ea15f1828466266a97d4f219ff2e64111a60cb204b30148b199260bd0"
random2 = "mmQDjcub4ozy7e7ET6Yx75MDcLQHdhofbU"
#print "NEW", bitcoin.getnewaddress("")
#print bitcoin.validateaddress(mine)
print ""
print "Addresses and priv keys in entire wallet"
addresses = bitcoin.getaddressesbyaccount("")
print addresses
for add in addresses:
if not add[0] == '2':
print bitcoin.dumpprivkey(add), add
## Create a multi-sig
import logging
from config import *
logging.basicConfig(format='%(asctime)s %(message)s',
filename=config.CHECK_LOG_FILE,
level=logging.INFO)
console = logging.StreamHandler()
console.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)-12s: %(message)s')
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
from bitcoinrpc.authproxy import AuthServiceProxy
access = AuthServiceProxy(RPC_URL)
vout_type = {
'nonstandard': 0,
'pubkey': 1,
'pubkeyhash': 2,
'scripthash': 3,
'multisig': 4,
'nulldata': 5
}
def read_tx(txhash):
return json.loads(access.getrawtransaction(txhash, 1))
def __init__(self, url=None, path=None):
super().__init__()
self.rpc = AuthServiceProxy(url)
def update_bitcoin_other_info():
global mynode_block_height
global bitcoin_blockchain_info
global bitcoin_recent_blocks
global bitcoin_recent_blocks_last_cache_height
global bitcoin_peers
global bitcoin_network_info
global bitcoin_mempool
global bitcoin_wallets
while bitcoin_blockchain_info == None:
# Wait until we have gotten the important info...
# Checking quickly helps the API get started faster
time.sleep(1)
try:
rpc_user = get_bitcoin_rpc_username()
rpc_pass = get_bitcoin_rpc_password()
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332" %
(rpc_user, rpc_pass),
timeout=60)
# Get other less important info
try:
# Recent blocks
if mynode_block_height != bitcoin_recent_blocks_last_cache_height:
commands = [["getblockhash", height]
for height in range(mynode_block_height -
9, mynode_block_height + 1)]
block_hashes = rpc_connection.batch_(commands)
bitcoin_recent_blocks = rpc_connection.batch_(
[["getblock", h] for h in block_hashes])
bitcoin_recent_blocks_last_cache_height = mynode_block_height
# Get peers
bitcoin_peers = rpc_connection.getpeerinfo()
# Get network info
bitcoin_network_info = rpc_connection.getnetworkinfo()
# Get mempool
bitcoin_mempool = rpc_connection.getmempoolinfo()
# Get wallet info
wallets = rpc_connection.listwallets()
wallet_data = []
for w in wallets:
wallet_name = urllib.pathname2url(w)
wallet_rpc_connection = AuthServiceProxy(
"http://%s:%[email protected]:8332/wallet/%s" %
(rpc_user, rpc_pass, wallet_name),
timeout=60)
wallet_info = wallet_rpc_connection.getwalletinfo()
wallet_data.append(wallet_info)
bitcoin_wallets = wallet_data
except:
pass
except Exception as e:
print("ERROR: In update_bitcoin_info - {}".format(str(e)))
return False
return True
class LocalBlockchainRPCReader(BlockExplorerReader):
rpc_connection = None
#transaction_output_cache = None ''' deprecated '''
def __init__(self, database_connector=None):
BlockExplorerReader.__init__(self, database_connector) #super
self.rpc_connection = AuthServiceProxy(
"http://%s:%s@%s:%s" %
(self.config.RPC_USERNAME, self.config.RPC_PASSWORD,
self.config.RPC_HOST, self.config.RPC_PORT))
def get_current_blockchain_block_height(self):
raise NotImplementedError #TODO maybe... for now can use another class
#Retreives a list of transactions at specified block height. Each tx
# will be formatted as a BCI-like tuple per
# get_bci_like_tuple_for_tx_id().
#param0: block_height: Height at which to get a list of txs for.
#param1: use_tx_out_addr_cache_only (Optional): When looking up addresses
# for previous transactions, ONLY refer to cache in SQLite database,
# rather than slower option of using RPC interface. If set to True,
# process will sleep until the data is available in the cache. Default:
# False.
def get_tx_list(self, block_height, use_tx_out_addr_cache_only=False):
ids = self.get_tx_ids_at_height(block_height)
txs = []
for tx_id in ids:
bci_like_tuple = self.get_bci_like_tuple_for_tx_id(
tx_id, use_tx_out_addr_cache_only)
txs.append(bci_like_tuple)
return txs
#Checks if the specified transaction is the first time the specified address
# has received funds. If it is, it will cache this for the specified
# block height in the database so subsequent lookups will answer
# correctly. IMPORTANT: This function assumes that that blocks are being
# processed in a complete, monotonically-increasing fashion from the
# genesis block. Otherwise, correct results not guaranteed! It is the
# caller's responsibility to ensure that enough blocks have been
# processed.
def is_first_transaction_for_address(self,
addr,
tx_id,
block_height,
benchmarker=None):
if self.database_connector.has_address_been_seen_cache_if_not(
addr, block_height):
dprint("Address %s at block height %d was already seen." %
(addr, block_height))
return False
else:
dprint("Address %s at block height %d has no prior tx history." %
(addr, block_height))
return True
def get_block_hash_at_height(self, block_height):
return self.rpc_connection.getblockhash(block_height)
def get_tx_json_for_block_hash(self, block_hash):
return self.rpc_connection.getblock(block_hash)
def get_tx_ids_at_height(self, block_height):
block_hash = self.get_block_hash_at_height(block_height)
tx_json = self.get_tx_json_for_block_hash(block_hash)
tx_ids = []
for tx_id in tx_json['tx']:
tx_ids.append(tx_id)
return tx_ids
#Returns the transaction in raw format. If the requested transaction is
# the sole transaction of the genesis block, bitcoind's RPC interface
# will throw an error 'No information available about transaction
# (code -5)' so we preempt this by raising a custom error that callers
# should handle; iterating callers should just move onto the next tx.
#throws: NoDataAvailableForGenesisBlockError
def get_raw_tx(self, tx_id):
if tx_id == (
'4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7af'
'deda33b'):
raise custom_errors.NoDataAvailableForGenesisBlockError()
else:
return self.rpc_connection.getrawtransaction(tx_id)
#Gets a human-readable string of the transaction in JSON format.
def get_decoded_tx(self, tx_id):
try:
return self.rpc_connection.decoderawtransaction(
self.get_raw_tx(tx_id))
except custom_errors.NoDataAvailableForGenesisBlockError:
#bitcoind won't generate this, but here's what it would look like
genesis_json = {
'txid': ('4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2'
'127b7afdeda33b'),
'version':
1,
'locktime':
0,
'vin': [{
"sequence":
4294967295,
'coinbase':
('04ffff001d0104455468652054696d65732030332f4a6'
'16e2f32303039204368616e63656c6c6f72206f6e2062'
'72696e6b206f66207365636f6e64206261696c6f75742'
'0666f722062616e6b73')
}],
'vout': [{
'value': 50.00000000,
'n': 0,
'scriptPubKey': {
'asm': ('04678afdb0fe5548271967f1a67130b7105cd6a828'
'e03909a67962e0ea1f61deb649f6bc3f4cef38c4f3'
'5504e51ec112de5c384df7ba0b8d578a4c702b6bf1'
'1d5f OP_CHECKSIG'),
'hex': ('4104678afdb0fe5548271967f1a67130b7105cd6a8'
'28e03909a67962e0ea1f61deb649f6bc3f4cef38c4'
'f35504e51ec112de5c384df7ba0b8d578a4c702b6b'
'f11d5fac'),
'reqSigs':
1,
'type':
'pubkey',
'addresses': ['1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa']
}
}]
}
return genesis_json
#Converts required infromation from local bitcoind RPC into a format similar
# to that returned by Blockchain.info's API. This helps to make the code
# more agnostic as to the source of blockchain data.
#Note: When an output address cannot be decoded, BCI excludes the "addr"
# field from the JSON returned. Therefore, this function will do the same.
# See:
# https://blockchain.info/tx/cee16a9b222f636cd27d734da0a131cee5dd7a1d09cb5f14f4d1330b22aaa38e
#Note: When a previous output address for an input cannot be decoded, BCI
# excludes the "addr" field from the JSON returned. Therefore, this
# function will do the same. See:
# https://blockchain.info/tx/8ebe1df6ebf008f7ec42ccd022478c9afaec3ca0444322243b745aa2e317c272
#param0: tx_id: Specified transaction hash
#param1: use_tx_out_addr_cache_only (Optional): When looking up addresses
# for previous transactions, ONLY refer to cache in SQLite database,
# rather than slower option of using RPC interface. If set to True,
# process will sleep until the data is available in the cache. Default:
# False.
def get_bci_like_tuple_for_tx_id(self,
tx_id,
use_tx_out_addr_cache_only=False):
json_tuple = {}
json_tuple['hash'] = tx_id
json_tuple['inputs'] = []
json_tuple['out'] = []
subscription = None
if use_tx_out_addr_cache_only:
subscription = data_subscription.TxOutputAddressCacheSubscriber(
database=self.database_connector)
tx_json = self.get_decoded_tx(tx_id)
#populate input addresses
for vin in tx_json['vin']:
#look up address based on its previous transaction
prev_txid = None
if 'txid' in vin:
prev_txid = vin['txid']
prev_vout = None
if 'vout' in vin:
prev_vout_num = vin[
'vout'] #yes, this RPC field is poorly named
prev_out = {'n': prev_vout_num}
try:
if use_tx_out_addr_cache_only:
#flag specifies that we will wait for cache to catch up
# before continuing this operation. Process/thread
# will sleep until then.
subscription.next_tx_id_needed = prev_txid
subscription.next_prev_tx_ouput_pos_needed = prev_vout_num
dprint(
("get_bci_like_tuple_for_tx_id: May sleep until "
"tx output address is cached..."))
subscription.do_sleep_until_producers_ready()
address = self.get_output_address(prev_txid, prev_vout_num)
prev_out['addr'] = address
except custom_errors.PrevOutAddressCannotBeDecodedError:
pass
current_input = {'prev_out': prev_out}
json_tuple['inputs'].append(current_input)
else:
#If there's no index specifying the txo from prev tx, there's
# probably nothing to do here. Should only come up for
# coinbase transactions.
continue
#populate output addresses
for vout in tx_json['vout']:
output_index = vout['n']
current_output = {'n': output_index}
if 'scriptPubKey' in vout and 'addresses' in vout['scriptPubKey']:
address = vout['scriptPubKey']['addresses'][0]
current_output['addr'] = address
json_tuple['out'].append(current_output)
return json_tuple
#Returns an ordered list of output addresses for the specified transaction
# JSON as returned by the bitcoind RPC interface. If an address cannot be
# decoded for one of the outputs, a value of None will be inserted
# at that position in the list.
#TODO: This does not properly handle multisig outputs that list multiple
# addresses per output. See:
# http://bitcoin.stackexchange.com/questions/4687/can-a-scriptpubkey-have-multiple-addresses
# When support for this is added, make sure to add a test case.
def get_output_addresses(self, tx_json):
assert 'vout' in tx_json
output_addresses = []
for vout in tx_json['vout']:
assert 'scriptPubKey' in vout
if 'addresses' in vout['scriptPubKey']:
ouput_address = vout['scriptPubKey']['addresses'][0]
output_addresses.append(ouput_address)
else:
output_addresses.append(None)
return output_addresses
#Raises: custom_errors.PrevOutAddressCannotBeDecoded
#TODO: This does not properly handle multisig outputs that list multiple
# addresses per output.
def get_output_address(self, tx_id, output_index, tx_json=None):
if USE_TX_OUTPUT_ADDR_CACHE_FIRST:
addr = self.database_connector.get_output_address(
tx_id, output_index)
if addr is not None:
return addr
#not in cache, fall back to querying RPC interface
if tx_json is None:
tx_json = self.get_decoded_tx(tx_id)
if 'vout' in tx_json and len(tx_json['vout']) > output_index and \
'scriptPubKey' in tx_json['vout'][output_index]:
if 'addresses' not in tx_json['vout'][output_index][
'scriptPubKey']:
raise custom_errors.PrevOutAddressCannotBeDecodedError
else:
return tx_json['vout'][output_index]['scriptPubKey'][
'addresses'][0]
else:
msg = ("Missing element for vout in get_output_address() with tx "
"id %s and output index %d") % (tx_id, output_index)
logger.log_and_die(msg)
def connect():
global rpc_connection
username, password = vertcoin_config.read_vertcoin_config()
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:5888" %
(username, password))
def get_rpc_connection():
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
connection = "http://%s:%[email protected]:%s" % (rpc_user, rpc_pass, rpc_port)
#print("Connection: " + connection)
rpc_connection = AuthServiceProxy(connection)
return (rpc_connection)
def rpc_connection(self):
return AuthServiceProxy("http://{0}:{1}@{2}:{3}".format(*self.creds))
def __init__(self, url):
self.rpc = AuthServiceProxy(url)
self.height = self.rpc.getblockcount()
class DaemonBTC:
def __init__(self, url):
self.rpc = AuthServiceProxy(url)
self.height = self.rpc.getblockcount()
def get_block(self, i):
block = self.rpc.getblockhash(i)
block_data = self.rpc.getblock(block)
block_data['transactions'] = len(block_data['tx'])
# Elasticsearch struggles with these as integers
#block_data['chainwork_int'] = int(block_data['chainwork'], 16)
block_data['difficulty'] = int(block_data['difficulty'])
del(block_data['tx'])
return block_data
def get_transaction(self, tx):
rtx = self.rpc.getrawtransaction(tx)
dtx = self.rpc.decoderawtransaction(rtx)
return dtx
def get_transactions(self, txs):
rtx = self.rpc.batch_([["getrawtransaction", t] for t in txs])
dtx = self.rpc.batch_([["decoderawtransaction", t] for t in rtx])
return dtx
def get_block_transactions(self, block):
# The genesis block is special
if block == 0:
return []
blockhash = self.rpc.getblockhash(block)
block_data = self.rpc.getblock(blockhash)
transactions = []
rtx = self.rpc.batch_([["getrawtransaction", t] for t in block_data['tx']])
dtx = self.rpc.batch_([["decoderawtransaction", t] for t in rtx])
for tx in dtx:
tx['height'] = block_data['height']
tx['block'] = block_data['hash']
tx['time'] = block_data['time']
# We can't use this data, let's get rid of it
for i in tx['vin']:
if 'scriptSig' in i:
del(i['scriptSig'])
for i in tx['vout']:
if 'hex' in i['scriptPubKey']:
del(i['scriptPubKey']['hex'])
if 'asm' in i['scriptPubKey']:
del(i['scriptPubKey']['asm'])
transactions.append(tx)
return transactions
def get_block_transactions_bulk(self, block):
"Return an iterable object for bulk transactions"
transactions = self.get_block_transactions(block)
tx = Transactions()
for i in transactions:
tx.add_transaction(i)
return tx
def get_blocks_bulk(self, blocks):
rbh = self.rpc.batch_([["getblockhash", t] for t in blocks])
dbh = self.rpc.batch_([["get_block", t] for t in rbh])
output = []
for block_data in dbh:
block_data['transactions'] = len(block_data['tx'])
block_data['chainwork_int'] = int(block_data['chainwork'], 16)
del(block_data['tx'])
output.append(block_data)
return output
def get_max_block(self):
return self.rpc.getblockcount()
def call_node(commands):
"""Creates a proxy for communicating with a full bitcoin node
"""
return AuthServiceProxy(CONNECTION_STRING).batch_(commands)
class RpcClient:
def __init__(self, rpc_protocol, rpc_host, rpc_user, rpc_password):
# Lock for threads
self.lock = threading.RLock()
self.rpc_url = "%s://%s:%s@%s" % (rpc_protocol, rpc_user, rpc_password,
rpc_host)
host, port = rpc_host.split(":")
if rpc_protocol == "https":
self.httpConnection = httplib.HTTPSConnection(
host,
port,
timeout=20,
context=ssl._create_unverified_context())
else:
self.httpConnection = httplib.HTTPConnection(host,
port,
timeout=20)
self.conn = AuthServiceProxy(self.rpc_url,
timeout=1000,
connection=self.httpConnection)
@process_RPC_exceptions
def getBlockCount(self):
n = 0
with self.lock:
n = self.conn.getblockcount()
return n
@process_RPC_exceptions
def getBlockHash(self, blockNum):
h = None
with self.lock:
h = self.conn.getblockhash(blockNum)
return h
@process_RPC_exceptions
def getBudgetVotes(self, proposal):
votes = {}
with self.lock:
votes = self.conn.getbudgetvotes(proposal)
return votes
@process_RPC_exceptions
def getFeePerKb(self):
res = MINIMUM_FEE
with self.lock:
# get transaction data from last 200 blocks
feePerKb = float(self.conn.getfeeinfo(200)['feeperkb'])
res = (feePerKb if feePerKb > MINIMUM_FEE else MINIMUM_FEE)
return res
@process_RPC_exceptions
def getMNStatus(self, address):
mnStatus = None
with self.lock:
mnStatusList = self.conn.listmasternodes(address)
if not mnStatusList:
return None
mnStatus = mnStatusList[0]
mnStatus['mnCount'] = self.conn.getmasternodecount()['enabled']
return mnStatus
@process_RPC_exceptions
def getMasternodeCount(self):
ans = None
with self.lock:
ans = self.conn.getmasternodecount()
return ans
@process_RPC_exceptions
def getMasternodes(self):
printDbg("RPC: Getting masternode list...")
mnList = {}
score = []
masternodes = []
with self.lock:
masternodes = self.conn.listmasternodes()
for mn in masternodes:
if mn.get('status') == 'ENABLED':
# compute masternode score
if mn.get('lastpaid') == 0:
mn['score'] = mn.get('activetime')
else:
lastpaid_ago = now() - mn.get('lastpaid')
mn['score'] = min(lastpaid_ago, mn.get('activetime'))
else:
mn['score'] = 0
score.append(mn)
# sort masternodes by decreasing score
score.sort(key=lambda x: x['score'], reverse=True)
# save masternode position in the payment queue
for mn in masternodes:
mn['queue_pos'] = score.index(mn)
mnList['masternodes'] = masternodes
return mnList
@process_RPC_exceptions
def getNextSuperBlock(self):
n = 0
with self.lock:
n = self.conn.getnextsuperblock()
return n
@process_RPC_exceptions
def getProposals(self):
printDbg("RPC: Getting proposals list...")
proposals = []
data = []
with self.lock:
# get proposals JSON data
data = self.conn.getbudgetinfo()
for p in data:
# create proposal Object
new_proposal = Proposal(p.get('Name'), p.get('URL'), p.get('Hash'),
p.get('FeeHash'), p.get('BlockStart'),
p.get('BlockEnd'),
p.get('TotalPaymentCount'),
p.get('RemainingPaymentCount'),
p.get('PaymentAddress'), p.get('Yeas'),
p.get('Nays'), p.get('Abstains'),
float(p.get('TotalPayment')),
float(p.get('MonthlyPayment')))
# append object to list
proposals.append(new_proposal)
# return proposals list
return proposals
@process_RPC_exceptions
def getProposalsProjection(self):
printDbg("RPC: Getting proposals projection...")
data = []
proposals = []
with self.lock:
# get budget projection JSON data
data = self.conn.getbudgetprojection()
for p in data:
# create proposal-projection dictionary
new_proposal = {}
new_proposal['Name'] = p.get('Name')
new_proposal['Allotted'] = float(p.get("Alloted"))
new_proposal['Votes'] = p.get('Yeas') - p.get('Nays')
new_proposal['Total_Allotted'] = float(p.get('TotalBudgetAlloted'))
# append dictionary to list
proposals.append(new_proposal)
# return proposals list
return proposals
@process_RPC_exceptions
def getProtocolVersion(self):
res = DEFAULT_PROTOCOL_VERSION
with self.lock:
prot_version = self.conn.getinfo().get('protocolversion')
res = int(prot_version)
return res
@process_RPC_exceptions
def getRawTransaction(self, txid):
res = None
with self.lock:
res = self.conn.getrawtransaction(txid)
return res
@process_RPC_exceptions
def getStatus(self):
status = False
statusMess = "Unable to connect to a PIVX RPC server.\n"
statusMess += "Either the local PIVX wallet is not open, or the remote RPC server is not responding."
n = 0
response_time = None
with self.lock:
isTestnet = self.conn.getinfo()['testnet']
n, response_time = timeThis(self.conn.getblockcount)
if n is None:
n = 0
if n > 0:
status = True
statusMess = "Connected to PIVX Blockchain"
return status, statusMess, n, response_time, isTestnet
@process_RPC_exceptions
def isBlockchainSynced(self):
res = False
response_time = None
with self.lock:
status, response_time = timeThis(self.conn.mnsync, 'status')
if status is not None:
res = status.get("IsBlockchainSynced")
return res, response_time
@process_RPC_exceptions
def mnBudgetRawVote(self, mn_tx_hash, mn_tx_index, proposal_hash, vote,
time, vote_sig):
res = None
with self.lock:
res = self.conn.mnbudgetrawvote(mn_tx_hash, mn_tx_index,
proposal_hash, vote, time,
vote_sig)
return res
@process_RPC_exceptions
def decodemasternodebroadcast(self, work):
printDbg("RPC: Decoding masternode broadcast...")
res = ""
with self.lock:
res = self.conn.decodemasternodebroadcast(work.strip())
return res
@process_RPC_exceptions
def relaymasternodebroadcast(self, work):
printDbg("RPC: Relaying masternode broadcast...")
res = ""
with self.lock:
res = self.conn.relaymasternodebroadcast(work.strip())
return res
@process_RPC_exceptions
def sendRawTransaction(self, tx_hex, use_swiftx):
dbg_mess = "RPC: Sending raw transaction"
if use_swiftx:
dbg_mess += " with SwiftX"
dbg_mess += "..."
printDbg(dbg_mess)
tx_id = None
with self.lock:
tx_id = self.conn.sendrawtransaction(tx_hex, True,
bool(use_swiftx))
return tx_id
@process_RPC_exceptions
def verifyMessage(self, pivxaddress, signature, message):
printDbg("RPC: Verifying message...")
res = False
with self.lock:
res = self.conn.verifymessage(pivxaddress, signature, message)
return res
# DB connection settings
WALLET_IP = config.get(CURRENCY, 'wallet_ip')
WALLET_PORT = config.get(CURRENCY, 'wallet_port')
WALLET_USERNAME = config.get(CURRENCY, 'wallet_username')
WALLET_PASSWORD = config.get(CURRENCY, 'wallet_password')
MIN_TX_CONFIRMATION = config.get(CURRENCY, 'min_tx_confirmation')
CURRENCY_NAME = config.get(CURRENCY, 'currency_name')
CURRENCY_SYMBOL = config.get(CURRENCY, 'currency_symbol')
# Constants
RE_EMOJI = re.compile('[\U00010000-\U0010ffff\U000026A1]', flags=re.UNICODE)
rpc = AuthServiceProxy(
"http://%s:%s@%s:%s" %
(WALLET_USERNAME, WALLET_PASSWORD, WALLET_IP, WALLET_PORT))
def strip_emoji(text):
"""
Remove Emojis from tweet text to prevent issues with logging
"""
logger.info('{}: removing emojis'.format(datetime.now()))
text = str(text)
return RE_EMOJI.sub(r'', text)
def get_account_balance(account_name):
"""
Get the current balance of an account
from bitcoinrpc.authproxy import AuthServiceProxy
access = AuthServiceProxy("http://*****:*****@172.17.0.3:18332")
print access.getbalance()
#Envoie 0,001 bitcoin a une nouvelle adresse
access.sendtoaddress(access.getnewaddress(), 0.001)
def initialize_chain(test_dir):
"""
Create (or copy from cache) a 200-block-long chain and
4 wallets.
filokd and filok-cli must be in search path.
"""
if not os.path.isdir(os.path.join("cache", "node0")):
devnull = open("/dev/null", "w+")
# Create cache directories, run filokd:
for i in range(4):
datadir = initialize_datadir("cache", i)
args = [
os.getenv("BITCOIND", "filokd"), "-keypool=1",
"-datadir=" + datadir, "-discover=0"
]
if i > 0:
args.append("-connect=127.0.0.1:" + str(p2p_port(0)))
bitcoind_processes[i] = subprocess.Popen(args)
subprocess.check_call([
os.getenv("BITCOINCLI", "filok-cli"), "-datadir=" + datadir,
"-rpcwait", "getblockcount"
],
stdout=devnull)
devnull.close()
rpcs = []
for i in range(4):
try:
url = "http://*****:*****@127.0.0.1:%d" % (rpc_port(i), )
rpcs.append(AuthServiceProxy(url))
except:
sys.stderr.write("Error connecting to " + url + "\n")
sys.exit(1)
# Create a 200-block-long chain; each of the 4 nodes
# gets 25 mature blocks and 25 immature.
# blocks are created with timestamps 10 minutes apart, starting
# at 1 Jan 2014
block_time = 1388534400
for i in range(2):
for peer in range(4):
for j in range(25):
set_node_times(rpcs, block_time)
rpcs[peer].setgenerate(True, 1)
block_time += 10 * 60
# Must sync before next peer starts generating blocks
sync_blocks(rpcs)
# Shut them down, and clean up cache directories:
stop_nodes(rpcs)
wait_bitcoinds()
for i in range(4):
os.remove(log_filename("cache", i, "debug.log"))
os.remove(log_filename("cache", i, "db.log"))
os.remove(log_filename("cache", i, "peers.dat"))
os.remove(log_filename("cache", i, "fee_estimates.dat"))
for i in range(4):
from_dir = os.path.join("cache", "node" + str(i))
to_dir = os.path.join(test_dir, "node" + str(i))
shutil.copytree(from_dir, to_dir)
initialize_datadir(test_dir, i) # Overwrite port/rpcport in filok.conf
def get_rpc_connection():
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:18501"%(rpc_user, rpc_pass))
return(rpc_connection)
def open_internal(self):
"""
Try to establish connection to polis RPC daemon for current connection config.
:return: True, if connection successfully establishes, False if user Cancels the operation (not always
cancelling will be possible - only when user is prompted for a password).
"""
if not self.active:
logging.debug("Trying to open connection: %s" % self.cur_conn_def.get_description())
try:
# make the owner know, we are connecting
if self.on_connection_initiated_callback:
self.on_connection_initiated_callback()
except:
pass
if self.cur_conn_def.use_ssh_tunnel:
# RPC over SSH
if self.ssh is None:
self.ssh = PolisdSSH(self.cur_conn_def.ssh_conn_cfg.host, self.cur_conn_def.ssh_conn_cfg.port,
self.cur_conn_def.ssh_conn_cfg.username)
try:
logging.debug('starting ssh.connect')
self.ssh.connect()
logging.debug('finished ssh.connect')
except Exception as e:
logging.error('error in ssh.connect')
try:
# make the owner know, connection attempt failed
if self.on_connection_failed_callback:
self.on_connection_failed_callback()
except:
logging.exception('on_connection_try_fail_callback call exception')
raise
# configure SSH tunnel
# get random local unprivileged port number to establish SSH tunnel
success = False
local_port = None
for try_nr in range(1, 10):
try:
logging.debug(f'beginning ssh.open_tunnel, try: {try_nr}')
local_port = randint(2000, 50000)
self.ssh.open_tunnel(local_port,
self.cur_conn_def.host,
int(self.cur_conn_def.port))
success = True
break
except Exception as e:
logging.exception('error in ssh.open_tunnel loop: ' + str(e))
logging.debug('finished ssh.open_tunnel loop')
if not success:
logging.error('finished ssh.open_tunnel loop with error')
return False
else:
rpc_user = self.cur_conn_def.username
rpc_password = self.cur_conn_def.password
rpc_host = '127.0.0.1' # SSH tunnel on loopback
rpc_port = local_port
else:
# direct RPC
rpc_host = self.cur_conn_def.host
rpc_port = self.cur_conn_def.port
rpc_user = self.cur_conn_def.username
rpc_password = self.cur_conn_def.password
if self.cur_conn_def.use_ssl:
self.rpc_url = 'https://'
self.http_conn = httplib.HTTPSConnection(rpc_host, rpc_port, timeout=5, context=ssl._create_unverified_context())
else:
self.rpc_url = 'http://'
self.http_conn = httplib.HTTPConnection(rpc_host, rpc_port, timeout=5)
self.rpc_url += rpc_user + ':' + rpc_password + '@' + rpc_host + ':' + str(rpc_port)
logging.debug('AuthServiceProxy configured to: %s' % self.rpc_url)
self.proxy = AuthServiceProxy(self.rpc_url, timeout=1000, connection=self.http_conn)
try:
# check the connection
self.http_conn.connect()
logging.debug('Successfully connected AuthServiceProxy')
try:
# make the owner know, we successfully finished connection
if self.on_connection_successful_callback:
self.on_connection_successful_callback()
except:
logging.exception('on_connection_finished_callback call exception')
except:
logging.exception('Connection failed')
try:
# make the owner know, connection attempt failed
if self.on_connection_failed_callback:
self.on_connection_failed_callback()
if self.ssh:
# if there is a ssh connection established earlier, disconnect it because apparently it isn't
# functioning
self.ssh.disconnect()
except:
logging.exception('on_connection_try_fail_callback call exception')
raise
finally:
logging.debug('http_conn.close()')
self.http_conn.close()
# timeout hase been initially set to 5 seconds to perform 'quick' connection test
self.http_conn.timeout = 20
self.active = True
return self.active
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
rpc_user = '******'
rpc_password = '******'
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:6969"%(rpc_user, rpc_password))
print rpc_connection
print rpc_connection.getbalance()
class PolisdInterface(WndUtils):
def __init__(self, window,
on_connection_initiated_callback=None,
on_connection_failed_callback=None,
on_connection_successful_callback=None,
on_connection_disconnected_callback=None):
WndUtils.__init__(self, app_config=None)
self.config = None
self.db_intf = None
self.connections = []
self.cur_conn_index = 0
self.cur_conn_def = None
# below is the connection with which particular RPC call has started; if connection is switched because of
# problems with some nodes, switching stops if we close round and return to the starting connection
self.starting_conn = None
self.masternodes = [] # cached list of all masternodes (Masternode object)
self.masternodes_by_ident = {}
self.payment_queue = []
self.ssh = None
self.window = window
self.active = False
self.rpc_url = None
self.proxy = None
self.http_conn = None # HTTPConnection object passed to the AuthServiceProxy (for convinient connection reset)
self.on_connection_initiated_callback = on_connection_initiated_callback
self.on_connection_failed_callback = on_connection_failed_callback
self.on_connection_successful_callback = on_connection_successful_callback
self.on_connection_disconnected_callback = on_connection_disconnected_callback
self.last_error_message = None
self.http_lock = threading.Lock()
def initialize(self, config: AppConfig, connection=None, for_testing_connections_only=False):
self.config = config
self.app_config = config
self.db_intf = self.config.db_intf
# conn configurations are used from the first item in the list; if one fails, then next is taken
if connection:
# this parameter is used for testing specific connection
self.connections = [connection]
else:
# get connection list orderd by priority of use
self.connections = self.config.get_ordered_conn_list()
self.cur_conn_index = 0
if self.connections:
self.cur_conn_def = self.connections[self.cur_conn_index]
else:
self.cur_conn_def = None
if not for_testing_connections_only:
self.load_data_from_db_cache()
def load_data_from_db_cache(self):
self.masternodes.clear()
self.masternodes_by_ident.clear()
cur = self.db_intf.get_cursor()
cur2 = self.db_intf.get_cursor()
db_modified = False
try:
tm_start = time.time()
db_correction_duration = 0.0
logging.debug("Reading masternodes' data from DB")
cur.execute("SELECT id, ident, status, protocol, payee, last_seen, active_seconds,"
" last_paid_time, last_paid_block, IP from MASTERNODES where pmt_active=1")
for row in cur.fetchall():
db_id = row[0]
ident = row[1]
# correct duplicated masternodes issue
mn_first = self.masternodes_by_ident.get(ident)
if mn_first is not None:
continue
# delete duplicated (caused by breaking the app while loading)
tm_start_1 = time.time()
cur2.execute('DELETE from MASTERNODES where ident=? and id<>?', (ident, db_id))
if cur2.rowcount > 0:
db_modified = True
db_correction_duration += (time.time() - tm_start_1)
mn = Masternode()
mn.db_id = db_id
mn.ident = ident
mn.status = row[2]
mn.protocol = row[3]
mn.payee = row[4]
mn.lastseen = row[5]
mn.activeseconds = row[6]
mn.lastpaidtime = row[7]
mn.lastpaidblock = row[8]
mn.ip = row[9]
self.masternodes.append(mn)
self.masternodes_by_ident[mn.ident] = mn
tm_diff = time.time() - tm_start
logging.info('DB read time of %d MASTERNODES: %s s, db fix time: %s' %
(len(self.masternodes), str(tm_diff), str(db_correction_duration)))
self.update_mn_queue_values()
except Exception as e:
logging.exception('SQLite initialization error')
finally:
if db_modified:
self.db_intf.commit()
self.db_intf.release_cursor()
self.db_intf.release_cursor()
def reload_configuration(self):
"""Called after modification of connections' configuration or changes having impact on the file name
associated to database cache."""
# get connection list orderd by priority of use
self.disconnect()
self.connections = self.config.get_ordered_conn_list()
self.cur_conn_index = 0
if len(self.connections):
self.cur_conn_def = self.connections[self.cur_conn_index]
self.load_data_from_db_cache()
else:
self.cur_conn_def = None
def disconnect(self):
if self.active:
logging.debug('Disconnecting')
if self.ssh:
self.ssh.disconnect()
del self.ssh
self.ssh = None
self.active = False
if self.on_connection_disconnected_callback:
self.on_connection_disconnected_callback()
def mark_call_begin(self):
self.starting_conn = self.cur_conn_def
def switch_to_next_config(self):
"""
If there is another polisd config not used recently, switch to it. Called only when there was a problem
with current connection config.
:return: True if successfully switched or False if there was no another config
"""
if self.cur_conn_def:
self.config.conn_cfg_failure(self.cur_conn_def) # mark connection as defective
if self.cur_conn_index < len(self.connections)-1:
idx = self.cur_conn_index + 1
else:
idx = 0
conn = self.connections[idx]
if conn != self.starting_conn and conn != self.cur_conn_def:
logging.debug("Trying to switch to another connection: %s" % conn.get_description())
self.disconnect()
self.cur_conn_index = idx
self.cur_conn_def = conn
if not self.open():
return self.switch_to_next_config()
else:
return True
else:
logging.warning('Failed to connect: no another connection configurations.')
return False
def mark_cur_conn_cfg_is_ok(self):
if self.cur_conn_def:
self.config.conn_cfg_success(self.cur_conn_def)
def open(self):
"""
Opens connection to polis RPC. If it fails, then the next enabled conn config will be used, if any exists.
:return: True if successfully connected, False if user cancelled the operation. If all of the attempts
fail, then appropriate exception will be raised.
"""
try:
if not self.cur_conn_def:
raise Exception('There is no connections to Polis network enabled in the configuration.')
while True:
try:
if self.open_internal():
break
else:
if not self.switch_to_next_config():
return False
except UserCancelledConnection:
return False
except (socket.gaierror, ConnectionRefusedError, TimeoutError, socket.timeout,
NoValidConnectionsError) as e:
# exceptions raised by not likely functioning polisd node; try to switch to another node
# if there is any in the config
if not self.switch_to_next_config():
raise e # couldn't use another conn config, raise exception
else:
break
except Exception as e:
self.last_error_message = str(e)
raise
return True
def reset_connection(self):
"""
Called when communication errors are detected while sending RPC commands. Here we are closing the SSH-tunnel
(if used) and HTTP connection object to prepare for another try.
:return:
"""
if self.active:
if self.http_conn:
self.http_conn.close()
if self.ssh:
self.ssh.disconnect()
self.active = False
def open_internal(self):
"""
Try to establish connection to polis RPC daemon for current connection config.
:return: True, if connection successfully establishes, False if user Cancels the operation (not always
cancelling will be possible - only when user is prompted for a password).
"""
if not self.active:
logging.debug("Trying to open connection: %s" % self.cur_conn_def.get_description())
try:
# make the owner know, we are connecting
if self.on_connection_initiated_callback:
self.on_connection_initiated_callback()
except:
pass
if self.cur_conn_def.use_ssh_tunnel:
# RPC over SSH
if self.ssh is None:
self.ssh = PolisdSSH(self.cur_conn_def.ssh_conn_cfg.host, self.cur_conn_def.ssh_conn_cfg.port,
self.cur_conn_def.ssh_conn_cfg.username)
try:
logging.debug('starting ssh.connect')
self.ssh.connect()
logging.debug('finished ssh.connect')
except Exception as e:
logging.error('error in ssh.connect')
try:
# make the owner know, connection attempt failed
if self.on_connection_failed_callback:
self.on_connection_failed_callback()
except:
logging.exception('on_connection_try_fail_callback call exception')
raise
# configure SSH tunnel
# get random local unprivileged port number to establish SSH tunnel
success = False
local_port = None
for try_nr in range(1, 10):
try:
logging.debug(f'beginning ssh.open_tunnel, try: {try_nr}')
local_port = randint(2000, 50000)
self.ssh.open_tunnel(local_port,
self.cur_conn_def.host,
int(self.cur_conn_def.port))
success = True
break
except Exception as e:
logging.exception('error in ssh.open_tunnel loop: ' + str(e))
logging.debug('finished ssh.open_tunnel loop')
if not success:
logging.error('finished ssh.open_tunnel loop with error')
return False
else:
rpc_user = self.cur_conn_def.username
rpc_password = self.cur_conn_def.password
rpc_host = '127.0.0.1' # SSH tunnel on loopback
rpc_port = local_port
else:
# direct RPC
rpc_host = self.cur_conn_def.host
rpc_port = self.cur_conn_def.port
rpc_user = self.cur_conn_def.username
rpc_password = self.cur_conn_def.password
if self.cur_conn_def.use_ssl:
self.rpc_url = 'https://'
self.http_conn = httplib.HTTPSConnection(rpc_host, rpc_port, timeout=5, context=ssl._create_unverified_context())
else:
self.rpc_url = 'http://'
self.http_conn = httplib.HTTPConnection(rpc_host, rpc_port, timeout=5)
self.rpc_url += rpc_user + ':' + rpc_password + '@' + rpc_host + ':' + str(rpc_port)
logging.debug('AuthServiceProxy configured to: %s' % self.rpc_url)
self.proxy = AuthServiceProxy(self.rpc_url, timeout=1000, connection=self.http_conn)
try:
# check the connection
self.http_conn.connect()
logging.debug('Successfully connected AuthServiceProxy')
try:
# make the owner know, we successfully finished connection
if self.on_connection_successful_callback:
self.on_connection_successful_callback()
except:
logging.exception('on_connection_finished_callback call exception')
except:
logging.exception('Connection failed')
try:
# make the owner know, connection attempt failed
if self.on_connection_failed_callback:
self.on_connection_failed_callback()
if self.ssh:
# if there is a ssh connection established earlier, disconnect it because apparently it isn't
# functioning
self.ssh.disconnect()
except:
logging.exception('on_connection_try_fail_callback call exception')
raise
finally:
logging.debug('http_conn.close()')
self.http_conn.close()
# timeout hase been initially set to 5 seconds to perform 'quick' connection test
self.http_conn.timeout = 20
self.active = True
return self.active
def get_active_conn_description(self):
if self.cur_conn_def:
return self.cur_conn_def.get_description()
else:
return '???'
@control_rpc_call
def getblockcount(self):
if self.open():
return self.proxy.getblockcount()
else:
raise Exception('Not connected')
@control_rpc_call
def getinfo(self, verify_node: bool = True):
if self.open():
info = self.proxy.getinfo()
if verify_node:
node_under_testnet = info.get('testnet')
if self.config.is_testnet() and not node_under_testnet:
raise Exception('This RPC node works under Polis MAINNET, but your current configuration is '
'for TESTNET.')
elif self.config.is_mainnet() and node_under_testnet:
raise Exception('This RPC node works under Polis TESTNET, but your current configuration is '
'for MAINNET.')
return info
else:
raise Exception('Not connected')
@control_rpc_call
def issynchronized(self):
if self.open():
# if connecting to HTTP(S) proxy do not check if polis daemon is synchronized
if self.cur_conn_def.is_http_proxy():
return True
else:
syn = self.proxy.mnsync('status')
return syn.get('IsSynced')
else:
raise Exception('Not connected')
@control_rpc_call
def mnsync(self):
if self.open():
# if connecting to HTTP(S) proxy do not call this function - it will not be exposed
if self.cur_conn_def.is_http_proxy():
return {}
else:
return self.proxy.mnsync('status')
else:
raise Exception('Not connected')
@control_rpc_call
def masternodebroadcast(self, what, hexto):
if self.open():
return self.proxy.masternodebroadcast(what, hexto)
else:
raise Exception('Not connected')
def update_mn_queue_values(self):
"""
Updates masternode payment queue order values.
"""
start_tm = time.time()
self.payment_queue = []
d = datetime.datetime.utcnow()
now = int(time.mktime((d.year, d.month, d.day, d.hour, d.minute, d.second, 0, 0, 0)))
for mn in self.masternodes:
if mn.status == 'ENABLED':
# estimate payment queue position: after loading all masternodes
# queue_position will be used to sort mn list and count the real queue position
if mn.lastpaidtime == 0:
mn.queue_position = mn.activeseconds
else:
lastpaid_ago = now - mn.lastpaidtime
mn.queue_position = min(lastpaid_ago, mn.activeseconds)
self.payment_queue.append(mn)
else:
mn.queue_position = None
duration1 = time.time() - start_tm
self.payment_queue.sort(key=lambda x: x.queue_position, reverse=True)
duration2 = time.time() - start_tm
for mn in self.masternodes:
if mn.status == 'ENABLED':
mn.queue_position = self.payment_queue.index(mn)
else:
mn.queue_position = None
duration3 = time.time() - start_tm
logging.info('Masternode queue build time1: %s, time2: %s, time3: %s' %
(str(duration1), str(duration2), str(duration3)))
@control_rpc_call
def get_masternodelist(self, *args, data_max_age=MASTERNODES_CACHE_VALID_SECONDS) -> List[Masternode]:
"""
Returns masternode list, read from the Polis network or from the internal cache.
:param args: arguments passed to the 'masternodelist' RPC call
:param data_max_age: maximum age (in seconds) of the cached masternode data to used; if the
cache is older than 'data_max_age', then an RPC call is performed to load newer masternode data;
value of 0 forces reading of the new data from the network
:return: list of Masternode objects, matching the 'args' arguments
"""
def parse_mns(mns_raw) -> List[Masternode]:
"""
Parses dictionary of strings returned from the RPC to Masternode object list.
:param mns_raw: Dict of masternodes in format of RPC masternodelist command
:return: list of Masternode object
"""
tm_begin = time.time()
ret_list = []
for mn_id in mns_raw.keys():
mn_raw = mns_raw.get(mn_id)
mn_raw = mn_raw.strip()
elems = mn_raw.split()
if len(elems) >= 8:
mn = Masternode()
# (status, protocol, payee, lastseen, activeseconds, lastpaidtime, pastpaidblock, ip)
mn.status, mn.protocol, mn.payee, mn.lastseen, mn.activeseconds, mn.lastpaidtime, \
mn.lastpaidblock, mn.ip = elems
mn.lastseen = int(mn.lastseen)
mn.activeseconds = int(mn.activeseconds)
mn.lastpaidtime = int(mn.lastpaidtime)
mn.lastpaidblock = int(mn.lastpaidblock)
mn.ident = mn_id
ret_list.append(mn)
duration = time.time() - tm_begin
logging.info('Parse masternodelist time: ' + str(duration))
return ret_list
def update_masternode_data(existing_mn, new_data, cursor):
# update cached masternode's properties
existing_mn.modified = False
existing_mn.monitor_changes = True
existing_mn.ident = new_data.ident
existing_mn.status = new_data.status
existing_mn.protocol = new_data.protocol
existing_mn.payee = new_data.payee
existing_mn.lastseen = new_data.lastseen
existing_mn.activeseconds = new_data.activeseconds
existing_mn.lastpaidtime = new_data.lastpaidtime
existing_mn.lastpaidblock = new_data.lastpaidblock
existing_mn.ip = new_data.ip
# ... and finally update MN db record
if cursor and existing_mn.modified:
cursor.execute("UPDATE MASTERNODES set ident=?, status=?, protocol=?, payee=?,"
" last_seen=?, active_seconds=?, last_paid_time=?, "
" last_paid_block=?, ip=?"
"WHERE id=?",
(new_data.ident, new_data.status, new_data.protocol, new_data.payee,
new_data.lastseen, new_data.activeseconds, new_data.lastpaidtime,
new_data.lastpaidblock, new_data.ip, existing_mn.db_id))
if self.open():
if len(args) == 1 and args[0] == 'full':
last_read_time = app_cache.get_value(f'MasternodesLastReadTime_{self.app_config.polis_network}', 0, int)
logging.info("MasternodesLastReadTime: %d" % last_read_time)
if self.masternodes and data_max_age > 0 and \
int(time.time()) - last_read_time < data_max_age:
logging.info('Using cached masternodelist (data age: %s)' % str(int(time.time()) - last_read_time))
return self.masternodes
else:
logging.info('Loading masternode list from Polis daemon...')
mns = self.proxy.masternodelist(*args)
mns = parse_mns(mns)
logging.info('Finished loading masternode list')
# mark already cached masternodes to identify those to delete
for mn in self.masternodes:
mn.marker = False
# save masternodes to the db cache
db_modified = False
cur = None
try:
if self.db_intf.db_active:
cur = self.db_intf.get_cursor()
for mn in mns:
# check if newly-read masternode already exists in the cache
existing_mn = self.masternodes_by_ident.get(mn.ident)
if not existing_mn:
mn.marker = True
self.masternodes.append(mn)
self.masternodes_by_ident[mn.ident] = mn
if self.db_intf.db_active:
cur.execute("INSERT INTO MASTERNODES(ident, status, protocol, payee, last_seen,"
" active_seconds, last_paid_time, last_paid_block, ip, pmt_active,"
" pmt_create_time) "
"VALUES (?,?,?,?,?,?,?,?,?,?,?)",
(mn.ident, mn.status, mn.protocol, mn.payee, mn.lastseen,
mn.activeseconds, mn.lastpaidtime, mn.lastpaidblock, mn.ip, 1,
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
mn.db_id = cur.lastrowid
db_modified = True
else:
existing_mn.marker = True
update_masternode_data(existing_mn, mn, cur)
db_modified = True
# remove from the cache masternodes that no longer exist
for mn_index in reversed(range(len(self.masternodes))):
mn = self.masternodes[mn_index]
if not mn.marker:
if self.db_intf.db_active:
cur.execute("UPDATE MASTERNODES set pmt_active=0, pmt_deactivation_time=?"
"WHERE ID=?",
(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
mn.db_id))
db_modified = True
self.masternodes_by_ident.pop(mn.ident,0)
del self.masternodes[mn_index]
app_cache.set_value(f'MasternodesLastReadTime_{self.app_config.polis_network}', int(time.time()))
self.update_mn_queue_values()
finally:
if db_modified:
self.db_intf.commit()
if cur is not None:
self.db_intf.release_cursor()
return self.masternodes
else:
mns = self.proxy.masternodelist(*args)
mns = parse_mns(mns)
return mns
else:
raise Exception('Not connected')
@control_rpc_call
def getaddressbalance(self, addresses):
if self.open():
return self.proxy.getaddressbalance({'addresses': addresses})
else:
raise Exception('Not connected')
@control_rpc_call
def getaddressutxos(self, addresses):
if self.open():
return self.proxy.getaddressutxos({'addresses': addresses})
else:
raise Exception('Not connected')
@control_rpc_call
def getrawtransaction(self, txid, verbose):
if self.open():
return json_cache_wrapper(self.proxy.getrawtransaction, self, 'tx-' + str(verbose) + '-' + txid)(txid, verbose)
else:
raise Exception('Not connected')
@control_rpc_call
def getblockhash(self, blockid):
if self.open():
return json_cache_wrapper(self.proxy.getblockhash, self, 'blockhash-' + str(blockid))(blockid)
else:
raise Exception('Not connected')
@control_rpc_call
def getblockheader(self, blockhash):
if self.open():
return json_cache_wrapper(self.proxy.getblockheader, self, 'blockheader-' + str(blockhash))(blockhash)
else:
raise Exception('Not connected')
@control_rpc_call
def validateaddress(self, address):
if self.open():
return self.proxy.validateaddress(address)
else:
raise Exception('Not connected')
@control_rpc_call
def decoderawtransaction(self, rawtx):
if self.open():
return self.proxy.decoderawtransaction(rawtx)
else:
raise Exception('Not connected')
@control_rpc_call
def sendrawtransaction(self, tx, use_instant_send):
if self.open():
return self.proxy.sendrawtransaction(tx, False, use_instant_send)
else:
raise Exception('Not connected')
@control_rpc_call
def getcurrentvotes(self, hash):
if self.open():
return self.proxy.getcurrentvotes(hash)
else:
raise Exception('Not connected')
@control_rpc_call
def gobject(self, *args):
if self.open():
return self.proxy.gobject(*args)
else:
raise Exception('Not connected')
@control_rpc_call
def masternode(self, *args):
if self.open():
return self.proxy.masternode(*args)
else:
raise Exception('Not connected')
@control_rpc_call
def getgovernanceinfo(self):
if self.open():
return self.proxy.getgovernanceinfo()
else:
raise Exception('Not connected')
@control_rpc_call
def getsuperblockbudget(self, block_index):
if self.open():
return self.proxy.getsuperblockbudget(block_index)
else:
raise Exception('Not connected')
@control_rpc_call
def voteraw(self, masternode_tx_hash, masternode_tx_index, governance_hash, vote_signal, vote, sig_time, vote_sig):
if self.open():
return self.proxy.voteraw(masternode_tx_hash, masternode_tx_index, governance_hash, vote_signal, vote,
sig_time, vote_sig)
else:
raise Exception('Not connected')
def rpc(self):
rpc_template = "http://%s:%s@%s:%s/wallet/%s"
url = rpc_template % ('bitcoin', 'python', 'localhost', 18332,
self.wallet_name)
return AuthServiceProxy(url, timeout=60 * 5) # 5 minute timeouts
# This is a python file that was run in the AWS Instance running a full #
# bitcoin node to traverse and build the network topology of the Bitcoin #
# network. It uses RPC commands to query the raw transaction historical #
# data and from there builds the network by tracing the inputs of these #
# transactions to their addresses and so on. It was also used as a means #
# to test the algorithm on a high powered machine since the instance was #
# a r3.8xlarge EC2 instance #
# #
##########################################################################
rpc_user="******"
rpc_password="******"
#Connect to the aws instance's Bitcoin node running on port 8332
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332"%(rpc_user, rpc_password))
# Select a random address from a random transaction id from a random block to be the starting transaction and address.
# address:14JThBAeM4DSXMuChoJEreY7qTzZUYx8Bp from txid:4d17a5713c5555122540dda109e8c70025076781d55008d69b076731fb786787 from Block 250 000 chosen
def crawler(maxTxDepth):
depth = 0
seen = deque() #queue of transactions that have to be traversed
seen.append('4d17a5713c5555122540dda109e8c70025076781d55008d69b076731fb786787') #append initial transaction
nodes = []
while depth < maxTxDepth:
if len(seen) == 0:
break
item = seen.popleft()
try:
transaction = rpc_connection.getrawtransaction(item,1) # the "1" is to decode the raw transaction
class CryptoEngineBitcoin(CryptoEngine):
BITCOIN_FEE = 0.0001
BITCOIN_FINAL_CONFIRMATIONS = 6
def __init__(self, url=None, path=None):
super().__init__()
self.rpc = AuthServiceProxy(url)
def certify(self, data: bytes) -> str:
#if len(data) <1 or len(data) > 32:
# raise ValueError("data length must be > 0 and <= 32")
blockchain_payload = DATA_PREFIX.encode() + data
avail_coin = self.__get_available_coin()
if avail_coin is None:
raise ValueError("No coin available")
inputs = [{'txid': avail_coin['txid'], 'vout': avail_coin['vout']}]
outputs = {'data': binascii.hexlify(blockchain_payload).decode(), avail_coin['address']: avail_coin['amount'] - decimal.Decimal(self.BITCOIN_FEE)}
rawtrans = self.rpc.createrawtransaction(inputs, outputs)
#print("RAW Transaction: %s" % rawtrans)
signedtrans = self.rpc.signrawtransaction(rawtrans)
#print("Signed transaction: %s" % signedtrans)
if not signedtrans['complete']:
raise RuntimeError("Error signing transaction: %s" % (signedtrans))
txid = self.rpc.sendrawtransaction(signedtrans['hex'])
#print("Transaction sent, TXID: %s" % txid)
return txid
def __get_available_coin(self):
unspent = self.rpc.listunspent()
target = None
#print("# of unspent entries: %d" % len(unspent))
for i in range(0, len(unspent)):
ue = unspent[i]
#print("UE: %s" % ue)
if ue['spendable'] and ue['amount'] >= self.BITCOIN_FEE:
#print("Spendable entry found: %s" % ue)
target = ue
break
return target
def __get_fee(self):
pass
def check_cert(self, data: bytes):
return True
def cert_status(self, txid: str):
tx = self.rpc.gettransaction(txid)
if tx is None:
return self.generate_result(STATUS_NOT_FOUND, "TX not found")
confirmations = tx['confirmations']
status = -1
msg = None
if confirmations == 0:
status = STATUS_IN_MEMPOOL
msg = "In mempool"
elif confirmations < self.BITCOIN_FINAL_CONFIRMATIONS:
status = STATUS_PARTIALLY_CONFIRMED
msg = "Partially confirmed: %d" % confirmations
else:
status = STATUS_CONFIRMED
msg = "Confirmed: %d" % confirmations
result = super().generate_result(status, msg, confirmations)
return result
def unlock(self, password = None, timeout = None) -> bool:
self.rpc.walletpassphrase(password, timeout)
return self.is_locked()
def lock(self):
return self.rpc.walletlock()
def is_locked(self) -> bool:
code = None
try:
self.rpc.signmessage("", "")
except JSONRPCException as err:
code = err.code
if code is None or code == -3:
return False
return True
## brew install python
## python -m ensurepip --upgrade OR python3 -m ensurepip --upgrade
## pip install python-bitcoinrpc OR pip3 install python-bitcoinrpc
## command: "/usr/local/bin/python3",
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
from datetime import datetime
import json
import socket
from os import walk
print('-----------------------------------------------')
print("\n")
# rpc_user and rpc_password are set in the bitcoin.conf file
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:8332" %
("mynode", "13Xu4dSoPPKt8AaeBdmjeA5k"))
best_block_hash = rpc_connection.getbestblockhash()
best_block_height = rpc_connection.getblockcount()
# Current block height 683878 ~340 difficulty adjustments
print("best_block_hash: " + best_block_hash)
print("best_block_height: " + str(best_block_height))
print("\n")
data_folder = 'rcp_bitcoin_block_data_v6'
data_file_name = data_folder + '_'
data_files = next(walk(data_folder), (None, None, []))[2]
fetch_num_of_blocks = 2016
bottomBlock = 0
topBlock = fetch_num_of_blocks - 1
def get_rpc():
return AuthServiceProxy(
f'http://{rpc_user}:{rpc_password}@{rpc_ip}:{rpc_port}',
timeout=timeout)
class ApiReceiveApplication(tornado.web.Application):
def __init__(self):
handlers = [
(r"/api/receive", ReceiveHandler),
(r"/api/walletnotify/(?P<txid>[^\/]+)", WalletNotifyHandler),
(r"/api/blocknotify/(?P<hash>[^\/]+)", BlockNotifyHandler),
]
settings = dict(cookie_secret='cookie_secret')
tornado.web.Application.__init__(self, handlers, **settings)
input_log_file_handler = logging.handlers.TimedRotatingFileHandler(
options.log, when='MIDNIGHT')
formatter = logging.Formatter('%(asctime)s - %(message)s')
input_log_file_handler.setFormatter(formatter)
self.bitcoind = AuthServiceProxy(options.rpc_url, options.rpc_username,
options.rpc_password)
self.paytxfee = self.bitcoind.getinfo()['paytxfee']
self.replay_logger = logging.getLogger("REPLAY")
self.replay_logger.setLevel(logging.INFO)
self.replay_logger.addHandler(input_log_file_handler)
self.replay_logger.info('START')
from models import engine, db_bootstrap
self.db_session = scoped_session(sessionmaker(bind=engine))
db_bootstrap(self.db_session)
self.log_start_data()
def invoke_callback_url(self, forwarding_address):
url = forwarding_address.get_callback_url()
self.log('EXECUTE', 'curl ' + url)
http_client = httpclient.AsyncHTTPClient()
http_client.fetch(
url, partial(self.on_handle_callback_url, forwarding_address.id))
def on_handle_callback_url(self, forwarding_address_id, response):
from models import ForwardingAddress
forwarding_address = ForwardingAddress.get_by_id(
self.db_session, forwarding_address_id)
if response.error:
self.log('ERROR', str(response.error))
forwarding_address.callback_number_of_errors += 1
self.db_session.add(forwarding_address)
self.db_session.commit()
else:
if response.body == '*ok*':
forwarding_address.is_confirmed_by_client = True
self.db_session.add(forwarding_address)
self.db_session.commit()
def log(self, command, key, value=None):
log_msg = command + ',' + key
if value:
try:
log_msg += ',' + value
except Exception, e:
try:
log_msg += ',' + str(value)
except Exception, e:
try:
log_msg += ',' + unicode(value)
except Exception, e:
log_msg += ', [object]'
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
import logging
logging.basicConfig()
logging.getLogger("BitcoinRPC").setLevel(logging.DEBUG)
rpc_connection = AuthServiceProxy("http://*****:*****@192.168.51.202:8332")
print(rpc_connection.getinfo())
def RPC():
name = 'username'
wallet_name = ''
uri = wallet_template.format(**settings, wallet_name=wallet_name)
rpc = AuthServiceProxy(uri, timeout=600) # 1 minute timeout
return rpc
# MULTISIGS - PART TWO - SPENDING FROM A 2-of-3 MULTISIG ADDRESS
# This simple wallet works with bitcoind and will only work with 2-of-3 multisigs
# wobine code for world bitcoin network blackboard 101
# Educational Purposes only
# Python 2.7.6 and relies on bitcoind & bitcoinrpc from https://github.com/jgarzik/python-bitcoinrpc
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
# rpc_user and rpc_password are set in the bitcoin.conf file
bitcoin = AuthServiceProxy("http://%s:%[email protected]:8332" %
(rpc_user, rpc_password))
# YOU NEED AT LEAST TWO OF THE PRIVATE KEYS FROM PART ONE linked to your MULTI-SIG ADDRESS
multisigprivkeyone = "L2M1uRgdwgCotoP8prWJYYwz2zwWgsMa9TJwqARG7nFxkpdvBSsm" #your key/brother one
multisigprivkeytwo = "L1M2ZgjoAtDVu9uemahiZBQPwFA5Tyj4GLd1ECkDryviFrGp6m7k" #wallet service/brother two
multisigprivkeythree = "L5PkVBzR4SdQimMsfHnRqRegJZDFJ22sGjSbfp3SsPSnVoB8vRFE" #safe deposit box/brother three
ChangeAddress = "35Z3xG92YkW5Xo4ngQw6w5b3Ce6MDw94A8" #!!! Makes Sure to set your own personal Change Address
SetTxFee = int(
0.00005461 * 100000000
) # Lets proper good etiquette & put something aside for our friends the miners
unspent = bitcoin.listunspent(
) # Query wallet.dat file for unspent funds to see if we have multisigs to spend from
print "Your Bitcoin-QT/d has", len(unspent), "unspent outputs"
for i in range(0, len(unspent)):
print
print "Output", i + 1, "has", unspent[i]["amount"], "bitcoins, or", int(
unspent[i]["amount"] * 100000000), "satoshis"
print "The transaction id for output", i + 1, "is"
print unspent[i]["txid"]
# Run bitcoind in regtest mode
# bitcoind -daemon -regtest -zmqpubrawtx=tcp://127.0.0.1:28332 -rpcallowip=0.0.0.0/0 -server \
# -rpcuser=username -rpcpassword=password
# bitcoin-cli -regtest -rpcuser=username -rpcpassword=password generate 101
# Run the keyserver
# cargo run
HOST_A = "127.0.0.1:8080"
HOST_B = "127.0.0.1:8090"
BASE_URL = "http://%s" % HOST_A
bitcoin.SelectParams("regtest")
# Init Bitcoin RPC
rpc_user = "******"
rpc_password = "******"
rpc_connection = AuthServiceProxy("http://%s:%[email protected]:18443" %
(rpc_user, rpc_password))
# Generate keys
secret = os.urandom(16)
keypair = CECKey()
keypair.set_compressed(True)
keypair.set_secretbytes(secret)
private_key = keypair.get_privkey()
public_key = keypair.get_pubkey()
# Generate key addr
key_addr = str(P2PKHBitcoinAddress.from_pubkey(public_key))
# Construct Payload
header = Header(name="Something wicked", value="this way comes")
entry = Entry(headers=[header], entry_data=b'This gonna be so f*****g fast')
