def move(prop, serial=None):
for file in prop.get_files():
filename = os.path.split(file)
push(
file,
'/sdcard/{tb}/{filename}'.format(tb=phone_dirs['titanium_backup'],
filename=filename), serial)
def frontiers_sendlist():
if (proxy_url is None):
bot = Bot(api_key)
else:
proxy = Request(proxy_url=proxy_url,
urllib3_proxy_kwargs={
'username': proxy_user,
'password': proxy_pass
})
bot = Bot(token=api_key, request=proxy)
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].encode("utf8")))
except Exception as e:
logging.warning(
'NoCallback From sendlist + exception: {0} :: {1}'.format(
send[0], send[1].encode("utf8")))
logging.error(e)
mysql_delete_sendlist(send[0])
def monitoring_block_count():
# set bot
bot = Bot(api_key)
count = int(rpc({"action": "block_count"}, 'count'))
reference_count = int(reference_block_count())
http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',
ca_certs=certifi.where())
response = http.request('GET', summary_url, timeout=20.0)
try:
json_data = json.loads(response.data)
community_count = int(json_data['blocks'])
except ValueError as e:
community_count = reference_count
difference = int(math.fabs(community_count - count))
response = http.request('GET', block_count_url, timeout=20.0)
raiwallet_count = int(response.data)
if (difference > block_count_difference_threshold):
# Warning to admins
for user_id in admin_list:
push(
bot, user_id,
'Block count: {0}\nCommunity: {1}\nDifference: *{2}*\nReference: {3}\nraiwallet.info: {4}'
.format(count, community_count, difference, reference_count,
raiwallet_count))
# trying to fix
bootstrap_multi()
def monitoring_block_count():
# set bot
if (proxy_url is None):
bot = Bot(api_key)
else:
proxy = Request(proxy_url = proxy_url, urllib3_proxy_kwargs = {'username': proxy_user, 'password': proxy_pass })
bot = Bot(token=api_key, request = proxy)
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 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 monitoring_peers():
# set bot
bot = Bot(api_key)
# list of available peers
rpc_peers = peers_ip()
# check in the list of available peers
for peer in peer_list:
if (peer not in rpc_peers):
# check peers from raiblockscommunity.net
http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',
ca_certs=certifi.where())
response = http.request('GET', peers_url, timeout=10.0)
json_data = json.loads(response.data)
json_peers = json_data['peers']
for (i, item) in enumerate(json_peers):
json_peers[i] = item['ip'].replace("::ffff:", "")
if (peer not in json_peers):
# possible peer names
response = http.request('GET', known_ips_url, timeout=10.0)
json_data = json.loads(response.data)
try:
peer_name = json_data['::ffff:{0}'.format(peer)][0]
# Warning to admins
for user_id in admin_list:
push(
bot, user_id, 'Peer *{0}* ({1}) is offline'.format(
peer, peer_name))
except KeyError:
# Warning to admins
for user_id in admin_list:
push(bot, user_id,
'Peer *{0}* is offline'.format(peer))
def frontiers_sendlist():
bot = Bot(api_key)
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].encode("utf8")))
except Exception as e:
logging.warning('NoCallback From sendlist + exception: {0} :: {1}'.format(send[0], send[1].encode("utf8")))
logging.error(e)
mysql_delete_sendlist(send[0])
def main():
import sys
mapping = [
(KIND_CASE, "cases.csv"),
(KIND_DEATH, "deaths.csv"),
(KIND_RECOVERED, "recovered.csv"),
]
print("loading ...")
data = {}
for kind, filename in mapping:
with (pathlib.Path(sys.argv[1]) / filename).open("r") as f:
load_jhu_data(f, kind, data)
print("\x1b[J", end="")
print("loading population data ...")
with (pathlib.Path(sys.argv[1]) / "lut.csv").open("r") as f:
population = load_jhu_population_data(f)
print("preparing ...")
counters = load_counters(data)
print("crunching the numbers ...")
print(" deriving data")
out = common.derive_data(counters.data, is_cumsum=True)
expected_samples = \
len(population) * out.shape[0] + \
functools.reduce(operator.mul, out.shape[:-1])
print("sending ...")
asyncio.run(
common.push(
common.generate_counter_samples(
dataclasses.replace(
counters,
data=out,
keys=counters.keys,
),
MEASUREMENT_GEOGRAPHICS,
[("country", )],
[
"ccases", "cdeaths", "crecovered", "d1cases", "d1deaths",
"d1recovered", "d7cases", "d7deaths", "d7recovered",
"d7cases_s7", "d7deaths_s7", "d7recovered_s7"
],
),
generate_population_samples(
population,
MEASUREMENT_GEOGRAPHICS,
counters.first_date,
out.data.shape[0],
),
expected_samples=expected_samples,
))
import os
os._exit(0)
def prices_above_below(bot, user_id, price, exchange, above):
lang_id = mysql_select_language(user_id)
btc_price = ('%.8f' % (float(price) / (10 ** 8)))
if (above == 1):
text = lang_text('prices_above', lang_id).format(exchange, btc_price).encode("utf-8")
else:
text = lang_text('prices_below', lang_id).format(exchange, btc_price).encode("utf-8")
try:
push(bot, user_id, text)
except Exception as e:
print('Exception user_id {0}'.format(user_id))
print(text)
if (above == 1):
mysql_delete_price_high(user_id)
else:
mysql_delete_price_low(user_id)
time.sleep(0.5)
def main():
with open("events.toml") as f:
events = toml.load(f)["event"]
print("streaming to influx ...")
asyncio.run(
common.push(
generate_events(events),
expected_samples=len(events),
))
def main():
import sys
print("streaming ...")
with (pathlib.Path(sys.argv[1]) / "tests.csv").open("r") as f:
asyncio.run(common.push(import_samples(f), ))
print("\x1b[J", end="")
import os
os._exit(0)
def receive_messages(bot, account, balance):
history = rpc(
{
"action": "account_history",
"account": account[1],
"count": "50"
}, 'history')
for item in history:
if (item['hash'] == account[2]):
break
if (item['type'] == 'receive'):
lang_id = mysql_select_language(account[0])
sender_account = item['account']
sender = find_sender(item, account, sender_account, balance,
lang_text)
received_amount = int(math.floor(int(item['amount']) / (10**24)))
logging.warning(
'NoCallback {0} Nano (XRB) received by {1}, hash: {2}'.format(
mrai_text(received_amount), account[0], item['hash']))
text = lang_text('frontiers_receive',
lang_id).format(mrai_text(received_amount),
mrai_text(balance), mrai_text(0),
item['hash'], hash_url, sender)
mysql_set_sendlist(account[0], text)
#print(text)
try:
push(bot, account[0], text)
mysql_delete_sendlist(account[0])
except BadRequest as e:
logging.exception('Bad request account {0}'.format(account[0]))
time.sleep(0.25)
if (received_amount >= large_amount_warning):
try:
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]))
time.sleep(0.25)
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument(
"infile",
type=argparse.FileType("rb"),
)
args = parser.parse_args()
print("streaming to influxdb...")
with common.magic_open(args.infile) as f:
asyncio.run(common.push(generate_samples(f), ))
def monitoring_peers():
# set bot
if (proxy_url is None):
bot = Bot(api_key)
else:
proxy = Request(proxy_url=proxy_url,
urllib3_proxy_kwargs={
'username': proxy_user,
'password': proxy_pass
})
bot = Bot(token=api_key, request=proxy)
try:
# list of available peers
rpc_peers = peers_ip()
# check in the list of available peers
for peer in peer_list:
if (peer not in rpc_peers):
# check peers from raiblockscommunity.net
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']
for (i, item) in enumerate(json_peers):
json_peers[i] = item['ip'].replace("::ffff:", "")
if (peer not in json_peers):
# possible peer names
response = http.request('GET',
known_ips_url,
headers=header,
timeout=10.0)
json_data = json.loads(response.data)
try:
peer_name = json_data['::ffff:{0}'.format(peer)][0]
# Warning to admins
for user_id in admin_list:
push(
bot, user_id,
'Peer *{0}* ({1}) is offline'.format(
peer, peer_name))
except KeyError:
# 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 compute_solution(Q, counts):
if len(Q) == 0: return 0
_, m = common.pop(Q)
k = counts.pop(m)
best = m
if m > 1:
for a in range(1, m):
child_Q = copy.deepcopy(Q)
child_counts = copy.deepcopy(counts)
b = m - a
common.push(child_Q, child_counts, a, k)
common.push(child_Q, child_counts, b, k)
best = min(best, compute_solution(child_Q, child_counts) + k)
else:
best = 1
common.push(Q, counts, m, k)
return best
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
def frontiers():
time_start = int(time.time())
# set bot
bot = Bot(api_key)
# list from MySQL
accounts_list = mysql_select_accounts_list()
# list from node. Replace with wallet_frontiers once released
frontiers = rpc({"action":"frontiers","account":"xrb_1111111111111111111111111111111111111111111111111117353trpda","count":65536}, 'frontiers')
#print(len(frontiers))
faucet_account = 'xrb_13ezf4od79h1tgj9aiu4djzcmmguendtjfuhwfukhuucboua8cpoihmh8byo'
for account in accounts_list:
try:
frontier = frontiers[account[1]]
#if ((account[1] == r.keys()[0]) and (account[2] != frontier)):
if (account[2] != frontier):
# update frontier
balance = account_balance(account[1])
# check if balance changed
mysql_update_frontier(account[1], frontier)
#print('{0} --> {1} {2}'.format(account[3], balance, frontier))
logging.info('{0} --> {1} {2}'.format(account[3], balance, frontier))
#print(balance)
if (int(account[3]) < int(balance)):
received_amount = int(balance) - int(account[3])
max_send = int(balance) - int(fee_amount)
if (max_send < 0):
max_send = 0
# retrieve sender
send_tx = json.loads(rpc({"action":"block","hash":frontier}, 'contents'))
#print (send_tx)
send_source = send_tx['source']
#print (send_source)
block_account = rpc({"action":"block_account","hash":send_source}, 'account')
#print (block_account)
sender = ''
if (block_account == faucet_account):
sender = ' from Faucet/Landing'
elif (block_account == fee_account):
sender = ' from @RaiWalletBot itself'
elif (block_account == account[1]):
sender = ' from you'
else:
for sender_account in accounts_list:
if (sender_account[1] == block_account):
if ((sender_account[4] is not None) and (sender_account[4])):
sender = ' from @{0}'.format(sender_account[4])
else:
sender = ' from one of our users'
#print (sender)
logging.info(sender)
# receive fee protection
mysql_update_balance(account[1], int(balance))
logging.info('{0} Mrai (XRB) received by {1}, hash: {2}'.format(received_amount, account[0], frontier))
if (incoming_fee >= 1):
fee = rpc({"action": "send", "wallet": wallet, "source": account[1], "destination": fee_account, "amount": raw_incoming_fee}, 'block')
balance = account_balance(account[1])
push(bot, account[0], '*{0} Mrai (XRB)* received{7}. Transaction hash: [{5}]({6}{5})\nIncoming fee: *{4} Mrai (XRB)*. Your current balance: {1} Mrai (XRB). Send limit: {2} Mrai (XRB)'.format("{:,}".format(received_amount), "{:,}".format(balance), "{:,}".format(max_send), incoming_fee, frontier, hash_url, sender))
logging.info('Incoming fee deducted')
else:
#print(account[0])
#print('*{0} Mrai (XRB)* received{5}. Transaction hash: [{3}]({4}{3})\nYour current balance: *{1} Mrai (XRB)*. Send limit: {2} Mrai (XRB)'.format("{:,}".format(received_amount), "{:,}".format(balance), "{:,}".format(max_send), frontier, hash_url, sender))
push(bot, account[0], '*{0} Mrai (XRB)* received{5}. Transaction hash: [{3}]({4}{3})\nYour current balance: *{1} Mrai (XRB)*. Send limit: {2} Mrai (XRB)'.format("{:,}".format(received_amount), "{:,}".format(balance), "{:,}".format(max_send), frontier, hash_url, sender))
time.sleep(0.1)
# no frontier. No transactions
except KeyError:
# doesn't exist
x = 0 # do something
time_end = int(time.time())
total_time = time_end - time_start
#print(total_time)
if (total_time > 20):
logging.warning(('WARNING!!! \nMore than 20 seconds execution time!!!'))
return total_time
def frontiers():
time_start = int(time.time())
# set bot
bot = Bot(api_key)
# 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')
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):
received_amount = balance - int(account[3])
# FEELESS
if ((account[0] in LIST_OF_FEELESS) or
(mysql_select_send_time(account[0]) is not False)):
final_fee_amount = 0
else:
final_fee_amount = fee_amount
# FEELESS
max_send = balance - final_fee_amount
if (max_send < 0):
max_send = 0
# retrieve sender
send_tx = json.loads(
rpc({
"action": "block",
"hash": frontier
}, 'contents'))
send_source = send_tx['source']
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:
for sender_account in accounts_list_orig:
if (sender_account[1] == block_account):
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)
for sender_account in accounts_list_extra:
if (sender_account[1] == block_account):
user_sender = mysql_select_user(
sender_account[0])
if ((user_sender[8] is not None)
and (user_sender[8])
and (account[0] != sender_account[0])):
sender = lang_text(
'frontiers_sender_username',
lang_id).format(user_sender[8])
elif (account[0] != sender_account[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.warning(
'NoCallback {0} Mrai (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(max_send), frontier, hash_url, sender)
mysql_set_sendlist(account[0], text.encode("utf8"))
#print(text)
push(bot, account[0], text)
mysql_delete_sendlist(account[0])
time.sleep(0.25)
# no frontier. No transactions
except KeyError:
# 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
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'] == 'receive') or (block['type'] == 'open')):
bot = Bot(api_key)
raw_received = int(post['amount'])
received_amount = int(math.floor(raw_received / (10 ** 24)))
balance = account_balance(xrb_account)
frontier = post['hash']
# FEELESS
if ((account[0] in LIST_OF_FEELESS) or (mysql_select_send_time(account[0]) is not False)):
final_fee_amount = 0
else:
final_fee_amount = fee_amount
# FEELESS
max_send = balance - final_fee_amount
if (max_send < 0):
max_send = 0
try:
z = account[4]
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['source']
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:
accounts_list = mysql_select_accounts_list()
for sender_account in accounts_list:
if (sender_account[1] == block_account):
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)
accounts_list_extra = mysql_select_accounts_list_extra()
for sender_account in accounts_list_extra:
if (sender_account[1] == block_account):
user_sender = mysql_select_user(sender_account[0])
if ((user_sender[8] is not None) and (user_sender[8]) and (account[0] != sender_account[0])):
sender = lang_text('frontiers_sender_username', lang_id).format(user_sender[8])
elif (account[0] != sender_account[0]):
sender = lang_text('frontiers_sender_users', lang_id).format(block_account)
try:
z = account[4]
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} Mrai (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(max_send), frontier, hash_url, sender)
mysql_set_sendlist(account[0], text.encode("utf8"))
#print(text)
push(bot, account[0], text)
mysql_delete_sendlist(account[0])
return
def receive_messages(bot, account, balance):
history = rpc(
{
"action": "account_history",
"account": account[1],
"count": "50"
}, 'history')
for item in history:
if (item['hash'] == account[2]):
break
if (item['type'] == 'receive'):
received_amount = int(math.floor(int(item['amount']) / (10**24)))
# retrieve sender
block_account = item['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 from bot
account_mysql = mysql_select_by_account_extra(block_account)
if (account_mysql is False):
# sender from users accounts
account_mysql = mysql_select_by_account(block_account)
if (account_mysql is not False):
if ((account_mysql[4] is not None)
and (account_mysql[4])):
sender = lang_text('frontiers_sender_username',
lang_id).format(
account_mysql[4])
elif (block_account != account[1]):
sender = lang_text('frontiers_sender_users',
lang_id).format(block_account)
else:
# sender from extra accounts
user_sender = mysql_select_user(account_mysql[0])
if ((user_sender[8] is not None) and (user_sender[8])
and (account[0] != account_mysql[0])):
sender = lang_text('frontiers_sender_username',
lang_id).format(user_sender[8])
elif (block_account != account[1]):
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.warning(
'NoCallback {0} Nano (XRB) received by {1}, hash: {2}'.format(
mrai_text(received_amount), account[0], item['hash']))
text = lang_text('frontiers_receive',
lang_id).format(mrai_text(received_amount),
mrai_text(balance), mrai_text(0),
item['hash'], hash_url, sender)
mysql_set_sendlist(account[0], text)
#print(text)
push(bot, account[0], text)
mysql_delete_sendlist(account[0])
time.sleep(0.25)
if (received_amount >= large_amount_warning):
push(bot, account[0],
lang_text('frontiers_large_amount_warning', lang_id))
time.sleep(0.25)
