Clients & SDKs

import { ClobClient, OrderType, Side, SignatureType } from '@kuestcom/clob-client'
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { polygonAmoy } from 'viem/chains'

const host = process.env.CLOB_URL!
const chainId = 80002
const tokenID = process.env.CLOB_TOKEN_ID!
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)
const signer = createWalletClient({
  account,
  chain: polygonAmoy,
  transport: http(process.env.RPC_URL),
})

const bootstrap = new ClobClient(host, chainId, signer)
const creds = await bootstrap.createOrDeriveApiKey()
const client = new ClobClient(
  host,
  chainId,
  signer,
  creds,
  SignatureType.DEPOSIT_WALLET,
  process.env.DEPOSIT_WALLET!,
)

const tickSize = await client.getTickSize(tokenID)
const negRisk = await client.getNegRisk(tokenID)
const result = await client.createAndPostOrder(
  { tokenID, price: 0.42, size: 5, side: Side.BUY },
  { tickSize, negRisk },
  OrderType.GTC,
  false,
  true,
)

console.log(result)

import os

from py_clob_client.client import ClobClient
from py_clob_client.clob_types import OrderArgs, OrderType, PartialCreateOrderOptions
from py_clob_client.order_builder.constants import BUY

client = ClobClient(
    os.environ["CLOB_URL"],
    chain_id=80002,
    key=os.environ["PRIVATE_KEY"],
    signature_type=3,
    funder=os.environ["DEPOSIT_WALLET"],
)
client.set_api_creds(client.create_or_derive_api_creds())

token_id = os.environ["CLOB_TOKEN_ID"]
order = client.create_order(
    OrderArgs(token_id=token_id, price=0.42, size=5, side=BUY),
    options=PartialCreateOrderOptions(
        tick_size=client.get_tick_size(token_id),
        neg_risk=client.get_neg_risk(token_id),
    ),
)

print(client.post_order(order, OrderType.GTC))

[dependencies]
kuest-client-sdk = { version = "2", features = ["clob"] }
rust_decimal = "1"
rust_decimal_macros = "1"
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

use std::str::FromStr as _;

use alloy::signers::{local::LocalSigner, Signer as _};
use kuest_client_sdk::clob::types::{OrderType, Side, SignatureType};
use kuest_client_sdk::clob::{Client, Config};
use kuest_client_sdk::types::{Address, U256};
use kuest_client_sdk::AMOY;
use rust_decimal::Decimal;
use rust_decimal_macros::dec;

#[tokio::main]
async fn main() -> kuest_client_sdk::Result<()> {
    let signer = LocalSigner::from_str(&std::env::var("PRIVATE_KEY")?)?
        .with_chain_id(Some(AMOY));
    let funder = Address::from_str(&std::env::var("DEPOSIT_WALLET")?)?;
    let token_id = U256::from_str(&std::env::var("CLOB_TOKEN_ID")?)?;
    let clob_url = std::env::var("CLOB_URL")?;

    let client = Client::new(&clob_url, Config::default())?
        .authentication_builder(&signer)
        .signature_type(SignatureType::DepositWallet)
        .funder(funder)
        .authenticate()
        .await?;

    let order = client.limit_order()
        .token_id(token_id)
        .side(Side::Buy)
        .price(dec!(0.42))
        .size(Decimal::new(5, 0))
        .order_type(OrderType::GTC)
        .build()
        .await?;

    let result = client.post_order(client.sign(&signer, order).await?).await?;
    println!("{result:?}");
    Ok(())
}