# 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.

```typescript
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();
```

```python
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())
```

```go
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
	}
}
```

```csharp
#: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;
}
```

```java
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;
            }
        }
    }
}
```

```rust
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
<?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();
```
