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)