Quickstart

import { PolyesterClient, POLYESTER_TESTNET_ENVIRONMENT, evmHexToBytes } from "@polyester/sdk";

const SYMBOL = "BTC-USDT";
const PRICE = "60000"; // example value: set it below the best bid
const QTY = "0.001";

const client = new PolyesterClient({
	environment: POLYESTER_TESTNET_ENVIRONMENT,
	auth: {
		kind: "api-key-ed25519",
		getKeyId: () => process.env.POLYESTER_API_KEY_ID ?? null,
		getSecretKey: () => evmHexToBytes(`0x${process.env.POLYESTER_API_PRIVATE_KEY}`),
	},
});

// 1. The Pair's trading rules
await client.catalog.ensureReady();
const symbolId = client.catalog.market.requireSymbolIdByPairSymbol(SYMBOL);
const { status, tickSize, stepSize, minQtyBase, minNotionalQuote } =
	client.catalog.orders.getSpotOrderConstraints(SYMBOL);
console.log({ status, tickSize, stepSize, minQtyBase, minNotionalQuote });

// 2. Place a post-only limit buy
const created = await client.orders.create({
	symbolId,
	side: "buy",
	qty: QTY,
	execution: { type: "limit_gtc", price: PRICE, postOnly: true },
});
console.log("created", created.orderId);

// 3. Read it back, then cancel it
await new Promise((resolve) => setTimeout(resolve, 1000));
const details = await client.orders.getDetails({
	orderId: created.orderId,
	includeExecutionHistory: false,
});
console.log("status", details?.order.status);
await client.orders.cancel({ orderId: created.orderId, symbolId });

import asyncio
import os

from polyester import AsyncPolyester, POLYESTER_TESTNET_ENVIRONMENT
from polyester.models import OrderId

SYMBOL = "BTC-USDT"
PRICE = "60000"  # example value: set it below the best bid
QTY = "0.001"


async def main() -> None:
    async with AsyncPolyester(
        environment=POLYESTER_TESTNET_ENVIRONMENT,
        api_key_id=os.environ["POLYESTER_API_KEY_ID"],
        api_private_key=os.environ["POLYESTER_API_PRIVATE_KEY"],
    ) as client:
        await client.wait_for_catalogs()

        # 1. The Pair's trading rules
        config = await client.market_data.get_spot_config()
        pair = next(p for p in config.raw["pairs"] if p["symbol"] == SYMBOL)
        rules = ("status", "tickSize", "stepSize", "minQtyBase", "minNotionalQuote")
        print({rule: pair[rule] for rule in rules})

        # 2. Place a post-only limit buy
        created = await client.orders.create(
            symbol=SYMBOL, side="buy", order_type="limit", tif="gtc",
            qty=QTY, price=PRICE, post_only=True,
        )
        print("created", created.order_id)

        # 3. Read it back, then cancel it
        await asyncio.sleep(1)
        key = OrderId(created.order_id)
        details = await client.orders.get(key=key, include_execution_history=False)
        print("status", details.order.status if details.order else None)
        await client.orders.cancel(key=key, symbol=SYMBOL)


asyncio.run(main())

package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"time"

	polyester "github.com/Fabric-Labs/polyester-sdk-go"
	"github.com/Fabric-Labs/polyester-sdk-go/models"
)

const (
	symbol     = "BTC-USDT"
	limitPrice = "60000" // example value: set it below the best bid
	qty        = "0.001"
)

func main() {
	check := func(err error) {
		if err != nil {
			log.Fatal(err)
		}
	}
	ctx := context.Background()
	client, err := polyester.New(polyester.Config{
		Environment:     &polyester.TestnetEnvironment,
		APIKeyID:        os.Getenv("POLYESTER_API_KEY_ID"),
		APIPrivateKey:   os.Getenv("POLYESTER_API_PRIVATE_KEY"),
		HydrateCatalogs: true,
	})
	check(err)
	defer client.Close()
	check(client.WaitForCatalogs(ctx))

	// 1. The Pair's trading rules
	cfg, err := client.MarketData.GetSpotConfig(ctx)
	check(err)
	for _, p := range cfg.Pairs {
		if p.Symbol == symbol {
			fmt.Println(p.Status, p.TickSize, p.StepSize, p.MinQtyBase, p.MinNotionalQuote)
		}
	}

	// 2. Place a post-only limit buy
	sym, tif := symbol, "gtc"
	price := models.PriceFromDecimal(limitPrice)
	created, err := client.Orders.Create(ctx, models.CreateOrderRequest{
		Symbol: &sym, Side: "buy", OrderType: "limit", TIF: &tif,
		Qty: models.QtyFromDecimal(qty), Price: &price, PostOnly: true,
	}, nil)
	check(err)
	fmt.Println("created", created.OrderID)

	// 3. Read it back, then cancel it
	time.Sleep(time.Second)
	key := models.OrderKeyByID(created.OrderID)
	details, err := client.Orders.Get(ctx, nil, key, nil, false, false)
	check(err)
	if details.Order != nil {
		fmt.Println("status", details.Order.Status)
	}
	_, err = client.Orders.Cancel(ctx, nil, key, &sym, nil, nil)
	check(err)
}

use std::time::Duration;

use polyester::models::{
    CreateOrderParams, CreateOrderType, CreateSide, CreateTimeInForce, OrderKey,
};
use polyester::{Client, Config, Error, Price, Quantity};

const SYMBOL: &str = "BTC-USDT";
const PRICE: &str = "60000"; // example value: set it below the best bid
const QTY: &str = "0.001";

#[tokio::main]
async fn main() -> polyester::Result<()> {
    let client = Client::new(Config {
        environment: Some(polyester::POLYESTER_TESTNET_ENVIRONMENT.clone()),
        api_key_id: std::env::var("POLYESTER_API_KEY_ID").ok(),
        api_private_key: std::env::var("POLYESTER_API_PRIVATE_KEY").ok(),
        ..Default::default()
    })?;
    client.wait_for_catalogs().await?;

    // 1. The Pair's trading rules
    let config = client.market_data.get_spot_config().await?;
    for p in config.raw["pairs"].as_array().into_iter().flatten() {
        if p["symbol"] == SYMBOL {
            for rule in ["status", "tickSize", "stepSize", "minQtyBase", "minNotionalQuote"] {
                println!("{rule}: {}", p[rule]);
            }
        }
    }

    // 2. Place a post-only limit buy
    let scale = client
        .catalogs
        .base_quantity_scale_for_symbol(SYMBOL)
        .ok_or_else(|| Error::validation("unknown symbol"))?;
    let mut order = CreateOrderParams::new(SYMBOL, CreateSide::Buy, CreateOrderType::Limit);
    order.quantity = Some(Quantity::from_decimal_str(QTY, scale, None, None)?);
    order.price = Some(Price::from_decimal_str(PRICE, None)?);
    order.time_in_force = Some(CreateTimeInForce::Gtc);
    order.post_only = Some(true);
    let created = client.orders.create(order).await?;
    println!("created {}", created.order_id);

    // 3. Read it back, then cancel it
    tokio::time::sleep(Duration::from_secs(1)).await;
    let key = OrderKey::OrderId(created.order_id.clone());
    let details = client.orders.get(key, None).await?;
    println!("status {:?}", details.order.map(|o| o.status));
    client.orders.cancel_by_order_id(&created.order_id, None).await?;
    Ok(())
}