def faucet():
update_counters()
bver = str(get_latest_version())
message = ''
if request.method == 'POST':
try:
acct = request.form.get('acct')
app.logger.info('acct: {}'.format(acct))
amount = request.form.get('amount')
app.logger.info('amount: {}'.format(amount))
if float(amount) < 0:
message = 'Amount must be >= 0'
elif not is_valid_account(acct):
message = 'Invalid account format'
else:
do_cmd('a mb 0 ' + str(float(amount)), p=p)
do_cmd('tb 0 ' + acct + ' ' + str(float(amount)), p=p)
acct_link = '<a href="/account/{0}">{0}</a>'.format(acct)
message = 'Sent ' + amount + ' <small>Libra</small> to ' + acct_link
except:
message = 'Invalid request logged!'
app.logger.exception(message)
if message:
message = faucet_alert_template.format(message)
return faucet_template.format(bver, message)
def faucet():
update_counters()
with session_scope() as session:
bver = str(get_latest_version(session))
message = ''
if request.method == 'POST':
try:
acct = request.form.get('acct')
app.logger.info('acct: {}'.format(acct))
amount = float(request.form.get('amount'))
app.logger.info('amount: {}'.format(amount))
if amount < 0:
message = 'Amount must be >= 0'
elif not is_valid_account(acct):
message = 'Invalid account format'
else:
response = requests.get(config['FAUCET_HOST'],
params={
'address': acct,
'amount':
format(amount * 1e6, '.0f')
})
if response.status_code == 200:
message = 'Sent {0} <small>Libra</small> to <a href="/account/{1}">{1}</a>'.format(
amount, acct)
except:
message = 'Invalid request logged!'
app.logger.exception(message)
if message:
message = faucet_alert_template.format(message)
return faucet_template.format(bver, message)
def acct_details(acct):
app.logger.info('Account: {}'.format(acct))
update_counters()
try:
page = int(request.args.get('page'))
except:
page = 0
if not is_valid_account(acct):
return invalid_account_template
bver = str(get_latest_version())
acct_state_raw = get_acct_raw(acct)
acct_info = get_acct_info(acct_state_raw)
app.logger.info('acct_info: {}'.format(acct_info))
try:
tx_list = get_all_account_tx(acct, page)
tx_tbl = ''
for tx in tx_list:
tx_tbl += gen_tx_table_row(tx)
except:
app.logger.exception('error in building table')
next_page = "/account/" + acct + "?page=" + str(page + 1)
return account_template.format(bver, *acct_info, tx_tbl, next_page)
def acct_details(acct):
print(acct)
update_counters()
try:
page = int(request.args.get('page'))
except:
page = 0
if not is_valid_account(acct):
return invalid_account_template
c2, conn = connect_to_db(config['DB_PATH'])
bver = str(get_latest_version(c2))
acct_state_raw = get_acct_raw(acct)
acct_info = get_acct_info(acct_state_raw)
print('acct_info', acct_info)
try:
tx_list = get_all_account_tx(c2, acct, page)
tx_tbl = ''
for tx in tx_list:
tx_tbl += gen_tx_table_row(tx)
except:
print(sys.exc_info())
traceback.print_exception(*sys.exc_info())
print('error in building table')
next_page = "/account/" + acct + "?page=" + str(page + 1)
conn.close()
return account_template.format(bver, *acct_info, tx_tbl, next_page)
def faucet():
update_counters()
c2, conn = connect_to_db(config['DB_PATH'])
bver = str(get_latest_version(c2))
message = ''
if request.method == 'POST':
try:
acct = request.form.get('acct')
print(acct)
amount = request.form.get('amount')
print(amount)
if float(amount) < 0:
message = 'Amount must be >= 0'
elif not is_valid_account(acct):
message = 'Invalid account format'
else:
do_cmd('a mb 0 ' + str(float(amount)), p=p)
do_cmd('tb 0 ' + acct + ' ' + str(float(amount)), p=p)
acct_link = '<a href="/account/{0}">{0}</a>'.format(acct)
message = 'Sent ' + amount + ' <small>Libra</small> to ' + acct_link
except:
traceback.print_exception(*sys.exc_info())
message = 'Invalid request logged!'
if message:
message = faucet_alert_template.format(message)
return faucet_template.format(bver, message)
def version(ver):
update_counters()
c2, conn = connect_to_db(config['DB_PATH'])
bver = str(get_latest_version(c2))
try:
ver = int(ver)
tx = get_tx_from_db_by_version(ver, c2)
except:
conn.close()
return version_error_template
# for toggle raw view
if request.args.get('raw') == '1':
extra = """<tr>
<td><strong>Program Raw</strong></td>
<td><pre>{0}</pre></td>
</tr>""".format(tx[-1])
not_raw = '0'
else:
extra = ''
not_raw = '1'
conn.close()
return version_template.format(bver, *tx, add_br_every64(tx[12]), extra,
not_raw, tx[-2].replace('<', '<'))
def calc_stats(session, limit=None):
# time
cur_time = datetime.now()
int_ts = int(cur_time.timestamp())
time_filter = lambda q: (q.filter(
Transaction.expiration_unixtime >= int_ts - limit + 100).filter(
Transaction.expiration_unixtime < int_ts + 600)) if limit else q
# first block
q = session.query(func.min(
Transaction.version)).filter(Transaction.version > 0)
first_version = time_filter(q).scalar()
if not first_version:
first_version = 1
logger.info('first ver = {}'.format(first_version))
# get max block
last_block = get_latest_version(session)
logger.info('last block = {}'.format(last_block))
# deltas
first_block_time = datetime.fromtimestamp(
session.query(Transaction.expiration_unixtime).filter_by(
version=first_version).scalar())
td = timedelta(0, limit) if limit else (cur_time - first_block_time)
dhms = days_hours_minutes_seconds(td)
blocks_delta = last_block - first_version + 1
logger.info('deltas: {} {}'.format(td, blocks_delta))
# mint p2p other
q_amount = time_filter(session.query(Transaction.amount))
q = q_amount.filter_by(type='mint_transaction')
get_cnt_sum = lambda q: (q.count(), sum(unpack(v.amount) for v in q))
mint_count, mint_sum = get_cnt_sum(q)
logger.info('mint {} {}'.format(mint_count, mint_sum))
q = q_amount.filter_by(type='peer_to_peer_transaction')
p2p_count, p2p_sum = get_cnt_sum(q)
logger.info('p2p {} {}'.format(p2p_count, p2p_sum))
q = q_amount.filter((Transaction.type != 'mint_transaction')
& (Transaction.type != 'peer_to_peer_transaction'))
other_count, other_sum = get_cnt_sum(q)
# add 1 to account for the genesis block until it is added to DB
if first_version == 1:
other_count += 1
logger.info('others {} {}'.format(other_count, other_sum))
# unique accounts
count_dest, count_src = tuple(
time_filter(session.query(col).filter(
Transaction.version != 0)).distinct().count()
for col in (Transaction.dest, Transaction.src))
return (blocks_delta, *dhms, blocks_delta / td.total_seconds(),
100 * mint_count / blocks_delta, 100 * p2p_count / blocks_delta,
100 * other_count / blocks_delta, mint_sum, p2p_sum, other_sum,
count_dest, count_src)
def index():
update_counters()
c2, conn = connect_to_db(config['DB_PATH'])
bver = str(get_latest_version(c2))
conn.close()
return index_template.format(bver)
def version(ver):
update_counters()
with session_scope() as session:
bver = str(get_latest_version(session))
try:
ver = int(ver) # safety
except:
logger.warning('potential attempt to inject: {}'.format(ver))
ver = 1
res = session.query(Transaction).filter_by(version=ver).all()
if 1 < len(res):
logger.warning('possible duplicates detected in db, record version: {}'.format(ver))
try:
tx = res.pop()
except:
return gen_error_page(bver), 404
# for toggle raw view
if request.args.get('raw') == '1':
extra = """<tr>
<td><strong>Program Raw</strong></td>
<td><pre>{0}</pre></td>
</tr>""".format(tx.code_hex)
not_raw = '0'
else:
extra = ''
not_raw = '1'
return version_template.format(
bver,
tx.version,
tx.expiration_date,
tx.src,
tx.dest,
tx.type,
unpack(tx.amount),
unpack(tx.gas_price),
unpack(tx.max_gas),
tx.sq_num,
tx.pub_key,
tx.expiration_unixtime,
unpack(tx.gas_used),
tx.sender_sig,
tx.signed_tx_hash,
tx.state_root_hash,
tx.event_root_hash,
tx.code_hex,
tx.program,
add_br_every64(tx.sender_sig),
extra,
not_raw,
tx.code_hex.replace('<', '<')
)
def version(ver):
update_counters()
bver = str(get_latest_version())
try:
ver = int(ver)
tx = get_tx_from_db_by_version(ver)
except:
return gen_error_page(bver), 404
# for toggle raw view
if request.args.get('raw') == '1':
extra = """<tr>
<td><strong>Program Raw</strong></td>
<td><pre>{0}</pre></td>
</tr>""".format(tx[-1])
not_raw = '0'
else:
extra = ''
not_raw = '1'
return version_template.format(bver, *tx, add_br_every64(tx[12]), extra,
not_raw, tx[-2].replace('<', '<'))
def acct_details(acct):
update_counters()
app.logger.info('Account: {}'.format(acct))
with session_scope() as session:
bver = str(get_latest_version(session))
try:
page = int(request.args.get('page'))
except:
page = 0
if not is_valid_account(acct):
return gen_error_page(bver), 404
try:
acct_state_raw = get_acct_raw(acct)
try:
acct_info = get_acct_info(acct_state_raw)
except:
# if account_state_with_proof.blob does not exist
acct_info = (acct, 0, '-', 0, 0, None)
app.logger.info('acct_info: {}'.format(acct_info))
tx_tbl = ''.join(
gen_tx_table_row(tx)
for tx in session.query(Transaction).filter((
Transaction.src == acct) | (Transaction.dest == acct)).
order_by(desc(Transaction.version)).limit(100).offset(page *
100))
except:
app.logger.exception('error in building table')
return gen_error_page(bver), 404
next_page = "/account/" + acct + "?page=" + str(page + 1)
return account_template.format(bver, *(acct_info[:-1]), tx_tbl, next_page)
def calc_stats(c, limit = None):
# time
cur_time = datetime.now()
# time expression
if limit:
n = int(cur_time.timestamp()) - limit
# TODO: using heuristic of expiration_time - 100 = tx time until there is a better way
# see: https://community.libra.org/t/fetch-previous-version-ledgerinfo-via-rpc/848/6
t_str = ' and expiration_unixtime >= ' + str(n + 100) + ' and expiration_unixtime < 2147485547'
# TODO: limiting the top of the counter means we're discounting TXs with high expriation time in stats - fix it
else:
t_str = ''
# first block
c.execute("SELECT MIN(version) FROM transactions WHERE version > 0" + t_str)
first_version = c.fetchall()[0][0]
first_block_time = datetime.fromtimestamp(get_tx_from_db_by_version(first_version, c)[10])
# get max block
last_block = get_latest_version(c)
print('last block = ', last_block)
# deltas
td = cur_time - first_block_time
dhms = days_hours_minutes_seconds(td)
blocks_delta = last_block - first_version + 1
# mints
c.execute("SELECT count(DISTINCT version) FROM transactions WHERE type = 'mint_transaction'" + t_str)
mint_count = c.fetchall()[0][0]
c.execute("SELECT DISTINCT version FROM transactions WHERE type = 'mint_transaction'" + t_str)
mint_sum = sum([x[0] for x in c.fetchall()])
# p2p txs
c.execute("SELECT count(DISTINCT version) FROM transactions WHERE type = 'peer_to_peer_transaction'" + t_str)
p2p_count = c.fetchall()[0][0]
c.execute("SELECT DISTINCT version FROM transactions WHERE type = 'peer_to_peer_transaction'" + t_str)
p2p_sum = sum([x[0] for x in c.fetchall()])
# add 1 to account for the genesis block until it is added to DB
c.execute("SELECT count(DISTINCT version) FROM transactions " +
"WHERE (type != 'peer_to_peer_transaction') and (type != 'mint_transaction')" + t_str)
other_tx_count = c.fetchall()[0][0]
if limit is None:
other_tx_count += 1 # TODO: this is for genesis block - remove later
c.execute("SELECT DISTINCT version FROM transactions " +
"WHERE (type != 'peer_to_peer_transaction') and (type != 'mint_transaction')" + t_str)
other_sum = sum([x[0] for x in c.fetchall()])
print('p2p + mint =', mint_count + p2p_count)
# unique accounts
c.execute("SELECT COUNT(DISTINCT dest) FROM transactions WHERE version > 0" + t_str)
count_dest = c.fetchone()[0]
c.execute("SELECT COUNT(DISTINCT src) FROM transactions WHERE version > 0" + t_str)
count_src = c.fetchone()[0]
r = (blocks_delta, *dhms, blocks_delta/td.total_seconds(), 100*mint_count/blocks_delta,
100*p2p_count/blocks_delta, 100*other_tx_count/blocks_delta, mint_sum, p2p_sum, other_sum,
count_dest, count_src)
return r
def index():
update_counters()
bver = str(get_latest_version())
return index_template.format(bver)
def index():
update_counters()
with session_scope() as session:
bver = str(get_latest_version(session))
return index_template.format(bver)
def calc_stats(limit=None):
# time
cur_time = datetime.now()
int_ts = int(cur_time.timestamp())
s_limit = lambda s: (s.where(txs.c.expiration_unixtime >= int_ts - limit +
100).where(txs.c.expiration_unixtime < int_ts
+ 600)) if limit else s
# first block
first_version = engine.execute(
s_limit(select([func.min(txs.c.version)
]).where(txs.c.version > 0))).scalar()
if not first_version:
first_version = 1
logger.info('first ver = {}'.format(first_version))
# get max block
last_block = get_latest_version()
logger.info('last block = {}'.format(last_block))
# deltas
first_block_time = datetime.fromtimestamp(
get_tx_from_db_by_version(first_version)[10])
td = timedelta(0, limit) if limit else (cur_time - first_block_time)
dhms = days_hours_minutes_seconds(td)
blocks_delta = last_block - first_version + 1
logger.info('deltas: {} {}'.format(td, blocks_delta))
# mint p2p other
def get_tx_cnt_sum(whereclause):
selected = engine.execute(
s_limit(
select([txs.c.amount]).where(whereclause).distinct(
txs.c.version))).fetchall()
return len(selected), sum(map(lambda r: unpack(r['amount']), selected))
mint_count, mint_sum = get_tx_cnt_sum(txs.c.type == 'mint_transaction')
logger.info('mint {} {}'.format(mint_count, mint_sum))
p2p_count, p2p_sum = get_tx_cnt_sum(
txs.c.type == 'peer_to_peer_transaction')
logger.info('p2p {} {}'.format(p2p_count, p2p_sum))
other_count, other_sum = get_tx_cnt_sum(
(txs.c.type != 'mint_transaction')
& (txs.c.type != 'peer_to_peer_transaction'))
# add 1 to account for the genesis block until it is added to DB
other_count += 1
logger.info('others {} {}'.format(other_count, other_sum))
# unique accounts
def get_acct_cnt(acct):
return engine.execute(
s_limit(select([
acct
]).where(txs.c.version > 0).distinct()).count()).fetchone()[0]
count_dest = get_acct_cnt(txs.c.dest)
count_src = get_acct_cnt(txs.c.src)
return (blocks_delta, *dhms, blocks_delta / td.total_seconds(),
100 * mint_count / blocks_delta, 100 * p2p_count / blocks_delta,
100 * other_count / blocks_delta, mint_sum, p2p_sum, other_sum,
count_dest, count_src)
