def test_get_addresses_single(self):
"""
Generating a single address.
"""
ag = AddressGenerator(self.seed_1)
# noinspection SpellCheckingInspection
self.assertListEqual(
ag.get_addresses(start=0),
[
Address(
b'DLEIS9XU9V9T9OURAKDUSQWBQEYFGJLRPRVEWKN9'
b'SSUGIHBEIPBPEWISSAURGTQKWKWNHXGCBQTWNOGIY',
),
],
)
# noinspection SpellCheckingInspection
self.assertListEqual(
ag.get_addresses(start=10),
[
Address(
b'XLXFTFBXUOOHRJDVBDBFEBDQDUKSLSOCLUYWGLAP'
b'R9FUROUHPFINIUFKYSRTFMNWKNEPDZATWXIVWJMDD',
),
],
)
def test_get_addresses_error_step_zero(self):
"""
Providing a ``step`` value of 0 to ``get_addresses``.
"""
ag = AddressGenerator(seed=b'')
with self.assertRaises(ValueError):
ag.get_addresses(start=0, step=0)
def test_get_addresses_error_count_too_small(self):
"""
Providing a ``count`` value less than 1 to ``get_addresses``.
:py:class:`AddressGenerator` can potentially generate an infinite
number of addresses, so there is no "end" to offset against.
"""
ag = AddressGenerator(seed=b'')
with self.assertRaises(ValueError):
ag.get_addresses(start=0, count=0)
def test_get_addresses_error_start_too_small(self):
"""
Providing a negative ``start`` value to ``get_addresses``.
:py:class:`AddressGenerator` can potentially generate an infinite
number of addresses, so there is no "end" to offset against.
"""
ag = AddressGenerator(seed=b'')
with self.assertRaises(ValueError):
ag.get_addresses(start=-1)
def test_get_addresses_multiple(self):
"""
Generating multiple addresses in one go.
"""
ag = AddressGenerator(self.seed_2)
# noinspection SpellCheckingInspection
self.assertListEqual(
ag.get_addresses(start=0, count=3),
[
Address(
b'FNKCVJPUANHNWNBAHFBTCONMCUBC9KCZ9EKREBCJ'
b'AFMABCTEPLGGXDJXVGPXDCFOUCRBWFJFLEAVOEUPY',
),
Address(
b'MSYILYYZLSJ99TDMGQHDOBWGHTBARCBGJZE9PIMQ'
b'LTEXJXKTDREGVTPA9NDGGLQHTMGISGRAKSLYPGWMB',
),
Address(
b'IIREHGHXUHARKVZDMHGUUCHZLUEQQULLEUSJHIIB'
b'WFYZIZDUFTOVHAWCKRJXUZ9CSUVLTRYSUGBVRMTOW',
),
],
)
# noinspection SpellCheckingInspection
self.assertListEqual(
ag.get_addresses(start=10, count=3),
[
Address(
b'BPXMVV9UPKBTVPJXPBHHOJYAFLALOYCGTSEDLZBH'
b'NFMGEHREBQTRIPZAPREANPMZJNZZNCDIUFOYYGGFY',
),
Address(
b'RUCZQJWKXVDIXTLHHOKGMHOV9AKVDBG9HUQHPWNZ'
b'UNKJNFVMULUSLKFJGSTBSNJMRYSJOBVBQSKVXISZB',
),
Address(
b'FQAKF9XVCLTBESJKWCHFOCTVABYEEJP9RXUVAEUW'
b'ENFUUQK9VCHFEORHCYDUJQHNUDWNRDUDZTUGKHSPD',
),
],
)
def address(self):
addresses = AddressGenerator(seed=self.seed,
checksum=False,
security_level=3)
main_address = addresses.get_addresses(0, 1)
main = str(main_address[0])
return main
def CreateAddress():
print("\nWelcome to IOTA addresses generator!")
seed = InputSeed()
if seed == None:
return
index = InputIndex()
if index == None:
return
index = int(index)
address_amount = InputAddressAmount()
if address_amount == None:
return
address_amount = int(address_amount)
generator = AddressGenerator(seed)
addresses = generator.get_addresses(start=index,
count=address_amount,
step=1)
offset = 0
for address in addresses:
print("\nYour Address #%d: %s" % (index + offset, address))
print("\n https://thetangle.org/address/%s" %
(address))
offset += 1
print()
def generate_addresses(self, count):
"""
Generates one or more addresses and saves them in the account file
:param count:
:return:
"""
index_list = [-1]
for data in self._data['account_data'][0]['address_data']:
index = data["index"]
index_list.append(index)
if max(index_list) == -1:
start_index = 0
else:
start_index = max(index_list) + 1
generator = AddressGenerator(self._seed)
addresses = generator.get_addresses(
start_index,
count) # This is the actual function to generate the address.
i = 0
while i < count:
index = start_index + i
address = addresses[i]
balance = address_balance(
self._data['account_data'][0]['settings'][0]['host'], address)
self._write_address_data(index, str(address), balance)
i += 1
self._update_fal_balance()
def _generate_addresses(self, count):
"""
Generate addresses for user
:param count:
"""
index_list = [-1]
for i in range(0, len(self.addresses)):
index_list.append(self.addresses[i].index)
if max(index_list) == -1:
start_index = 0
else:
start_index = max(index_list) + 1
generator = AddressGenerator(self.seed)
generated = generator.get_addresses(start_index, count)
i = 0
while i < count:
index = start_index + i
address = address_checksum(str(generated[i]))
balance = address_balance(current_app.config['IOTA_HOST'], address)
addr = IOTAAddress(index=index,
address=str(address),
balance=balance,
checksum=str(get_checksum(address, self.seed)))
addr.save()
self.addresses.append(addr)
i += 1
self.save()
def clientthread(conn, addr):
global address_num
global seed
conn.send("Connected to the PONG Server")
client_num = address_num
address_num = address_num + 1
file = open("pong.conf", "w")
file.write(str(address_num))
file.close()
generator = AddressGenerator(seed, 1, True)
addresses = generator.get_addresses(client_num, count=1)[0]
conn.send(str(addresses))
while True:
try:
message = conn.recv(2048)
if message:
print "<" + addr[0] + "> " + message
broadcast(message, conn)
else:
remove(conn)
except KeyboardInterrupt:
server.close()
except:
continue
def _find_addresses(self, seed, index, count, security_level, checksum):
# type: (Seed, int, Optional[int], int, bool) -> List[Address]
"""
Find addresses matching the command parameters.
"""
generator = AddressGenerator(seed, security_level, checksum)
if count is None:
# Connect to Tangle and find the first unused address.
for addy in generator.create_iterator(start=index):
# We use addy.address here because the commands do
# not work on an address with a checksum
response = WereAddressesSpentFromCommand(self.adapter)(
addresses=[addy.address], )
if response['states'][0]:
continue
response = FindTransactionsCommand(self.adapter)(
addresses=[addy.address], )
if response.get('hashes'):
continue
return [addy]
return generator.get_addresses(start=index, count=count)
async def _find_addresses(self, seed: Seed, index: int,
count: Optional[int], security_level: int,
checksum: bool) -> List[Address]:
"""
Find addresses matching the command parameters.
"""
generator = AddressGenerator(seed, security_level, checksum)
if count is None:
# Connect to Tangle and find the first unused address.
for addy in generator.create_iterator(start=index):
# We use addy.address here because the commands do
# not work on an address with a checksum
# Execute two checks concurrently
responses = await asyncio.gather(
WereAddressesSpentFromCommand(self.adapter)(
addresses=[addy.address], ),
FindTransactionsCommand(self.adapter)(
addresses=[addy.address], ),
)
# responses[0] -> was it spent from?
# responses[1] -> any transaction found?
if responses[0]['states'][0] or responses[1].get('hashes'):
continue
return [addy]
return generator.get_addresses(start=index, count=count)
def test_security_level_lowered(self):
"""
Generating addresses with a lower security level.
"""
ag = AddressGenerator(self.seed_1, security_level=1)
# noinspection SpellCheckingInspection
self.assertListEqual(
ag.get_addresses(start=0, count=3),
[
Address(
b'KNDWDEEWWFVZLISLYRABGVWZCHZNZLNSEJXFKVGA'
b'UFLL9UMZYEZMEJB9BDLAASWTHEKFREUDIUPY9ICKW',
),
Address(
b'CHOBTRTQWTMH9GWFWGWUODRSGPOJOIVJUNIQIBZL'
b'HSWNYPHOD9APWJBMJMGLHFZENWFKDYWHX9JDFXTAB',
),
Address(
b'YHTOYQUCLDHAIDILFNPITVPYSTOCFAZIUNDYTRDZ'
b'CVMVGZPONPINNVPJTOAOKHHZWLOKIZPVASTOGAKPA',
),
],
)
def test_security_level_elevated(self):
"""
Generating addresses with a higher security level.
"""
ag = AddressGenerator(self.seed_1, security_level=3)
# noinspection SpellCheckingInspection
self.assertListEqual(
ag.get_addresses(start=0, count=3),
[
Address(
b'BGHTGOUKKNTYFHYUAAPSRUEVN9QQXFOGVCH9Y9BO'
b'NWXUBDLSKAWEOFZIVMHXBAYVPGDZEYCKNTUJCLPAX',
),
Address(
b'EGMRJEUIYFUGWAIXXZCHCZUVUUYITICVHDSHCQXG'
b'FHJIVDCLTI9ZVRIKRLZQWW9CPOIXVDCBAHVGLUHI9',
),
Address(
b'ENPSARVJZGMMPWZTAIRHADEOZCEVIFNJWSZQHNEI'
b'RVEVI9GYMFNEOGNUYCPGPSEFCSDHUHOQKDPVGDKYC',
),
],
)
def generate_address(num):
seed = b"N9MOJKSFIHTPRIBYDIWEHLRNBLNFSLWPVNYTEGBIRAOZRJSIBXDNCDBVPSEJRFVRSMISGQMSLAGZEVQTR"
generator = AddressGenerator(seed=seed, security_level=2)
results = generator.get_addresses(0, num+2)
with open('./Snapshot.txt', 'w') as fs:
for i in range(0, num+1):
fs.write(str(results[i]) + ';' + '1000000000\n')
fs.write(str(results[num+1]) +';' + str(2779530283277761-1000000000*(num+1)))
def generate_addresses(count=1, seed=None):
"""Generates a number of IOTA addresses (given by count and optional seed)
Returns: (address, seed)
"""
if seed is None:
seed = Seed.random()
generator = AddressGenerator(seed=seed, security_level=security_level)
return (generator.get_addresses(0, count), seed) # index, count
def test_cache_miss_seed(self):
"""
Cached addresses are keyed by seed.
"""
AddressGenerator.cache = MemoryAddressCache()
mock_generate_address = Mock(return_value=self.addy)
with patch(
'iota.crypto.addresses.AddressGenerator._generate_address',
mock_generate_address,
):
generator1 = AddressGenerator(Seed.random())
generator1.get_addresses(42)
mock_generate_address.assert_called_once()
generator2 = AddressGenerator(Seed.random())
generator2.get_addresses(42)
self.assertEqual(mock_generate_address.call_count, 2)
def generator(): chars=u'9ABCDEFGHIJKLMNOPQRSTUVWXYZ' #27 characters - max number you can express by one Tryte - do you remember? rndgenerator = random.SystemRandom() MySeed = u''.join(rndgenerator.choice(chars) for _ in range(81)) generator = AddressGenerator(seed=MySeed, security_level=2) addresses = generator.get_addresses(0, 3) #index, count return(addresses)
def test_get_addresses_single(self):
"""
Generating a single address.
"""
# Seed is not important for this test; it is only used by
# :py:class:`KeyGenerator`, which we will mock in this test.
ag = AddressGenerator(seed=b'')
# noinspection PyUnresolvedReferences
with patch.object(ag, '_get_digest', self._mock_get_digest):
addresses = ag.get_addresses(start=0)
self.assertListEqual(addresses, [self.addy0])
# noinspection PyUnresolvedReferences
with patch.object(ag, '_get_digest', self._mock_get_digest):
# You can provide any positive integer as the ``start`` value.
addresses = ag.get_addresses(start=2)
self.assertListEqual(addresses, [self.addy2])
def __init__(self, name, initBal=100):
self.name = name
self.bal = initBal
self.seed = iota.crypto.types.Seed.random(
) # Generates official random 81 tryte seed
generator = AddressGenerator(
self.seed, security_level=1) # Generates IOTA address from seed
self.address = generator.get_addresses(start=0)
self.address = self.address[0].address
keyGen = KeyGenerator(self.seed)
self.privKey = keyGen.get_key(
index=0, iterations=1) # Generate IOTA key from seed
def test_get_addresses_multiple(self):
"""
Generating multiple addresses in one go.
"""
# Seed is not important for this test; it is only used by
# :py:class:`KeyGenerator`, which we will mock in this test.
ag = AddressGenerator(seed=b'')
# noinspection PyUnresolvedReferences
with patch.object(ag, '_get_digest', self._mock_get_digest):
addresses = ag.get_addresses(start=1, count=2)
self.assertListEqual(addresses, [self.addy1, self.addy2])
def test_get_addresses_single(self):
"""
Generating a single address.
"""
ag = AddressGenerator(self.seed_1)
self.assertListEqual(
ag.get_addresses(start=0),
[
Address(
b'DLEIS9XU9V9T9OURAKDUSQWBQEYFGJLRPRVEWKN9'
b'SSUGIHBEIPBPEWISSAURGTQKWKWNHXGCBQTWNOGIY', ),
],
)
self.assertListEqual(
ag.get_addresses(start=10),
[
Address(
b'XLXFTFBXUOOHRJDVBDBFEBDQDUKSLSOCLUYWGLAP'
b'R9FUROUHPFINIUFKYSRTFMNWKNEPDZATWXIVWJMDD', ),
],
)
def test_get_addresses_multiple(self):
"""
Generating multiple addresses in one go.
"""
ag = AddressGenerator(self.seed_2)
# noinspection SpellCheckingInspection
self.assertListEqual(
ag.get_addresses(start=0, count=3),
[
Address(
b'FNKCVJPUANHNWNBAHFBTCONMCUBC9KCZ9EKREBCJ'
b'AFMABCTEPLGGXDJXVGPXDCFOUCRBWFJFLEAVOEUPY', ),
Address(
b'MSYILYYZLSJ99TDMGQHDOBWGHTBARCBGJZE9PIMQ'
b'LTEXJXKTDREGVTPA9NDGGLQHTMGISGRAKSLYPGWMB', ),
Address(
b'IIREHGHXUHARKVZDMHGUUCHZLUEQQULLEUSJHIIB'
b'WFYZIZDUFTOVHAWCKRJXUZ9CSUVLTRYSUGBVRMTOW', ),
],
)
# noinspection SpellCheckingInspection
self.assertListEqual(
ag.get_addresses(start=10, count=3),
[
Address(
b'BPXMVV9UPKBTVPJXPBHHOJYAFLALOYCGTSEDLZBH'
b'NFMGEHREBQTRIPZAPREANPMZJNZZNCDIUFOYYGGFY', ),
Address(
b'RUCZQJWKXVDIXTLHHOKGMHOV9AKVDBG9HUQHPWNZ'
b'UNKJNFVMULUSLKFJGSTBSNJMRYSJOBVBQSKVXISZB', ),
Address(
b'FQAKF9XVCLTBESJKWCHFOCTVABYEEJP9RXUVAEUW'
b'ENFUUQK9VCHFEORHCYDUJQHNUDWNRDUDZTUGKHSPD', ),
],
)
def vanity_address_generator(vanity_text, report_interval=False):
"""Generates iota seed whose first subaddress begins with vanity_text
Type:
Function
Args:
vanity_text (str object, required) string
report_interval (int object, optional) reports progress via standard output at designated intervals if defined
Returns:
None
"""
# Tests
if report_interval < 0:
raise ValueError('Report interval cannot be negative')
if type(vanity_text) is not str:
raise TypeError('Vanity text must be type str')
for char in vanity_text.upper():
if char not in string.ascii_uppercase + '9':
raise ValueError('Vanity text must only contain chars A-Z and 9')
# Brute force loop
count = 0
while True:
secret = "".join([random.choice(string.ascii_letters + string.digits) for i in range(64)])
seed = next(seed_generator(secret, 0, 1))
ag = AddressGenerator(seed, checksum=True)
address = str(ag.get_addresses(0)[0])
if vanity_text in address[:len(vanity_text)]:
print()
print('Count: ', count)
print('Secret: ', secret)
print('Seed: ', seed)
print('Address: ', address)
print()
break
# Report
if report_interval:
if count % int(report_interval) == 0:
print('Count: ', str(count) + '\t', datetime.datetime.now() - datetime.timedelta(hours=-10))
count += 1
def _find_addresses(self, seed, index, count):
"""
Find addresses matching the command parameters.
"""
# type: (Seed, int, Optional[int]) -> List[Address]
generator = AddressGenerator(seed)
if count is None:
# Connect to Tangle and find the first address without any
# transactions.
for addy in generator.create_iterator(start=index):
response = FindTransactionsCommand(
self.adapter)(addresses=[addy])
if not response.get('hashes'):
return [addy]
return generator.get_addresses(start=index, count=count)
def test_get_addresses_step_negative(self):
"""
Providing a negative ``step`` value to ``get_addresses``.
This is probably a weird use case, but what the heck.
"""
ag = AddressGenerator(self.seed_1)
self.assertListEqual(
ag.get_addresses(start=1, count=2, step=-1),
[
Address(
b'PNLOTLFSALMICK9PSW9ZWLE9KJAKPKGJZQJDAFMO'
b'VLHXMJCJXFPVHOTTOYDIAUAYELXKZWZUITCQBIQKY', ),
Address(
b'DLEIS9XU9V9T9OURAKDUSQWBQEYFGJLRPRVEWKN9'
b'SSUGIHBEIPBPEWISSAURGTQKWKWNHXGCBQTWNOGIY', ),
],
)
def SearchLedgerIndex(recovery_words, passphrase, ledger_start_index,
ledger_end_index, ledger_start_page, ledger_end_page,
address_amount):
print("\nChecking ledger indexes for funds:")
for ledger_index in range(ledger_start_index, ledger_end_index + 1):
for ledger_page in range(ledger_start_page, ledger_end_page + 1):
print(" Ledger Index: %d, Ledger Page: %d" %
(ledger_index, ledger_page))
iota_seed = MnemonicsToIotaSeed(recovery_words,
passphrase,
bip44_account=ledger_index,
bip44_page_index=ledger_page)
generator = AddressGenerator(iota_seed)
addresses = generator.get_addresses(start=0,
count=address_amount,
step=1)
result = api.get_balances(addresses=addresses)
# search by available balances
found = False
for address_index, balance in enumerate(result['balances']):
if balance == 0:
continue
found = True
print(
"\n Found balance %di (seed: %s, ledger index: %d, ledger page: %d, address index: %d"
% (balance, iota_seed, ledger_index, ledger_page,
address_index))
print("\n Your Address: %s" % (addresses[address_index]))
print(
"\n https://explorer.iota.org/mainnet/address/%s"
% (addresses[address_index][:81]))
if found:
return
print(" no funds found!")
def test_security_level_lowered(self):
"""
Generating addresses with a lower security level.
"""
ag = AddressGenerator(self.seed_1, security_level=1)
self.assertListEqual(
ag.get_addresses(start=0, count=3),
[
Address(
b'KNDWDEEWWFVZLISLYRABGVWZCHZNZLNSEJXFKVGA'
b'UFLL9UMZYEZMEJB9BDLAASWTHEKFREUDIUPY9ICKW', ),
Address(
b'CHOBTRTQWTMH9GWFWGWUODRSGPOJOIVJUNIQIBZL'
b'HSWNYPHOD9APWJBMJMGLHFZENWFKDYWHX9JDFXTAB', ),
Address(
b'YHTOYQUCLDHAIDILFNPITVPYSTOCFAZIUNDYTRDZ'
b'CVMVGZPONPINNVPJTOAOKHHZWLOKIZPVASTOGAKPA', ),
],
)
def test_security_level_elevated(self):
"""
Generating addresses with a higher security level.
"""
ag = AddressGenerator(self.seed_1, security_level=3)
self.assertListEqual(
ag.get_addresses(start=0, count=3),
[
Address(
b'BGHTGOUKKNTYFHYUAAPSRUEVN9QQXFOGVCH9Y9BO'
b'NWXUBDLSKAWEOFZIVMHXBAYVPGDZEYCKNTUJCLPAX', ),
Address(
b'EGMRJEUIYFUGWAIXXZCHCZUVUUYITICVHDSHCQXG'
b'FHJIVDCLTI9ZVRIKRLZQWW9CPOIXVDCBAHVGLUHI9', ),
Address(
b'ENPSARVJZGMMPWZTAIRHADEOZCEVIFNJWSZQHNEI'
b'RVEVI9GYMFNEOGNUYCPGPSEFCSDHUHOQKDPVGDKYC', ),
],
)
def test_get_addresses_step_negative(self):
"""
Providing a negative ``step`` value to ``get_addresses``.
This is probably a weird use case, but what the heck.
"""
ag = AddressGenerator(self.seed_1)
# noinspection SpellCheckingInspection
self.assertListEqual(
ag.get_addresses(start=1, count=2, step=-1),
[
Address(
b'DUOVVF9WCNAEOHHWUYUFSYOOWZPDVVD9JKFLQN9Z'
b'DPAKKHSBKLTRFHD9UHIWGKSGAWCOMDG9GBPYISPWR', ),
Address(
b'NWQBMJEBSYFCRKGLNUQZJIOQOMNMYPCIRVSVJLP9'
b'OFV9CZ99LFGZHDKOUDGRVJXUDPUPCVOQBKSZLPU9K', ),
],
)
def test_security_level_elevated(self):
"""
Generating addresses with a higher security level.
"""
ag = AddressGenerator(self.seed_1, security_level=3)
# noinspection SpellCheckingInspection
self.assertListEqual(
ag.get_addresses(start=0, count=3),
[
Address(
b'ZWJEPOOWHOZYEMGJCJAWDETMBUEHOYFHAGOFINQA'
b'CSGFNHXTMDHVHVAWQHQEBLDXKOQVKHEIU9QWLWPSV', ),
Address(
b'TNCURBUSWSCMWKJMZFW9SDUTVMQRAHTWVPYQFDRZ'
b'ALTMDEMCVWEVWYIJZMKOCEPSJKRV9EGDDDCLMCJBL', ),
Address(
b'HHZUZEKUTMBBIFZDUBVSEXEPEDWATWOBBGVCHBMI'
b'MBVRLDDLBBWWMECJGNSXFJOCPOFSEZOHDGPVADYCK', ),
],
)
def test_get_addresses_step_negative(self):
"""
Providing a negative ``step`` value to ``get_addresses``.
This is probably a weird use case, but what the heck.
"""
# Seed is not important for this test; it is only used by
# :py:class:`KeyGenerator`, which we will mock in this test.
ag = AddressGenerator(seed=b'')
# noinspection PyUnresolvedReferences
with patch.object(ag, '_get_digest', self._mock_get_digest):
addresses = ag.get_addresses(start=1, count=2, step=-1)
self.assertListEqual(
addresses,
# This is the same as ``ag.get_addresses(start=0, count=2)``, but
# the order is reversed.
[self.addy1, self.addy0],
)
def test_security_level_lowered(self):
"""
Generating addresses with a lower security level.
"""
ag = AddressGenerator(self.seed_1, security_level=1)
# noinspection SpellCheckingInspection
self.assertListEqual(
ag.get_addresses(start=0, count=3),
[
Address(
b'QTGZZPTYYFMFG9UCTOREALIZZJ9VEASMBFLMZARF'
b'LENFSNPSITZZVXH9IGPVIRAVRYMXYVXQBUORWVILF', ),
Address(
b'FHOFBSATJIGMLKGGPWEBIBWIPELKTEAMAQTEDNUN'
b'HOJBVBAIGTPLMKSGBHWZGNXTLRMFZXASV9FNZGBNY', ),
Address(
b'VRYXJWWGQIKDLI9R9KFECQXCLYNBHUMCWEYDTOTZ'
b'GITLQIRDZCOBWXAOTVPGKBQBXKZAZAFRLZTDBRBXW', ),
],
)
def address_generator(seed, address_start=0, address_depth=1):
"""Generates iota addresses from a given seed to a desired depth
Type:
Function
Args:
secret (str object, required) 81 character iota seed
seed_start (int object, required) integer defining subaddress starting point
seed_start (int object, required) integer defining subaddress ending point
Returns:
None
"""
count = address_start
ag = AddressGenerator(seed, checksum=True)
for address in ag.get_addresses(address_start, address_depth):
print('Address {}:'.format(count), address)
count += 1
def _find_addresses(self, seed, index, count, security_level, checksum):
# type: (Seed, int, Optional[int], int, bool) -> List[Address]
"""
Find addresses matching the command parameters.
"""
generator = AddressGenerator(seed, security_level, checksum)
if count is None:
# Connect to Tangle and find the first address without any
# transactions.
for addy in generator.create_iterator(start=index):
# We use addy.address here because FindTransactions does
# not work on an address with a checksum
response = FindTransactionsCommand(self.adapter)(
addresses=[addy.address]
)
if not response.get('hashes'):
return [addy]
return generator.get_addresses(start=index, count=count)
def SearchLedgerIndexByTargetAddress(recovery_words, passphrase,
ledger_start_index, ledger_end_index,
ledger_start_page, ledger_end_page,
address_amount, target_address):
print("\nChecking ledger indexes for funds:")
for ledger_index in range(ledger_start_index, ledger_end_index + 1):
for ledger_page in range(ledger_start_page, ledger_end_page + 1):
print(" Ledger Index: %d, Ledger Page: %d" %
(ledger_index, ledger_page))
iota_seed = MnemonicsToIotaSeed(recovery_words,
passphrase,
bip44_account=ledger_index,
bip44_page_index=ledger_page)
generator = AddressGenerator(iota_seed)
addresses = generator.get_addresses(start=0,
count=address_amount,
step=1)
# search given target address
for address_index, address in enumerate(addresses):
if target_address != address:
continue
print(
"\n Found address (seed: %s, ledger index: %d, ledger page: %d, address index: %d"
% (iota_seed, ledger_index, ledger_page, address_index))
print("\n Your Address: %s" % (addresses[address_index]))
print(
"\n https://explorer.iota.org/mainnet/address/%s"
% (addresses[address_index][:81]))
return
print(" no funds found!")
def generate_addresses(count):
index_list = [-1]
for data in address_data:
index = data["index"]
index_list.append(index)
if max(index_list) == -1:
start_index = 0
else:
start_index = max(index_list) + 1
generator = AddressGenerator(seed)
addresses = generator.get_addresses(
start_index,
count) # This is the actual function to generate the address.
i = 0
while i < count:
index = start_index + i
address = addresses[i]
balance = address_balance(address)
write_address_data(index, str(address), balance)
i += 1
update_fal_balance()
def test_get_addresses_step_negative(self):
"""
Providing a negative ``step`` value to ``get_addresses``.
This is probably a weird use case, but what the heck.
"""
ag = AddressGenerator(self.seed_1)
# noinspection SpellCheckingInspection
self.assertListEqual(
ag.get_addresses(start=1, count=2, step=-1),
[
Address(
b'PNLOTLFSALMICK9PSW9ZWLE9KJAKPKGJZQJDAFMO'
b'VLHXMJCJXFPVHOTTOYDIAUAYELXKZWZUITCQBIQKY',
),
Address(
b'DLEIS9XU9V9T9OURAKDUSQWBQEYFGJLRPRVEWKN9'
b'SSUGIHBEIPBPEWISSAURGTQKWKWNHXGCBQTWNOGIY',
),
],
)
