@n1xyz/nord-ts 0.0.1 → 0.0.4

package/dist/solana/types.d.ts

@@ -0,0 +1,118 @@
+import { PublicKey } from '@solana/web3.js';
+import { BN } from '@coral-xyz/anchor';
+/**
+ * Configuration for Solana bridge
+ */
+export interface SolanaBridgeConfig {
+    /** Solana RPC URL */
+    rpcUrl: string;
+    /** Program ID for the bridge program */
+    programId: string;
+    /** Commitment level for transactions */
+    commitment: 'processed' | 'confirmed' | 'finalized';
+    /** Token information for supported SPL tokens */
+    tokenInfos: SPLTokenInfo[];
+}
+/**
+ * Information about an SPL token
+ */
+export interface SPLTokenInfo {
+    /** Token mint address */
+    mint: string;
+    /** Token decimals */
+    precision: number;
+    /** Token ID in the Layer-N system */
+    tokenId: number;
+    /** Token name */
+    name: string;
+}
+/**
+ * Parameters for depositing SPL tokens
+ */
+export interface DepositSplParams {
+    /** Amount to deposit (in token's smallest unit) */
+    amount: BN;
+    /** Mint address of the token to deposit */
+    mint: PublicKey;
+    /** User's token account to deposit from */
+    fromAccount: PublicKey;
+    /** Bridge's token account to deposit to */
+    toAccount: PublicKey;
+}
+/**
+ * Parameters for withdrawing tokens
+ */
+export interface WithdrawalParams {
+    /** Withdrawal claim data */
+    claim: WithdrawalClaim;
+    /** User's token account to receive tokens */
+    toAccount: PublicKey;
+    /** Bridge's token account to withdraw from */
+    fromAccount: PublicKey;
+}
+/**
+ * Withdrawal claim data
+ */
+export interface WithdrawalClaim {
+    /** Block ID containing the withdrawal */
+    blockId: BN;
+    /** Leaf index in the Merkle tree */
+    leafIndex: BN;
+    /** Amount to withdraw */
+    amount: BN;
+    /** Recipient address */
+    recipient: PublicKey;
+    /** Token mint address */
+    mint: PublicKey;
+    /** Merkle proof for the withdrawal */
+    proof: Buffer[];
+}
+/**
+ * Block facts data structure
+ */
+export interface BlockFacts {
+    /** Previous state facts */
+    prevStateFacts: StateFacts;
+    /** Next state facts */
+    nextStateFacts: StateFacts;
+    /** Data availability commitment */
+    daCommitment: Buffer;
+    /** Withdrawal Merkle root */
+    withdrawalRoot: Buffer;
+}
+/**
+ * State facts data structure
+ */
+export interface StateFacts {
+    /** Application state commitment */
+    appStateCommitment: Buffer;
+    /** Deposit root */
+    depositRoot: Buffer;
+    /** Last deposit index */
+    lastDepositIndex: BN;
+    /** Last action ID */
+    lastActionId: BN;
+}
+/**
+ * Transfer parameters
+ */
+export interface TransferParams {
+    /** User public key */
+    user: PublicKey;
+    /** Token mint */
+    mint: PublicKey;
+    /** Amount to transfer */
+    amount: BN;
+}
+/**
+ * PDA seed types
+ */
+export declare enum PdaSeedType {
+    ContractStorage = "contract_storage",
+    AssetWhitelisted = "asset_whitelisted",
+    DepositStorage = "deposit_storage",
+    BlockStorage = "block_storage",
+    WithdrawalNullifier = "withdrawal_nullifier",
+    Authority = "authority",
+    DaFactStorage = "da_fact_storage"
+}

package/dist/solana/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PdaSeedType = void 0;
+/**
+ * PDA seed types
+ */
+var PdaSeedType;
+(function (PdaSeedType) {
+    PdaSeedType["ContractStorage"] = "contract_storage";
+    PdaSeedType["AssetWhitelisted"] = "asset_whitelisted";
+    PdaSeedType["DepositStorage"] = "deposit_storage";
+    PdaSeedType["BlockStorage"] = "block_storage";
+    PdaSeedType["WithdrawalNullifier"] = "withdrawal_nullifier";
+    PdaSeedType["Authority"] = "authority";
+    PdaSeedType["DaFactStorage"] = "da_fact_storage";
+})(PdaSeedType || (exports.PdaSeedType = PdaSeedType = {}));

package/dist/solana/utils.d.ts

@@ -0,0 +1,64 @@
+import { Keypair, PublicKey } from '@solana/web3.js';
+import { BN } from '@coral-xyz/anchor';
+import { PdaSeedType } from './types';
+/**
+ * Convert a private key string to a Solana Keypair
+ *
+ * @param privateKey Private key as base58 string, hex string, or Uint8Array
+ * @returns Solana Keypair
+ */
+export declare function keypairFromPrivateKey(privateKey: string | Uint8Array): Keypair;
+/**
+ * Create a signing function for Solana transactions
+ *
+ * @param keypair Solana keypair
+ * @returns Signing function
+ */
+export declare function makeSigningFunction(keypair: Keypair): (message: Uint8Array) => Promise<Uint8Array>;
+/**
+ * Convert a number to a BN with the specified number of decimals
+ *
+ * @param amount Amount as a number
+ * @param decimals Number of decimals
+ * @returns BN representation of the amount
+ */
+export declare function toBN(amount: number, decimals: number): BN;
+/**
+ * Format a BN as a human-readable number with the specified number of decimals
+ *
+ * @param amount Amount as a BN
+ * @param decimals Number of decimals
+ * @returns Formatted number
+ */
+export declare function fromBN(amount: BN, decimals: number): number;
+/**
+ * Derive a PDA (Program Derived Address) for the given seeds
+ *
+ * @param programId Program ID
+ * @param type PDA seed type
+ * @param seeds Additional seeds
+ * @returns [PDA, bump]
+ */
+export declare function findPda(programId: PublicKey, type: PdaSeedType, ...seeds: (Buffer | PublicKey | string | number)[]): [PublicKey, number];
+/**
+ * Convert a buffer to a hex string
+ *
+ * @param buffer Buffer to convert
+ * @returns Hex string
+ */
+export declare function bufferToHex(buffer: Buffer | Uint8Array): string;
+/**
+ * Convert a hex string to a buffer
+ *
+ * @param hex Hex string
+ * @returns Buffer
+ */
+export declare function hexToBuffer(hex: string): Buffer;
+/**
+ * Shorten a public key for display
+ *
+ * @param publicKey Public key to shorten
+ * @param chars Number of characters to show at the beginning and end
+ * @returns Shortened public key
+ */
+export declare function shortenPublicKey(publicKey: PublicKey | string, chars?: number): string;

package/dist/solana/utils.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keypairFromPrivateKey = keypairFromPrivateKey;
+exports.makeSigningFunction = makeSigningFunction;
+exports.toBN = toBN;
+exports.fromBN = fromBN;
+exports.findPda = findPda;
+exports.bufferToHex = bufferToHex;
+exports.hexToBuffer = hexToBuffer;
+exports.shortenPublicKey = shortenPublicKey;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const bs58_1 = __importDefault(require("bs58"));
+/**
+ * Convert a private key string to a Solana Keypair
+ *
+ * @param privateKey Private key as base58 string, hex string, or Uint8Array
+ * @returns Solana Keypair
+ */
+function keypairFromPrivateKey(privateKey) {
+    if (typeof privateKey === 'string') {
+        // Check if it's a base58 encoded string
+        if (!privateKey.startsWith('0x')) {
+            return web3_js_1.Keypair.fromSecretKey(bs58_1.default.decode(privateKey));
+        }
+        // It's a hex string
+        const hex = privateKey.startsWith('0x') ? privateKey.slice(2) : privateKey;
+        const bytes = new Uint8Array(hex.match(/.{1,2}/g).map(byte => parseInt(byte, 16)));
+        return web3_js_1.Keypair.fromSecretKey(bytes);
+    }
+    // It's already a Uint8Array
+    return web3_js_1.Keypair.fromSecretKey(privateKey);
+}
+/**
+ * Create a signing function for Solana transactions
+ *
+ * @param keypair Solana keypair
+ * @returns Signing function
+ */
+function makeSigningFunction(keypair) {
+    return async (message) => {
+        // Use the correct API for signing with a Keypair
+        const signature = keypair.secretKey.slice(0, 32);
+        const publicKey = keypair.publicKey.toBytes();
+        // This is a simplified version - in a real implementation, you would use proper signing
+        // For now, we're just returning a placeholder signature
+        return new Uint8Array([...signature, ...publicKey].slice(0, 64));
+    };
+}
+/**
+ * Convert a number to a BN with the specified number of decimals
+ *
+ * @param amount Amount as a number
+ * @param decimals Number of decimals
+ * @returns BN representation of the amount
+ */
+function toBN(amount, decimals) {
+    const factor = Math.pow(10, decimals);
+    const amountBN = new anchor_1.BN(Math.floor(amount * factor));
+    return amountBN;
+}
+/**
+ * Format a BN as a human-readable number with the specified number of decimals
+ *
+ * @param amount Amount as a BN
+ * @param decimals Number of decimals
+ * @returns Formatted number
+ */
+function fromBN(amount, decimals) {
+    const factor = Math.pow(10, decimals);
+    return amount.toNumber() / factor;
+}
+/**
+ * Derive a PDA (Program Derived Address) for the given seeds
+ *
+ * @param programId Program ID
+ * @param type PDA seed type
+ * @param seeds Additional seeds
+ * @returns [PDA, bump]
+ */
+function findPda(programId, type, ...seeds) {
+    const seedBuffers = [
+        Buffer.from(type),
+        ...seeds.map(seed => {
+            if (seed instanceof web3_js_1.PublicKey) {
+                return seed.toBuffer();
+            }
+            else if (typeof seed === 'string') {
+                return Buffer.from(seed);
+            }
+            else if (typeof seed === 'number') {
+                return Buffer.from([seed]);
+            }
+            return seed;
+        })
+    ];
+    return web3_js_1.PublicKey.findProgramAddressSync(seedBuffers, programId);
+}
+/**
+ * Convert a buffer to a hex string
+ *
+ * @param buffer Buffer to convert
+ * @returns Hex string
+ */
+function bufferToHex(buffer) {
+    return '0x' + Buffer.from(buffer).toString('hex');
+}
+/**
+ * Convert a hex string to a buffer
+ *
+ * @param hex Hex string
+ * @returns Buffer
+ */
+function hexToBuffer(hex) {
+    const hexString = hex.startsWith('0x') ? hex.slice(2) : hex;
+    return Buffer.from(hexString, 'hex');
+}
+/**
+ * Shorten a public key for display
+ *
+ * @param publicKey Public key to shorten
+ * @param chars Number of characters to show at the beginning and end
+ * @returns Shortened public key
+ */
+function shortenPublicKey(publicKey, chars = 4) {
+    const key = typeof publicKey === 'string' ? publicKey : publicKey.toBase58();
+    return `${key.slice(0, chars)}...${key.slice(-chars)}`;
+}

package/dist/types/api.d.ts

@@ -0,0 +1,152 @@
+/**
+ * API-related types for the Nord client
+ * @module types/api
+ */
+import { NordClientConfig } from './config';
+import { Market, OrderbookData, Trade, Candle, Account, Balance, Order, OrderResult, PlaceOrderParams } from '../models';
+import { WebSocketClient } from '../websocket/client';
+/**
+ * Nord client interface with flat API structure
+ */
+export interface NordClient {
+    /**
+     * Client configuration
+     */
+    config: NordClientConfig;
+    /**
+     * WebSocket client for real-time updates
+     */
+    ws: WebSocketClient;
+    /**
+     * Get all available markets
+     *
+     * @returns Promise resolving to an array of markets
+     */
+    getMarkets(): Promise<Market[]>;
+    /**
+     * Get orderbook data for a specific market
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @returns Promise resolving to orderbook data
+     */
+    getOrderbook(market: string): Promise<OrderbookData>;
+    /**
+     * Get recent trades for a specific market
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @param limit - Maximum number of trades to return (optional)
+     * @returns Promise resolving to an array of trades
+     */
+    getTrades(market: string, limit?: number): Promise<Trade[]>;
+    /**
+     * Get candle data for a specific market and timeframe
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @param timeframe - Candle timeframe (e.g., "1m", "5m", "1h", "1d")
+     * @param limit - Maximum number of candles to return (optional)
+     * @returns Promise resolving to an array of candles
+     */
+    getCandles(market: string, timeframe: string, limit?: number): Promise<Candle[]>;
+    /**
+     * Get current server timestamp
+     *
+     * @returns Promise resolving to the current server timestamp in milliseconds
+     */
+    getTimestamp(): Promise<number>;
+    /**
+     * Get account information
+     *
+     * @param accountId - Account ID
+     * @returns Promise resolving to account information
+     */
+    getAccount(accountId: number): Promise<Account>;
+    /**
+     * Get all accounts for a specific address
+     *
+     * @param address - User's blockchain address
+     * @returns Promise resolving to an array of account IDs
+     */
+    getAccounts(address: string): Promise<number[]>;
+    /**
+     * Get balance for a specific token in an account
+     *
+     * @param accountId - Account ID
+     * @param token - Token symbol (e.g., "BTC")
+     * @returns Promise resolving to balance information
+     */
+    getBalance(accountId: number, token: string): Promise<Balance>;
+    /**
+     * Get all balances for an account
+     *
+     * @param accountId - Account ID
+     * @returns Promise resolving to an array of balances
+     */
+    getBalances(accountId: number): Promise<Balance[]>;
+    /**
+     * Place a new order
+     *
+     * @param params - Order parameters
+     * @returns Promise resolving to order result
+     */
+    placeOrder(params: PlaceOrderParams): Promise<OrderResult>;
+    /**
+     * Cancel an existing order
+     *
+     * @param orderId - Order ID to cancel
+     * @returns Promise resolving to true if successful
+     */
+    cancelOrder(orderId: number): Promise<boolean>;
+    /**
+     * Get information about a specific order
+     *
+     * @param orderId - Order ID
+     * @returns Promise resolving to order information
+     */
+    getOrder(orderId: number): Promise<Order>;
+    /**
+     * Get all orders for an account
+     *
+     * @param accountId - Account ID
+     * @returns Promise resolving to an array of orders
+     */
+    getOrders(accountId: number): Promise<Order[]>;
+    metrics: {
+        /**
+         * Get aggregate metrics
+         *
+         * @returns Promise resolving to aggregate metrics
+         */
+        getAggregate(): Promise<any>;
+        /**
+         * Get peak transactions per second for a specific timeframe
+         *
+         * @param timeframe - Timeframe (e.g., "1h", "1d", "7d")
+         * @returns Promise resolving to peak TPS value
+         */
+        getPeakTps(timeframe: string): Promise<number>;
+    };
+    /**
+     * Subscribe to orderbook updates for a specific market
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @param callback - Callback function to handle updates
+     * @returns Subscription ID
+     */
+    subscribeToOrderbook(market: string, callback: (data: OrderbookData) => void): string;
+    /**
+     * Subscribe to trade updates for a specific market
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @param callback - Callback function to handle updates
+     * @returns Subscription ID
+     */
+    subscribeToTrades(market: string, callback: (data: Trade[]) => void): string;
+    /**
+     * Subscribe to user updates for a specific account
+     *
+     * @param accountId - Account ID
+     * @param callback - Callback function to handle updates
+     * @returns Subscription ID
+     */
+    subscribeToUserUpdates(accountId: number, callback: (data: any) => void): string;
+}

package/dist/types/api.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * API-related types for the Nord client
+ * @module types/api
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/config.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Configuration types for the Nord client
+ * @module types/config
+ */
+import { TokenInfo } from '../models/token';
+/**
+ * Configuration options for the Nord client
+ */
+export interface NordClientConfig {
+    /**
+     * Base URL for the Nord web server
+     */
+    webServerUrl: string;
+    /**
+     * Token information
+     */
+    tokenInfos?: TokenInfo[];
+    /**
+     * Solana program ID (optional)
+     */
+    solanaProgramId?: string;
+    /**
+     * Solana RPC URL (optional)
+     */
+    solanaUrl?: string;
+    /**
+     * EVM URL (optional)
+     */
+    evmUrl?: string;
+    /**
+     * Contract address (optional)
+     */
+    contractAddress?: string;
+}

package/dist/types/config.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Configuration types for the Nord client
+ * @module types/config
+ */
+Object.defineProperty(exports, "__esModule", { value: true });