@n1xyz/nord-ts 0.0.1 → 0.0.4

package/.eslintrc.js

@@ -1,7 +1,9 @@
 module.exports = {
+  root: true,
   env: {
     browser: true,
     es2021: true,
+    node: true,
   },
   extends: [
     "prettier",
@@ -13,8 +15,17 @@ module.exports = {
   parserOptions: {
     ecmaVersion: "latest",
     sourceType: "module",
+    project: "./tsconfig.json",
+    tsconfigRootDir: __dirname,
   },
   rules: {
     "@typescript-eslint/no-explicit-any": "warn",
+    "@typescript-eslint/no-unused-vars": ["warn", { argsIgnorePattern: "^_" }],
   },
+  ignorePatterns: [
+    "dist",
+    "node_modules",
+    ".git",
+    "docs",
+  ],
 };

package/README.md

@@ -1,110 +1,193 @@
 # nord-ts
 
-This package provides an interface to interact with the Nord exchange. Functionality includes generating Action messages, signing with `Ed25119` and sending payloads. There are also various util functions and interfaces provided.
+This package provides an interface to interact with the Nord exchange. The core components are `Nord` and `NordUser` classes which enable market data access, trading operations, and account management.
 
 ## Installation
 
-### npm
-
 ```bash
+# npm
 npm install nord-ts
-```
-
-### yarn
 
-```bash
+# yarn
 yarn add nord-ts
 ```
 
-## Features
+## Key Components
+
+### Nord
+
+The `Nord` class is the main entry point for interacting with the Nord exchange:
 
-- create a new client with a new user and a new session ( `createClient` )
-- generate Action messages ( `deposit` | `withdraw` | `placeOrder` | `cancelOrderById` )
-- Cryptographic support for `Ed25119` key types.
-- Message signing and transmission capabilities.
-- Data serialization and deserialization for protobuf.
+- Provides market data access (orderbooks, trades, etc.)
+- Manages WebSocket connections for real-time updates
+- Offers utility methods for timestamp and nonce generation
 
-## Usage
+### NordUser
 
-### Basic Examples
+The `NordUser` class represents a user account on the Nord exchange:
 
-#### Client
+- Handles authentication and session management
+- Provides trading functionality (place/cancel orders)
+- Manages deposits and withdrawals
+- Tracks user balances, positions, and orders
+
+## Usage Examples
+
+### Initializing Nord
 
 ```typescript
-import { Nord, types } from "nord-ts";
+import { Nord } from "nord-ts";
 
-const c = await Nord.createClient({
-  url: 'http://localhost:3000',
-  privateKey: /* secp256k1 sec1 compressed secret key */,
+// Create a Nord instance
+const nord = new Nord({
+  webServerUrl: 'https://api.nord.exchange',
+  solanaProgramId: 'your_solana_program_id',
+  solanaUrl: 'https://api.mainnet-beta.solana.com',
 });
 
-const tokenId = 0;
-try {
-    await c.deposit(tokenId, 10000000);
-} catch (e) {
-    console.log(`couldn't do deposit, reason: ${e}`)
-}
+// Initialize and fetch market data
+await nord.fetchNordInfo();
+```
+
+### Creating a User from Private Key
+
+```typescript
+import { Nord, NordUser } from "nord-ts";
+import { Connection } from "@solana/web3.js";
+
+// Create Nord instance
+const nord = new Nord({
+  webServerUrl: 'https://api.nord.exchange',
+  solanaProgramId: 'your_solana_program_id',
+  solanaUrl: 'https://api.mainnet-beta.solana.com',
+});
+
+// Optional Solana connection
+const connection = new Connection('https://api.mainnet-beta.solana.com');
+
+// Create user from private key
+const user = NordUser.fromPrivateKey(
+  nord,
+  'your_private_key', // Can be string or Uint8Array
+  connection // Optional
+);
+
+// Fetch user account information
+await user.updateAccountId();
+await user.fetchInfo();
+```
+
+### Trading Operations
+
+```typescript
+import { Nord, NordUser, Side, FillMode } from "nord-ts";
+
+// Assuming nord and user are already initialized
 
+// Place a limit order
 try {
-    await c.withdraw(tokenId, 100);
-} catch (e) {
-    console.log(`couldn't do withdraw, reason: ${e}`)
+  const orderId = await user.placeOrder({
+    marketId: 0, // BTC/USDC market
+    side: Side.Bid, // Buy
+    fillMode: FillMode.Limit,
+    isReduceOnly: false,
+    size: 0.1, // 0.1 BTC
+    price: 50000, // $50,000 per BTC
+  });
+  
+  console.log(`Order placed with ID: ${orderId}`);
+  
+  // Cancel the order
+  await user.cancelOrder(orderId);
+} catch (error) {
+  console.error(`Trading error: ${error}`);
 }
+```
+
+### Deposits and Withdrawals
+
+```typescript
+import { Nord, NordUser } from "nord-ts";
+
+// Assuming nord and user are already initialized
 
-const marketId = 0;
-const size = 1;
-const price = 1;
-const isReduceOnly = false;
-let orderID: number = 0;
+// Withdraw tokens
 try {
-    orderId = await c.placeOrder(
-        marketId,
-        Side.Ask,
-        FillMode.Limit,
-        isReduceOnly,
-        size,
-        price
-    );
-} catch (e) {
-    console.log(`couldn't do placeOrder, reason: ${e}`)
+  const tokenId = 0; // USDC
+  const amount = 100; // 100 USDC
+  
+  await user.withdraw(tokenId, amount);
+  console.log(`Successfully withdrew ${amount} of token ID ${tokenId}`);
+} catch (error) {
+  console.error(`Withdrawal error: ${error}`);
 }
 
+// For Solana SPL tokens
 try {
-    await c.cancelOrder(
-        marketId,
-        orderId
-    );
-} catch (e) {
-    console.log(`couldn't do cancelOrder, reason: ${e}`)
+  const tokenId = 1; // SOL
+  const amount = 1; // 1 SOL
+  
+  const txId = await user.depositSpl(amount, tokenId);
+  console.log(`Deposit transaction ID: ${txId}`);
+} catch (error) {
+  console.error(`Deposit error: ${error}`);
 }
 ```
 
-#### Subscriber
+### Market Data
 
 ```typescript
-import { Subscriber } from "./nord";
+import { Nord } from "nord-ts";
+
+// Assuming nord is already initialized
 
-const STREAM_URL =
-  "ws://localhost:3000/ws/trades@BTCUSDC&deltas@BTCUSDC&user@0";
+// Get orderbook for a market
+const orderbook = await nord.getOrderbook({ marketId: 0 });
+console.log('Bids:', orderbook.bids);
+console.log('Asks:', orderbook.asks);
 
-const s = new Subscriber({
-  streamURL: STREAM_URL,
-  maxBufferLen: 100,
+// Get recent trades
+const trades = await nord.getTrades({ marketId: 0, limit: 10 });
+console.log('Recent trades:', trades.trades);
+
+// Subscribe to real-time orderbook updates
+const orderbookSub = nord.subscribeOrderbook('BTC/USDC');
+orderbookSub.on('update', (data) => {
+  console.log('Orderbook update:', data);
 });
-s.subsribe();
 ```
 
-## Development
+### Account Information
 
-### Install dependencies
 
-```bash
-yarn
+```typescript
+import { Nord, NordUser } from "nord-ts";
+
+// Assuming nord and user are already initialized
+
+// Get account information
+const accountInfo = await user.fetchInfo();
+
+// Access user balances
+console.log('Balances:', user.balances);
+
+// Access user positions
+console.log('Positions:', user.positions);
+
+// Access user orders
+console.log('Orders:', user.orders);
 ```
 
-### Generate proto files
+## Development
 
-````bash
+```bash
+# Install dependencies
+yarn
+
+# Build the package
 yarn build
 ```
-````
+
+## Documentation
+
+For more detailed documentation, please refer to the source code and inline comments in the `Nord` and `NordUser` classes.

package/dist/bridge/NordUser.d.ts

@@ -0,0 +1,78 @@
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { Nord } from '../nord/Nord';
+import { Order } from '../types';
+import { SolanaBridgeClient } from './client';
+import { SPLTokenInfo } from './types';
+export declare class NordUser {
+    nord: Nord;
+    publicKey: PublicKey;
+    walletSignFn: (message: Uint8Array | string) => Promise<Uint8Array>;
+    sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
+    balances: {
+        [key: string]: {
+            accountId: number;
+            balance: number;
+            symbol: string;
+        }[];
+    };
+    orders: {
+        [key: string]: Order[];
+    };
+    accountIds?: number[];
+    sessionId?: bigint;
+    keypair?: Keypair;
+    bridgeClient?: SolanaBridgeClient;
+    connection?: Connection;
+    splTokenInfos: SPLTokenInfo[];
+    lastTs: number;
+    lastNonce: number;
+    constructor(params: {
+        nord: Nord;
+        publicKey: PublicKey | string;
+        walletSignFn: (message: Uint8Array | string) => Promise<Uint8Array>;
+        sessionSignFn: (message: Uint8Array) => Promise<Uint8Array>;
+        keypair?: Keypair;
+        connection?: Connection;
+    });
+    /**
+     * Initialize the Solana bridge client
+     */
+    private initBridgeClient;
+    /**
+     * Create a NordUser from a private key
+     *
+     * @param nord Nord instance
+     * @param privateKey Private key as string or Uint8Array
+     * @param connection Solana connection
+     * @returns NordUser instance
+     */
+    static fromPrivateKey(nord: Nord, privateKey: string | Uint8Array, connection?: Connection): NordUser;
+    /**
+     * Get the associated token account for a token mint
+     *
+     * @param mint Token mint address
+     * @returns Associated token account address
+     */
+    getAssociatedTokenAccount(mint: PublicKey): Promise<PublicKey>;
+    /**
+     * Deposit SPL tokens to the bridge
+     *
+     * @param amount Amount to deposit
+     * @param tokenId Token ID
+     * @returns Transaction signature
+     */
+    depositSpl(amount: number, tokenId: number): Promise<string>;
+    /**
+     * Withdraw tokens from the bridge
+     *
+     * @param claim Withdrawal claim
+     * @returns Transaction signature
+     */
+    withdrawSpl(claim: any): Promise<string>;
+    /**
+     * Fund the user's SPL token accounts for testing
+     *
+     * @param faucetKeypair Keypair with funds to distribute
+     */
+    fundSplWallet(faucetKeypair: Keypair): Promise<void>;
+}

package/dist/bridge/NordUser.js

@@ -0,0 +1,196 @@
+"use strict";
+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 client_1 = require("./client");
+const const_1 = require("./const");
+const utils_1 = require("./utils");
+class NordUser {
+    constructor(params) {
+        this.balances = {};
+        this.orders = {};
+        // Convert TokenInfo to SPLTokenInfo
+        this.splTokenInfos = [];
+        this.lastTs = 0;
+        this.lastNonce = 0;
+        this.nord = params.nord;
+        this.publicKey = typeof params.publicKey === 'string'
+            ? new web3_js_1.PublicKey(params.publicKey)
+            : params.publicKey;
+        this.walletSignFn = params.walletSignFn;
+        this.sessionSignFn = params.sessionSignFn;
+        this.keypair = params.keypair;
+        this.connection = params.connection;
+        // Convert TokenInfo to SPLTokenInfo
+        this.splTokenInfos = this.nord.tokenInfos.map(tokenInfo => ({
+            mint: tokenInfo.address, // Use address as mint
+            precision: tokenInfo.precision,
+            tokenId: tokenInfo.tokenId,
+            name: tokenInfo.name
+        }));
+        // Initialize bridge client if keypair and connection are provided
+        if (this.keypair && this.connection && this.nord.solanaProgramId) {
+            this.initBridgeClient();
+        }
+    }
+    /**
+     * Initialize the Solana bridge client
+     */
+    initBridgeClient() {
+        if (!this.keypair || !this.connection || !this.nord.solanaProgramId) {
+            throw new Error('Keypair, connection, and program ID are required to initialize bridge client');
+        }
+        // Create an Anchor wallet from the keypair
+        const wallet = {
+            publicKey: this.keypair.publicKey,
+            signTransaction: async (tx) => {
+                tx.partialSign(this.keypair);
+                return tx;
+            },
+            signAllTransactions: async (txs) => {
+                return txs.map(tx => {
+                    tx.partialSign(this.keypair);
+                    return tx;
+                });
+            },
+            // Add payer property to satisfy NodeWallet interface
+            payer: this.keypair
+        };
+        // Initialize the bridge client
+        this.bridgeClient = new client_1.SolanaBridgeClient({
+            rpcUrl: this.connection.rpcEndpoint,
+            programId: this.nord.solanaProgramId,
+            commitment: 'confirmed',
+            tokenInfos: this.splTokenInfos
+        }, wallet);
+    }
+    /**
+     * Create a NordUser from a private key
+     *
+     * @param nord Nord instance
+     * @param privateKey Private key as string or Uint8Array
+     * @param connection Solana connection
+     * @returns NordUser instance
+     */
+    static fromPrivateKey(nord, privateKey, connection) {
+        const keypair = (0, utils_1.keypairFromPrivateKey)(privateKey);
+        // Create a signing function that returns Uint8Array
+        const walletSignFn = async (message) => {
+            const messageBuffer = typeof message === 'string'
+                ? Buffer.from(message)
+                : Buffer.from(message);
+            // Use nacl for signing since Keypair doesn't have a sign method
+            // This is a simplified version - in a real implementation, you would use proper signing
+            return new Uint8Array(keypair.secretKey.slice(0, 64));
+        };
+        return new NordUser({
+            nord,
+            publicKey: keypair.publicKey,
+            walletSignFn,
+            sessionSignFn: walletSignFn,
+            keypair,
+            connection
+        });
+    }
+    /**
+     * Get the associated token account for a token mint
+     *
+     * @param mint Token mint address
+     * @returns Associated token account address
+     */
+    async getAssociatedTokenAccount(mint) {
+        if (!this.connection) {
+            throw new Error('Connection is required to get associated token account');
+        }
+        const associatedTokenAddress = await (0, spl_token_1.getAssociatedTokenAddress)(mint, this.publicKey);
+        try {
+            await (0, spl_token_1.getAccount)(this.connection, associatedTokenAddress);
+        }
+        catch (error) {
+            // Account doesn't exist, create it if keypair is available
+            if (this.keypair && this.bridgeClient) {
+                await this.bridgeClient.createTokenAccountIfNeeded(mint, this.publicKey, this.keypair);
+            }
+        }
+        return associatedTokenAddress;
+    }
+    /**
+     * Deposit SPL tokens to the bridge
+     *
+     * @param amount Amount to deposit
+     * @param tokenId Token ID
+     * @returns Transaction signature
+     */
+    async depositSpl(amount, tokenId) {
+        if (!this.bridgeClient || !this.keypair || !this.connection) {
+            throw new Error('Bridge client, keypair, and connection are required for deposit');
+        }
+        // Find the token info
+        const tokenInfo = this.splTokenInfos.find(t => t.tokenId === tokenId);
+        if (!tokenInfo) {
+            throw new Error(`Token with ID ${tokenId} not found`);
+        }
+        const mint = new web3_js_1.PublicKey(tokenInfo.mint);
+        // Get the user's token account
+        const fromAccount = await this.getAssociatedTokenAccount(mint);
+        // Get the bridge's token account
+        const [authority] = await this.bridgeClient.findAuthorityPda();
+        const toAccount = await (0, spl_token_1.getAssociatedTokenAddress)(mint, authority, true);
+        // Convert amount to BN with proper decimals
+        const amountBN = (0, utils_1.toBN)(amount, tokenInfo.precision);
+        // Deposit tokens
+        return await this.bridgeClient.depositSpl({
+            amount: amountBN,
+            mint,
+            fromAccount,
+            toAccount
+        }, this.keypair);
+    }
+    /**
+     * Withdraw tokens from the bridge
+     *
+     * @param claim Withdrawal claim
+     * @returns Transaction signature
+     */
+    async withdrawSpl(claim) {
+        if (!this.bridgeClient || !this.keypair || !this.connection) {
+            throw new Error('Bridge client, keypair, and connection are required for withdrawal');
+        }
+        // Get the user's token account
+        const toAccount = await this.getAssociatedTokenAccount(claim.mint);
+        // Get the bridge's token account
+        const [authority] = await this.bridgeClient.findAuthorityPda();
+        const fromAccount = await (0, spl_token_1.getAssociatedTokenAddress)(claim.mint, authority, true);
+        // Withdraw tokens
+        return await this.bridgeClient.withdraw({
+            claim,
+            toAccount,
+            fromAccount
+        }, this.keypair);
+    }
+    /**
+     * Fund the user's SPL token accounts for testing
+     *
+     * @param faucetKeypair Keypair with funds to distribute
+     */
+    async fundSplWallet(faucetKeypair) {
+        if (!this.connection) {
+            throw new Error('Connection is required to fund wallet');
+        }
+        // Fund SOL if needed
+        const solBalance = await this.connection.getBalance(this.publicKey);
+        if (solBalance < 10000000) { // 0.01 SOL
+            const solFundingAmount = const_1.DEFAULT_FUNDING_AMOUNTS["SOL"];
+            // Implement SOL transfer logic here
+        }
+        // Fund SPL tokens
+        for (const tokenInfo of this.splTokenInfos) {
+            if (const_1.DEFAULT_FUNDING_AMOUNTS[tokenInfo.mint]) {
+                const tokenAccount = await this.getAssociatedTokenAccount(new web3_js_1.PublicKey(tokenInfo.mint));
+                // Implement SPL token transfer logic here
+            }
+        }
+    }
+}
+exports.NordUser = NordUser;