def get_rpcconn(self):
''' returns a working AuthServiceProxy for the bitcoind '''
url = self.render_url()
rpc = AuthServiceProxy(url)
rpc.getblockchaininfo()
logging.debug("created bitcoind-url {} is working".format(url))
return rpc
def test(self):
'''raises JunctionErrors if RPC-connection doesn't work'''
# Test RPC connection works
try:
# FIXME: want shorter timeout ...
rpc = AuthServiceProxy(self.uri, timeout=0.5)
rpc.getblockchaininfo()
except (ConnectionRefusedError, http.client.CannotSendRequest) as e:
raise JunctionError("ConnectionRefusedError: check https://bitcoin.stackexchange.com/questions/74337/testnet-bitcoin-connection-refused-111")
except JSONRPCException as e:
if "Unauthorized" in str(e):
raise JunctionError("Please double-check your credentials!")
# Check node version requirements are met
version = rpc.getnetworkinfo()['version']
if int(version) < 180000:
raise JunctionError("Update your Bitcoin node to at least version 0.18")
# Check wallet enabled
try:
rpc.getwalletinfo()
except JSONRPCException as e:
if "Method not found" in str(e):
raise JunctionError("Junction requires 'disablewallet=0' in your bitcoin.conf")
# Can't detect any problems
return None
def start_bitcoind(bitcoind_path):
datadir = tempfile.mkdtemp()
bitcoind_proc = subprocess.Popen([
bitcoind_path, '-regtest', '-datadir=' + datadir, '-noprinttoconsole'
])
def cleanup_bitcoind():
bitcoind_proc.kill()
shutil.rmtree(datadir)
atexit.register(cleanup_bitcoind)
# Wait for cookie file to be created
while not os.path.exists(datadir + '/regtest/.cookie'):
time.sleep(0.5)
# Read .cookie file to get user and pass
with open(datadir + '/regtest/.cookie') as f:
userpass = f.readline().lstrip().rstrip()
rpc = AuthServiceProxy('http://{}@127.0.0.1:18443'.format(userpass))
# Wait for bitcoind to be ready
ready = False
while not ready:
try:
rpc.getblockchaininfo()
ready = True
except JSONRPCException as e:
time.sleep(0.5)
pass
# Make sure there are blocks and coins available
rpc.generatetoaddress(101, rpc.getnewaddress())
return (rpc, userpass)
async def info(self, ctx):
client = AuthServiceProxy(rpc_connection)
user_id = str(ctx.author.id)
if not user_db.check_user(user_id):
embed = discord.Embed(title="**For first-use**", color=0x0043ff)
embed.set_author(name=ctx.author.display_name,
icon_url=ctx.author.avatar_url_as(format='png',
size=256))
embed.add_field(name="First of all, please type `//help`",
value="Welcome to CPUchain tipbot !")
embed.set_thumbnail(
url=self.bot.user.avatar_url_as(format='png', size=1024))
embed.set_footer(text="CPUchain tipbot {0} [Owner: {1}]".format(
config.VERSION, self.bot.get_user(config.OWNER_ID)),
icon_url=self.bot.user.avatar_url_as(format='png',
size=256))
await ctx.channel.send(embed=embed)
else:
pass
block = client.getblockchaininfo()['blocks']
hash_rate = round(client.getnetworkhashps() / 1000, 4)
difficulty = client.getblockchaininfo()['difficulty']
connection = client.getnetworkinfo()['connections']
client_version = client.getnetworkinfo()['subversion']
blockchain_size = round(
client.getblockchaininfo()['size_on_disk'] / 1000000000, 3)
embed = discord.Embed(title="**CPUchain info**", color=0x0043ff)
embed.set_author(name=ctx.author.display_name,
icon_url=ctx.author.avatar_url_as(format='png',
size=256))
embed.add_field(name="__Current block height__",
value="`{0}`".format(block),
inline=True)
embed.add_field(name="__Network hash rate__",
value="`{0} KH/s`".format(hash_rate),
inline=True)
embed.add_field(name="__Difficulty__",
value="`{0}`".format(difficulty),
inline=True)
embed.add_field(name="__Connection__",
value="`{0}`".format(connection),
inline=True)
embed.add_field(name="__Client Version__",
value="`{0}`".format(client_version),
inline=True)
embed.add_field(name="__Block chain size__",
value="`About {0} GB`".format(blockchain_size),
inline=True)
embed.set_footer(text="CPUchain tipbot {0} [Owner: {1}]".format(
config.VERSION, self.bot.get_user(config.OWNER_ID)),
icon_url=self.bot.user.avatar_url_as(format='png',
size=256))
await ctx.channel.send(embed=embed)
async def info(self, ctx):
client = AuthServiceProxy(rpc_connection)
user_id = str(ctx.author.id)
user_name = ctx.author.name
if not user_db.check_user(user_id):
user_db.add_user(user_id, user_name)
embed = discord.Embed(
title="**How may I be of service?**",
color=0x7152b6)
embed.set_author(
name=ctx.author.display_name,
icon_url=ctx.author.avatar_url_as(format='png', size=256))
embed.add_field(
name="To see all my available commands type `!help`",
value="If you have any issues please let one of the team know.")
embed.set_thumbnail(url=self.bot.user.avatar_url_as(format='png', size=1024))
embed.set_footer(text="TipBot v{0}".format(config.VERSION), icon_url=self.bot.user.avatar_url_as(format='png', size=256))
await ctx.channel.send(embed=embed)
else:
pass
block = client.getblockchaininfo()['blocks']
hash_rate = round(client.getnetworkhashps() / 1000000000, 4)
difficulty = round(client.getblockchaininfo()['difficulty'], 4)
connection = client.getnetworkinfo()['connections']
client_version = client.getnetworkinfo()['subversion']
embed = discord.Embed(
title="**Umbru Network Information**",
color=0x7152b6)
embed.set_author(
name=ctx.author.display_name,
icon_url=ctx.author.avatar_url_as(format='png', size=256))
embed.add_field(
name="**Current Block Height:**",
value="`{0}`".format(block))
embed.add_field(
name="**Network Hash Rate:**",
value="`{0} GH/s`".format(hash_rate))
embed.add_field(
name="**Difficulty:**",
value="`{0}`".format(difficulty))
embed.add_field(
name="**Connections:**",
value="`{0}`".format(connection))
embed.add_field(
name="**Wallet Version:**",
value="`{0}`".format(client_version))
embed.add_field(
name="**Explorer:**",
value="<https://explorer.umbru.io>")
embed.set_footer(text="TipBot v{0}".format(config.VERSION), icon_url=self.bot.user.avatar_url_as(format='png', size=256))
await ctx.channel.send(embed=embed)
def index():
try:
rpc_connect = AuthServiceProxy("http://{}:{}@{}:{}".format(rpc_user,rpc_password,allowed_ip,rpc_port))
current_block_height = rpc_connect.getblockcount()
onchain_peers = rpc_connect.getconnectioncount()
onchain_balance = rpc_connect.getbalance()
bitcoin_version = (rpc_connect.getnetworkinfo()['subversion'])[1:-1].replace("Satoshi:","")
sync_prog = str(round(rpc_connect.getblockchaininfo()['verificationprogress']*100, 2)) + "%"
chain_type = rpc_connect.getblockchaininfo()['chain']
if onchain_balance > 0 and chain_type == "main":
onchain_balance = u"₿ " + str(onchain_balance)
elif onchain_balance == 0:
onchain_balance = u"₿ " + str(0)
elif onchain_balance > 0 and chain_type == "test":
onchain_balance = u"t₿ " + str(onchain_balance)
else:
onchain_balance = u"t₿ " + str(0)
if chain_type == "test":
chaintype_ln = "testnet"
else:
chaintype_ln = "mainnet"
except:
current_block_height = onchain_peers = onchain_balance = bitcoin_version = sync_prog = chain_type = "Offline!"
try:
os.environ["GRPC_SSL_CIPHER_SUITES"] = 'HIGH+ECDSA'
with open(os.path.expanduser(lnd_dir_location + 'data/chain/bitcoin/{}/admin.macaroon'.format(chaintype_ln)), 'rb') as f:
macaroon_bytes = f.read()
macaroon = codecs.encode(macaroon_bytes, 'hex')
cert = open(os.path.expanduser(lnd_dir_location + 'tls.cert'), 'rb').read()
creds = grpc.ssl_channel_credentials(cert)
channel = grpc.secure_channel('localhost:10009', creds)
stub = lnrpc.LightningStub(channel)
response = stub.GetInfo(ln.GetInfoRequest(), metadata=[('macaroon', macaroon)])
satbalance = stub.ChannelBalance(ln.ChannelBalanceRequest(), metadata=[('macaroon', macaroon)])
lightning_channels_act = response.num_active_channels
lightning_peers = response.num_peers
offchain_balance = u"ş " + str(format(satbalance.balance,','))
lightning_version = response.version[:5]
alias = response.alias
except:
lightning_channels_act = lightning_peers = offchain_balance = lightning_version = alias = "Offline!"
return render_template('index.html', current_block_height=current_block_height,
onchain_peers=onchain_peers, onchain_balance=onchain_balance,
bitcoin_version=bitcoin_version, sync_prog=sync_prog, chain_type=chain_type, lightning_channels_act=lightning_channels_act,
lightning_peers=lightning_peers, offchain_balance=offchain_balance,
lightning_version=lightning_version, alias=alias)
def rpcConnection():
'''
Tests RPC via Auth Service Proxy
:return:
'''
rpc_connection = AuthServiceProxy("http://%s:%s@%s:%i/" % (rpcuser, rpcpassword, url, rpcport), timeout=120)
# test it
count = 0
maxTries = 5
while(count<maxTries):
count += 1
try:
info = rpc_connection.getblockchaininfo()
return rpc_connection
except JSONRPCException as e:
print("Authentication error " + str(e))
print("Exiting program")
sys.exit(1)
except Exception as e:
# apologies for bad exception catching
print("Socket error when connecting to rpc")
print(e)
print("Waiting 5 seconds then trying again")
time.sleep(5)
print("Could not establish a connection")
print("Exiting")
def connection():
rpc_connection = AuthServiceProxy(
"http://*****:*****@blockchain.oss.unist.hr:8332"
)
getnetworkinfo = rpc_connection.getnetworkinfo()
getblockchaininfo = rpc_connection.getblockchaininfo()
getnettotals = rpc_connection.getnettotals()
getwalletinfo = rpc_connection.getwalletinfo()
print("BLOCKCHAIN INFO")
print("Tip mreže: %s" % (getblockchaininfo["chain"]))
print("Verzija: %s" % (getnetworkinfo["subversion"]))
print("Broj blokova: %s" % (getblockchaininfo["blocks"]))
print("Veličina blockchaina na disku: %s" %
((getblockchaininfo["size_on_disk"])))
print("Težina: %s" % (getblockchaininfo["difficulty"]))
print("Primljeno: %s" % (getnettotals["totalbytesrecv"]))
print("Poslano: %s" % (getnettotals["totalbytessent"]))
print("\nWALLET INFO")
print("Naziv novčanika: %s" % (getwalletinfo["walletname"]))
print("Verzija novčanika: %s" % (getwalletinfo["walletversion"]))
print("Stanje novčanika: %f" % (getwalletinfo["balance"]))
print("Stanje novčanika (nepotvrđeno): %f " %
(getwalletinfo["unconfirmed_balance"]))
print("Broj transakcija: %s" % (getwalletinfo["txcount"]))
class BitcoinClient:
rpc_connection: AuthServiceProxy = None
def __init__(self, host: str, port: int, cookie_path: str):
cookie = open(path.expanduser(cookie_path)).read().split(":")
self.rpc_connection = AuthServiceProxy(
"http://{user}:{password}@{host}:{port}".format(
port=port,
host=host,
user=cookie[0],
password=cookie[1],
))
def get_blockchain_info(self):
return self.rpc_connection.getblockchaininfo()
def get_network_info(self):
return self.rpc_connection.getnetworkinfo()
def get_mempool_info(self):
return self.rpc_connection.getmempoolinfo()
def get_connection_count(self):
return self.rpc_connection.getconnectioncount()
def bitcoind_wallet(bitcoind):
# Use bitcoind to create a temporary wallet file, and then do cleanup after
# - wallet will not have any keys, and is watch only
import os, shutil
fname = '/tmp/ckcc-test-wallet-%d' % os.getpid()
disable_private_keys = True
blank = True
w = bitcoind.createwallet(fname, disable_private_keys, blank)
assert w['name'] == fname
# give them an object they can do API calls w/ rpcwallet filled-in
cookie = get_cookie()
url = 'http://' + cookie + '@' + URL + '/wallet/' + fname.replace(
'/', '%2f')
#print(url)
conn = AuthServiceProxy(url)
assert conn.getblockchaininfo()['chain'] == 'test'
yield conn
# cleanup
bitcoind.unloadwallet(fname)
assert fname.startswith('/tmp/ckcc-test-wallet')
shutil.rmtree(fname)
class btcd(invoice):
def __init__(self, dollar_value, currency, label, test=False):
super().__init__(dollar_value, currency, label, test)
print(self.__dict__)
# self.__dict__ = invoice.__dict__.copy()
from bitcoinrpc.authproxy import AuthServiceProxy
connection_str = "http://{}:{}@{}:{}".format(config.username,
config.password,
config.host,
config.rpcport)
print("Attempting to connect to {}.".format(connection_str))
for i in range(config.connection_attempts):
try:
self.rpc = AuthServiceProxy(connection_str)
if test:
info = self.rpc.getblockchaininfo()
print(info)
print("Successfully contacted bitcoind.")
break
except Exception as e:
print(e)
time.sleep(config.pollrate)
print("Attempting again... {}/{}...".format(
i + 1, config.connection_attempts))
else:
raise Exception("Could not connect to bitcoind. \
Check your RPC / port tunneling settings and try again.")
def check_payment(self):
transactions = self.rpc.listtransactions()
relevant_txs = [
tx for tx in transactions if tx["address"] == self.address
]
conf_paid = 0
unconf_paid = 0
for tx in relevant_txs:
self.txid = tx["txid"]
if tx["confirmations"] >= config.required_confirmations:
conf_paid += tx["amount"]
else:
unconf_paid += tx["amount"]
return conf_paid, unconf_paid
def get_address(self):
for i in range(config.connection_attempts):
try:
self.address = self.rpc.getnewaddress(self.label)
except Exception as e:
print(e)
print("Attempting again... {}/{}...".format(
i + 1, config.connection_attempts))
return
def bitcoind_d_wallet(bitcoind):
# Use bitcoind to create a temporary DESCRIPTOR-based wallet file, and then do cleanup after
# - wallet will not have any keys until a descriptor is added, and is not just watch-only
import os, shutil
fname = '/tmp/ckcc-test-desc-wallet-%d' % os.getpid()
disable_private_keys = True
blank = True
password = None
avoid_reuse = False
descriptors = True
w = bitcoind.createwallet(fname, disable_private_keys, blank,
password, avoid_reuse, descriptors)
assert w['name'] == fname
# give them an object they can do API calls w/ rpcwallet filled-in
cookie = get_cookie()
url = 'http://' + cookie + '@' + URL + '/wallet/' + fname.replace('/', '%2f')
#print(url)
conn = AuthServiceProxy(url)
assert conn.getblockchaininfo()['chain'] == 'test'
yield conn
# cleanup
bitcoind.unloadwallet(fname)
assert fname.startswith('/tmp/ckcc-test-desc-wallet')
shutil.rmtree(fname)
class ChainData:
RPC_USER = RPC_NODE["user"]
RPC_PASSWORD = RPC_NODE["password"]
RPC_SERVER = RPC_NODE["server"]
RPC_PORT = RPC_NODE["port"]
MIN_BLOCK = CHAIN["start_block"]
MIN_CONFIRMS = CHAIN["confirms"]
COIN = CHAIN["name"]
def __init__(self):
self.rpc_conn = AuthServiceProxy(
"http://%s:%s@%s:%s" %
(self.RPC_USER, self.RPC_PASSWORD, self.RPC_SERVER, self.RPC_PORT))
def get_blocks(self):
resp = self.rpc_conn.getblockchaininfo()
return resp["blocks"]
def get_headers(self):
resp = self.rpc_conn.getblockchaininfo()
return resp["headers"]
def get_blockhash(self, block):
resp = self.rpc_conn.getblockhash(block)
return resp
def _get_blocktransactions(self, block):
blockhash = self.get_blockhash(block)
resp = self.rpc_conn.getblock(blockhash, 2)
return resp["tx"], blockhash
def getblock_out_balances(self, block):
txs, blockhash = self._get_blocktransactions(block)
balances = []
for tx in txs:
for iout in tx['vout']:
if iout.get("scriptPubKey") and iout.get("scriptPubKey").get(
"addresses"):
balances.append(
(iout["scriptPubKey"]["addresses"][0], iout["value"]))
if len(iout["scriptPubKey"]["addresses"]) > 1:
logger.error(
"More than one address detected! block %s, addresses: %s"
% (block, iout["scriptPubKey"]["addresses"]))
return balances, blockhash
def main():
brojac=0
priceList=[]
days=[]
#spajanje na server
node_name="blockchain.oss.*****"
port=*****
rpc_user=*****
rpc_password=******
server =AuthServiceProxy("http://%s:%s@%s:%s"%(rpc_user,rpc_password,node_name,port))
#podaci sa servera
getinfo = server.getnetworkinfo()
getblockinfo= server.getblockchaininfo()
getmininginfo= server.getmininginfo()
print ("Host: %s , Port: %s"%(node_name,port))
print ("Broj konekcija na server: ",getinfo["connections"])
print ("Vrsta blockchaina: ",getblockinfo["chain"])
print ("Visina bloka: ",getmininginfo["blocks"])
print ("Zauzece diska: %.2f GB"%((getblockinfo["size_on_disk"]/(1024**3))))
#zadaje se interval otkad dokad se dobije graf
start=str(input("unesite pocetni datum u formatu yyyy-mm-dd: "))
end=str(input("unesite krajnji datum u formatu yyyy-mm-dd: "))
dan=str(input("unesite datum za koji zelite vrijednost u formatu yyyy-mm-dd: "))
poveznica=("https://api.coindesk.com/v1/bpi/historical/close.json?")
rez=(poveznica + 'start=' + start + '&'+ 'end='+end)
#dan na koji se dobije vrijednost BTC
datum=((poveznica + 'start=' + dan + '&'+ 'end='+end))
specifican_dan=requests.get(datum).json()
vrijednost=specifican_dan["bpi"][dan]
print ("Vrijednost BTC na datum",dan,"je ",vrijednost,"$")
response= requests.get(rez).json()
date_time_obj = datetime.datetime.strptime(end, '%Y-%m-%d')
kraj=date_time_obj.date()
for i in range(1,(len(response["bpi"]))):
dateInput=(kraj-timedelta(days=i))
data=response["bpi"][str(dateInput)]
priceList.append(data)
days.append(str(dateInput))
brojac+=1
days.reverse()
priceList.reverse()
plt.plot(days,priceList)
plt.xticks([days[0],days[round(brojac/5)],days[round(brojac/2)],days[round(brojac/1.2)],days[round(brojac-1)]])
plt.ylabel("Cijena USD")
plt.title("Cijena BTC kroz specificirani period")
plt.grid(True)
plt.show()
def sync():
print("trying sync")
try:
rpc_connect = AuthServiceProxy("http://{}:{}@{}:{}".format(rpc_user,rpc_password,nodeip,rpc_port))
blocks = rpc_connect.getblockcount()
peers = rpc_connect.getconnectioncount()
sync_prog = str(round(rpc_connect.getblockchaininfo()['verificationprogress']*100, 2)) + "%"
return "👥 Peers: {}\n\n⏹ Block Height: {}\n\n🔄 Sync Progress: {}".format(peers, blocks, sync_prog)
except:
return "Something went wrong. Check your node is properly connected."
def bitcoind():
# JSON-RPC connection to a bitcoind instance
# see <https://github.com/jgarzik/python-bitcoinrpc>
cookie = get_cookie()
conn = AuthServiceProxy('http://' + cookie + '@' + URL)
assert conn.getblockchaininfo()['chain'] == 'test'
return conn
class ChainData:
RPC_USER = RPC_NODE["user"]
RPC_PASSWORD = RPC_NODE["password"]
RPC_SERVER = RPC_NODE["server"]
RPC_PORT = RPC_NODE["port"]
def __init__(self):
self.db1 = db.DataBase()
self.rpc_conn = AuthServiceProxy(
"http://%s:%s@%s:%s" %
(self.RPC_USER, self.RPC_PASSWORD, self.RPC_SERVER, self.RPC_PORT))
def get_blocks(self):
resp = self.rpc_conn.getblockchaininfo()
return resp["blocks"]
def get_headers(self):
resp = self.rpc_conn.getblockchaininfo()
return resp["headers"]
def get_blockhash(self, block):
resp = self.rpc_conn.getblockhash(block)
return resp
def _get_blocktransactions(self, block):
blockhash = self.get_blockhash(block)
resp = self.rpc_conn.getblock(blockhash, 2)
return resp["tx"], blockhash
def getblock_out_addresses(self, block):
txs, blockhash = self._get_blocktransactions(block)
count = 0
for tx in txs:
for iout in tx['vout']:
if iout.get("scriptPubKey") and iout.get("scriptPubKey").get(
"addresses"):
addresses = iout["scriptPubKey"]["addresses"]
for ad in addresses:
count += 1
self.db1.add_unique(ad)
class BtcRPC:
def __init__(self):
btcurl = "http://%s:%s@%s:%s" % (
os.getenv('BITCOIN_RPC_USER'), os.getenv('BITCOIN_RPC_PASS'),
os.getenv('BITCOIN_IP'), os.getenv('BITCOIN_RPC_PORT'))
self.connection = AuthServiceProxy(btcurl)
def connection_locked(self):
try:
response = self.connection.get_blockchain_info()
return True
except JSONRPCException:
return False
def get_blockchain_info(self):
response = self.connection.getblockchaininfo()
return response
def get_sync_progress(self):
response = self.connection.getblockchaininfo()
return response["verificationprogress"] * 100
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 init(options, configuration, plugin, **kwargs):
global lightning_rpc, bitcoin_rpc, rpc_settings
print(configuration)
# setup lightning rpc
lightning_dir, rpc_file = configuration['lightning-dir'], configuration['rpc-file']
path = Path(f"{lightning_dir}/{rpc_file}")
lightning_rpc = LightningRpc(str(path))
# setup bitcoin rpc
config = lightning_rpc.listconfigs()
rpc_settings['user'] = config['bitcoin-rpcuser']
rpc_settings['password'] = config['bitcoin-rpcpassword']
rpc_settings['port'] = config['bitcoin-rpcport']
rpc_settings['host'] = config['bitcoin-rpcconnect']
network = config['network']
template = "http://{user}:{password}@{host}:{port}"
uri = template.format(**rpc_settings)
bitcoin_rpc = AuthServiceProxy(uri)
# check that it works
bitcoin_rpc.getblockchaininfo()
def getpercentfin():
try:
# rpc_user and rpc_password are set in the bitcoin.conf file
rpc_connection = AuthServiceProxy("http://%s:%s@%s:8332" %
("user", "user", "192.168.2.100"))
best_block_hash = rpc_connection.getblockchaininfo()
if round(best_block_hash["blocks"] / best_block_hash["headers"] * 100,
2) == 100:
mineblock(rpc_connection.getblocktemplate())
except JSONRPCException:
print("You can't divide by zero, you're silly.")
return
async def info(self, ctx):
client = AuthServiceProxy(
f'http://{config.rpc_user}:{config.rpc_password}@{config.ip}:{config.rpc_port}'
)
user_id = str(ctx.author.id)
block = client.getblockchaininfo()['blocks']
hash_rate = round(client.getnetworkhashps() / 1000, 4)
difficulty = client.getblockchaininfo()['difficulty']
connection = client.getnetworkinfo()['connections']
client_version = client.getnetworkinfo()['subversion']
blockchain_size = round(
client.getblockchaininfo()['size_on_disk'] / 1000000000, 3)
embed = await utility.make_embed(ctx,
self.bot,
title="**Sugarchain info**",
color=0x0043ff)
embed.add_field(name="__Current block height__",
value="`{0}`".format(block),
inline=True)
embed.add_field(name="__Network hash rate__",
value="`{0} KH/s`".format(hash_rate),
inline=True)
embed.add_field(name="__Difficulty__",
value="`{0}`".format(difficulty),
inline=True)
embed.add_field(name="__Connection__",
value="`{0}`".format(connection),
inline=True)
embed.add_field(name="__Client Version__",
value="`{0}`".format(client_version),
inline=True)
embed.add_field(name="__Block chain size__",
value="`About {0} GB`".format(blockchain_size),
inline=True)
await ctx.channel.send(embed=embed)
def bitcoind():
# JSON-RPC connection to a bitcoind instance
try:
cookie = open(os.path.expanduser(AUTHFILE), 'rt').read().strip()
except FileNotFoundError:
raise pytest.skip('no local bitcoind')
# see <https://github.com/jgarzik/python-bitcoinrpc>
conn = AuthServiceProxy('http://' + cookie + '@' + URL)
assert conn.getblockchaininfo()['chain'] == 'test'
return conn
def update_bitcoin_main_info():
global bitcoin_block_height
global mynode_block_height
global bitcoin_blockchain_info
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=120)
# Basic Info
bitcoin_blockchain_info = rpc_connection.getblockchaininfo()
if bitcoin_blockchain_info != None:
bitcoin_block_height = bitcoin_blockchain_info['headers']
mynode_block_height = bitcoin_blockchain_info['blocks']
except Exception as e:
print "ERROR: In update_bitcoin_info - {}".format( str(e) )
return False
return True
def rpcinfo_from_node():
try:
rpc_connection = AuthServiceProxy(
"http://%s:%s@%s:%s" %
(rpc_user, rpc_password, rpc_host, rpc_port),
timeout=120)
mining_info = rpc_connection.getmininginfo()
mempool_info = rpc_connection.getmempoolinfo()
blockchain_info = rpc_connection.getblockchaininfo()
mempool_usage = mempool_info["usage"]
mempool_minfee = mempool_info["mempoolminfee"]
mempool_size = str(mempool_usage / (1024 * 1024))
satfee = str(int(mempool_minfee * 100000000))
block_height = str(blockchain_info["blocks"])
except:
mempool_usage = "?"
mempool_minfee = "?"
mempool_size = "?"
satfee = "?"
block_height = "?"
scroll_message("RPC ERROR")
scroll_message("CHECK VARIABLES")
return mempool_usage, mempool_minfee, mempool_size, satfee, block_height
async def on_message(self, message):
split_msg = message.content.split(' ')
if message.channel.id == self.reset_channel_id:
self.time_last_block = datetime.datetime.now()
return
if split_msg[0] == '!info':
msg = INFO_MESSAGE_TEMPLATE
network_hashrate = 1
pool_hashrate = 1
async with aiohttp.get(
'https://garli.co.in/api/getnetworkhashps') as r:
if r.status == 200:
data = await r.text()
network_hashrate = round(float(data) / 1e9, 2)
msg = msg.replace('[network_hashrate]',
str(network_hashrate))
else:
self.RequestError('Error retreiving network hashrate')
return
access = AuthServiceProxy(JSON_RPC_ADDRESS)
blockchain_info = access.getblockchaininfo()
msg = msg.replace('[block_height]', str(blockchain_info['blocks']))
msg = msg.replace('[difficulty]',
str(round(blockchain_info['difficulty'], 2)))
async with aiohttp.get(FRESHGRLC_API_ADDRESS +
'/poolstats/noheights') as r:
if r.status == 200:
data = await r.json()
pool_hashrate = round(
float(data['averageHashrate']) / 1e9, 2)
msg = msg.replace('[pool_hashrate]', str(pool_hashrate))
msg = msg.replace('[workers]', str(data['workers']))
else:
self.RequestError(
'Error retreiving pool pool hashrate and worker count')
return
msg = msg.replace(
'[percentage]',
str(round(pool_hashrate / network_hashrate * 100, 2)))
async with aiohttp.get(FRESHGRLC_API_ADDRESS + '/luck') as r:
if r.status == 200:
data = await r.json()
luck_array = []
for blocks in data:
luck_array.append(blocks['luck'])
avg_luck = round(statistics.mean(luck_array) * 100, 2)
msg = msg.replace('[avg_luck]', str(avg_luck))
else:
self.RequestError('Error retreiving pool pool luck')
return
time_diff = datetime.datetime.now() - self.time_last_block
time_since = str(time_diff)
time_since = time_since[:time_since.find('.')]
msg = msg.replace('[time_since]', time_since)
embed = discord.Embed()
embed.set_author(name='Fresh Garlic Blocks Info')
embed.description = msg
embed.color = discord.Color(0xffa517)
await self.send_message(message.channel, embed=embed)
return
if split_msg[0] == '!cmc':
coin_id = 'garlicoin'
if len(split_msg) > 1:
if bool(re.match('^[a-zA-Z0-9_-]+$', split_msg[1])):
coin_id = split_msg[1]
else:
# No message if an invalid coin is specified.
return
msg = CMC_MESSAGE_TEMPLATE
async with aiohttp.get(
'https://api.coinmarketcap.com/v1/ticker/%s/' %
coin_id) as r:
if r.status == 200:
data = await r.json()
coin = data[0]
for prop in coin:
msg = msg.replace('[%s]' % prop, str(coin[prop]))
else:
raise self.RequestError('Error retreiving coin properties')
return
coin_icon = await self.get_coin_icon(coin_id)
if coin_icon is None:
coin_icon = discord.Embed.Empty
embed = discord.Embed()
embed.set_author(name='%s | CoinMarketCap' % coin['name'],
url=self.coin_url(coin_id),
icon_url=coin_icon)
embed.description = msg
embed.color = discord.Color(0xffa517)
await self.send_message(message.channel, embed=embed)
return
if split_msg[0] == '!myinfo':
msg = WORKER_INFO_MESSAGE_TEMPLATE
try:
user = self.users[str(message.author)]
msg = msg.replace('[address]', user['address'])
async with aiohttp.get(
'https://garlicinsight.com/insight-grlc-api/addr/' +
user['address']) as r:
if r.status == 200:
data = await r.json()
balance = data['balance']
msg = msg.replace('[balance]', str(balance))
else:
self.RequestError('Error retreiving worker balance')
return
async with aiohttp.get(FRESHGRLC_API_ADDRESS + '/workerinfo/' +
user['address']) as r:
if r.status == 200:
data = await r.json()
expected_payout = data['nextpayout']['grlc']
worker_hashrate = data['hashrate']
worker_percentage = round(
data['nextpayout']['percentage'], 2)
if worker_hashrate is None:
worker_hashrate = 0
else:
worker_hashrate = round(
float(worker_hashrate) / 1e6, 2)
msg = msg.replace('[expected_payout]',
str(expected_payout))
msg = msg.replace('[worker_hashrate]',
str(worker_hashrate))
msg = msg.replace('[worker_percentage]',
str(worker_percentage))
else:
self.RequestError(
'Error retreiving worker information')
return
except KeyError:
msg = ADDRESS_SET_ERROR_MESSAGE
embed = discord.Embed()
embed.set_author(name=message.author.display_name + "'s Info")
embed.description = msg
embed.color = discord.Color(0xffa517)
await self.send_message(message.channel, embed=embed)
return
if split_msg[0] == '!register':
address = split_msg[1]
access = AuthServiceProxy(JSON_RPC_ADDRESS)
if len(split_msg) > 1 and access.validateaddress(
address)['isvalid']:
self.users[str(message.author)] = {'address': address}
db_shelve = shelve.open('db')
db_shelve['users'] = self.users
db_shelve.close()
embed = discord.Embed()
embed.set_author(name=message.author.display_name +
' Registered')
embed.description = 'You are now registered! Use`!myinfo` to see information about yourself!'
embed.color = discord.Color(0xffa517)
await self.send_message(message.channel, embed=embed)
return
class UsdtWallet():
USDT_BLOCK_NUM = 'http://www.tokenview.com:8088/coin/latest/USDT'
USDT_TX_API = 'https://api.omniexplorer.info/v1/transaction/address'
USDT_URL_BALANCE = 'https://api.omniexplorer.info/v1/address/addr/'
def __init__(self, consul_client=None):
if consul_client:
self.init_consul(consul_client)
def init_consul(self, app, consul_client):
self.propertyid = 31
# self.usdt_rpc_user = app.config["USDT_RPC_USER"]
# self.usdt_rpc_password = app.config["USDT_RPC_PWD"]
# self.usdt_passphrase = app.config.get('GETH_USDT_PASSPHRASE')
# self.consul_client = consul_client
# # self.wallet_url = self.consul_client.getRandomOneAvailableServiceIpPort(ConsulServiceName.USDTEREUM_CLI)
# self.wallet_url = '47.52.131.71:7332'
# print(self.wallet_url)
# self.usdtcoin_cli = AuthServiceProxy(
# "http://%s:%s@" % (self.usdt_rpc_user, self.usdt_rpc_password) + self.wallet_url, timeout=10)
# if not self.is_connected():
# logging.error('Connect USDT wallet node fial')
self.usdtcoin_cli = AuthServiceProxy("http://%s:%[email protected]:7332" %
('xianda', 'ABQOqmPZ0tr95f5Z'))
def is_connected(self):
"""获取钱包状态判读是否链接"""
try:
if self.usdtcoin_cli.getwalletinfo().get('walletversion'):
return True
return False
except Exception as e:
return False
def is_syncing(self):
"""节点是否在同步中"""
# 注意返回Flase表示节点同步完成
info = self.usdtcoin_cli.getblockchaininfo()
# print(info['blocks'], info['headers'])
if info['blocks'] != info['headers']:
return False
else:
return True
def accountCreate(self, accountName):
# 否则，创建账户，并返回账户地址
address = self.usdtcoin_cli.getaccountaddress(accountName)
privateKey = self.usdtcoin_cli.dumpprivkey(address)
return privateKey, address
# 檢驗賬戶是否有效
def is_valid_address(self, address):
if address is None or address == '':
return False
else:
try:
# print(self.usdtcoin_cli.validateaddress(address))
return self.usdtcoin_cli.validateaddress(address).get(
'isvalid')
except:
return False
# 獲取餘額
def get_balance(self, address):
"""获取余额,默认最新区块"""
try:
balance = str(
self.usdtcoin_cli.omni_getbalance(address,
self.propertyid)['balance'])
except Exception as e:
logging.error('USDT node get balance error:{}'.format(str(e)))
raise Exception('USDT node get balance error')
return Decimal(balance)
def get_block_num(self):
"""获取最新区块数"""
try:
block_num = self.usdtcoin_cli.getblockcount()
except Exception as e:
logging.error('Get eth node block number error:{}'.format(str(e)))
return
return block_num
def get_nonce(self, address):
"""获取账户nonce值"""
try:
# pending 获得最新已使用的nonce,对nonce进行加1
nonce = len(
self.usdtcoin_cli.omni_listpendingtransactions(address))
except Exception as e:
logging.error('USDT node get balance error:{}'.format(str(e)))
raise Exception('USDT node get balance error')
return nonce
def get_mian_block_num(self):
"""获取公链上的最新区块数"""
try:
header = {
'User-Agent':
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.75 Safari/537.36',
}
ret = session_pool.get(self.USDT_BLOCK_NUM,
headers=header,
timeout=30).json()
if ret is None:
logging.error('Get usdt main chain block number error')
return
block_num = ret.get('data')
except Exception as e:
logging.error(
'Get usdt main chain block number error:{}'.format(e))
return
return block_num # int
def get_minerFee(self, address):
data = {'addr': address}
try:
balance = None
rets = session_pool.post(self.USDT_URL_BALANCE,
data=data,
timeout=50).json().get('balance')
if rets or len(rets) != 0:
for ret in rets:
if ret.get('propertyinfo') and int(
ret.get('propertyinfo').get('propertyid')) == 0:
balance = ret.get('value')
except Exception as e:
logging.error(
'Request USDT_TX_API error address:{},error:{},url:{}'.format(
address, str(e), self.USDT_TX_API))
raise Exception('USDT node get balance error')
return Decimal(balance) / 100000000
def usdt_transaction_record(self,
address,
last_timestamp,
start_block=None,
end_block=None):
"""查询账户交易记录"""
if start_block is None:
start_block = 0
if end_block is None:
end_block = 99999999
# 可能会有重复记录，使用此方法
run_function = lambda x, y: x if y in x else x + [y]
data = {'addr': address, 'page': 0}
try:
rets = session_pool.post(self.USDT_TX_API, data=data,
timeout=50).json()
except Exception as e:
logging.error(
'Request USDT_TX_API error address:{},error:{},url:{}'.format(
address, str(e), self.USDT_TX_API))
rets = None
new_records = []
ret = rets.get('transactions')
if ret is None:
return new_records
ret_page_num = int(rets.get('pages'))
if ret_page_num == 1:
# print(ret_page_num)
self.query_records(address, ret, new_records, last_timestamp,
start_block, end_block)
return (reduce(run_function, [
[],
] + new_records))
else:
for i in range(0, ret_page_num):
data = {'addr': address, 'page': i}
try:
ret = session_pool.post(
self.USDT_TX_API, data=data,
timeout=50).json().get('transactions')
except Exception as e:
logging.error(
'Request USDT_TX_API error address:{},error:{},url:{}'.
format(address, str(e), self.USDT_TX_API))
ret = None
if ret is None:
return new_records
self.query_records(address, ret, new_records, last_timestamp,
start_block, end_block)
return (reduce(run_function, [
[],
] + new_records))
def query_records(self, address, records, new_records, last_timestamp,
start_block, end_block):
for record in records:
propertyid = record.get('propertyid')
valid = record.get('valid')
block = record.get('block')
if valid and int(propertyid) == 31 and int(start_block) <= int(
block) and int(block) <= int(end_block):
to_address = record['referenceaddress'] # 是否为收款记录
current_timestamp = int(record['blocktime']) # 当前记录时间戳
confirmations = int(record['confirmations']) # 交易记录确认数
record_hash = record['txid']
amount = Decimal(record['amount'])
if to_address.lower() != address.lower():
continue
if int(last_timestamp) > int(current_timestamp):
continue
if Order.hash_is_exist(record_hash):
continue
if amount < Decimal('0.0000001'):
continue
if confirmations < 2:
break
else:
new_records.append(record)
else:
if records is None:
logging.error(
'Request USDT_TX_API fail address:{} ret:{}, url:{}'.
format(address, str(records), self.USDT_TX_API))
return new_records
def hash_get_detail(self, tx_hash):
"""hash获取交易细节,用于确认链外交易是否被确认"""
# 交易是否被确认.status=1(被确认)
is_confirm = False # 是否确认
is_success = False # 如果已确认,交易是否成功
msg = None # 未被确认返回异常信息(一般超时),确认失败:失败的细节,确认成功:交易详情
fee = None # 确认成功交易的手续费
try:
ret = self.usdtcoin_cli.omni_gettransaction(tx_hash) # 获取交易细节
except Exception as e:
msg = str(e)
return is_confirm, is_success, msg, fee
confirm = ret.get('confirmations')
if confirm < 1: # 确认交易失败
msg = dict(fail_detail=str(ret))
return is_confirm, is_success, msg, fee
else: # 确认交易成功
is_confirm = True
is_success = True
fee = ret.get('fee')
msg = dict(confirm=str(ret), tx_detail=str(ret))
return is_confirm, is_success, msg, fee
def payment(self, addrfrom, addrto, amount):
"""普通付款"""
# 单位换算
payload = {'from': addrfrom, 'to': addrto, 'value': str(amount)}
try:
# 钱包转账,返回交易哈希值
tx_hash = self.usdtcoin_cli.omni_send(addrfrom, addrto,
self.propertyid, str(amount))
return True, tx_hash
except Exception as e:
payload.update(dict(errormsg=str(e)))
logging.error('usdt payment error:{}'.format(str(payload)))
return False, str(e)
def raw_transaction(self, minerfee_address, fromAddr, toAddre, value,
miner_minfee):
# 查询USDT未使用的UTXO
USDT_unspents = self.usdtcoin_cli.listunspent(1, 9999999, [fromAddr])
if not USDT_unspents:
return False, str('No USDT UTXO model available')
USDT_unspent = USDT_unspents[0]
# 查询BTC未使用的UTXO(矿工费)
BTC_unspents = self.usdtcoin_cli.listunspent(1, 9999999,
[minerfee_address])
if not BTC_unspents:
return False, str('No BTC UTXO model available')
BTC_unspent = BTC_unspents[0]
# 所用值
from_txid = USDT_unspent['txid']
from_scriptPubKey = USDT_unspent['scriptPubKey']
from_vout = USDT_unspent['vout']
from_amount = USDT_unspent['amount']
to_txid = BTC_unspent['txid']
to_scriptPubKey = BTC_unspent['scriptPubKey']
to_vout = BTC_unspent['vout']
to_amount = BTC_unspent['amount']
rawtransactionparams = [
dict(txid=from_txid,
scriptPubKey=from_scriptPubKey,
vout=from_vout),
dict(txid=to_txid, scriptPubKey=to_scriptPubKey, vout=to_vout),
]
# 创建原生BTC交易获取哈希值
RawTxChangeparams = [
# 转出地址必须放在第一个，矿工费地址放在下面
dict(txid=from_txid,
scriptPubKey=from_scriptPubKey,
vout=from_vout,
value=from_amount),
dict(txid=to_txid,
scriptPubKey=to_scriptPubKey,
vout=to_vout,
value=to_amount),
]
# 构造发送代币类型和代币数量数据
payload = self.usdtcoin_cli.omni_createpayload_simplesend(
self.propertyid, str(value))
print('usdt交易', payload)
# 构造交易基本数据
data = {}
btc_txid = self.usdtcoin_cli.createrawtransaction(
rawtransactionparams, data)
# 在交易上绑定代币数据
rawtx = self.usdtcoin_cli.omni_createrawtx_opreturn(btc_txid, payload)
print('usdt交易绑定到btc交易的哈希', rawtx)
# 在交易上添加接收地址
rawtx = self.usdtcoin_cli.omni_createrawtx_reference(rawtx, toAddre)
print('添加接受地址', rawtx)
# 在交易数据上指定矿工费用
rawtx = self.usdtcoin_cli.omni_createrawtx_change(
rawtx, RawTxChangeparams, minerfee_address, Decimal(miner_minfee))
print('设置手续的哈希', rawtx)
# 签名
ret = self.usdtcoin_cli.signrawtransaction(rawtx)
if not ret['complete']:
return False, str('Incomplete signature')
# 广播
tx_hash = self.usdtcoin_cli.sendrawtransaction(ret['hex'])
print('交易哈希', tx_hash)
if tx_hash:
return True, tx_hash
class BtcWallet():
"""btc钱包"""
BTC_BLOCK_API = 'https://blockchain.info/'
def __init__(self, app=None, consul_client=None):
if app and consul_client:
self.init_consul(app, consul_client)
def init_consul(self, app, consul_client):
try:
rpc_user = app.config.get('CONFIG_BITCOIND_RPC_USER')
rpc_pwd = app.config.get('CONFIG_BITCOIND_RPC_PASSWORD')
wallet_passphrase = app.config.get('CONFIG_BITCOIND_WALLET_PASSWORD')
self.ipport = consul_client.getRandomOneAvailableServiceIpPort(ConsulServiceName.BTC_CLI)
# s = "http://%s:%s@" % (self.user, self.pwd) + self.ipport
# print(s)
self.bitcoin_cli = AuthServiceProxy(
"http://%s:%s@" % (rpc_user, rpc_pwd) + self.ipport, timeout=10)
print("Succeed to connect to the BTC node")
except Exception as e:
print(str(e))
print("Failed to connect to the BTC node")
# 是否连接BTC节点
def is_connected(self):
try:
if self.bitcoin_cli.getwalletinfo().get('walletversion'):
return True
return False
except Exception as e:
print(str(e))
print("Failed to connect to the BTC node")
# 节点是否同步
def is_sync(self):
ret = self.bitcoin_cli.getblockchaininfo()
if ret.get('blocks') != ret.get("headers"):
return False
else:
return True
# btc地址是否有效
def is_valid_address(self, coin_address):
if coin_address is None or coin_address == '':
return False
else:
ret = self.bitcoin_cli.validateaddress(coin_address).get('isvalid')
print('账户检查结果:', ret)
return ret
# return self.bitcoin_cli.validateaddress(coin_address).get('isvalid')
# 获取账户余额, 默认经过6个区块确认
def get_balance(self, coin_address):
transaction_lists = self.bitcoin_cli.listunspent(1, 99999999, [coin_address])
print(transaction_lists)
current_amount = 0
for transaction_list in transaction_lists:
amount = transaction_list.get('amount')
amount = float(amount)
current_amount += amount
return current_amount
def get_balance_by_account(self, account):
try:
ret = self.bitcoin_cli.getbalance(account)
return ret
except Exception as e:
logging.error('get balance error:{}'.format(str(e)))
return None
def estimate_fee(self):
try:
fee = self.bitcoin_cli.estimatefee(6)
return fee
except Exception as e:
logging.error('get fee error:{}'.format(str(e)))
return None
def create_account(self, stellar_account):
# private = random_key()
# address = pubtoaddr(privtopub(private))
# print(address, private)
# return address, private
address = self.bitcoin_cli.getnewaddress(stellar_account)
private_key = self.bitcoin_cli.dumpprivkey(address)
return address, private_key
def get_block_num(self):
"""获取最新区块数"""
try:
block_num = self.bitcoin_cli.getblockcount()
return block_num
except Exception as e:
logging.error('Get btc node block number error:{}'.format(str(e)))
return None
def get_chain_info(self):
ret = self.bitcoin_cli.getblockchaininfo()
return ret
def get_block_info(self, block_num):
"""获取区块的详细信息"""
param = "block-height/{}?format=json".format(block_num)
api_url = self.BTC_BLOCK_API + param
# print(api_url)
blocks = requests.get(api_url, timeout=500).json()
# print(type(blocks))
return blocks
# 链外转帐,普通交易
def payment(self, btc_base_account, address_to, amount):
try:
txid = self.bitcoin_cli.sendfrom(btc_base_account, address_to, amount)
return True, txid
except Exception as e:
logging.error('btc payment error:{}'.format(str(e)))
return False, str(e)
def hash_get_detail(self, tx_id):
"""
Arguments:
1. "txid" (string, required) The transaction id
"""
# 根据txid获取确认链外交易信息
ret = self.bitcoin_cli.gettransaction(tx_id)
abandoned = ret.get("details")[0].get("abandoned") # 获取abandon信息
confirmation_num = ret.get('confirmations') # 获取确认数
# 如果确认数小于1，则未确认
if confirmation_num < 1:
msg = dict(confirm=str(ret))
# msg = ret.get("details")[0]
return False, False, msg, None
# 如果确认数大于1，则确认
else:
msg = dict(confirm=str(ret))
# msg = ret
fee = abs(ret.get("fee"))
if abandoned:
return True, False, msg, None
else:
return True, True, msg, fee
def raw_payment(self, address_from, address_to, collect_amount):
inputs = []
# 获取地址余额信息
try:
unspend_lists = self.bitcoin_cli.listunspent(1, 9999999, [address_from])
for unspend_list in unspend_lists:
# if unspend_list.get('amount') <= 0:
# continue
# else:
txid = unspend_list.get('txid')
vout = unspend_list.get('vout')
inputs.append({'txid': txid, 'vout': vout})
outputs = {address_to: round(collect_amount, 8)}
# 交易建立和签名时不用连接比特币网络,只有在执行交易时才需要将交易发送到网络
# 创建裸交易
transaction_hash = self.bitcoin_cli.createrawtransaction(inputs, outputs)
# 使用私钥签名,获取16进制信息
hex = self.bitcoin_cli.signrawtransaction(transaction_hash).get('hex')
# 广播到p2p网络,返回交易哈希
trading_hash = self.bitcoin_cli.sendrawtransaction(hex, False)
return True, trading_hash, ''
except Exception as e:
print(e)
return None, None, ''
def btc_transaction_record(self, block_num):
# 获取某一区块信息
block_info = self.get_block_info(block_num)
blocks = block_info.get('blocks')
txs = blocks[0].get('tx')
records = []
for tx in txs:
outs = tx.get('out')
hash = tx.get('hash')
inputs = tx.get('inputs')
p_out = inputs[0].get('prev_out')
if not p_out:
continue
else:
addr_from = p_out.get('addr')
for out in outs:
re = []
addr_to = out.get('addr')
value = out.get('value') / (10 ** 8)
# addr_to与User表中绑定的地址进行对比，如果有，则说明此address_to有冲币记录
user = User.address_query_user('BTC', addr_to)
if not user:
continue
else:
re.append(addr_from)
re.append(addr_to)
re.append(value)
re.append(hash)
records.append(re)
return records
def get_accounts(self, addr):
try:
ad = self.bitcoin_cli.getaccount(addr)
return ad
except Exception as e:
# logging.error('get btc_account error:{}'.format(str(e)))
return None
def get_address_byaccount(self, account):
re = self.bitcoin_cli.getaddressesbyaccount(account)
return re
def test1(self):
transaction_list = self.bitcoin_cli.listaccounts()
# transaction_list = self.bitcoin_cli.getwalletinfo()
print(transaction_list)
from bitcoinrpc.authproxy import AuthServiceProxy
import simplejson as json
for x in range(1, 4):
access = AuthServiceProxy("http://*****:*****@172.17.0." + str(x + 1) +
":18332")
blockbesthash = access.getbestblockhash()
blockbest = access.getblock(blockbesthash)
#Affiche la hauteur du dernier block présent dans chaque noeuds
print("node n:" + str(x) + " " + str(blockbest["height"]))
#Affichage des informations du dernier noeud
print json.dumps(access.getmininginfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getpeerinfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getnetworkinfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getblockchaininfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getrawmempool(), indent=4, separators=(',', ': '))
class BitcoinClient(object):
"""Bitcoin client class"""
# Handler for Bitcoin connection
connection = None
network_info = None
blockchain_info = None
wallet_info = None
def __init__(self):
self.user = os.environ["BITCOIN_USER"]
self.password = os.environ["BITCOIN_PASSWORD"]
self.host = os.environ["BITCOIN_HOST"]
self.port = int(os.environ["BITCOIN_PORT"])
self.connection = AuthServiceProxy(
"http://%s:%s@%s:%i" %
(self.user, self.password, self.host, self.port))
def info(self):
# Use following links for reference:
# https://chainquery.com/bitcoin-api/getblockchaininfo
# https://chainquery.com/bitcoin-api/getnetworkinfo
# https://chainquery.com/bitcoin-api/getwalletinfo
self.blockchain_info = self.connection.getblockchaininfo()
self.network_info = self.connection.getnetworkinfo()
self.wallet_info = self.connection.getwalletinfo()
accounts = []
for acc in self.connection.listaccounts(0):
if len(acc) > 0:
accounts.append(acc)
# new_address = self.new_address()
# new_address_valid = self.validate_address(new_address)
# new_address_pk = self.get_private_key(new_address)
# New address: "miC9oPat2xrtDstticmrw2YM7UUN9A6jcn"
# New address private key: "cNci511KkyyU8GqMdZVxv1NxMbUMKqjo75PAQNdBFGgzbD7W8gZm"
# valid_bitcoin_address = '134dV6U7gQ6wCFbfHUz2CMh6Dth72oGpgH'
# addr = Address(self, valid_bitcoin_address)
data_hash = {
"blocks": int(self.blockchain_info["blocks"]),
"headers": int(self.blockchain_info["headers"]),
"bestblockhash": self.blockchain_info["bestblockhash"],
"difficulty": float(self.blockchain_info["difficulty"]),
"accounts": accounts,
"account_addresses": self.connection.getaddressesbyaccount(""),
# "new_address": str(self.new_account('Trololo')),
# "new_address": new_address,
# "new_address_valid": new_address_valid,
# "new_address_pk": new_address_pk,
# "valid_address_balance": addr.balance(),
}
return data_hash
def balance(self):
"""Overall balance of current wallet
Returns:
(int) balance in satoshis
"""
balance = float(self.connection.getbalance())
# return balance
return int(balance * SATOSHI)
def new_address(self):
"""Generate new address"""
return self.connection.getnewaddress()
def get_private_key(self, address):
"""Fetch private key of specific address owned by you.
Keyword arguments:
address -- address (public key) to fetch from
"""
return self.connection.dumpprivkey(address)
def validate_address(self, address):
"""Check that address is valid on Blockchain.
Keyword arguments:
address -- address (public key) to validate
"""
result = self.connection.validateaddress(address)
if "isvalid" in result:
return result["isvalid"]
return False
def new_account(self, name):
"""Generate new account and address.
Keyword arguments:
name -- name of the account, not stored in the blockchain
"""
return self.connection.getnewaddress(name)
def generate_blocks(self, amount):
"""Generate some blocks. Availabe only in Regtest mode.
Keyword arguments:
amount -- number of blocks to generate
"""
return self.connection.generate(amount)
def lock_wallet(self):
"""Lock current wallet."""
return self.connection.walletlock()
def unlock_wallet(self, passphrase=None, seconds=60):
"""Unlock current wallet with a passphase.
Keyword arguments:
passphrase -- the passphrase that unlocks the wallet
seconds -- the number of seconds after which the decryption key will be automatically deleted from memory
"""
if not passphrase:
passphrase = os.environ["BITCOIN_WALLET_PASSPHRASE"]
return self.connection.walletlock(passphrase, seconds)
def change_wallet_passphrase(self,
old_passphrase=None,
new_passphrase=None):
"""Set passphrase for current wallet.
Keyword arguments:
old_passphrase -- old passphrase that unlocks the wallet
new_passphrase -- new passphrase that unlocks the wallet
"""
if not old_passphrase:
old_passphrase = ''
if not new_passphrase:
new_passphrase = os.environ["BITCOIN_WALLET_PASSPHRASE"]
return self.connection.walletpassphrasechange(old_passphrase,
new_passphrase)
def send(self, from_addr, to_addr, amount):
"""Send funds from address to address. Returns transaction ID.
Keyword arguments:
from_addr -- address (public key) we're sending funds from
to_addr -- address (public key) we're sending funds to
amount -- (float) amount of bitcoins to send
"""
return self.connection.sendfrom(from_addr, to_addr, amount)
if sys.platform == 'win32':
command_sign_publish = ['"%s"' % param for param in command_sign_publish]
# Initialize rpc connection
rpc_auth, rpc_timeout = initRpc(namecoin_location + "namecoin.conf")
rpc = AuthServiceProxy(rpc_auth, timeout=rpc_timeout)
node_version = rpc.getnetworkinfo()['version']
while 1:
try:
time.sleep(1)
if node_version < 160000:
last_block = int(rpc.getinfo()["blocks"])
else:
last_block = int(rpc.getblockchaininfo()["blocks"])
break # Connection succeeded
except socket.timeout: # Timeout
print ".",
sys.stdout.flush()
except Exception, err:
print "Exception", err.__class__, err
time.sleep(5)
rpc = AuthServiceProxy(rpc_auth, timeout=rpc_timeout)
if not config[
"lastprocessed"]: # First startup: Start processing from last block
config["lastprocessed"] = last_block
print "- Testing domain parsing..."
assert processBlock(223911, test=True) # Testing zeronetwork.bit
from bitcoinrpc.authproxy import AuthServiceProxy
import simplejson as json
for x in range(1, 4):
access = AuthServiceProxy("http://*****:*****@172.17.0."+str(x+1)+":18332")
blockbesthash = access.getbestblockhash()
blockbest = access.getblock(blockbesthash)
#Affiche la hauteur du dernier block présent dans chaque noeuds
print ("node n:"+str(x)+" "+str(blockbest["height"]))
#Affichage des informations du dernier noeud
print json.dumps(access.getmininginfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getpeerinfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getnetworkinfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getblockchaininfo(), indent=4, separators=(',', ': '))
print json.dumps(access.getrawmempool(), indent=4, separators=(',', ': '))
