Cookbook
Place and cancel a limit order.
A limit order far from the market, found again by your own id, then canceled.
The whole program, in each language. Set PHOENIXPERPS_API_KEY to a sandbox key (ppk_test_...) and run it. The Idempotency-Key makes a retried request return the first order instead of placing a second one.
import { randomUUID } from 'node:crypto';
import { MarketRules, PhoenixPerps } from '@phoenixperps/sdk';
const client = new PhoenixPerps();
if (client.environment === 'live' && process.env.PHOENIXPERPS_ALLOW_LIVE !== 'yes') {
console.error('This example trades: it runs on the sandbox (PHOENIXPERPS_ALLOW_LIVE=yes to run it on live).');
process.exit(1);
}
const [account] = (await client.accounts.list()).data;
const rules = new MarketRules(await client.markets.get('BTC-USD'));
const market = client.marketStream();
const tick = new Promise<{ bid: string }>((resolve) => market.once('ticker', (f) => resolve(f.data)));
await market.subscribe('ticker', ['BTC-USD']);
const { bid } = await tick;
market.close();
const clientOrderId = `example-04-${Date.now()}`;
const order = await client.orders.create(account.id, {
market: 'BTC-USD',
side: 'buy',
type: 'limit',
size: rules.sizeForNotional('100', bid), // about 100 USD
limit_price: rules.roundPrice(Number(bid) * 0.9, 'down'), // 10% below: it rests
client_order_id: clientOrderId,
}, { idempotencyKey: randomUUID() });
console.log(`placed ${order.id}: ${order.status}, ${order.size} at ${order.limit_price}`);
const found = (await client.orders.list(account.id, { client_order_id: clientOrderId })).data[0];
console.log(`found by client_order_id: ${found.id}`);
const canceled = await client.orders.cancel(account.id, order.id);
console.log(`canceled: ${canceled.status} (${canceled.cancel_reason})`);import asyncio
import os
import time
import uuid
from decimal import Decimal
from phoenixperps import MarketRules, PhoenixPerps
client = PhoenixPerps()
if client.environment == "live" and os.environ.get("PHOENIXPERPS_ALLOW_LIVE") != "yes":
raise SystemExit("This example trades: it runs on the sandbox (PHOENIXPERPS_ALLOW_LIVE=yes to run it on live).")
account = client.accounts.list().data[0]
rules = MarketRules(client.markets.get("BTC-USD"))
async def best_bid() -> str:
async with client.market_stream() as market:
await market.subscribe("ticker", ["BTC-USD"])
async for frame in market:
if frame["type"] == "ticker":
return frame["data"]["bid"]
raise RuntimeError("the market stream ended")
bid = asyncio.run(best_bid())
client_order_id = f"example-04-{int(time.time() * 1000)}"
order = client.orders.create(account["id"], {
"market": "BTC-USD",
"side": "buy",
"type": "limit",
"size": rules.size_for_notional("100", bid), # about 100 USD
"limit_price": rules.round_price(Decimal(bid) * Decimal("0.9"), "down"), # 10% below: it rests
"client_order_id": client_order_id,
}, idempotency_key=str(uuid.uuid4()))
print(f'placed {order["id"]}: {order["status"]}, {order["size"]} at {order["limit_price"]}')
found = client.orders.list(account["id"], {"client_order_id": client_order_id}).data[0]
print(f'found by client_order_id: {found["id"]}')
canceled = client.orders.cancel(account["id"], order["id"])
print(f'canceled: {canceled["status"]} ({canceled["cancel_reason"]})')package main
import (
"context"
"crypto/rand"
"encoding/json"
"fmt"
"log"
"math/big"
"os"
"time"
phoenixperps "github.com/phoenixperps/sdk/go"
)
func main() {
ctx := context.Background()
client, err := phoenixperps.NewClient()
if err != nil {
log.Fatal(err)
}
if client.Environment() == "live" && os.Getenv("PHOENIXPERPS_ALLOW_LIVE") != "yes" {
log.Fatal("This example trades: it runs on the sandbox (PHOENIXPERPS_ALLOW_LIVE=yes to run it on live).")
}
accounts, err := client.Accounts.List(ctx)
if err != nil {
log.Fatal(err)
}
account := accounts.Data[0].ID
btc, err := client.Markets.Get(ctx, "BTC-USD")
if err != nil {
log.Fatal(err)
}
rules := phoenixperps.NewMarketRules(btc)
bid := bestBid(ctx, client)
size, err := rules.SizeForNotional("100", bid) // about 100 USD
if err != nil {
log.Fatal(err)
}
b, _ := new(big.Rat).SetString(string(bid))
limit, err := rules.RoundPrice(phoenixperps.Decimal(b.Mul(b, big.NewRat(9, 10)).FloatString(8)), phoenixperps.RoundDown) // 10% below: it rests
if err != nil {
log.Fatal(err)
}
clientOrderID := fmt.Sprintf("example-04-%d", time.Now().UnixMilli())
order, err := client.Orders.Create(ctx, account, phoenixperps.CreateOrder{
Market: "BTC-USD",
Side: phoenixperps.OrderSideBuy,
Type: phoenixperps.CreateOrderTypeLimit,
Size: &size,
LimitPrice: &limit,
ClientOrderID: phoenixperps.Ptr(clientOrderID),
}, phoenixperps.WithIdempotencyKey(newKey()))
if err != nil {
log.Fatal(err)
}
fmt.Printf("placed %s: %s, %s at %s\n", order.ID, order.Status, size, limit)
found, err := client.Orders.List(ctx, account, &phoenixperps.OrdersListParams{ClientOrderID: phoenixperps.Ptr(clientOrderID)})
if err != nil {
log.Fatal(err)
}
fmt.Printf("found by client_order_id: %s\n", found.Data[0].ID)
canceled, err := client.Orders.Cancel(ctx, account, order.ID)
if err != nil {
log.Fatal(err)
}
fmt.Printf("canceled: %s\n", canceled.Status)
}
// bestBid is the market's bid now, from the market stream.
func bestBid(ctx context.Context, client *phoenixperps.Client) phoenixperps.Decimal {
stream := client.MarketStream(ctx)
defer stream.Close()
if _, err := stream.Subscribe(ctx, "ticker", []string{"BTC-USD"}, nil); err != nil {
log.Fatal(err)
}
for {
f, err := stream.Next(ctx)
if err != nil {
log.Fatal(err)
}
var q struct{ Bid phoenixperps.Decimal }
if f.Type == "ticker" && json.Unmarshal(f.Data, &q) == nil {
return q.Bid
}
}
}
func newKey() string {
b := make([]byte, 16)
_, _ = rand.Read(b)
return fmt.Sprintf("%x", b)
}#:package PhoenixPerps.Sdk@1.0.0
using System.Globalization;
using PhoenixPerps;
CultureInfo.CurrentCulture = CultureInfo.InvariantCulture; // decimals print as 0.0001 on every machine
using var client = new PhoenixPerpsClient();
if (client.Environment == "live" && Environment.GetEnvironmentVariable("PHOENIXPERPS_ALLOW_LIVE") != "yes")
{
Console.Error.WriteLine("This example trades: it runs on the sandbox (PHOENIXPERPS_ALLOW_LIVE=yes to run it on live).");
return 1;
}
var account = (await client.Accounts.ListAsync()).Data[0].Id;
var rules = new MarketRules(await client.Markets.GetAsync("BTC-USD"));
decimal bid;
await using (var market = client.OpenMarketStream())
{
await market.SubscribeAsync("ticker", new[] { "BTC-USD" });
while (true)
{
var f = await market.ReadAsync();
if (f.Type == "ticker" && f.Data is { } q)
{
bid = decimal.Parse(q.GetProperty("bid").GetString()!, CultureInfo.InvariantCulture);
break;
}
}
}
var clientOrderId = $"example-04-{DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}";
var order = await client.Orders.CreateAsync(account, new CreateOrder
{
Market = "BTC-USD",
Side = OrderSide.Buy,
Type = CreateOrderType.Limit,
Size = rules.SizeForNotional(100m, bid), // about 100 USD
LimitPrice = rules.RoundPrice(bid * 0.9m, RoundMode.Down), // 10% below: it rests
ClientOrderId = clientOrderId,
}, new RequestOptions { IdempotencyKey = Guid.NewGuid().ToString() });
Console.WriteLine($"placed {order.Id}: {order.Status}, {order.Size} at {order.LimitPrice}");
var found = (await client.Orders.ListAsync(account, new OrdersListParams { ClientOrderId = clientOrderId })).Data[0];
Console.WriteLine($"found by client_order_id: {found.Id}");
var canceled = await client.Orders.CancelAsync(account, order.Id);
Console.WriteLine($"canceled: {canceled.Status} ({canceled.CancelReason})");
return 0;import com.phoenixperpsfunding.sdk.MarketRules;
import com.phoenixperpsfunding.sdk.MarketStream;
import com.phoenixperpsfunding.sdk.PhoenixPerpsClient;
import com.phoenixperpsfunding.sdk.RequestOptions;
import com.phoenixperpsfunding.sdk.gen.CreateOrder;
import com.phoenixperpsfunding.sdk.gen.CreateOrderType;
import com.phoenixperpsfunding.sdk.gen.Order;
import com.phoenixperpsfunding.sdk.gen.OrderSide;
import com.phoenixperpsfunding.sdk.gen.OrdersListParams;
import java.math.BigDecimal;
import java.time.Duration;
import java.util.List;
import java.util.Map;
import java.util.UUID;
final class Example04 {
public static void main(String[] args) {
PhoenixPerpsClient client = PhoenixPerpsClient.fromEnv();
if ("live".equals(client.environment()) && !"yes".equals(System.getenv("PHOENIXPERPS_ALLOW_LIVE"))) {
System.err.println("This example trades: it runs on the sandbox (PHOENIXPERPS_ALLOW_LIVE=yes to run it on live).");
System.exit(1);
}
String account = client.accounts().list().data().get(0).id();
MarketRules rules = new MarketRules(client.markets().get("BTC-USD"));
BigDecimal bid = null;
try (MarketStream market = client.openMarketStream()) {
market.subscribe("ticker", List.of("BTC-USD"), Map.of(), Duration.ofSeconds(10));
for (MarketStream.Frame f : market) {
if ("ticker".equals(f.type())) {
bid = new BigDecimal(f.data().path("bid").asText());
break;
}
}
}
if (bid == null) throw new IllegalStateException("no price");
String clientOrderId = "example-04-" + System.currentTimeMillis();
Order order = client.orders().create(account, new CreateOrder()
.market("BTC-USD")
.side(OrderSide.BUY)
.type(CreateOrderType.LIMIT)
.size(rules.sizeForNotional(new BigDecimal("100"), bid)) // about 100 USD
.limitPrice(rules.roundPrice(bid.multiply(new BigDecimal("0.9")), MarketRules.Mode.DOWN)) // 10% below: it rests
.clientOrderId(clientOrderId),
RequestOptions.none().withIdempotencyKey(UUID.randomUUID().toString()));
System.out.printf("placed %s: %s, %s at %s%n", order.id(), order.status(), order.size(), order.limitPrice());
Order found = client.orders().list(account, new OrdersListParams().clientOrderId(clientOrderId)).data().get(0);
System.out.printf("found by client_order_id: %s%n", found.id());
Order canceled = client.orders().cancel(account, order.id());
System.out.printf("canceled: %s (%s)%n", canceled.status(), canceled.cancelReason());
}
}use std::time::{SystemTime, UNIX_EPOCH};
use phoenixperps::{dec, Client, CreateOrder, CreateOrderType, Decimal, MarketRules, OrderSide, OrdersListParams, RequestOptions, RoundMode};
use serde_json::Map;
#[tokio::main]
async fn main() -> phoenixperps::Result<()> {
let client = Client::from_env()?;
if client.environment() == "live" && std::env::var("PHOENIXPERPS_ALLOW_LIVE").as_deref() != Ok("yes") {
eprintln!("This example trades: it runs on the sandbox (PHOENIXPERPS_ALLOW_LIVE=yes to run it on live).");
std::process::exit(1);
}
let account = client.accounts().list().await?.data[0].id.clone();
let rules = MarketRules::new(&client.markets().get("BTC-USD").await?);
let mut market = client.market_stream();
market.subscribe("ticker", &["BTC-USD"], Map::new()).await?;
let mut bid = Decimal::ZERO;
while let Some(frame) = market.next().await {
let frame = frame?;
if let (true, Some(q)) = (frame.r#type == "ticker", frame.data) {
bid = dec(q["bid"].as_str().unwrap_or("0"));
break;
}
}
drop(market);
let millis = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_millis()).unwrap_or_default();
let client_order_id = format!("example-04-{millis}");
let size = rules.size_for_notional(dec("100"), bid).expect("a price"); // about 100 USD
let limit = rules.round_price(bid * dec("0.9"), RoundMode::Down).expect("a price"); // 10% below: it rests
let body = CreateOrder {
market: "BTC-USD".into(),
side: OrderSide::Buy,
r#type: CreateOrderType::Limit,
size: Some(size),
limit_price: Some(limit),
client_order_id: Some(client_order_id.clone()),
..Default::default()
};
let options = RequestOptions { idempotency_key: Some(uuid::Uuid::new_v4().to_string()), ..Default::default() };
let order = client.orders().create_with(&account, &body, &options).await?;
println!("placed {}: {}, {size} at {limit}", order.id, order.status);
let params = OrdersListParams { client_order_id: Some(client_order_id), ..Default::default() };
let found = client.orders().list(&account, Some(¶ms)).await?;
println!("found by client_order_id: {}", found.data[0].id);
let canceled = client.orders().cancel(&account, &order.id).await?;
println!("canceled: {}", canceled.status);
Ok(())
}<?php
require 'vendor/autoload.php';
use PhoenixPerps\Client;
use PhoenixPerps\MarketRules;
use PhoenixPerps\RequestOptions;
$client = new Client();
if ($client->environment === 'live' && getenv('PHOENIXPERPS_ALLOW_LIVE') !== 'yes') {
fwrite(STDERR, "This example trades: it runs on the sandbox (PHOENIXPERPS_ALLOW_LIVE=yes to run it on live).\n");
exit(1);
}
$account = $client->accounts->list()->data[0]->id;
$rules = new MarketRules($client->markets->get('BTC-USD'));
$market = $client->marketStream();
$market->subscribe('ticker', ['BTC-USD']);
$bid = null;
foreach ($market as $f) {
if ($f['type'] === 'ticker') {
$bid = $f['data']['bid'];
break;
}
}
$market->close();
$clientOrderId = 'example-04-' . (int) (microtime(true) * 1000);
$order = $client->orders->create($account, [
'market' => 'BTC-USD',
'side' => 'buy',
'type' => 'limit',
'size' => $rules->sizeForNotional('100', $bid), // about 100 USD
'limit_price' => $rules->roundPrice(bcmul($bid, '0.9', 8), MarketRules::DOWN), // 10% below: it rests
'client_order_id' => $clientOrderId,
], new RequestOptions(idempotencyKey: bin2hex(random_bytes(16))));
printf("placed %s: %s, %s at %s\n", $order->id, $order->status, $order->size, $order->limitPrice);
$found = $client->orders->list($account, ['client_order_id' => $clientOrderId])->data[0];
printf("found by client_order_id: %s\n", $found->id);
$canceled = $client->orders->cancel($account, $order->id);
printf("canceled: %s (%s)\n", $canceled->status, $canceled->cancelReason);