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

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

```python
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"]})')
```

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

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

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

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