def test_checksum_valid(self): """ An address is created with a valid checksum. """ addy = Address( b'RVORZ9SIIP9RCYMREUIXXVPQIPHVCNPQ9HZWYKFWYWZRE' b'9JQKG9REPKIASHUUECPSQO9JT9XNMVKWYGVAITCOXAQSD', ) self.assertTrue(addy.is_checksum_valid()) self.assertEqual( binary_type(addy.with_valid_checksum()), b'RVORZ9SIIP9RCYMREUIXXVPQIPHVCNPQ9HZWYKFWYWZRE' b'9JQKG9REPKIASHUUECPSQO9JT9XNMVKWYGVAITCOXAQSD', )
def test_checksum_null(self): """ An address is created without a checksum. """ trytes = ( b'ZKIUDZXQYQAWSHPKSAATJXPAQZPGYCDCQDRSMWWCGQJNI' b'PCOORMDRNREDUDKBMUYENYTFVUNEWDBAKXMV' ) addy = Address(trytes) self.assertFalse(addy.is_checksum_valid()) self.assertEqual( binary_type(addy.with_valid_checksum()), b'ZKIUDZXQYQAWSHPKSAATJXPAQZPGYCDCQDRSMWWCGQJNI' b'PCOORMDRNREDUDKBMUYENYTFVUNEWDBAKXMVJJJGBARPB', )
def test_with_checksum_attributes(self): """ :py:meth:`Address.with_valid_checksum` also copies attributes such as key index and balance. """ addy =\ Address( trytes = b'ZKIUDZXQYQAWSHPKSAATJXPAQZPGYCDCQDRSMWWCGQJNI' b'PCOORMDRNREDUDKBMUYENYTFVUNEWDBAKXMV', key_index = 42, balance = 86, ) checked = addy.with_valid_checksum() self.assertEqual(checked.key_index, 42) self.assertEqual(checked.balance, 86)
def test_checksum_invalid(self): """ An address is created with an invalid checksum. """ trytes = ( b'IGKUOZGEFNSVJXETLIBKRSUZAWMYSVDPMHGQPCETEFNZP' b'XSJLZMBLAWDRLUBWPIPKFNEPADIWMXMYYRKQ' ) addy = Address( trytes + b'XYYNAFRMB' # <- Last tryte s/b 'A'. ) self.assertFalse(addy.is_checksum_valid()) self.assertEqual( binary_type(addy.with_valid_checksum()), b'IGKUOZGEFNSVJXETLIBKRSUZAWMYSVDPMHGQPCETEFNZP' b'XSJLZMBLAWDRLUBWPIPKFNEPADIWMXMYYRKQXYYNAFRMA', )
def _apply(self, value): super(AddressNoChecksum, self)._apply(value) if self._has_errors: return None # Possible it's still just a TryteString if not isinstance(value, Address): value = Address(value) # Bail out if we have a bad checksum if value.checksum and not value.is_checksum_valid(): return self._invalid_value( value = value, reason = self.ADDRESS_BAD_CHECKSUM, exc_info = True, context = { 'supplied_checksum': value.checksum, 'expected_checksum': value.with_valid_checksum().checksum, }, ) return Address(value.address)
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 test_fail_transfers_empty(self): """ ``transfers`` is an array, but it's empty. """ self.assertFilterErrors( { 'changeAddress': Address(self.trytes_1), 'multisigInput': MultisigAddress( digests=[self.digest_1, self.digest_2], trytes=self.trytes_2, ), # This is a variation on the ``null`` test. 'transfers': [], }, { 'transfers': [f.Required.CODE_EMPTY], }, )
def test_sign_input_at_error_index_invalid(self): """ The specified index doesn't exist in the bundle. """ # Add a transaction so that we can finalize the bundle. # noinspection SpellCheckingInspection self.bundle.add_transaction( ProposedTransaction( address=Address(b'TESTVALUE9DONTUSEINPRODUCTION99999QARFLF' b'TDVATBVFTFCGEHLFJBMHPBOBOHFBSGAGWCM9PG9GX'), value=42, )) self.bundle.add_inputs([self.input_0_bal_eq_42]) self.bundle.finalize() private_key =\ KeyGenerator(self.seed).get_key_for(self.input_0_bal_eq_42) with self.assertRaises(IndexError): self.bundle.sign_input_at(2, private_key)
def test_sign_inputs_error_not_finalized(self): """ Attempting to sign inputs in a bundle that hasn't been finalized yet. """ # Add a transaction so that we can finalize the bundle. # noinspection SpellCheckingInspection self.bundle.add_transaction( ProposedTransaction( address=Address(b'TESTVALUE9DONTUSEINPRODUCTION99999QARFLF' b'TDVATBVFTFCGEHLFJBMHPBOBOHFBSGAGWCM9PG9GX'), value=42, )) self.bundle.add_inputs([self.input_0_bal_eq_42]) # Oops; did we forget something? # self.bundle.finalize() with self.assertRaises(RuntimeError): self.bundle.sign_inputs(KeyGenerator(b''))
def test_add_inputs_error_already_finalized(self): """ Attempting to add inputs to a bundle that is already finalized. """ # Add 1 transaction so that we can finalize the bundle. # noinspection SpellCheckingInspection self.bundle.add_transaction( ProposedTransaction( address=Address( b'TESTVALUE9DONTUSEINPRODUCTION99999XE9IVG' b'EFNDOCQCMERGUATCIEGGOHPHGFIAQEZGNHQ9W99CH', ), value=0, ), ) self.bundle.finalize() with self.assertRaises(RuntimeError): # Even though no inputs are provided, it's still an error; you # shouldn't even be calling ``add_inputs`` once the bundle is # finalized! self.bundle.add_inputs([])
def test_finalize_error_negative_balance(self): """ Attempting to finalize a bundle with unspent inputs. """ # noinspection SpellCheckingInspection self.bundle.add_transaction( ProposedTransaction( address=Address(b'TESTVALUE9DONTUSEINPRODUCTION99999IGEFUG' b'LIHIJGJGZ9CGRENCRHF9XFEAWD9ILFWEJFKDLITCC'), value=42, )) self.bundle.add_inputs([self.input_0_bal_eq_42, self.input_2_bal_eq_2]) # Bundle spends 42 IOTAs, but inputs total 44 IOTAs. self.assertEqual(self.bundle.balance, -2) # In order to finalize this bundle, we need to specify a change # address. with self.assertRaises(ValueError): self.bundle.finalize()
class IotaApiUser(IotaUser): wait_time = between(0, 1) address = 'ZLGVEQ9JUZZWCZXLWVNTHBDX9G9KZTJP9VEERIIFHY9SIQKYBVAHIMLHXPQVE9IXFDDXNHQINXJDRPFDXNYVAPLZAW' message = TryteString.from_unicode('Hello world') tx = ProposedTransaction(address=Address(address), message=message, value=0) @task def send_msg(self): result = self.client.send_transfer(transfers=[self.tx]) @task(0) def prepare_transfer(self): tx_trytes = self.client.prepare_transfer(transfers=[self.tx]) @task(0) def send_trytes(self): api = Iota(adapter="http://localhost:14265", testnet=True) tx_trytes = api.prepare_transfer(transfers=[self.tx]) resp_sendTrytes = self.client.send_trytes(trytes=tx_trytes['trytes'])
def test_add_signature_or_message_finalized_bundle(self): """ Try to call the method on a finalized bundle. """ self.bundle.add_transaction( ProposedTransaction( address=Address(b'TESTVALUE9DONTUSEINPRODUCTION99999QARFLF' b'TDVATBVFTFCGEHLFJBMHPBOBOHFBSGAGWCM9PG9GX'), message=TryteString.from_unicode('This should be overwritten'), value=0, )) custom_msg = \ 'The early bird gets the worm, but the custom-msg gets into the bundle.' custom_fragment = Fragment.from_unicode(custom_msg) # Finalize the bundle, no further changes should be permitted. self.bundle.finalize() with self.assertRaises(RuntimeError): self.bundle.add_signature_or_message([custom_fragment])
def test_pass_compatible_types(self): """ The incoming request contains values that can be converted to the expected types. """ request = { 'addresses': [ Address(self.address_1), bytearray(self.address_2.encode('ascii')), ], } filter_ = self._filter(request) self.assertFilterPasses(filter_) self.assertDictEqual( filter_.cleaned_data, { 'addresses': [self.address_1, self.address_2], }, )
def test_finalize_error_positive_balance(self): """ Attempting to finalize a bundle with insufficient inputs. """ # noinspection SpellCheckingInspection self.bundle.add_transaction( ProposedTransaction( address=Address(b'TESTVALUE9DONTUSEINPRODUCTION99999IGEFUG' b'LIHIJGJGZ9CGRENCRHF9XFEAWD9ILFWEJFKDLITCC'), value=42, )) self.bundle.add_inputs([self.input_1_bal_eq_40]) # Bundle spends 42 IOTAs, but inputs total only 40 IOTAs. self.assertEqual(self.bundle.balance, 2) # In order to finalize this bundle, we need to provide additional # inputs. with self.assertRaises(ValueError): self.bundle.finalize()
def test_add_signature_or_message_multiple_offset(self): """ Add multiple fragments with offset. """ # Add 3 transactions to the bundle. for i in ['A', 'B', 'C']: self.bundle.add_transaction(ProposedTransaction( address = Address( 'TESTVALUE' + i + 'DONTUSEINPRODUCTION99999QARFLF' 'TDVATBVFTFCGEHLFJBMHPBOBOHFBSGAGWCM9PG9GX' ), message = TryteString.from_unicode('This should be overwritten'), value = 0, )) fragment1 = Fragment.from_unicode('This is the first fragment.') fragment2 = Fragment.from_unicode('This is the second fragment.') self.bundle.add_signature_or_message([fragment1, fragment2], 1) bundle_fragments = [] for tx in self.bundle: bundle_fragments.append(tx.message) self.assertListEqual( bundle_fragments, [TryteString.from_unicode('This should be overwritten'), fragment1, fragment2] ) self.bundle.finalize() bundle_fragments_unicode = [] for tx in self.bundle: bundle_fragments_unicode.append(tx.signature_message_fragment.decode()) self.assertListEqual( bundle_fragments_unicode, ['This should be overwritten', fragment1.decode(), fragment2.decode()] )
def test_add_checksum_second_time(self): """ Checksum is added to an address that already has. """ addy = Address(trytes=b'ZKIUDZXQYQAWSHPKSAATJXPAQZPGYCDCQDRSMWWCGQJNI' b'PCOORMDRNREDUDKBMUYENYTFVUNEWDBAKXMVJJJGBARPB') addy.add_checksum() self.assertTrue(addy.is_checksum_valid()) self.assertTrue(len(addy) == Address.LEN + AddressChecksum.LEN) self.assertEqual( addy, Address(trytes=b'ZKIUDZXQYQAWSHPKSAATJXPAQZPGYCDCQDRSMWWCGQJNI' b'PCOORMDRNREDUDKBMUYENYTFVUNEWDBAKXMVJJJGBARPB'))
def test_finalize_insecure_bundle(self): """ When finalizing, the bundle detects an insecure bundle hash. References: - https://github.com/iotaledger/iota.py/issues/84 """ bundle =\ ProposedBundle([ ProposedTransaction( address =\ Address( '9XV9RJGFJJZWITDPKSQXRTHCKJAIZZY9BYLBEQUX' 'UNCLITRQDR9CCD99AANMXYEKD9GLJGVB9HIAGRIBQ', ), tag = Tag('PPDIDNQDJZGUQKOWJ9JZRCKOVGP'), timestamp = 1509136296, value = 0, ), ]) bundle.finalize() # The resulting bundle hash is insecure (contains a [1, 1, 1]), so # the legacy tag is manipulated until a secure hash is generated. self.assertEqual(bundle[0].legacy_tag, Tag('ZTDIDNQDJZGUQKOWJ9JZRCKOVGP')) # The proper tag is left alone, however. self.assertEqual(bundle[0].tag, Tag('PPDIDNQDJZGUQKOWJ9JZRCKOVGP')) # The bundle hash takes the modified legacy tag into account. self.assertEqual( bundle.hash, BundleHash( 'NYSJSEGCWESDAFLIFCNJFWGZ9PCYDOT9VCSALKBD' '9UUNKBJAJCB9KVMTHZDPRDDXC9UFJQBJBQFUPJKFC', ) )
def test_success_multiple_digests(self): """ Generating a multisig address from multiple digests. """ builder = MultisigAddressBuilder() builder.add_digest(self.digest_1) builder.add_digest(self.digest_2) addy = builder.get_address() self.assertIsInstance(addy, MultisigAddress) # noinspection SpellCheckingInspection self.assertEqual( addy, Address( b'JUIFYSUQFVBFGNHOJMLWBHMGASFGBPAUMRZRRCJF' b'CCOJHJKZVUOCEYSCLXAGDABCEWSUXCILJCGQWI9SF', ), ) # The multisig address also keeps track of the digests used to # create it (mostly for troubleshooting purposes). self.assertListEqual(addy.digests, [self.digest_1, self.digest_2])
def Send(self, Receiver_Address, Message): if isinstance(Message, bytes): Message = Message.decode() Trytes_Convertion = TryteString.from_string(Message) TX = ProposedTransaction(address = Address(Receiver_Address), message = Trytes_Convertion, value = 0) bundle = ProposedBundle() bundle.add_transaction(TX) bundle.finalize() TX_Hash = str(bundle.hash) bundle_as_trytes = bundle.as_tryte_strings() TX_Success = False try: TX_Confirmation = self.IOTA_Api.send_trytes(trytes = bundle_as_trytes, depth = 4) TX_Success = TX_Hash except: if "iota.adapter.BadApiResponse" in str(sys.exc_info()[1]): print("Node not in Sync, finding another node....") #< ---------------------------------------------------- elif "The subtangle has not been updated yet." in str(sys.exc_info()[1]): print("Node not synced yet, finding another node...") #< ---------------------------------------------------- elif "429 response from node"in str(sys.exc_info()[1]): print("Too many requests to node, finding an alternative node...") #< ---------------------------------------------------- elif "[Errno 111] Connection refused" in str(sys.exc_info()[1]): print("Connection error, finding an alternative node...") #< ---------------------------------------------------- elif "403 Forbidden" in str(sys.exc_info()[1]): print("No access granted to node, finding an alternative node...") #< ---------------------------------------------------- # special case; a node accepts with POW set to "True" elif "certificate verify failed" in str(sys.exc_info()[1]): print("Node does not have a valid SSL certificate, finding an alternative node...") else: print("Unexpected exception caught in send") #< ---------------------------------------------------- print(sys.exc_info()[1]) #< ---------------------------------------------------- return TX_Success
def send(value): api = Iota("http://localhost:14265") ti = time.time() api.send_transfer( depth=3, transfers=[ ProposedTransaction( # Recipient of the transfer. address=Address( "RECEIVINGWALLETADDRESSGOESHERE9WITHCHECKSUMANDSECURITYLEVELB999999999999999999999999999999" ), value=value, # Optional tag to attach to the transfer. tag=Tag(b'KITTEHS'), # Optional message to include with the transfer. message=TryteString.from_unicode('thx fur cheezburgers'), ), ], min_weight_magnitude=9) print(time.time() - ti)
def sendiota(self, address, amount): self.api.send_transfer( depth=100, # One or more :py:class:`ProposedTransaction` objects to add to the # bundle. transfers=[ ProposedTransaction( # Recipient of the transfer. address=Address( address, ), # Amount of IOTA to transfer. # This value may be zero. value=amount, # Optional tag to attach to the transfer. tag=Tag(b'EXAMPLEK'), # Optional message to include with the transfer. message=TryteString.from_string('Hello!'), ), ], )
def test_fail_signature_fragment_address_wrong(self): """ The second signature fragment for an input is associated with the wrong address. """ # noinspection SpellCheckingInspection self.bundle[2].address =\ Address( b'QHEDFWZULBZFEOMNLRNIDQKDNNIELAOXOVMYEI9P' b'GNFDPEEZCWVYLKZGSLCQNOFUSENIXRHWWTZFBXMPS' ) validator = BundleValidator(self.bundle) self.assertFalse(validator.is_valid()) self.assertListEqual( validator.errors, [ 'Transaction 1 has invalid signature (using 1 fragments).', ], )
def test_success_multiple_digests(self): """ Generating a multisig address from multiple digests. """ builder = MultisigAddressBuilder() builder.add_digest(self.digest_1) builder.add_digest(self.digest_2) addy = builder.get_address() self.assertIsInstance(addy, MultisigAddress) # noinspection SpellCheckingInspection self.assertEqual( addy, Address( b'ZYKDKGXTMGINTQLUMVNBBI9XCEI9BWYF9YOPCBFT' b'UUJZWM9YIWHNYZEWOPEVRVLKZCPRKLCQD9BR9FVLC', ), ) # The multisig address also keeps track of the digests used to # create it (mostly for troubleshooting purposes). self.assertListEqual(addy.digests, [self.digest_1, self.digest_2])
def test_sign_input_at_error_index_not_input(self): """ The specified index references a transaction that is not an input. """ # Add a transaction so that we can finalize the bundle. # noinspection SpellCheckingInspection self.bundle.add_transaction( ProposedTransaction( address=Address(b'TESTVALUE9DONTUSEINPRODUCTION99999QARFLF' b'TDVATBVFTFCGEHLFJBMHPBOBOHFBSGAGWCM9PG9GX'), value=42, )) self.bundle.add_inputs([self.input_0_bal_eq_42]) self.bundle.finalize() private_key =\ KeyGenerator(self.seed).get_key_for(self.input_0_bal_eq_42) with self.assertRaises(ValueError): # You can't sign the spend transaction, silly! self.bundle.sign_input_at(0, private_key)
def test_fail_transfers_null(self): """ ``transfers`` is null. """ self.assertFilterErrors( { 'changeAddress': Address(self.trytes_1), 'multisigInput': MultisigAddress( digests=[self.digest_1, self.digest_2], trytes=self.trytes_2, ), # On second thought, I changed my mind. 'transfers': None, }, { 'transfers': [f.Required.CODE_EMPTY], }, )
def transfer(message): address = "KTTAJJPDQBXDYFFSYNV9BVREJFGXIGNISDWD9RFHSBWZOBI9GXPXFGGLDOZLGTEZCTBXDCWUZZVYMYC9Y" tag = "JDIWHUEFE9S" value = 0 recipient_address = address sender_message = message sender_tag = tag bundle_hash = "" prepared_transferes = [] api = Iota(NODE_URL, SEED) sender_tag = bytes(sender_tag) transfer_value = int(value) txn = \ ProposedTransaction( address = Address( recipient_address ), message = TryteString.from_string(sender_message), tag = Tag(sender_tag), value = transfer_value, ) prepared_transferes.append(txn) try: bundle_hash = api.send_transfer( depth=DEPTH, transfers=prepared_transferes, min_weight_magnitude=MIN_WEIGHT_MAGNITUDE) except Exception as e: print "Exception on TangleID transaction agent." + str(e) return "Exception on TangleID transaction agent." return str(bundle_hash['bundle'].hash)
def test_add_signature_or_message(self): """ Add a fragment to a transaction. """ # Add a transaction self.bundle.add_transaction(ProposedTransaction( address = Address( b'TESTVALUE9DONTUSEINPRODUCTION99999QARFLF' b'TDVATBVFTFCGEHLFJBMHPBOBOHFBSGAGWCM9PG9GX' ), message = TryteString.from_unicode('This should be overwritten'), value = 0, )) custom_msg = \ 'The early bird gets the worm, but the custom-msg gets into the bundle.' custom_fragment = Fragment.from_unicode(custom_msg) # Before finalization, the method adds to message field... self.bundle.add_signature_or_message([custom_fragment]) self.assertEqual( self.bundle._transactions[0].message, custom_fragment ) # ... because upon finalization, this is translated into # signature_message_fragment field. self.bundle.finalize() self.assertEqual( self.bundle._transactions[0].signature_message_fragment, custom_fragment ) # Do we have the right text inside? self.assertEqual( self.bundle.get_messages()[0], custom_msg )
def test_init_with_checksum(self): """ Creating an address with checksum already attached. """ addy = Address(b'RVORZ9SIIP9RCYMREUIXXVPQIPHVCNPQ9HZWYKFWYWZRE' b'9JQKG9REPKIASHUUECPSQO9JT9XNMVKWYGVAFOXM9MUBX') self.assertEqual( binary_type(addy), b'RVORZ9SIIP9RCYMREUIXXVPQIPHVCNPQ9HZWYKFWYWZRE' b'9JQKG9REPKIASHUUECPSQO9JT9XNMVKWYGVAFOXM9MUBX', ) self.assertEqual( binary_type(addy.address), b'RVORZ9SIIP9RCYMREUIXXVPQIPHVCNPQ9HZWYKFWYWZRE' b'9JQKG9REPKIASHUUECPSQO9JT9XNMVKWYGVA', ) self.assertEqual( binary_type(addy.checksum), b'FOXM9MUBX', )
async def test_error_zero_iotas_transferred(self): """ The bundle doesn't spend any IOTAs. This is considered an error case because :py:meth:`MultisigIota.prepare_multisig_transfer` is specialized for generating bundles that require multisig inputs. Any bundle that doesn't require multisig functionality should be generated using :py:meth:`iota.api.Iota.prepare_transfer` instead. """ with self.assertRaises(ValueError): await self.command( transfers=[ ProposedTransaction( address=Address(self.trytes_1), value=0, ), ], multisigInput=MultisigAddress( digests=[self.digest_1, self.digest_2], trytes=self.trytes_2, ), )
def from_tryte_string_and_hash(cls, trytes,hash): # type: (TrytesCompatible) -> Transaction """ Creates a Transaction object from a sequence of trytes. """ tryte_string = TransactionTrytes(trytes) hash_ = hash return cls( hash_=TransactionHash(hash_), signature_message_fragment=Fragment(tryte_string[0:2187]), address=Address(tryte_string[2187:2268]), value=int_from_trits(tryte_string[2268:2295].as_trits()), tag=Tag(tryte_string[2295:2322]), timestamp=int_from_trits(tryte_string[2322:2331].as_trits()), current_index=int_from_trits(tryte_string[2331:2340].as_trits()), last_index=int_from_trits(tryte_string[2340:2349].as_trits()), bundle_hash=BundleHash(tryte_string[2349:2430]), trunk_transaction_hash=TransactionHash(tryte_string[2430:2511]), branch_transaction_hash=TransactionHash(tryte_string[2511:2592]), nonce=Hash(tryte_string[2592:2673]), )
def test_add_inputs_happy_path(self): """ Adding a multisig input to a bundle. """ # noinspection SpellCheckingInspection self.bundle.add_transaction( ProposedTransaction( address=Address(self.trytes_1), value=42, ), ) self.bundle.add_inputs([ MultisigAddress( trytes=self.trytes_2, digests=[self.digest_1, self.digest_2], balance=42, ) ]) # The multisig input requires a total of 4 transactions to store # all the signatures. Including the spend, that makes 5 # transactions in total. self.assertEqual(len(self.bundle), 5)
def main(): api = Iota("http://localhost:14265") # In this file, we tranfer tokens with 0-value; thus the seed can be ignored. ti = time.time() a = api.send_transfer( depth=3, transfers=[ ProposedTransaction( # Recipient of the transfer. address=Address( "RECEIVINGWALLETADDRESSGOESHERE9WITHCHECKSUMANDSECURITYLEVELB999999999999999999999999999999" ), value=0, # Optional tag to attach to the transfer. tag=Tag(b'KITTEHS'), # Optional message to include with the transfer. message=TryteString.from_unicode('thx fur cheezburgers'), ), ], min_weight_magnitude=1)
def test_success_single_digest(self): """ Generating a "multisig" address from a single digest. This does the same thing as generating a regular address from the corresponding key. """ builder = MultisigAddressBuilder() builder.add_digest(self.digest_1) addy = builder.get_address() self.assertIsInstance(addy, MultisigAddress) self.assertEqual( addy, Address( b'TBOLOKTNJ9MFGBSJBIWDZBHWJRLMKAEGUZFJFNGS' b'VODKPPULLGJVHTCENCD9OOCNYPRLV9XGBGLDZNHPZ', ), ) # The address is still designated multisig, so we keep track of the # digest used to generate it. self.assertListEqual(addy.digests, [self.digest_1])
def test_sign_input_at_error_not_finalized(self): """ Cannot sign inputs because the bundle isn't finalized yet. """ # Add a transaction so that we can finalize the bundle. # noinspection SpellCheckingInspection self.bundle.add_transaction( ProposedTransaction( address=Address(b'TESTVALUE9DONTUSEINPRODUCTION99999QARFLF' b'TDVATBVFTFCGEHLFJBMHPBOBOHFBSGAGWCM9PG9GX'), value=42, )) self.bundle.add_inputs([self.input_0_bal_eq_42]) # Oops; did we forget something? # self.bundle.finalize() private_key =\ KeyGenerator(self.seed).get_key_for(self.input_0_bal_eq_42) with self.assertRaises(RuntimeError): self.bundle.sign_input_at(1, private_key)
def transfer(address, tag, message, value): recipient_address = address sender_message = message sender_tag = tag bundle_hash = "" prepared_transferes = [] api = Iota(NODE_URL, SEED) sender_tag = sender_tag transfer_value = int(value) txn = \ ProposedTransaction( address = Address( recipient_address ), message = TryteString.from_string(sender_message), tag = Tag(sender_tag), value = transfer_value, ) prepared_transferes.append(txn) try: bundle_hash = api.send_transfer( depth=DEPTH, transfers=prepared_transferes, min_weight_magnitude=MIN_WEIGHT_MAGNITUDE ) except: print("Exception on TangleID transaction agent.") return "Exception on TangleID transaction agent." print(bundle_hash['bundle'].hash) return str(bundle_hash['bundle'].hash)