def create_multiple_keypair():
print("Create multiple keypair")
sm = StellarMnemonic()
secret_phrase = sm.generate()
kp0 = Keypair.deterministic(secret_phrase, index=0)
kp1 = Keypair.deterministic(secret_phrase, index=1)
kp2 = Keypair.deterministic(secret_phrase, index=2)
for keypair in (kp0, kp1, kp2):
print("Public key / Account address:\n", keypair.address().decode())
print("Seed / Your secret to keep it on local:\n",
keypair.seed().decode())
def create_keypair_determinist_english():
print("Create keypair determinist english")
mnemonic = ('illness spike retreat truth genius clock brain pass '
'fit cave bargain toe')
keypair = Keypair.deterministic(mnemonic)
print("Public key / Account address:\n", keypair.address().decode())
print("Seed / Your secret to keep it on local:\n", keypair.seed().decode())
async 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=test_data.horizon, network_name=setup.network, fee=100) \
.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_change_trust_op('BEER', test_data.cold_account, '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
await cold.update_sequence()
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 = await cold.submit()
assert response.get('hash') == cold.hash_hex()
async def test_builder_xdr(setup, helpers, test_data, aio_session):
hot = Keypair.random()
hot_account = hot.address().decode()
hot_secret = hot.seed()
await helpers.fund_account(setup, hot_account, aio_session)
cold = Builder(secret=test_data.cold_secret, horizon=test_data.horizon, network_name=setup.network, fee=100) \
.append_change_trust_op('BEER', test_data.cold_account, '1000', hot_account) \
.append_allow_trust_op(hot_account, 'BEER', True, test_data.cold_account) \
.append_payment_op(hot_account, '100', 'BEER', test_data.cold_account, test_data.cold_account) \
.append_payment_op(test_data.cold_account, '2.222', 'BEER', test_data.cold_account, hot_account)
await cold.update_sequence()
cold.sign()
xdr = cold.gen_xdr()
hot = Builder(
secret=hot_secret,
horizon=test_data.horizon,
network_name=setup.network, fee=100)
hot.import_from_xdr(xdr)
hot.sign()
assert len(hot.te.signatures) == 2
assert len(hot.ops) == 4
response = await hot.submit()
assert response.get('hash') == hot.hash_hex()
def test_builder_xdr(setup, helpers, test_data):
hot = Keypair.random()
hot_account = hot.address().decode()
hot_secret = hot.seed()
helpers.fund_account(setup, hot_account)
cold = Builder(secret=test_data.cold_secret, horizon_uri=setup.horizon_endpoint_uri, network=setup.network) \
.append_change_trust_op('BEER', test_data.cold_account, '1000', hot_account) \
.append_allow_trust_op(hot_account, 'BEER', True, test_data.cold_account) \
.append_payment_op(hot_account, '100', 'BEER', test_data.cold_account, test_data.cold_account) \
.append_payment_op(test_data.cold_account, '2.222', 'BEER', test_data.cold_account, hot_account)
cold.sign()
xdr = cold.gen_xdr()
hot = Builder(secret=hot_secret,
horizon_uri=setup.horizon_endpoint_uri,
network=setup.network)
hot.import_from_xdr(xdr)
hot.sign()
assert len(hot.te.signatures) == 2
assert len(hot.ops) == 4
response = hot.submit()
assert response.get('hash') == hot.hash_hex()
def do(self, network, op):
tx = Transaction(self.source, sequence=1)
tx.add_operation(op)
envelope = Te(tx, network_id=network)
signer = Keypair.from_seed(self.seed)
envelope.sign(signer)
envelope_b64 = envelope.xdr()
return envelope_b64
def do(self, network, opts):
tx = Transaction(self.source, **opts)
tx.add_operation(Inflation())
envelope = Te(tx, network_id=network)
signer = Keypair.from_seed(self.seed)
envelope.sign(signer)
envelope_b64 = envelope.xdr()
print(envelope_b64)
return envelope_b64
def test_data(setup, helpers):
class Struct:
def __init__(self, **entries):
self.__dict__.update(entries)
cold = Keypair.random()
cold_secret = cold.seed()
cold_account = cold.address().decode()
helpers.fund_account(setup, cold.address().decode())
return Struct(cold_secret=cold_secret, cold_account=cold_account)
def make_envelope(self, network, *args, **kwargs):
opts = {'sequence': 2, 'fee': 100 * len(args)}
for opt, value in kwargs.items():
opts[opt] = value
tx = Transaction(self.address, **opts)
for count, op in enumerate(args):
tx.add_operation(op)
envelope = Te(tx, network_id=network)
signer = Keypair.from_seed(self.seed)
envelope.sign(signer)
envelope_b64 = envelope.xdr()
print(envelope_b64)
return envelope_b64
def test_submit(setup, helpers):
kp = Keypair.random()
address = kp.address().decode()
seed = kp.seed()
helpers.fund_account(setup, address)
horizon = Horizon(setup.horizon_endpoint_uri)
envelope_xdr = make_envelope(
setup.network, horizon, address, seed,
Payment(destination=address, asset=Asset.native(), amount="0.0001618"))
response = horizon.submit(envelope_xdr)
assert 'hash' in response
async def test_data(setup, helpers, aio_session):
class Struct:
def __init__(self, **entries):
self.__dict__.update(entries)
cold = Keypair.random()
cold_secret = cold.seed()
cold_account = cold.address().decode()
horizon = Horizon(setup.horizon_endpoint_uri)
await helpers.fund_account(setup, cold.address().decode(), aio_session)
yield Struct(cold_secret=cold_secret, cold_account=cold_account, horizon=horizon)
await horizon.close()
async def test_sse(setup, helpers, aio_session):
kp = Keypair.random()
address = kp.address().decode()
events = []
async def sse_handler(events):
async with Horizon(setup.horizon_endpoint_uri) as horizon:
async for event in await horizon.account_transactions('GA3FLH3EVYHZUHTPQZU63JPX7ECJQL2XZFCMALPCLFYMSYC4JKVLAJWM',
sse=True):
events.append(event)
break
handler = asyncio.ensure_future(sse_handler(events))
await helpers.fund_account(setup, address, aio_session)
await asyncio.sleep(5)
assert len(events) == 1
async def make_envelope(network, horizon, address, seed, *args, **kwargs):
opts = {
'sequence': int((await horizon.account(address))['sequence']) + 1,
'fee': 100 * len(args)
}
for opt, value in kwargs.items():
opts[opt] = value
tx = Transaction(address, **opts)
for count, op in enumerate(args):
tx.add_operation(op)
envelope = Te(tx, network_id=network)
signer = Keypair.from_seed(seed)
envelope.sign(signer)
envelope_xdr = envelope.xdr()
return envelope_xdr
async def test_submit(setup, helpers, aio_session):
kp = Keypair.random()
address = kp.address().decode()
seed = kp.seed()
await helpers.fund_account(setup, address, aio_session)
async with Horizon(setup.horizon_endpoint_uri) as horizon:
envelope_xdr = await make_envelope(setup.network, horizon, address, seed,
Payment(
destination=address,
asset=Asset.native(),
amount="0.1618"))
response = await horizon.submit(envelope_xdr.decode())
assert 'hash' in response
def setup():
class Struct:
"""Handy variable holder"""
def __init__(self, **entries):
self.__dict__.update(entries)
issuer_keypair = Keypair.random()
test_asset = Asset('TEST', issuer_keypair.address().decode())
# local testnet (kinecosystem docker)
from kin_base.network import NETWORKS
# we will leave this passphrase instead of changing every envelop in the test suite
NETWORKS['CUSTOM'] = 'Integration Test Network ; zulucrypto'
return Struct(type='local',
network='CUSTOM',
issuer_keypair=issuer_keypair,
test_asset=test_asset,
horizon_endpoint_uri='http://localhost:8008',
friendbot_url='http://localhost:8001')
async def test_sse_event_timeout(setup, helpers, aio_session):
kp = Keypair.random()
address = kp.address().decode()
events = []
async def sse_handler(events):
async with Horizon(setup.horizon_endpoint_uri) as horizon:
async for event in await horizon.account_transactions(
'GA3FLH3EVYHZUHTPQZU63JPX7ECJQL2XZFCMALPCLFYMSYC4JKVLAJWM',
sse=True, sse_timeout=15):
events.append(event)
handler = asyncio.ensure_future(sse_handler(events))
await helpers.fund_account(setup, address, aio_session)
await asyncio.sleep(5)
assert len(events) == 1
await asyncio.sleep(20)
# Make sure that the sse generator raised timeout error
with pytest.raises(asyncio.TimeoutError):
raise handler.exception()
def test_sep0005():
# https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0005.md
mnemonic = 'illness spike retreat truth genius clock brain pass fit cave bargain toe'
seed = Keypair.deterministic(mnemonic).seed()
assert seed == b'SDBKOVHBX2UFDTSEESHEEHR76OMJ5GMOWISBDC7BQOSF7FA2E23JRZLS'
address = Keypair.deterministic(mnemonic, index=6).address().decode()
assert address == 'GB37PRJSTEGB6CWTRU7DCSJWD4A22IYTGSHFEN73IJ3AM3CETFAZPRJO'
mnemonic = 'cable spray genius state float twenty onion head street palace net private method loan turn phrase state blanket interest dry amazing dress blast tube'
seed = Keypair.deterministic(mnemonic, passphrase='p4ssphr4se').seed()
assert seed == b'SBRC5DWN6RPRY5IJABDVEUESPJBMQEIA5HNKEMERYUOKJ5VUCIXTSF6J'
address = Keypair.deterministic(
mnemonic, passphrase='p4ssphr4se', index=9).address().decode()
assert address == 'GDPJJCIKGNOM73NXVYX5R76PNATGDP7IW4TWSOY5HOARGKZY2ZSBTVEA'
mnemonic = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
seed = Keypair.deterministic(mnemonic).seed()
assert seed == b'SDRX36LJA7O4S5GZ3PF7CCLO5S5XEXO6SAV7SFCHRCQHAASE2HOJY6TX'
address = Keypair.deterministic(mnemonic, index=8).address().decode()
assert address == 'GCAZEAOQBCGBJKH7OKJO35NIHAVGNP3A5NN2MUNB37Z4MI35AIC7K5PC'
def test_sep0005():
# https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0005.md
mnemonic = 'illness spike retreat truth genius clock brain pass fit cave bargain toe'
seed = Keypair.deterministic(mnemonic).seed()
assert seed == b'SBGWSG6BTNCKCOB3DIFBGCVMUPQFYPA2G4O34RMTB343OYPXU5DJDVMN'
address = Keypair.deterministic(mnemonic, index=6).address().decode()
assert address == 'GBY27SJVFEWR3DUACNBSMJB6T4ZPR4C7ZXSTHT6GMZUDL23LAM5S2PQX'
mnemonic = 'cable spray genius state float twenty onion head street palace net private method loan turn phrase state blanket interest dry amazing dress blast tube'
seed = Keypair.deterministic(mnemonic, passphrase='p4ssphr4se').seed()
assert seed == b'SAFWTGXVS7ELMNCXELFWCFZOPMHUZ5LXNBGUVRCY3FHLFPXK4QPXYP2X'
address = Keypair.deterministic(
mnemonic, passphrase='p4ssphr4se', index=9).address().decode()
assert address == 'GBOSMFQYKWFDHJWCMCZSMGUMWCZOM4KFMXXS64INDHVCJ2A2JAABCYRR'
mnemonic = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
seed = Keypair.deterministic(mnemonic).seed()
assert seed == b'SBUV3MRWKNS6AYKZ6E6MOUVF2OYMON3MIUASWL3JLY5E3ISDJFELYBRZ'
address = Keypair.deterministic(mnemonic, index=8).address().decode()
assert address == 'GABTYCZJMCP55SS6I46SR76IHETZDLG4L37MLZRZKQDGBLS5RMP65TSX'
def test_sign_missing_signing_key_raise(self):
keypair = Keypair.from_address(self.keypair0.address())
raises(MissingSigningKeyError, keypair.sign, "")
# See: https://www.stellar.org/developers/guides/issuing-assets.html
from kin_base.keypair import Keypair
from kin_base.asset import Asset
from kin_base.builder import Builder
# Keys for accounts to issue and receive the new asset
issuing_secret = 'SCBHQEGSNBTT4S7Y73YAF3M3JSVSTSNBGAVU5M4XVFGUF7664EUXQHFU'
issuing_public = Keypair.from_seed(issuing_secret).address().decode()
receiving_secret = 'SB6MJ6M3BPJZUGFP2QCODUIKWQWF6AIN4Z6L3J6PWL3QGDW4L6YR3QIU'
receiving_public = Keypair.from_seed(receiving_secret).address().decode()
# Create an object to represent the new asset
my_asset = Asset('Hello', issuing_public)
# First, the receiving account must trust the asset
builder = Builder(receiving_secret, network='TESTNET').append_trust_op(
destination=my_asset.issuer, code=my_asset.code)
builder.sign()
resp = builder.submit()
print(resp)
# Second, the issuing account actually sends a payment using the asset
builder = Builder(issuing_secret, network='TESTNET').append_payment_op(
destination=receiving_public,
amount='1000',
asset_code=my_asset.code,
asset_issuer=my_asset.issuer)
builder.sign()
resp = builder.submit()
from kin_base.keypair import Keypair
from kin_base.asset import Asset
from kin_base.operation import Payment, SetOptions
from kin_base.transaction import Transaction
from kin_base.transaction_envelope import TransactionEnvelope as Te
from kin_base.memo import TextMemo
from kin_base.horizon import horizon_testnet, horizon_livenet
alice_seed = 'SBUORYV26AZ3ULEEC5FQ4NKPVRO7MBAWTW26YKCDPPKFGMK7WAYNX4UN'
bob_address = 'GBZF7GQJXXHD3OL3B5IOUICFDYIATZZ3F3XQ7SOQ5PXLVQMDSOI5ACEE'
Alice = Keypair.from_seed(alice_seed)
horizon = horizon_testnet() # for TESTNET
# horizon = horizon_livenet() # for LIVENET
# create op
payment_op = Payment(
# source=Alice.address().decode(),
destination=bob_address,
asset=Asset('XLM'),
amount='10.5')
set_home_domain_op = SetOptions(home_domain='fed.network')
# create a memo
msg = TextMemo('Buy yourself a beer!')
# get sequence of Alice
# Python 3
sequence = horizon.account(Alice.address().decode('utf-8')).get('sequence')
# Python 2
def generate_random_keypair():
print("Generate random keypair")
keypair = Keypair.random()
print("Public key / Account address:\n", keypair.address().decode())
print("Seed / Your secret to keep it on local:\n", keypair.seed().decode())
def get_proxy_address(address: str, salt: str) -> str:
"""Generate a deterministic keypair using an address and a salt"""
raw_seed = sha256((address + salt).encode()).digest()
keypair = BaseKeypair.from_raw_seed(raw_seed)
return keypair.address().decode()
def test_from_seed(self):
keypair = Keypair.from_seed(self.keypair0.seed())
assert self.keypair0.address() == keypair.address()
def setUpClass(cls):
cls.mnemonic = ('illness spike retreat truth genius clock brain pass '
'fit cave bargain toe')
cls.keypair0 = Keypair.deterministic(cls.mnemonic)
# https://www.stellar.org/developers/guides/concepts/multi-sig.html
import time
from kin_base.keypair import Keypair
from kin_base.builder import Builder
alice_seed = 'SDW74JLSQCDDJELC3S6EP4V4SGIM6MSFFVT73PMKIH4BAAJX6OZY4PCC' # GCDCDLVJNSLJWWHH2Q36IGBYZP6O6MFZOMXSW2DNBUCWKZDCRTIT73DP
bob_seed = 'SCEQG2XD2HPDKBLIFHFT2CFC5FLOHNT2HNHTTPAXFXS6YDW4UCP57V2H' # GCNT7JJDVQ5ZAZ4OLHXUJPONYATFE5YOTRTKMPI2EQCGU2SK4QGCETJ5
dav_seed = 'SDE2CEJ3HMXPAO5TBKLRTV3WYI2DHIRQ6ZESKRMHEDLCOHLCZPU3TFPH' # GCPITREYLKN3WHVPYBM7SNW2V7ZPYYPZHARPBWEC3XTZASUI3MGFYLWF
eve_address = 'GDQ6L5ULMQPY5S363O7HXALMVIQ4OLS4PZJSPRF6R4FC5QMX2BJFJYX7'
alice_kp = Keypair.from_seed(alice_seed)
bob_kp = Keypair.from_seed(bob_seed)
dav_kp = Keypair.from_seed(dav_seed)
def setup_threshold():
builder = Builder(dav_seed).append_set_options_op(
source=dav_kp.address().decode(),
high_threshold=3,
med_threshold=3,
low_threshold=3,
master_weight=1,
signer_type='ed25519PublicKey',
signer_weight=1,
signer_address=alice_kp.address().decode()).append_set_options_op(
source=dav_kp.address().decode(),
signer_type='ed25519PublicKey',
signer_weight=1,
signer_address=bob_kp.address().decode(
)) # append more signers here
