Asynchronous

Now we have supported the use of asynchronous methods to submit transactions, digital-world-py-sdk gives you the choice, rather than forcing you into always writing async; sync code is easier to write, generally safer, and has many more libraries to choose from.

The following is an example of send a payment by an asynchronous method, the same example of using the synchronization method can be found here:

"""
The effect of this example is the same as `payment.py`, but this example is asynchronous.

Create, sign, and submit a transaction using Python Digital World SDK.

Assumes that you have the following items:
1. Secret key of a funded account to be the source account
2. Public key of an existing account as a recipient
    These two keys can be created and funded by the faucet at
    https://lab.digitalworld.global/ under the heading "Quick Start: Test Account"
3. Access to Python Digital World SDK (https://github.com/DigitalWorld/digital-world-py-sdk) through Python shell.

See: https://docs.digitalworld.global/docs/start/list-of-operations/#payment
"""

import asyncio

from digital_world_sdk import (
    AiohttpClient,
    Asset,
    Keypair,
    Network,
    GatewayServerAsync,
    TransactionBuilder,
)

# The source account is the account we will be signing and sending from.
# Derive Keypair object and public key (that starts with a G) from the secret
source_keypair = Keypair.from_secret(
    "SCDG4ORIDX4QGPMMHQY36KDHHMTJEM4RQ2AWKH3G7AXHTVBJWEV6XOUM"
)
source_public_key = source_keypair.public_key

# We are sending the native asset to the receiver account
receiver_public_key = "GD2JXEFGEO53CNQ22KN2ICOQ2LOASCABQHAIOMLZV265C246PFKKHPYU"


async def main():
    # Configure Digital World SDK to talk to the Gateway instance
    # To use the live network, set the hostname to 'dex.digitalworld.global'
    # When we use the `with` syntax, it automatically releases the resources it occupies.
    async with GatewayServerAsync(
        gateway_url="https://dex-testnet.digitalworld.global", 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 Gateway.
        source_account = await server.load_account(source_public_key)

        base_fee = 100
        # 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, Digital World!")  # Add a memo
            # Add a payment operation to the transaction
            # Send 350.1234567 of the native asset to receiver
            # The native asset is divisible to seven digits past the decimal.
            .append_payment_op(receiver_public_key, Asset.native(), "350.1234567")
            .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 digital_world_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 Gateway server.
        # The Gateway server will then submit the transaction into the network for us.
        response = await server.submit_transaction(transaction)
        print(response)


if __name__ == "__main__":
    asyncio.run(main())

The following example helps you listen to multiple endpoints asynchronously.

"""
See: https://digital-world-sdk.docs.digitalworld.global/en/latest/asynchronous.html
"""

import asyncio

from digital_world_sdk import AiohttpClient, GatewayServerAsync

GATEWAY_URL = "https://dex.digitalworld.global"


async def payments():
    async with GatewayServerAsync(GATEWAY_URL, AiohttpClient()) as server:
        async for payment in server.payments().cursor(cursor="now").stream():
            print(f"Payment: {payment}")


async def effects():
    async with GatewayServerAsync(GATEWAY_URL, AiohttpClient()) as server:
        async for effect in server.effects().cursor(cursor="now").stream():
            print(f"Effect: {effect}")


async def operations():
    async with GatewayServerAsync(GATEWAY_URL, AiohttpClient()) as server:
        async for operation in server.operations().cursor(cursor="now").stream():
            print(f"Operation: {operation}")


async def transactions():
    async with GatewayServerAsync(GATEWAY_URL, AiohttpClient()) as server:
        async for transaction in server.transactions().cursor(cursor="now").stream():
            print(f"Transaction: {transaction}")


async def listen():
    await asyncio.gather(payments(), effects(), operations(), transactions())


if __name__ == "__main__":
    asyncio.run(listen())