Skip to main content

Vega API client for gRPC and REST

Project description

Vega API client

Python tests

This is the Vega API client, which can talk to a Vega node using gRPC or REST, and to a Vega Wallet server using REST.

Examples

Connect to a Vega node

In order to interact with a Vega node, create:

  • VegaTradingClient: for trading, e.g. submitting, amending, cancelling orders
  • VegaTradingDataClient: for accessing public data
import vegaapiclient as vac

nodeurl = "veganode.example.com:1234"  # gRPC
# nodeurl = "https://veganode.example.com"  # REST

# Create client for accessing public data
datacli = vac.VegaTradingDataClient(nodeurl)

# Create client for trading (e.g. submitting orders)
tradingcli = vac.VegaTradingClient(nodeurl)

Get market data

from google.protobuf.empty_pb2 import Empty

import vegaapiclient as vac

# Create client for accessing public data
datacli = vac.VegaTradingDataClient(nodeurl)

# Get a list of markets
markets = datacli.Markets(Empty()).markets
for mkt in markets:
	print("{}: {}".format(mkt.id, mkt.name))

# Get a specific market by ID
req = vac.grpc.api.trading.MarketByIDRequest(marketID="MARKETID")
market = datacli.MarketByID(req)
print("{}: {}".format(market.id, market.name))

Connect to a Vega Wallet server

In order to submit signed transactions to a Vega node, connect to a Vega Wallet server, which handles your keypairs for you.

On Vega mainnet, everyone will run their own private wallet server: Your private keys, under your control, your responsibility.

But for testnet demonstration purposes, Vega provides a centralised wallet server. The URL for this is communicated separately.

import vegaapiclient as vac

walleturl = "https://wallet.example.com"
walletclient = vac.WalletClient(walleturl)

wname = "my_vega_wallet"
wpass = "supersecret_passphrase"

# If this is your first time: create a new wallet.
response = walletclient.create(wname, wpass)
assert response.status_code == 200
# If this is *not* your first time: log in to an existing wallet.
response = walletclient.login(wname, wpass)
assert response.status_code == 200

# If you don't already have a keypair, generate one.
response = walletclient.generatekey(wpass, [])
assert response.status_code == 200
key = response.json()["key"]
# Print key information. Note that the private key is *not* returned.
print("Key: {}".format(key))

# List keypairs
response = walletclient.listkeys()
assert response.status_code == 200
for key in response.json()["keys"]:
	print("Key: {}".format(key))

myPubKey = "1122aabb..."  # hex-encoded public key

# Get one keypair
response = walletclient.getkey(myPubKey)
assert response.status_code == 200
print("Key: {}".format(response.json()["key"]))

# Sign a transaction
blob = b"data returned from a Vega node 'Prepare' call"
tx = base64.b64encode(blob).decode("ascii")
response = walletclient.signtx(tx, myPubKey)
assert response.status_code == 200
print("signed tx: {}".format(response.json()["signedTx"]))

# When you're finished with the wallet, log out.
response = walletclient.logout()
assert response.status_code == 200

Submit a transaction

The flow to submit a signed transaction to a Vega node is as follows:

  1. Wallet server: Create a new wallet, or log in to an existing one.
  2. Wallet server: Create a keypair, if one has not already been created.
  3. Vega node: Call PrepareSubmitOrder. Send the order details. Receive a PreparedOrder object.
  4. Wallet server: Call SignTx. Send the PreparedOrder object and a public key associated with the logged-in wallet. Receive a SignedBundle object.
  5. Vega node: Call SubmitTransaction. Send the SignedBundle object.
import base64, binascii
import vegaapiclient as vac

# Vega node: Create client for trading (e.g. submitting orders)
tradingcli = vac.VegaTradingClient(url)

# Wallet server: Create a walletclient (see above for details)
walletclient = vac.WalletClient(walleturl)
walletclient.login(wallet_name, wallet_passphrase)

myPubKey = "1122aabb..."

# Vega node: Prepare the SubmitOrder
order = vac.grpc.api.trading.SubmitOrderRequest(
    submission=vac.grpc.vega.OrderSubmission(
        marketID='MARKETID',
        partyID=myPubKey,
        # price is an integer. For example 123456 is a price of 1.23456,
        # assuming 5 decimal places.
        price=100000,
        side=vac.grpc.vega.Side.Buy,
        size=100,
        timeInForce=vac.grpc.vega.Order.TimeInForce.GTC,
        type=vac.grpc.vega.Order.Type.LIMIT
    )
)
response = tradingcli.PrepareSubmitOrder(order)

# Wallet server: Sign the prepared transaction
blob_base64 = base64.b64encode(response.blob).decode("ascii")
response = walletclient.signtx(blob_base64, myPubKey)
assert r.status_code == 200
signedTx = response.json()["signedTx"]

# Vega node: Submit the signed transaction
request = vac.grpc.api.trading.SubmitTransactionRequest(
    tx=vac.grpc.vega.SignedBundle(
        data=base64.b64decode(signedTx["data"]),
        sig=base64.b64decode(signedTx["sig"]),
        pubKey=binascii.unhexlify(signedTx["pubKey"])
    )
)
response = tradingcli.SubmitTransaction(request)
assert response.success

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Files for Vega-API-client, version 0.0.13
Filename, size File type Python version Upload date Hashes
Filename, size Vega_API_client-0.0.13-py3-none-any.whl (49.4 kB) File type Wheel Python version py3 Upload date Hashes View
Filename, size Vega API client-0.0.13.tar.gz (39.7 kB) File type Source Python version None Upload date Hashes View

Supported by

Pingdom Pingdom Monitoring Google Google Object Storage and Download Analytics Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN DigiCert DigiCert EV certificate StatusPage StatusPage Status page