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
