def test_to_xdr(self):
# GDF5O4OWEMVBY5FLDHWA5RZTYSV2U276XGKZZ6VSHDDR3THSQ6OQS7UM
source = Keypair.from_secret(
"SCCS5ZBI7WVIJ4SW36WGOQQIWJYCL3VOAULSXX3FB57USIO25EDOYQHH")
destination = "GDJJRRMBK4IWLEPJGIE6SXD2LP7REGZODU7WDC3I2D6MR37F4XSHBKX2"
amount = "1000.0"
sequence = 1
memo = IdMemo(100)
fee = 200
asset = Asset.native()
time_bounds = TimeBounds(12345, 56789)
ops = [
Payment(destination, asset, amount),
ManageData("hello", "world")
]
tx = Transaction(source, sequence, fee, ops, memo, time_bounds)
te = TransactionEnvelope(tx, Network.PUBLIC_NETWORK_PASSPHRASE)
assert binascii.hexlify(te.hash()).decode() == te.hash_hex()
te.sign(source)
hashx = bytes.fromhex(
"94e8223a518ac16a8cb110ab1952ef14da2c10b264645c38c8b3d82bd2b20000")
te.sign_hashx(hashx)
te_xdr = "AAAAAMvXcdYjKhx0qxnsDsczxKuqa/65lZz6sjjHHczyh50JAAAAyAAAAAAAAAABAAAAAQAAAAAAADA5AAAAAAAA3dUAAAACAAAAAAAAAGQAAAACAAAAAAAAAAEAAAAA0pjFgVcRZZHpMgnpXHpb/xIbLh0/YYto0PzI7+Xl5HAAAAAAAAAAAlQL5AAAAAAAAAAACgAAAAVoZWxsbwAAAAAAAAEAAAAFd29ybGQAAAAAAAAAAAAAAvKHnQkAAABAM4dg0J1LEFBmbDESJ5d+60WCuZC8lnA80g45qyEgz2oRBSNw1mOfZETnL/BgrebkG/K03oI2Wqcs9lvDKrDGDE0sOBsAAAAglOgiOlGKwWqMsRCrGVLvFNosELJkZFw4yLPYK9KyAAA="
assert te.to_xdr() == te_xdr
restore_te = TransactionEnvelope.from_xdr(
te_xdr, Network.PUBLIC_NETWORK_PASSPHRASE)
assert restore_te.to_xdr() == te_xdr
def test_verify_challenge_transaction_signed_by_client_raise_not_signed(
self):
server_kp = Keypair.random()
client_kp = Keypair.random()
timeout = 600
network_passphrase = Network.PUBLIC_NETWORK_PASSPHRASE
anchor_name = "SDF"
challenge = build_challenge_transaction(
server_secret=server_kp.secret,
client_account_id=client_kp.public_key,
anchor_name=anchor_name,
network_passphrase=network_passphrase,
timeout=timeout,
)
transaction = TransactionEnvelope.from_xdr(challenge,
network_passphrase)
challenge_tx = transaction.to_xdr()
with pytest.raises(
InvalidSep10ChallengeError,
match="Transaction not signed by client: {}.".format(
client_kp.public_key),
):
verify_challenge_transaction_signed_by_client_master_key(
challenge_tx, server_kp.public_key, network_passphrase)
def test_verify_challenge_transaction_signers_raise_no_signers(self):
server_kp = Keypair.random()
client_kp_a = Keypair.random()
client_kp_b = Keypair.random()
client_kp_c = Keypair.random()
timeout = 600
network_passphrase = Network.PUBLIC_NETWORK_PASSPHRASE
anchor_name = "SDF"
challenge = build_challenge_transaction(
server_secret=server_kp.secret,
client_account_id=client_kp_a.public_key,
anchor_name=anchor_name,
network_passphrase=network_passphrase,
timeout=timeout,
)
transaction = TransactionEnvelope.from_xdr(challenge,
network_passphrase)
transaction.sign(client_kp_a)
transaction.sign(client_kp_b)
transaction.sign(client_kp_c)
challenge_tx = transaction.to_xdr()
signers = []
with pytest.raises(InvalidSep10ChallengeError,
match="No signers provided."):
verify_challenge_transaction_signers(challenge_tx,
server_kp.public_key,
network_passphrase, signers)
def test_verify_transaction_signatures(self):
server_kp = Keypair.random()
client_kp_a = Keypair.random()
client_kp_b = Keypair.random()
client_kp_c = Keypair.random()
timeout = 600
network_passphrase = Network.PUBLIC_NETWORK_PASSPHRASE
anchor_name = "SDF"
challenge = build_challenge_transaction(
server_secret=server_kp.secret,
client_account_id=client_kp_a.public_key,
anchor_name=anchor_name,
network_passphrase=network_passphrase,
timeout=timeout,
)
transaction = TransactionEnvelope.from_xdr(challenge,
network_passphrase)
transaction.sign(client_kp_a)
transaction.sign(client_kp_b)
transaction.sign(client_kp_c)
signers = [
Ed25519PublicKeySigner(client_kp_a.public_key, 1),
Ed25519PublicKeySigner(client_kp_b.public_key, 2),
Ed25519PublicKeySigner(client_kp_c.public_key, 3),
Ed25519PublicKeySigner(Keypair.random().public_key, 4),
]
signers_found = _verify_transaction_signatures(transaction, signers)
assert signers_found == [
Ed25519PublicKeySigner(client_kp_a.public_key, 1),
Ed25519PublicKeySigner(client_kp_b.public_key, 2),
Ed25519PublicKeySigner(client_kp_c.public_key, 3),
]
def test_verify_challenge_tx_transaction_is_not_signed_by_the_server(self):
server_kp = Keypair.random()
client_kp = Keypair.random()
network_passphrase = Network.PUBLIC_NETWORK_PASSPHRASE
anchor_name = "SDF"
timeout = 900
now = int(time.time())
server_keypair = Keypair.from_secret(server_kp.secret)
server_account = Account(account_id=server_keypair.public_key,
sequence=-1)
transaction_builder = TransactionBuilder(server_account,
network_passphrase, 100)
transaction_builder.add_time_bounds(min_time=now,
max_time=now + timeout)
nonce = os.urandom(48)
nonce_encoded = base64.b64encode(nonce)
transaction_builder.append_manage_data_op(
data_name="{} auth".format(anchor_name),
data_value=nonce_encoded,
source=client_kp.public_key,
)
challenge = transaction_builder.build().to_xdr()
transaction = TransactionEnvelope.from_xdr(challenge,
network_passphrase)
transaction.sign(client_kp)
challenge_tx = transaction.to_xdr()
with pytest.raises(
InvalidSep10ChallengeError,
match="Transaction not signed by server: {}".format(
server_kp.public_key),
):
verify_challenge_transaction(challenge_tx, server_kp.public_key,
network_passphrase)
def test_challenge_transaction(self):
server_kp = Keypair.random()
client_account_id = "GBDIT5GUJ7R5BXO3GJHFXJ6AZ5UQK6MNOIDMPQUSMXLIHTUNR2Q5CFNF"
timeout = 600
network_passphrase = Network.TESTNET_NETWORK_PASSPHRASE
anchor_name = "SDF"
challenge = build_challenge_transaction(
server_secret=server_kp.secret,
client_account_id=client_account_id,
anchor_name=anchor_name,
network_passphrase=network_passphrase,
timeout=timeout,
)
transaction = TransactionEnvelope.from_xdr(
challenge, network_passphrase).transaction
assert len(transaction.operations) == 1
op = transaction.operations[0]
assert isinstance(op, ManageData)
assert op.data_name == "SDF auth"
assert len(op.data_value) == 64
assert len(base64.b64decode(op.data_value)) == 48
assert op.source == client_account_id
now = int(time.time())
assert now - 3 < transaction.time_bounds.min_time < now + 3
assert (transaction.time_bounds.max_time -
transaction.time_bounds.min_time == timeout)
assert transaction.source.public_key == server_kp.public_key
assert transaction.sequence == 0
def test_verify_challenge_tx_source_is_different_to_server_account_id(
self):
server_kp = Keypair.random()
client_kp = Keypair.random()
network_passphrase = Network.TESTNET_NETWORK_PASSPHRASE
anchor_name = "SDF"
challenge = build_challenge_transaction(server_kp.secret,
client_kp.public_key,
anchor_name,
network_passphrase)
transaction = TransactionEnvelope.from_xdr(challenge,
network_passphrase)
transaction.sign(client_kp)
challenge_tx = transaction.to_xdr()
with pytest.raises(
InvalidSep10ChallengeError,
match=
"Transaction source account is not equal to server's account.",
):
verify_challenge_transaction(challenge_tx,
Keypair.random().public_key,
network_passphrase)
async def test_submit_transaction_with_te(self):
xdr = "AAAAAHI7fpgo+b7tgpiFyYWimjV7L7IOYLwmQS7k7F8SronXAAAAZAE+QT4AAAAJAAAAAQAAAAAAAAAAAAAAAF1MG8cAAAAAAAAAAQAAAAAAAAAAAAAAAOvi1O/HEn+QgZJw+EMZBtwvTVNmpgvE9p8IRfwp0GY4AAAAAAExLQAAAAAAAAAAARKuidcAAABAJVc1ASGp35hUquGNbzzSqWPoTG0zgc89zc4p+19QkgbPqsdyEfHs7+ng9VJA49YneEXRa6Fv7pfKpEigb3VTCg=="
te = TransactionEnvelope.from_xdr(xdr,
Network.PUBLIC_NETWORK_PASSPHRASE)
horizon_url = "https://testhorizon.paydex.io/"
client = AiohttpClient()
async with Server(horizon_url, client) as server:
resp = await server.submit_transaction(te)
assert resp["envelope_xdr"] == xdr
def test_verify_challenge_transaction_threshold_raise_not_meet_threshold(
self):
server_kp = Keypair.random()
client_kp_a = Keypair.random()
client_kp_b = Keypair.random()
client_kp_c = Keypair.random()
timeout = 600
network_passphrase = Network.PUBLIC_NETWORK_PASSPHRASE
anchor_name = "SDF"
challenge = build_challenge_transaction(
server_secret=server_kp.secret,
client_account_id=client_kp_a.public_key,
anchor_name=anchor_name,
network_passphrase=network_passphrase,
timeout=timeout,
)
transaction = TransactionEnvelope.from_xdr(challenge,
network_passphrase)
transaction.sign(client_kp_a)
transaction.sign(client_kp_b)
transaction.sign(client_kp_c)
challenge_tx = transaction.to_xdr()
signers = [
Ed25519PublicKeySigner(client_kp_a.public_key, 1),
Ed25519PublicKeySigner(client_kp_b.public_key, 2),
Ed25519PublicKeySigner(client_kp_c.public_key, 4),
Ed25519PublicKeySigner(Keypair.random().public_key, 255),
]
med_threshold = 10
with pytest.raises(
InvalidSep10ChallengeError,
match="signers with weight 7 do not meet threshold 10.",
):
verify_challenge_transaction_threshold(
challenge_tx,
server_kp.public_key,
network_passphrase,
med_threshold,
signers,
)
def test_verify_challenge_transaction(self):
server_kp = Keypair.random()
client_kp = Keypair.random()
timeout = 600
network_passphrase = Network.PUBLIC_NETWORK_PASSPHRASE
anchor_name = "SDF"
challenge = build_challenge_transaction(
server_secret=server_kp.secret,
client_account_id=client_kp.public_key,
anchor_name=anchor_name,
network_passphrase=network_passphrase,
timeout=timeout,
)
transaction = TransactionEnvelope.from_xdr(challenge,
network_passphrase)
transaction.sign(client_kp)
challenge_tx = transaction.to_xdr()
verify_challenge_transaction(challenge_tx, server_kp.public_key,
network_passphrase)
def test_verify_challenge_transaction_signers_raise_no_server_signature(
self):
server_kp = Keypair.random()
client_kp_a = Keypair.random()
client_kp_b = Keypair.random()
client_kp_c = Keypair.random()
timeout = 600
network_passphrase = Network.PUBLIC_NETWORK_PASSPHRASE
anchor_name = "SDF"
challenge = build_challenge_transaction(
server_secret=server_kp.secret,
client_account_id=client_kp_a.public_key,
anchor_name=anchor_name,
network_passphrase=network_passphrase,
timeout=timeout,
)
transaction = TransactionEnvelope.from_xdr(challenge,
network_passphrase)
transaction.signatures = []
transaction.sign(client_kp_a)
transaction.sign(client_kp_b)
transaction.sign(client_kp_c)
challenge_tx = transaction.to_xdr()
signers = [
Ed25519PublicKeySigner(client_kp_a.public_key, 1),
Ed25519PublicKeySigner(client_kp_b.public_key, 2),
Ed25519PublicKeySigner(client_kp_c.public_key, 4),
Ed25519PublicKeySigner(Keypair.random().public_key, 255),
]
with pytest.raises(
InvalidSep10ChallengeError,
match="Transaction not signed by server: {}.".format(
server_kp.public_key),
):
verify_challenge_transaction_signers(challenge_tx,
server_kp.public_key,
network_passphrase, signers)
def test_already_signed_raise(self):
# GDF5O4OWEMVBY5FLDHWA5RZTYSV2U276XGKZZ6VSHDDR3THSQ6OQS7UM
source = Keypair.from_secret(
"SCCS5ZBI7WVIJ4SW36WGOQQIWJYCL3VOAULSXX3FB57USIO25EDOYQHH")
destination = "GDJJRRMBK4IWLEPJGIE6SXD2LP7REGZODU7WDC3I2D6MR37F4XSHBKX2"
amount = "1000.0"
sequence = 1
memo = IdMemo(100)
fee = 200
asset = Asset.native()
time_bounds = TimeBounds(12345, 56789)
ops = [
Payment(destination, asset, amount),
ManageData("hello", "world")
]
tx = Transaction(source, sequence, fee, ops, memo, time_bounds)
te = TransactionEnvelope(tx, Network.PUBLIC_NETWORK_PASSPHRASE)
assert binascii.hexlify(te.hash()).decode() == te.hash_hex()
# te.sign(source)
te.sign("SCCS5ZBI7WVIJ4SW36WGOQQIWJYCL3VOAULSXX3FB57USIO25EDOYQHH")
hashx = bytes.fromhex(
"94e8223a518ac16a8cb110ab1952ef14da2c10b264645c38c8b3d82bd2b20000")
te.sign_hashx(hashx)
with pytest.raises(SignatureExistError,
match="The keypair has already signed."):
te.sign(source)
with pytest.raises(SignatureExistError,
match="The preimage has already signed."):
te.sign_hashx(hashx)
