def test_estimate_virtual_op_num(self): stm = self.bts account = Account("gtg", steem_instance=stm) block_num = 21248120 block = Block(block_num, steem_instance=stm) op_num1 = account.estimate_virtual_op_num(block.time(), stop_diff=1, max_count=100) op_num2 = account.estimate_virtual_op_num(block_num, stop_diff=1, max_count=100) op_num3 = account.estimate_virtual_op_num(block_num, stop_diff=100, max_count=100) op_num4 = account.estimate_virtual_op_num(block_num, stop_diff=0.00001, max_count=100) self.assertTrue(abs(op_num1 - op_num2) < 2) self.assertTrue(abs(op_num1 - op_num4) < 2) self.assertTrue(abs(op_num1 - op_num3) < 200) block_diff1 = 0 block_diff2 = 0 for h in account.get_account_history(op_num4 - 1, 1): block_diff1 = (block_num - h["block"]) for h in account.get_account_history(op_num4 + 1, 1): block_diff2 = (block_num - h["block"]) self.assertTrue(block_diff1 > 0) self.assertTrue(block_diff1 < 1000) self.assertTrue(block_diff2 <= 0) self.assertTrue(block_diff2 > -1000)
def test_estimate_block_num(self): bts = self.bts b = Blockchain(steem_instance=bts) last_block = b.get_current_block() num = last_block.identifier old_block = Block(num - 60, steem_instance=bts) date = old_block.time() est_block_num = b.get_estimated_block_num(date, accurate=False) self.assertTrue((est_block_num - (old_block.identifier)) < 10) est_block_num = b.get_estimated_block_num(date, accurate=True) self.assertTrue((est_block_num - (old_block.identifier)) < 2) est_block_num = b.get_estimated_block_num(date, estimateForwards=True, accurate=True) self.assertTrue((est_block_num - (old_block.identifier)) < 2) est_block_num = b.get_estimated_block_num(date, estimateForwards=True, accurate=False)
def test_block(self, node_param): if node_param == "instance": stm = Steem(node="abc", autoconnect=False, num_retries=1) set_shared_steem_instance(self.bts) o = Block(1) self.assertIn(o.steem.rpc.url, self.urls) with self.assertRaises(NumRetriesReached): Block(1, steem_instance=stm) else: set_shared_steem_instance( Steem(node="abc", autoconnect=False, num_retries=1)) stm = self.bts o = Block(1, steem_instance=stm) self.assertIn(o.steem.rpc.url, self.urls) with self.assertRaises(NumRetriesReached): Block(1)
def test_verify_transaction(self): stm = self.stm block = Block(22005665, steem_instance=stm) trx = block.transactions[28] signed_tx = Signed_Transaction(trx) key = signed_tx.verify(chain=stm.chain_params, recover_parameter=False) public_key = format(Base58(key[0]), stm.prefix) self.assertEqual(public_key, "STM4tzr1wjmuov9ftXR6QNv7qDWsbShMBPQpuwatZsfSc5pKjRDfq")
def test_export(self, node_param): if node_param == "normal": bts = self.bts block_num = 2000000 else: bts = self.testnet block_num = 2 if bts.rpc.get_use_appbase(): block = bts.rpc.get_block({"block_num": block_num}, api="block") if block and "block" in block: block = block["block"] else: block = bts.rpc.get_block(block_num) b = Block(block_num, steem_instance=bts) keys = list(block.keys()) json_content = b.json() for k in keys: if k not in "json_metadata": if isinstance(block[k], dict) and isinstance( json_content[k], list): self.assertEqual(list(block[k].values()), json_content[k]) else: self.assertEqual(block[k], json_content[k]) if bts.rpc.get_use_appbase(): block = bts.rpc.get_block_header({"block_num": block_num}, api="block") if "header" in block: block = block["header"] else: block = bts.rpc.get_block_header(block_num) b = BlockHeader(block_num, steem_instance=bts) keys = list(block.keys()) json_content = b.json() for k in keys: if k not in "json_metadata": if isinstance(block[k], dict) and isinstance( json_content[k], list): self.assertEqual(list(block[k].values()), json_content[k]) else: self.assertEqual(block[k], json_content[k])
def test_block(self, node_param): if node_param == "instance": set_shared_steem_instance(self.bts) o = Block(1) self.assertIn(o.steem.rpc.url, self.urls) with self.assertRaises( RPCConnection ): Block(1, steem_instance=Steem(node="https://abc.d", autoconnect=False, num_retries=1)) else: set_shared_steem_instance(Steem(node="https://abc.d", autoconnect=False, num_retries=1)) stm = self.bts o = Block(1, steem_instance=stm) self.assertIn(o.steem.rpc.url, self.urls) with self.assertRaises( RPCConnection ): Block(1)
def test_block_only_ops(self): bts = self.bts test_block_id = self.test_block_id block = Block(test_block_id, only_ops=True, steem_instance=bts) self.assertEqual(block.identifier, test_block_id) self.assertTrue(isinstance(block.time(), datetime)) self.assertTrue(isinstance(block, dict)) self.assertTrue(len(block.operations)) self.assertTrue(isinstance(block.ops_statistics(), dict)) block2 = Block(test_block_id + 1, steem_instance=bts) self.assertTrue(block2.time() > block.time()) with self.assertRaises(exceptions.BlockDoesNotExistsException): Block(0, steem_instance=bts)
def uid_from_block(trx_id, block_num, qty, prefix): block = Block(block_num) seed = hashlib.md5( (trx_id + block["block_id"] + block["previous"]).encode()).hexdigest() random.seed(a=seed, version=2) uid_list = [] for i in range(qty): uid = prefix + generateUid(10) uid_list.append(uid) return uid_list
def test_block(self, node_param): if node_param == "non_appbase": bts = self.bts else: bts = self.appbase block = Block(self.test_block_id, steem_instance=bts) self.assertEqual(block.identifier, self.test_block_id) self.assertTrue(isinstance(block.time(), datetime)) self.assertTrue(isinstance(block, dict)) self.assertTrue(len(block.ops())) self.assertTrue(isinstance(block.ops_statistics(), dict)) block2 = Block(self.test_block_id + 1, steem_instance=bts) self.assertTrue(block2.time() > block.time()) with self.assertRaises( exceptions.BlockDoesNotExistsException ): Block(0, steem_instance=bts)
def test_verify_transaction(self): stm = self.stm block = Block(22005665, steem_instance=stm) trx = block.transactions[28] signed_tx = Signed_Transaction(trx) key = signed_tx.verify(chain=stm.chain_params, recover_parameter=False) public_key = format(Base58(key[0]), stm.prefix) self.assertEqual( public_key, "STM4xA6aCu23rKxsEZWF2xVYJvJAyycuoFxBRQEuQ5Hc7UtFET7fT")
else: _ids[ops["_id"]] = 1 duplicate_indices = [] _id_list = [] for _id in sorted(list(ops_dict.keys())): ops = ops_dict[_id] if _ids[ops["_id"]] == 1: continue if ops["_id"] not in _id_list: _id_list.append(ops["_id"]) else: trx_id = ops["trx_id"] if trx_id == "0000000000000000000000000000000000000000": duplicate_indices.append(ops["index"]) else: block = Block(ops["block"], blockchain_instance=stm) count_ops = 0 for t in block.transactions: if t["transaction_id"] != trx_id: continue for o in t["operations"]: count_ops += 1 if count_ops < _ids[ops["_id"]]: duplicate_indices.append(ops["index"]) type_count = {} for _id in sorted(list(ops_dict.keys())): ops = ops_dict[_id] if ops["type"] in type_count: type_count[ops["type"]] += 1 else:
def benchmark_node_blocks(node, num_retries=10, num_retries_call=10, timeout=60, how_many_seconds=30): block_count = 0 sucessfull = False error_msg = None start_total = timer() start_time = timer() max_batch_size = None threading = False thread_num = 16 last_block_id = 19273700 try: stm = Steem(node=node, num_retries=num_retries, num_retries_call=num_retries_call, timeout=timeout) blockchain = Blockchain(steem_instance=stm) last_block_id = int(blockchain.get_current_block_num() * 0.75) last_block = Block(last_block_id, steem_instance=stm) total_transaction = 0 start_time = timer() for entry in blockchain.blocks(start=last_block_id, max_batch_size=max_batch_size, threading=threading, thread_num=thread_num): block_no = entry.identifier block_count += 1 if not sucessfull: sucessfull = True if "block" in entry: trxs = entry["block"]["transactions"] else: trxs = entry["transactions"] for tx in trxs: for op in tx["operations"]: total_transaction += 1 if "block" in entry: block_time = (entry["block"]["timestamp"]) else: block_time = (entry["timestamp"]) if timer() - start_time > how_many_seconds or quit_thread: break except NumRetriesReached: error_msg = 'NumRetriesReached' sucessfull = False except KeyboardInterrupt: error_msg = 'KeyboardInterrupt' # quit = True except Exception as e: error_msg = str(e) sucessfull = False total_duration = float("{0:.2f}".format(timer() - start_time)) return { 'sucessfull': sucessfull, 'node': node, 'error': error_msg, 'total_duration': total_duration, 'count': block_count, 'access_time': None }
block_num = b.get_estimated_block_num( vote["time"]) current_block_num = b.get_current_block_num() transaction = None block_search_list = [ 0, 1, -1, 2, -2, 3, -3, 4, -4, 5, -5 ] block_cnt = 0 while transaction is None and block_cnt < len( block_search_list): if block_num + block_search_list[ block_cnt] > current_block_num: block_cnt += 1 continue block = Block(block_num + block_search_list[block_cnt], steem_instance=stm) for tt in block.transactions: for op in tt["operations"]: if isinstance( op, dict ) and op["type"][:4] == "vote": if op["value"][ "voter"] == vote[ "voter"]: transaction = tt elif isinstance(op, list) and len( op ) > 1 and op[0][:4] == "vote": if op[1]["voter"] == vote[ "voter"]:
def test_block(self): o = Block(1) self.assertEqual(o.steem.rpc.url, self.url)
def main(): checkPoint() startblock = 0 try: conn = create_connection(database) if conn is not None: printX('###########################') printX('#### Database connected #####') printX('###########################') c = conn.cursor() c.execute("SELECT blockheight FROM last_check") last_check = c.fetchall() startblock = last_check[0][0] except Exception as error: conn.close() print(error) if startblock is None or startblock == 0: startblock = int(input("Please insert initial block number.")) try: with conn: c.execute( '''INSERT OR IGNORE INTO last_check (blockheight) VALUES (?)''', (startblock, )) except Exception as e: print('ERROR UPDATING BLOCKHEIGHT 1 ' + str(e)) startblock = int(startblock) getblock = startblock go = True while go == True: # Block was read based on block number and always trying to catch the latest block. try: blockchain = Blockchain() print('Block : ' + str(getblock)) except: print("Latest Block") try: block = Block(getblock) except: block = None printX('###########################') printX('#### End of Block #########') printX('###########################') try: if getblock % retrieveInterval == 0: retrieveBlackList() checkPoint() getConfig() setHouseFund() if getblock % 200 == 0: resetSoftBannedCount() except Exception as e: print('Error get blacklist ' + str(e)) # Iterating each transaction on every block to check any transaction is send to @epicdice, then storing all crucial value into global variable which later will be stored into local database for processing. if block != None: for i, txs in enumerate(block.transactions): for (j, tx) in enumerate(txs['operations']): if tx['type'] == 'transfer_operation' and tx['value'][ 'to'] in [watching]: if tx != None: transId = txs['transaction_id'] precision = str(tx['value']['amount']['precision']) nai = tx['value']['amount']['nai'] fromWho = tx['value']['from'] toWho = tx['value']['to'] amount = tx['value']['amount']['amount'] ref_block_num = txs['ref_block_num'] transaction_num = txs['transaction_num'] block_num = txs['block_num'] memo = tx['value']['memo'] transType = tx['type'] finalAmount = (float(amount) * 0.1**float(precision)) * 100 / 100 finalAmount = float_round(finalAmount, 3, round) if '@@000000013' in nai: finalAmountWithAsset = str( finalAmount) + ' SBD' asset = 'SBD' else: finalAmountWithAsset = str( finalAmount) + ' STEEM' asset = 'STEEM' else: print('is None') sender = fromWho factor = 0 try: details = memo betType = 0 details = str(details).lower() rate = 0 if 'over' in details: indexOfSpace = memo.index(" ") rate = int(memo[indexOfSpace:indexOfSpace + 3]) factor = 100 - rate betType = 1 elif 'above' in details: indexOfSpace = memo.index(" ") rate = int(memo[indexOfSpace:indexOfSpace + 3]) factor = 100 - rate betType = 1 elif 'below' in details or 'under' in details: try: indexOfSpace = memo.index(" ") rate = int(memo[indexOfSpace:indexOfSpace + 3]) printX("indexOfSpace " + str(indexOfSpace)) except Exception as e: print('failed ' + str(e)) factor = 0 + rate - 1 betType = 2 else: factor = 0 except Exception as e: print('Exception ' + str(e)) factor = 0 printX( '************************** Bet Found ***********************************' ) printX('Transaction : ' + str(tx)) printX('transType : ' + transType) printX('fromWho : ' + fromWho) printX('toWho : ' + toWho) printX('amount : ' + amount) printX('finalAmount : ' + str(finalAmount)) printX('finalAmountWithAsset : ' + finalAmountWithAsset) printX('precision : ' + str(precision)) printX('nai : ' + nai) printX('memo : ' + memo) printX('rate ' + str(rate)) printX('factor ' + str(factor)) printX('ref_block_num ' + str(ref_block_num)) printX('block_num ' + str(block_num)) printX('transaction_num ' + str(transaction_num)) printX('transId ' + str(transId)) if factor > 0: # Calculation of the possible winning payout and go through a series of validation checking. win = (float(finalAmount) * 100 / factor) * (1 - houseEdge) win = float_round(win, 3, round) if sender in userList: printX('Found in blacklisted*****') else: if float(finalAmount) < minbet: printX('Sorry, Minimum bet is ' + str(minbet)) clientTransfer( watching, sender, str(finalAmountWithAsset), 'Refund invalid bet. Minimum bet is ' + str(minbet) + ' . ' + str(potentialBlackListChecking(sender)) + ' more invalid bets will get your account permanently blacklisted.' ) elif win > maxwin[asset]: clientTransfer( watching, sender, str(finalAmountWithAsset), 'Refund invalid bet. The maximum amount you can win in one game is ' + str(maxwin[asset]) + ' ' + asset + ' . ' + str(potentialBlackListChecking(sender)) + ' more invalid bets will get your account permanently blacklisted.' ) printX( 'Sorry, the maximum amount you can win in one game is ' + str(maxwin[asset]) + ' ' + asset) elif not isWatchingAccountSufficient( finalAmount, asset): clientTransfer( watching, sender, str(finalAmountWithAsset), 'Sorry, Host insufficient fund. Refund Your Bet. Refund initiated' ) printX('Host insufficient fund.') else: error = 0 if betType == 1: if rate < minRate or rate >= 96: error = 1 clientTransfer( watching, sender, str(finalAmountWithAsset), 'Refund invalid Bet. Cannot bet below 6 or above 96. ' + str( potentialBlackListChecking( sender)) + ' more invalid bets will get your account permanently blacklisted.' ) printX( 'Below min rate or over 100') elif betType == 2: if rate > maxRate or rate <= 1: error = 1 clientTransfer( watching, sender, str(finalAmountWithAsset), 'Refund invalid Bet. Cannot bet above 95 or below 1. ' + str( potentialBlackListChecking( sender)) + ' more invalid bets will get your account permanently blacklisted.' ) printX( 'Exceeded max rate or below 1') if error == 0: # store valid bet into local database try: with conn: c.execute( '''INSERT OR IGNORE INTO percentagebets (block, txid, user, amount, bet, asset, hashServerSeed, serverSeed , clientSeed) VALUES (?,?,?,?,?,?,?,?,?)''', (getblock, transId, sender, finalAmount, memo, asset, "", "", "")) printX( 'Insert to database succesfully !!!' ) except Exception as e: print('ERROR INSERTING BET ' + str(e)) print( 'Sorry, Your bet is invalid 1') clientTransfer( watching, sender, str(finalAmountWithAsset), 'Refund invalid Bet. ' + str( potentialBlackListChecking( sender)) + ' more invalid bets will get your account permanently blacklisted.' ) else: print('Generic exception !!!') getblock = getblock + 1 else: go = False try: with conn: c.execute('''UPDATE last_check SET blockheight=?''', (getblock, )) except Exception as e: conn.close() print('ERROR UPDATING BLOCKHEIGHT 2 ' + str(e)) processActiveBet(houseEdge, referralRate) return getblock
new_acc += 1 new_acc_names.append(b["new_account_name"]) new_acc_index = b["new_account_id"] if trx_num_needed: if len(what_list) <= 1 and len(what_list) <= 1: # and new_acc <= 1: trx_num_needed = False elif len(follower_names_1) == 0 or len(follower_names_0) == 0: # and new_acc <= 1: trx_num_needed = False elif len(following_names_1 + following_names_0) == len(set(following_names_1 + following_names_0)): trx_num_needed = False if trx_num_needed: if len(blocks) < 2: trx_num_needed = False if trx_num_needed: block = Block(blocks[0]["block_num"]) api_calls += 1 trx_ids = block["transaction_ids"] # print("%d - %d blocks" % (last_block_num, len(blocks))) for i in range(len(blocks)): trx_num = trx_ids.index(blocks[i]["trx_id"]) blocks[i]["trx_num"] = trx_num # blockTrxStorage.update_trx_num(block["block_num"], block["trx_id"], block["op_num"], trx_num) elif new_acc > 1 and new_acc_index < 965300: sorted_blocks = sorted(blocks, key=lambda x: (x["new_account_id"] is None, x["new_account_id"])) trx_ids = [] for block in sorted_blocks: trx_ids.append(block["trx_id"]) for i in range(len(blocks)): trx_num = trx_ids.index(blocks[i]["trx_id"]) blocks[i]["trx_num"] = trx_num
def scan_history( hive: beem.Hive, block_num: Optional[int] = None, hours_ago: Optional[timedelta] = None, report_freq: int = 5, reports=True, use_test_node=False, quiet=False, include_unauthorized=False, include_non_podping=False, write_csv=False, ): """Scans back in history timed time delta ago, reporting with report_freq if timed is an int, treat it as hours, if report_freq is int, treat as min""" # Very first transaction from Dave Testing: """2021-05-10 13:51:58,353 INFO root MainThread : Feed Updated - 2021-05-07 20:58:33+00:00 - f0affd194524a6e0171d65d29d5c501865f0bd72 - https://feeds.transistor.fm/retail-remix""" scan_start_time = datetime.utcnow() report_timedelta = timedelta(minutes=report_freq) blockchain = Blockchain(mode="head", blockchain_instance=hive) if block_num: start_time = Block(block_num)["timestamp"].replace(tzinfo=None) elif hours_ago: start_time = datetime.utcnow() - hours_ago block_num = blockchain.get_estimated_block_num(start_time) else: raise ValueError( "scan_history: block_num or --old=<hours> required sto scan history" ) allowed_accounts = get_allowed_accounts() count_posts = 0 pings = 0 if reports: logging.info("Started catching up") # beem type doesn't have type hints # noinspection PyTypeChecker stream = blockchain.stream( opNames=["custom_json"], start=block_num, max_batch_size=50, raw_ops=False, threading=False, ) post = None for post in stream: post_time = post["timestamp"].replace(tzinfo=None) time_dif = post_time - start_time time_to_now = datetime.utcnow() - post_time count_posts += 1 if reports: if time_dif > report_timedelta: timestamp = post["timestamp"] current_block_num = post["block_num"] output_status( timestamp, pings, count_posts, time_to_now, current_block_num=current_block_num, reports=reports, quiet=quiet, ) start_time = post["timestamp"].replace(tzinfo=None) count_posts = 0 pings = 0 if allowed_op_id(post["id"]): if set(post["required_posting_auths"]) & allowed_accounts: count = output(post, quiet, use_test_node, write_csv, "data-podping") pings += count Pings.total_pings += count else: if include_unauthorized: count = output(post, quiet, use_test_node, write_csv, "data-unauthorized") pings += count Pings.total_pings += count else: if include_non_podping: output(post, quiet, use_test_node, write_csv, "data-not-podping_firehose") if time_to_now < timedelta(seconds=2): timestamp = post["timestamp"] current_block_num = post["block_num"] output_status( timestamp, pings, count_posts, time_to_now, current_block_num=current_block_num, reports=reports, quiet=quiet, ) logging.info(f"block_num: {post['block_num']}") # Break out of the for loop we've caught up. break if post: scan_time = datetime.utcnow() - scan_start_time logging.info( f"Finished catching up at block_num: {post['block_num']} in {scan_time}" )
owner_privkey = owner_key.get_private_key() memo_privkey = memo_key.get_private_key() if useWallet: stm.wallet.addPrivateKey(owner_privkey) stm.wallet.addPrivateKey(active_privkey) stm.wallet.addPrivateKey(memo_privkey) stm.wallet.addPrivateKey(posting_privkey) else: stm = Steem(node=testnet_node, wif={'active': str(active_privkey), 'posting': str(posting_privkey), 'memo': str(memo_privkey)}) account = Account(username, steem_instance=stm) if account["name"] == "beem": account.disallow("beem1", permission='posting') account.allow('beem1', weight=1, permission='posting', account=None) account.follow("beem1") elif account["name"] == "beem5": account.allow('beem4', weight=2, permission='active', account=None) if useWallet: stm.wallet.getAccountFromPrivateKey(str(active_privkey)) # stm.create_account("beem1", creator=account, password=password1) account1 = Account("beem1", steem_instance=stm) b = Blockchain(steem_instance=stm) blocknum = b.get_current_block().identifier account.transfer("beem1", 1, "SBD", "test") b1 = Block(blocknum, steem_instance=stm)
s = Steem("https://steemd.minnowsupportproject.org") s = Steem("https://api.steemit.com") #读取日志 con = sqlite3.connect('steemdatabase.db') cur = con.cursor() f2 = open('block.txt', 'r') txt = f2.read() number_block=int(txt) print("start:",number_block) while p==1: try: #while True: block = Block(number_block,steem_instance=s) a=block.json_transactions print("Block:",number_block) write=0 for i in a: timess=i["expiration"] operations=i["operations"][0] types=operations["type"] if types == "delegate_vesting_shares_operation": write=1 print("find:",operations) name = operations["value"]["delegator"] towho = operations["value"]["delegatee"] vesting_shares=operations["value"]["vesting_shares"]["amount"] vesting = float(vesting_shares)/1000000
def treat_block(no): global last_idb, idb, blocks_checked, blocks_treat # Adding the number of this block to the currently treated list if no not in blocks_treat: blocks_treat.append(no) # If we're missing some blocks, we launch new threads while no != (last_idb + 1) and (last_idb + 1) <= idb: if (last_idb + 1) in blocks_treat: time.sleep(0.2) else: threading.Thread(target=treat_block, args=[last_idb + 1]).start() time.sleep(0.2) block_valid = 0 tries = 0 # Extracting operations from the block while block_valid == 0 and tries < 10: try: # print("Treating Block %s" % no) block_posts = Block(no).ops() blocks_checked += 1 block_valid = 1 except Exception as e: print("*** ERROR IN BLOCK %s (Try %s) : %s" % (no, tries, e)) block_valid = 0 tries += 1 time.sleep(0.1) if tries == 10: print("--- Master Error on Block %s" % no) # If the extraction worked if block_valid == 1: for b in block_posts: indic_tag = 0 indic_mention = 0 # If the operation is a comment if b[0] == 'comment': if b[1]["title"] != "" and b[1]["parent_author"] == "": try: # Getting the json_metadata if b[1]['json_metadata'] != '': metadata = json.loads(b[1]['json_metadata']) if target_tag in metadata["tags"]: print("-> Post with tag") indic_tag = 1 except Exception as err: pass if target_tagc in b[1]['body']: print("-> Body with tag") indic_tag = 1 if target_mention in b[1]['body']: print("-> Body with mention") indic_mention = 1 if indic_tag == 1 or indic_mention == 1: threading.Thread(target=treat_post, args=[b, "TAG"]).start() # If we've been proxied votes if b[0] == 'account_witness_proxy' and b[1][ 'proxy'] == account_name: print("-> Been proxied") threading.Thread(target=treat_post, args=[b, "PROXY"]).start() # Block is now treated, we remove it from the currently treated blocks blocks_treat = list(filter(lambda x: x != no, blocks_treat)) # print(blocks_treat) # Connecting to the database indic_conn = 0 while indic_conn == 0: try: conn = mdb.connect(MySQL_Host, MySQL_User, MySQL_Pass, MySQL_Base, charset='utf8mb4') cur = conn.cursor() indic_conn = 1 except (mdb.Error, mdb.Warning): time.sleep(0.25) # Updating the last block number sql = "UPDATE LAST_BLOCK SET NUM = %s WHERE UID = 1" try: cur.execute(sql, (no, )) last_idb = no except mdb.Error as e: print("*SQL Error : %S" % e) # Closing connection cur.close() conn.commit() conn.close() # print("Last Block %s" % last_idb) del block_posts return
b = Blockchain(steem_instance=stm) blocks_per_day = 20 * 60 * 24 if newBlockTrxStorage: start_block = 1091 trx_id_list = [] else: start_block = blockTrxStorage.get_latest_block_num() trx_id_list = blockTrxStorage.get_block_trx_id(start_block) if start_block is None: start_block = 1091 trx_id_list = [] end_block = b.get_current_block_num() end_block_round = int(start_block) + blocks_per_day - 1 cnt = 0 sb = Block(start_block, steem_instance=stm) print("start: %d - %s" % (start_block, str(sb["timestamp"]))) end_date = datetime(sb["timestamp"].year, sb["timestamp"].month, sb["timestamp"].day, 23, 59, 50) + timedelta(seconds = 60 * 60 * 24) if (addTzInfo(end_date) - sb["timestamp"]).total_seconds() / 60 / 60 / 24 > 1.1: end_date = datetime(sb["timestamp"].year, sb["timestamp"].month, sb["timestamp"].day, 23, 59, 50) #end_block_round = b.get_estimated_block_num(end_date) - 1 print("end: %d - %s" % (end_block_round, str(end_date))) next_account_id = accountTrxStorage.get_latest_index() + 1 if end_block_round > end_block: end_block_round = end_block data_available = False db_data = [] db_account = [] db_follow = [] accounts = accountTrxStorage.get_accounts()
def main(args=None): args = parse_args(args) blockchain = args.blockchain nodelist = NodeList() nodelist.update_nodes(weights={"block": 1}) if blockchain == "hive" or blockchain is None: max_batch_size = 50 threading = False thread_num = 16 block_debug = 1000 nodes = nodelist.get_hive_nodes() blk_inst = Hive(node=nodes, num_retries=3, num_retries_call=3, timeout=30) elif blockchain == "blurt": max_batch_size = None threading = False thread_num = 8 block_debug = 20 nodes = ["https://rpc.blurt.buzz/", "https://api.blurt.blog", "https://rpc.blurtworld.com", "https://rpc.blurtworld.com"] blk_inst = Blurt(node=nodes, num_retries=3, num_retries_call=3, timeout=30) elif blockchain == "steem": max_batch_size = 50 threading = False thread_num = 16 block_debug = 1000 nodes = nodelist.get_steem_nodes() blk_inst = Steem(node=nodes, num_retries=3, num_retries_call=3, timeout=30) else: raise Exception("Wrong parameter, can be hive, blurt or steem") print(blk_inst) block_count = 0 total_ops = 0 total_trx = 0 duration_s = 60 * 60 * 1 blocksperday = int(duration_s / 3) blockchain = Blockchain(blockchain_instance=blk_inst, ) current_block_num = blockchain.get_current_block_num() last_block_id = current_block_num - blocksperday last_block = Block(last_block_id, blockchain_instance=blk_inst) stopTime = last_block.time() + timedelta(seconds=duration_s) start = timer() op_stats = {} for entry in blockchain.blocks(start=last_block_id, max_batch_size=max_batch_size, threading=threading, thread_num=thread_num): if "block" in entry: block_time = parse_time(entry["block"]["timestamp"]) else: block_time = entry["timestamp"] if block_time > stopTime: break block_count += 1 if "block" in entry: trxs = entry["block"]["transactions"] else: trxs = entry["transactions"] for tx in trxs: total_trx += 1 for op in tx["operations"]: if "_operation" in op["type"]: op_type = op["type"][:-10] else: op_type = op["type"] if op_type in op_stats: op_stats[op_type] += 1 else: op_stats[op_type] = 1 total_ops += 1 ops_per_day = total_ops / block_count * blocksperday if block_count % (block_debug) == 0: print("%d blocks remaining... estimated ops per day: %.1f" % (blocksperday - block_count, ops_per_day)) duration = timer() - start t = PrettyTable(["Type", "Count", "percentage"]) t.align = "l" op_list = [] for o in op_stats: op_list.append({"type": o, "n": op_stats[o], "perc": op_stats[o] / total_ops * 100}) op_list_sorted = sorted(op_list, key=lambda x: x['n'], reverse=True) for op in op_list_sorted: t.add_row([op["type"], op["n"], "%.2f %%" % op["perc"]]) print(t)
def benchmark_node(node, how_many_minutes=10, how_many_seconds=30): block_count = 0 history_count = 0 access_time = 0 follow_time = 0 blockchain_version = u'0.0.0' successful = True error_msg = None start_total = timer() max_batch_size = None threading = False thread_num = 16 authorpermvoter = u"@gtg/steem-pressure-4-need-for-speed|gandalf" [author, permlink, voter] = resolve_authorpermvoter(authorpermvoter) authorperm = construct_authorperm(author, permlink) last_block_id = 19273700 try: stm = Steem(node=node, num_retries=3, num_retries_call=3, timeout=30) blockchain = Blockchain(steem_instance=stm) blockchain_version = stm.get_blockchain_version() last_block = Block(last_block_id, steem_instance=stm) stopTime = last_block.time() + timedelta(seconds=how_many_minutes * 60) total_transaction = 0 start = timer() for entry in blockchain.blocks(start=last_block_id, max_batch_size=max_batch_size, threading=threading, thread_num=thread_num): block_no = entry.identifier block_count += 1 if "block" in entry: trxs = entry["block"]["transactions"] else: trxs = entry["transactions"] for tx in trxs: for op in tx["operations"]: total_transaction += 1 if "block" in entry: block_time = parse_time(entry["block"]["timestamp"]) else: block_time = parse_time(entry["timestamp"]) if block_time > stopTime: last_block_id = block_no break if timer() - start > how_many_seconds or quit_thread: break except NumRetriesReached: error_msg = 'NumRetriesReached' block_count = -1 except KeyboardInterrupt: error_msg = 'KeyboardInterrupt' # quit = True except Exception as e: error_msg = str(e) block_count = -1 try: stm = Steem(node=node, num_retries=3, num_retries_call=3, timeout=30) account = Account("gtg", steem_instance=stm) blockchain_version = stm.get_blockchain_version() start = timer() for acc_op in account.history_reverse(batch_size=100): history_count += 1 if timer() - start > how_many_seconds or quit_thread: break except NumRetriesReached: error_msg = 'NumRetriesReached' history_count = -1 successful = False except KeyboardInterrupt: error_msg = 'KeyboardInterrupt' history_count = -1 successful = False # quit = True except Exception as e: error_msg = str(e) history_count = -1 successful = False try: stm = Steem(node=node, num_retries=3, num_retries_call=3, timeout=30) account = Account("gtg", steem_instance=stm) blockchain_version = stm.get_blockchain_version() start = timer() Vote(authorpermvoter, steem_instance=stm) stop = timer() vote_time = stop - start start = timer() Comment(authorperm, steem_instance=stm) stop = timer() comment_time = stop - start start = timer() Account(author, steem_instance=stm) stop = timer() account_time = stop - start start = timer() account.get_followers() stop = timer() follow_time = stop - start access_time = (vote_time + comment_time + account_time + follow_time) / 4.0 except NumRetriesReached: error_msg = 'NumRetriesReached' access_time = -1 except KeyboardInterrupt: error_msg = 'KeyboardInterrupt' # quit = True except Exception as e: error_msg = str(e) access_time = -1 return {'successful': successful, 'node': node, 'error': error_msg, 'total_duration': timer() - start_total, 'block_count': block_count, 'history_count': history_count, 'access_time': access_time, 'follow_time': follow_time, 'version': blockchain_version}
nodes = get_node_list(appbase=False) + get_node_list(appbase=True) t = PrettyTable([ "node", "10 blockchain minutes", "10000 virtual account op", "version" ]) t.align = "l" for node in nodes: print("Current node:", node) try: stm = Steem(node=node, num_retries=3) blockchain = Blockchain(steem_instance=stm) account = Account("gtg", steem_instance=stm) virtual_op_count = account.virtual_op_count() blockchain_version = stm.get_blockchain_version() last_block_id = 19273700 last_block = Block(last_block_id, steem_instance=stm) startTime = datetime.now() stopTime = last_block.time() + timedelta(seconds=how_many_minutes * 60) ltime = time.time() cnt = 0 total_transaction = 0 start_time = time.time() last_node = blockchain.steem.rpc.url for entry in blockchain.blocks(start=last_block_id, max_batch_size=max_batch_size, threading=threading, thread_num=thread_num):
payload = json.loads(trx["payload"]) contract = trx["contract"] action = trx["action"] if action == "sell": if "events" not in logs: continue elif len(logs["events"]) == 1: continue else: token_found = False for transfer in logs["events"]: if transfer["data"]["symbol"] in scan_token: token_found = True if token_found: steem_block = Block(block["refSteemBlockNumber"]) print( "%d (%s) - %s:" % (block["blockNumber"], steem_block.json()["timestamp"], trx['transactionId'])) print("%s sold %s %s for %s" % (trx["sender"], payload["quantity"], payload["symbol"], payload["price"])) for transfer in logs["events"]: print(" - %s transfers %s %s to %s" % (transfer["data"]["from"], transfer["data"]["quantity"], transfer["data"]["symbol"], transfer["data"]["to"])) elif action == "buy":
def main(args=None): args = parse_args(args) blockchain = args.blockchain nodelist = NodeList() nodelist.update_nodes(weights={"block": 1}) if blockchain == "hive" or blockchain is None: max_batch_size = 50 threading = False thread_num = 16 block_debug = 1000 nodes = nodelist.get_hive_nodes() blk_inst = Hive(node=nodes, num_retries=3, num_retries_call=3, timeout=30) elif blockchain == "blurt": max_batch_size = None threading = False thread_num = 8 block_debug = 20 nodes = [ "https://api.blurt.blog", "https://rpc.blurtworld.com", "https://rpc.blurtworld.com" ] blk_inst = Blurt(node=nodes, num_retries=3, num_retries_call=3, timeout=30) elif blockchain == "steem": max_batch_size = 50 threading = False thread_num = 16 block_debug = 1000 nodes = nodelist.get_steem_nodes() blk_inst = Steem(node=nodes, num_retries=3, num_retries_call=3, timeout=30) else: raise Exception("Wrong parameter, can be hive, blurt or steem") print(blk_inst) block_count = 0 total_ops = 0 total_virtual_ops = 0 total_trx = 0 blocksperday = 20 * 60 * 24 blockchain = Blockchain(blockchain_instance=blk_inst, ) current_block_num = blockchain.get_current_block_num() last_block_id = current_block_num - blocksperday last_block = Block(last_block_id, blockchain_instance=blk_inst) stopTime = last_block.time() + timedelta(seconds=60 * 60 * 24) start = timer() for entry in blockchain.blocks(start=last_block_id, max_batch_size=max_batch_size, threading=threading, thread_num=thread_num): if "block" in entry: block_time = parse_time(entry["block"]["timestamp"]) else: block_time = entry["timestamp"] if block_time > stopTime: break block_count += 1 if "block" in entry: trxs = entry["block"]["transactions"] else: trxs = entry["transactions"] for tx in trxs: total_trx += 1 for op in tx["operations"]: total_ops += 1 ops_per_day = total_ops / block_count * blocksperday if block_count % (block_debug) == 0: print("%d blocks remaining... estimated ops per day: %.1f" % (blocksperday - block_count, ops_per_day)) duration = timer() - start stopTime = last_block.time() + timedelta(seconds=60 * 60 * 24) start = timer() for entry in blockchain.blocks(start=last_block_id, max_batch_size=max_batch_size, threading=threading, thread_num=thread_num, only_virtual_ops=True): block_time = entry["timestamp"] if block_time > stopTime: break for tx in entry["operations"]: for op in tx["op"]: total_virtual_ops += 1 duration = timer() - start print("Received %.2f blocks/s." % (block_count / duration)) print("Bocks: %d, duration %.3f s" % (block_count, duration)) print("Operations per day: %d" % total_ops) print("Trx per day: %d" % total_trx) print("Virtual Operations per day: %d" % total_virtual_ops)