@n1xyz/nord-ts 0.1.2 → 0.1.4

package/dist/nord/client/NordAdmin.d.ts

@@ -0,0 +1,70 @@
+import * as proto from "../../gen/nord_pb";
+import { NordClient } from "./NordClient";
+import type { NordClientParams } from "./NordClient";
+import type { NordUser } from "./NordUser";
+export interface CreateTokenParams {
+    tokenDecimals: number;
+    weightBps: number;
+    viewSymbol: string;
+    oracleSymbol: string;
+    solAddr: Uint8Array;
+}
+export interface CreateMarketParams {
+    sizeDecimals: number;
+    priceDecimals: number;
+    imfBps: number;
+    cmfBps: number;
+    mmfBps: number;
+    marketType: proto.MarketType;
+    viewSymbol: string;
+    oracleSymbol: string;
+    baseTokenId: number;
+}
+export interface PythSetWormholeGuardiansParams {
+    guardianSetIndex: number;
+    addresses: Uint8Array[];
+}
+export interface PythSetSymbolFeedParams {
+    oracleSymbol: string;
+    priceFeedId: Uint8Array;
+}
+export interface FreezeMarketParams {
+    marketId: number;
+}
+export interface UnfreezeMarketParams {
+    marketId: number;
+}
+export interface NordAdminParams extends NordClientParams {
+    signFn: (message: Uint8Array) => Promise<Uint8Array>;
+}
+export declare class NordAdmin extends NordClient {
+    private readonly signFn;
+    constructor(params: NordAdminParams);
+    clone(): NordAdmin;
+    static fromUser(user: NordUser, adminSignFn: (message: Uint8Array) => Promise<Uint8Array>): NordAdmin;
+    private submitAction;
+    createToken(params: CreateTokenParams): Promise<{
+        actionId: bigint;
+    } & proto.Receipt_InsertTokenResult>;
+    createMarket(params: CreateMarketParams): Promise<{
+        actionId: bigint;
+    } & proto.Receipt_InsertMarketResult>;
+    pythSetWormholeGuardians(params: PythSetWormholeGuardiansParams): Promise<{
+        actionId: bigint;
+    } & proto.Receipt_UpdateGuardianSetResult>;
+    pythSetSymbolFeed(params: PythSetSymbolFeedParams): Promise<{
+        actionId: bigint;
+    } & proto.Receipt_OracleSymbolFeedResult>;
+    pause(): Promise<{
+        actionId: bigint;
+    }>;
+    unpause(): Promise<{
+        actionId: bigint;
+    }>;
+    freezeMarket(params: FreezeMarketParams): Promise<{
+        actionId: bigint;
+    } & proto.Receipt_MarketFreezeUpdated>;
+    unfreezeMarket(params: UnfreezeMarketParams): Promise<{
+        actionId: bigint;
+    } & proto.Receipt_MarketFreezeUpdated>;
+}

package/dist/nord/client/NordAdmin.js

@@ -0,0 +1,187 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordAdmin = void 0;
+const proto = __importStar(require("../../gen/nord_pb"));
+const protobuf_1 = require("@bufbuild/protobuf");
+const utils_1 = require("../../utils");
+const types_1 = require("../../types");
+const NordError_1 = require("../utils/NordError");
+const NordClient_1 = require("./NordClient");
+class NordAdmin extends NordClient_1.NordClient {
+    constructor(params) {
+        const { signFn: adminSignFn, ...clientParams } = params;
+        super(clientParams);
+        this.signFn = adminSignFn;
+    }
+    clone() {
+        const copy = new NordAdmin({
+            nord: this.nord,
+            address: this.address,
+            walletSignFn: this.walletSignFn,
+            sessionSignFn: this.sessionSignFn,
+            transactionSignFn: this.transactionSignFn,
+            connection: this.connection,
+            sessionId: this.sessionId,
+            sessionPubKey: new Uint8Array(this.sessionPubKey),
+            publicKey: this.publicKey,
+            signFn: this.signFn,
+        });
+        this.cloneClientState(copy);
+        return copy;
+    }
+    static fromUser(user, adminSignFn) {
+        return new NordAdmin({
+            nord: user.nord,
+            address: user.address,
+            walletSignFn: user.walletSignFn,
+            sessionSignFn: user.sessionSignFn,
+            transactionSignFn: user.transactionSignFn,
+            connection: user.connection,
+            sessionId: user.sessionId,
+            sessionPubKey: new Uint8Array(user.sessionPubKey),
+            publicKey: user.publicKey,
+            signFn: adminSignFn,
+        });
+    }
+    async submitAction(kind) {
+        try {
+            return await this.submitSignedAction(kind, async (message) => {
+                const signature = await this.signFn(message);
+                const signed = new Uint8Array(message.length + signature.length);
+                signed.set(message);
+                signed.set(signature, message.length);
+                return signed;
+            });
+        }
+        catch (error) {
+            throw new NordError_1.NordError(`Admin action ${kind.case} failed`, {
+                cause: error,
+            });
+        }
+    }
+    async createToken(params) {
+        (0, utils_1.checkPubKeyLength)(types_1.KeyType.Ed25519, params.solAddr.length);
+        const receipt = await this.submitAction({
+            case: "createToken",
+            value: (0, protobuf_1.create)(proto.Action_CreateTokenSchema, {
+                tokenDecimals: params.tokenDecimals,
+                weightBps: params.weightBps,
+                viewSymbol: params.viewSymbol,
+                oracleSymbol: params.oracleSymbol,
+                solAddr: params.solAddr,
+            }),
+        });
+        this.expectReceiptKind(receipt, "insertTokenResult", "create token");
+        return { actionId: receipt.actionId, ...receipt.kind.value };
+    }
+    async createMarket(params) {
+        const receipt = await this.submitAction({
+            case: "createMarket",
+            value: (0, protobuf_1.create)(proto.Action_CreateMarketSchema, {
+                sizeDecimals: params.sizeDecimals,
+                priceDecimals: params.priceDecimals,
+                imfBps: params.imfBps,
+                cmfBps: params.cmfBps,
+                mmfBps: params.mmfBps,
+                marketType: params.marketType,
+                viewSymbol: params.viewSymbol,
+                oracleSymbol: params.oracleSymbol,
+                baseTokenId: params.baseTokenId,
+            }),
+        });
+        this.expectReceiptKind(receipt, "insertMarketResult", "create market");
+        return { actionId: receipt.actionId, ...receipt.kind.value };
+    }
+    async pythSetWormholeGuardians(params) {
+        const receipt = await this.submitAction({
+            case: "pythSetWormholeGuardians",
+            value: (0, protobuf_1.create)(proto.Action_PythSetWormholeGuardiansSchema, {
+                guardianSetIndex: params.guardianSetIndex,
+                addresses: params.addresses,
+            }),
+        });
+        this.expectReceiptKind(receipt, "updateGuardianSetResult", "update wormhole guardians");
+        return { actionId: receipt.actionId, ...receipt.kind.value };
+    }
+    async pythSetSymbolFeed(params) {
+        const receipt = await this.submitAction({
+            case: "pythSetSymbolFeed",
+            value: (0, protobuf_1.create)(proto.Action_PythSetSymbolFeedSchema, {
+                oracleSymbol: params.oracleSymbol,
+                priceFeedId: params.priceFeedId,
+            }),
+        });
+        this.expectReceiptKind(receipt, "oracleSymbolFeedResult", "set symbol feed");
+        return { actionId: receipt.actionId, ...receipt.kind.value };
+    }
+    async pause() {
+        const receipt = await this.submitAction({
+            case: "pause",
+            value: (0, protobuf_1.create)(proto.Action_PauseSchema, {}),
+        });
+        this.expectReceiptKind(receipt, "paused", "pause");
+        return { actionId: receipt.actionId };
+    }
+    async unpause() {
+        const receipt = await this.submitAction({
+            case: "unpause",
+            value: (0, protobuf_1.create)(proto.Action_UnpauseSchema, {}),
+        });
+        this.expectReceiptKind(receipt, "unpaused", "unpause");
+        return { actionId: receipt.actionId };
+    }
+    async freezeMarket(params) {
+        const receipt = await this.submitAction({
+            case: "freezeMarket",
+            value: (0, protobuf_1.create)(proto.Action_FreezeMarketSchema, {
+                marketId: params.marketId,
+            }),
+        });
+        this.expectReceiptKind(receipt, "marketFreezeUpdated", "freeze market");
+        return { actionId: receipt.actionId, ...receipt.kind.value };
+    }
+    async unfreezeMarket(params) {
+        const receipt = await this.submitAction({
+            case: "unfreezeMarket",
+            value: (0, protobuf_1.create)(proto.Action_UnfreezeMarketSchema, {
+                marketId: params.marketId,
+            }),
+        });
+        this.expectReceiptKind(receipt, "marketFreezeUpdated", "unfreeze market");
+        return { actionId: receipt.actionId, ...receipt.kind.value };
+    }
+}
+exports.NordAdmin = NordAdmin;

package/dist/nord/client/NordClient.d.ts

@@ -0,0 +1,42 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import type { Transaction } from "@solana/web3.js";
+import * as proto from "../../gen/nord_pb";
+import { Nord } from "./Nord";
+type ReceiptKind = NonNullable<proto.Receipt["kind"]>;
+type ExtractReceiptKind<K extends ReceiptKind["case"]> = Extract<ReceiptKind, {
+    case: K;
+}>;
+export interface NordClientParams {
+    nord: Nord;
+    address: PublicKey;
+    walletSignFn: (message: Uint8Array | string) => Promise<Uint8Array>;
+    sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
+    transactionSignFn: <T extends Transaction>(tx: T) => Promise<T>;
+    connection?: Connection;
+    sessionId?: bigint;
+    sessionPubKey: Uint8Array;
+    publicKey: PublicKey;
+}
+export declare abstract class NordClient {
+    readonly nord: Nord;
+    readonly address: PublicKey;
+    readonly walletSignFn: (message: Uint8Array | string) => Promise<Uint8Array>;
+    readonly sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
+    readonly transactionSignFn: <T extends Transaction>(tx: T) => Promise<T>;
+    connection: Connection;
+    sessionId?: bigint;
+    sessionPubKey: Uint8Array;
+    publicKey: PublicKey;
+    lastTs: number;
+    protected actionNonce: number;
+    protected constructor(params: NordClientParams);
+    protected submitSignedAction(kind: proto.Action["kind"], makeSignedMessage: (message: Uint8Array) => Promise<Uint8Array>): Promise<proto.Receipt>;
+    protected nextActionNonce(): number;
+    protected cloneClientState(target: NordClient): void;
+    getSolanaPublicKey(): PublicKey;
+    protected expectReceiptKind<K extends ReceiptKind["case"]>(receipt: proto.Receipt, expected: K, action: string): asserts receipt is proto.Receipt & {
+        kind: ExtractReceiptKind<K>;
+    };
+    protected formatReceiptError(receipt: proto.Receipt): string;
+}
+export {};

package/dist/nord/client/NordClient.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const proto = __importStar(require("../../gen/nord_pb"));
+const actions_1 = require("../api/actions");
+const NordError_1 = require("../utils/NordError");
+class NordClient {
+    constructor(params) {
+        this.lastTs = 0;
+        this.actionNonce = 0;
+        this.nord = params.nord;
+        this.address = params.address;
+        this.walletSignFn = params.walletSignFn;
+        this.sessionSignFn = params.sessionSignFn;
+        this.transactionSignFn = params.transactionSignFn;
+        this.connection =
+            params.connection ??
+                new web3_js_1.Connection(params.nord.solanaUrl, {
+                    commitment: "confirmed",
+                });
+        this.sessionId = params.sessionId;
+        this.sessionPubKey = new Uint8Array(params.sessionPubKey);
+        this.publicKey = params.publicKey;
+    }
+    async submitSignedAction(kind, makeSignedMessage) {
+        const nonce = this.nextActionNonce();
+        const currentTimestamp = await this.nord.getTimestamp();
+        const action = (0, actions_1.createAction)(currentTimestamp, nonce, kind);
+        return (0, actions_1.sendAction)(this.nord.webServerUrl, makeSignedMessage, action);
+    }
+    nextActionNonce() {
+        return ++this.actionNonce;
+    }
+    cloneClientState(target) {
+        target.connection = this.connection;
+        target.sessionId = this.sessionId;
+        target.sessionPubKey = new Uint8Array(this.sessionPubKey);
+        target.publicKey = this.publicKey;
+        target.lastTs = this.lastTs;
+        target.actionNonce = this.actionNonce;
+    }
+    getSolanaPublicKey() {
+        return this.address;
+    }
+    expectReceiptKind(receipt, expected, action) {
+        if (receipt.kind?.case !== expected) {
+            const label = this.formatReceiptError(receipt);
+            throw new NordError_1.NordError(`Failed to ${action}: ${label}`);
+        }
+    }
+    formatReceiptError(receipt) {
+        if (receipt.kind?.case === "err") {
+            const err = receipt.kind.value;
+            return proto.Error[err] ?? err.toString();
+        }
+        return receipt.kind?.case ?? "unknown";
+    }
+}
+exports.NordClient = NordClient;

package/dist/nord/client/NordUser.d.ts

@@ -3,8 +3,8 @@ import Decimal from "decimal.js";
 import { FillMode, Side, SPLTokenInfo, QuoteSize, TriggerKind } from "../../types";
 import * as proto from "../../gen/nord_pb";
 import { BigIntValue } from "../../utils";
-import type { AccountTriggerInfo, TriggerHistoryPage, HistoryTriggerQuery } from "../api/triggers";
 import { Nord } from "./Nord";
+import { NordClient } from "./NordClient";
 /**
  * Parameters for creating a NordUser instance
  */
@@ -48,6 +48,7 @@ export interface PlaceOrderParams {
     quoteSize?: QuoteSize;
     /** Account ID to place the order from */
     accountId?: number;
+    clientOrderId?: BigIntValue;
 }
 export interface AddTriggerParams {
     marketId: number;
@@ -106,17 +107,7 @@ export interface UserAtomicSubaction {
 /**
  * User class for interacting with the Nord protocol
  */
-export declare class NordUser {
-    /** Nord client instance */
-    readonly nord: Nord;
-    /** User's blockchain address */
-    readonly address: PublicKey;
-    /** Function to sign messages with the user's wallet */
-    readonly walletSignFn: (message: Uint8Array | string) => Promise<Uint8Array>;
-    /** Function to sign messages with the user's session key */
-    readonly sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
-    /** Function to sign transactions with the user's wallet */
-    readonly transactionSignFn: <T extends Transaction>(tx: T) => Promise<T>;
+export declare class NordUser extends NordClient {
     /** User balances by token symbol */
     balances: {
         [key: string]: {
@@ -156,18 +147,6 @@ export declare class NordUser {
     };
     /** User's account IDs */
     accountIds?: number[];
-    /** Current session ID */
-    sessionId?: bigint;
-    /** User's public key */
-    publicKey: PublicKey;
-    /** Session public key */
-    sessionPubKey: Uint8Array;
-    /** Last timestamp used */
-    lastTs: number;
-    /** Last nonce used */
-    lastNonce: number;
-    /** Solana connection */
-    connection: Connection;
     /** SPL token information */
     splTokenInfos: SPLTokenInfo[];
     /**
@@ -202,7 +181,7 @@ export declare class NordUser {
      */
     getAssociatedTokenAccount(mint: PublicKey): Promise<PublicKey>;
     /**
-     * Deposit SPL tokens to the bridge
+     * Deposit SPL tokens to the app
      *
      * @param amount - Amount to deposit
      * @param tokenId - Token ID
@@ -213,7 +192,7 @@ export declare class NordUser {
      */
     depositSpl(amount: number, tokenId: number, recipient?: PublicKey): Promise<string>;
     /**
-     * Deposit SPL tokens to the bridge
+     * Deposit SPL tokens to the app
      *
      * @param amount - Amount to deposit
      * @param tokenId - Token ID
@@ -234,6 +213,7 @@ export declare class NordUser {
      * @returns Nonce as number
      */
     getNonce(): number;
+    private submitSessionAction;
     /**
      * Update account IDs for this user
      *
@@ -323,24 +303,6 @@ export declare class NordUser {
     removeTrigger(params: RemoveTriggerParams): Promise<{
         actionId: bigint;
     }>;
-    /**
-     * Fetch active triggers for an account.
-     *
-     * @param params Optional parameters containing an explicit account id.
-     * @throws {NordError} If no account can be resolved or the request fails.
-     */
-    getAccountTriggers(params?: {
-        accountId?: number;
-    }): Promise<AccountTriggerInfo[]>;
-    /**
-     * Fetch trigger history for an account.
-     *
-     * @param params Optional parameters with account id and history query filters.
-     * @throws {NordError} If no account can be resolved or the request fails.
-     */
-    getAccountTriggerHistory(params: HistoryTriggerQuery & {
-        accountId?: number;
-    }): Promise<TriggerHistoryPage>;
     /**
      * Transfer tokens to another account
      *
@@ -397,10 +359,4 @@ export declare class NordUser {
             [symbol: string]: string;
         };
     }>;
-    /**
-     * Get the Solana public key derived from the address
-     *
-     * @returns The Solana public key
-     */
-    getSolanaPublicKey(): PublicKey;
 }