# What an order would do

What an order would do now, without placing it: fill or rest, the price, the fee, the margin, the position after.

The whole program, in each language. Set `PHOENIXPERPS_API_KEY` to a sandbox key (`ppk_test_...`) and run it. Nothing is sent to the market.

```typescript
import { PhoenixPerps } from '@phoenixperps/sdk';

const client = new PhoenixPerps();
const [account] = (await client.accounts.list()).data;

const w = await client.orders.preview(account.id, { market: 'BTC-USD', side: 'buy', type: 'market', notional_usd: '1000' });
console.log(`result:         ${w.result}${w.reject ? ` (${JSON.stringify(w.reject)})` : ''}`);
console.log(`size:           ${w.size ?? '-'}`);
console.log(`price:          ${w.execution?.expected_price ?? '-'} (worst ${w.execution?.worst_price ?? '-'})`);
console.log(`notional, fee:  ${w.notional ?? '-'}, ${w.fee ?? '-'}`);
console.log(`margin:         ${w.margin?.required ?? '-'} needed, ${w.margin?.available_after ?? '-'} left after`);
console.log(`position after: ${w.position_after?.side ?? 'flat'} ${w.position_after?.size ?? ''}`);
```

```python
from phoenixperps import PhoenixPerps

client = PhoenixPerps()
account = client.accounts.list().data[0]

w = client.orders.preview(account["id"], {"market": "BTC-USD", "side": "buy", "type": "market", "notional_usd": "1000"})
execution = w.get("execution") or {}
margin = w.get("margin") or {}
after = w.get("position_after") or {}
print(f'result:         {w["result"]}{" (" + str(w["reject"]) + ")" if w.get("reject") else ""}')
print(f'size:           {w.get("size") or "-"}')
print(f'price:          {execution.get("expected_price", "-")} (worst {execution.get("worst_price") or "-"})')
print(f'notional, fee:  {w.get("notional") or "-"}, {w.get("fee") or "-"}')
print(f'margin:         {margin.get("required", "-")} needed, {margin.get("available_after") or "-"} left after')
print(f'position after: {after.get("side") or "flat"} {after.get("size", "")}')
```

```go
package main

import (
	"context"
	"fmt"
	"log"

	phoenixperps "github.com/phoenixperps/sdk/go"
)

func or(d *phoenixperps.Decimal) string {
	if d == nil {
		return "-"
	}
	return string(*d)
}

func main() {
	ctx := context.Background()
	client, err := phoenixperps.NewClient()
	if err != nil {
		log.Fatal(err)
	}
	accounts, err := client.Accounts.List(ctx)
	if err != nil {
		log.Fatal(err)
	}
	w, err := client.Orders.Preview(ctx, accounts.Data[0].ID, phoenixperps.CreateOrder{
		Market:      "BTC-USD",
		Side:        phoenixperps.OrderSideBuy,
		Type:        phoenixperps.CreateOrderTypeMarket,
		NotionalUSD: phoenixperps.Dec("1000"),
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("result:         %s\n", w.Result)
	if w.Reject != nil {
		fmt.Printf("refused:        %+v\n", *w.Reject)
	}
	fmt.Printf("size:           %s\n", or(w.Size))
	if w.Execution != nil {
		fmt.Printf("price:          %s (worst %s)\n", w.Execution.ExpectedPrice, or(w.Execution.WorstPrice))
	}
	fmt.Printf("notional, fee:  %s, %s\n", or(w.Notional), or(w.Fee))
	if w.Margin != nil {
		fmt.Printf("margin:         %s needed, %s left after\n", w.Margin.Required, or(w.Margin.AvailableAfter))
	}
	if w.PositionAfter != nil {
		side := "flat"
		if w.PositionAfter.Side != nil {
			side = string(*w.PositionAfter.Side)
		}
		fmt.Printf("position after: %s %s\n", side, w.PositionAfter.Size)
	}
}
```

```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 account = (await client.Accounts.ListAsync()).Data[0].Id;

var w = await client.Orders.PreviewAsync(account, new CreateOrder
{
    Market = "BTC-USD",
    Side = OrderSide.Buy,
    Type = CreateOrderType.Market,
    NotionalUsd = 1000m,
});
Console.WriteLine($"result:         {w.Result}{(w.Reject is null ? "" : $" ({w.Reject.Code})")}");
Console.WriteLine($"size:           {w.Size?.ToString() ?? "-"}");
Console.WriteLine($"price:          {w.Execution?.ExpectedPrice.ToString() ?? "-"} (worst {w.Execution?.WorstPrice?.ToString() ?? "-"})");
Console.WriteLine($"notional, fee:  {w.Notional?.ToString() ?? "-"}, {w.Fee?.ToString() ?? "-"}");
Console.WriteLine($"margin:         {w.Margin?.Required.ToString() ?? "-"} needed, {w.Margin?.AvailableAfter?.ToString() ?? "-"} left after");
Console.WriteLine($"position after: {w.PositionAfter?.Side?.ToString() ?? "flat"} {w.PositionAfter?.Size}");
```

```java
import com.phoenixperpsfunding.sdk.PhoenixPerpsClient;
import com.phoenixperpsfunding.sdk.gen.CreateOrder;
import com.phoenixperpsfunding.sdk.gen.CreateOrderType;
import com.phoenixperpsfunding.sdk.gen.OrderSide;
import com.phoenixperpsfunding.sdk.gen.WhatIf;
import java.math.BigDecimal;

final class Example07 {
    public static void main(String[] args) {
        PhoenixPerpsClient client = PhoenixPerpsClient.fromEnv();
        String account = client.accounts().list().data().get(0).id();

        WhatIf w = client.orders().preview(account, new CreateOrder()
                .market("BTC-USD")
                .side(OrderSide.BUY)
                .type(CreateOrderType.MARKET)
                .notionalUsd(new BigDecimal("1000")));
        System.out.printf("result:         %s%s%n", w.result(), w.reject() == null ? "" : " (" + w.reject().code() + ")");
        System.out.printf("size:           %s%n", w.size());
        if (w.execution() != null) System.out.printf("price:          %s (worst %s)%n", w.execution().expectedPrice(), w.execution().worstPrice());
        System.out.printf("notional, fee:  %s, %s%n", w.notional(), w.fee());
        if (w.margin() != null) System.out.printf("margin:         %s needed, %s left after%n", w.margin().required(), w.margin().availableAfter());
        if (w.positionAfter() != null) System.out.printf("position after: %s %s%n", w.positionAfter().side() == null ? "flat" : w.positionAfter().side(), w.positionAfter().size());
    }
}
```

```rust
use phoenixperps::{dec, Client, CreateOrder, CreateOrderType, Decimal, OrderSide};

fn or(d: Option<Decimal>) -> String {
    d.map(|d| d.to_string()).unwrap_or_else(|| "-".into())
}

#[tokio::main]
async fn main() -> phoenixperps::Result<()> {
    let client = Client::from_env()?;
    let account = client.accounts().list().await?.data[0].id.clone();

    let w = client
        .orders()
        .preview(&account, &CreateOrder {
            market: "BTC-USD".into(),
            side: OrderSide::Buy,
            r#type: CreateOrderType::Market,
            notional_usd: Some(dec("1000")),
            ..Default::default()
        })
        .await?;
    let refused = w.reject.as_ref().map(|r| format!(" ({})", r.code)).unwrap_or_default();
    println!("result:         {}{refused}", w.result);
    println!("size:           {}", or(w.size));
    if let Some(x) = &w.execution {
        println!("price:          {} (worst {})", x.expected_price, or(x.worst_price));
    }
    println!("notional, fee:  {}, {}", or(w.notional), or(w.fee));
    if let Some(m) = &w.margin {
        println!("margin:         {} needed, {} left after", m.required, or(m.available_after));
    }
    if let Some(p) = &w.position_after {
        let side = p.side.as_ref().map(|s| s.to_string()).unwrap_or_else(|| "flat".into());
        println!("position after: {side} {}", p.size);
    }
    Ok(())
}
```

```php
<?php
require 'vendor/autoload.php';

use PhoenixPerps\Client;

$client = new Client();
$account = $client->accounts->list()->data[0]->id;

$w = $client->orders->preview($account, ['market' => 'BTC-USD', 'side' => 'buy', 'type' => 'market', 'notional_usd' => '1000']);
printf("result:         %s%s\n", $w->result, $w->reject ? " ({$w->reject->code})" : '');
printf("size:           %s\n", $w->size ?? '-');
printf("price:          %s (worst %s)\n", $w->execution?->expectedPrice ?? '-', $w->execution?->worstPrice ?? '-');
printf("notional, fee:  %s, %s\n", $w->notional ?? '-', $w->fee ?? '-');
printf("margin:         %s needed, %s left after\n", $w->margin?->required ?? '-', $w->margin?->availableAfter ?? '-');
printf("position after: %s %s\n", $w->positionAfter?->side ?? 'flat', $w->positionAfter?->size ?? '');
```
