@sentico-labs/sdk 0.1.0-preview.1

package/dist/src/http.d.ts

@@ -0,0 +1,88 @@
+import type { ApiResponse, HexAddress, MarketCandlesOptions, MarketOrderbookOptions, MarketTradesOptions, NonceReservationOptions, NormalizedSenticoreSdkConfig, PrivateWsTokenOptions, RateLimitInfo, RequestOptions, SenticoreSdkConfig, WsSessionTokenResponse } from "./types.js";
+export declare class SenticoreHttpTransport {
+    readonly config: NormalizedSenticoreSdkConfig;
+    constructor(config: SenticoreSdkConfig | NormalizedSenticoreSdkConfig);
+    request<T = unknown>(method: string, baseUrl: string, path: string, options?: RequestOptions & {
+        query?: Record<string, string | number | boolean | undefined>;
+        body?: unknown;
+        content?: BodyInit;
+    }): Promise<ApiResponse<T>>;
+    private headers;
+    private toApiResponse;
+    private url;
+    private sleepBeforeRetry;
+}
+export declare class SenticorePublicHttpClient {
+    private readonly transport;
+    constructor(transport: SenticoreHttpTransport);
+    listMarkets(): Promise<ApiResponse<unknown>>;
+    getMarket(marketId: number): Promise<ApiResponse<unknown>>;
+    getMarketOracle(marketId: number): Promise<ApiResponse<unknown>>;
+    getMarketSnapshot(marketId: number, options?: {
+        depth?: number;
+        limit?: number;
+    }): Promise<ApiResponse<unknown>>;
+    getMarketOrderbook(marketId: number, options?: MarketOrderbookOptions): Promise<ApiResponse<unknown>>;
+    listMarketTrades(marketId: number, options?: MarketTradesOptions): Promise<ApiResponse<unknown>>;
+    getMarketCandles(marketId: number, options?: MarketCandlesOptions): Promise<ApiResponse<unknown>>;
+    getMarketTicker(marketId: number): Promise<ApiResponse<unknown>>;
+    listTickers(): Promise<ApiResponse<unknown>>;
+    getTime(): Promise<ApiResponse<unknown>>;
+    getStatus(): Promise<ApiResponse<unknown>>;
+    private get;
+}
+export declare class SenticoreTradingHttpClient {
+    private readonly transport;
+    constructor(transport: SenticoreHttpTransport);
+    getAccount(account: HexAddress, options?: RequestOptions): Promise<ApiResponse<unknown>>;
+    getAccountBalances(account: HexAddress, options?: RequestOptions): Promise<ApiResponse<unknown>>;
+    getAccountPositions(account: HexAddress, options?: RequestOptions): Promise<ApiResponse<unknown>>;
+    getAccountOrders(account: HexAddress, options?: RequestOptions & {
+        limit?: number;
+    }): Promise<ApiResponse<unknown>>;
+    getAccountFills(account: HexAddress, options?: RequestOptions & {
+        limit?: number;
+    }): Promise<ApiResponse<unknown>>;
+    issuePrivateWsToken(account: HexAddress, options?: RequestOptions & PrivateWsTokenOptions): Promise<ApiResponse<WsSessionTokenResponse>>;
+    reserveNonce(account: HexAddress, options?: NonceReservationOptions): Promise<ApiResponse<unknown>>;
+    getActionSigningHash(payload: unknown, options?: RequestOptions): Promise<ApiResponse<unknown>>;
+    submitSignedAction(payload: unknown, options?: RequestOptions): Promise<ApiResponse<unknown>>;
+    placeOrder(order: unknown, options?: RequestOptions): Promise<ApiResponse<unknown>>;
+    submitOrderBatch(batch: unknown, options?: RequestOptions): Promise<ApiResponse<unknown>>;
+    cancelOrder(orderId: string, options?: RequestOptions): Promise<ApiResponse<unknown>>;
+    private get;
+    private post;
+}
+export declare class SenticoreRawHttpClient {
+    private readonly transport;
+    constructor(transport: SenticoreHttpTransport);
+    request<T = unknown>(method: string, path: string, options?: RequestOptions & {
+        baseUrl?: string;
+        query?: Record<string, string | number | boolean | undefined>;
+        body?: unknown;
+        content?: BodyInit;
+    }): Promise<ApiResponse<T>>;
+}
+export declare class SenticoreHttpClient {
+    private readonly publicClient;
+    private readonly tradingClient;
+    constructor(config: SenticoreSdkConfig);
+    getMarkets(): Promise<unknown>;
+    getMarket(marketId: number): Promise<unknown>;
+    getTickers(): Promise<unknown>;
+    getMarketTicker(marketId: number): Promise<unknown>;
+    getMarketOrderbook(marketId: number, options?: MarketOrderbookOptions): Promise<unknown>;
+    getMarketTrades(marketId: number, options?: MarketTradesOptions): Promise<unknown>;
+    getMarketCandles(marketId: number, options?: MarketCandlesOptions): Promise<unknown>;
+    getAccount(account: HexAddress, bearerToken: string): Promise<unknown>;
+    getAccountBalances(account: HexAddress, bearerToken: string): Promise<unknown>;
+    getAccountPositions(account: HexAddress, bearerToken: string): Promise<unknown>;
+    issuePrivateWsToken(account: HexAddress, bearerToken: string, options?: PrivateWsTokenOptions): Promise<WsSessionTokenResponse>;
+    submitSignedAction(payload: unknown, bearerToken?: string): Promise<unknown>;
+    getActionSigningHash(payload: unknown, bearerToken?: string): Promise<unknown>;
+    reserveNonce(account: HexAddress, payload: {
+        count?: number;
+        ttlMs?: number;
+    }, bearerToken?: string): Promise<unknown>;
+}
+export declare function rateLimitFromHeaders(headers: Headers): RateLimitInfo | undefined;

package/dist/src/http.js

@@ -0,0 +1,313 @@
+import { normalizeConfig } from "./config.js";
+import { apiErrorFromStatus, requestIdFromHeaders, SenticoreApiError, TransportError } from "./errors.js";
+export class SenticoreHttpTransport {
+    config;
+    constructor(config) {
+        this.config = normalizeConfig(config);
+    }
+    async request(method, baseUrl, path, options = {}) {
+        const methodUpper = method.toUpperCase();
+        const retry = options.retry ?? (methodUpper === "GET" || Boolean(options.idempotencyKey));
+        const attempts = retry ? this.config.maxRetries + 1 : 1;
+        const url = this.url(baseUrl, path, options.query);
+        let lastError;
+        for (let attempt = 0; attempt < attempts; attempt += 1) {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
+            try {
+                const response = await this.config.fetch(url, {
+                    method: methodUpper,
+                    headers: this.headers(options),
+                    body: options.content ?? (options.body === undefined ? undefined : JSON.stringify(options.body)),
+                    signal: controller.signal
+                });
+                clearTimeout(timeout);
+                if (shouldRetry(response.status) && attempt + 1 < attempts) {
+                    await this.sleepBeforeRetry(attempt, response);
+                    continue;
+                }
+                return await this.toApiResponse(response);
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                if (error instanceof SenticoreApiError) {
+                    throw error;
+                }
+                lastError = error;
+                if (attempt + 1 >= attempts) {
+                    throw new TransportError(error instanceof Error ? error.message : "request failed", error);
+                }
+                await this.sleepBeforeRetry(attempt);
+            }
+        }
+        throw new TransportError("request failed", lastError);
+    }
+    headers(options) {
+        const headers = new Headers({
+            accept: "application/json",
+            "user-agent": this.config.userAgent,
+            ...this.config.headers,
+            ...options.headers
+        });
+        const token = options.bearerToken ?? this.config.bearerToken;
+        if (token) {
+            headers.set("authorization", token.startsWith("Bearer ") ? token : `Bearer ${token}`);
+        }
+        if (options.idempotencyKey) {
+            headers.set("idempotency-key", options.idempotencyKey);
+        }
+        return headers;
+    }
+    async toApiResponse(response) {
+        const data = (await decodeBody(response));
+        if (!response.ok) {
+            throw apiErrorFromStatus(response, data);
+        }
+        return {
+            data,
+            status: response.status,
+            headers: response.headers,
+            requestId: requestIdFromHeaders(response.headers),
+            rateLimit: rateLimitFromHeaders(response.headers)
+        };
+    }
+    url(baseUrl, path, query) {
+        const url = new URL(path, `${baseUrl}/`);
+        for (const [key, value] of Object.entries(query ?? {})) {
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        }
+        return url.toString();
+    }
+    async sleepBeforeRetry(attempt, response) {
+        const retryAfter = response?.headers.get("retry-after");
+        const parsedRetryAfter = retryAfter ? Number(retryAfter) : undefined;
+        const ms = parsedRetryAfter && Number.isFinite(parsedRetryAfter)
+            ? parsedRetryAfter * 1000
+            : this.config.retryBackoffMs * 2 ** attempt;
+        if (ms > 0)
+            await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+export class SenticorePublicHttpClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    listMarkets() {
+        return this.get("/api/v1/public/markets");
+    }
+    getMarket(marketId) {
+        return this.get(`/api/v1/public/markets/${marketId}`);
+    }
+    getMarketOracle(marketId) {
+        return this.get(`/api/v1/public/markets/${marketId}/oracle`);
+    }
+    getMarketSnapshot(marketId, options = {}) {
+        return this.get(`/api/v1/public/markets/${marketId}/snapshot`, options);
+    }
+    getMarketOrderbook(marketId, options = {}) {
+        return this.get(`/api/v1/public/markets/${marketId}/orderbook`, {
+            book: options.book,
+            depth: options.depth
+        });
+    }
+    listMarketTrades(marketId, options = {}) {
+        return this.get(`/api/v1/public/markets/${marketId}/trades`, {
+            limit: options.limit
+        });
+    }
+    getMarketCandles(marketId, options = {}) {
+        return this.get(`/api/v1/public/markets/${marketId}/candles`, {
+            tf: options.tf,
+            beforeTs: options.beforeTs,
+            countBack: options.countBack
+        });
+    }
+    getMarketTicker(marketId) {
+        return this.get(`/api/v1/public/markets/${marketId}/ticker`);
+    }
+    listTickers() {
+        return this.get("/api/v1/public/tickers");
+    }
+    getTime() {
+        return this.get("/api/v1/public/time");
+    }
+    getStatus() {
+        return this.get("/api/v1/public/status");
+    }
+    get(path, query) {
+        return this.transport.request("GET", this.transport.config.publicHttpBaseUrl, path, { query });
+    }
+}
+export class SenticoreTradingHttpClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    getAccount(account, options = {}) {
+        return this.get(`/api/v1/accounts/${account}`, options);
+    }
+    getAccountBalances(account, options = {}) {
+        return this.get(`/api/v1/accounts/${account}/balances`, options);
+    }
+    getAccountPositions(account, options = {}) {
+        return this.get(`/api/v1/accounts/${account}/positions`, options);
+    }
+    getAccountOrders(account, options = {}) {
+        return this.get(`/api/v1/accounts/${account}/orders`, options, { limit: options.limit });
+    }
+    getAccountFills(account, options = {}) {
+        return this.get(`/api/v1/accounts/${account}/fills`, options, { limit: options.limit });
+    }
+    issuePrivateWsToken(account, options = {}) {
+        return this.post("/api/v1/ws/token", {
+            account,
+            ttlMs: options.ttlMs,
+            clientId: options.clientId
+        }, options);
+    }
+    reserveNonce(account, options = {}) {
+        return this.post(`/api/v1/trading/nonce-reservations/${account}`, {
+            count: options.count ?? 1,
+            ttlMs: options.ttlMs ?? 30_000
+        }, options);
+    }
+    getActionSigningHash(payload, options = {}) {
+        return this.post("/api/v1/trading/actions/hash", payload, options);
+    }
+    submitSignedAction(payload, options = {}) {
+        return this.post("/api/v1/trading/actions", payload, options);
+    }
+    placeOrder(order, options = {}) {
+        return this.post("/api/v1/trading/orders", order, options);
+    }
+    submitOrderBatch(batch, options = {}) {
+        return this.post("/api/v1/trading/orders/batch", batch, options);
+    }
+    cancelOrder(orderId, options = {}) {
+        return this.transport.request("DELETE", this.transport.config.tradingHttpBaseUrl, `/api/v1/trading/orders/${orderId}`, options);
+    }
+    get(path, options, query) {
+        return this.transport.request("GET", this.transport.config.tradingHttpBaseUrl, path, {
+            ...options,
+            query
+        });
+    }
+    post(path, body, options) {
+        return this.transport.request("POST", this.transport.config.tradingHttpBaseUrl, path, {
+            ...options,
+            body: dropUndefined(body),
+            retry: options.retry ?? Boolean(options.idempotencyKey)
+        });
+    }
+}
+export class SenticoreRawHttpClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    request(method, path, options = {}) {
+        return this.transport.request(method, options.baseUrl ?? this.transport.config.tradingHttpBaseUrl, path, options);
+    }
+}
+export class SenticoreHttpClient {
+    publicClient;
+    tradingClient;
+    constructor(config) {
+        const transport = new SenticoreHttpTransport(config);
+        this.publicClient = new SenticorePublicHttpClient(transport);
+        this.tradingClient = new SenticoreTradingHttpClient(transport);
+    }
+    async getMarkets() {
+        return (await this.publicClient.listMarkets()).data;
+    }
+    async getMarket(marketId) {
+        return (await this.publicClient.getMarket(marketId)).data;
+    }
+    async getTickers() {
+        return (await this.publicClient.listTickers()).data;
+    }
+    async getMarketTicker(marketId) {
+        return (await this.publicClient.getMarketTicker(marketId)).data;
+    }
+    async getMarketOrderbook(marketId, options) {
+        return (await this.publicClient.getMarketOrderbook(marketId, options)).data;
+    }
+    async getMarketTrades(marketId, options) {
+        return (await this.publicClient.listMarketTrades(marketId, options)).data;
+    }
+    async getMarketCandles(marketId, options) {
+        return (await this.publicClient.getMarketCandles(marketId, options)).data;
+    }
+    async getAccount(account, bearerToken) {
+        return (await this.tradingClient.getAccount(account, { bearerToken })).data;
+    }
+    async getAccountBalances(account, bearerToken) {
+        return (await this.tradingClient.getAccountBalances(account, { bearerToken })).data;
+    }
+    async getAccountPositions(account, bearerToken) {
+        return (await this.tradingClient.getAccountPositions(account, { bearerToken })).data;
+    }
+    async issuePrivateWsToken(account, bearerToken, options) {
+        return (await this.tradingClient.issuePrivateWsToken(account, {
+            ...options,
+            bearerToken
+        })).data;
+    }
+    async submitSignedAction(payload, bearerToken) {
+        return (await this.tradingClient.submitSignedAction(payload, { bearerToken })).data;
+    }
+    async getActionSigningHash(payload, bearerToken) {
+        return (await this.tradingClient.getActionSigningHash(payload, { bearerToken })).data;
+    }
+    async reserveNonce(account, payload, bearerToken) {
+        return (await this.tradingClient.reserveNonce(account, {
+            count: payload.count,
+            ttlMs: payload.ttlMs,
+            bearerToken
+        })).data;
+    }
+}
+export function rateLimitFromHeaders(headers) {
+    const raw = {};
+    for (const [key, value] of headers.entries()) {
+        const lower = key.toLowerCase();
+        if (lower.startsWith("x-ratelimit") || lower === "retry-after") {
+            raw[lower] = value;
+        }
+    }
+    if (Object.keys(raw).length === 0)
+        return undefined;
+    return {
+        limit: raw["x-ratelimit-limit"],
+        remaining: raw["x-ratelimit-remaining"],
+        reset: raw["x-ratelimit-reset"],
+        retryAfter: raw["retry-after"],
+        raw
+    };
+}
+async function decodeBody(response) {
+    const text = await response.text();
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function shouldRetry(status) {
+    return [408, 429, 500, 502, 503, 504].includes(status);
+}
+function dropUndefined(value) {
+    if (Array.isArray(value))
+        return value.map(dropUndefined);
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .map(([key, entry]) => [key, dropUndefined(entry)]));
+    }
+    return value;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./client.js";
+export * from "./config.js";
+export * from "./errors.js";
+export * from "./http.js";
+export * from "./mm.js";
+export * from "./signing.js";
+export * from "./types.js";
+export * from "./ws.js";

package/dist/src/index.js

@@ -0,0 +1,8 @@
+export * from "./client.js";
+export * from "./config.js";
+export * from "./errors.js";
+export * from "./http.js";
+export * from "./mm.js";
+export * from "./signing.js";
+export * from "./types.js";
+export * from "./ws.js";

package/dist/src/mm.d.ts

@@ -0,0 +1,32 @@
+import type { ApiResponse, MmActionBatch, MmActionBatchResponse, RequestOptions, SignedAction } from "./types.js";
+import { SenticoreHttpTransport } from "./http.js";
+export declare class SenticoreOrderEntryClient {
+    private readonly transport;
+    constructor(transport: SenticoreHttpTransport);
+    buildBatch(actions: SignedAction[], idempotencyKey?: string): MmActionBatch;
+    encodeBatch(batch: MmActionBatch): Uint8Array;
+    submitActions(actions: SignedAction[], options?: RequestOptions & {
+        orderEntryApiKey?: string;
+        idempotencyKey?: string;
+        /** @deprecated Use orderEntryApiKey. */
+        mmApiKey?: string;
+        responseMode?: "summary" | "detailed" | "full" | "compact" | "conflated";
+    }): Promise<ApiResponse<MmActionBatchResponse>>;
+    submitBatch(batch: MmActionBatch, options?: RequestOptions & {
+        orderEntryApiKey?: string;
+        /** @deprecated Use orderEntryApiKey. */
+        mmApiKey?: string;
+        responseMode?: "summary" | "detailed" | "full" | "compact" | "conflated";
+    }): Promise<ApiResponse<MmActionBatchResponse>>;
+    submitEncoded(payload: BodyInit, options?: RequestOptions & {
+        orderEntryApiKey?: string;
+        /** @deprecated Use orderEntryApiKey. */
+        mmApiKey?: string;
+        responseMode?: "summary" | "detailed" | "full" | "compact" | "conflated";
+    }): Promise<ApiResponse<MmActionBatchResponse>>;
+}
+/** @deprecated Use SenticoreOrderEntryClient. */
+export declare class SenticoreMarketMakerClient extends SenticoreOrderEntryClient {
+}
+export declare function encodeMmActionBatch(batch: MmActionBatch): Uint8Array;
+export declare const encodeOrderEntryActionBatch: typeof encodeMmActionBatch;

package/dist/src/mm.js

@@ -0,0 +1,74 @@
+const ORDER_ENTRY_BATCH_CONTENT_TYPE = "application/x-senticore-order-entry-batch";
+const ORDER_ENTRY_BATCH_RESPONSE_CONTENT_TYPE = "application/x-senticore-order-entry-batch-response";
+const LEGACY_MM_BATCH_RESPONSE_CONTENT_TYPE = "application/x-senticore-mm-batch-response";
+export class SenticoreOrderEntryClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    buildBatch(actions, idempotencyKey) {
+        return {
+            version: 1,
+            actions,
+            ...(idempotencyKey ? { idempotencyKey } : {})
+        };
+    }
+    encodeBatch(batch) {
+        return encodeMmActionBatch(batch);
+    }
+    submitActions(actions, options = {}) {
+        return this.submitBatch(this.buildBatch(actions, options.idempotencyKey), options);
+    }
+    async submitBatch(batch, options = {}) {
+        return this.submitEncoded(encodeMmActionBatch(batch), {
+            ...options,
+            idempotencyKey: options.idempotencyKey ?? batch.idempotencyKey
+        });
+    }
+    submitEncoded(payload, options = {}) {
+        const headers = {
+            "content-type": ORDER_ENTRY_BATCH_CONTENT_TYPE,
+            accept: `${ORDER_ENTRY_BATCH_RESPONSE_CONTENT_TYPE}, ${LEGACY_MM_BATCH_RESPONSE_CONTENT_TYPE}, application/json`,
+            ...options.headers
+        };
+        const orderEntryApiKey = options.orderEntryApiKey ?? options.mmApiKey ?? this.transport.config.orderEntryApiKey;
+        if (orderEntryApiKey)
+            headers["x-senticore-order-entry-key"] = orderEntryApiKey;
+        if (options.responseMode)
+            headers["x-senticore-response-mode"] = options.responseMode;
+        return this.transport.request("POST", this.transport.config.orderEntryHttpBaseUrl, this.transport.config.orderEntryBinaryPath, {
+            ...options,
+            headers,
+            content: payload,
+            retry: options.retry ?? Boolean(options.idempotencyKey)
+        });
+    }
+}
+/** @deprecated Use SenticoreOrderEntryClient. */
+export class SenticoreMarketMakerClient extends SenticoreOrderEntryClient {
+}
+export function encodeMmActionBatch(batch) {
+    const normalized = {
+        version: batch.version,
+        actions: batch.actions.map(normalizeSignedAction),
+        ...(batch.idempotencyKey ? { idempotencyKey: batch.idempotencyKey } : {})
+    };
+    return new TextEncoder().encode(JSON.stringify(normalized));
+}
+export const encodeOrderEntryActionBatch = encodeMmActionBatch;
+function normalizeSignedAction(action) {
+    return {
+        payload: action.payload,
+        signature: {
+            scheme: action.signature.scheme,
+            bytes: normalizeSignatureBytes(action.signature.bytes)
+        }
+    };
+}
+function normalizeSignatureBytes(bytes) {
+    if (typeof bytes === "string")
+        return bytes;
+    if (bytes instanceof Uint8Array)
+        return [...bytes];
+    return bytes;
+}

package/dist/src/signing.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Local (client-side) canonical encoding and signing-hash computation for
+ * Senticore trading actions.
+ *
+ * This removes the `POST /api/v1/trading/actions/hash` roundtrip from the
+ * order hot path: the canonical bytes and the blake3 signing hash are
+ * computed locally, signed locally, and submitted in a single HTTP call.
+ *
+ * CANONICAL ENCODING RULES (must match `senticore-types` byte-for-byte):
+ * - JSON with NO whitespace.
+ * - Object keys in Rust struct DECLARATION order (NOT alphabetical). The
+ *   `canonicalPayload` echoed by the server /hash endpoint is alphabetically
+ *   sorted for display — hashing that JSON gives a DIFFERENT hash. Always
+ *   hash the declaration-order encoding produced here.
+ * - Field names in snake_case (the internal wire names).
+ * - Optional fields are ALWAYS serialized (as null when absent).
+ * - Account ids are 0x-prefixed lowercase hex (20 bytes), order ids
+ *   0x-prefixed lowercase hex (32 bytes).
+ * - Enums: Side "Bid"/"Ask"; Book "YES"/"NO"; time_in_force / stp_mode /
+ *   trigger_direction / conditional_kind in snake_case.
+ * - The outcome variant is serialized with its INTERNAL tag "PlaceOrder"
+ *   (the public alias "OutcomePlaceOrder" is an input-side name only).
+ * - hash = blake3("SENTICORE/ACTION_PAYLOAD/v1" || canonical_bytes).
+ *
+ * Golden vectors pinning compatibility with the backend live in
+ * `tests/signing.test.ts` and in `senticore-types::tests::signing_hash_golden_vectors`.
+ */
+export declare const ACTION_PAYLOAD_DOMAIN_V1 = "SENTICORE/ACTION_PAYLOAD/v1";
+export type UintLike = number | bigint;
+export type LocalSide = "Bid" | "Ask";
+export type LocalBook = "YES" | "NO";
+export type LocalTimeInForce = "gtc" | "ioc" | "fok" | "post_only";
+export type LocalStpMode = "cancel_maker" | "cancel_taker" | "reject" | "skip_self";
+export interface LocalOrderFlags {
+    stpMode?: LocalStpMode | null;
+    timeInForce?: LocalTimeInForce | null;
+    isMarket?: boolean;
+    reduceOnly?: boolean;
+    expiresAt?: UintLike | null;
+}
+export interface LocalSpotPlaceOrder extends LocalOrderFlags {
+    kind: "SpotPlaceOrder";
+    market: UintLike;
+    side: LocalSide;
+    price: UintLike;
+    qty: UintLike;
+}
+export interface LocalOutcomePlaceOrder extends LocalOrderFlags {
+    kind: "OutcomePlaceOrder";
+    market: UintLike;
+    book: LocalBook;
+    side: LocalSide;
+    price: UintLike;
+    qty: UintLike;
+}
+export interface LocalCancel {
+    kind: "Cancel";
+    orderId: string;
+}
+export interface LocalAmendOrder {
+    kind: "AmendOrder";
+    orderId: string;
+    /** AmendOrder is quantity-only by design (keeps time priority). */
+    newQty: UintLike;
+}
+export interface LocalSpotQuoteReplaceLeg extends LocalOrderFlags {
+    cancelOrderId?: string | null;
+    side: LocalSide;
+    price: UintLike;
+    qty: UintLike;
+}
+export interface LocalSpotQuoteReplace {
+    kind: "SpotQuoteReplace";
+    market: UintLike;
+    legs: LocalSpotQuoteReplaceLeg[];
+}
+export interface LocalQuoteReplaceLeg extends LocalSpotQuoteReplaceLeg {
+    book: LocalBook;
+}
+export interface LocalQuoteReplace {
+    kind: "QuoteReplace";
+    market: UintLike;
+    legs: LocalQuoteReplaceLeg[];
+}
+export type LocalAction = LocalSpotPlaceOrder | LocalOutcomePlaceOrder | LocalCancel | LocalAmendOrder | LocalSpotQuoteReplace | LocalQuoteReplace;
+export interface LocalActionPayload {
+    account: string;
+    nonce: UintLike;
+    nonceReservationId?: string | null;
+    ts: UintLike;
+    action: LocalAction;
+}
+/**
+ * Canonical declaration-order JSON for an action payload — the EXACT bytes
+ * the backend hashes and persists.
+ */
+export declare function canonicalActionPayloadJson(payload: LocalActionPayload): string;
+/** blake3(domain || canonical_bytes) as raw bytes. */
+export declare function actionSigningHash(payload: LocalActionPayload): Uint8Array;
+/** blake3 signing hash as 0x-prefixed lowercase hex. */
+export declare function actionSigningHashHex(payload: LocalActionPayload): `0x${string}`;