def test_builder_xdr(self): cold_account = self.cold.address().decode() hot_account = self.hot.address().decode() fund(cold_account) fund(hot_account) cold = Builder(self.cold.seed().decode()) cold.append_trust_op(cold_account, 'BEER', 1000, hot_account) cold.append_payment_op(hot_account, 100, 'BEER', cold_account) cold.append_payment_op(cold_account, 2.222, 'BEER', cold_account, hot_account) xdr = cold.gen_xdr() hot = Builder(self.hot.seed().decode()) hot.import_from_xdr(xdr) # hot.sign() try: response = hot.submit() except: assert False
def create_transaction(cls, text): builder = Builder(secret=cls.key) # use this to use local node e.g with docker instead of public node # builder = Builder(secret=cls.key, horizon_uri="http://localhost:8000/") builder.append_payment_op(cls.address, '100', 'XLM') builder.add_text_memo(text) # string length <= 28 bytes return builder
def test_builder(self): cold_account = self.cold.address().decode() hot_account = self.hot.address().decode() fund(cold_account) cold = Builder(self.cold.seed().decode()) \ .append_create_account_op(hot_account, 200) \ .append_set_options_op(inflation_dest=cold_account, set_flags=1, home_domain='256kw.com', master_weight=10, low_threshold=5, ) \ .append_trust_op(cold_account, 'BEER', 1000, source=hot_account) \ .append_allow_trust_op(hot_account, 'BEER', True) # append twice for test cold.append_payment_op(hot_account, 50.123, 'BEER', cold_account) \ .append_payment_op(hot_account, 50.123, 'BEER', cold_account) cold.sign(self.hot.seed().decode()) try: # sign twice cold.sign(self.hot.seed().decode()) except SignatureExistError: assert True except: assert False cold.sign() assert len(cold.te.signatures) == 2 assert len(cold.ops) == 5 try: response = cold.submit() print(response) except: assert False
class Build: """Creates a transaction between the sender and receiver. :param: sender: Account that sends the money (seed). :param: receiver: Account that receives the money (Account ID). :param: amount: Amount that needs to be sent. """ def __init__(self, sender, receiver, amount=0): self.sender, self.receiver, self.amount = sender, receiver, amount self.builder = None def send(self): """Text Memo needs to be added.""" if self.check_account_validity: self.builder = Builder( secret=self.sender, horizon='https://horizon-testnet.stellar.org') self.builder.append_payment_op(self.receiver, self.amount) self.builder.sign() self.builder.submit() return True return False @property def check_account_validity(self): return Details(self.receiver).check
def create_transaction(sender_seed, recipient_key, hash_value): builder = Builder(secret=sender_seed) builder.append_payment_op(recipient_key, "1", "XLM") builder.add_hash_memo(hash_value.encode()) builder.sign() # TODO: handle possible errors return builder.submit()
def __send(self, address, encrypted, sequence_number): ''' Sends the encrypted blocks to the recipient as sequential payment transactions. Args: address: The Stellar address of the recipient. encrypted: The encrypted message blocks. sequence_number: The current sequence number of the sending account. Returns: True if successful, False otherwise. ''' try: for i in range(0, len(encrypted)): sequence = str(sequence_number + i) builder = Builder(secret = self.__seed, sequence = sequence) builder.append_payment_op(address, '0.0000001', 'XLM') builder.add_hash_memo(encrypted[i]) builder.sign() builder.submit() except: return False # todo: check sending status return True
def test_builder(setup, test_data): hot = Keypair.random() hot_account = hot.address().decode() hot_secret = hot.seed() cold = Builder(secret=test_data.cold_secret, horizon=setup.horizon_endpoint_uri, network=setup.network) \ .append_create_account_op(hot_account, '200') \ .append_set_options_op(inflation_dest=test_data.cold_account, set_flags=1, home_domain='256kw.com', master_weight=10, low_threshold=5, ) \ .append_trust_op(test_data.cold_account, 'BEER', '1000', hot_account) \ .append_allow_trust_op(hot_account, 'BEER', True) # append twice for test cold.append_payment_op(hot_account, '50.123', 'BEER', test_data.cold_account) \ .append_payment_op(hot_account, '50.123', 'BEER', test_data.cold_account) # TODO: append_bump_sequence_op test cold.sign() cold.sign(hot_secret) # try to sign twice with pytest.raises(SignatureExistError): cold.sign(hot_secret) assert len(cold.te.signatures) == 2 assert len(cold.ops) == 5 response = cold.submit() assert response.get('hash') == cold.hash_hex()
def send_asset(text): # send 10 EURT antb123*papayame.com or send 1 XLM PUBKEY memo text if CONF['private_key'] == '': print( 'no private key setup - pls type set to set key or c to create wallet' ) return val = text.split() memo_type = 'text' if len(val) < 3: print( 'invalid syntax please use send amount asset receiver e.g. s 10 EURT antb123*papayame.com' ) return amount, asset, address = val[1], val[2].upper(), val[3] if '*' in address: res = fed(address.split('*')[1], address) sendto = res['account_id'] memo = res['memo'] memo_type = res['memo_type'] else: sendto = address memo = '' # override memo, type if given if len(val) == 6: memo = val[4] memo_type = val[5] if len(val) == 5: memo = val[4] memo_type = 'text' print_formatted_text( HTML("""Are you sure you want to send <ansiyellow>%s</ansiyellow> <ansired>%s %s</ansired> with memo of <ansiblue>%s</ansiblue> (y/n) """ % (sendto, asset, amount, memo))) text = session.prompt(u'> ', default='y') if text != 'y': return ret, asset_issuer = get_balance_issuer(amount, asset) if ret: return retsan = send_sanity(sendto, memo_type, asset) if not retsan: return send = Builder(CONF['private_key'], network=CONF['network']) if asset != 'XLM': send.append_payment_op(sendto, amount, asset, asset_issuer) else: send.append_payment_op(sendto, amount) if memo != '' and memo_type == 'text': send.add_text_memo(memo) if memo != '' and memo_type == 'id': send.add_id_memo(memo) if CONF['multisig'] != '': print( 'You have 2of2 multisig - send this data to the other key to sign when you get it back type signsend data' ) print(send.gen_xdr()) return send.sign() send.submit()
def create_stellar_deposit(transaction_id): transaction = Transaction.objects.get(id=transaction_id) # Assume transaction has valid stellar_account, amount_in, asset.name stellar_account = transaction.stellar_account payment_amount = transaction.amount_in - transaction.amount_fee asset = transaction.asset.name # If the given Stellar account does not exist, create # the account with at least enough XLM for the minimum # reserve and a trust line (recommended 2.01 XLM), update # the transaction in our internal database, and return. address = Address(stellar_account) try: address.get() except HorizonError as e: # 404 code corresponds to Resource Missing. if e.status_code == 404: starting_balance = settings.ACCOUNT_STARTING_BALANCE builder = Builder(secret=settings.STELLAR_ACCOUNT_SEED) builder.append_create_account_op( destination=stellar_account, starting_balance=starting_balance, source=settings.STELLAR_ACCOUNT_ADDRESS, ) builder.sign() try: builder.submit() except HorizonError as exception: raise exception transaction.status = Transaction.STATUS.pending_trust transaction.save() return # If the account does exist, deposit the desired amount of the given # asset via a Stellar payment. If that payment succeeds, we update the # transaction to completed at the current time. If it fails due to a # trustline error, we update the database accordingly. Else, we do not update. builder = Builder(secret=settings.STELLAR_ACCOUNT_SEED) builder.append_payment_op( destination=stellar_account, asset_code=asset, asset_issuer=settings.STELLAR_ACCOUNT_ADDRESS, amount=str(payment_amount), ) builder.sign() try: builder.submit() except HorizonError as exception: if TRUSTLINE_FAILURE_XDR in exception.message: transaction.status = Transaction.STATUS.pending_trust transaction.save() return # If we reach here, the Stellar payment succeeded, so we # can mark the transaction as completed. transaction.status = Transaction.STATUS.completed transaction.completed_at = now() transaction.amount_out = payment_amount transaction.save()
def send_payment(request,amount,currency,sender,account): builder = Builder(secret=sender) builder.append_payment_op(account,amount,currency) builder.add_text_memo("first payment") builder.sign() s = builder.submit() print(s['_links']) return HttpResponse("send successfully plz check user transaction here")
def build_generate_trust_wallet_transaction( transaction_source_address: str, source_address: str, destination_address: str, xlm_amount: Decimal, hot_amount: Decimal = Decimal(0), sequence=None, ) -> Tuple[bytes, bytes]: """"Build transaction return unsigned XDR and transaction hash. Args: transaction_source_address: Owner of a transaction. source_address: Owner of creator address and payment operations. destination_address: wallet id of new wallet. xlm_amount: starting xlm_balance of new wallet. hot_amount: starting hot balance of new wallet. """ builder = Builder( address=transaction_source_address, horizon=settings['HORIZON_URL'], network=settings['PASSPHRASE'], sequence=sequence, ) builder.append_create_account_op(source=source_address, destination=destination_address, starting_balance=xlm_amount) try: builder.append_trust_op( source=destination_address, destination=settings['ISSUER'], code=settings['ASSET_CODE'], limit=settings['LIMIT_ASSET'], ) except DecodeError: raise web.HTTPBadRequest(reason='Parameter values are not valid.') except Exception as e: msg = str(e) raise web.HTTPInternalServerError(reason=msg) if hot_amount > 0: builder.append_payment_op( source=source_address, destination=destination_address, asset_code=settings['ASSET_CODE'], asset_issuer=settings['ISSUER'], amount=hot_amount, ) try: unsigned_xdr = builder.gen_xdr() except Exception as e: raise web.HTTPBadRequest( reason='Bad request, Please ensure parameters are valid.') tx_hash = builder.te.hash_meta() return unsigned_xdr, tx_hash
def create_signed_tx(private_key, to_address, amount, network='PUBLIC', memo=None): amount = round(amount, 7) builder = Builder(secret=private_key, network=network) builder.append_payment_op(to_address, amount, 'XLM') if memo: builder.add_text_memo(memo) builder.sign() return builder.gen_xdr().decode()
def send_asset(cls, setup, secret_key, address, amount, memo_text=None): """A helper to send asset""" builder = Builder(secret=secret_key, horizon_uri=setup.horizon_endpoint_uri, network=setup.network) builder.append_payment_op(address, amount, setup.test_asset.code, setup.test_asset.issuer) if memo_text: builder.add_text_memo(memo_text[:28]) # max memo length is 28 builder.sign() reply = builder.submit() return reply.get('hash')
def transfer_lumen(sender, to_address, amount, memo=None): # type: (User, str, float, Optional[str]) -> None # ToDo: check remaining lumen of sending account (fee + base reserve) # (take base reserve https://www.stellar.org/developers/guides/concepts/fees.html) builder = Builder(secret=sender.stellaraccount.seed, network=network) builder.append_payment_op(to_address, str(amount), 'XLM') if memo: builder.add_text_memo(memo) # string length <= 28 bytes builder.sign() builder.submit()
def award_degree(self, address, student_name, birthdate, year): """Sends a transaction with a hash of the student's informations as text memo. :param student_name: in format prenamesurname with only one prename :param year: 4-digits number :return: Horizon return of the tx """ memo = hash128((student_name+birthdate+year).encode()) builder = Builder(secret=self.kp.seed().decode()) builder.add_text_memo(memo) builder.append_payment_op(address, 0.0000001) builder.sign() return builder.submit()
async def build_payment_operation(builder: Builder, source: str, parties_wallet: List): for wallet in parties_wallet: destination = wallet['address'] amount = Decimal(wallet['amount']) if amount > 0: builder.append_payment_op( destination=destination, amount=amount, asset_code=settings['ASSET_CODE'], asset_issuer=settings['ISSUER'], source=source, )
def _add_signer(builder: Builder, deal_address: str, party: str, amount: Decimal): """Set permission of parties can signed transaction that generate from joint account""" builder.append_set_options_op(source=deal_address, signer_address=party, signer_type='ed25519PublicKey', signer_weight=1) builder.append_payment_op( source=party, destination=deal_address, asset_code=settings['ASSET_CODE'], asset_issuer=settings['ISSUER'], amount=amount, )
def send_payment(amount, item, asset='XLM'): flag = False try: builder = Builder(secret=MEMBER_SEED) builder.append_payment_op(SITE_ADDR, amount, asset) builder.add_text_memo(item) builder.sign() s = builder.submit() print(s) flag = True except Exception as ex: print('Error in Payment') print(str(ex)) finally: return flag
def transfer(self, amount, to_address, description): ''' ''' if float(self._get_balance()) < float(amount): return 'Insufficient Balance' seed = self.get_seed() builder = Builder(secret=seed) # builder = Builder(secret=seed, network='public') for LIVENET builder.append_payment_op(to_address, amount, 'XLM') builder.add_text_memo(description) # string length <= 28 bytes builder.sign() # Uses an internal horizon instance to submit over the network builder.submit() return 'SUCCESS'
def send_payment(amount, item, asset='XLM'): flag = False try: builder = Builder( secret=MEMBER_SEED) #send payment from member to site builder.append_payment_op(SITE_ADDRESS, amount, asset) builder.add_text_memo(item) builder.sign() s = builder.submit() global balance balance = calculate_balance(s) flag = True except Exception as e: print('Error', e) finally: return flag
def transaction(): # Performs the transaction from one to another thus providing the current balance. builder = Builder(secret=send_seed) builder.append_payment_op(receive_publickey, '500', 'XLM') # Assigning of Receiver address, amount & Asset. builder.add_text_memo('testing') # Assigning of a memo or remark. builder.sign() s = builder.submit() # Submitting the result of the transaction. address1.get() # Receiving balance info in JSON format address2.get() for a1 in address1.balances: send_current = a1['balance'] # Retrieving the eaxct balance info fron JSON. for a2 in address2.balances: receive_current = a2['balance'] cbalance = { # Current balance. 'send_current': send_current, 'receive_current': receive_current, } return render_template("transaction.html", cbalance=cbalance)
def create_token_and_lock_account(self, code, owner_address, metadata): # Setup the base transaction builder = Builder( secret=self.issuer_secret, network=self.network ) # Append relevant payment ops ipfs_hash = self.create_ipfs_hash(metadata) builder.append_manage_data_op('token_ipfs_hash', ipfs_hash) builder.append_payment_op( owner_address, '0.0000001', code, self.issuer_keypair.address().decode() ) builder.append_set_options_op(master_weight=0) builder.sign() return builder.submit()
def withdraw(key, to_address, amount=None, dst_tag=None): keypair = RawKeypair(key) builder = Builder(address=public_key_to_address(keypair.raw_public_key()), network='PUBLIC') if amount is None: builder.append_account_merge_op(to_address) else: builder.append_payment_op(to_address, str(round(float(amount), 7)), 'XLM') if dst_tag is not None: builder.add_text_memo(dst_tag) builder.keypair = keypair builder.sign() ret = builder.submit() if ret['successful']: return ret['hash'] print(ret) return None
def call(self): keypair = self.keypair() builder = Builder(address=keypair.address().decode(), sequence=self.random_sequence(), secret=keypair.seed()) builder.sign() builder.add_memo(self.memo()) builder.add_time_bounds(self.build_time_bounds()) builder.append_payment_op(source=Keypair.random(), destination=keypair.address().decode(), amount='0.000001') builder.sign() te = builder.gen_te() return te.xdr()
def issue_asset(issuer_private_key, distributor_private_key, asset_code, limit, network): issuer_address = Keypair.from_seed(issuer_private_key).address().decode() distributor_address = Keypair.from_seed( distributor_private_key).address().decode() builder = Builder(secret=distributor_private_key, network=network) builder.append_trust_op(destination=issuer_address, code=asset_code, limit=limit) builder.sign() builder.submit() builder = Builder(secret=issuer_private_key, network=network) builder.append_payment_op(destination=distributor_address, amount=limit, asset_type=asset_code, asset_issuer=issuer_address) builder.sign() result = builder.submit() return result
def handle(self, handler_input): # type: (HandlerInput) -> Response speech_text = "" slots = handler_input.request_envelope.request.intent.slots stellar = slots["amount"].value receiver = slots["contact"].value if receiver.lower() in address_book: account = ''.join(value for key, value in address_book.items() if receiver.lower() == key.lower()) builder = Builder(secret=secret) builder.append_payment_op(destination=account, amount=stellar, asset_code='XLM') builder.sign() response = builder.submit() speech_text = f"{stellar} stellar has been sent to {receiver}." else: speech_text = "I could not find that contact in your address book." handler_input.response_builder.speak(speech_text).set_card( SimpleCard("Hello World", speech_text)).set_should_end_session(False) return handler_input.response_builder.response
def send_asset( systemdb, source_name, asset_name, asset_source_name, amount, recipient_name): q = Query() a_sk = systemdb.search(q.name == source_name)[0]['sk'] r_pk = systemdb.search(q.name == recipient_name)[0]['pk'] b = Builder(secret = a_sk, network='TESTNET') if asset_source_name == None: b.append_payment_op(r_pk, amount, asset_name, None) else: as_pk = systemdb.search(q.name == asset_source_name)[0]['pk'] b.append_payment_op(r_pk, amount, asset_name, as_pk) b.sign() response = b.submit() print response
def payment(target_address: str, amount: str, network, source_secret): config = configs[network] src_address = Keypair.from_seed(source_secret).address().decode() builder = Builder(secret=source_secret, horizon_uri=config['HORIZON_URL'], network=network) builder.append_payment_op(destination=target_address, asset_code='HOT', asset_issuer=config['ISSUER_HOT'], amount=amount) builder.sign() print("############### TX #################") print('Payment {} HOT from {} to {}'.format(amount, src_address, target_address)) print('Network: {}'.format(network)) print('Sequence: {}'.format(builder.sequence)) print('Hash: {}'.format(builder.hash())) print("#########################################") click.confirm('Correct?', abort=True) print('Submitting...') builder.submit() print('success') return True
async def build_unsigned_add_trust_and_hot( source_address: str, transaction_source_address: str, hot_amount: Decimal, sequence: str = None) -> Tuple[str, str]: """"Build unsigned transfer transaction return unsigned XDR and transaction hash. Args: source_address: address need to be trust HOT and address for getting HOT """ builder = Builder( address=transaction_source_address, horizon=settings['HORIZON_URL'], network=settings['PASSPHRASE'], sequence=sequence, ) builder.append_trust_op(settings['ISSUER'], settings['ASSET_CODE'], source=source_address, limit=settings['LIMIT_ASSET']) if hot_amount > 0: builder.append_payment_op( source=transaction_source_address, destination=source_address, asset_code=settings['ASSET_CODE'], asset_issuer=settings['ISSUER'], amount=hot_amount, ) try: unsigned_xdr = builder.gen_xdr() tx_hash = builder.te.hash_meta() except Exception as ex: raise web.HTTPNotFound(text=str(ex)) return unsigned_xdr.decode('utf8'), binascii.hexlify(tx_hash).decode()
def send_asset(issuingkeys, receivingkeys, assetcode): send_v1 = Builder(secret=issuingkeys.seed().decode()) send_v1.append_payment_op(receivingkeys.address().decode( ), '1', assetcode, issuingkeys.address().decode()) send_v1.sign() return send_v1.submit()