aster-connector-python

This is a lightweight library that works as a connector to Aster Finance public API

Installation

pip install aster-connector-python

Documentation

RESTful APIs

Usage examples:

from aster.rest_api import Client 

# Get timestamp
client = Client()
print(client.time())


client = Client(key='<api_key>', secret='<api_secret>')

# Get account information
print(client.account())

# Post a new order
params = {
    'symbol': 'BTCUSDT',
    'side': 'SELL',
    'type': 'LIMIT',
    'timeInForce': 'GTC',
    'quantity': 0.002,
    'price': 59808
}

response = client.new_order(**params)
print(response)

Please find examples folder to check for more endpoints.

Base URL

https://fapi.asterdex.com

This host serves both the legacy /fapi/v1, /fapi/v2 routes and the Pro API /fapi/v3 routes. The fapi3.asterdex.com host that appears in some official code samples is not reachable.

Authentication: V1 and V3

Two schemes coexist and are selected explicitly, never inferred from the shape of a credential.

V1 (legacy) signs with HMAC-SHA256 over the API secret and is the default, so existing code is unchanged:

from aster.rest_api import AsyncClient

client = AsyncClient(key=api_key, secret=api_secret)

V3 (Pro API) signs an EIP-712 envelope with an API wallet's private key. AsterDex issues new credentials as Pro API wallets, so new accounts need this:

from aster.rest_api import AsyncClientV3

# `key`/`secret` are the API wallet address and its private key. `signer` and
# `private_key` are accepted as explicit aliases.
client = AsyncClientV3(key=api_wallet_address, secret=api_wallet_private_key)

AsyncClientV3 exposes the same method names as AsyncClient over /fapi/v3 routes, so call sites do not change. V3 requires the v3 extra:

pip install "aster-connector-python[v3]"

user (the master account wallet address) is optional -- the exchange authenticates agent-signed TRADE, USER_DATA and USER_STREAM requests from the signer alone -- and is carried as an opaque string, so a Solana master account needs no Ed25519 signing:

client = AsyncClientV3(key=..., secret=..., user=master_wallet_address)

Requests carry a microsecond nonce. The exchange tracks nonces per agent address and keeps only the most recent 100, so nonces are generated from a strictly increasing counter shared across every client in the process. Clock skew is rejected as -1000 Signature check failed rather than as a nonce error, so keep the system clock synchronised.

Optional parameters

PEP8 suggests lowercase with words separated by underscores, but for this connector, the methods' optional parameters should follow their exact naming as in the API documentation.

# Recognised parameter name
response = client.query_order('BTCUSDT', orderListId=1)

# Unrecognised parameter name
response = client.query_order('BTCUSDT', order_list_id=1)

RecvWindow parameter

Additional parameter recvWindow is available for endpoints requiring signature.
It defaults to 5000 (milliseconds) and can be any value lower than 60000(milliseconds). Anything beyond the limit will result in an error response from aster server.

from aster.rest_api import Client

client = Client(key, secret)
response = client.query_order('BTCUSDT', orderId=11, recvWindow=10000)

Timeout

timeout is available to be assigned with the number of seconds you find most appropriate to wait for a server response.
Please remember the value as it won't be shown in error message no bytes have been received on the underlying socket for timeout seconds.
By default, timeout is None. Hence, requests do not time out.

from aster.rest_api import Client

client= Client(timeout=1)

Proxy

proxy is supported

from aster.rest_api import Client

proxies = { 'https': 'http://1.2.3.4:8080' }

client= Client(proxies=proxies)

Response Metadata

The aster API server provides weight usages in the headers of each response. You can display them by initializing the client with show_limit_usage=True:

from aster.rest_api import Client

client = Client(show_limit_usage=True)
print(client.time())

You can also display full response metadata to help in debugging:

client = Client(show_header=True)
print(client.time())

If ClientError is received, it'll display full response meta information.

Display logs

Setting the log level to DEBUG will log the request URL, payload and response text.

Error

There are 2 types of error returned from the library:

• aster.error.ClientError
  • This is thrown when server returns 4XX, it's an issue from client side.
  • It has 4 properties:
    • status_code - HTTP status code
    • error_code - Server's error code, e.g. -1102
    • error_message - Server's error message, e.g. Unknown order sent.
    • header - Full response header.
• aster.error.ServerError
  • This is thrown when server returns 5XX, it's an issue from server side.

Websocket

from aster.websocket.client.stream import WebsocketClient as Client

def message_handler(message):
    print(message)

ws_client = Client()
ws_client.start()

ws_client.mini_ticker(
    symbol='bnbusdt',
    id=1,
    callback=message_handler,
)

# Combine selected streams
ws_client.instant_subscribe(
    stream=['bnbusdt@bookTicker', 'ethusdt@bookTicker'],
    callback=message_handler,
)

ws_client.stop()

More websocket examples are available in the examples folder

Heartbeat

Once connected, the websocket server sends a ping frame every 3 minutes and requires a response pong frame back within a 10 minutes period. This package handles the pong responses automatically.