Esempio n. 1
0
 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
Esempio n. 2
0
def bounty_dispatcher(document, amount):
    """
    Dispatch amount specified to the destination address
    :param document: Desetination address
    :param amount: Amount of nwc to dispatch
    :return: response object
    """
    for line in document:
        builder = Builder(secret=REAL_SEED, network='public')
        builder.add_text_memo(
            "NWC bounty reward amount: {}".format(amount)).append_payment_op(
                destination=line,
                amount=amount,
                asset_code='NWC',
                asset_issuer=ISSUER)
        builder.sign()
        response = builder.submit()
        print(response)
        with open("bounty.log", "a+") as log:
            log.write("\n")
            log.write(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
            log.write("\n")
            log.write("=============================================")
            log.write("\n")
            log.write(json.dumps(response))
            log.write("\n")
    return response
Esempio n. 3
0
def burn_tokens(address):
    """
    Burn the recent payments to the address for the percent specified in the BURN_RATE constant
    :param address: address to burn the tokens on
    :return: response object
    """
    # get recent payments
    address_obj = Address(address=address)
    payments = address_obj.payments()
    asset_sum = 0
    for payment in payments:
        asset_sum += payment

    burn_sum = asset_sum * BURN_RATE

    # send the BURN % of tokens to the issuer ultimately taking them out of circulation
    builder = Builder(secret=REAL_SEED, network='public')
    builder.add_text_memo(
        "NWC daily burn: {}".format(burn_sum)).append_payment_op(
            destination=ISSUER,
            amount=burn_sum,
            asset_code='NWC',
            asset_issuer=ISSUER)
    builder.sign()
    response = builder.submit()
    return response
Esempio n. 4
0
def submit_operations(account_seed, operations, transaction_memo):
    """
    This method signs the given operations and submits them to the Stellar network
    :param str account_seed: Seed of the account submitting the operations. It is required to sign the transactions.
    :param Operation operations: Operations to be submitted.
    :param str transaction_memo: Text memo to be included in Stellar transaction. Maximum size of 28 bytes.
    :return: Returns a string containing the server response or None if the transaction could not be submitted.
    :rtype: str or None
    """
    try:
        builder = Builder(secret=account_seed)
    except Exception:
        # Too broad exception because no specific exception is being thrown by the stellar_base package.
        # TODO: This should be fixed in future versions
        print("An error occurred (Please check your Internet connection)")
        return None

    builder.add_text_memo(transaction_memo)
    for operation in operations:
        builder.append_op(operation)
    builder.sign()
    try:
        return builder.submit()
    except Exception:
        # Too broad exception because no specific exception is being thrown by the stellar_base package.
        # TODO: This should be fixed in future versions
        print("An error occurred (Please check your Internet connection)")
        return None
Esempio n. 5
0
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()
Esempio n. 6
0
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")
Esempio n. 7
0
 def trust_asset(setup, secret_key, memo_text=None):
     """A helper to establish a trustline"""
     builder = Builder(secret=secret_key,
                       horizon_uri=setup.horizon_endpoint_uri,
                       network=setup.network)
     builder.append_trust_op(setup.test_asset.issuer, setup.test_asset.code)
     if memo_text:
         builder.add_text_memo(memo_text[:28])  # max memo length is 28
     builder.sign()
     reply = builder.submit()
     return reply.get('hash')
Esempio n. 8
0
 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()
Esempio n. 9
0
 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')
Esempio n. 10
0
def pay(message, amount, secret, address):

    sender_secret = secret
    receiver_address = address

    builder = Builder(secret=sender_secret,
                      horizon_uri=None,
                      network='TESTNET')
    builder.add_text_memo(message).append_payment_op(
        destination=receiver_address, amount=amount, asset_code='XLM')
    builder.sign()
    response = builder.submit()
Esempio n. 11
0
    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()
Esempio n. 12
0
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()
Esempio n. 13
0
 def send(self, destination, amount):
     destination = check_pay_by_name(destination, "XLM")
     wallet = Wallet.objects.get(user=self.user, name=self.coin)
     try:
         builder = Builder(secret=wallet.private)
         builder.add_text_memo("EXMR, Stellar!").append_payment_op(
             destination=destination.strip(),
             amount=str(amount),
             asset_code='XLM')
         builder.sign()
         response = builder.submit()
         return response["hash"]
     except:
         return {"error": "insufficient funds"}
Esempio n. 14
0
    def test_add_memo(self, test_data):
        builder = Builder(test_data.cold_secret, sequence=1, fee=100)

        builder.add_text_memo("hello")
        assert builder.memo == memo.TextMemo("hello")

        builder.add_id_memo(123123)
        assert builder.memo == memo.IdMemo(123123)

        hash = b"\x95\xe5\xbb\x95\x15\xd9\x9f\x82\x9d\xf9\x93\xc3'\x8e\xeb\xf1\nj!\xda\xa4\xa1\xe4\xf2<6cG}\x17\x97\xfe"
        builder.add_hash_memo(hash)
        assert builder.memo == memo.HashMemo(hash)
        builder.add_ret_hash_memo(hash)
        assert builder.memo == memo.RetHashMemo(hash)
Esempio n. 15
0
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
Esempio n. 16
0
    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'
Esempio n. 17
0
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
Esempio n. 18
0
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)
Esempio n. 19
0
def send_payment(address, amount):
    builder = Builder(secret=REAL_SEED, network='public')
    builder.add_text_memo(
        "NWC transaction amount: {}".format(amount)).append_payment_op(
            destination=address,
            amount=amount,
            asset_code='NWC',
            asset_issuer=ISSUER)
    builder.sign()
    response = builder.submit()
    print(response)
    with open("transaction.log", "a+") as log:
        log.write("\n")
        log.write(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
        log.write("\n")
        log.write("=============================================")
        log.write("\n")
        log.write(json.dumps(response))
        log.write("\n")
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
Esempio n. 21
0
def send_payment_and_lock(address, amount, release, valid):
    """
    Send the payment to the specified address and lock it for the specified time period
    :param address: Destination address
    :param amount:  Amount of NWC to payout
    :param release: Start of token lock date
    :param valid:  End of token lock date
    :return: response object
    """
    timestamp_release = (release -
                         datetime.datetime(1970, 1, 1)).total_seconds()
    timestamp_valid = (valid - datetime.datetime(1970, 1, 1)).total_seconds()
    builder = Builder(secret=REAL_SEED, network='public')
    builder.add_text_memo(
        "NWC transaction amount: {}; asset locked till: {}".format(
            amount,
            release)).append_payment_op(destination=address,
                                        amount=amount,
                                        asset_code='NWC',
                                        asset_issuer=ISSUER).add_time_bounds({
                                            'minTime':
                                            timestamp_release,
                                            'maxTime':
                                            timestamp_valid
                                        })
    builder.sign()
    response = builder.submit()
    print(response)
    with open("transaction.log", "a+") as log:
        log.write("\n")
        log.write(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
        log.write("\n")
        log.write("unlocks: " + release.strftime("%Y-%m-%d %H:%M:%S"))
        log.write("\n")
        log.write("valid till: " + valid.strftime("%Y-%m-%d %H:%M:%S"))
        log.write("=============================================")
        log.write("\n")
        log.write(json.dumps(response))
        log.write("\n")
    return response
Esempio n. 22
0
 def create_transaction(self, from_address, to_address, amount, memo):
     """
     创建一笔交易
     :param from_address: 发起账户的私钥
     :param to_address:  目的账户的公钥
     :return: response
     """
     builder = Builder(secret=from_address, horizon_uri=self.rpc_uri)
     builder_memo = builder.add_text_memo(memo)
     builder_memo.append_payment_op(destination=to_address,
                                    amount=amount,
                                    asset_code='XLM')
     builder.sign()
     response = builder.submit()
     return response
Esempio n. 23
0
class Interface:
    """
    Interface to handle all API calls to third-party account.
    """
    def __init__(self, account):
        self.account = account
        if account.secret:
            self.builder = Builder(secret=account.secret,
                                   network=account.network)
        self.address = Address(address=account.account_id,
                               network=account.network)

    def _get_new_receives(self):
        # Get all stored transactions for account
        transactions = ReceiveTransaction.filter(admin_account=self.account)

        # Set the cursor according to latest stored transaction:
        if not transactions:
            cursor = None
        else:
            cursor = int(transactions.latest().data['paging_token']) + 1

        # Get new transactions from the stellar network:
        new_transactions = self._get_receives(cursor=cursor)

        return new_transactions

    def _get_receives(self, cursor=None):
        # If cursor was specified, get all transactions after the cursor:
        if cursor:
            transactions = self.address.payments(cursor=cursor)['_embedded']['records']
            print(transactions)
            for i, tx in enumerate(transactions):
                if tx.get('to') != self.account.account_id:
                    transactions.pop(i)  # remove sends

        # else just get all the transactions:
        else:
            transactions = self.address.payments()['_embedded']['records']
            for i, tx in enumerate(transactions):
                if tx.get('from') == self.account.account_id:
                    transactions.pop(i)  # remove sends

        return transactions

    def _process_receive(self, tx):
        # Get memo:
        details = requests.get(url=tx['_links']['transaction']['href']).json()
        memo = details.get('memo')
        print('memo: ' + str(memo))
        if memo:
            account_id = memo + '*rehive.com'
            user_account = UserAccount.objects.get(account_id=account_id)
            user_email = user_account.user_id  # for this implementation, user_id is the user's email
            amount = to_cents(Decimal(tx['amount']), 7)

            if tx['asset_type'] == 'native':
                currency = 'XLM'
                issuer = ''
            else:
                currency = tx['asset_code']
                issuer_address = tx['asset_issuer']
                issuer = Asset.objects.get(account_id=issuer_address, code=currency).issuer

            # Create Transaction:
            tx = ReceiveTransaction.objects.create(user_account=user_account,
                                                   external_id=tx['hash'],
                                                   recipient=user_email,
                                                   amount=amount,
                                                   currency=currency,
                                                   issuer=issuer,
                                                   status='Waiting',
                                                   data=tx,
                                                   metadata={'type': 'stellar'}
                                                   )

            # TODO: Move tx.upload_to_rehive() to a signal to auto-run after Transaction creation.
            tx.upload_to_rehive()

            return True

    @staticmethod
    def _is_valid_address(address: str) -> bool:
        # TODO: Replace with real address check.
        if len(address) == 56 and '*' not in address:
            return True
        else:
            return False

    # This function should always be included if transactions are received to admin account and not added via webhooks:
    def process_receives(self):
        # Get new receive transactions
        new_transactions = self._get_new_receives()

        # Add each transaction to Rehive and log in transaction table:
        for tx in new_transactions:
            self._process_receive(tx)

    # This function should always be included.
    def process_send(self, tx):
        if self._is_valid_address(tx.recipient):
            address = tx.recipient
        else:
            federation = get_federation_details(tx.recipient)
            if federation['memo_type'] == 'text':
                self.builder.add_text_memo(federation['memo'])
            elif federation['memo_type'] == 'id':
                self.builder.add_id_memo(federation['memo'])
            elif federation['memo_type'] == 'hash':
                self.builder.add_hash_memo(federation['memo'])
            else:
                raise NotImplementedAPIError('Invalid memo type specified.')

            address = federation['account_id']

        # Create account or create payment:
        if tx.currency == 'XLM':
            try:
                address_obj = self.address
                address_obj.get()
                self.builder.append_payment_op(address, tx.amount, 'XLM')
            except APIException as exc:
                if exc.status_code == 404:
                    self.builder.append_create_account_op(address, tx.amount)
        else:
            # Get issuer address details:
            issuer_address = get_issuer_address(tx.issuer, tx.currency)

            address_obj = self.address
            address_obj.get()
            self.builder.append_payment_op(address, tx.amount, tx.currency, issuer_address)

        try:
            self.builder.sign()
            self.builder.submit()
        except Exception as exc:
            print(exc.payload)

    def get_balance(self):
        address = self.address
        address.get()
        for balance in address.balances:
            if balance['asset_type'] == 'native':
                return to_cents(Decimal(balance['balance']), 7)

    def get_issuer_address(self, issuer, asset_code):
        if self._is_valid_address(issuer):
            address = issuer
        else:
            if '*' in issuer:
                address = get_federation_details(issuer)['account_id']
            else:  # assume it is an anchor domain
                address = address_from_domain(issuer, asset_code)

        return address

    def trust_issuer(self, asset_code, issuer):
        logger.info('Trusting issuer: %s %s' % (issuer, asset_code))
        address = self.get_issuer_address(issuer, asset_code)
        self.builder.append_trust_op(address, asset_code)

        try:
            self.builder.sign()
            self.builder.submit()
        except Exception as exc:
            print(exc.payload)

    # Generate new crypto address/ account id
    @staticmethod
    def new_account_id(**kwargs):
        metadata = kwargs.get('metadata')
        account_id = metadata['username'] + '*' + getattr(settings, 'STELLAR_WALLET_DOMAIN')
        return account_id

    def get_account_details(self):
        address = self.account.account_id
        qr_code = create_qr_code_url('stellar:' + str(address))
        return {'account_id': address, 'metadata': {'qr_code': qr_code}}
Esempio n. 24
0
 def sendTransaction(self, receiverAddress, amount, message='Test'):
     builder = Builder(secret=self.seed)
     builder.append_payment_op(receiverAddress, amount, 'XLM')
     builder.add_text_memo(message)
     builder.sign()
     builder.submit()
Esempio n. 25
0
from stellar_base.builder import Builder
import csv
from array import *

sender_secret = 'SBIQIV2XQBBVXK7FFNNRDTTKG2YTQI5GI4DNY75SDCP2IBMQ2NFZNQNS'

receiver_address = []
with open('assetHoldersExport(testnet).csv', 'r') as csv_file:
    csv_reader = csv.reader(csv_file)

    next(csv_reader)

    for line in csv_reader:
        receiver_address.append(line[1])


for i in range(len(receiver_address)):


    builder = Builder(secret=sender_secret, horizon_uri='https://horizon-testnet.stellar.org', network='TESTNET')
    builder.add_text_memo("Thank you for using TXBNB!").append_payment_op(
        destination=receiver_address[i],
        amount='1.6333',
        asset_code='TXBNB',
        asset_issuer='GDHAFLI6STAHO2GPJEG56CEWRC5QNT54QNWIPREHI4NXJHANSKOGDDTI'
    )
    builder.sign()
    response = builder.submit()
    print(response)
Esempio n. 26
0
async def build_unsigned_transfer(
    transaction_source_address: str,
    source_address: str,
    destination_address: str,
    amount_hot: Decimal,
    amount_xlm: Decimal,
    tax_amount_hot: Decimal = None,
    sequence: int = None,
    memo_text: str = None,
) -> Tuple[str, str]:
    """"Build unsigned transfer transaction return unsigned XDR and transaction hash.

        Args:
            source_address: Owner of operation
            destination_address: wallet id of new wallet
            amount_hot: amount of hot that would be transfer
            amount_xlm: amount of xlm that would be transfer
            sequence: sequence number for generate transaction [optional]
            memo: memo text [optional]
    """
    builder = Builder(
        address=transaction_source_address,
        sequence=sequence,
        horizon=settings['HORIZON_URL'],
        network=settings['PASSPHRASE'],
    )

    wallet = await get_wallet_detail(destination_address)

    if amount_hot and not wallet['asset'].get(settings['ASSET_CODE'], False):
        raise web.HTTPBadRequest(reason="{} is not trusted {}".format(
            destination_address, settings['ASSET_CODE']))

    if amount_xlm:
        builder.append_payment_op(destination_address,
                                  amount_xlm,
                                  source=source_address)

    if amount_hot and wallet['asset'].get(settings['ASSET_CODE'], False):
        builder.append_payment_op(
            destination_address,
            amount_hot,
            asset_code=settings['ASSET_CODE'],
            asset_issuer=settings['ISSUER'],
            source=source_address,
        )

    if tax_amount_hot and Decimal(tax_amount_hot) > 0:
        builder.append_payment_op(
            settings['TAX_COLLECTOR_ADDRESS'],
            Decimal(tax_amount_hot),
            asset_code=settings['ASSET_CODE'],
            asset_issuer=settings['ISSUER'],
            source=source_address,
        )

    if memo_text:
        builder.add_text_memo(memo_text)

    unsigned_xdr = builder.gen_xdr()
    tx_hash = builder.te.hash_meta()
    return unsigned_xdr.decode('utf8'), binascii.hexlify(tx_hash).decode()
Esempio n. 27
0
from stellar_base.builder import Builder

alice_secret = 'SCB6JIZUC3RDHLRGFRTISOUYATKEE63EP7MCHNZNXQMQGZSLZ5CNRTKK'
bob_address = 'GA7YNBW5CBTJZ3ZZOWX3ZNBKD6OE7A7IHUQVWMY62W2ZBG2SGZVOOPVH'

builder = Builder(secret=alice_secret,
                  horizon='https://horizon.stellar.org',
                  network='PUBLIC')
builder.add_text_memo("Hello, Stellar!").append_payment_op(
    destination=bob_address, amount='12.25', asset_code='XLM')
builder.sign()
response = builder.submit()
print(response)
print('Alice Balances: {}'.format(address.balances))

# Bob's address, for the destination
kp = Keypair.random()
bob_address = kp.address().decode()
print('bobs_address: {}'.format(bob_address))
url = 'https://friendbot.stellar.org'
r = requests.get(url, params={'addr': bob_address})

address = Address(address=bob_address)  # See signature for additional args
address.get()  # Get the latest information from Horizon

print('Bobs Balances: {}'.format(address.balances))

builder = Builder(secret=seed)
builder.append_payment_op(bob_address, '100', 'XLM')
builder.add_text_memo('For beers')  # string length <= 28 bytes
builder.sign()

# Uses an internal horizon instance to submit over the network
response = builder.submit()

address = Address(address=bob_address)  # See signature for additional args
address.get()  # Get the latest information from Horizon

print('Bobs Balances: {}'.format(address.balances))

address = Address(address=alice_address)  # See signature for additional args
address.get()  # Get the latest information from Horizon

print('Alice Balances: {}'.format(address.balances))
Esempio n. 29
0
from stellar_base.builder import Builder
seed = "SAUV4WPT2IY3N5OVQHGYLMOH4SPOUFS27YEER3BYFWVVIWSEETFIHTLQ"
builder = Builder(secret=seed)
# builder = Builder(secret=seed, network='public') for LIVENET

bob_address = 'GBCCC62LUXPDL7DLNQPYJWASA672CCJOLCJRBSIFXNIPRMQRRQ2HCWW6'
builder.append_payment_op(bob_address, '100', 'XLM')
builder.add_text_memo("K L P") # string length <= 28 bytes
builder.sign()

# Uses an internal horizon instance to submit over the network
builder.submit()