def __init__(self,
symbol,
rpc_address,
rpc_user,
rpc_pass,
service_id=1,
respond_id=None):
super().__init__(symbol, rpc_address, rpc_user, rpc_pass)
self.proxy = Proxy(
'http://%s:%s@%s' %
(rpc_user, rpc_pass, rpc_address)) # Not thread safe ...
self.prox2 = Proxy(
'http://%s:%s@%s' %
(rpc_user, rpc_pass, rpc_address)) # ... hence needing 2
self.serviceId = service_id
self.respondId = respond_id
self.serviceKey = ''
self.respondKey = ''
self.routingTag = ''
self.ecresolve_tags = []
# ECC feature flags (based on version number)
self.fPacketSig = False
# Caching prior unlock state for post transaction reversion
self.cached_prior_walletinfo = {}
def start(self, extra_args=None, timewait=None):
if self.__proxy is not None:
raise RuntimeError('Already started')
rpcuser = '******'
rpcpassword = '******'
args = [
self.__zcashd,
'-datadir=%s' % self.__datadir,
'-wallet=%s' % self.__wallet,
'-rpcuser=%s' % rpcuser,
'-rpcpassword=%s' % rpcpassword,
'-showmetrics=0',
'-experimentalfeatures',
'-zmergetoaddress',
]
if self.__testnet:
args.append('-testnet=1')
if extra_args is not None:
args.extend(extra_args)
self.__process = subprocess.Popen(args)
cli_args = [
self.__zcash_cli,
'-datadir=%s' % self.__datadir,
'-rpcuser=%s' % rpcuser,
'-rpcpassword=%s' % rpcpassword,
'-rpcwait',
]
if self.__testnet:
cli_args.append('-testnet=1')
cli_args.append('getblockcount')
devnull = open('/dev/null', 'w+', encoding='utf8')
if os.getenv('PYTHON_DEBUG', ''):
print(
'start_node: zcashd started, calling zcash-cli -rpcwait getblockcount'
)
subprocess.check_call(cli_args, stdout=devnull)
if os.getenv('PYTHON_DEBUG', ''):
print(
'start_node: calling zcash-cli -rpcwait getblockcount returned'
)
devnull.close()
rpcuserpass = '******' % (rpcuser, rpcpassword)
rpchost = '127.0.0.1'
rpcport = 18232 if self.__testnet else 8232
url = 'http://%s@%s:%d' % (rpcuserpass, rpchost, rpcport)
if timewait is not None:
self.__proxy = Proxy(url, timeout=timewait)
else:
self.__proxy = Proxy(url)
def rpc_connect(rpc_user, rpc_password, port):
try:
rpc_connection = Proxy("http://%s:%[email protected]:%d" %
(rpc_user, rpc_password, port))
except Exception as e:
raise Exception(e)
return rpc_connection
def def_credentials(chain):
rpcport = ''
operating_system = platform.system()
if operating_system == 'Darwin':
data_dir = os.path.join(os.environ['HOME'], 'Library',
'Application Support', 'Komodo')
elif operating_system == 'Linux':
data_dir = os.path.join(os.environ['HOME'], '.komodo')
elif operating_system == 'Windows':
data_dir = os.path.join(os.environ['APPDATA'], 'komodo')
if chain == 'KMD':
coin_config_file = os.path.join(data_dir, 'komodo.conf')
else:
coin_config_file = os.path.join(data_dir, chain, chain + '.conf')
with open(coin_config_file, 'r') as f:
for line in f:
l = line.rstrip()
if re.search('rpcuser', l):
rpcuser = l.replace('rpcuser='******'')
elif re.search('rpcpassword', l):
rpcpassword = l.replace('rpcpassword='******'')
elif re.search('rpcport', l):
rpcport = l.replace('rpcport=', '')
if len(rpcport) == 0:
if chain == 'KMD':
rpcport = 7771
else:
print("rpcport not in conf file, exiting")
print("check " + coin_config_file)
exit(1)
return Proxy(
conf_file=coin_config_file
), rpcport, "http://" + rpcuser + ":" + rpcpassword + "@127.0.0.1:" + str(
rpcport)
def def_credentials(chain):
rpcport = '';
operating_system = platform.system()
if operating_system == 'Darwin':
ac_dir = os.environ['HOME'] + '/Library/Application Support/Komodo'
elif operating_system == 'Linux':
ac_dir = os.environ['HOME'] + '/.komodo'
elif operating_system == 'Windows':
ac_dir = '%s/komodo/' % os.environ['APPDATA']
if chain == 'KMD':
coin_config_file = str(ac_dir + '/komodo.conf')
else:
coin_config_file = str(ac_dir + '/' + chain + '/' + chain + '.conf')
with open(coin_config_file, 'r') as f:
for line in f:
l = line.rstrip()
if re.search('rpcuser', l):
rpcuser = l.replace('rpcuser='******'')
elif re.search('rpcpassword', l):
rpcpassword = l.replace('rpcpassword='******'')
elif re.search('rpcport', l):
rpcport = l.replace('rpcport=', '')
if len(rpcport) == 0:
if chain == 'KMD':
rpcport = 7771
else:
print("rpcport not in conf file, exiting")
print("check " + coin_config_file)
exit(1)
return (Proxy("http://%s:%[email protected]:%d" % (rpcuser, rpcpassword, int(rpcport))))
def def_credentials(chain):
rpcport = ''
ac_dir = def_data_dir()
if chain == 'KMD':
coin_config_file = str(ac_dir + '/komodo.conf')
else:
coin_config_file = str(ac_dir + '/' + chain + '/' + chain + '.conf')
with open(coin_config_file, 'r') as f:
for line in f:
l = line.rstrip()
if re.search('rpcuser', l):
rpcuser = l.replace('rpcuser='******'')
elif re.search('rpcpassword', l):
rpcpassword = l.replace('rpcpassword='******'')
elif re.search('rpcport', l):
rpcport = l.replace('rpcport=', '')
if len(rpcport) == 0:
if chain == 'KMD':
rpcport = 7771
else:
print("rpcport not in conf file, exiting")
print("check " + coin_config_file)
exit(1)
return (Proxy("http://%s:%[email protected]:%d" %
(rpcuser, rpcpassword, int(rpcport))))
def rpc_connect(rpc_user, rpc_password, server, port):
try:
rpc_connection = Proxy("http://%s:%s@%s:%d"%(rpc_user, rpc_password, server, port))
except Exception as e:
print(e)
raise Exception("Connection error! Probably no daemon on selected port.")
return rpc_connection
def set_rpc_proxy(ticker):
rpcport = ''
ac_dir = ''
operating_system = platform.system()
if operating_system == 'Darwin':
ac_dir = os.environ['HOME'] + '/Library/Application Support/Komodo'
elif operating_system == 'Linux':
ac_dir = os.environ['HOME'] + '/.komodo'
elif operating_system == 'Win64' or operating_system == 'Windows':
ac_dir = '%s/komodo/' % os.environ['APPDATA']
if ticker == 'KMD':
coin_config_file = str(ac_dir + '/komodo.conf')
else:
coin_config_file = str(ac_dir + '/' + ticker + '/' + ticker + '.conf')
with open(coin_config_file, 'r') as f:
for line in f:
l = line.rstrip()
if re.search('rpcuser', l):
rpcuser = l.replace('rpcuser='******'')
elif re.search('rpcpassword', l):
rpcpassword = l.replace('rpcpassword='******'')
elif re.search('rpcport', l):
rpcport = l.replace('rpcport=', '')
if len(rpcport) == 0:
if ticker == 'KMD':
rpcport = 7771
else:
return
return Proxy("http://%s:%[email protected]:%d" %
(rpcuser, rpcpassword, int(rpcport)))
def __init__(self):
self.logger = Logger()
self.mongo = mongo.Mongo(self.logger)
self.rpc_connection = Proxy(
f"http://{os.environ['CRYPTO_USER']}:{os.environ['CRYPTO_PASS']}@"
f"127.0.0.1:{os.environ['CRYPTO_PORT']}")
self.tx_cache = TxCache()
def rpc_connect(rpc_user, rpc_password, port):
try:
rpc_connection = Proxy("http://%s:%[email protected]:%d" %
(rpc_user, rpc_password, port))
except Exception:
raise Exception(
"Connection error! Probably no daemon on selected port.")
return rpc_connection
def def_credentials(chain):
rpc = get_rpc_details(chain)
try:
rpc_connection = Proxy("http://%s:%[email protected]:%d" %
(rpc[0], rpc[1], int(rpc[2])))
except Exception:
raise Exception(
"Connection error! Probably no daemon on selected port.")
return rpc_connection
def rpc_connect(rpc_user, rpc_password, server, port):
try:
rpc_connection = Proxy("http://%s:%s@%s:%d" %
(rpc_user, rpc_password, server, port))
except (http.client.CannotSendRequest, http.client.RemoteDisconnected,
ConnectionRefusedError, OSError):
raise Exception(
"Connection error! Probably no daemon on selected port.")
return rpc_connection
def create_proxy(node_params_dictionary):
try:
proxy = Proxy("http://%s:%s@%s:%d" % (node_params_dictionary.get('rpc_user'),
node_params_dictionary.get('rpc_password'),
node_params_dictionary.get('rpc_ip'),
node_params_dictionary.get('rpc_port')), timeout=120)
except Exception as e:
raise Exception("Connection error! Probably no daemon on selected port. Error: ", e)
return proxy
def _proxy_connection(node_params_dictionary):
try:
proxy = Proxy("http://%s:%s@%s:%d" %
(node_params_dictionary["rpc_user"],
node_params_dictionary["rpc_password"],
node_params_dictionary["rpc_ip"],
node_params_dictionary["rpc_port"]),
timeout=120)
proxy_connected.append(proxy)
except Exception as e:
raise Exception(
"Connection error! Probably no daemon on selected port. Error: ",
e)
return proxy
def init_app(self, app):
"""Set up this instance for use with *app*, if no app was passed to
the constructor.
"""
self.app = app
app.wallet_instance = self
if not hasattr(app, 'extensions'):
app.extensions = {}
app.extensions['wallet'] = self
app.config.setdefault(
'WALLET_RPC_URL',
'"http://%s:%[email protected]:8332"%("Rpcuser", "Rpcpassword")')
self.connect = Proxy(app.config['WALLET_RPC_URL'])
app.context_processor(_wallet_context_processor)
app.teardown_appcontext(self.teardown)
def def_creds(chain):
rpcport =''
coin_config_file = ''
if chain == 'KMD':
coin_config_file = str(ac_dir + '/komodo.conf')
elif chain == 'BTC':
coin_config_file = str(home + '/.bitcoin/bitcoin.conf')
elif this_node == 'third_party':
with open(coins_json) as file:
coins_3p = json.load(file)
for coin in coins_3p:
if coin['tag'] == chain:
coin_config_file = str(home+'/'+coin['datadir']+'/'+coin['conf'])
if coin_config_file == '':
coin_config_file = str(ac_dir + '/' + chain + '/' + chain + '.conf')
else:
coin_config_file = str(ac_dir + '/' + chain + '/' + chain + '.conf')
with open(coin_config_file, 'r') as f:
for line in f:
l = line.rstrip()
if re.search('rpcuser', l):
rpcuser = l.replace('rpcuser='******'')
elif re.search('rpcpassword', l):
rpcpassword = l.replace('rpcpassword='******'')
elif re.search('rpcport', l):
rpcport = l.replace('rpcport=', '')
if len(rpcport) == 0:
if chain == 'KMD':
rpcport = 7771
elif chain == 'KMD':
rpcport = 8333
else:
print("rpcport not in conf file, exiting")
print("check "+coin_config_file)
exit(1)
return(Proxy("http://%s:%[email protected]:%d"%(rpcuser, rpcpassword, int(rpcport))))
print("Transaction confirmed!\n")
def print_balance(rpc_connection_source, rpc_connection_destination):
balance_source = rpc_connection_source.getbalance()
balance_destination = rpc_connection_destination.getbalance()
source_chain_name = rpc_connection_source.getinfo()["name"]
destination_chain_name = rpc_connection_destination.getinfo()["name"]
print("Source chain " + source_chain_name + " balance: " +
str(balance_source))
print("Destination chain " + destination_chain_name + " balance: " +
str(balance_destination))
# SET RPC CONNECTION DETAILS HERE
rpc_connection_sourcechain = Proxy("http://%s:%[email protected]:%d" %
("user", "pass", 30667))
rpc_connection_destinationchain = Proxy("http://%s:%[email protected]:%d" %
("user", "pass", 50609))
rpc_connection_kmdblockchain = Proxy("http://%s:%[email protected]:%d" %
("user", "pass", 7771))
# SET ADDRESS AND MIGRATION AMOUNT HERE
address = "RHq3JsvLxU45Z8ufYS6RsDpSG4wi6ucDev"
amount = 0.1
t0 = time.time()
print_balance(rpc_connection_sourcechain, rpc_connection_destinationchain)
print("Sending " + str(amount) + " coins from " + rpc_connection_sourcechain.getinfo()["name"] + " chain " +\
"to " + rpc_connection_destinationchain.getinfo()["name"] + " chain")
class ZcashNode(object):
def __init__(self, args, zcashd=None, zcash_cli=None):
if zcashd is None:
zcashd = os.getenv('ZCASHD', 'zcashd')
if zcash_cli is None:
zcash_cli = os.getenv('ZCASHCLI', 'zcash-cli')
self.__datadir = args.datadir
self.__wallet = args.wallet
self.__testnet = not args.mainnet
self.__zcashd = zcashd
self.__zcash_cli = zcash_cli
self.__process = None
self.__proxy = None
self.automated = args.automate
self.use_faucet = args.faucet
def start(self, extra_args=None, timewait=None):
if self.__proxy is not None:
raise RuntimeError('Already started')
rpcuser = '******'
rpcpassword = '******'
args = [
self.__zcashd,
'-datadir=%s' % self.__datadir,
'-wallet=%s' % self.__wallet,
'-rpcuser=%s' % rpcuser,
'-rpcpassword=%s' % rpcpassword,
'-showmetrics=0',
'-experimentalfeatures',
'-zmergetoaddress',
]
if self.__testnet:
args.append('-testnet=1')
if extra_args is not None:
args.extend(extra_args)
self.__process = subprocess.Popen(args)
cli_args = [
self.__zcash_cli,
'-datadir=%s' % self.__datadir,
'-rpcuser=%s' % rpcuser,
'-rpcpassword=%s' % rpcpassword,
'-rpcwait',
]
if self.__testnet:
cli_args.append('-testnet=1')
cli_args.append('getblockcount')
devnull = open('/dev/null', 'w+', encoding='utf8')
if os.getenv('PYTHON_DEBUG', ''):
print(
'start_node: zcashd started, calling zcash-cli -rpcwait getblockcount'
)
subprocess.check_call(cli_args, stdout=devnull)
if os.getenv('PYTHON_DEBUG', ''):
print(
'start_node: calling zcash-cli -rpcwait getblockcount returned'
)
devnull.close()
rpcuserpass = '******' % (rpcuser, rpcpassword)
rpchost = '127.0.0.1'
rpcport = 18232 if self.__testnet else 8232
url = 'http://%s@%s:%d' % (rpcuserpass, rpchost, rpcport)
if timewait is not None:
self.__proxy = Proxy(url, timeout=timewait)
else:
self.__proxy = Proxy(url)
def stop(self):
if self.__proxy is None:
raise RuntimeError('Not running')
self.__proxy.stop()
self.__process.wait()
self.__proxy = None
self.__process = None
def __getattr__(self, name):
if self.__proxy is None:
raise RuntimeError('Not running')
return self.__proxy.__getattr__(name)
#!/usr/bin/env python3
# coding: UTF-8
import datetime
import settings
import argparse
import pathlib
import logging
import signal
import time
import sys
from slickrpc import Proxy
from slickrpc import exc
proxy = Proxy('http://%s:%s@%s' %
(settings.rpc_user, settings.rpc_pass, settings.rpc_address))
################################################################################
## SyncMonApp class ############################################################
################################################################################
class SyncMonApp:
def __init__(self):
pass
############################################################################
def run(self):
from lib import rpclib
from slickrpc import Proxy
import requests
import json
rpc_user = "******"
rpc_password = "******"
port = 24708
rpc_connect = rpc_connection = Proxy("http://%s:%[email protected]:%d" %
(rpc_user, rpc_password, port))
address = "RXju6We6DDK9EYhrAVBZVXNAFbA5czw7yK"
url = "http://seed.juicydev.coingateways.com:24711/insight-api-komodo/addrs/RS7y4zjQtcNv7inZowb8M6bH3ytS1moj9A/utxo"
try:
res = requests.get(url)
except Exception as e:
print(e)
to_python = json.loads(res.text)
count = 0
list_of_ids = []
list_of_vouts = []
amount = 0
for objects in to_python:
if (objects['amount'] < 0.01) and count < 10:
#To use this test run in the terminal:
# $: python3 test_rpc.py
from slickrpc import Proxy
rpc_user="******"
rpc_password="******"
rpc_host="127.0.0.1"
rpc_port="8332"
bitcoin = Proxy("http://%s:%[email protected]:8332"%(rpc_user, rpc_password))
hex = bitcoin.getrawtransaction ("a9a9db6b085df091ea1491e57df9177d128f6650ec9405148c9c2b64a835e88e", False,
#"00000000e6f2148b04603d41257bb25b984787f6e5d0aadbfcda1b517806f9df"
)
decoded_tx = bitcoin.decoderawtransaction (hex)
print(decoded_tx)
transactions = bitcoin.listtransactions("bc1qfm5repssqrnx9twvzw4glkcmk4z0gha5lnaeyp")
print(transactions)
from slickrpc import Proxy;
from time import sleep
p = Proxy(service_url='http://*****:*****@127.0.0.1:24127');
#print(p.masternode("outputs"))
def get_collat(p, unspent, pw):
'''
take a list of unspent outputs and return a list of
tx to make at least 1 collateral sized output
If it's not possible return empty list
'''
p.walletpassphrase(pw, 1)
inputs = []
total = 0
keychain = []
keys = []
for u in unspent:
inputs.append({'txid':u['txid'], 'vout':u['vout']})
total += u['amount']
privkey = p.dumpprivkey(r['address'])
keychain.append(privkey)
if privkey in keys:
keys[privkey] += 1
else:
keys[privkey] = 1
if collat > MN_COLLAT:
return [inputs, keychain]
return []
class eccoinNode(cryptoNode):
version_min = 30000
version_max = 99999
win_zmq_bug = 30300
version_fPacketSig = 30300
serviceIdx = count(start=1)
respondIdx = count(start=1)
############################################################################
def __init__(self,
symbol,
rpc_address,
rpc_user,
rpc_pass,
service_id=1,
respond_id=None):
super().__init__(symbol, rpc_address, rpc_user, rpc_pass)
self.proxy = Proxy(
'http://%s:%s@%s' %
(rpc_user, rpc_pass, rpc_address)) # Not thread safe ...
self.prox2 = Proxy(
'http://%s:%s@%s' %
(rpc_user, rpc_pass, rpc_address)) # ... hence needing 2
self.serviceId = service_id
self.respondId = respond_id
self.serviceKey = ''
self.respondKey = ''
self.routingTag = ''
self.ecresolve_tags = []
# ECC feature flags (based on version number)
self.fPacketSig = False
# Caching prior unlock state for post transaction reversion
self.cached_prior_walletinfo = {}
############################################################################
def __getattr__(self, method):
return getattr(self.proxy, method)
############################################################################
def initialise(self):
try:
info = self.proxy.getnetworkinfo()
except ValueError:
raise cryptoNodeException(
'Failed to connect - error in rpcuser or rpcpassword for eccoin'
)
except pycurl.error:
raise cryptoNodeException(
'Failed to connect - check that eccoin daemon is running')
except exc.RpcInWarmUp:
raise cryptoNodeException(
'Failed to connect - eccoin daemon is starting but not ready - try again after 60 seconds'
)
except exc.RpcMethodNotFound:
raise cryptoNodeException(
'RPC getnetworkinfo unavailable for {} daemon'.format(
self.symbol))
# ECC daemon version checking and feature enablement
if not self.version_min <= info['version'] <= self.version_max:
raise cryptoNodeException(
'eccoind version {} not supported - please run a version in the range {}-{}'
.format(info['version'], self.version_min, self.version_max))
if (info['version'] == self.win_zmq_bug) and (sys.platform
in ['win32', 'cygwin']):
raise cryptoNodeException(
'eccoind version {} not supported on Windows - please upgrade'.
format(info['version']))
self.fPacketSig = info['version'] >= self.version_fPacketSig
# ECC messaging buffer setup
try:
self.routingTag = self.proxy.getroutingpubkey()
if self.serviceId:
self.serviceKey = self.proxy.registerbuffer(self.serviceId)
if self.respondId:
self.respondKey = self.proxy.registerbuffer(self.respondId)
except exc.RpcInternalError:
raise cryptoNodeException(
'API Buffer was not correctly unregistered or another instance running - try again after 60 seconds'
)
# ZMQ detection and configuration loading
try:
zmqnotifications = self.proxy.getzmqnotifications()
except pycurl.error:
raise cryptoNodeException(
'Blockchain node for {} not available or incorrectly configured'
.format(self.symbol))
except (exc.RpcMethodNotFound, ValueError):
zmqnotifications = []
for zmqnotification in zmqnotifications:
if zmqnotification['type'] == 'pubhashblock':
self.zmqAddress = zmqnotification['address']
# Load ecresolve routing tags and setup routes for subsequent ecc network name resolution
self.ecresolve_tags = self.get_ecresolve_tags()
route = []
for tag in self.ecresolve_tags:
try:
self.proxy.findroute(tag)
route.append(self.proxy.haveroute(tag))
except exc.RpcInvalidAddressOrKey:
raise cryptoNodeException(
'Routing tag for ecresolve has invalid base64 encoding : {}'
.format(tag))
if not any(route):
raise cryptoNodeException(
'No route available to ecresolve across all {} configured routing tags'
.format(len(self.ecresolve_tags)))
############################################################################
def refresh(self):
self.blocks = self.proxy.getblockcount()
self.peers = self.proxy.getconnectioncount()
############################################################################
def get_balance(self):
return self.proxy.getbalance()
############################################################################
def get_unlocked_balance(self):
return self.proxy.getbalance()
############################################################################
def get_unconfirmed_balance(self):
return self.proxy.getunconfirmedbalance()
############################################################################
def get_new_address(self):
return self.proxy.getnewaddress()
############################################################################
def wallet_locked(self, cache_prior_state=False):
info = self.proxy.getwalletinfo()
if cache_prior_state and info.keys() >= {
'unlocked_until', 'staking_only_unlock'
}:
self.cached_prior_walletinfo = info.copy()
if 'unlocked_until' in info:
if 'staking_only_unlock' in info:
return info['staking_only_unlock'] or (info['unlocked_until']
== 0)
else:
return info['unlocked_until'] == 0
return False # unencrypted wallet
############################################################################
def unlock_wallet(self, passphrase, seconds, staking=False):
try:
self.proxy.walletpassphrase(passphrase, seconds, staking)
except exc.RpcWalletPassphraseIncorrect:
return False
else:
# Cache passphrase for later call to revert_wallet_lock
if self.cached_prior_walletinfo:
self.cached_prior_walletinfo['passphrase'] = passphrase
return True
############################################################################
def revert_wallet_lock(self):
if self.cached_prior_walletinfo and 'passphrase' in self.cached_prior_walletinfo:
if self.cached_prior_walletinfo['unlocked_until'] > 0:
seconds = self.cached_prior_walletinfo['unlocked_until'] - int(
time.time())
self.unlock_wallet(
self.cached_prior_walletinfo['passphrase'], seconds,
self.cached_prior_walletinfo['staking_only_unlock'])
self.cached_prior_walletinfo.clear()
############################################################################
def send_to_address(self, address, amount, comment):
try:
txid = self.proxy.sendtoaddress(address, amount, comment)
except exc.RpcWalletUnlockNeeded:
raise cryptoNodeException('Wallet locked - please unlock')
except exc.RpcWalletInsufficientFunds:
raise cryptoNodeException('Insufficient funds in wallet')
except exc.RpcTypeError:
raise cryptoNodeException('Invalid amount')
except exc.RpcWalletError:
raise cryptoNodeException('Amount too small')
else:
return txid
############################################################################
def reset_service_buffer_timeout(self):
if self.serviceKey:
try:
bufferSig = self.prox2.buffersignmessage(
self.serviceKey, 'ResetBufferTimeout')
self.prox2.resetbuffertimeout(self.serviceId, bufferSig)
except pycurl.error:
self.serviceKey = ''
raise cryptoNodeException(
'Failed to connect - check that eccoin daemon is running')
return True
return False
############################################################################
def reset_respond_buffer_timeout(self):
if self.respondKey:
try:
bufferSig = self.prox2.buffersignmessage(
self.respondKey, 'ResetBufferTimeout')
self.prox2.resetbuffertimeout(self.respondId, bufferSig)
except pycurl.error:
self.serviceKey = ''
raise cryptoNodeException(
'Failed to connect - check that eccoin daemon is running')
return True
return False
############################################################################
def reset_buffer_timeouts(self):
serviceResult = self.reset_service_buffer_timeout()
respondResult = self.reset_respond_buffer_timeout()
return serviceResult or respondResult # OR semantics because the return value is used to gate timer setup
############################################################################
def get_ecresolve_tags(self):
domain = 'ecchat.io'
# TODO - Make this daemon version dependent ref new RPC
tags = []
try:
resolved = dns.resolver.resolve(domain, 'TXT')
except:
raise cryptoNodeException(
'Error while resolving ecresolve routing tags from {} TXT record'
.format(domain))
for entry in resolved:
decoded_entry = entry.to_text()[1:-1].split('=', 1)
if (len(decoded_entry) == 2) and (decoded_entry[0] == 'ecresolve'):
tags.append(decoded_entry[1])
return tags
############################################################################
def setup_route(self, targetRoute):
try:
self.proxy.findroute(targetRoute)
isRoute = self.proxy.haveroute(targetRoute)
except exc.RpcInvalidAddressOrKey:
raise cryptoNodeException(
'Routing tag has invalid base64 encoding : {}'.format(
targetRoute))
if not isRoute:
raise cryptoNodeException(
'No route available to : {}'.format(targetRoute))
############################################################################
def send_packet(self, dest_key, protocol_id, data):
if self.fPacketSig:
signature = self.proxy.tagsignmessage(data)
self.proxy.sendpacket(dest_key, protocol_id, data, self.routingTag,
signature)
else:
self.proxy.sendpacket(dest_key, protocol_id, data)
############################################################################
def get_service_buffer(self):
if self.serviceKey:
bufferCmd = 'GetBufferRequest:' + str(self.serviceId) + str(
next(self.serviceIdx))
bufferSig = self.proxy.buffersignmessage(self.serviceKey,
bufferCmd)
eccbuffer = self.proxy.getbuffer(self.serviceId, bufferSig)
return eccbuffer
else:
return None
############################################################################
def get_respond_buffer(self):
if self.respondKey:
bufferCmd = 'GetBufferRequest:' + str(self.respondId) + str(
next(self.respondIdx))
bufferSig = self.proxy.buffersignmessage(self.respondKey,
bufferCmd)
eccbuffer = self.proxy.getbuffer(self.respondId, bufferSig)
return eccbuffer
else:
return None
############################################################################
def get_buffer(self, protocol_id=1):
if protocol_id == self.serviceId:
return self.get_service_buffer()
if protocol_id == self.respondId:
return self.get_respond_buffer()
return None
############################################################################
def shutdown(self):
if self.serviceKey:
bufferSig = self.proxy.buffersignmessage(self.serviceKey,
'ReleaseBufferRequest')
self.proxy.releasebuffer(self.serviceId, bufferSig)
self.serviceKey = ''
if self.respondKey:
bufferSig = self.proxy.buffersignmessage(self.respondKey,
'ReleaseBufferRequest')
self.proxy.releasebuffer(self.respondId, bufferSig)
self.respondKey = ''
#!/usr/bin/env python3
import datetime
from slickrpc import Proxy
from slickrpc.exc import RpcException
TIME_STARTED = datetime.datetime.now()
zcash_proxy = Proxy("http://%s:%[email protected]:%s" %
(
"rpcuser",
"rpcpass",
"8232")
)
def call_rpc(name, args=[]):
print("%s: ./zcash-cli %s %s" %
(
datetime.datetime.now() - TIME_STARTED,
name,
' '.join([str(arg) for arg in args]))
)
try:
return zcash_proxy.__getattr__(name)(*args)
except RpcException as e:
print("RpcException: %s" % (e))
return None
# Call "help" to generate a list of rpcs
help_rpc_output = call_rpc("help")
#!/usr/bin/env python
from json import loads, dumps
from sys import exit, argv
import base64
import urllib.request
from slickrpc import Proxy
bitcoin = Proxy("http://%s:%[email protected]:44444" % ("user", "password"))
# Electrum checkpoints are blocks 2015, 2015 + 2016, 2015 + 2016*2, ...
i = 2015
INTERVAL = 2016
# From electrum.
def bits_to_target(bits):
bitsN = (bits >> 24) & 0xff
if not (bitsN >= 0x03 and bitsN <= 0x1e):
raise BaseException("First part of bits should be in [0x03, 0x1e]")
bitsBase = bits & 0xffffff
if not (bitsBase >= 0x8000 and bitsBase <= 0x7fffff):
raise BaseException(
"Second part of bits should be in [0x8000, 0x7fffff]")
return bitsBase << (8 * (bitsN - 3))
checkpoints = []
block_count = bitcoin.getblockcount()
print('Blocks: {}'.format(block_count))
while True:
else:
already_choosen_ips = []
for j in range(3):
connect_ip = random.choice(ips_of_running_servers)
if connect_ip in already_choosen_ips:
connect_ip = random.choice(ips_of_running_servers)
else:
already_choosen_ips.append(connect_ip)
for ip in already_choosen_ips:
daemon_args.append("-addnode=" + ip + ":6000")
subprocess.call(daemon_args)
time.sleep(3)
# creating rpc proxies for all nodes
for i in range(dexp2p_clients_to_start):
rpcport = 7000 + i
globals()['proxy_%s' % i] = Proxy("http://%s:%[email protected]:%d" %
("test", "test", int(rpcport)))
try:
dex_stats_output = globals()['proxy_%s' % i].DEX_stats()
print(dex_stats_output)
except Exception as e:
print(e)
# since connection ports were chosen randomly let's try to interconnect orphan nodes
for i in range(dexp2p_clients_to_start):
connections_amount = globals()['proxy_%s' % i].getinfo()["connections"]
print(connections_amount)
print("All nodes started (hopefully) - you can proceed to loading test")
class bitcoinNode(cryptoNode):
############################################################################
def __init__(self, symbol, rpc_address, rpc_user, rpc_pass):
super().__init__(symbol, rpc_address, rpc_user, rpc_pass)
self.proxy = Proxy('http://%s:%s@%s' %
(rpc_user, rpc_pass, rpc_address))
############################################################################
def __getattr__(self, method):
return getattr(self.proxy, method)
############################################################################
def initialise(self):
try:
info = self.proxy.getnetworkinfo()
except ValueError:
raise cryptoNodeException(
'Failed to connect - error in rpcuser or rpcpassword for {} daemon'
.format(self.symbol))
except pycurl.error:
raise cryptoNodeException(
'Failed to connect - check that {} daemon is running'.format(
self.symbol))
except exc.RpcInWarmUp:
raise cryptoNodeException(
'Failed to connect - {} daemon is starting but not ready - try again after 60 seconds'
.format(self.symbol))
except exc.RpcMethodNotFound:
raise cryptoNodeException(
'RPC getnetworkinfo unavailable for {} daemon'.format(
self.symbol))
try:
zmqnotifications = self.proxy.getzmqnotifications()
except pycurl.error:
raise cryptoNodeException(
'Blockchain node for {} not available or incorrectly configured'
.format(self.symbol))
except (exc.RpcMethodNotFound, ValueError):
zmqnotifications = []
for zmqnotification in zmqnotifications:
if zmqnotification['type'] == 'pubhashblock':
self.zmqAddress = zmqnotification['address']
############################################################################
def refresh(self):
self.blocks = self.proxy.getblockcount()
self.peers = self.proxy.getconnectioncount()
############################################################################
def get_balance(self):
try:
result = self.proxy.getbalance()
except exc.RpcException as error:
raise cryptoNodeException('{} daemon returned error: {}'.format(
self.symbol, str(error)))
else:
return result
############################################################################
def get_unlocked_balance(self):
try:
result = self.proxy.getbalance()
except exc.RpcException as error:
raise cryptoNodeException('{} daemon returned error: {}'.format(
self.symbol, str(error)))
else:
return result
############################################################################
def get_unconfirmed_balance(self):
try:
result = self.proxy.getunconfirmedbalance()
except exc.RpcException as error:
raise cryptoNodeException('{} daemon returned error: {}'.format(
self.symbol, str(error)))
else:
return result
############################################################################
def get_new_address(self):
return self.proxy.getnewaddress()
############################################################################
def wallet_locked(self, cache_prior_state=False):
info = self.proxy.getwalletinfo()
if 'unlocked_until' in info:
return info['unlocked_until'] == 0
return False
############################################################################
def unlock_wallet(self, passphrase, seconds, staking=False):
try:
self.proxy.walletpassphrase(passphrase, seconds)
except exc.RpcWalletPassphraseIncorrect:
return False
else:
return True
############################################################################
def revert_wallet_lock(self):
pass
############################################################################
def send_to_address(self, address, amount, comment):
try:
txid = self.proxy.sendtoaddress(address, amount, comment)
except exc.RpcWalletUnlockNeeded:
raise cryptoNodeException('Wallet locked - please unlock')
except exc.RpcWalletInsufficientFunds:
raise cryptoNodeException('Insufficient funds in wallet')
except exc.RpcTypeError:
raise cryptoNodeException('Invalid amount')
except exc.RpcWalletError:
raise cryptoNodeException('Amount too small')
else:
return txid
############################################################################
def shutdown(self):
pass
time.sleep(15)
else:
print("Transactinon broadcasted on destination chain")
dest_tx_list.append(sent_itx)
is_broadcasted = True
break
else:
print("Too many attempts. Bye bye.")
sys.exit()
return is_broadcasted
# SET RPC CONNECTION DETAILS HERE
rpc_connection_sourcechain = Proxy(
"http://%s:%[email protected]:%d" %
("user1531394351",
"pass24e95276e008e3f6176b672631a89beef6959ce9dae44f8bdb7a92e5ca41e56c77",
30667))
rpc_connection_destinationchain = Proxy(
"http://%s:%[email protected]:%d" %
("user2491106895",
"pass253372aea1796039438e3e3c240a39cec6f9aa11cff7bc3d3c29ab93c0e985d73e",
50609))
rpc_connection_kmdblockchain = Proxy("http://%s:%[email protected]:%d" %
("tony", "156ewr", 7771))
# SET ADDRESS AND MIGRATION AMOUNT HERE
address = "RSbcG63XbgfAwmFmPA362d4zqLb31hJiyt"
amount = 2
migrations_amount = 500
# preparing UTXOs if there is not enough
def __init__(self, symbol, rpc_address, rpc_user, rpc_pass):
super().__init__(symbol, rpc_address, rpc_user, rpc_pass)
self.proxy = Proxy('http://%s:%s@%s' %
(rpc_user, rpc_pass, rpc_address))
# Cron for dump MN and Gov Info
from slickrpc import Proxy
import datetime
import json
import sys
rpc_user = "******"
rpc_password = "******"
rpc_con = Proxy("http://%s:%[email protected]:9846" % (rpc_user, rpc_password))
def dump_mn_info():
"""Get Masternodes info"""
mn = rpc_con.masternode("list", "full")
# format
# 'status protocol payee lastseen activeseconds lastpaidtime lastpaidblock IP'
result = """
{
"data": [
"""
for k in mn.keys():
cr = mn[k].split(" ")
cr = filter(lambda a: a != "", cr)
cr[3] = datetime.datetime.fromtimestamp(int(
cr[3])).strftime('%Y-%m-%d %H:%M:%S')
cr[4] = str(datetime.timedelta(seconds=int(cr[4])))
cr[5] = datetime.datetime.fromtimestamp(int(
cr[5])).strftime('%Y-%m-%d %H:%M:%S')
result += "\n %s," % json.dumps(cr)
