def test_check_memo_required_with_memo_muxed_account_sync(
self, httpserver):
self.__inject_mock_server(httpserver)
horizon_url = httpserver.url_for("/")
server = Server(horizon_url)
keypair = Keypair.from_secret(
"SDQXFKA32UVQHUTLYJ42N56ZUEM5PNVVI4XE7EA5QFMLA2DHDCQX3GPY")
account = Account(keypair.public_key, 1)
transaction = (TransactionBuilder(account).append_payment_op(
self.DESTINATION_ACCOUNT_MEMO_REQUIRED_A, "10",
"PMN").append_path_payment_strict_receive_op(
self.DESTINATION_ACCOUNT_MEMO_REQUIRED_B,
"PMN",
None,
"10",
"BTC",
"GA7GYB3QGLTZNHNGXN3BMANS6TC7KJT3TCGTR763J4JOU4QHKL37RVV2",
"1",
[],
).append_path_payment_strict_send_op(
self.DESTINATION_ACCOUNT_MEMO_REQUIRED_C,
"PMN",
None,
"10",
"BTC",
"GA7GYB3QGLTZNHNGXN3BMANS6TC7KJT3TCGTR763J4JOU4QHKL37RVV2",
"1",
[],
).append_account_merge_op(
self.DESTINATION_ACCOUNT_MEMO_REQUIRED_D).add_text_memo(
"hello, world").build())
transaction.sign(keypair)
server.submit_transaction(transaction)
def test_check_memo_required_with_fee_bump_transaction_sync(
self, httpserver):
self.__inject_mock_server(httpserver)
horizon_url = httpserver.url_for("/")
server = Server(horizon_url)
keypair = Keypair.from_secret(
"SDQXFKA32UVQHUTLYJ42N56ZUEM5PNVVI4XE7EA5QFMLA2DHDCQX3GPY")
account = Account(keypair.public_key, 1)
transaction = (TransactionBuilder(account, v1=True).append_payment_op(
self.DESTINATION_ACCOUNT_MEMO_REQUIRED_A, "10",
"PMN").append_path_payment_strict_send_op(
self.DESTINATION_ACCOUNT_MEMO_REQUIRED_C,
"PMN",
None,
"10",
"BTC",
"GA7GYB3QGLTZNHNGXN3BMANS6TC7KJT3TCGTR763J4JOU4QHKL37RVV2",
"1",
[],
).append_account_merge_op(
self.DESTINATION_ACCOUNT_MEMO_REQUIRED_D).add_text_memo(
"hello, world").build())
transaction.sign(keypair)
fee_bump_tx = TransactionBuilder.build_fee_bump_transaction(
fee_source=Keypair.random().public_key,
base_fee=200,
inner_transaction_envelope=transaction,
network_passphrase=Network.TESTNET_NETWORK_PASSPHRASE,
)
server.submit_transaction(fee_bump_tx)
def test_check_memo_required_with_fetch_account_error_raise_sync(
self, httpserver):
self.__inject_mock_server(httpserver)
horizon_url = httpserver.url_for("/")
server = Server(horizon_url)
keypair = Keypair.from_secret(
"SDQXFKA32UVQHUTLYJ42N56ZUEM5PNVVI4XE7EA5QFMLA2DHDCQX3GPY")
account = Account(keypair.public_key, 1)
transaction = (TransactionBuilder(account).append_payment_op(
self.DESTINATION_ACCOUNT_FETCH_ERROR, "10",
"PMN").append_path_payment_strict_receive_op(
self.DESTINATION_ACCOUNT_NO_MEMO_REQUIRED,
"PMN",
None,
"10",
"BTC",
"GA7GYB3QGLTZNHNGXN3BMANS6TC7KJT3TCGTR763J4JOU4QHKL37RVV2",
"1",
[],
).append_path_payment_strict_send_op(
self.DESTINATION_ACCOUNT_NO_MEMO_REQUIRED,
"PMN",
None,
"10",
"BTC",
"GA7GYB3QGLTZNHNGXN3BMANS6TC7KJT3TCGTR763J4JOU4QHKL37RVV2",
"1",
[],
).append_account_merge_op(
self.DESTINATION_ACCOUNT_NO_MEMO_REQUIRED).build())
transaction.sign(keypair)
with pytest.raises(BadRequestError) as err:
server.submit_transaction(transaction)
assert err.value.status == 400
def test_check_memo_required_with_no_destination_operation_sync(
self, httpserver):
self.__inject_mock_server(httpserver)
horizon_url = httpserver.url_for("/")
server = Server(horizon_url)
keypair = Keypair.from_secret(
"SDQXFKA32UVQHUTLYJ42N56ZUEM5PNVVI4XE7EA5QFMLA2DHDCQX3GPY")
account = Account(keypair.public_key, 1)
transaction = (TransactionBuilder(account).append_manage_data_op(
"Hello", "world").build())
transaction.sign(keypair)
server.submit_transaction(transaction)
async def test_check_memo_required_with_account_not_found_async(
self, httpserver):
self.__inject_mock_server(httpserver)
horizon_url = httpserver.url_for("/")
keypair = Keypair.from_secret(
"SDQXFKA32UVQHUTLYJ42N56ZUEM5PNVVI4XE7EA5QFMLA2DHDCQX3GPY")
account = Account(keypair.public_key, 1)
async with Server(horizon_url, AiohttpClient()) as server:
transaction = (TransactionBuilder(account).append_payment_op(
self.DESTINATION_ACCOUNT_NO_FOUND, "10",
"PMN").append_path_payment_strict_receive_op(
self.DESTINATION_ACCOUNT_NO_FOUND,
"PMN",
None,
"10",
"BTC",
"GA7GYB3QGLTZNHNGXN3BMANS6TC7KJT3TCGTR763J4JOU4QHKL37RVV2",
"1",
[],
).append_path_payment_strict_send_op(
self.DESTINATION_ACCOUNT_NO_FOUND,
"PMN",
None,
"10",
"BTC",
"GA7GYB3QGLTZNHNGXN3BMANS6TC7KJT3TCGTR763J4JOU4QHKL37RVV2",
"1",
[],
).append_account_merge_op(
self.DESTINATION_ACCOUNT_NO_FOUND).build())
transaction.sign(keypair)
await server.submit_transaction(transaction)
def test_check_memo_required_with_two_operation_with_same_destination_sync(
self, httpserver):
self.__inject_mock_server(httpserver)
horizon_url = httpserver.url_for("/")
server = Server(horizon_url)
keypair = Keypair.from_secret(
"SDQXFKA32UVQHUTLYJ42N56ZUEM5PNVVI4XE7EA5QFMLA2DHDCQX3GPY")
account = Account(keypair.public_key, 1)
transaction = (TransactionBuilder(account).append_payment_op(
self.DESTINATION_ACCOUNT_NO_MEMO_REQUIRED, "10",
"PMN").append_path_payment_strict_receive_op(
self.DESTINATION_ACCOUNT_NO_MEMO_REQUIRED,
"PMN",
None,
"10",
"BTC",
"GA7GYB3QGLTZNHNGXN3BMANS6TC7KJT3TCGTR763J4JOU4QHKL37RVV2",
"1",
[],
).append_path_payment_strict_send_op(
self.DESTINATION_ACCOUNT_NO_MEMO_REQUIRED,
"PMN",
None,
"10",
"BTC",
"GA7GYB3QGLTZNHNGXN3BMANS6TC7KJT3TCGTR763J4JOU4QHKL37RVV2",
"1",
[],
).append_account_merge_op(
self.DESTINATION_ACCOUNT_MEMO_REQUIRED_D).build())
transaction.sign(keypair)
with pytest.raises(
AccountRequiresMemoError,
match="Destination account requires a memo in the transaction.",
) as err:
server.submit_transaction(transaction)
assert err.value.account_id == self.DESTINATION_ACCOUNT_MEMO_REQUIRED_D
assert err.value.operation_index == 3
async def main():
# Configure KuknosSdk to talk to the horizon instance hosted by Kuknos.org
# To use the live network, set the hostname to 'horizon.kuknos.org'
# When we use the `with` syntax, it automatically releases the resources it occupies.
async with Server(
horizon_url="https://hz1-test.kuknos.org", client=AiohttpClient()
) as server:
# Transactions require a valid sequence number that is specific to this account.
# We can fetch the current sequence number for the source account from Horizon.
source_account = await server.load_account(source_public_key)
base_fee = await server.fetch_base_fee()
# we are going to submit the transaction to the test network,
# so network_passphrase is `Network.TESTNET_NETWORK_PASSPHRASE`,
# if you want to submit to the public network, please use `Network.PUBLIC_NETWORK_PASSPHRASE`.
transaction = (
TransactionBuilder(
source_account=source_account,
network_passphrase=Network.TESTNET_NETWORK_PASSPHRASE,
base_fee=base_fee,
)
.add_text_memo("Hello, Kuknos!") # Add a memo
# Add a payment operation to the transaction
# Send 350.1234567 PMN to receiver
# Specify 350.1234567 paymons. Paymons are divisible to seven digits past the decimal.
.append_payment_op(receiver_public_key, "350.1234567", "PMN")
.set_timeout(30) # Make this transaction valid for the next 30 seconds only
.build()
)
# Sign this transaction with the secret key
# NOTE: signing is transaction is network specific. Test network transactions
# won't work in the public network. To switch networks, use the Network object
# as explained above (look for kuknos_sdk.network.Network).
transaction.sign(source_keypair)
# Let's see the XDR (encoded in base64) of the transaction we just built
print(transaction.to_xdr())
# Submit the transaction to the Horizon server.
# The Horizon server will then submit the transaction into the network for us.
response = await server.submit_transaction(transaction)
print(response)
async def operations():
async with Server(HORIZON_URL, AiohttpClient()) as server:
async for operation in server.operations().cursor(
cursor="now").stream():
print(f"Operation: {operation}")
async def effects():
async with Server(HORIZON_URL, AiohttpClient()) as server:
async for effect in server.effects().cursor(cursor="now").stream():
print(f"Effect: {effect}")
from kuknos_sdk import Server, TransactionBuilder, Keypair, Network
from kuknos_sdk.exceptions import NotFoundError
from kuknos_sdk.sep.exceptions import InvalidSep10ChallengeError
from kuknos_sdk.sep.kuknos_web_authentication import build_challenge_transaction, read_challenge_transaction, \
verify_challenge_transaction_threshold, verify_challenge_transaction_signed_by_client_master_key
server_keypair = Keypair.from_secret(
"SBGCNEOQGECW5R4A55C26ZFS736IONKCHY5PPPSFZVXSJSU63MWNM4K6")
client_master_keypair = Keypair.from_secret(
"SDWZHXKWSHTQ2YGPT6YQQSOJWJX5JX2IEU7KOLGQ2XEJEECIQHUU3RMR")
client_signer_keypair1 = Keypair.from_secret(
"SCKJFEF2H767XINUY5YFBORUO7AAWOAXSTQ2B2YHSI6N4UF23HFV42I7")
client_signer_keypair2 = Keypair.from_secret(
"SCE2JBZ6FKPTQ5LM4X4NIZOOZPIC5DXVG6VP2TKSBZCQAGXABJV55IN5")
server = Server("https://hz1-test.kuknos.org")
home_domain = "example.com"
web_auth_domain = "auth.example.com"
network_passphrase = Network.TESTNET_NETWORK_PASSPHRASE
def setup_multisig():
client_master_account = server.load_account(
client_master_keypair.public_key)
te = TransactionBuilder(client_master_account, network_passphrase) \
.append_ed25519_public_key_signer(client_signer_keypair1.public_key, 40) \
.append_ed25519_public_key_signer(client_signer_keypair2.public_key, 60) \
.append_set_options_op(master_weight=0, low_threshold=1, med_threshold=10, high_threshold=100) \
.build()
te.sign(client_master_keypair)
resp = server.submit_transaction(te)
from kuknos_sdk import TransactionBuilder, Server, Network, Keypair
server = Server(horizon_url="https://hz1-test.kuknos.org")
source = Keypair.from_secret("SBFZCHU5645DOKRWYBXVOXY2ELGJKFRX6VGGPRYUWHQ7PMXXJNDZFMKD")
destination = Keypair.random()
source_account = server.load_account(account_id=source.public_key)
transaction = TransactionBuilder(
source_account=source_account,
network_passphrase=Network.TESTNET_NETWORK_PASSPHRASE,
base_fee=100) \
.append_create_account_op(destination=destination.public_key, starting_balance="12.25") \
.build()
transaction.sign(source)
response = server.submit_transaction(transaction)
print("Transaction hash: {}".format(response["hash"]))
print("New Keypair: \n\taccount id: {account_id}\n\tsecret seed: {secret_seed}".format(
account_id=destination.public_key, secret_seed=destination.secret))
from kuknos_sdk import Server, TransactionBuilder, Signer, Network, Keypair
server = Server(horizon_url="https://hz1-test.kuknos.org/")
root_keypair = Keypair.from_secret("SA6XHAH4GNLRWWWF6TEVEWNS44CBNFAJWHWOPZCVZOUXSQA7BOYN7XHC")
root_account = server.load_account(account_id=root_keypair.public_key)
secondary_keypair = Keypair.from_secret("SAMZUAAPLRUH62HH3XE7NVD6ZSMTWPWGM6DS4X47HLVRHEBKP4U2H5E7")
secondary_signer = Signer.ed25519_public_key(account_id=secondary_keypair.public_key, weight=1)
transaction = TransactionBuilder(
source_account=root_account,
network_passphrase=Network.TESTNET_NETWORK_PASSPHRASE,
base_fee=100) \
.append_set_options_op(
master_weight=1, # set master key weight
low_threshold=1,
med_threshold=2, # a payment is medium threshold
high_threshold=2, # make sure to have enough weight to add up to the high threshold!
signer=secondary_signer) \
.set_timeout(30) \
.build()
# only need to sign with the root signer as the 2nd signer won't
# be added to the account till after this transaction completes
transaction.sign(root_keypair)
response = server.submit_transaction(transaction)
print(response)
# now create a payment with the account that has two signers
destination = "GBA5SMM5OYAOOPL6R773MV7O3CCLUDVLCWHIVVL3W4XTD3DA5FJ4JSEZ"
transaction = TransactionBuilder(
source_account=root_account,
from kuknos_sdk import Server, TransactionBuilder, Keypair, Network
sponsor_secret = "SAOJHTVFCYVKUMPNQI7RUSI566GKWXP7RXOHP4SV6JAVUQKSIWGPZFPJ"
new_account_secret = "SCN5D72JHQAHUHGIA23SLS3LBYCPHJWD7HLYNJRBBZIG4PD74UCGQBYM"
sponsor_keypair = Keypair.from_secret(sponsor_secret)
newly_created_keypair = Keypair.from_secret(new_account_secret)
server = Server("https://hz1-test.kuknos.org")
network_passphrase = Network.TESTNET_NETWORK_PASSPHRASE
# Sponsoring Account Creation
# https://github.com/kuknos/kuknos-protocol/blob/master/core/cap-0033.md#example-sponsoring-account-creation
sponsor_account = server.load_account(sponsor_keypair.public_key)
sponsoring_account_creation_te = TransactionBuilder(
source_account=sponsor_account,
network_passphrase=network_passphrase
).append_begin_sponsoring_future_reserves_op(
sponsored_id=newly_created_keypair.public_key,
source=sponsor_keypair.public_key
).append_create_account_op(
destination=newly_created_keypair.public_key,
starting_balance="10",
source=sponsor_keypair.public_key
).append_end_sponsoring_future_reserves_op(
source=newly_created_keypair.public_key
).build()
sponsoring_account_creation_te.sign(sponsor_keypair)
sponsoring_account_creation_te.sign(new_account_secret)
sponsoring_account_creation_resp = server.submit_transaction(sponsoring_account_creation_te)
print(sponsoring_account_creation_resp)
import pprint
from kuknos_sdk import Keypair, Server, TransactionBuilder, Network
from kuknos_sdk.exceptions import BadRequestError
horizon_url = "https://hz1-test.kuknos.org/"
network_passphrase = Network.TESTNET_NETWORK_PASSPHRASE
fee_source_keypair = Keypair.from_secret(
"SASZKBDB6PFHXN6LRH4NQNTRGLGDTI3PSUVIKMZMLTYYBB7NDVMA6DSL")
inner_source_keypair = Keypair.from_secret(
"SC5O7VZUXDJ6JBDSZ74DSERXL7W3Y5LTOAMRF7RQRL3TAGAPS7LUVG3L")
destination_address = "GBVKI23OQZCANDUZ2SI7XU7W6ICYKYT74JBXDD2CYRDAFZHZNRPASSQK"
server = Server(horizon_url=horizon_url)
inner_account = server.load_account(inner_source_keypair)
inner_tx = (TransactionBuilder(source_account=inner_account,
network_passphrase=network_passphrase,
base_fee=50,
v1=True).append_payment_op(
destination=destination_address,
amount="100",
asset_code="PMN").build())
inner_tx.sign(inner_source_keypair)
try:
# This transaction will fail.
tx_insufficient_fee_resp = server.submit_transaction(inner_tx)
except BadRequestError as e:
print(e)
async def transactions():
async with Server(HORIZON_URL, AiohttpClient()) as server:
async for transaction in server.transactions().cursor(
cursor="now").stream():
print(f"Transaction: {transaction}")
from kuknos_sdk import Server, TransactionBuilder, Keypair, ClaimPredicate, Claimant, Asset, Network
sponsor_secret = "SAOJHTVFCYVKUMPNQI7RUSI566GKWXP7RXOHP4SV6JAVUQKSIWGPZFPJ"
claimant_secret = "SBOLGU7D7A7MTY4JZ3WZUKSKB6NZBQFNQG3BZT4HZW4AAVZJRG7TWXGQ"
sponsor_keypair = Keypair.from_secret(sponsor_secret)
claimant_keypair = Keypair.from_secret(claimant_secret)
server = Server("https://hz1-test.kuknos.org/")
network_passphrase = Network.TESTNET_NETWORK_PASSPHRASE
# Create Claimable Balance
sponsor_account = server.load_account(sponsor_keypair.public_key)
predicate_left = ClaimPredicate.predicate_before_relative_time(60 * 60 * 24 *
7)
predicate_right = ClaimPredicate.predicate_not(
ClaimPredicate.predicate_before_relative_time(60 * 3))
predicate = ClaimPredicate.predicate_and(predicate_left, predicate_right)
claimant = Claimant(destination=claimant_keypair.public_key,
predicate=predicate)
create_claimable_balance_te = TransactionBuilder(
source_account=sponsor_account,
network_passphrase=network_passphrase).append_create_claimable_balance_op(
asset=Asset.native(),
amount="100",
claimants=[claimant],
source=sponsor_keypair.public_key).build()
create_claimable_balance_te.sign(sponsor_keypair)
create_claimable_balance_resp = server.submit_transaction(
create_claimable_balance_te)
3. Access to Python Kuknos SDK (https://github.com/javadnikbakht/py-kuknos-base) through Python shell.
"""
from kuknos_sdk import Server, Keypair, TransactionBuilder, Network
# The source account is the account we will be signing and sending from.
source_secret_key = "SBFZCHU5645DOKRWYBXVOXY2ELGJKFRX6VGGPRYUWHQ7PMXXJNDZFMKD"
# Derive Keypair object and public key (that starts with a G) from the secret
source_keypair = Keypair.from_secret(source_secret_key)
source_public_key = source_keypair.public_key
receiver_public_key = "GA7YNBW5CBTJZ3ZZOWX3ZNBKD6OE7A7IHUQVWMY62W2ZBG2SGZVOOPVH"
# Configure KuknosSdk to talk to the horizon instance hosted by Kuknos.org
# To use the live network, set the hostname to 'horizon.kuknos.org'
server = Server(horizon_url="https://hz1-test.kuknos.org")
# Transactions require a valid sequence number that is specific to this account.
# We can fetch the current sequence number for the source account from Horizon.
source_account = server.load_account(source_public_key)
base_fee = server.fetch_base_fee()
# we are going to submit the transaction to the test network,
# so network_passphrase is `Network.TESTNET_NETWORK_PASSPHRASE`,
# if you want to submit to the public network, please use `Network.PUBLIC_NETWORK_PASSPHRASE`.
transaction = (
TransactionBuilder(
source_account=source_account,
network_passphrase=Network.TESTNET_NETWORK_PASSPHRASE,
base_fee=base_fee,
).add_text_memo("Hello, Kuknos!") # Add a memo
async def payments():
async with Server(HORIZON_URL, AiohttpClient()) as server:
async for payment in server.payments().cursor(cursor="now").stream():
print(f"Payment: {payment}")
from kuknos_sdk import Server
server = Server(horizon_url="https://hz1-test.kuknos.org/")
# get a list of transactions that occurred in ledger 1400
transactions = server.transactions().for_ledger(1400).call()
print(transactions)
# get a list of transactions submitted by a particular account
transactions = server.transactions() \
.for_account(account_id="GASOCNHNNLYFNMDJYQ3XFMI7BYHIOCFW3GJEOWRPEGK2TDPGTG2E5EDW") \
.call()
print(transactions)
from kuknos_sdk import Server
server = Server(horizon_url="https://hz1-test.kuknos.org")
account_id = "GASOCNHNNLYFNMDJYQ3XFMI7BYHIOCFW3GJEOWRPEGK2TDPGTG2E5EDW"
last_cursor = 'now' # or load where you left off
def tx_handler(tx_response):
print(tx_response)
for tx in server.transactions().for_account(account_id).cursor(last_cursor).stream():
tx_handler(tx)
# Let's assume Alice and Bob hold an escrow account and now they want to
# send 100 PMN from the escrow account to Eve, the following code shows how to achieve it.
from kuknos_sdk import Server, TransactionBuilder, Network, TransactionEnvelope
escrow_public = "GD7ZZHKFKFPV2KR6JPE5L6QOZ43LV6HBJWLITCC73V6R7YFERSAITE4S"
alice_secret = "SDKE26TSKMJDWPTWMA5YJYSIA6VQ5QNBUS5VEUR7P6NY4F7ITL7ZILQG"
bob_secret = "SBVFXGIXA22LSNZQKXCTNBRBFHBPRWBGZ7KNWAEINCYCPMNFGJDFPWA2"
eve_public = "GAPE2V77237AQJGTFNYNI3RBMERSFLTUYPVXDMANXUGUN6IEWCVY3VXN"
network_passphrase = Network.TESTNET_NETWORK_PASSPHRASE
server = Server(horizon_url="https://hz1-test.kuknos.org")
escrow_account = server.load_account(eve_public)
base_fee = 100
transaction = TransactionBuilder(
source_account=escrow_account,
network_passphrase=network_passphrase,
base_fee=base_fee,
).add_text_memo("Hello, Kuknos!") \
.append_payment_op(eve_public, "100", "PMN") \
.set_timeout(30) \
.build()
# Now Alice signs this transaction and sends the generated XDR to Bob
transaction.sign(alice_secret)
xdr = transaction.to_xdr()
print(f"xdr: {xdr}")
# Bob receives this XDR and signs it.
transaction = TransactionEnvelope.from_xdr(xdr, network_passphrase)
