async def main():
initialize()
txs = []
accounts = []
minimum_fee = clients[0].get_minimum_fee()
# Creating new test accounts
accounts.append(Keypair())
accounts.append(Keypair())
accounts.append(Keypair())
print('Creating new test accounts')
root_account.create_account(accounts[0].public_address, 100000000,
minimum_fee)
root_account.create_account(accounts[1].public_address, 100000000,
minimum_fee)
assert clients[0].does_account_exists(
accounts[1].public_address) and clients[0].does_account_exists(
accounts[0].public_address)
print('2 Test accounts created - Passed')
for i in range(tx_count):
# generating transactions using multiple kin-cores
builder = Builder('LOCAL',
clients[i % len(clients)].horizon,
fee=minimum_fee,
secret=accounts[i % len(accounts)].secret_seed)
builder.get_sequence()
builder.append_manage_data_op('test' + str(i), 'test'.encode())
builder.sign()
txs.append(builder)
# waiting for the txs receipts from different cores
receipts = await send_txs(txs)
assert len(receipts) == tx_count
print('All of the transactions approved by different cores - Passed')
assert len(set([(rec._result['ledger']) for rec in receipts])) == 1
print('All of the transactions are in the same ledger - Passed')
cores_hashes = [(rec._result['hash']) for rec in receipts]
ledger_no = receipts[0]._result['ledger']
# waiting for the next ledger
while ledger_no + 1 > get_latest_ledger(clients[0])['sequence']:
time.sleep(0.5)
# getting ledger txs from horizon
ledger_txs = clients[0].horizon.ledger_transactions(
ledger_no)['_embedded']['records']
# comparing ledger hashes with the core hashes
assert set(cores_hashes) & set([t['hash'] for t in ledger_txs])
print('Multi cores test - Passed')
def onboard_with_phone(self, userid, phone_num):
resp = self.app.post('/user/register',
data=json.dumps({
'user_id': str(userid),
'os': 'android',
'device_model': 'samsung8',
'device_id': '234234',
'time_zone': '05:00',
'token': 'fake_token',
'app_ver': '1.0'
}),
headers={},
content_type='application/json')
self.assertEqual(resp.status_code, 200)
# phone authenticate
resp = self.app.post('/user/firebase/update-id-token',
data=json.dumps({
'token': 'fake-token',
'phone_number': phone_num
}),
headers={USER_ID_HEADER: str(userid)},
content_type='application/json')
self.assertEqual(resp.status_code, 200)
print('onboarding user --------------')
from kin import Keypair
kp = Keypair()
address = kp.address_from_seed(kp.generate_seed())
resp = self.app.post('/user/onboard',
data=json.dumps({'public_address': address}),
headers={USER_ID_HEADER: str(userid)},
content_type='application/json')
print(json.loads(resp.data))
self.assertEqual(resp.status_code, 200)
# try onboarding again with the same user - should fail
print('onboarding same user second time should fail --------------')
resp = self.app.post('/user/onboard',
data=json.dumps({'public_address': address}),
headers={USER_ID_HEADER: str(userid)},
content_type='application/json')
print(json.loads(resp.data))
self.assertEqual(resp.status_code, 400)
return address
def __init__(self, sdk: KinAccount, channel: str):
self.write_sdk = sdk
self.write_sdk.raw_seed = BaseKeypair.from_seed(
sdk.keypair.secret_seed).raw_seed()
self.root_address = self.write_sdk.keypair.public_address
self.channel = channel
self.channel_address = Keypair.address_from_seed(channel)
def initialize():
if len(sys.argv) < 4:
print('invalid number of params :', len(clients))
sys.exit(1)
global PASSPHRASE
global WHITELIST_MANAGER_KEYPAIR
global root_account
global tx_count
PASSPHRASE = sys.argv[1]
WHITELIST_MANAGER_KEYPAIR = Keypair(sys.argv[2])
tx_count = int(sys.argv[3])
for arg in sys.argv[4:]:
local_env = Environment('LOCAL', arg, PASSPHRASE,
'http://localhost:8001')
# Creates a client
clients.append(KinClient(local_env))
print('Client ', len(clients), ' created!')
# Create the root account object
root_account = clients[0].kin_account(
derive_root_account(PASSPHRASE).secret_seed)
print('Root account object created')
def generate():
# generates a file that can be 'sourced' and creates environment vars for
# payment-service
keys = Keypair()
public_address = keys.public_address
private_seed = keys.secret_seed
print('# creating %s' % public_address)
fund_kin(public_address)
return public_address, private_seed
def load_accounts(path) -> List[Keypair]:
"""Load seeds from file path and return Keypair list.
Expected file format is a newline-delimited seed list.
"""
kps = []
with open(path) as f:
for seed in f:
kps.append(Keypair(seed.strip()))
return kps
def balance_api():
"""endpoint used to get the current balance of the seed and channels"""
if not config.DEBUG:
limit_to_localhost()
base_seed, channel_seeds = ssm.get_stellar_credentials()
balance = {'base_seed': {}, 'channel_seeds': {}}
from kin import Keypair
kp = Keypair()
balance['base_seed']['kin'] = get_kin_balance(
kp.address_from_seed(base_seed))
index = 0
for channel in channel_seeds:
# seeds only need to carry XLMs
balance['channel_seeds'][index] = {'kin': 0}
balance['channel_seeds'][index]['kin'] = get_kin_balance(
kp.address_from_seed(channel))
index = index + 1
return jsonify(status='ok', balance=balance)
async def main():
"""Create accounts and print their seeds to stdout."""
args = parse_args()
# initialize channels
channel_builders = await init_channel_builders(args.channel_seeds_file, args.passphrase, args.horizon)
kps = generate_keypairs(args.accounts)
source_kp = Keypair(args.source_account)
await create_accounts(source_kp, kps, channel_builders, args.horizon, STARTING_BALANCE)
if args.json_output:
keypairs = []
for kp in kps:
keypairs.append({"address": kp.public_address, "seed": kp.secret_seed})
out = {"keypairs": keypairs}
print(json.dumps(out, indent=True))
else:
out = (kp.secret_seed for kp in kps)
print('\n'.join(list(out)))
def keypair_list(n):
return [Keypair() for _ in range(n)]
async def main():
# Create the environment
local_env = Environment('LOCAL', 'http://localhost:8000', PASSPHRASE,
'http://localhost:8001')
# Create a client
client = KinClient(local_env)
print('Client created')
initial_ledger_size = get_latest_ledger(client)['max_tx_set_size']
try:
# Set ledger tx size to 1
requests.get(
'http://localhost:11626/upgrades?mode=set&maxtxsize=1&upgradetime=2018-10-15T18:34:00Z'
)
# Create the root account object
root_account = client.kin_account(
derive_root_account(PASSPHRASE).secret_seed)
print('Root account object created')
minimum_fee = client.get_minimum_fee()
# Create an account with 0 base reserve
test_account = Keypair()
root_account.create_account(test_account.public_address, 0,
minimum_fee)
assert client.does_account_exists(test_account.public_address)
print('Test account created')
# Add the account to the whitelist
if not client.does_account_exists(
WHITELIST_MANAGER_KEYPAIR.public_address):
root_account.create_account(
WHITELIST_MANAGER_KEYPAIR.public_address, 10000, 100)
print('Created whitelisting account')
builder = Builder('LOCAL',
client.horizon,
fee=minimum_fee,
secret=WHITELIST_MANAGER_KEYPAIR.secret_seed)
builder.get_sequence()
builder.append_manage_data_op(test_account.public_address,
test_account._hint)
builder.sign()
builder.submit()
print('Added account to whitelist')
for _ in range(5):
txs = []
first_builder = Builder('LOCAL',
client.horizon,
fee=minimum_fee,
secret=test_account.secret_seed)
first_builder.append_manage_data_op('test', 'test'.encode())
first_builder.get_sequence()
first_builder.sign()
txs.append(first_builder)
second_builder = Builder(
'LOCAL',
client.horizon,
fee=minimum_fee,
secret=WHITELIST_MANAGER_KEYPAIR.secret_seed)
second_builder.append_payment_op(test_account.public_address, '1')
second_builder.get_sequence()
second_builder.sign()
txs.append(second_builder)
initial_ledger = get_latest_ledger(client)['sequence']
print(f'Initial ledger: {initial_ledger}')
while initial_ledger == get_latest_ledger(client)['sequence']:
time.sleep(0.5)
first_populated_ledger = initial_ledger + 2
print(f'Sending on ledger: {first_populated_ledger}')
print(f'Sending txs at {time.strftime("%d/%m/%Y %H:%M:%S")}')
await send_txs(txs)
print(f'Done sending txs at {time.strftime("%d/%m/%Y %H:%M:%S")}')
first_ledger_txs = client.horizon.ledger_transactions(
first_populated_ledger)['_embedded']['records']
# First ledger should have tx from whitelist_manager
assert WHITELIST_MANAGER_KEYPAIR.public_address == first_ledger_txs[
0]['source_account']
print('Verified tx from whitelist manager got priority')
except:
raise
finally:
# Set tx size to what it was before
requests.get(
f'http://localhost:11626/upgrades?mode=set&maxtxsize={initial_ledger_size}&upgradetime=2018-10-15T18:34:00Z'
)
"""Test the prioritization of transactions in the ledger for the whitelist_holder"""
import sys
import asyncio
from concurrent.futures import ThreadPoolExecutor
from kin import KinClient, Environment, Keypair
from kin.blockchain.builder import Builder
from helpers import derive_root_account
import requests
import time
PASSPHRASE = sys.argv[1]
WHITELIST_MANAGER_KEYPAIR = Keypair(sys.argv[2])
async def send_txs(txs):
with ThreadPoolExecutor(max_workers=2) as executor:
loop = asyncio.get_running_loop()
promises = [loop.run_in_executor(executor, tx.submit) for tx in txs]
for _ in await asyncio.gather(*promises):
pass
def get_latest_ledger(client):
params = {'order': 'desc', 'limit': 1}
return client.horizon.ledgers(params=params)['_embedded']['records'][0]
def main():
# Create the environment
local_env = Environment('LOCAL', 'http://localhost:8000', PASSPHRASE,
'http://localhost:8001')
# Create a client
client = KinClient(local_env)
print('Client created')
# Create the root account object
root_account = client.kin_account(
derive_root_account(PASSPHRASE).secret_seed)
print('Root account object created')
minimum_fee = client.get_minimum_fee()
# Create an account with 0 base reserve
test_account = Keypair()
root_account.create_account(test_account.public_address, 0, minimum_fee)
assert client.does_account_exists(test_account.public_address)
print('Test account created')
# Send a tx that does not require spending kin
builder = Builder('LOCAL',
client.horizon,
fee=0,
secret=test_account.secret_seed)
builder.get_sequence()
builder.append_manage_data_op('test', 'test'.encode())
builder.sign()
try:
builder.submit()
except KinErrors.HorizonError as e:
# Tx should fail since the fee is under minimum fee
assert e.extras.result_codes.transaction == KinErrors.TransactionResultCode.INSUFFICIENT_FEE
print('Sending under minimum fee - Passed')
builder = Builder('LOCAL',
client.horizon,
fee=minimum_fee,
secret=test_account.secret_seed)
builder.get_sequence()
builder.append_manage_data_op('test', 'test'.encode())
builder.sign()
try:
builder.submit()
except KinErrors.HorizonError as e:
# Tx should fail since the account cant pay the fee
assert e.extras.result_codes.transaction == KinErrors.TransactionResultCode.INSUFFICIENT_BALANCE
print('Sending with no fee to pay - Passed')
# Add the account to the whitelist
if not client.does_account_exists(
WHITELIST_MANAGER_KEYPAIR.public_address):
root_account.create_account(WHITELIST_MANAGER_KEYPAIR.public_address,
10000, 100)
print('Created whitelisting account')
builder = Builder('LOCAL',
client.horizon,
fee=minimum_fee,
secret=WHITELIST_MANAGER_KEYPAIR.secret_seed)
builder.get_sequence()
builder.append_manage_data_op(test_account.public_address,
test_account._hint)
builder.sign()
builder.submit()
print('Added account to whitelist')
# test_account is now a whitelister, so the fee should be ignored
builder = Builder('LOCAL',
client.horizon,
fee=0,
secret=test_account.secret_seed)
builder.get_sequence()
builder.append_manage_data_op('test2', 'test2'.encode())
builder.sign()
builder.submit()
print('Sending prioritized tx under minimum fee - Passed')
builder = Builder('LOCAL',
client.horizon,
fee=999999,
secret=test_account.secret_seed)
builder.get_sequence()
builder.append_manage_data_op('test3', 'test3'.encode())
builder.sign()
builder.submit()
print('Sending prioritized tx with fee > balance - Passed')
# Try the same if the account is not a whitelister, but the tx is whitelisted
test_account2 = Keypair()
root_account.create_account(test_account2.public_address, 0, minimum_fee)
builder = Builder('LOCAL',
client.horizon,
fee=999999,
secret=test_account2.secret_seed)
builder.get_sequence()
builder.append_manage_data_op('test', 'test'.encode())
builder.sign()
# sign with the whitelister as well to prioritize the tx
builder.sign(secret=test_account.secret_seed)
builder.submit()
print('Sending prioritized tx2 with fee > balance - Passed')
async def main():
# Create the environment
local_env = Environment('LOCAL', 'http://localhost:8000', PASSPHRASE,
'http://localhost:8001')
# Create a client
client = KinClient(local_env)
print('Client created')
initial_ledger_size = get_latest_ledger(client)['max_tx_set_size']
try:
# Set ledger tx size to 3
requests.get(
'http://localhost:11626/upgrades?mode=set&maxtxsize=3&upgradetime=2018-10-15T18:34:00Z'
)
# Create the root account object
root_account = client.kin_account(
derive_root_account(PASSPHRASE).secret_seed)
print('Root account object created')
minimum_fee = client.get_minimum_fee()
# Create an account with 0 base reserve
test_account = Keypair()
root_account.create_account(test_account.public_address, 0,
minimum_fee)
assert client.does_account_exists(test_account.public_address)
print('Test account created')
accounts = [Keypair() for _ in range(5)]
builder = Builder('LOCAL',
client.horizon,
fee=minimum_fee,
secret=root_account.keypair.secret_seed)
for keypair in accounts:
builder.append_create_account_op(keypair.public_address, '100')
builder.get_sequence()
builder.sign()
builder.submit()
print('Created 5 accounts')
txs = []
for index, account in enumerate(accounts, start=1):
builder = Builder('LOCAL',
client.horizon,
fee=minimum_fee * index,
secret=account.secret_seed)
builder.append_manage_data_op('test', 'test'.encode())
builder.get_sequence()
builder.sign()
txs.append(builder)
initial_ledger = get_latest_ledger(client)['sequence']
print(f'Initial ledger: {initial_ledger}')
while initial_ledger == get_latest_ledger(client)['sequence']:
time.sleep(0.5)
first_populated_ledger = initial_ledger + 2
second_populated_ledger = initial_ledger + 3
print(f'Sending on ledger: {first_populated_ledger}')
print(f'Sending txs at {time.strftime("%d/%m/%Y %H:%M:%S")}')
await send_txs(txs)
print(f'Done sending txs at {time.strftime("%d/%m/%Y %H:%M:%S")}')
first_ledger_txs = client.horizon.ledger_transactions(
first_populated_ledger)['_embedded']['records']
second_ledger_txs = client.horizon.ledger_transactions(
second_populated_ledger)['_embedded']['records']
# First ledger should have txs where fee>=300
first_txs = sum(1 for tx in first_ledger_txs if tx['fee_paid'] >= 300)
assert first_txs == 3
print('Verified first ledger')
# Second ledger should have txs where fee<=200
second_txs = sum(1 for tx in second_ledger_txs
if tx['fee_paid'] <= 200)
assert second_txs == 2
print('Verified seconds ledger')
except:
raise
finally:
# Set tx size to what it was before
requests.get(
f'http://localhost:11626/upgrades?mode=set&maxtxsize={initial_ledger_size}&upgradetime=2018-10-15T18:34:00Z'
)
async def main():
# Create the environment
local_env = Environment('LOCAL', 'http://localhost:8000', PASSPHRASE,
'http://localhost:8001')
# Create a client
client = KinClient(local_env)
print('Client created')
initial_ledger_size = get_latest_ledger(client)['max_tx_set_size']
try:
# Set ledger tx size to 1
requests.get(
'http://localhost:11626/upgrades?mode=set&maxtxsize=1&upgradetime=2018-10-15T18:34:00Z'
)
# Create the root account object
root_account = client.kin_account(
derive_root_account(PASSPHRASE).secret_seed)
print('Root account object created')
minimum_fee = client.get_minimum_fee()
# Create an account with 0 base reserve
test_account = Keypair()
root_account.create_account(test_account.public_address, 0,
minimum_fee)
assert client.does_account_exists(test_account.public_address)
print('Test account created')
# Add the account to the whitelist
if not client.does_account_exists(
WHITELIST_MANAGER_KEYPAIR.public_address):
root_account.create_account(
WHITELIST_MANAGER_KEYPAIR.public_address, 10000, 100)
print('Created whitelisting account')
initial_ledger = get_latest_ledger(client)['sequence']
print(f'Adding account to whitelist on ledger: {initial_ledger + 2}')
builder = Builder('LOCAL',
client.horizon,
fee=minimum_fee,
secret=WHITELIST_MANAGER_KEYPAIR.secret_seed)
builder.get_sequence()
builder.append_manage_data_op(test_account.public_address,
test_account._hint)
builder.sign()
builder.submit()
print('Added account to whitelist')
while initial_ledger + 1 == get_latest_ledger(client)['sequence']:
time.sleep(0.5)
print(
f'Submitting tx from test account on ledger: {initial_ledger + 3}')
builder = Builder('LOCAL',
client.horizon,
fee=0,
secret=test_account.secret_seed)
builder.append_manage_data_op('test', 'test'.encode())
builder.get_sequence()
builder.sign()
builder.submit()
while initial_ledger + 2 == get_latest_ledger(client)['sequence']:
time.sleep(0.5)
populated_ledger_txs = client.horizon.ledger_transactions(
initial_ledger + 3)['_embedded']['records']
assert len(populated_ledger_txs) == 1
assert populated_ledger_txs[0]['fee_paid'] == 0
except:
raise
finally:
# Set tx size to what it was before
requests.get(
f'http://localhost:11626/upgrades?mode=set&maxtxsize={initial_ledger_size}&upgradetime=2018-10-15T18:34:00Z'
)
def derive_root_account(passphrase):
"""Return the keypair of the root account, based on the network passphrase."""
network_hash = sha256(passphrase.encode()).digest()
seed = BaseKeypair.from_raw_seed(network_hash).seed().decode()
return Keypair(seed)
def keypair_list(n) -> List[Keypair]:
"""Return Keypair list according to given amount."""
return [Keypair() for _ in range(n)]
async def main():
# Create the environment
local_env = Environment('LOCAL', 'http://localhost:8000', PASSPHRASE,
'http://localhost:8001')
# Create a client
client = KinClient(local_env)
print('Client created')
initial_ledger_size = get_latest_ledger(client)['max_tx_set_size']
try:
# Set ledger tx size to 3
requests.get(
'http://localhost:11626/upgrades?mode=set&maxtxsize=3&upgradetime=2018-10-15T18:34:00Z'
)
# Create the root account object
root_account = client.kin_account(
derive_root_account(PASSPHRASE).secret_seed)
print('Root account object created')
minimum_fee = client.get_minimum_fee()
# Create an account with 0 base reserve
test_account = Keypair()
root_account.create_account(test_account.public_address, 0,
minimum_fee)
assert client.does_account_exists(test_account.public_address)
print('Test account created')
# Add the account to the whitelist
if not client.does_account_exists(
WHITELIST_MANAGER_KEYPAIR.public_address):
root_account.create_account(
WHITELIST_MANAGER_KEYPAIR.public_address, 10000, 100)
print('Created whitelisting account')
builder = Builder('LOCAL',
client.horizon,
fee=minimum_fee,
secret=WHITELIST_MANAGER_KEYPAIR.secret_seed)
builder.get_sequence()
builder.append_manage_data_op(test_account.public_address,
test_account._hint)
builder.sign()
builder.submit()
print('Added account to whitelist')
accounts = [Keypair() for _ in range(5)]
builder = Builder('LOCAL',
client.horizon,
fee=minimum_fee,
secret=root_account.keypair.secret_seed)
for keypair in accounts:
builder.append_create_account_op(keypair.public_address, '100')
builder.get_sequence()
builder.sign()
builder.submit()
print('Created 5 accounts')
txs = []
for account in accounts:
builder = Builder('LOCAL',
client.horizon,
fee=minimum_fee,
secret=account.secret_seed)
builder.append_manage_data_op('test', 'test'.encode())
builder.get_sequence()
builder.sign()
txs.append(builder)
for tx in txs[2:]:
tx.sign(test_account.secret_seed)
print('Whitelisted 3 transactions')
initial_ledger = get_latest_ledger(client)['sequence']
print(f'Initial ledger: {initial_ledger}')
while initial_ledger == get_latest_ledger(client)['sequence']:
time.sleep(0.5)
first_populated_ledger = initial_ledger + 2
second_populated_ledger = initial_ledger + 3
print(f'Sending on ledger: {first_populated_ledger}')
print(f'Sending txs at {time.strftime("%d/%m/%Y %H:%M:%S")}')
await send_txs(txs)
print(f'Done sending txs at {time.strftime("%d/%m/%Y %H:%M:%S")}')
first_ledger_txs = client.horizon.ledger_transactions(
first_populated_ledger)['_embedded']['records']
second_ledger_txs = client.horizon.ledger_transactions(
second_populated_ledger)['_embedded']['records']
# First ledger should have 2 whitelisted txs, and 1 non-whitelisted
whitelisted_amount = sum(1 for tx in first_ledger_txs
if len(tx['signatures']) == 2)
assert whitelisted_amount == 2
regular_amount = sum(1 for tx in first_ledger_txs
if len(tx['signatures']) == 1)
assert regular_amount == 1
# # Second ledger should have 1 whitelisted tx, and 1 non-whitelisted
whitelisted_amount = sum(1 for tx in second_ledger_txs
if len(tx['signatures']) == 2)
assert whitelisted_amount == 1
regular_amount = sum(1 for tx in second_ledger_txs
if len(tx['signatures']) == 1)
assert regular_amount == 1
except:
raise
finally:
# Set tx size to what it was before
requests.get(
f'http://localhost:11626/upgrades?mode=set&maxtxsize={initial_ledger_size}&upgradetime=2018-10-15T18:34:00Z'
)
