@n1xyz/nord-ts 0.0.21 → 0.1.0

package/dist/nord/api/actions.d.ts

@@ -1,55 +1,29 @@
 import Decimal from "decimal.js";
-import * as proto from "../../gen/nord";
-import { FillMode, Side } from "../../types";
+import * as proto from "../../gen/nord_pb";
+import { FillMode, Side, QuoteSize } from "../../types";
 import { BigIntValue } from "../../utils";
-declare function createSessionImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    userPubkey: Uint8Array;
-    sessionPubkey: Uint8Array;
-    expiryTimestamp?: bigint;
-}): Promise<bigint>;
+export declare function prepareAction(action: proto.Action, makeSignedMessage: (message: Uint8Array) => Promise<Uint8Array>): Promise<Uint8Array<ArrayBufferLike>>;
 export declare function createSession(serverUrl: string, walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
     userPubkey: Uint8Array;
     sessionPubkey: Uint8Array;
     expiryTimestamp?: bigint;
-}): Promise<bigint>;
-declare function revokeSessionImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sessionId: BigIntValue;
-}): Promise<void>;
+}): Promise<{
+    actionId: bigint;
+    sessionId: bigint;
+}>;
 export declare function revokeSession(serverUrl: string, walletSignFn: (message: string | Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
     sessionId: BigIntValue;
-}): Promise<void>;
-declare function withdrawImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sizeDecimals: number;
-    sessionId: BigIntValue;
-    tokenId: number;
-    amount: Decimal.Value;
 }): Promise<{
     actionId: bigint;
-} & proto.Receipt_WithdrawResult>;
+}>;
 export declare function withdraw(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
     sizeDecimals: number;
     sessionId: BigIntValue;
     tokenId: number;
-    amount: number;
+    amount: Decimal.Value;
 }): Promise<{
     actionId: bigint;
 } & proto.Receipt_WithdrawResult>;
-declare function placeOrderImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sessionId: BigIntValue;
-    senderId?: number;
-    liquidateeId?: number;
-    sizeDecimals: number;
-    priceDecimals: number;
-    marketId: number;
-    side: Side;
-    fillMode: FillMode;
-    isReduceOnly: boolean;
-    size?: Decimal.Value;
-    price?: Decimal.Value;
-    quoteSizeSize?: Decimal.Value;
-    quoteSizePrice?: Decimal.Value;
-    clientOrderId?: BigIntValue;
-}): Promise<bigint | undefined>;
 export declare function placeOrder(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
     sessionId: BigIntValue;
     senderId?: number;
@@ -61,38 +35,39 @@ export declare function placeOrder(serverUrl: string, signFn: (message: Uint8Arr
     isReduceOnly: boolean;
     size?: Decimal.Value;
     price?: Decimal.Value;
-    quoteSize?: Decimal.Value;
+    quoteSize?: QuoteSize;
     liquidateeId?: number;
     clientOrderId?: BigIntValue;
-}): Promise<bigint | undefined>;
-declare function cancelOrderImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sessionId: BigIntValue;
-    senderId?: number;
-    orderId: BigIntValue;
-    liquidateeId?: number;
-}): Promise<bigint>;
+}): Promise<{
+    actionId: bigint;
+    orderId?: bigint;
+    fills: proto.Receipt_Trade[];
+}>;
 export declare function cancelOrder(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
     sessionId: BigIntValue;
     senderId?: number;
     orderId: BigIntValue;
     liquidateeId?: number;
-}): Promise<bigint>;
-declare function transferImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+}): Promise<{
+    actionId: bigint;
+    orderId: bigint;
+    accountId: number;
+}>;
+export declare function transfer(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
     sessionId: BigIntValue;
     fromAccountId: number;
     toAccountId?: number;
     tokenId: number;
     tokenDecimals: number;
     amount: Decimal.Value;
-}): Promise<number | undefined>;
-export declare function transfer(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sessionId: BigIntValue;
+}): Promise<{
+    actionId: bigint;
     fromAccountId: number;
     toAccountId?: number;
     tokenId: number;
-    tokenDecimals: number;
-    amount: Decimal.Value;
-}): Promise<number | undefined>;
+    amount: bigint;
+    accountCreated: boolean;
+}>;
 export type AtomicSubaction = {
     kind: "place";
     marketId: number;
@@ -103,33 +78,17 @@ export type AtomicSubaction = {
     priceDecimals: number;
     size?: Decimal.Value;
     price?: Decimal.Value;
-    quoteSizeSize?: Decimal.Value;
-    quoteSizePrice?: Decimal.Value;
+    quoteSize?: QuoteSize;
     clientOrderId?: BigIntValue;
 } | {
     kind: "cancel";
     orderId: BigIntValue;
 };
-declare function atomicImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
-    sessionId: BigIntValue;
-    accountId?: number;
-    actions: AtomicSubaction[];
-}): Promise<proto.Receipt_AtomicResult>;
 export declare function atomic(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
     sessionId: BigIntValue;
     accountId?: number;
     actions: AtomicSubaction[];
-}): Promise<proto.Receipt_AtomicResult>;
-/**
- * For testing purposes
- */
-export declare const _private: {
-    createSessionImpl: typeof createSessionImpl;
-    revokeSessionImpl: typeof revokeSessionImpl;
-    withdrawImpl: typeof withdrawImpl;
-    placeOrderImpl: typeof placeOrderImpl;
-    cancelOrderImpl: typeof cancelOrderImpl;
-    transferImpl: typeof transferImpl;
-    atomicImpl: typeof atomicImpl;
-};
-export {};
+}): Promise<{
+    actionId: bigint;
+    results: proto.Receipt_AtomicSubactionResultKind[];
+}>;

package/dist/nord/api/actions.js

@@ -32,8 +32,11 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._private = void 0;
+exports.prepareAction = prepareAction;
 exports.createSession = createSession;
 exports.revokeSession = revokeSession;
 exports.withdraw = withdraw;
@@ -41,9 +44,12 @@ exports.placeOrder = placeOrder;
 exports.cancelOrder = cancelOrder;
 exports.transfer = transfer;
 exports.atomic = atomic;
-const proto = __importStar(require("../../gen/nord"));
+const proto = __importStar(require("../../gen/nord_pb"));
+const openapi_fetch_1 = __importDefault(require("openapi-fetch"));
+const protobuf_1 = require("@bufbuild/protobuf");
 const types_1 = require("../../types");
 const utils_1 = require("../../utils");
+const wire_1 = require("@bufbuild/protobuf/wire");
 async function sessionSign(signFn, message) {
     const signature = await signFn(message);
     return new Uint8Array([...message, ...signature]);
@@ -52,30 +58,49 @@ async function walletSign(walletSignFn, message) {
     const signature = await walletSignFn(message);
     return new Uint8Array([...message, ...signature]);
 }
-function makeSendHttp(serverUrl) {
-    return async (body) => {
-        // TODO: this should be changed to use openapi
-        const response = await (0, utils_1.checkedFetch)(`${serverUrl}/action`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body,
-        });
-        return new Uint8Array(await response.arrayBuffer());
-    };
+// Helper to create an action with common fields
+function createAction(currentTimestamp, nonce, kind) {
+    return (0, protobuf_1.create)(proto.ActionSchema, {
+        currentTimestamp,
+        nonce,
+        kind,
+    });
 }
-async function sendAction(sendFn, makeSignedMessage, action, actionErrorDesc) {
-    const encoded = (0, utils_1.encodeLengthDelimited)(action, proto.Action);
-    const body = await makeSignedMessage(encoded);
-    const rawResp = await sendFn(body);
-    const resp = (0, utils_1.decodeLengthDelimited)(rawResp, proto.Receipt);
-    if (resp.kind?.$case === "err") {
-        throw new Error(`Could not ${actionErrorDesc}, reason: ${proto.errorToJSON(resp.kind.value)}`);
+async function sendAction(serverUrl, makeSignedMessage, action, actionErrorDesc) {
+    const body = await prepareAction(action, makeSignedMessage);
+    // NOTE: restructure and reuse client as it is in Nord.ts
+    const client = (0, openapi_fetch_1.default)({ baseUrl: serverUrl });
+    const response = await client.POST("/action", {
+        params: {
+            header: {
+                "content-type": "application/octet-stream",
+            },
+        },
+        body: body,
+    });
+    if (response.error) {
+        throw new Error(`Failed to ${actionErrorDesc}, HTTP status ${response}`);
+    }
+    const rawResp = new Uint8Array(await response.response.arrayBuffer());
+    const resp = (0, utils_1.decodeLengthDelimited)(rawResp, proto.ReceiptSchema);
+    if (resp.kind?.case === "err") {
+        throw new Error(`Could not ${actionErrorDesc}, reason: ${proto.Error[resp.kind.value]}`);
     }
     return resp;
 }
-async function createSessionImpl(sendFn, walletSignFn, currentTimestamp, nonce, params) {
+// Given action and signature function, prepare the signed message to send to server as `body`.
+// `makeSignedMessage` must include the original message and signature.
+async function prepareAction(action, makeSignedMessage) {
+    const encoded = (0, wire_1.sizeDelimitedEncode)(proto.ActionSchema, action);
+    // NOTE(agent): keep in sync with MAX_HTTP_REQUEST_BODY_SIZE in rust code
+    const MAX_HTTP_REQUEST_BODY_SIZE = 1024;
+    if (encoded.byteLength > MAX_HTTP_REQUEST_BODY_SIZE) {
+        throw new Error(`Encoded message size (${encoded.byteLength} bytes) is greater than max payload size (${MAX_HTTP_REQUEST_BODY_SIZE} bytes).`);
+    }
+    const body = await makeSignedMessage(encoded);
+    return body;
+}
+async function createSession(serverUrl, walletSignFn, currentTimestamp, nonce, params) {
     (0, utils_1.checkPubKeyLength)(types_1.KeyType.Ed25519, params.userPubkey.length);
     (0, utils_1.checkPubKeyLength)(types_1.KeyType.Ed25519, params.sessionPubkey.length);
     let expiry = 0n;
@@ -86,228 +111,201 @@ async function createSessionImpl(sendFn, walletSignFn, currentTimestamp, nonce,
     else {
         expiry = currentTimestamp + utils_1.SESSION_TTL;
     }
-    const action = {
-        currentTimestamp,
-        nonce,
-        kind: {
-            $case: "createSession",
-            value: {
-                userPubkey: params.userPubkey,
-                blstPubkey: params.sessionPubkey,
-                expiryTimestamp: expiry,
-            },
-        },
-    };
-    const resp = await sendAction(sendFn, (m) => walletSign(walletSignFn, m), action, "create a new session");
-    if (resp.kind?.$case === "createSessionResult") {
-        return resp.kind.value.sessionId;
+    const action = createAction(currentTimestamp, nonce, {
+        case: "createSession",
+        value: (0, protobuf_1.create)(proto.Action_CreateSessionSchema, {
+            userPubkey: params.userPubkey,
+            blstPubkey: params.sessionPubkey,
+            expiryTimestamp: expiry,
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => walletSign(walletSignFn, m), action, "create a new session");
+    if (resp.kind?.case === "createSessionResult") {
+        return {
+            actionId: resp.actionId,
+            sessionId: resp.kind.value.sessionId,
+        };
     }
     else {
-        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+        throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
     }
 }
-async function createSession(serverUrl, walletSignFn, currentTimestamp, nonce, params) {
-    return createSessionImpl(makeSendHttp(serverUrl), walletSignFn, currentTimestamp, nonce, params);
-}
-async function revokeSessionImpl(sendFn, walletSignFn, currentTimestamp, nonce, params) {
-    const action = {
-        currentTimestamp,
-        nonce,
-        kind: {
-            $case: "revokeSession",
-            value: {
-                sessionId: BigInt(params.sessionId),
-            },
-        },
-    };
-    await sendAction(sendFn, (m) => walletSign(walletSignFn, m), action, "create a new session");
-}
 async function revokeSession(serverUrl, walletSignFn, currentTimestamp, nonce, params) {
-    return revokeSessionImpl(makeSendHttp(serverUrl), walletSignFn, currentTimestamp, nonce, params);
+    const action = createAction(currentTimestamp, nonce, {
+        case: "revokeSession",
+        value: (0, protobuf_1.create)(proto.Action_RevokeSessionSchema, {
+            sessionId: BigInt(params.sessionId),
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => walletSign(walletSignFn, m), action, "revoke session");
+    return { actionId: resp.actionId };
 }
-async function withdrawImpl(sendFn, signFn, currentTimestamp, nonce, params) {
+async function withdraw(serverUrl, signFn, currentTimestamp, nonce, params) {
     const amount = (0, utils_1.toScaledU64)(params.amount, params.sizeDecimals);
     if (amount <= 0) {
         throw new Error("Withdraw amount must be positive");
     }
-    const action = {
-        currentTimestamp,
-        nonce,
-        kind: {
-            $case: "withdraw",
-            value: {
-                sessionId: BigInt(params.sessionId),
-                tokenId: params.tokenId,
-                amount,
-            },
-        },
-    };
-    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "withdraw");
-    if (resp.kind?.$case === "withdrawResult") {
+    const action = createAction(currentTimestamp, nonce, {
+        case: "withdraw",
+        value: (0, protobuf_1.create)(proto.Action_WithdrawSchema, {
+            sessionId: BigInt(params.sessionId),
+            tokenId: params.tokenId,
+            amount,
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "withdraw");
+    if (resp.kind?.case === "withdrawResult") {
         return { actionId: resp.actionId, ...resp.kind.value };
     }
     else {
-        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+        throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
     }
 }
-async function withdraw(serverUrl, signFn, currentTimestamp, nonce, params) {
-    return withdrawImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
-}
-async function placeOrderImpl(sendFn, signFn, currentTimestamp, nonce, params) {
+async function placeOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
     const price = (0, utils_1.toScaledU64)(params.price ?? 0, params.priceDecimals);
     const size = (0, utils_1.toScaledU64)(params.size ?? 0, params.sizeDecimals);
-    const quoteSize = (0, utils_1.toScaledU64)(params.quoteSizeSize ?? 0, params.sizeDecimals);
-    const quotePrice = (0, utils_1.toScaledU64)(params.quoteSizePrice ?? 0, params.priceDecimals);
-    // Compose action object
-    const action = {
-        currentTimestamp,
-        nonce,
-        kind: {
-            $case: "placeOrder",
-            value: {
-                sessionId: BigInt(params.sessionId),
-                senderAccountId: params.senderId,
-                marketId: params.marketId,
-                side: params.side === types_1.Side.Bid ? proto.Side.BID : proto.Side.ASK,
-                fillMode: (0, types_1.fillModeToProtoFillMode)(params.fillMode),
-                isReduceOnly: params.isReduceOnly,
-                price,
-                size,
-                quoteSize: { size: quoteSize, price: quotePrice },
-                clientOrderId: params.clientOrderId === undefined
-                    ? undefined
-                    : BigInt(params.clientOrderId),
-                delegatorAccountId: params.liquidateeId,
-            },
-        },
-    };
-    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "place the order");
-    if (resp.kind?.$case === "placeOrderResult") {
-        return resp.kind.value.posted?.orderId;
+    const scaledQuote = params.quoteSize
+        ? params.quoteSize.toScaledU64(params.priceDecimals, params.sizeDecimals)
+        : undefined;
+    (0, utils_1.assert)(price > 0n || size > 0n || scaledQuote !== undefined, "OrderLimit must include at least one of: size, price, or quoteSize");
+    const action = createAction(currentTimestamp, nonce, {
+        case: "placeOrder",
+        value: (0, protobuf_1.create)(proto.Action_PlaceOrderSchema, {
+            sessionId: BigInt(params.sessionId),
+            senderAccountId: params.senderId,
+            marketId: params.marketId,
+            side: params.side === types_1.Side.Bid ? proto.Side.BID : proto.Side.ASK,
+            fillMode: (0, types_1.fillModeToProtoFillMode)(params.fillMode),
+            isReduceOnly: params.isReduceOnly,
+            price,
+            size,
+            quoteSize: scaledQuote === undefined
+                ? undefined
+                : (0, protobuf_1.create)(proto.QuoteSizeSchema, {
+                    size: scaledQuote.size,
+                    price: scaledQuote.price,
+                }),
+            clientOrderId: params.clientOrderId === undefined
+                ? undefined
+                : BigInt(params.clientOrderId),
+            delegatorAccountId: params.liquidateeId,
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "place order");
+    if (resp.kind?.case === "placeOrderResult") {
+        return {
+            actionId: resp.actionId,
+            orderId: resp.kind.value.posted?.orderId,
+            fills: resp.kind.value.fills,
+        };
     }
     else {
-        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+        throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
     }
 }
-async function placeOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
-    return placeOrderImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
-}
-async function cancelOrderImpl(sendFn, signFn, currentTimestamp, nonce, params) {
-    const action = {
-        currentTimestamp,
-        nonce: nonce,
-        kind: {
-            $case: "cancelOrderById",
-            value: {
-                orderId: BigInt(params.orderId),
-                sessionId: BigInt(params.sessionId),
-                senderAccountId: params.senderId,
-                delegatorAccountId: params.liquidateeId,
-            },
-        },
-    };
-    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "cancel the order");
-    if (resp.kind?.$case === "cancelOrderResult") {
-        return resp.kind.value.orderId;
+async function cancelOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
+    const action = createAction(currentTimestamp, nonce, {
+        case: "cancelOrderById",
+        value: (0, protobuf_1.create)(proto.Action_CancelOrderByIdSchema, {
+            orderId: BigInt(params.orderId),
+            sessionId: BigInt(params.sessionId),
+            senderAccountId: params.senderId,
+            delegatorAccountId: params.liquidateeId,
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "cancel order");
+    if (resp.kind?.case === "cancelOrderResult") {
+        return {
+            actionId: resp.actionId,
+            orderId: resp.kind.value.orderId,
+            accountId: resp.kind.value.accountId,
+        };
     }
     else {
-        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+        throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
     }
 }
-async function cancelOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
-    return cancelOrderImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
-}
-async function transferImpl(sendFn, signFn, currentTimestamp, nonce, params) {
-    const action = {
-        currentTimestamp,
-        nonce: nonce,
-        kind: {
-            $case: "transfer",
-            value: {
-                sessionId: BigInt(params.sessionId),
-                fromAccountId: params.fromAccountId,
-                toAccountId: params.toAccountId,
-                tokenId: params.tokenId,
-                amount: (0, utils_1.toScaledU64)(params.amount ?? 0, params.tokenDecimals),
-            },
-        },
-    };
-    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "transfer asset to other account");
-    if (resp.kind?.$case === "transferred") {
-        if (resp.kind.value.accountCreated) {
-            return resp.kind.value.toUserAccount;
-        }
-        else {
-            return undefined;
-        }
+async function transfer(serverUrl, signFn, currentTimestamp, nonce, params) {
+    const action = createAction(currentTimestamp, nonce, {
+        case: "transfer",
+        value: (0, protobuf_1.create)(proto.Action_TransferSchema, {
+            sessionId: BigInt(params.sessionId),
+            fromAccountId: params.fromAccountId,
+            toAccountId: params.toAccountId,
+            tokenId: params.tokenId,
+            amount: (0, utils_1.toScaledU64)(params.amount ?? 0, params.tokenDecimals),
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "transfer");
+    if (resp.kind?.case === "transferred") {
+        return {
+            actionId: resp.actionId,
+            fromAccountId: resp.kind.value.fromAccountId,
+            toAccountId: resp.kind.value.toUserAccount,
+            tokenId: resp.kind.value.tokenId,
+            amount: resp.kind.value.amount,
+            accountCreated: resp.kind.value.accountCreated,
+        };
     }
     else {
-        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+        throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
     }
 }
-async function transfer(serverUrl, signFn, currentTimestamp, nonce, params) {
-    return transferImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
-}
-async function atomicImpl(sendFn, signFn, currentTimestamp, nonce, params) {
+async function atomic(serverUrl, signFn, currentTimestamp, nonce, params) {
     (0, utils_1.assert)(params.actions.length > 0 && params.actions.length <= 4, "Atomic action must contain between 1 and 4 sub-actions");
     const subactions = params.actions.map((a) => {
         if (a.kind === "place") {
             const price = (0, utils_1.toScaledU64)(a.price ?? 0, a.priceDecimals);
             const size = (0, utils_1.toScaledU64)(a.size ?? 0, a.sizeDecimals);
-            const quoteSizeSize = (0, utils_1.toScaledU64)(a.quoteSizeSize ?? 0, a.sizeDecimals);
-            const quoteSizePrice = (0, utils_1.toScaledU64)(a.quoteSizePrice ?? 0, a.priceDecimals);
-            const tradeOrPlace = {
+            const scaledQuote = a.quoteSize
+                ? a.quoteSize.toScaledU64(a.priceDecimals, a.sizeDecimals)
+                : undefined;
+            // Require at least one limit to be set (non-zero size, non-zero price, or quoteSize)
+            (0, utils_1.assert)(price > 0n || size > 0n || scaledQuote !== undefined, "OrderLimit must include at least one of: size, price, or quoteSize");
+            const tradeOrPlace = (0, protobuf_1.create)(proto.TradeOrPlaceSchema, {
                 marketId: a.marketId,
-                orderType: {
+                orderType: (0, protobuf_1.create)(proto.OrderTypeSchema, {
                     side: a.side === types_1.Side.Bid ? proto.Side.BID : proto.Side.ASK,
                     fillMode: (0, types_1.fillModeToProtoFillMode)(a.fillMode),
                     isReduceOnly: a.isReduceOnly,
-                },
-                limit: {
+                }),
+                limit: (0, protobuf_1.create)(proto.OrderLimitSchema, {
                     price,
                     size,
-                    quoteSize: { size: quoteSizeSize, price: quoteSizePrice },
-                },
+                    quoteSize: scaledQuote === undefined
+                        ? undefined
+                        : (0, protobuf_1.create)(proto.QuoteSizeSchema, {
+                            size: scaledQuote.size,
+                            price: scaledQuote.price,
+                        }),
+                }),
                 clientOrderId: a.clientOrderId === undefined ? undefined : BigInt(a.clientOrderId),
-            };
-            return {
-                inner: { $case: "tradeOrPlace", value: tradeOrPlace },
-            };
+            });
+            return (0, protobuf_1.create)(proto.AtomicSubactionKindSchema, {
+                inner: { case: "tradeOrPlace", value: tradeOrPlace },
+            });
         }
+        return (0, protobuf_1.create)(proto.AtomicSubactionKindSchema, {
+            inner: {
+                case: "cancelOrder",
+                value: (0, protobuf_1.create)(proto.CancelOrderSchema, { orderId: BigInt(a.orderId) }),
+            },
+        });
+    });
+    const action = createAction(currentTimestamp, nonce, {
+        case: "atomic",
+        value: (0, protobuf_1.create)(proto.AtomicSchema, {
+            sessionId: BigInt(params.sessionId),
+            accountId: params.accountId, // optional
+            actions: subactions,
+        }),
+    });
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "execute atomic action");
+    if (resp.kind?.case === "atomic") {
         return {
-            inner: { $case: "cancelOrder", value: { orderId: BigInt(a.orderId) } },
+            actionId: resp.actionId,
+            results: resp.kind.value.results,
         };
-    });
-    const action = {
-        currentTimestamp,
-        nonce,
-        kind: {
-            $case: "atomic",
-            value: {
-                sessionId: BigInt(params.sessionId),
-                accountId: params.accountId, // optional
-                actions: subactions,
-            },
-        },
-    };
-    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "execute atomic action");
-    if (resp.kind?.$case === "atomic") {
-        return resp.kind.value;
     }
-    throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    throw new Error(`Unexpected receipt kind ${resp.kind?.case}`);
 }
-async function atomic(serverUrl, signFn, currentTimestamp, nonce, params) {
-    return atomicImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
-}
-/**
- * For testing purposes
- */
-exports._private = {
-    createSessionImpl,
-    revokeSessionImpl,
-    withdrawImpl,
-    placeOrderImpl,
-    cancelOrderImpl,
-    transferImpl,
-    atomicImpl,
-};