@n1xyz/nord-ts 0.0.19 → 0.0.21

package/dist/nord/client/NordUser.js

@@ -0,0 +1,652 @@
+"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.NordUser = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const ed = __importStar(require("@noble/ed25519"));
+const sha512_1 = require("@noble/hashes/sha512");
+ed.etc.sha512Sync = sha512_1.sha512;
+const proton_1 = require("@n1xyz/proton");
+const utils_1 = require("../../utils");
+const actions_1 = require("../api/actions");
+const NordError_1 = require("../utils/NordError");
+/**
+ * User class for interacting with the Nord protocol
+ */
+class NordUser {
+    /**
+     * Create a new NordUser instance
+     *
+     * @param params - Parameters for creating a NordUser
+     * @throws {NordError} If required parameters are missing
+     */
+    constructor({ address, nord, publicKey, sessionPubKey, sessionSignFn, transactionSignFn, walletSignFn, connection, sessionId, }) {
+        /** User balances by token symbol */
+        this.balances = {};
+        /** User positions by account ID */
+        this.positions = {};
+        /** User margins by account ID */
+        this.margins = {};
+        /** Last timestamp used */
+        this.lastTs = 0;
+        /** Last nonce used */
+        this.lastNonce = 0;
+        /** SPL token information */
+        this.splTokenInfos = [];
+        if (!walletSignFn) {
+            throw new NordError_1.NordError("Wallet sign function is required");
+        }
+        if (!sessionSignFn) {
+            throw new NordError_1.NordError("Session sign function is required");
+        }
+        if (!sessionPubKey) {
+            throw new NordError_1.NordError("Session public key is required");
+        }
+        try {
+            this.address = new web3_js_1.PublicKey(address);
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Invalid Solana address", { cause: error });
+        }
+        this.nord = nord;
+        this.walletSignFn = walletSignFn;
+        this.sessionSignFn = sessionSignFn;
+        this.transactionSignFn = transactionSignFn;
+        this.sessionPubKey = sessionPubKey;
+        this.publicKey = publicKey;
+        this.connection =
+            connection ||
+                new web3_js_1.Connection(nord.solanaUrl, {
+                    commitment: "confirmed",
+                });
+        // Set sessionId if provided
+        if (sessionId !== undefined) {
+            this.sessionId = sessionId;
+        }
+        // Convert tokens from info endpoint to SPLTokenInfo
+        if (this.nord.tokens && this.nord.tokens.length > 0) {
+            this.splTokenInfos = this.nord.tokens.map((token) => ({
+                mint: token.mintAddr, // Use mintAddr as mint
+                precision: token.decimals,
+                tokenId: token.tokenId,
+                name: token.symbol,
+            }));
+        }
+    }
+    /**
+     * Create a clone of this NordUser instance
+     *
+     * @returns A new NordUser instance with the same properties
+     */
+    clone() {
+        const cloned = new NordUser({
+            nord: this.nord,
+            address: this.address.toBase58(),
+            walletSignFn: this.walletSignFn,
+            sessionSignFn: this.sessionSignFn,
+            transactionSignFn: this.transactionSignFn,
+            connection: this.connection,
+            sessionPubKey: this.sessionPubKey,
+            publicKey: this.publicKey,
+        });
+        // Copy other properties
+        cloned.balances = { ...this.balances };
+        cloned.positions = { ...this.positions };
+        cloned.margins = { ...this.margins };
+        cloned.accountIds = this.accountIds ? [...this.accountIds] : undefined;
+        cloned.sessionId = this.sessionId;
+        cloned.publicKey = this.publicKey;
+        cloned.lastTs = this.lastTs;
+        cloned.lastNonce = this.lastNonce;
+        cloned.splTokenInfos = [...this.splTokenInfos];
+        return cloned;
+    }
+    /**
+     * Create a NordUser from a private key
+     *
+     * @param nord - Nord instance
+     * @param privateKey - Private key as string or Uint8Array
+     * @param connection - Solana connection (optional)
+     * @returns NordUser instance
+     * @throws {NordError} If the private key is invalid
+     */
+    static fromPrivateKey(nord, privateKey, connection) {
+        try {
+            const keypair = (0, utils_1.keypairFromPrivateKey)(privateKey);
+            const publicKey = keypair.publicKey;
+            // Create a signing function that uses the keypair but doesn't expose it
+            const walletSignFn = async (message) => {
+                function toHex(buffer) {
+                    return Array.from(buffer)
+                        .map((byte) => byte.toString(16).padStart(2, "0"))
+                        .join("");
+                }
+                const messageBuffer = new TextEncoder().encode(toHex(message));
+                // Use ed25519 to sign the message
+                const signature = ed.sign(messageBuffer, keypair.secretKey.slice(0, 32));
+                return signature;
+            };
+            const sessionSignFn = async (message) => {
+                // Use ed25519 to sign the message
+                return ed.sign(message, keypair.secretKey.slice(0, 32));
+            };
+            // Create a transaction signing function
+            const transactionSignFn = async (transaction) => {
+                // This is a basic implementation - actual implementation would depend on the transaction type
+                if (transaction.sign) {
+                    // Solana transaction
+                    transaction.sign(keypair);
+                    return transaction;
+                }
+                // For other transaction types, would need specific implementation
+                throw new NordError_1.NordError("Unsupported transaction type for signing");
+            };
+            return new NordUser({
+                nord,
+                address: publicKey.toBase58(),
+                walletSignFn,
+                sessionSignFn,
+                transactionSignFn,
+                connection,
+                publicKey,
+                sessionPubKey: publicKey.toBytes(), // Use the public key derived from the private key as the session public key
+            });
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Failed to create NordUser from private key", {
+                cause: error,
+            });
+        }
+    }
+    /**
+     * Get the associated token account for a token mint
+     *
+     * @param mint - Token mint address
+     * @returns Associated token account address
+     * @throws {NordError} If required parameters are missing or operation fails
+     */
+    async getAssociatedTokenAccount(mint) {
+        if (!this.getSolanaPublicKey()) {
+            throw new NordError_1.NordError("Solana public key is required to get associated token account");
+        }
+        try {
+            // Get the token program ID from the mint account
+            const mintAccount = await this.connection.getAccountInfo(mint);
+            if (!mintAccount) {
+                throw new NordError_1.NordError("Mint account not found");
+            }
+            const tokenProgramId = mintAccount.owner;
+            // Validate that the mint is owned by a supported SPL token program
+            if (!tokenProgramId.equals(spl_token_1.TOKEN_PROGRAM_ID) &&
+                !tokenProgramId.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)) {
+                throw new NordError_1.NordError("Mint Account is not owned by a supported SPL token program");
+            }
+            const associatedTokenAddress = await (0, spl_token_1.getAssociatedTokenAddress)(mint, this.getSolanaPublicKey(), false, tokenProgramId, spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID);
+            return associatedTokenAddress;
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Failed to get associated token account", {
+                cause: error,
+            });
+        }
+    }
+    /**
+     * Deposit SPL tokens to the bridge
+     *
+     * @param amount - Amount to deposit
+     * @param tokenId - Token ID
+     * @param recipient - Recipient address; defaults to the user's address
+     * @returns Transaction signature
+     * @deprecated Use deposit instead
+     * @throws {NordError} If required parameters are missing or operation fails
+     */
+    async depositSpl(amount, tokenId, recipient) {
+        return this.deposit({ amount, tokenId, recipient });
+    }
+    /**
+     * Deposit SPL tokens to the bridge
+     *
+     * @param amount - Amount to deposit
+     * @param tokenId - Token ID
+     * @param recipient - Recipient address; defaults to the user's address
+     * @returns Transaction signature
+     * @throws {NordError} If required parameters are missing or operation fails
+     */
+    async deposit({ amount, tokenId, recipient, }) {
+        try {
+            // Find the token info
+            const tokenInfo = this.splTokenInfos.find((t) => t.tokenId === tokenId);
+            if (!tokenInfo) {
+                throw new NordError_1.NordError(`Token with ID ${tokenId} not found`);
+            }
+            const mint = new web3_js_1.PublicKey(tokenInfo.mint);
+            const fromAccount = await this.getAssociatedTokenAccount(mint);
+            const payer = this.getSolanaPublicKey();
+            const { ix, extraSigner } = await this.nord.protonClient.buildDepositIx({
+                payer,
+                recipient: recipient ?? payer,
+                quantAmount: (0, proton_1.floatToScaledBigIntLossy)(amount, tokenInfo.precision),
+                mint,
+                sourceTokenAccount: fromAccount,
+            });
+            const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
+            const tx = new web3_js_1.Transaction();
+            tx.add(ix);
+            tx.recentBlockhash = blockhash;
+            tx.feePayer = payer;
+            const signedTx = await this.transactionSignFn(tx);
+            signedTx.partialSign(extraSigner);
+            const signature = await this.connection.sendRawTransaction(signedTx.serialize());
+            return signature;
+        }
+        catch (error) {
+            throw new NordError_1.NordError(`Failed to deposit ${amount} of token ID ${tokenId}`, { cause: error });
+        }
+    }
+    /**
+     * Get a new nonce for actions
+     *
+     * @returns Nonce as number
+     */
+    getNonce() {
+        return ++this.lastNonce;
+    }
+    /**
+     * Update account IDs for this user
+     *
+     * @throws {NordError} If the operation fails
+     */
+    async updateAccountId() {
+        try {
+            if (!this.publicKey) {
+                throw new NordError_1.NordError("Public key is required to update account ID");
+            }
+            const resp = await this.nord.getUser({
+                pubkey: this.publicKey.toBase58(),
+            });
+            if (!resp) {
+                throw new NordError_1.NordError(`User ${this.publicKey.toBase58()} not found`);
+            }
+            this.accountIds = resp.accountIds;
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Failed to update account ID", { cause: error });
+        }
+    }
+    /**
+     * Fetch user information including balances and orders
+     *
+     * @throws {NordError} If the operation fails
+     */
+    async fetchInfo() {
+        if (this.accountIds !== undefined) {
+            const accountsData = await Promise.all(this.accountIds.map(async (accountId) => {
+                const response = await (0, utils_1.checkedFetch)(`${this.nord.webServerUrl}/account/${accountId}`);
+                const accountData = (await response.json());
+                // Ensure we have the correct accountId
+                return {
+                    ...accountData,
+                    accountId,
+                };
+            }));
+            for (const accountData of accountsData) {
+                // Process balances
+                this.balances[accountData.accountId] = [];
+                for (const balance of accountData.balances) {
+                    this.balances[accountData.accountId].push({
+                        accountId: accountData.accountId,
+                        balance: balance.amount,
+                        symbol: balance.token,
+                    });
+                }
+                // Process positions
+                this.positions[accountData.accountId] = accountData.positions;
+                // Process margins
+                this.margins[accountData.accountId] = accountData.margins;
+            }
+        }
+    }
+    /**
+     * Refresh the user's session
+     *
+     * @throws {NordError} If the operation fails
+     */
+    async refreshSession() {
+        this.sessionId = await (0, actions_1.createSession)(this.nord.webServerUrl, this.walletSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+            userPubkey: (0, utils_1.optExpect)(this.publicKey.toBytes(), "No user's public key"),
+            sessionPubkey: this.sessionPubKey,
+        });
+    }
+    /**
+     * Revoke a session
+     *
+     * @param sessionId - Session ID to revoke
+     * @throws {NordError} If the operation fails
+     */
+    async revokeSession(sessionId) {
+        try {
+            await (0, actions_1.revokeSession)(this.nord.webServerUrl, this.walletSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sessionId,
+            });
+        }
+        catch (error) {
+            throw new NordError_1.NordError(`Failed to revoke session ${sessionId}`, {
+                cause: error,
+            });
+        }
+    }
+    /**
+     * Checks if the session is valid
+     * @private
+     * @throws {NordError} If the session is not valid
+     */
+    checkSessionValidity() {
+        if (this.sessionId === undefined || this.sessionId === BigInt(0)) {
+            throw new NordError_1.NordError("Invalid or empty session ID. Please create or refresh your session.");
+        }
+    }
+    /**
+     * Withdraw tokens from the exchange
+     *
+     * @param tokenId - Token ID to withdraw
+     * @param amount - Amount to withdraw
+     * @throws {NordError} If the operation fails
+     */
+    async withdraw({ amount, tokenId, }) {
+        try {
+            this.checkSessionValidity();
+            const { actionId } = await (0, actions_1.withdraw)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sizeDecimals: (0, utils_1.findToken)(this.nord.tokens, tokenId).decimals,
+                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+                tokenId: tokenId,
+                amount,
+            });
+            return { actionId };
+        }
+        catch (error) {
+            throw new NordError_1.NordError(`Failed to withdraw ${amount} of token ID ${tokenId}`, { cause: error });
+        }
+    }
+    /**
+     * Place an order on the exchange
+     *
+     * @param params - Order parameters
+     * @returns Order ID if successful
+     * @throws {NordError} If the operation fails
+     */
+    async placeOrder(params) {
+        try {
+            this.checkSessionValidity();
+            const market = (0, utils_1.findMarket)(this.nord.markets, params.marketId);
+            if (!market) {
+                throw new NordError_1.NordError(`Market with ID ${params.marketId} not found`);
+            }
+            return (0, actions_1.placeOrder)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+                senderId: params.accountId,
+                sizeDecimals: market.sizeDecimals,
+                priceDecimals: market.priceDecimals,
+                marketId: params.marketId,
+                side: params.side,
+                fillMode: params.fillMode,
+                isReduceOnly: params.isReduceOnly,
+                size: params.size,
+                price: params.price,
+                quoteSize: params.quoteSize,
+            });
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Failed to place order", { cause: error });
+        }
+    }
+    /**
+     * Cancel an order
+     *
+     * @param orderId - Order ID to cancel
+     * @param providedAccountId - Account ID that placed the order
+     * @returns Action ID if successful
+     * @throws {NordError} If the operation fails
+     */
+    async cancelOrder(orderId, providedAccountId) {
+        const accountId = providedAccountId != null ? providedAccountId : this.accountIds?.[0];
+        try {
+            this.checkSessionValidity();
+            return (0, actions_1.cancelOrder)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+                senderId: accountId,
+                orderId,
+            });
+        }
+        catch (error) {
+            throw new NordError_1.NordError(`Failed to cancel order ${orderId}`, {
+                cause: error,
+            });
+        }
+    }
+    /**
+     * Transfer tokens to another account
+     *
+     * @param params - Transfer parameters
+     * @throws {NordError} If the operation fails
+     */
+    async transferToAccount(params) {
+        try {
+            this.checkSessionValidity();
+            const token = (0, utils_1.findToken)(this.nord.tokens, params.tokenId);
+            await (0, actions_1.transfer)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+                fromAccountId: (0, utils_1.optExpect)(params.fromAccountId, "No source account"),
+                toAccountId: (0, utils_1.optExpect)(params.toAccountId, "No target account"),
+                tokenId: params.tokenId,
+                tokenDecimals: token.decimals,
+                amount: params.amount,
+            });
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Failed to transfer tokens", { cause: error });
+        }
+    }
+    /**
+     * Execute up to four place/cancel operations atomically.
+     * Per Market:
+     * 1. cancels can only be in the start (one cannot predict future order ids)
+     * 2. intermediate trades can trade only
+     * 3. placements go last
+     *
+     * Across Markets, order action can be any
+     *
+     * @param userActions array of user-friendly subactions
+     * @param providedAccountId optional account performing the action (defaults to first account)
+     */
+    async atomic(userActions, providedAccountId) {
+        try {
+            this.checkSessionValidity();
+            const accountId = providedAccountId != null ? providedAccountId : this.accountIds?.[0];
+            if (accountId == null) {
+                throw new NordError_1.NordError("Account ID is undefined. Make sure to call updateAccountId() before atomic operations.");
+            }
+            const apiActions = userActions.map((act) => {
+                if (act.kind === "place") {
+                    const market = (0, utils_1.findMarket)(this.nord.markets, act.marketId);
+                    if (!market) {
+                        throw new NordError_1.NordError(`Market ${act.marketId} not found`);
+                    }
+                    return {
+                        kind: "place",
+                        marketId: act.marketId,
+                        side: act.side,
+                        fillMode: act.fillMode,
+                        isReduceOnly: act.isReduceOnly,
+                        sizeDecimals: market.sizeDecimals,
+                        priceDecimals: market.priceDecimals,
+                        size: act.size,
+                        price: act.price,
+                        quoteSizeSize: act.quoteSize, // treated as quote size; we pass only size component
+                        quoteSizePrice: undefined,
+                        clientOrderId: act.clientOrderId,
+                    };
+                }
+                return {
+                    kind: "cancel",
+                    orderId: act.orderId,
+                };
+            });
+            const result = await (0, actions_1.atomic)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.getTimestamp(), this.getNonce(), {
+                sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+                accountId: accountId,
+                actions: apiActions,
+            });
+            return result;
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Atomic operation failed", { cause: error });
+        }
+    }
+    /**
+     * Helper function to retry a promise with exponential backoff
+     *
+     * @param fn - Function to retry
+     * @param maxRetries - Maximum number of retries
+     * @param initialDelay - Initial delay in milliseconds
+     * @returns Promise result
+     */
+    async retryWithBackoff(fn, maxRetries = 3, initialDelay = 500) {
+        let retries = 0;
+        let delay = initialDelay;
+        while (true) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                if (retries >= maxRetries) {
+                    throw error;
+                }
+                // Check if error is rate limiting related
+                const isRateLimitError = error instanceof Error &&
+                    (error.message.includes("rate limit") ||
+                        error.message.includes("429") ||
+                        error.message.includes("too many requests"));
+                if (!isRateLimitError) {
+                    throw error;
+                }
+                retries++;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                delay *= 2; // Exponential backoff
+            }
+        }
+    }
+    /**
+     * Get user's token balances on Solana chain using mintAddr
+     *
+     * @param options - Optional parameters
+     * @param options.includeZeroBalances - Whether to include tokens with zero balance (default: true)
+     * @param options.includeTokenAccounts - Whether to include token account addresses in the result (default: false)
+     * @param options.maxConcurrent - Maximum number of concurrent requests (default: 5)
+     * @param options.maxRetries - Maximum number of retries for rate-limited requests (default: 3)
+     * @returns Object with token balances and optional token account addresses
+     * @throws {NordError} If required parameters are missing or operation fails
+     */
+    async getSolanaBalances(options = {}) {
+        const { includeZeroBalances = true, includeTokenAccounts = false, maxConcurrent = 5, maxRetries = 3, } = options;
+        if (!this.connection || !this.getSolanaPublicKey()) {
+            throw new NordError_1.NordError("Connection and Solana public key are required to get Solana balances");
+        }
+        const balances = {};
+        const tokenAccounts = {};
+        try {
+            // Get SOL balance (native token)
+            const solBalance = await this.retryWithBackoff(() => this.connection.getBalance(this.getSolanaPublicKey()), maxRetries);
+            balances["SOL"] = solBalance / 1e9; // Convert lamports to SOL
+            if (includeTokenAccounts) {
+                tokenAccounts["SOL"] = this.getSolanaPublicKey().toString();
+            }
+            // Get SPL token balances using mintAddr from Nord tokens
+            if (this.nord.tokens && this.nord.tokens.length > 0) {
+                const tokens = this.nord.tokens.filter((token) => !!token.mintAddr);
+                // Process tokens in batches to avoid rate limiting
+                for (let i = 0; i < tokens.length; i += maxConcurrent) {
+                    const batch = tokens.slice(i, i + maxConcurrent);
+                    // Process batch in parallel
+                    const batchPromises = batch.map(async (token) => {
+                        try {
+                            const mint = new web3_js_1.PublicKey(token.mintAddr);
+                            const associatedTokenAddress = await this.retryWithBackoff(() => (0, spl_token_1.getAssociatedTokenAddress)(mint, this.getSolanaPublicKey()), maxRetries);
+                            if (includeTokenAccounts) {
+                                tokenAccounts[token.symbol] = associatedTokenAddress.toString();
+                            }
+                            try {
+                                const tokenBalance = await this.retryWithBackoff(() => this.connection.getTokenAccountBalance(associatedTokenAddress), maxRetries);
+                                const balance = Number(tokenBalance.value.uiAmount);
+                                if (balance > 0 || includeZeroBalances) {
+                                    balances[token.symbol] = balance;
+                                }
+                            }
+                            catch {
+                                // Token account might not exist yet, set balance to 0
+                                if (includeZeroBalances) {
+                                    balances[token.symbol] = 0;
+                                }
+                            }
+                        }
+                        catch (error) {
+                            console.error(`Error getting balance for token ${token.symbol}:`, error);
+                            if (includeZeroBalances) {
+                                balances[token.symbol] = 0;
+                            }
+                        }
+                    });
+                    // Wait for current batch to complete before processing next batch
+                    await Promise.all(batchPromises);
+                }
+            }
+            return includeTokenAccounts ? { balances, tokenAccounts } : { balances };
+        }
+        catch (error) {
+            throw new NordError_1.NordError("Failed to get Solana token balances", {
+                cause: error,
+            });
+        }
+    }
+    /**
+     * Get the Solana public key derived from the address
+     *
+     * @returns The Solana public key
+     */
+    getSolanaPublicKey() {
+        return this.address;
+    }
+}
+exports.NordUser = NordUser;

package/dist/nord/index.d.ts

@@ -0,0 +1,7 @@
+export { Nord } from "./client/Nord";
+export { NordUser } from "./client/NordUser";
+export { NordError } from "./utils/NordError";
+export * from "./api/core";
+export * from "./api/metrics";
+export * from "./api/actions";
+export * from "./models/Subscriber";

package/dist/nord/index.js

@@ -0,0 +1,31 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordError = exports.NordUser = exports.Nord = void 0;
+// Export main client classes
+var Nord_1 = require("./client/Nord");
+Object.defineProperty(exports, "Nord", { enumerable: true, get: function () { return Nord_1.Nord; } });
+var NordUser_1 = require("./client/NordUser");
+Object.defineProperty(exports, "NordUser", { enumerable: true, get: function () { return NordUser_1.NordUser; } });
+// Export utility classes
+var NordError_1 = require("./utils/NordError");
+Object.defineProperty(exports, "NordError", { enumerable: true, get: function () { return NordError_1.NordError; } });
+// Export API modules
+__exportStar(require("./api/core"), exports);
+__exportStar(require("./api/metrics"), exports);
+__exportStar(require("./api/actions"), exports);
+// Export models
+__exportStar(require("./models/Subscriber"), exports);