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 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', ), ], )