@n1xyz/nord-ts 0.0.22 → 0.1.1

package/dist/gen/openapi.d.ts

@@ -111,11 +111,13 @@ export interface paths {
             };
         };
         put?: never;
-        /** @description Send an action to nord to execute. */
+        /** @description Send an action to nord to execute. This doesn't use `Protobuf<T>` since we want to length-delimit this message. `body` - (length prefix of action, action data protobuf, and signature). signature has exact length, but depend on action kind. body is exact payload used via other transports and journalled for rexecution */
         post: {
             parameters: {
                 query?: never;
-                header?: never;
+                header: {
+                    "content-type": string;
+                };
                 path?: never;
                 cookie?: never;
             };
@@ -134,6 +136,27 @@ export interface paths {
                         "application/octet-stream": unknown;
                     };
                 };
+                413: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["PayloadTooLarge"];
+                    };
+                };
+                415: {
+                    headers: {
+                        /**
+                         * @description Expected request media type
+                         * @example application/octet-stream
+                         */
+                        accept: string;
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["AcceptedMediaType"];
+                    };
+                };
             };
         };
         delete?: never;
@@ -1892,6 +1915,13 @@ export interface components {
             /** Format: uint16 */
             weightBps: number;
         };
+        AcceptedMediaType: {
+            expected: string;
+        };
+        PayloadTooLarge: {
+            /** Format: uint */
+            limit: number;
+        };
         ActionsQuery: {
             /** Format: uint64 */
             from: number;
@@ -2223,8 +2253,6 @@ export interface components {
         HistoryTriggerInfo: {
             /** Format: uint32 */
             accountId: number;
-            /** Format: uint64 */
-            actionId: number;
             /** Format: uint32 */
             marketId: number;
             /** Format: uint64 */
@@ -2232,21 +2260,30 @@ export interface components {
             side: components["schemas"]["Side"];
             kind: components["schemas"]["TriggerKind"];
             status: components["schemas"]["TriggerStatus"];
+            /** Format: uint64 */
+            createdAtActionId: number;
+            /** Format: uint64 */
+            finalizedAtActionId?: number | null;
             createdAt: string;
-            updatedAt: string;
+            finalizedAt: string;
         };
         /** @enum {string} */
         TriggerKind: "stopLoss" | "takeProfit";
         /** @enum {string} */
-        TriggerStatus: "added" | "succeeded" | "failed" | "removed";
+        TriggerStatus: "active" | "success" | "cancel" | "fail" | "remove";
         TriggerInfo: {
             /** Format: uint32 */
             marketId: number;
-            /** Format: uint64 */
-            price: number;
             side: components["schemas"]["Side"];
             kind: components["schemas"]["TriggerKind"];
+            triggerPrice: components["schemas"]["PositivePriceMantissa"];
+            limitPrice?: components["schemas"]["PositivePriceMantissa"] | null;
         };
+        /**
+         * Format: uint64
+         * @description 63 bit integer, which is always positive
+         */
+        PositivePriceMantissa: number;
         OrderNotFound: null;
         PageResult_for_String_and_Trade: {
             /** @description Set of items for requested by query. */

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

@@ -2,6 +2,7 @@ import Decimal from "decimal.js";
 import * as proto from "../../gen/nord_pb";
 import { FillMode, Side, QuoteSize } from "../../types";
 import { BigIntValue } from "../../utils";
+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;

package/dist/nord/api/actions.js

@@ -32,7 +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.prepareAction = prepareAction;
 exports.createSession = createSession;
 exports.revokeSession = revokeSession;
 exports.withdraw = withdraw;
@@ -41,6 +45,7 @@ exports.cancelOrder = cancelOrder;
 exports.transfer = transfer;
 exports.atomic = atomic;
 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");
@@ -61,29 +66,49 @@ function createAction(currentTimestamp, nonce, kind) {
         kind,
     });
 }
-async function sendAction(serverUrl, makeSignedMessage, action, actionErrorDesc) {
-    const encoded = (0, wire_1.sizeDelimitedEncode)(proto.ActionSchema, action);
-    // validate the payload size
-    const MAX_PAYLOAD_SIZE = 100 * 1024; // 100 kB
-    if (encoded.byteLength > MAX_PAYLOAD_SIZE) {
-        throw new Error(`Encoded message size (${encoded.byteLength} bytes) is greater than max payload size (${MAX_PAYLOAD_SIZE} bytes).`);
-    }
-    const body = await makeSignedMessage(encoded);
-    // TODO: this should be changed to use openapi
-    const response = await (0, utils_1.checkedFetch)(`${serverUrl}/action`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
+async function sendAction(serverUrl, makeSignedMessage, action) {
+    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: body,
+        // NOTE: openapi-fetch ignores headers and types/const headers in schema, and always assume all things are JSON
+        // to handle multi type bodies, need these overrides and later adhoc parsing
+        bodySerializer: (body) => body,
+        parseAs: "stream",
     });
-    const rawResp = new Uint8Array(await response.arrayBuffer());
+    if (response.error) {
+        throw new Error(`Failed to ${action.kind.case}, HTTP status ${JSON.stringify(response.error)}`);
+    }
+    const rawResp = new Uint8Array(await response.response.bytes());
     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]}`);
+        throw new Error(`Could not execute ${action.kind.case}, reason: ${proto.Error[resp.kind.value]}`);
     }
     return resp;
 }
+// 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_ENCODED_ACTION_SIZE in Rust code
+    const MAX_ENCODED_ACTION_SIZE = 1024;
+    if (encoded.byteLength > MAX_ENCODED_ACTION_SIZE) {
+        console.warn("Encoded message:", encoded);
+        throw new Error(`Encoded message size (${encoded.byteLength} bytes) is greater than max payload size (${MAX_ENCODED_ACTION_SIZE} bytes).`);
+    }
+    const body = await makeSignedMessage(encoded);
+    if (body.byteLength > MAX_ENCODED_ACTION_SIZE) {
+        console.warn("Encoded length:", encoded.byteLength);
+        throw new Error(`Signed message size (${body.byteLength} bytes) is greater than max payload size (${MAX_ENCODED_ACTION_SIZE} bytes).`);
+    }
+    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);
@@ -103,7 +128,7 @@ async function createSession(serverUrl, walletSignFn, currentTimestamp, nonce, p
             expiryTimestamp: expiry,
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => walletSign(walletSignFn, m), action, "create a new session");
+    const resp = await sendAction(serverUrl, (m) => walletSign(walletSignFn, m), action);
     if (resp.kind?.case === "createSessionResult") {
         return {
             actionId: resp.actionId,
@@ -121,7 +146,7 @@ async function revokeSession(serverUrl, walletSignFn, currentTimestamp, nonce, p
             sessionId: BigInt(params.sessionId),
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => walletSign(walletSignFn, m), action, "revoke session");
+    const resp = await sendAction(serverUrl, (m) => walletSign(walletSignFn, m), action);
     return { actionId: resp.actionId };
 }
 async function withdraw(serverUrl, signFn, currentTimestamp, nonce, params) {
@@ -137,7 +162,7 @@ async function withdraw(serverUrl, signFn, currentTimestamp, nonce, params) {
             amount,
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "withdraw");
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action);
     if (resp.kind?.case === "withdrawResult") {
         return { actionId: resp.actionId, ...resp.kind.value };
     }
@@ -151,6 +176,7 @@ async function placeOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
     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, {
@@ -174,7 +200,7 @@ async function placeOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
             delegatorAccountId: params.liquidateeId,
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "place order");
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action);
     if (resp.kind?.case === "placeOrderResult") {
         return {
             actionId: resp.actionId,
@@ -196,7 +222,7 @@ async function cancelOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
             delegatorAccountId: params.liquidateeId,
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "cancel order");
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action);
     if (resp.kind?.case === "cancelOrderResult") {
         return {
             actionId: resp.actionId,
@@ -219,7 +245,7 @@ async function transfer(serverUrl, signFn, currentTimestamp, nonce, params) {
             amount: (0, utils_1.toScaledU64)(params.amount ?? 0, params.tokenDecimals),
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "transfer");
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action);
     if (resp.kind?.case === "transferred") {
         return {
             actionId: resp.actionId,
@@ -243,6 +269,8 @@ async function atomic(serverUrl, signFn, currentTimestamp, nonce, params) {
             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: (0, protobuf_1.create)(proto.OrderTypeSchema, {
@@ -281,7 +309,7 @@ async function atomic(serverUrl, signFn, currentTimestamp, nonce, params) {
             actions: subactions,
         }),
     });
-    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action, "execute atomic action");
+    const resp = await sendAction(serverUrl, (m) => sessionSign(signFn, m), action);
     if (resp.kind?.case === "atomic") {
         return {
             actionId: resp.actionId,

package/dist/types.js

@@ -109,8 +109,8 @@ class QuoteSize {
     constructor(quotePrice, quoteSize) {
         const p = new decimal_js_1.default(quotePrice);
         const s = new decimal_js_1.default(quoteSize);
-        if (p.isZero() || s.isZero()) {
-            throw new Error("quotePrice and quoteSize must be non-zero");
+        if (!p.isPositive() || !s.isPositive()) {
+            throw new Error("quotePrice and quoteSize must be positive");
         }
         this.price = p;
         this.size = s;

package/dist/utils.js

@@ -31,6 +31,7 @@ const bs58_1 = __importDefault(require("bs58"));
 exports.SESSION_TTL = 60n * 60n * 24n * 30n;
 exports.ZERO_DECIMAL = new decimal_js_1.Decimal(0);
 exports.MAX_BUFFER_LEN = 10000;
+// Max size of data returned from Nord endpoints
 const MAX_PAYLOAD_SIZE = 100 * 1024; // 100 kB
 function panic(message) {
     throw new Error(message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@n1xyz/nord-ts",
-  "version": "0.0.22",
+  "version": "0.1.1",
   "description": "Typescript for Nord",
   "keywords": [],
   "author": "",