def monitoring_peers():
# set bot
bot = bot_start()
try:
# list of available peers
rpc_peers = peers_ip()
# remote peer peers list
remote_peers = reference_peers()
# check in the list of available peers
for peer in peer_list:
if (peer not in rpc_peers and peer not in remote_peers):
# check peers from nanocrawler.cc
http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',
ca_certs=certifi.where())
response = http.request('GET',
peers_url,
headers=header,
timeout=10.0)
json_data = json.loads(response.data)
json_peers = json_data['peers']
if (peer not in json_peers
and '::ffff:{0}'.format(peer) not in json_peers):
# Warning to admins
for user_id in admin_list:
push(bot, user_id,
'Peer *{0}* is offline'.format(peer))
except AttributeError as e:
for user_id in admin_list:
push(bot, user_id, 'Peers list is empty!')
def frontiers():
time_start = int(time.time())
# set bot
bot = bot_start()
# list from MySQL
accounts_list_orig = mysql_select_accounts_list()
accounts_list_extra = mysql_select_accounts_list_extra()
accounts_list = accounts_list_orig + accounts_list_extra
# list from node
frontiers = rpc({
"action": "wallet_frontiers",
"wallet": wallet
}, 'frontiers', True)
frontiers_old = json.loads(mysql_select_frontiers())
mysql_set_frontiers(json.dumps(frontiers))
for account in accounts_list:
try:
frontier = frontiers[account[1]]
frontier_old = frontiers_old[account[1]]
if ((account[2] != frontier) and (frontier == frontier_old)):
# update frontier
try:
z = account[5]
account_mysql = mysql_select_by_account_extra(account[1])
if (account[2] == account_mysql[2]): # no changes in MySQL
mysql_update_frontier_extra(account[1], frontier)
else:
account = account_mysql
except IndexError as e:
account_mysql = mysql_select_by_account(account[1])
if (account[2] == account_mysql[2]): # no changes in MySQL
mysql_update_frontier(account[1], frontier)
else:
account = account_mysql
# check if balance changed
balance = account_balance(account[1])
logging.info('{0} --> {1} {2}'.format(mrai_text(account[3]),
mrai_text(balance),
frontier))
#print(balance)
if (int(account[3]) < balance):
receive_messages(bot, account, balance)
# no frontier. No transactions
except KeyError as e:
# doesn't exist
x = 0 # do something
time_end = int(time.time())
total_time = time_end - time_start
#print(total_time)
if (total_time > 15):
logging.warning(
('WARNING!!! \nMore than 15 seconds execution time!!!'))
return total_time
def frontiers_sendlist():
bot = bot_start()
sendlist = mysql_select_sendlist()
for send in sendlist:
time.sleep(5) # if long push to user
sendlist_new = mysql_select_sendlist()
if (send in sendlist_new):
try:
push(bot, send[0], send[1].replace("_", "\_"))
logging.warning('NoCallback From sendlist: {0} :: {1}'.format(
send[0], send[1]))
except Exception as e:
logging.warning(
'NoCallback From sendlist + exception: {0} :: {1}'.format(
send[0], send[1]))
logging.error(e)
mysql_delete_sendlist(send[0])
def monitoring_block_count():
# set bot
bot = bot_start()
count = int(rpc({"action": "block_count"}, 'count'))
reference_count = int(reference_block_count())
http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',
ca_certs=certifi.where())
try:
response = http.request('GET',
nanocrawler_url,
headers=header,
timeout=20.0)
json_data = json.loads(response.data)
nanocrawler_count = int(json_data['send']) + int(
json_data['receive']) + int(json_data['open']) + int(
json_data['change']) + int(json_data['state'])
except (ValueError, urllib3.exceptions.ReadTimeoutError,
urllib3.exceptions.MaxRetryError) as e:
nanocrawler_count = reference_count
difference = int(math.fabs(nanocrawler_count - count))
try:
response = http.request('GET',
block_count_url,
headers=header,
timeout=20.0)
raiwallet_count = int(response.data)
except (urllib3.exceptions.ReadTimeoutError,
urllib3.exceptions.MaxRetryError) as e:
raiwallet_count = reference_count
if (difference > block_count_difference_threshold * 3):
# Warning admins
for user_id in admin_list:
push(
bot, user_id,
'Block count: {0}\nnanocrawler.cc: {1}\nDifference: *{2}*\nReference: {3}\nraiwallet.info: {4}'
.format(count, nanocrawler_count, difference, reference_count,
raiwallet_count))
# trying to fix
bootstrap_multi()
elif (difference > block_count_difference_threshold):
# trying to fix
bootstrap_multi()
def price_check():
bot = bot_start()
price = mysql_select_price()
# check if higher
users_high = mysql_select_price_high()
price_high_mercatox = max(int(price[0][0]), int(price[0][4]))
price_high_kucoin = max(int(price[3][0]), int(price[3][4]))
price_high_binance = max(int(price[5][0]), int(price[5][4]))
for user in users_high:
if ((price_high_mercatox >= int(user[1]))
and ((int(user[2]) == 0) or (int(user[2]) == 2))):
prices_above_below(bot, user[0], price_high_mercatox,
"Mercatox.com", 1)
elif ((price_high_kucoin >= int(user[1]))
and ((int(user[2]) == 0) or (int(user[2]) == 3))):
prices_above_below(bot, user[0], price_high_kucoin, "Kucoin.com",
1)
elif ((price_high_binance >= int(user[1]))
and ((int(user[2]) == 0) or (int(user[2]) == 4))):
prices_above_below(bot, user[0], price_high_binance, "Binance.com",
1)
# check if lower
users_low = mysql_select_price_low()
price_low_mercatox = min(int(price[0][0]), int(price[0][3]))
price_low_kucoin = min(int(price[3][0]), int(price[3][3]))
price_low_binance = min(int(price[5][0]), int(price[5][3]))
for user in users_low:
if ((price_low_mercatox <= int(user[1]))
and ((int(user[2]) == 0) or (int(user[2]) == 2))):
prices_above_below(bot, user[0], price_low_mercatox,
"Mercatox.com", 0)
elif ((price_low_kucoin <= int(user[1]))
and ((int(user[2]) == 0) or (int(user[2]) == 3))):
prices_above_below(bot, user[0], price_low_kucoin, "Kucoin.com", 0)
elif ((price_low_binance <= int(user[1]))
and ((int(user[2]) == 0) or (int(user[2]) == 4))):
prices_above_below(bot, user[0], price_low_binance, "Binance.com",
0)
async def websockets_receive():
async with websockets.connect(ws_url) as websocket:
bot = bot_start()
await websocket.send(
json.dumps(
subscription("confirmation",
options={
"include_election_info": "false",
"include_block": "true",
"all_local_accounts": "true"
},
ack=True)))
connect = json.loads(await websocket.recv()) # ack
print(connect)
logging.info(connect)
while 1:
rec = json.loads(await websocket.recv())
topic = rec.get("topic", None)
if topic:
item = rec["message"]
if topic == "confirmation":
item['type'] = item['block']['subtype']
if (item['type'] == 'receive' or item['type'] == 'change'
or item['type'] == 'epoch'):
balance = int(
math.floor(
int(item['block']['balance']) / (10**24)))
account_mysql = mysql_select_by_account(
item['account'])
extra = False
if (account_mysql is False):
account_mysql = mysql_select_by_account_extra(
item['account'])
extra = True
if (account_mysql[2] !=
item['hash']): # Compare frontiers
if (extra):
mysql_update_frontier_extra(
item['account'], item['hash'])
else:
mysql_update_frontier(item['account'],
item['hash'])
if (item['type'] == 'receive'): # Receive blocks
sender_account = rpc(
{
"action": "block_info",
"hash": item['block']['link']
}, 'block_account')
lang_id = mysql_select_language(
account_mysql[0])
#logging.info('{0} --> {1} {2}'.format(mrai_text(account_mysql[3]), mrai_text(balance), item['hash']))
sender = find_sender(item, account_mysql,
sender_account, balance,
lang_text)
received_amount = int(
math.floor(int(item['amount']) / (10**24)))
text = lang_text(
'frontiers_receive',
lang_id).format(mrai_text(received_amount),
mrai_text(balance),
mrai_text(0), item['hash'],
hash_url, sender)
try:
push(bot, account_mysql[0], text)
except BadRequest as e:
logging.exception(
'Bad request account {0}'.format(
account_mysql[0]))
logging.info(
'{0} Nano (XRB) received by {1}, hash: {2}'
.format(mrai_text(received_amount),
account_mysql[0], item['hash']))
#print(text)
# Large amount check
if (received_amount >= large_amount_warning):
time.sleep(0.1)
try:
push(
bot, account_mysql[0],
lang_text(
'frontiers_large_amount_warning',
lang_id))
except BadRequest as e:
logging.exception(
'Bad request account {0}'.format(
account_mysql[0]))
elif (item['type'] == 'change'): # Change blocks
logging.warning(
'Change block {0} for account {1}'.format(
item['hash'], item['account']))
if (balance != int(account_mysql[3])):
logging.error(
'Balance change: {0} --> {1}'.format(
mrai_text(balance),
mrai_text(int(account_mysql[3]))))
elif (item['type'] == 'epoch'): # Epoch blocks
logging.warning(
'Epoch block {0} for account {1}'.format(
item['hash'], item['account']))
if (balance != int(account_mysql[3])):
logging.error(
'Balance change: {0} --> {1}'.format(
mrai_text(balance),
mrai_text(int(account_mysql[3]))))
# Previous block check
previous_zero = (
item['block']['previous'] ==
'0000000000000000000000000000000000000000000000000000000000000000'
and account_mysql[2] is None)
if ((previous_zero is False)
and item['block']['previous'] !=
account_mysql[2]):
logging.error(
'Mismatch for previous block. Expected {0}, received {1}'
.format(account_mysql[2],
item['block']['previous']))
if (item['type'] == 'receive'):
time.sleep(0.1)
try:
push(
bot, account_mysql[0],
'Please check received block in explorer, you can receive notification for some older block'
)
except BadRequest as e:
logging.exception(
'Bad request account {0}'.format(
account_mysql[0]))
else:
logging.warning(
'Unexpected WebSockets message: {0}'.format(
json.dumps(item)))
def do_POST(self):
post_string = self.rfile.read(int(self.headers['Content-Length']))
post = json.loads(post_string)
#print(post)
self.send_response(200)
self.send_header('Content-Type', 'application/json')
self.end_headers()
# Return empty JSON
self.wfile.write('{}\n')
xrb_account = post['account']
account = mysql_select_by_account(xrb_account)
if (account is False):
account = mysql_select_by_account_extra(xrb_account)
if (account is not False):
block = json.loads(post['block'])
if ((block['type'] == 'state')
and (block['subtype'] == 'receive')):
bot = bot_start()
raw_received = int(post['amount'])
received_amount = int(math.floor(raw_received / (10**24)))
balance = account_balance(xrb_account)
try:
mysql_balance = int(account[3])
except Exception as e:
mysql_balance = 0
if (mysql_balance == balance): # workaround
logging.warning(
'Warning receive balance change. Old: {0}, new: {1}'.
format(mysql_balance, balance))
time.sleep(1)
balance = account_balance(xrb_account)
if (mysql_balance == balance):
time.sleep(8)
balance = account_balance(xrb_account)
# workaround
frontier = post['hash']
try:
z = account[5]
mysql_update_frontier_extra(account[1], frontier)
except IndexError as e:
mysql_update_frontier(account[1], frontier)
logging.info('{0} --> {1} {2}'.format(mrai_text(account[3]),
mrai_text(balance),
frontier))
# retrieve sender
send_source = block['link']
block_account = rpc(
{
"action": "block_account",
"hash": send_source
}, 'account')
lang_id = mysql_select_language(account[0])
sender = lang_text('frontiers_sender_account',
lang_id).format(block_account)
# Sender info
if (block_account == faucet_account):
sender = lang_text('frontiers_sender_faucet', lang_id)
elif ((block_account == fee_account)
or (block_account == welcome_account)):
sender = lang_text('frontiers_sender_bot', lang_id)
elif (block_account == account[1]):
sender = lang_text('frontiers_sender_self', lang_id)
else:
sender_account = mysql_select_by_account(block_account)
if (sender_account is not False):
if ((sender_account[4] is not None)
and (sender_account[4])):
sender = lang_text('frontiers_sender_username',
lang_id).format(
sender_account[4])
else:
sender = lang_text('frontiers_sender_users',
lang_id).format(block_account)
else:
sender_account_extra = mysql_select_by_account_extra(
block_account)
if (sender_account_extra is not False):
user_sender = mysql_select_user(
sender_account_extra[0])
if ((user_sender[8] is not None)
and (user_sender[8]) and
(account[0] != sender_account_extra[0])):
sender = lang_text('frontiers_sender_username',
lang_id).format(
user_sender[8])
elif (account[0] != sender_account_extra[0]):
sender = lang_text(
'frontiers_sender_users',
lang_id).format(block_account)
try:
z = account[5]
sender = lang_text('frontiers_sender_by', lang_id).format(
sender, account[1].replace("_", "\_"))
mysql_update_balance_extra(account[1], balance)
except IndexError as e:
mysql_update_balance(account[1], balance)
logging.info(sender)
logging.info(block_account)
logging.info(
'{0} Nano (XRB) received by {1}, hash: {2}'.format(
mrai_text(received_amount), account[0], frontier))
text = lang_text('frontiers_receive',
lang_id).format(mrai_text(received_amount),
mrai_text(balance),
mrai_text(0), frontier,
hash_url, sender)
mysql_set_sendlist(account[0], text)
#print(text)
try:
push(bot, account[0], text)
if (received_amount >= large_amount_warning):
time.sleep(0.25)
push(
bot, account[0],
lang_text('frontiers_large_amount_warning',
lang_id))
except BadRequest as e:
logging.exception('Bad request account {0}'.format(
account[0]))
mysql_delete_sendlist(account[0])
return