Build with Derive.

import { DeriveClient } from '@derivexyz/derive-ts';

const client = new DeriveClient({
  network: 'mainnet',
  wallet: PRIVATE_KEY
});
await client.connect();
await client.login();

const { order } = await client.orders.place({
  subaccountId: 9,
  instrumentName: 'ETH-PERP',
  direction: 'buy',
  orderType: 'limit',
  limitPrice: '3100',
  amount: '1',
});

import asyncio
from decimal import Decimal

from derive_py import WebSocketClient
from derive_py.data_types import Direction, OrderType


async def main():
    client = WebSocketClient.from_env()
    await client.connect()

    response = await client.orders.create(
        instrument_name="ETH-PERP",
        direction=Direction.buy,
        order_type=OrderType.limit,
        limit_price=Decimal("3100"),
        amount=Decimal("1"),
    )
    print(response.order.order_id)
    await client.disconnect()


asyncio.run(main())

use bigdecimal::BigDecimal;
use derive_rs::{Environment, WsClient, actions::OrderArgs};
use derive_rs::models::{Direction, OrderType, TimeInForce};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = WsClient::new(
        Environment::Mainnet,
        Some(std::env::var("DERIVE_PRIVATE_KEY")?),
        Some(std::env::var("DERIVE_WALLET")?),
        Some(9),
    )
    .await?;
    client.login().await?;

    let order = OrderArgs::builder()
        .instrument_name("ETH-PERP".to_string())
        .direction(Direction::Buy)
        .order_type(OrderType::Limit)
        .time_in_force(TimeInForce::Gtc)
        .limit_price(BigDecimal::from(3100))
        .amount(BigDecimal::from(1))
        .build();

    let response = client.orders().place(order).await?;
    println!("{}", response.order.order_id);
    Ok(())
}