def create_and_fund(user_pubkey):
"""Create account and fund it with starting XLM and BUL amounts"""
try:
paket_stellar.get_bul_account(user_pubkey, accept_untrusted=True)
except paket_stellar.StellarAccountNotExists:
LOGGER.info("stellar account with pubkey %s does not exists and will be created", user_pubkey)
else:
LOGGER.info("stellar account with pubkey %s already exists", user_pubkey)
return
daily_spent_euro = get_daily_spent_euro()
if daily_spent_euro >= DAILY_FUND_LIMIT:
raise FundLimitReached('daily fund limit reached')
hourly_spent_euro = get_hourly_spent_euro()
if hourly_spent_euro >= HOURLY_FUND_LIMIT:
raise FundLimitReached('hourly fund limit reached')
starting_balance = util.conversion.stroops_to_units(XLM_STARTING_BALANCE)
funder_pubkey = paket_stellar.stellar_base.Keypair.from_seed(FUNDER_SEED).address().decode()
builder = paket_stellar.gen_builder(funder_pubkey)
builder.append_create_account_op(destination=user_pubkey, starting_balance=starting_balance)
envelope = builder.gen_te().xdr().decode()
paket_stellar.submit_transaction_envelope(envelope, seed=FUNDER_SEED)
euro_cents = util.conversion.xlm_to_euro_cents(XLM_STARTING_BALANCE, prices.xlm_price())
with SQL_CONNECTION() as sql:
sql.execute("""
INSERT INTO fundings (user_pubkey, currency, currency_amount, euro_cents)
VALUES (%s, %s, %s, %s)""", (user_pubkey, 'XLM', XLM_STARTING_BALANCE, euro_cents))
def accept_package_by_recipient(package):
"""Accept package by recipient."""
accept_package_event(
TEST_RECIPIENT_PUBKEY, escrow_pubkey=package['escrow_pubkey'], location=package['to_location'])
xdr_event = next((event for event in package['events'] if event['event_type'] == 'escrow XDRs assigned'), None)
if xdr_event is None:
SimulationError("can't accept package without XDRs transactions")
xdrs = json.loads(xdr_event['kwargs'])['escrow_xdrs']
paket_stellar.submit_transaction_envelope(xdrs['payment_transaction'], TEST_RECIPIENT_SEED)
paket_stellar.submit_transaction_envelope(xdrs['merge_transaction'])
def fund(user_pubkey):
"""Fund account with starting BUL amount."""
funder_pubkey = paket_stellar.stellar_base.Keypair.from_seed(FUNDER_SEED).address().decode()
prepare_fund_transaction = paket_stellar.prepare_send_buls(
funder_pubkey, user_pubkey, BUL_STARTING_BALANCE)
paket_stellar.submit_transaction_envelope(prepare_fund_transaction, FUNDER_SEED)
euro_cents = util.conversion.bul_to_euro_cents(BUL_STARTING_BALANCE, prices.bul_price())
with SQL_CONNECTION() as sql:
sql.execute("""
INSERT INTO fundings (user_pubkey, currency, currency_amount, euro_cents)
VALUES (%s, %s, %s, %s)""", (user_pubkey, 'BUL', BUL_STARTING_BALANCE, euro_cents))
def test_submit(self):
"""Test submitting properly created and signed transaction."""
new_keypair = paket_stellar.get_keypair()
pubkey = new_keypair.address().decode()
create_account_transaction = paket_stellar.prepare_create_account(
self.regular_account_pubkey, pubkey, 50000000)
result = paket_stellar.submit_transaction_envelope(
create_account_transaction, self.regular_account_seed)
self.assertIn('result_xdr', result)
self.assertEqual(result['result_xdr'],
'AAAAAAAAAGQAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAA=')
def take_package_from_launcher(package):
"""
Confirm couriering, create new escrow account in stellar, add trust to it,
prepare transactions, send set_opts transaction, fund escrow account with payment and collateral,
accept package by courier.
:return:
"""
escrow_pubkey = package['escrow_pubkey']
confirm_couriering_event(
TEST_COURIER_PUBKEY, escrow_pubkey=escrow_pubkey, location=package['from_location'])
seed_event = next((event for event in package['events']
if event['event_type'] == 'escrow seed added'), None)
if seed_event is None:
raise SimulationError("package {} is not simulation pacakge".format(escrow_pubkey))
escrow_seed = json.loads(seed_event['kwargs'])['escrow_seed']
create_new_account(TEST_LAUNCHER_SEED, escrow_pubkey, ESCROW_BALANCE)
add_trust(escrow_pubkey, escrow_seed)
escrow = paket_stellar.prepare_escrow(
escrow_pubkey, TEST_LAUNCHER_PUBKEY, TEST_COURIER_PUBKEY,
TEST_RECIPIENT_PUBKEY, PAYMENT, COLLATERAL, package['deadline'])
assign_xdrs_event(TEST_LAUNCHER_PUBKEY, escrow_pubkey=escrow_pubkey,
location=package['from_location'], kwargs=json.dumps(dict(escrow_xdrs=escrow)))
paket_stellar.submit_transaction_envelope(escrow['set_options_transaction'], escrow_seed)
send_bul_transaction = paket_stellar.prepare_send_buls(TEST_LAUNCHER_PUBKEY, escrow_pubkey, PAYMENT)
paket_stellar.submit_transaction_envelope(send_bul_transaction, TEST_LAUNCHER_SEED)
send_bul_transaction = paket_stellar.prepare_send_buls(TEST_COURIER_PUBKEY, escrow_pubkey, COLLATERAL)
paket_stellar.submit_transaction_envelope(send_bul_transaction, TEST_COURIER_SEED)
accept_package_event(
TEST_COURIER_PUBKEY, escrow_pubkey=escrow_pubkey, location=package['from_location'])
def submit_transaction_handler(transaction):
"""
Submit a signed transaction.
This call is used to submit signed transactions.
Signed transactions can be obtained by signing unsigned
transactions returned by other calls. You can use the
[laboratory](https://www.stellar.org/laboratory/#txsigner?network=test) to
sign the transaction with your private key.
---
:param transaction:
:return:
"""
return {'status': 200, 'response': paket_stellar.submit_transaction_envelope(transaction)}
def setup_account(seed, new_account=False, add_trust=False):
"""Generate new keypair, and optionally create account and set trust."""
keypair = paket_stellar.get_keypair(seed=seed)
pubkey = keypair.address().decode()
seed = keypair.seed().decode()
if new_account:
try:
account = paket_stellar.get_bul_account(pubkey,
accept_untrusted=True)
except paket_stellar.StellarAccountNotExists:
LOGGER.info("%s not exist and will be created", pubkey)
create_account_transaction = paket_stellar.prepare_create_account(
paket_stellar.ISSUER, pubkey, START_ACCOUNT_BALANCE)
paket_stellar.submit_transaction_envelope(
create_account_transaction, paket_stellar.ISSUER_SEED)
else:
LOGGER.info("%s already exist", pubkey)
if account['xlm_balance'] < MINIMUM_ACCOUNT_BALANCE:
LOGGER.info("%s has %s XLM on balance and need to be funded",
pubkey, account['xlm_balance'])
send_xlm_transaction = paket_stellar.prepare_send_lumens(
paket_stellar.ISSUER, pubkey, START_ACCOUNT_BALANCE)
paket_stellar.submit_transaction_envelope(
send_xlm_transaction, paket_stellar.ISSUER_SEED)
else:
LOGGER.info("%s has %s XLM on balance", pubkey,
account['xlm_balance'])
if new_account and add_trust:
try:
paket_stellar.get_bul_account(pubkey)
except paket_stellar.TrustError:
LOGGER.info("BUL trustline will be added to %s", pubkey)
trust_transaction = paket_stellar.prepare_trust(pubkey)
paket_stellar.submit_transaction_envelope(trust_transaction, seed)
else:
LOGGER.info("%s already trust BUL", pubkey)
return pubkey, seed
def test_ent_to_end(self):
"""End-to-end test."""
# prepare escrow properties
payment = 10000000
collateral = 20000000
relay_payment = 5000000
relay_collateral = 10000000
deadline = int(time.time()) + 60 * 60 * 24 * 10
# prepare participants accounts
# launcher_account, first_courier_account, second_courier_account, recipient_account = (
# self.create_and_setup_new_account() for _ in range(4))
# escrow_account = self.create_and_setup_new_account(buls_amount=payment)
launcher_account = (
'GBI27N2K5CA46RVPPO2UFQABNQIOFVJGJPXJWNROS2KR6J5BP2H7TX4M',
'SAAR6N7SLB3OECH7OBEGNPXADX35GV7R7EVC6P67EEXXWKIZYC346BWV')
first_courier_account = (
'GDCFBUSFW5GDHO6TQW65ACW3JRDFTBK2I5YTWJRRJHIFIPO5FIQWLOLA',
'SDBE3HXYKW2WMQWKZOCNRD4EICC4VMBOTM7BCSROQAA7TGVWZZGCO7LV')
second_courier_account = (
'GB7VMXUABOSAG7TXDPVR2MMHEBKEXBNWA2EHP5SUHG5HU66PDW2F77W6',
'SAEYMJX77WYIHT2TSONGMTUTTSR7CR2GOMPZQKNRJA5Z6JZ63REZ5KU2')
recipient_account = (
'GBR4SCRHZUPYYFIC7HBJKMEIESSZRGSTYMZSLNSG2IH2B6Z766QDTXJC',
'SB7R6P6NMJS3S6PA6WKFWQMD3BU4H2N7ZT4OORVQC5PSHLBBEG2OU7TZ')
# prepare courier's additional account
keypair = paket_stellar.stellar_base.Keypair.random()
fcourier_additional_account = keypair.address().decode(), keypair.seed(
).decode()
prepare_account = paket_stellar.prepare_create_account(
first_courier_account[0], fcourier_additional_account[0])
paket_stellar.submit_transaction_envelope(
prepare_account, seed=first_courier_account[1])
prepare_trust = paket_stellar.prepare_trust(
fcourier_additional_account[0])
paket_stellar.submit_transaction_envelope(
prepare_trust, seed=fcourier_additional_account[1])
LOGGER.info('additional account prepared')
# get initial balances
launcher_initial_balance = paket_stellar.get_bul_account(
launcher_account[0])['bul_balance']
LOGGER.info("launcher initial balance: %s BUL stroops",
launcher_initial_balance)
first_courier_initial_balance = paket_stellar.get_bul_account(
first_courier_account[0])['bul_balance']
LOGGER.info("first courier initial balance: %s BUL stroops",
first_courier_initial_balance)
fcourier_additional_initial_balance = paket_stellar.get_bul_account(
fcourier_additional_account[0])['bul_balance']
LOGGER.info(
"first courier additional account initial balance: %s BUL stroops",
fcourier_additional_initial_balance)
second_courier_initial_balance = paket_stellar.get_bul_account(
second_courier_account[0])['bul_balance']
LOGGER.info("second courier initial balance: %s BUL stroops",
second_courier_initial_balance)
# prepare escrow account
# escrow_account = self.create_and_setup_new_account(buls_amount=payment+collateral)
escrow_keypair = paket_stellar.stellar_base.Keypair.random()
escrow_account = escrow_keypair.address().decode(
), escrow_keypair.seed().decode()
prepare_escrow_account = paket_stellar.prepare_create_account(
launcher_account[0], escrow_account[0])
paket_stellar.submit_transaction_envelope(prepare_escrow_account,
seed=launcher_account[1])
prepare_trust = paket_stellar.prepare_trust(escrow_account[0])
paket_stellar.submit_transaction_envelope(prepare_trust,
seed=escrow_account[1])
LOGGER.info('escrow account prepared')
# prepare escrow transactions
escrow_transactions = paket_stellar.prepare_escrow(
escrow_account[0], launcher_account[0],
fcourier_additional_account[0], recipient_account[0], payment,
collateral, deadline)
LOGGER.info('escrow transactions prepared')
paket_stellar.submit_transaction_envelope(
escrow_transactions['set_options_transaction'],
seed=escrow_account[1])
LOGGER.info('escrow set_options transaction sent')
# send payment and collateral to escrow
prepare_send_buls = paket_stellar.prepare_send_buls(
launcher_account[0], escrow_account[0], payment)
paket_stellar.submit_transaction_envelope(prepare_send_buls,
seed=launcher_account[1])
LOGGER.info('payment sent to escrow account')
prepare_send_buls = paket_stellar.prepare_send_buls(
first_courier_account[0], escrow_account[0], collateral)
paket_stellar.submit_transaction_envelope(
prepare_send_buls, seed=first_courier_account[1])
LOGGER.info('collateral sent to escrow account')
# prepare relay transactions
relay_transactions = paket_stellar.prepare_relay(
fcourier_additional_account[0], first_courier_account[0],
second_courier_account[0],
payment + collateral - relay_payment - relay_collateral,
relay_payment + relay_collateral, deadline)
LOGGER.info('relay transactions prepared')
paket_stellar.submit_transaction_envelope(
relay_transactions['set_options_transaction'],
seed=fcourier_additional_account[1])
# second courier send collateral directly to first courier account
prepare_send = paket_stellar.prepare_send_buls(
second_courier_account[0], first_courier_account[0],
relay_collateral)
paket_stellar.submit_transaction_envelope(
prepare_send, seed=second_courier_account[1])
# accept package by recipient
paket_stellar.submit_transaction_envelope(
escrow_transactions['payment_transaction'],
seed=recipient_account[1])
LOGGER.info('package accepted by courier')
paket_stellar.submit_transaction_envelope(
escrow_transactions['merge_transaction'])
LOGGER.info('escrow merge transaction sent')
# submit relay transactions
paket_stellar.submit_transaction_envelope(
relay_transactions['relay_transaction'])
paket_stellar.submit_transaction_envelope(
relay_transactions['sequence_merge_transaction'])
# get result balances
launcher_result_balance = paket_stellar.get_bul_account(
launcher_account[0])['bul_balance']
first_courier_result_balance = paket_stellar.get_bul_account(
first_courier_account[0])['bul_balance']
second_courier_result_balance = paket_stellar.get_bul_account(
second_courier_account[0])['bul_balance']
# check account balances
self.assertEqual(
launcher_result_balance, launcher_initial_balance - payment,
"expected {} BUL stroops for launcher, {} got instead".format(
launcher_initial_balance - payment, launcher_result_balance))
self.assertEqual(
first_courier_result_balance,
first_courier_initial_balance + payment - relay_payment,
"expected {} BUL stroops for first courier, {} got instead".format(
first_courier_initial_balance + payment - relay_payment,
first_courier_result_balance))
self.assertEqual(
second_courier_result_balance,
second_courier_initial_balance + relay_payment,
"expected {} BUL stroops for second courier, {} got instead".
format(second_courier_initial_balance + relay_payment,
second_courier_result_balance))
def add_trust(user_pubkey, user_seed):
"""Add BUL trust to account."""
prepared_transaction = paket_stellar.prepare_trust(user_pubkey)
paket_stellar.submit_transaction_envelope(prepared_transaction, seed=user_seed)
def create_new_account(source_account_seed, user_pubkey, amount):
"""Create new Stellar account and send specified amount of XLM to it."""
source_keypair = paket_stellar.stellar_base.Keypair.from_seed(source_account_seed)
prepared_transaction = paket_stellar.prepare_create_account(
source_keypair.address().decode(), user_pubkey, amount)
paket_stellar.submit_transaction_envelope(prepared_transaction, source_account_seed)
def create_new_account(user_pubkey, amount):
"""Create new Stellar account and send specified amount of XLM to it"""
prepared_transaction = paket_stellar.prepare_create_account(paket_stellar.ISSUER, user_pubkey, amount)
paket_stellar.submit_transaction_envelope(prepared_transaction, FUNDER_SEED)
def fund_account(user_pubkey, amount, asset_code):
"""Fund account with XLM or BUL"""
assert asset_code in ['XLM', 'BUL'], 'asset must be XLM or BUL'
prepare_function = paket_stellar.prepare_send_buls if asset_code == 'BUL' else paket_stellar.prepare_send_lumens
prepared_transaction = prepare_function(paket_stellar.ISSUER, user_pubkey, amount)
paket_stellar.submit_transaction_envelope(prepared_transaction, FUNDER_SEED)
