Trading & Orders

Overview

The OrderClient handles order creation, EIP-712 signing, and order management. It supports Good-Til-Cancelled (GTC), Fill-And-Kill (FAK), and Fill-or-Kill (FOK) orders.

Prerequisites

Before placing orders, you need three components:

import (
    "context"
    "log"
    "os"

    limitless "github.com/limitless-labs-group/limitless-exchange-go-sdk/limitless"
)

client := limitless.NewHttpClient(
    limitless.WithHMACCredentials(limitless.HMACCredentials{
        TokenID: os.Getenv("LMTS_TOKEN_ID"),
        Secret:  os.Getenv("LMTS_TOKEN_SECRET"),
    }),
)
marketFetcher := limitless.NewMarketFetcher(client)

orderClient, err := limitless.NewOrderClient(
    client,
    "0xYOUR_PRIVATE_KEY",  // hex-encoded private key (with or without "0x" prefix)
)
if err != nil {
    log.Fatal(err)
}

Component	Purpose
`HttpClient`	Authenticated HTTP client for API requests
`MarketFetcher`	Fetches market data and caches venue addresses
`OrderClient`	Creates, signs, and submits orders

The OrderClient lazily fetches your user profile on the first order to determine your fee rate. The CHAIN_ID environment variable defaults to 8453 (Base mainnet).

Wallet-mode preflight. Accepting the one-time “choose your trading wallet” prompt in the app enables 1-click (smart wallet) trading on your Limitless profile. Once that mode is set, self-signed orders are rejected with Signer does not match - you should use embedded address for smart wallet. Switch the profile to EOA trading mode first: see Trading wallet mode.

Token approvals

Before your first trade on a given venue, you must approve the exchange contracts to spend your tokens. This is a one-time on-chain setup per venue.

Standard CLOB
NegRisk

For standard CLOB markets, approve USDC and Conditional Tokens to the exchange contract:

market, _ := marketFetcher.GetMarket(ctx, "your-market-slug")
exchange := market.Venue.Exchange

// Use go-ethereum or any Ethereum client to send approval transactions:
// 1. Approve USDC (0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913) to the exchange for BUY orders
// 2. Approve Conditional Tokens (0xC9c98965297Bc527861c898329Ee280632B76e18) to the exchange for SELL orders

For NegRisk markets, you must additionally approve the adapter contract:

market, _ := marketFetcher.GetMarket(ctx, "your-negrisk-slug")
exchange := market.Venue.Exchange
adapter := *market.Venue.Adapter

// 1. Approve USDC to the exchange (same as CLOB)
// 2. Approve Conditional Tokens to the exchange (same as CLOB)
// 3. Approve Conditional Tokens to the adapter (NegRisk only)

Approvals are on-chain transactions that cost gas. You only need to perform them once per venue. Use Venue.Exchange for both CLOB and NegRisk, and additionally Venue.Adapter for NegRisk markets.

GTC orders (Good-Til-Cancelled)

GTC orders remain on the orderbook until filled or explicitly cancelled. Specify Price (0.0–1.0, tick-aligned to 0.001) and Size (number of shares):

ctx := context.Background()
market, err := marketFetcher.GetMarket(ctx, "btc-above-100k-march-2025")
if err != nil {
    log.Fatal(err)
}

result, err := orderClient.CreateOrder(ctx, limitless.CreateOrderParams{
    OrderType:  limitless.OrderTypeGTC,
    MarketSlug: "btc-above-100k-march-2025",
    Args: limitless.GTCOrderArgs{
        TokenID: market.Tokens.Yes,
        Side:    limitless.SideBuy,
        Price:   0.65,
        Size:    10.0,
    },
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Order placed: %+v\n", result.Order)

Post-only GTC order

Use PostOnly: true to ensure your order is never filled immediately as a taker. If the order would cross the spread (i.e., match against existing orders), it is rejected instead. This guarantees you always receive maker fees.

result, err := orderClient.CreateOrder(ctx, limitless.CreateOrderParams{
    OrderType:  limitless.OrderTypeGTC,
    MarketSlug: "btc-above-100k-march-2025",
    Args: limitless.GTCOrderArgs{
        TokenID:  market.Tokens.Yes,
        Side:     limitless.SideBuy,
        Price:    0.65,
        Size:     10.0,
        PostOnly: true,
    },
})

GTCOrderArgs

Field	Type	Description
`TokenID`	`string`	Token ID from `Market.Tokens.Yes` or `Market.Tokens.No`
`Side`	`Side`	`SideBuy` (0) or `SideSell` (1)
`Price`	`float64`	Price per share (0.0–1.0, must be tick-aligned to 0.001)
`Size`	`float64`	Number of shares to buy or sell
`PostOnly`	`bool`	Optional. When `true`, rejects the order if it would immediately match. Default `false`.
`Expiration`	`string`	Must be `"0"` (the default). Non-zero expiration is not currently supported and is rejected by the API.
`Nonce`	`*int`	Must be `0` (the default when `nil`). Non-zero nonce is not currently supported and is rejected by the API.
`Taker`	`string`	Optional taker address (defaults to zero address)

Self-trade prevention

Set StpPolicy on CreateOrderParams to control what happens when your incoming order would match your own resting order on the same token. It is a top-level request field — not part of the EIP-712 signed order args — and applies to any order type. Leave it empty to keep the server default, cancel_maker.

result, err := orderClient.CreateOrder(ctx, limitless.CreateOrderParams{
    OrderType:  limitless.OrderTypeGTC,
    MarketSlug: "btc-above-100k-march-2025",
    StpPolicy:  "cancel_maker", // "cancel_maker" | "cancel_taker" | "cancel_both"
    Args: limitless.GTCOrderArgs{
        TokenID: market.Tokens.Yes,
        Side:    limitless.SideBuy,
        Price:   0.65,
        Size:    10.0,
    },
})

Value	Result
`cancel_maker`	Default. Cancels your conflicting resting order and continues with the incoming order.
`cancel_taker`	Rejects the incoming order before it self-trades.
`cancel_both`	Cancels your conflicting resting order and rejects the incoming order.

The create-order response carries an Execution field with the outcome:

if result.Execution.SettlementStatus == "CANCELED" && result.Execution.Reason == "STP_TAKER_REJECTED" {
    fmt.Println("Order rejected by self-trade prevention")
} else if len(result.Execution.StpMakerCancels) > 0 {
    fmt.Printf("Cancelled own resting orders: %v\n", result.Execution.StpMakerCancels)
}

`Execution` field	Type	Description
`SettlementStatus`	`string`	`CANCELED` when a `cancel_taker` / `cancel_both` order is rejected.
`Reason`	`string`	`STP_TAKER_REJECTED` when the incoming order was rejected.
`StpMakerCancels`	`[]string`	Resting order ids cancelled by `cancel_maker` / `cancel_both`.

Self-trade prevention blocks same-profile matches on the same token only. Orders on a different token of the same profile are unaffected. The wire field is always stpPolicy, regardless of the SDK.

FAK orders (Fill-And-Kill)

FAK orders use the same Price and Size inputs as GTC, but they only consume immediately available liquidity and cancel any unmatched remainder. PostOnly is not supported for FAK orders.

result, err := orderClient.CreateOrder(ctx, limitless.CreateOrderParams{
    OrderType:  limitless.OrderTypeFAK,
    MarketSlug: "btc-above-100k-march-2025",
    Args: limitless.FAKOrderArgs{
        TokenID: market.Tokens.Yes,
        Side:    limitless.SideBuy,
        Price:   0.45,
        Size:    10.0,
    },
})
if err != nil {
    log.Fatal(err)
}

if len(result.MakerMatches) > 0 {
    fmt.Printf("FAK order matched immediately with %d fill(s)\n", len(result.MakerMatches))
} else {
    fmt.Println("FAK remainder was cancelled.")
}

FAKOrderArgs

Field	Type	Description
`TokenID`	`string`	Token ID from `Market.Tokens.Yes` or `Market.Tokens.No`
`Side`	`Side`	`SideBuy` (0) or `SideSell` (1)
`Price`	`float64`	Price per share (0.0–1.0, must be tick-aligned to 0.001)
`Size`	`float64`	Number of shares to buy or sell
`Expiration`	`string`	Must be `"0"` (the default). Non-zero expiration is not currently supported and is rejected by the API.
`Nonce`	`*int`	Must be `0` (the default when `nil`). Non-zero nonce is not currently supported and is rejected by the API.
`Taker`	`string`	Optional taker address (defaults to zero address)

FOK orders (Fill-or-Kill)

FOK orders execute immediately and fully, or are rejected entirely. Instead of Price and Size, you specify MakerAmount:

FOK BUY
FOK SELL

When buying, MakerAmount is the total USDC you want to spend (max 6 decimal places). The exchange fills as many shares as possible at the best available price:

result, err := orderClient.CreateOrder(ctx, limitless.CreateOrderParams{
    OrderType:  limitless.OrderTypeFOK,
    MarketSlug: "btc-above-100k-march-2025",
    Args: limitless.FOKOrderArgs{
        TokenID:     market.Tokens.Yes,
        Side:        limitless.SideBuy,
        MakerAmount: 10.0, // spend 10 USDC
    },
})

When selling, MakerAmount is the number of shares to sell. The exchange returns USDC at the best available price:

result, err := orderClient.CreateOrder(ctx, limitless.CreateOrderParams{
    OrderType:  limitless.OrderTypeFOK,
    MarketSlug: "btc-above-100k-march-2025",
    Args: limitless.FOKOrderArgs{
        TokenID:     market.Tokens.Yes,
        Side:        limitless.SideSell,
        MakerAmount: 10.0, // sell 10 shares
    },
})

FOKOrderArgs

Field	Type	Description
`TokenID`	`string`	Token ID from `Market.Tokens.Yes` or `Market.Tokens.No`
`Side`	`Side`	`SideBuy` (0) or `SideSell` (1)
`MakerAmount`	`float64`	USDC to spend (buy) or shares to sell (sell), max 6 decimal places
`Expiration`	`string`	Must be `"0"` (the default). Non-zero expiration is not currently supported and is rejected by the API.
`Nonce`	`*int`	Must be `0` (the default when `nil`). Non-zero nonce is not currently supported and is rejected by the API.
`Taker`	`string`	Optional taker address (defaults to zero address)

Advanced: Build and sign separately

For advanced use cases, you can build and sign orders without submitting them:

// Build an unsigned order
unsigned, err := orderClient.BuildUnsignedOrder(ctx, limitless.GTCOrderArgs{
    TokenID: market.Tokens.Yes,
    Side:    limitless.SideBuy,
    Price:   0.65,
    Size:    10.0,
})
if err != nil {
    log.Fatal(err)
}

// Sign the order
signature, err := orderClient.SignOrder(unsigned)
if err != nil {
    log.Fatal(err)
}
fmt.Println("Signature:", signature)

AMM trading

CLOB orders trade against the orderbook. AMM (FPMM) markets trade against a pool, and the SDK exposes them through sdk.AMM. The service calls POST /amm/allowances/check, POST /amm/allowances/approve, POST /amm/buy, and POST /amm/sell on behalf of a partner server wallet. Use it when the market is an AMM market and you want the server to hold custody, sign the trade, and pay gas. See AMM Trading (Server Wallets) for the underlying endpoints and market model.

Requirements

Authenticate with an HMAC API token that holds both the trading and delegated_signing scopes, or call the *WithIdentity variants with a Privy identity token. Legacy x-api-key credentials are rejected.
The trade runs against a server-wallet sub-account. Set OnBehalfOf to the sub-account profile ID (1..=2147483647), or omit it (zero value) to trade from the authenticated profile.
Amounts are positive integer strings in the collateral token’s base units (for USDC: "1000000" = 1 USDC). Never use float64.
SlippageBps is optional (*int). nil uses the server default of 100 (1%); values range from 0 to 1000.
OutcomeIndex is AMMOutcomeYes (0) or AMMOutcomeNo (1).

One-time approval per wallet and market

BUY and SELL approvals are independent and set up once per wallet and market. Buy and Sell do not preflight allowances themselves. Confirm the allowance first. EnsureAllowance runs CheckAllowance, submits ApproveAllowance at most once when missing, then polls the check until Confirmed is true. Polling defaults to every two seconds; use the context timeout to bound how long it waits.

marketSlug := "btc-100k-weekly"
childProfileID := 12345

for _, side := range []limitless.AMMAllowanceSide{
    limitless.AMMAllowanceSideBuy,
    limitless.AMMAllowanceSideSell,
} {
    allowanceCtx, cancel := context.WithTimeout(ctx, 2*time.Minute)
    _, err := sdk.AMM.EnsureAllowance(allowanceCtx, limitless.AMMAllowanceParams{
        Market:     marketSlug,
        Side:       side,
        OnBehalfOf: childProfileID,
    })
    cancel()
    if err != nil {
        return err
    }
}

A submitted response from ApproveAllowance (HTTP 202) is not confirmation. Either use EnsureAllowance, or poll CheckAllowance until Confirmed is true.

Buy shares

Buy spends an exact collateral amount on the chosen outcome. Pass a unique IdempotencyKey per trade. On a timeout retry, reuse the same immutable params value so the serialized body and idempotency key stay byte-identical.

slippageBps := 100
buyParams := limitless.AMMBuyParams{
    Market:           marketSlug,
    OutcomeIndex:     limitless.AMMOutcomeYes,
    CollateralAmount: "1000000", // 1 USDC in base units
    SlippageBps:      &slippageBps,
    IdempotencyKey:   "buy-unique-key-001",
    OnBehalfOf:       childProfileID,
}

buy, err := sdk.AMM.Buy(ctx, buyParams)
if err != nil {
    return err
}
fmt.Println(buy.Status, buy.ExpectedShares, buy.MinShares)

Sell shares

Sell requests an exact collateral return by selling outcome shares.

sellParams := limitless.AMMSellParams{
    Market:                 marketSlug,
    OutcomeIndex:           limitless.AMMOutcomeYes,
    CollateralReturnAmount: "992015",
    IdempotencyKey:         "sell-unique-key-001",
    OnBehalfOf:             childProfileID,
}

sell, err := sdk.AMM.Sell(ctx, sellParams)
if err != nil {
    return err
}
fmt.Println(sell.Status, sell.ExpectedShares, sell.MaxShares)

Reusing an IdempotencyKey with different params raises ConflictError (HTTP 409). The four AMM routes share a rate limit of 10 requests / 10 seconds per actor. Use the *WithRawResponse variants (e.g. sdk.AMM.BuyWithRawResponse) when you need the underlying HTTP status and headers.

Cancelling orders

Cancel a single order
Cancel all orders on a market

Cancel a specific order by its ID:

msg, err := orderClient.Cancel(ctx, "abc123-def456")
if err != nil {
    log.Fatal(err)
}
fmt.Println(msg)

Cancel every open order you have on a given market:

msg, err := orderClient.CancelAll(ctx, "btc-above-100k-march-2025")
if err != nil {
    log.Fatal(err)
}
fmt.Println(msg)

Cancel and replace

CancelReplace cancels one open order and submits a replacement in the same request. Use it to reprice or resize a resting order in one round-trip instead of separate cancel and create calls. CancelReplaceBatch runs several of these operations in a single call. The cancel and the replacement are not atomic: they report independent outcomes, and a successful cancel does not guarantee a successful replacement. Choose the failure mode with CancelReplaceMode:

Mode	Cancellation fails	Replacement result
`CancelReplaceStopOnFailure`	Stops the operation	`NOT_ATTEMPTED`
`CancelReplaceAllowFailure`	Continues the operation	`SUCCESS`, `FAILURE`, or `UNKNOWN` independently

Identify the order to cancel with CancelByOrderID or CancelByClientOrderID. The replacement is a normal signed order and uses the same OrderArgs fields as CreateOrder.

Single cancel-replace

result, err := orderClient.CancelReplace(ctx, limitless.CancelReplaceParams{
    Cancel: limitless.CancelByOrderID("order_abc123"),
    Mode:   limitless.CancelReplaceStopOnFailure,
    Replacement: limitless.CancelReplaceOrderParams{
        MarketSlug: market.Slug,
        OrderType:  limitless.OrderTypeGTC,
        Args: limitless.OrderArgs{
            TokenID: market.Tokens.Yes,
            Side:    limitless.SideBuy,
            Price:   0.62,
            Size:    100,
        },
    },
})
if err != nil {
    log.Fatal(err)
}

if result.Cancel.Status() == limitless.CancelReplaceCancelSuccess {
    if data, ok := result.Cancel.Success(); ok {
        fmt.Println("Cancelled:", data.OrderID)
    }
}
if result.Replacement.Status() == limitless.CancelReplaceReplacementSuccess {
    if data, ok := result.Replacement.Success(); ok {
        fmt.Println("Replacement placed:", data.Order.ID)
    }
}

Batch cancel-replace

Each operation runs independently and its result is returned with the caller’s Index:

batch, err := orderClient.CancelReplaceBatch(ctx, []limitless.CancelReplaceParams{
    {
        Cancel: limitless.CancelByOrderID("order_abc123"),
        Mode:   limitless.CancelReplaceAllowFailure,
        Replacement: limitless.CancelReplaceOrderParams{
            MarketSlug: market.Slug,
            OrderType:  limitless.OrderTypeGTC,
            Args:       limitless.OrderArgs{TokenID: market.Tokens.Yes, Side: limitless.SideBuy, Price: 0.62, Size: 100},
        },
    },
    {
        Cancel: limitless.CancelByClientOrderID("my-tag-42"),
        Mode:   limitless.CancelReplaceStopOnFailure,
        Replacement: limitless.CancelReplaceOrderParams{
            MarketSlug: market.Slug,
            OrderType:  limitless.OrderTypeGTC,
            Args:       limitless.OrderArgs{TokenID: market.Tokens.No, Side: limitless.SideSell, Price: 0.41, Size: 50},
        },
    },
})
if err != nil {
    log.Fatal(err)
}

for _, item := range batch.Results {
    fmt.Println(item.Index, item.Cancel.Status(), item.Replacement.Status())
}

Delegated cancel-replace

Partners with the delegated_signing scope call delegatedOrders.CancelReplace and delegatedOrders.CancelReplaceBatch. The server signs the replacement using the sub-account’s managed wallet, so no signing key is required. Set OnBehalfOf (the sub-account profile ID) on every operation:

_, err := delegatedOrders.CancelReplace(ctx, limitless.DelegatedCancelReplaceParams{
    Cancel:     limitless.CancelByOrderID("order_abc123"),
    Mode:       limitless.CancelReplaceStopOnFailure,
    OnBehalfOf: partnerAccount.ProfileID,
    Replacement: limitless.CancelReplaceOrderParams{
        MarketSlug: market.Slug,
        OrderType:  limitless.OrderTypeGTC,
        Args:       limitless.OrderArgs{TokenID: market.Tokens.Yes, Side: limitless.SideBuy, Price: 0.62, Size: 100},
    },
})

See POST /orders/cancel-replace and POST /orders/cancel-replace/batch for the full request and response shapes, per-status fields, and failure semantics.

Enums reference

Side

Constant	Value	Description
`SideBuy`	`0`	Buy shares with USDC
`SideSell`	`1`	Sell shares for USDC

OrderType

Constant	Value	Description
`OrderTypeGTC`	`"GTC"`	Good-Til-Cancelled limit order (rests on the book)
`OrderTypeFAK`	`"FAK"`	Fill-And-Kill limit order (cancels any unmatched remainder)
`OrderTypeFOK`	`"FOK"`	Fill-or-Kill market order (fills immediately or rejects)

Error handling

The SDK returns typed errors for order failures. Use errors.As() to inspect them:

import "errors"

result, err := orderClient.CreateOrder(ctx, params)
if err != nil {
    var apiErr *limitless.APIError
    if errors.As(err, &apiErr) {
        fmt.Printf("Order failed — status %d: %s\n", apiErr.Status, apiErr.Message)
    }

    var validErr *limitless.OrderValidationError
    if errors.As(err, &validErr) {
        fmt.Printf("Validation error on field %s: %s\n", validErr.Field, validErr.Message)
    }
}

See Error Handling & Retry for details on error types and the WithRetry function.

Complete example

package main

import (
    "context"
    "errors"
    "fmt"
    "log"
    "os"

    limitless "github.com/limitless-labs-group/limitless-exchange-go-sdk/limitless"
)

func main() {
    client := limitless.NewHttpClient(
        limitless.WithHMACCredentials(limitless.HMACCredentials{
            TokenID: os.Getenv("LMTS_TOKEN_ID"),
            Secret:  os.Getenv("LMTS_TOKEN_SECRET"),
        }),
    )
    marketFetcher := limitless.NewMarketFetcher(client)
    ctx := context.Background()

    orderClient, err := limitless.NewOrderClient(client, "0xYOUR_PRIVATE_KEY")
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Wallet:", orderClient.WalletAddress())

    // Fetch market (caches venue automatically)
    market, err := marketFetcher.GetMarket(ctx, "btc-above-100k-march-2025")
    if err != nil {
        log.Fatal(err)
    }

    // Place a GTC BUY order for 10 YES shares at $0.65
    result, err := orderClient.CreateOrder(ctx, limitless.CreateOrderParams{
        OrderType:  limitless.OrderTypeGTC,
        MarketSlug: "btc-above-100k-march-2025",
        Args: limitless.GTCOrderArgs{
            TokenID: market.Tokens.Yes,
            Side:    limitless.SideBuy,
            Price:   0.65,
            Size:    10.0,
        },
    })
    if err != nil {
        var apiErr *limitless.APIError
        if errors.As(err, &apiErr) {
            log.Fatalf("API error — status %d: %s", apiErr.Status, apiErr.Message)
        }
        log.Fatal(err)
    }
    fmt.Printf("GTC order placed: %+v\n", result.Order)

    // Place a FAK BUY order for 10 YES shares at $0.45
    fakResult, err := orderClient.CreateOrder(ctx, limitless.CreateOrderParams{
        OrderType:  limitless.OrderTypeFAK,
        MarketSlug: "btc-above-100k-march-2025",
        Args: limitless.FAKOrderArgs{
            TokenID: market.Tokens.Yes,
            Side:    limitless.SideBuy,
            Price:   0.45,
            Size:    10.0,
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("FAK order placed: %+v\n", fakResult.Order)

    // Place a FOK BUY order spending 5 USDC
    fokResult, err := orderClient.CreateOrder(ctx, limitless.CreateOrderParams{
        OrderType:  limitless.OrderTypeFOK,
        MarketSlug: "btc-above-100k-march-2025",
        Args: limitless.FOKOrderArgs{
            TokenID:     market.Tokens.Yes,
            Side:        limitless.SideBuy,
            MakerAmount: 5.0,
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("FOK order placed: %+v\n", fokResult.Order)

    // Cancel all orders on this market
    msg, err := orderClient.CancelAll(ctx, "btc-above-100k-march-2025")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Cancelled:", msg)
}

Getting Started

Quick Start

TypeScript SDK

Python SDK

Go SDK

Rust SDK

WebSocket

Overview

Prerequisites

Token approvals

GTC orders (Good-Til-Cancelled)

Post-only GTC order

GTCOrderArgs

Self-trade prevention

FAK orders (Fill-And-Kill)

FAKOrderArgs

FOK orders (Fill-or-Kill)

FOKOrderArgs

Advanced: Build and sign separately

AMM trading

Requirements

One-time approval per wallet and market

Buy shares

Sell shares

Cancelling orders

Cancel and replace

Single cancel-replace

Batch cancel-replace

Delegated cancel-replace

Enums reference

Side

OrderType

Error handling

Complete example

​Overview

​Prerequisites

​Token approvals

​GTC orders (Good-Til-Cancelled)

​Post-only GTC order

​GTCOrderArgs

​Self-trade prevention

​FAK orders (Fill-And-Kill)

​FAKOrderArgs

​FOK orders (Fill-or-Kill)

​FOKOrderArgs

​Advanced: Build and sign separately

​AMM trading

​Requirements

​One-time approval per wallet and market

​Buy shares

​Sell shares

​Cancelling orders

​Cancel and replace

​Single cancel-replace

​Batch cancel-replace

​Delegated cancel-replace

​Enums reference

​Side

​OrderType

​Error handling

​Complete example

Overview

Prerequisites

Token approvals

GTC orders (Good-Til-Cancelled)

Post-only GTC order

GTCOrderArgs

Self-trade prevention

FAK orders (Fill-And-Kill)

FAKOrderArgs

FOK orders (Fill-or-Kill)

FOKOrderArgs

Advanced: Build and sign separately

AMM trading

Requirements

One-time approval per wallet and market

Buy shares

Sell shares

Cancelling orders

Cancel and replace

Single cancel-replace

Batch cancel-replace

Delegated cancel-replace

Enums reference

Side

OrderType

Error handling

Complete example