def test_get_approvee(self): key = iota.TransactionHash( b'UNUK99RCIWLUQ9WMUT9MPQSZCHTUMGN9IWOCOXWMNPICCCQKLLNIIE9UIFGKZLHRI9QAOEQXQJLL99999' ) value = list(self.provider.get(key, 'approvee')) expect = [ TransactionHash( b'YUPJOZMOSVIEQZXSVTLSYMIGMLFGDBPSZUTRAML9MIQNCLCMPOGFRAYLSFJUDBJBFDGESTIAFGZR99999' ), TransactionHash( b'ELIWEYAYXYEFOWBHJMELTKVERQWTJF9RXRLISNNQQVWGS9EMYYBVWRJYVJUYAPBGDQNYQEZOPBXWA9999' ), ] self.assertEqual(Counter(value), Counter(expect)) # Bad self.assertFalse( list( self.provider.get( iota.TryteString('9' * (iota.Hash.LEN - 1) + 'A'), 'approvee'))) self.assertFalse( list(self.provider.get(iota.TransactionHash('FOOBAR'), 'approvee'))) with self.assertRaises(ValueError): self.assertIsNone( self.provider.get(iota.TryteString('FOOBAR'), 'approvee')) with self.assertRaises(TypeError): self.provider.get('', 'approvee')
def test_next_transaction(self): key = iota.TransactionHash( 'PZYRMRVTSPQXNEQIQEBAGINMDAKOHPOLNH9LR9DTFWMWFQICXL9BJCWBUPMKZERKYKBDRIBYEJYH99999' ) value = self.provider.next(key, 'transaction') self.assertEqual( value[0], iota.TransactionHash( 'PZYUVYZADTFXQSJCMNVOUKDKOMOBEPLQSKJGNZGCKSXOSXEJKUBTUQZGOFMVDTLXBDYABFIVGZ9JZ9999' ))
def test_save_milestone(self): key = 26000 value = (key, iota.TransactionHash('FOO')) self.provider.save(key, value, 'milestone') v = self.provider.get(key, 'milestone') self.assertEqual(v, value) value = (key, iota.TransactionHash('BAR')) self.provider.save(key, value, 'milestone') v = self.provider.get(key, 'milestone') self.assertEqual(v, value)
def test_save_state_diff(self): key = iota.TransactionHash('EXAMPLE') value = [(iota.TransactionHash('FOO'), 1000000), (iota.TransactionHash('BAR'), -10000000)] self.provider.save(key, value, 'state_diff') v = self.provider.get(key, 'state_diff') self.assertEqual(list(v), value) value = [(iota.TransactionHash('THISWILLOVERRIDETHEVALUE'), 10000)] self.provider.save(key, value, 'state_diff') v = self.provider.get(key, 'state_diff') self.assertEqual(list(v), value)
def test_save_address(self): key = iota.Address('EXAMPLE') value = [iota.TransactionHash('FOO'), iota.TransactionHash('BAR')] self.provider.save(key, value, 'address') v = self.provider.get(key, 'address') self.assertEqual(list(v), value) value = [iota.TransactionHash('THISWILLOVERRIDETHEVALUE')] self.provider.save(key, value, 'address') v = self.provider.get(key, 'address') self.assertEqual(list(v), value)
def milestone_list(num): milestone = [] #Last milestone index933209 while num <=61491: if num<=61491: # First miilestone index if num == 18750: milestone_dict = {} milestone_dict["index"] = r.first("milestone")[0] milestone_dict['hash'] = str(r.first("milestone")[1][1]) txh = iota.TransactionHash(str(r.first("milestone")[1][1])) column_family = 'transaction' tx = r.get(txh, column_family) milestone_dict['trunk_hash'] = str(tx.trunk_transaction_hash) milestone_dict['branch_hash'] = str(tx.branch_transaction_hash) milestone_dict['timestamp'] = str(tx.timestamp) milestone.append(milestone_dict) print(milestone_dict) else: milestone_dict = {} milestone_dict['index'] = r.next(num,'milestone')[0] milestone_dict['hash'] = str(r.next(num,'milestone')[1][1]) txh = iota.TransactionHash(str(r.next(num,'milestone')[1][1])) column_family = 'transaction' tx = r.get(txh, column_family) milestone_dict['trunk_hash'] = str(tx.trunk_transaction_hash) milestone_dict['branch_hash'] = str(tx.branch_transaction_hash) milestone_dict['timestamp'] = str(tx.timestamp) # Genesis milestone branch_hash is all9 if str(tx.branch_transaction_hash) == "999999999999999999999999999999999999999999999999999999999999999999999999999999999": genesis.append(milestone_dict) print('genesis',milestone_dict) print(milestone_dict) milestone.append(milestone_dict) num = num + 1 # with open("{n}_milestone_dict.json".format(n = name),"w") as f: json.dump(milestone,f) #f.flush() with open("{n}_genesis_dict.json".format(n = name),"w") as f: json.dump(genesis,f) #f.flush() return milestone
def test_get_transaction_metadata(self): key = iota.TransactionHash('PZYRMRVTSPQXNEQIQEBAGINMDAKOHPOLNH9LR9DTFWMWFQICXL9BJCWBUPMKZERKYKBDRIBYEJYH99999') value = self.provider.get(key, 'transaction_metadata') expect = {'address': iota.Address(b'9TPHVCFLAZTZSDUWFBLCJOZICJKKPVDMAASWJZNFFBKRDDTEOUJHR9JVGTJNI9IYNVISZVXARWJFKUZWC'), 'bundle_hash': iota.BundleHash(b'VLQUIJHXNWAINTXQNEQHNIASGSPYPOTNMQCM9RJPETERGLWIIKRLBZSCGPDYSFNZQ9FT9ZMQXZXNITRAC'), 'trunk_transaction_hash': TransactionHash(b'KTTHXMASNRQOSGZOW9ODAOBQFXKMPKNKWLIWDBVWJGMKQUBBPX9WHCYXCWEAHVTNZHPDKUWHOWN9Z9999'), 'branch_transaction_hash': TransactionHash(b'J9ZMRIJXZOZRNDHKOUBQGHPAPHQ9QOXFEEVQMJBMBOHKEVNUHJTEMRD9W9UDYMTGQ9ENQKDTJMJN99999'), 'legacy_tag': iota.Hash(b'EXAMPLEPYTHONLIB99999999999999999999999999999999999999999999999999999999999999999'), 'value': 0, 'current_index': 0, 'last_index': 0, 'timestamp': 1508993982, 'tag': iota.Hash(b'EXAMPLEPYTHONLIB99999999999999999999999999999999999999999999999999999999999999999'), 'attachment_timestamp': 1508993991533, 'attachment_timestamp_lower_bound': 0, 'attachment_timestamp_upper_bound': 12, 'validity': 1, 'type': -1, 'height': 0, 'solid': True} self.assertIsInstance(value, dict) self.assertEqual(value['solid'], True) for k in expect: self.assertEqual(value[k], expect[k], '"%s" different' % k)
def test_get_transaction(self): key = iota.TransactionHash( 'PZYRMRVTSPQXNEQIQEBAGINMDAKOHPOLNH9LR9DTFWMWFQICXL9BJCWBUPMKZERKYKBDRIBYEJYH99999' ) value = self.provider.get(key, 'transaction') # XXX: Skip the test now value.as_json_compatible()
def test_may_exist(self): # XXX: This function is not work now key = iota.TransactionHash( 'PZYRMRVTSPQXNEQIQEBAGINMDAKOHPOLNH9LR9DTFWMWFQICXL9BJCWBUPMKZERKYKBDRIBYEJYH99999' ) self.assertTrue(self.provider.may_exist(key, 'transaction')) self.assertFalse( self.provider.may_exist(iota.Hash('FOOBAR'), 'transaction'))
def test_first_milestone(self): key, value = self.provider.first('milestone') self.assertEqual(key, 243001) self.assertEqual(value, ( 243001, iota.TransactionHash( b'9PPVIKDMKUDXTYJFF9YNWUPPMOYZTYKRBFGLGDCNNNIMWAMGVJGEHOCOUDYRVYPPSDKDKDQXUBMYA9999' )))
def test_get_state_diff(self): key, value = self.provider.latest('state_diff') self.assertIsInstance(key, iota.TransactionHash) self.assertIsInstance(value, types.GeneratorType) # Bad self.assertFalse(list(self.provider.get(iota.TryteString('9' * (iota.Hash.LEN - 1) + 'A'), 'state_diff'))) self.assertFalse(list(self.provider.get(iota.TransactionHash('FOOBAR'), 'state_diff'))) with self.assertRaises(ValueError): self.assertIsNone(self.provider.get(iota.TryteString('FOOBAR'), 'state_diff')) with self.assertRaises(TypeError): self.provider.get('', 'state_diff')
def test_get_milestone(self): key = 259773 value = self.provider.get(key, 'milestone') self.assertEqual(value, (259773, iota.TransactionHash(b'9FRPRZZYOQSGZILXVNTSLKULYBODWKWTZHGGZ9WPOCRSJXSLAPNAHENFJNOEKCAMNQPBRNZDVJDZZ9999'))) # Bad self.assertIsNone(self.provider.get(-1, 'milestone')) self.assertIsNone(self.provider.get(0, 'milestone')) with self.assertRaises(TypeError): self.provider.get('test', 'milestone') with self.assertRaises(TypeError): self.provider.get(b'test', 'milestone') with self.assertRaises(TypeError): self.provider.get(None, 'milestone')
name = "MS13" r = iotapy.storage.providers.rocksdb.RocksDBProvider( db_path='/home/fyg/MS13/0933210-1039245/mainnetdb', db_log_path='/home/fyg/MS13/0933210-1039245/mainnetdb.log', read_only=True) r.init() file = "MS13_940227.json" all_nines = '9' * 81 #Last milestone hash, the extracting process always begin from the last milestone solid_milestone = "BYMILWAGSRENEYICAHLOGNQUEYZ9IOTZBEMZGDBCNXAJCQLMHYTXBJAFQWTZZGPVROKJRXTUCYTXZ9999" traversal_queue = [solid_milestone] EMPTY = iota.TransactionHash('9' * 81) tx_list = [] memDB = set() i = 0 with open(file, "w+") as f: while traversal_queue: tx_hash = traversal_queue.pop() if tx_hash in memDB or tx_hash == all_nines: continue txh = iota.TransactionHash(tx_hash) tx = r.get(txh, 'transaction')
def spam(api, txid, trans=None, max_time=None): if txid is not None: try: tx_trytes = api.get_trytes([ iota.TransactionHash(iota.TryteString(txid.encode('ascii'))) ])['trytes'][0] except: logger.error(traceback.format_exc()) return input_tx = iota.Transaction.from_tryte_string(tx_trytes) else: input_tx = trans start_time = time.time() logger.info('start promoting tx (%smin, %smi): %s (%s)', round((start_time - input_tx.timestamp) / 60), round(input_tx.value / 1000**2), input_tx.hash, input_tx.bundle_hash) count = 0 max_count = 7 sleeping = 0 while True: if is_confirmed(api, input_tx.bundle_hash): logger.info('bundle confirmed: %s', input_tx.bundle_hash) sumlogger.info('Success: %smin - %smi: %s', round((time.time() - start_time) / 60), round(input_tx.value / 1000**2), input_tx.bundle_hash) return try: tx_hashes = api.find_transactions([input_tx.bundle_hash])['hashes'] except: logger.warning(traceback.format_exc()) time.sleep(60) continue if len(tx_hashes) < 3: logger.warning('what is this bundle? only %s tx', len(tx_hashes)) bad_bundles.append(input_tx.bundle_hash) return logger.info('found %s tx in bundle. trying to promote/reattach', len(tx_hashes)) tx_trytes = [] chunks = [ tx_hashes[x:x + 1000] for x in range(0, len(tx_hashes), 1000) ] for chunk in chunks: try: tx_trytes += (api.get_trytes(chunk)['trytes']) except: logger.error(traceback.format_exc()) continue txs = [] for x in tx_trytes: txs.append(iota.Transaction.from_tryte_string(x)) tails = list(filter(lambda x: x.is_tail, txs)) tails = sorted(tails, key=lambda x: x.attachment_timestamp / 1000, reverse=True)[:min(len(tails), 10)] for tx in tails: if count < max_count: promote(api, tx) else: if reattach(api, tx): if not sleeping: sleeping = random.randint(1, 3) break if count == max_count: count = 0 else: count += 1 logger.info('run finished. %s more runs until reattach', max_count - count) while sleeping > 0: logger.info('%s min wait...', sleeping) time.sleep(60) sleeping -= 1 if max_time and ((time.time() - start_time) > max_time): logger.warning('Did take too long (%s).. Skipping', round((time.time() - start_time) / 60)) sumlogger.info('Timeout: %smin - %smi: %s', round((time.time() - start_time) / 60), round(input_tx.value / 1000**2), input_tx.bundle_hash) return