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))
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)
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,
# The following source key was created by the friendbot at https://laboratory.kuknos.org/#account-creator?network=test # before running this example create a new account, fund it and then copy and paste the # secret key where the current key is. source_secret_key = "SC7AUS23UKVZQL5KMIK4ZK3EZJUS6ZVMTQSVLH3VIK42W6RBQAQXOVQX" # The following obtains the keypair of the source account we will be dealing with. source_keypair = Keypair.from_secret(source_secret_key) source_public_key = source_keypair.public_key # This is the public key of another account created by the friendbot. When I wrote this # code it was active on the test network, but I would recommened creating a new account # the same way the source account was created. destination_public_key = "GANXMF6DCQNHZP5ULDONM4VNXBV5YECTDGLGXCESXNT66H6AZSAHLFGK" # loads the source account from the testnet source_account = server.load_account(source_public_key) # builds the transaction that merges the two accounts. # The current code uses the testnetwork and if you wanted to use # the public network 'Network.TESTNET_NETWORK_PASSPHRASE' would # have to be replaced with 'Network.PUBLIC_NETWORK_PASSPHRASE'. transaction = TransactionBuilder( source_account=source_account, network_passphrase=Network.TESTNET_NETWORK_PASSPHRASE, base_fee=100) \ .append_account_merge_op(destination=destination_public_key) \ .build() # source account signs the transaction transaction.sign(source_keypair)
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)
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)
# 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)