def create_next_address(address):
# create next address from root_address
astrits = TryteString(str(root_address).encode()).as_trits()
checksum_trits = []
sponge = Kerl()
sponge.absorb(astrits)
sponge.squeeze(checksum_trits)
result = TryteString.from_trits(checksum_trits)
next_address = Address(result)
# check if the next address is unsused
check_address = api.find_transactions(addresses=[next_address])
if len(check_address['hashes']) == 0:
address_empty = True
else:
address_empty = False
# If new address is used create find an empty address
if address_empty == False:
astrits = TryteString(
(str(next_address) + str(root_address)).encode()).as_trits()
checksum_trits = []
sponge = Kerl()
sponge.absorb(astrits)
sponge.squeeze(checksum_trits)
result = TryteString.from_trits(checksum_trits)
next_address = Address(result)
else:
next_address = next_address
return next_address
def get_digest(self):
# type: () -> Digest
"""
Generates the digest used to do the actual signing.
Signing keys can have variable length and tend to be quite long,
which makes them not-well-suited for use in crypto algorithms.
The digest is essentially the result of running the signing key
through a PBKDF, yielding a constant-length hash that can be used
for crypto.
"""
hashes_per_fragment = FRAGMENT_LENGTH // Hash.LEN
key_fragments = self.iter_chunks(FRAGMENT_LENGTH)
# The digest will contain one hash per key fragment.
digest = [0] * HASH_LENGTH * len(key_fragments)
# Iterate over each fragment in the key.
for (i, fragment
) in enumerate(key_fragments): # type: Tuple[int, TryteString]
fragment_trits = fragment.as_trits()
key_fragment = [0] * FRAGMENT_LENGTH
hash_trits = []
# Within each fragment, iterate over one hash at a time.
for j in range(hashes_per_fragment):
hash_start = j * HASH_LENGTH
hash_end = hash_start + HASH_LENGTH
hash_trits = fragment_trits[
hash_start:hash_end] # type: MutableSequence[int]
for k in range(26):
sponge = Kerl()
sponge.absorb(hash_trits)
sponge.squeeze(hash_trits)
key_fragment[hash_start:hash_end] = hash_trits
#
# After processing all of the hashes in the fragment, generate a
# final hash and append it to the digest.
#
# Note that we will do this once per fragment in the key, so the
# longer the key is, the longer the digest will be.
#
sponge = Kerl()
sponge.absorb(key_fragment)
sponge.squeeze(hash_trits)
fragment_start = i * FRAGMENT_LENGTH
fragment_end = fragment_start + FRAGMENT_LENGTH
digest[fragment_start:fragment_end] = hash_trits
return Digest(TryteString.from_trits(digest), self.key_index)
def test_generate_multi_trytes_and_hash(self):
filepath =\
join(
dirname(__file__),
'test_vectors/generate_multi_trytes_and_hash.csv',
)
with open(filepath, 'r') as f:
reader = DictReader(f)
for count, line in enumerate(reader):
trytes = line['multiTrytes']
hashes = line['Kerl_hash']
trits = trytes_to_trits(trytes)
kerl = Kerl()
kerl.absorb(trits)
trits_out = []
kerl.squeeze(trits_out)
trytes_out = trits_to_trytes(trits_out)
self.assertEqual(
hashes,
trytes_out,
msg='line {count}: {hashes} != {trytes}'.format(
count=count + 2,
hashes=hashes,
trytes=trytes_out,
),
)
def __init__(self, private_key: PrivateKey, hash_: Hash) -> None:
super(SignatureFragmentGenerator, self).__init__()
self._key_chunks = private_key.iter_chunks(FRAGMENT_LENGTH)
self._iteration = -1
self._normalized_hash = normalize(hash_)
self._sponge = Kerl()
def finalize(self):
# type: () -> None
"""
Finalizes the bundle, preparing it to be attached to the Tangle.
"""
if self.hash:
raise RuntimeError('Bundle is already finalized.')
if not self:
raise ValueError('Bundle has no transactions.')
# Quick validation.
balance = self.balance
if balance < 0:
if self.change_address:
self.add_transaction(
ProposedTransaction(
address=self.change_address,
value=-balance,
tag=self.tag,
))
else:
raise ValueError(
'Bundle has unspent inputs (balance: {balance}); '
'use ``send_unspent_inputs_to`` to create '
'change transaction.'.format(balance=balance, ), )
elif balance > 0:
raise ValueError(
'Inputs are insufficient to cover bundle spend '
'(balance: {balance}).'.format(balance=balance, ), )
# Generate bundle hash.
sponge = Kerl()
last_index = len(self) - 1
for (i,
txn) in enumerate(self): # type: Tuple[int, ProposedTransaction]
txn.current_index = i
txn.last_index = last_index
sponge.absorb(txn.get_signature_validation_trytes().as_trits())
bundle_hash_trits = [0] * HASH_LENGTH # type: MutableSequence[int]
sponge.squeeze(bundle_hash_trits)
# Copy bundle hash to individual transactions.
bundle_hash = BundleHash.from_trits(bundle_hash_trits)
for txn in self:
txn.bundle_hash = bundle_hash
# Initialize signature/message fragment.
txn.signature_message_fragment = Fragment(txn.message or b'')
def _generate_checksum(self) -> 'AddressChecksum':
"""
Generates the correct checksum for this address.
"""
checksum_trits: MutableSequence[int] = []
sponge = Kerl()
sponge.absorb(self.address.as_trits())
sponge.squeeze(checksum_trits)
checksum_length = AddressChecksum.LEN * TRITS_PER_TRYTE
return AddressChecksum.from_trits(checksum_trits[-checksum_length:])
def _generate_checksum(self):
# type: () -> TryteString
"""
Generates the correct checksum for this address.
"""
checksum_trits = [] # type: MutableSequence[int]
sponge = Kerl()
sponge.absorb(self.address.as_trits())
sponge.squeeze(checksum_trits)
checksum_length = AddressChecksum.LEN * TRITS_PER_TRYTE
return TryteString.from_trits(checksum_trits[-checksum_length:])
def calc_hash(self, bundle):
Trxn_HASH_Trytes = 81
HASH_LENGTH = Trxn_HASH_Trytes * 3 # Trits conversion
# Generate bundle hash. (taken from python API client)
while True:
sponge = Kerl()
last_index = len(bundle) - 1
for i, txn in enumerate(bundle):
txn.current_index = i
txn.last_index = last_index
sponge.absorb(txn.get_bundle_essence_trits())
bundle_hash_trits = [0] * HASH_LENGTH
sponge.squeeze(bundle_hash_trits)
bundle_hash = BundleHash.from_trits(
bundle_hash_trits) # Convert trits to ascii Trytes
bundle.bundle_hash = bundle_hash
# Check that we generated a secure bundle hash.
# https://github.com/iotaledger/iota.py/issues/84
if any(13 in part for part in normalize(bundle_hash)):
# Increment the legacy tag and try again.
bundle.tail_transaction.increment_legacy_tag()
else:
break
# Copy bundle hash to individual transactions.
for txn in bundle:
txn.bundle_hash = bundle_hash
# Initialize signature/message fragment.
if not txn.value_trxn:
# Put dummy message in fragment.
# txn.signature_message_fragment = Fragment('9' * 2187) # Fragment Length
txn.signature_message_fragment = Fragment(
TryteString.from_string(
'IOTA is cool! This is a meta transaction!')
) # Fragment Length
else:
# Generate signature for bundle transaction
txn.signature_message_fragment = self.genSig(
bundleHash=bundle_hash)
bundle.data_payload = self.name + " (" + str(
bundle.outputTrxn.value
) + ") ->" + bundle.outputTrxn.recName
return self.conductPOW(bundle)
def address_from_digest(digest: Digest) -> Address:
"""
Generates an address from a private key digest.
"""
address_trits: List[int] = [0] * (Address.LEN * TRITS_PER_TRYTE)
sponge = Kerl()
sponge.absorb(digest.as_trits())
sponge.squeeze(address_trits)
return Address.from_trits(
trits=address_trits,
key_index=digest.key_index,
security_level=digest.security_level,
)
def test_output_greater_243(self):
# noinspection SpellCheckingInspection
inp = ('9MIDYNHBWMBCXVDEFOFWINXTERALUKYYPPHKP9JJ'
'FGJEIUY9MUDVNFZHMMWZUYUSWAIOWEVTHNWMHANBH')
trits = trytes_to_trits(inp)
print_var_type_n_val(
var001=trits, pointer="#XCVBNbvcSDF23458765") #XCVBNbvcSDF23458765
# Value:
# # [0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, -1, 0, -1, -1, -1, -1, 0, 1, -1, 1, 0, -1, -1, 0, 1, 1, 1, -1, 1, 0, 0, 1, 0, 0, -1, 0, 1, 1, -1, 1, 1, 0, -1, -1, 1, 0, -1, 1, 0, -1, -1, 0, -1, 1, -1, -1, 0, 0, 0, 1, -1, -1, -1, 0, -1, 0, -1, 1, -1, -1, -1, 1, 0, 0, -1, 1, 0, 0, 0, 1, 1, 0, 1, -1, -1, 1, 1, 1, -1, 0, 1, -1, 0, 1, -1, -1, 1, -1, -1, -1, 0, 1, -1, 1, 1, 1, -1, -1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, -1, 1, 1, -1, 1, 1, 0, 1, -1, -1, 1, 0, 0, 1, 0, 1, -1, 1, -1, 0, 0, 0, 0, 1, 1, 1, 0, 1, -1, 1, 1, 0, 1, 1, -1, -1, -1, -1, 0, -1, 1, -1, 0, 0, -1, 0, 1, 1, 1, 1, 1, 1, 1, -1, -1, 0, -1, 0, 0, 0, 1, -1, 1, -1, 0, 0, 1, -1, 1, 0, -1, -1, -1, 0, 1, 0, 0, 0, 0, 1, 0, -1, -1, -1, -1, 0, -1, -1, 1, 1, 1, -1, -1, 1, -1, -1, 0, 1, -1, -1, -1, -1, -1, 0, 1, 1, 1, -1, 0, 1, 1, 0, 0, -1, -1, -1, -1, 1, 0, -1, 0, 1]
# Type: <class 'list'>
kerl = Kerl()
print_var_type_n_val(var001=kerl,
pointer="#SDFG345tredff") #SDFG345tredff
# Value:
# # <iota.crypto.kerl.pykerl.Kerl object at 0x0000018FAA7C6780>
# Type: <class 'iota.crypto.kerl.pykerl.Kerl'>
kerl.absorb(trits)
print_var_type_n_val(
var001=kerl,
pointer="#ERERdfgfdrtre2345665777") #ERERdfgfdrtre2345665777
# Value:
# # <iota.crypto.kerl.pykerl.Kerl object at 0x0000018FAA7C6780>
# Type: <class 'iota.crypto.kerl.pykerl.Kerl'>
trits_out = []
kerl.squeeze(trits_out, length=486)
print_var_type_n_val(var001=kerl, pointer="#2345gDFRER") #2345gDFRER
# Value:
# # <iota.crypto.kerl.pykerl.Kerl object at 0x0000018FAA7C6780>
# Type: <class 'iota.crypto.kerl.pykerl.Kerl'>
trytes_out = trits_to_trytes(trits_out)
print_var_type_n_val(var001=trytes_out,
pointer="#23458765SDFfffFGH") #23458765SDFfffFGH
# Value: G9JYBOMPUXHYHKSNRNMMSSZCSHOFYOYNZRSZMAAYWDYEIMVVOGKPJBVBM9TDPULSFUNMTVXRKFIDOHUXXVYDLFSZYZTWQYTE9SPYYWYTXJYQ9IFGYOLZXWZBKWZN9QOOTBQMWMUBLEWUEEASRHRTNIQWJQNDWRYLCA
# Type: <class 'str'>
# noinspection SpellCheckingInspection
self.assertEqual(
trytes_out,
'G9JYBOMPUXHYHKSNRNMMSSZCSHOFYOYNZRSZMAAYWDYEIMVVOGKPJB'
'VBM9TDPULSFUNMTVXRKFIDOHUXXVYDLFSZYZTWQYTE9SPYYWYTXJYQ'
'9IFGYOLZXWZBKWZN9QOOTBQMWMUBLEWUEEASRHRTNIQWJQNDWRYLCA',
)
def finalize(bundle):
sponge = Kerl()
last_index = len(bundle) - 1
for (i, txn) in enumerate(bundle):
txn.current_index = i
txn.last_index = last_index
sponge.absorb(txn.get_signature_validation_trytes().as_trits())
bundle_hash_trits = [0] * HASH_LENGTH
sponge.squeeze(bundle_hash_trits)
bundle_hash = BundleHash.from_trits(bundle_hash_trits)
for txn in bundle:
txn.bundle_hash = bundle_hash
txn.signature_message_fragment = Fragment(txn.message or b'')
def address_from_digest(digest):
# type: (Digest) -> Address
"""
Generates an address from a private key digest.
"""
address_trits = [0] * (Address.LEN * TRITS_PER_TRYTE
) # type: MutableSequence[int]
sponge = Kerl()
sponge.absorb(digest.as_trits())
sponge.squeeze(address_trits)
return Address.from_trits(
trits=address_trits,
key_index=digest.key_index,
security_level=digest.security_level,
)
def finalize(bundle):
sponge = Kerl()
last_index = len(bundle) - 1
for (i, txn) in enumerate(bundle): # type: Tuple[int, ProposedTransaction]
txn.current_index = i
txn.last_index = last_index
sponge.absorb(txn.get_signature_validation_trytes().as_trits())
bundle_hash_trits = [0] * HASH_LENGTH # type: MutableSequence[int]
sponge.squeeze(bundle_hash_trits)
bundle_hash = BundleHash.from_trits(bundle_hash_trits)
for txn in bundle:
txn.bundle_hash = bundle_hash
# Initialize signature/message fragment.
txn.signature_message_fragment = Fragment(txn.message or b'')
def _create_sponge(self, index: int) -> Kerl:
"""
Prepares the hash sponge for the generator.
"""
seed = self.seed_as_trits[:]
sponge = Kerl()
sponge.absorb(add_trits(seed, trits_from_int(index)))
# Squeeze all of the trits out of the sponge and re-absorb them.
# Note that the sponge transforms several times per operation,
# so this sequence is not as redundant as it looks at first
# glance.
sponge.squeeze(seed)
sponge.reset()
sponge.absorb(seed)
return sponge
def test_correct_first(self):
inp = ('EMIDYNHBWMBCXVDEFOFWINXTERALUKYYPPHKP9JJ'
'FGJEIUY9MUDVNFZHMMWZUYUSWAIOWEVTHNWMHANBH')
trits = trytes_to_trits(inp)
kerl = Kerl()
kerl.absorb(trits)
trits_out = []
kerl.squeeze(trits_out)
trytes_out = trits_to_trytes(trits_out)
self.assertEqual(
trytes_out,
'EJEAOOZYSAWFPZQESYDHZCGYNSTWXUMVJOVDWUNZ'
'JXDGWCLUFGIMZRMGCAZGKNPLBRLGUNYWKLJTYEAQX',
)
def __init__(self) -> None:
super(MultisigAddressBuilder, self).__init__()
self._digests: List[Digest] = []
"""
Keeps track of digests that were added, so that we can attach
them to the final :py:class:`MultisigAddress` object.
"""
self._address: Optional[MultisigAddress] = None
"""
Caches the generated address.
Generating the address modifies the internal state of the curl
sponge, so each :py:class:`MultisigAddressBuilder` instance can
only generate a single address.
"""
self._sponge = Kerl()
def test_output_greater_243(self):
inp = ('9MIDYNHBWMBCXVDEFOFWINXTERALUKYYPPHKP9JJ'
'FGJEIUY9MUDVNFZHMMWZUYUSWAIOWEVTHNWMHANBH')
trits = trytes_to_trits(inp)
kerl = Kerl()
kerl.absorb(trits)
trits_out = []
kerl.squeeze(trits_out, length=486)
trytes_out = trits_to_trytes(trits_out)
self.assertEqual(
trytes_out,
'G9JYBOMPUXHYHKSNRNMMSSZCSHOFYOYNZRSZMAAYWDYEIMVVOGKPJB'
'VBM9TDPULSFUNMTVXRKFIDOHUXXVYDLFSZYZTWQYTE9SPYYWYTXJYQ'
'9IFGYOLZXWZBKWZN9QOOTBQMWMUBLEWUEEASRHRTNIQWJQNDWRYLCA',
)
def MnemonicsToIotaSeed(recovery_words,
passphrase='',
bip44_account=0x00000000,
bip44_page_index=0x00000000):
"""Recover an IOTA seed from the ledger Nano S recovery phrase
Keyword arguments:
recovery_words -- a list of 24 words (your ledger recovery phrase)
passphrase -- a string containing the passphrase (only if set in ledger, not your pin number!)
bip44_account -- an integer containing BIP44 path 'Account'
bip44_page_index -- an integer containing BIP44 path 'Page index'
"""
print("\nCalculating your IOTA seed...")
master_seed = mnemonic.Mnemonic.to_seed(mnemonic=' '.join(recovery_words),
passphrase=passphrase)
bip32_root_key = bip32utils.BIP32Key.fromEntropy(master_seed)
bip44_purpose_key = bip32_root_key.ChildKey(0x8000002C) # Purpose
bip44_coin_type_key = bip44_purpose_key.ChildKey(0x8000107A) # CoinType
bip44_account_key = bip44_coin_type_key.ChildKey(0x80000000 +
bip44_account) # Account
bip44_page_index_key = bip44_account_key.ChildKey(
0x80000000 + bip44_page_index) # Page index
if (sys.version_info.major >= 3):
priv_key = bytearray(bip44_page_index_key.PrivateKey())
chain_code = bytearray(bip44_page_index_key.C)
else:
priv_key = bytearray.fromhex(
bip44_page_index_key.PrivateKey().encode('hex'))
chain_code = bytearray.fromhex(bip44_page_index_key.C.encode('hex'))
trits_out = []
kerl = Kerl()
kerl.k.update(priv_key[0:32] + chain_code[0:16] + priv_key[16:32] +
chain_code[0:32])
kerl.squeeze(trits_out)
iota_seed = conv.trits_to_trytes(trits_out)
print("Seed: %s, Length: %d" % (iota_seed, len(iota_seed)))
def test_input_greater_243(self):
inp = ('G9JYBOMPUXHYHKSNRNMMSSZCSHOFYOYNZRSZMAAYWDYEIMVVOGKPJB'
'VBM9TDPULSFUNMTVXRKFIDOHUXXVYDLFSZYZTWQYTE9SPYYWYTXJYQ'
'9IFGYOLZXWZBKWZN9QOOTBQMWMUBLEWUEEASRHRTNIQWJQNDWRYLCA')
trits = trytes_to_trits(inp)
kerl = Kerl()
kerl.absorb(trits)
trits_out = []
kerl.squeeze(trits_out, length=486)
trytes_out = trits_to_trytes(trits_out)
self.assertEqual(
trytes_out,
'LUCKQVACOGBFYSPPVSSOXJEKNSQQRQKPZC9NXFSMQNRQCGGUL9OHVV'
'KBDSKEQEBKXRNUJSRXYVHJTXBPDWQGNSCDCBAIRHAQCOWZEBSNHIJI'
'GPZQITIBJQ9LNTDIBTCQ9EUWKHFLGFUVGGUWJONK9GBCDUIMAYMMQX',
)
def test_correct_first(self):
# noinspection SpellCheckingInspection
inp = ('EMIDYNHBWMBCXVDEFOFWINXTERALUKYYPPHKP9JJ'
'FGJEIUY9MUDVNFZHMMWZUYUSWAIOWEVTHNWMHANBH')
trits = trytes_to_trits(inp)
print_var_type_n_val(
var001=trits,
pointer="#SDFGHhgfdAZER1234765555") #SDFGHhgfdAZER1234765555
# Value:
# # [-1, -1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, -1, 0, -1, -1, -1, -1, 0, 1, -1, 1, 0, -1, -1, 0, 1, 1, 1, -1, 1, 0, 0, 1, 0, 0, -1, 0, 1, 1, -1, 1, 1, 0, -1, -1, 1, 0, -1, 1, 0, -1, -1, 0, -1, 1, -1, -1, 0, 0, 0, 1, -1, -1, -1, 0, -1, 0, -1, 1, -1, -1, -1, 1, 0, 0, -1, 1, 0, 0, 0, 1, 1, 0, 1, -1, -1, 1, 1, 1, -1, 0, 1, -1, 0, 1, -1, -1, 1, -1, -1, -1, 0, 1, -1, 1, 1, 1, -1, -1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, -1, 1, 1, -1, 1, 1, 0, 1, -1, -1, 1, 0, 0, 1, 0, 1, -1, 1, -1, 0, 0, 0, 0, 1, 1, 1, 0, 1, -1, 1, 1, 0, 1, 1, -1, -1, -1, -1, 0, -1, 1, -1, 0, 0, -1, 0, 1, 1, 1, 1, 1, 1, 1, -1, -1, 0, -1, 0, 0, 0, 1, -1, 1, -1, 0, 0, 1, -1, 1, 0, -1, -1, -1, 0, 1, 0, 0, 0, 0, 1, 0, -1, -1, -1, -1, 0, -1, -1, 1, 1, 1, -1, -1, 1, -1, -1, 0, 1, -1, -1, -1, -1, -1, 0, 1, 1, 1, -1, 0, 1, 1, 0, 0, -1, -1, -1, -1, 1, 0, -1, 0, 1]
# Type: <class 'list'>
# print('trits001: ', trits)
# # [-1, -1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, -1, 0, -1, -1, -1, -1, 0, 1, -1, 1, 0, -1, -1, 0, 1, 1, 1, -1, 1, 0, 0, 1, 0, 0, -1, 0, 1, 1, -1, 1, 1, 0, -1, -1, 1, 0, -1, 1, 0, -1, -1, 0, -1, 1, -1, -1, 0, 0, 0, 1, -1, -1, -1, 0, -1, 0, -1, 1, -1, -1, -1, 1, 0, 0, -1, 1, 0, 0, 0, 1, 1, 0, 1, -1, -1, 1, 1, 1, -1, 0, 1, -1, 0, 1, -1, -1, 1, -1, -1, -1, 0, 1, -1, 1, 1, 1, -1, -1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, -1, 1, 1, -1, 1, 1, 0, 1, -1, -1, 1, 0, 0, 1, 0, 1, -1, 1, -1, 0, 0, 0, 0, 1, 1, 1, 0, 1, -1, 1, 1, 0, 1, 1, -1, -1, -1, -1, 0, -1, 1, -1, 0, 0, -1, 0, 1, 1, 1, 1, 1, 1, 1, -1, -1, 0, -1, 0, 0, 0, 1, -1, 1, -1, 0, 0, 1, -1, 1, 0, -1, -1, -1, 0, 1, 0, 0, 0, 0, 1, 0, -1, -1, -1, -1, 0, -1, -1, 1, 1, 1, -1, -1, 1, -1, -1, 0, 1, -1, -1, -1, -1, -1, 0, 1, 1, 1, -1, 0, 1, 1, 0, 0, -1, -1, -1, -1, 1, 0, -1, 0, 1]
kerl = Kerl()
kerl.absorb(trits)
# print('kerl001: ', kerl)
# # <iota.crypto.kerl.pykerl.Kerl object at 0x000002740CFA5BA8>
trits_out = []
kerl.squeeze(trits_out)
# print('kerl002: ', kerl)
# # <iota.crypto.kerl.pykerl.Kerl object at 0x000002740CFA5BA8>
trytes_out = trits_to_trytes(trits_out)
print_var_type_n_val(
var001=trytes_out,
pointer="#QSEZEzZERTYsder23434") #QSEZEzZERTYsder23434
# Value: EJEAOOZYSAWFPZQESYDHZCGYNSTWXUMVJOVDWUNZJXDGWCLUFGIMZRMGCAZGKNPLBRLGUNYWKLJTYEAQX
# Type: <class 'str'>
# noinspection SpellCheckingInspection
self.assertEqual(
trytes_out,
'EJEAOOZYSAWFPZQESYDHZCGYNSTWXUMVJOVDWUNZ'
'JXDGWCLUFGIMZRMGCAZGKNPLBRLGUNYWKLJTYEAQX',
)
def finalize(self):
# type: () -> None
"""
Finalizes the bundle, preparing it to be attached to the Tangle.
"""
if self.hash:
raise RuntimeError('Bundle is already finalized.')
if not self:
raise ValueError('Bundle has no transactions.')
# Quick validation.
balance = self.balance
if balance < 0:
if self.change_address:
self.add_transaction(
ProposedTransaction(
address=self.change_address,
value=-balance,
tag=self.tag,
))
else:
raise ValueError(
'Bundle has unspent inputs (balance: {balance}); '
'use ``send_unspent_inputs_to`` to create '
'change transaction.'.format(balance=balance, ), )
elif balance > 0:
raise ValueError(
'Inputs are insufficient to cover bundle spend '
'(balance: {balance}).'.format(balance=balance, ), )
# Generate bundle hash.
while True:
sponge = Kerl()
last_index = len(self) - 1
for (i, txn
) in enumerate(self): # type: Tuple[int, ProposedTransaction]
txn.current_index = i
txn.last_index = last_index
sponge.absorb(txn.get_signature_validation_trytes().as_trits())
bundle_hash_trits = [0] * HASH_LENGTH # type: MutableSequence[int]
sponge.squeeze(bundle_hash_trits)
bundle_hash = BundleHash.from_trits(bundle_hash_trits)
# Check that we generated a secure bundle hash.
# https://github.com/iotaledger/iota.lib.py/issues/84
if any(13 in part for part in normalize(bundle_hash)):
# Increment the legacy tag and try again.
tail_transaction = self.tail_transaction # type: ProposedTransaction
tail_transaction.increment_legacy_tag()
else:
break
# Copy bundle hash to individual transactions.
for txn in self:
txn.bundle_hash = bundle_hash
# Initialize signature/message fragment.
txn.signature_message_fragment = Fragment(txn.message or b'')
try:
while True:
print("Create your Message ")
Message = input()
print("Create your Tag ")
TAG = input()
print("Please type in the secret Key:")
secret_key = input()
## Create next root_address
astrits = TryteString(str(root_address).encode()).as_trits()
checksum_trits = []
sponge = Kerl()
sponge.absorb(astrits)
sponge.squeeze(checksum_trits)
result = TryteString.from_trits(checksum_trits)
new_address = Address(result)
## transforming the secret_key into Base64 Key
h = blake2b(digest_size=16)
h_pw = h.update(bytes(secret_key.encode('utf-8')))
hh = h.hexdigest()
pw_string = str(hh).encode('utf-8')
b64_pw = base64.b64encode(pw_string)
## Encrypt the Message
data = {'message': Message}
msg = json.dumps(data)
def test_generate_trytes_and_multi_squeeze(self):
filepath =\
join(
dirname(__file__),
'test_vectors/generate_trytes_and_multi_squeeze.csv',
)
with open(filepath, 'r') as f:
reader = DictReader(f)
for count, line in enumerate(reader):
trytes = line['trytes']
hashes1 = line['Kerl_squeeze1']
hashes2 = line['Kerl_squeeze2']
hashes3 = line['Kerl_squeeze3']
trits = trytes_to_trits(trytes)
# print(trits)
# # [-1, 0, 1, 1, -1, 0, -1, 0, 0, 1, -1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, -1, -1, 1, -1, -1, -1, -1, 0, -1, 1, -1, 0, -1, 0, 1, 0, 1, 1, 0, 1, -1, 0, 0, -1, 1, 0, 1, -1, -1, 0, 1, 1, 0, 0, 1, 0, -1, -1, 0, 0, -1, 0, 0, -1, 0, 1, 1, 0, 0, 0, 0, -1, 0, -1, 1, -1, -1, -1, 0, 0, 1, 0, 0, 1, 1, -1, 1, 1, -1, 0, 1, -1, 1, 0, -1, 1, 0, 1, 1, -1, 0, 1, 0, 1, 1, -1, -1, -1, 1, 1, 1, -1, 0, 1, -1, 0, -1, -1, -1, -1, 1, 0, 0, 0, -1, -1, -1, -1, -1, -1, 0, 1, -1, -1, -1, 0, 1, 1, 0, -1, -1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, -1, 1, 0, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 0, -1, 1, 1, -1, 1, 0, 0, 0, 1, 1, 1, -1, -1, 0, 0, -1, -1, 1, -1, -1, 0, -1, -1, 1, 0, 0, 1, 1, -1, -1, 1, 1, -1, -1, 0, 1, 1, 1, -1, -1, -1, 0, -1, -1, -1, -1, 0, 1, 1, 1, -1, -1, 0, 0, 1, 0, -1, 0, 1, -1, 0, -1, 1, -1, 1, -1, -1, -1, 0, 0, 1, 1, 0, 1, 0]
kerl = Kerl()
kerl.absorb(trits)
trits_out = []
kerl.squeeze(trits_out)
trytes_out = trits_to_trytes(trits_out)
# print('hashes1: ', hashes1)
# # IWDWJCUUE9EBBYAEDXPDNAKTJAVY9IFOUZBNRIHMZ9NWOGOL9GYKZZ9ZLXHAI9PVPSLEAUGX9TQKMIUAX
# print('trytes_out: ', trytes_out)
# # IWDWJCUUE9EBBYAEDXPDNAKTJAVY9IFOUZBNRIHMZ9NWOGOL9GYKZZ9ZLXHAI9PVPSLEAUGX9TQKMIUAX
self.assertEqual(
hashes1,
trytes_out,
msg='line {count}: {hashes} != {trytes}'.format(
count=count + 2,
hashes=hashes1,
trytes=trytes_out,
),
)
trits_out = []
kerl.squeeze(trits_out)
trytes_out = trits_to_trytes(trits_out)
# print('line {count}: {hashes} != {trytes}'.format(
# count = count + 2,
# hashes = hashes2,
# trytes = trytes_out,
# ))
# # ANLYSAFQ9RJKFEADAZDTLPMYCYSGTRIOUWFKZPWJIEQHDTREOPHSUMAGIZLVIRMZGAVKODZAYBUISSQNX != ANLYSAFQ9RJKFEADAZDTLPMYCYSGTRIOUWFKZPWJIEQHDTREOPHSUMAGIZLVIRMZGAVKODZAYBUISSQNX
self.assertEqual(
hashes2,
trytes_out,
msg='line {count}: {hashes} != {trytes}'.format(
count=count + 2,
hashes=hashes2,
trytes=trytes_out,
),
)
trits_out = []
kerl.squeeze(trits_out)
trytes_out = trits_to_trytes(trits_out)
self.assertEqual(
hashes3,
trytes_out,
msg='line {count}: {hashes} != {trytes}'.format(
count=count + 2,
hashes=hashes3,
trytes=trytes_out,
),
)
def finalize(self):
# type: () -> None
"""
Finalizes the bundle, preparing it to be attached to the Tangle.
This operation includes checking if the bundle has zero balance,
generating the bundle hash and updating the transactions with it,
furthermore to initialize signature/message fragment fields.
Once this method is invoked, no new transactions may be added to the
bundle.
:raises RuntimeError: if bundle is already finalized.
:raises ValueError:
- if bundle has no transactions.
- if bundle has unspent inputs (there is no ``change_address``
attribute specified.)
- if inputs are insufficient to cover bundle spend.
"""
if self.hash:
raise RuntimeError('Bundle is already finalized.')
if not self:
raise ValueError('Bundle has no transactions.')
# Quick validation.
balance = self.balance
if balance < 0:
if self.change_address:
self.add_transaction(
ProposedTransaction(
address=self.change_address,
value=-balance,
tag=self.tag,
))
else:
raise ValueError(
'Bundle has unspent inputs (balance: {balance}); '
'use ``send_unspent_inputs_to`` to create '
'change transaction.'.format(balance=balance, ), )
elif balance > 0:
raise ValueError(
'Inputs are insufficient to cover bundle spend '
'(balance: {balance}).'.format(balance=balance, ), )
# Generate bundle hash.
while True:
sponge = Kerl()
last_index = len(self) - 1
for i, txn in enumerate(self):
txn.current_index = i
txn.last_index = last_index
sponge.absorb(txn.get_signature_validation_trytes().as_trits())
bundle_hash_trits = [0] * HASH_LENGTH
sponge.squeeze(bundle_hash_trits)
bundle_hash = BundleHash.from_trits(bundle_hash_trits)
# Check that we generated a secure bundle hash.
# https://github.com/iotaledger/iota.py/issues/84
if any(13 in part for part in normalize(bundle_hash)):
# Increment the legacy tag and try again.
tail_transaction = (self.tail_transaction
) # type: ProposedTransaction
tail_transaction.increment_legacy_tag()
else:
break
# Copy bundle hash to individual transactions.
for txn in self:
txn.bundle_hash = bundle_hash
# Initialize signature/message fragment.
txn.signature_message_fragment = Fragment(txn.message or b'')