Cookbook
Markets and a quote.
The markets and their rules, then a quote (bid, ask, last) from the market stream.
The whole program, in each language. Set PHOENIXPERPS_API_KEY to a sandbox key (ppk_test_...) and run it.
import { PhoenixPerps } from '@phoenixperps/sdk';
const client = new PhoenixPerps();
const symbol = (process.argv[2] ?? 'BTC-USD').toUpperCase();
const { data } = await client.markets.list();
for (const m of data) console.log(`${m.market.padEnd(10)} tick ${m.tick_size} step ${m.size_step} min ${m.min_size} up to ${m.max_leverage}x ${m.status}`);
const market = client.marketStream();
const quote = new Promise<{ bid: string; ask: string; last: string }>((resolve) => market.once('ticker', (f) => resolve(f.data)));
const reply = await market.subscribe('ticker', [symbol], { interval_ms: 250 });
if (reply.rejected.length) throw new Error(`${symbol}: ${reply.rejected[0].code}`);
const q = await quote;
console.log(`${symbol}: bid ${q.bid} ask ${q.ask} last ${q.last}`);
market.close();import asyncio
import sys
from phoenixperps import PhoenixPerps
client = PhoenixPerps()
symbol = (sys.argv[1] if len(sys.argv) > 1 else "BTC-USD").upper()
for m in client.markets.list().data:
print(f'{m["market"]:<10} tick {m["tick_size"]} step {m["size_step"]} min {m["min_size"]} up to {m["max_leverage"]}x {m["status"]}')
async def quote() -> None:
async with client.market_stream() as market:
reply = await market.subscribe("ticker", [symbol], interval_ms=250)
if reply["rejected"]:
raise SystemExit(f'{symbol}: {reply["rejected"][0]["code"]}')
async for frame in market:
if frame["type"] == "ticker":
q = frame["data"]
print(f'{symbol}: bid {q["bid"]} ask {q["ask"]} last {q["last"]}')
return
asyncio.run(quote())package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
"strings"
phoenixperps "github.com/phoenixperps/sdk/go"
)
func main() {
ctx := context.Background()
client, err := phoenixperps.NewClient()
if err != nil {
log.Fatal(err)
}
symbol := "BTC-USD"
if len(os.Args) > 1 {
symbol = strings.ToUpper(os.Args[1])
}
markets, err := client.Markets.List(ctx)
if err != nil {
log.Fatal(err)
}
for _, m := range markets.Data {
fmt.Printf("%-10s tick %s step %s min %s up to %dx %s\n", m.Market, m.TickSize, m.SizeStep, m.MinSize, m.MaxLeverage, m.Status)
}
stream := client.MarketStream(ctx)
defer stream.Close()
reply, err := stream.Subscribe(ctx, "ticker", []string{symbol}, map[string]any{"interval_ms": 250})
if err != nil {
log.Fatal(err)
}
var sub struct {
Rejected []struct{ Symbol, Code string }
}
_ = json.Unmarshal(reply, &sub)
if len(sub.Rejected) > 0 {
log.Fatalf("%s: %s", symbol, sub.Rejected[0].Code)
}
for {
f, err := stream.Next(ctx)
if err != nil {
log.Fatal(err)
}
if f.Type != "ticker" {
continue
}
var q struct{ Bid, Ask, Last string }
if err := json.Unmarshal(f.Data, &q); err != nil {
log.Fatal(err)
}
fmt.Printf("%s: bid %s ask %s last %s\n", symbol, q.Bid, q.Ask, q.Last)
return
}
}#: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();
var symbol = (args.Length > 0 ? args[0] : "BTC-USD").ToUpperInvariant();
foreach (var m in (await client.Markets.ListAsync()).Data)
Console.WriteLine($"{m.Value,-10} tick {m.TickSize} step {m.SizeStep} min {m.MinSize} up to {m.MaxLeverage}x {m.Status}");
await using var market = client.OpenMarketStream();
var reply = await market.SubscribeAsync("ticker", new[] { symbol }, new Dictionary<string, object?> { ["interval_ms"] = 250 });
if (reply.GetProperty("rejected").GetArrayLength() > 0)
throw new InvalidOperationException($"{symbol}: {reply.GetProperty("rejected")[0].GetProperty("code")}");
await foreach (var frame in market.ReadAllAsync())
{
if (frame.Type != "ticker" || frame.Data is not { } q) continue;
Console.WriteLine($"{symbol}: bid {q.GetProperty("bid")} ask {q.GetProperty("ask")} last {q.GetProperty("last")}");
break;
}import com.fasterxml.jackson.databind.JsonNode;
import com.phoenixperpsfunding.sdk.MarketStream;
import com.phoenixperpsfunding.sdk.PhoenixPerpsClient;
import com.phoenixperpsfunding.sdk.gen.Market;
import java.time.Duration;
import java.util.List;
import java.util.Locale;
import java.util.Map;
final class Example02 {
public static void main(String[] args) {
PhoenixPerpsClient client = PhoenixPerpsClient.fromEnv();
String symbol = (args.length > 0 ? args[0] : "BTC-USD").toUpperCase(Locale.ROOT);
for (Market m : client.markets().list().data()) {
System.out.printf("%-10s tick %s step %s min %s up to %dx %s%n", m.market(), m.tickSize().toPlainString(), m.sizeStep().toPlainString(), m.minSize().toPlainString(), m.maxLeverage(), m.status());
}
try (MarketStream market = client.openMarketStream()) {
JsonNode reply = market.subscribe("ticker", List.of(symbol), Map.of("interval_ms", 250), Duration.ofSeconds(10));
if (!reply.path("rejected").isEmpty()) throw new IllegalStateException(symbol + ": " + reply.path("rejected").get(0).path("code").asText());
for (MarketStream.Frame f : market) {
if (!"ticker".equals(f.type())) continue;
System.out.printf("%s: bid %s ask %s last %s%n", symbol, f.data().path("bid").asText(), f.data().path("ask").asText(), f.data().path("last").asText());
break;
}
}
}
}use phoenixperps::Client;
use serde_json::{json, Map};
#[tokio::main]
async fn main() -> phoenixperps::Result<()> {
let client = Client::from_env()?;
let symbol = std::env::args().nth(1).unwrap_or_else(|| "BTC-USD".into()).to_uppercase();
for m in &client.markets().list().await?.data {
println!("{:<10} tick {} step {} min {} up to {}x {}", m.market, m.tick_size, m.size_step, m.min_size, m.max_leverage, m.status);
}
let mut market = client.market_stream();
let mut params = Map::new();
params.insert("interval_ms".into(), json!(250));
let reply = market.subscribe("ticker", &[symbol.as_str()], params).await?;
if let Some(r) = reply["rejected"].as_array().and_then(|r| r.first()) {
eprintln!("{symbol}: {}", r["code"]);
std::process::exit(1);
}
while let Some(frame) = market.next().await {
let frame = frame?;
if let (true, Some(q)) = (frame.r#type == "ticker", frame.data) {
println!("{symbol}: bid {} ask {} last {}", q["bid"], q["ask"], q["last"]);
break;
}
}
Ok(())
}<?php
require 'vendor/autoload.php';
use PhoenixPerps\Client;
$client = new Client();
$symbol = strtoupper($argv[1] ?? 'BTC-USD');
foreach ($client->markets->list()->data as $m) {
printf("%-10s tick %s step %s min %s up to %dx %s\n", $m->market, $m->tickSize, $m->sizeStep, $m->minSize, $m->maxLeverage, $m->status);
}
$market = $client->marketStream();
$reply = $market->subscribe('ticker', [$symbol], ['interval_ms' => 250]);
if (!empty($reply['rejected'])) {
fwrite(STDERR, "{$symbol}: {$reply['rejected'][0]['code']}\n");
exit(1);
}
foreach ($market as $frame) {
if ($frame['type'] !== 'ticker') {
continue;
}
$q = $frame['data'];
printf("%s: bid %s ask %s last %s\n", $symbol, $q['bid'], $q['ask'], $q['last']);
break;
}
$market->close();