@n1xyz/nord-ts 0.1.7 → 0.1.8

package/src/index.ts

@@ -1,11 +0,0 @@
-export * from "./types";
-export * from "./utils";
-export * from "./const";
-export * from "./error";
-export * from "./websocket/index";
-export * from "./client/Nord";
-export * from "./client/NordUser";
-export * from "./client/NordAdmin";
-
-export * as proto from "./gen/nord_pb";
-export * as openapi from "./gen/openapi";

package/src/types.ts

@@ -1,327 +0,0 @@
-import * as proto from "./gen/nord_pb";
-import type { components } from "./gen/openapi.ts";
-import Decimal from "decimal.js";
-import { toScaledU64 } from "./utils";
-import { Connection } from "@solana/web3.js";
-
-/**
- * Nord subscription type for trades or deltas
- */
-export type SubscriptionType = "trades" | "deltas" | "account";
-
-/**
- * Pattern for a valid Nord subscription
- * Format should be: "<type>@<parameter>"
- * Examples: "trades@BTCUSDC", "deltas@ETHUSDC", "account@42"
- */
-export type SubscriptionPattern = `${SubscriptionType}@${string}` | string;
-
-/**
- * Configuration options for the Nord client
- */
-export interface NordConfig {
-  /** Base URL for the Nord web server */
-  webServerUrl: string;
-  /** App address */
-  app: string;
-  /** Solana connection */
-  solanaConnection: Connection;
-  /** Proton URL, defaults to webServerUrl */
-  // TODO: this is ass. move to NordUser.
-  protonUrl?: string;
-  /**
-   * Whether to initialize WebSockets on creation, defaults to true
-   * @deprecated this is a funky api we're gonna be removing it
-   */
-  initWebSockets?: boolean;
-}
-
-export type MarketsInfo = components["schemas"]["MarketsInfo"];
-export type Market = MarketsInfo["markets"][number];
-export type Token = MarketsInfo["tokens"][number];
-export type Account = components["schemas"]["Account"];
-export type TradesResponse =
-  components["schemas"]["PageResult_for_String_and_Trade"];
-export type User = components["schemas"]["User"];
-export type OrderbookResponse = components["schemas"]["OrderbookInfo"];
-export type MarketStats = components["schemas"]["MarketStats"];
-export type OrderbookInfo = components["schemas"]["OrderbookInfo"];
-export type MarketStatsFromApi = components["schemas"]["MarketStats"];
-export type TradeFromApi = components["schemas"]["Trade"];
-// Generic PageResult type - note that K and V must match existing schema keys
-export type PageResult<K extends string, V extends string> = K extends "String"
-  ? V extends "OrderInfo"
-    ? components["schemas"]["PageResult_for_String_and_OrderInfo"]
-    : V extends "Trade"
-      ? components["schemas"]["PageResult_for_String_and_Trade"]
-      : never
-  : never;
-export type PageResultStringOrderInfo =
-  components["schemas"]["PageResult_for_String_and_OrderInfo"];
-export type PageResultStringTrade =
-  components["schemas"]["PageResult_for_String_and_Trade"];
-export type OrderInfoFromApi = components["schemas"]["OrderInfo"];
-export type OpenOrder = components["schemas"]["OpenOrder"];
-export type Balance = components["schemas"]["Balance"];
-export type PositionSummary = components["schemas"]["PositionSummary"];
-export type PerpPosition = components["schemas"]["PerpPosition"];
-export type AccountMarginsView = components["schemas"]["AccountMarginsView"];
-export type SideSummary = components["schemas"]["SideSummary"];
-export type UserSession = components["schemas"]["UserSession"];
-export type ActionsItem = components["schemas"]["ActionsItem"];
-export type FillRole = components["schemas"]["FillRole"];
-export type PerpMarketStatsFromApi = components["schemas"]["PerpMarketStats"];
-export type SideFromApi = components["schemas"]["Side"];
-export type FillModeFromApi = components["schemas"]["FillMode"];
-export type PlacementOrigin = components["schemas"]["PlacementOrigin"];
-export type FinalizationReason = components["schemas"]["FinalizationReason"];
-export type AccountPnlQuery = components["schemas"]["AccountPnlQuery"];
-export type AccountPnl = components["schemas"]["AccountPnl"];
-export type AccountPnlPage =
-  components["schemas"]["PageResult_for_uint64_and_AccountPnl"];
-export type AccountTriggerInfo = components["schemas"]["AccountTriggerInfo"];
-export type TriggerHistoryPage =
-  components["schemas"]["PageResult_for_uint64_and_HistoryTriggerInfo"];
-export type HistoryTriggerQuery = components["schemas"]["AccountTriggersQuery"];
-export type FeeTierConfig = components["schemas"]["FeeTierConfig"];
-export type FeeTierId = components["schemas"]["FeeTierId"];
-export type TokenStats = components["schemas"]["TokenStats"];
-export type AccountFeeTier = components["schemas"]["AccountFeeTier"];
-export type AccountFeeTierPage =
-  components["schemas"]["PageResult_for_uint32_and_AccountFeeTier"];
-
-/**
- * Configuration options for the Nord client
- */
-export interface TokenInfo {
-  address: string;
-  precision: number;
-  tokenId: number;
-  name: string;
-}
-
-export interface Order {
-  orderId: number;
-  isLong: boolean;
-  size: number;
-  price: number;
-  marketId: number;
-}
-
-export enum Side {
-  Ask = "ask",
-  Bid = "bid",
-}
-
-export enum FillMode {
-  Limit,
-  PostOnly,
-  ImmediateOrCancel,
-  FillOrKill,
-}
-
-export enum TriggerKind {
-  StopLoss = 0,
-  TakeProfit = 1,
-}
-
-export enum TriggerStatus {
-  Active = 0,
-  Success = 1,
-  Cancel = 2,
-  Remove = 4,
-}
-
-export interface SubscriberConfig {
-  streamURL: string;
-  maxBufferLen?: number;
-}
-
-export interface DeltaEvent {
-  last_update_id: number;
-  update_id: number;
-  market_symbol: string;
-  asks: OrderbookEntry[];
-  bids: OrderbookEntry[];
-}
-
-export interface StreamTrade {
-  side: Side;
-  price: number;
-  size: number;
-  order_id: number;
-}
-
-export interface Trades {
-  last_update_id: number;
-  update_id: number;
-  market_symbol: string;
-  trades: StreamTrade[];
-}
-
-export interface LocalOrderInfo {
-  id: number;
-  reduce_only: boolean;
-  limit_price: number;
-  size: number;
-  account_id: number;
-  sender_tracking_id?: number;
-}
-
-export interface HashMap<T> {
-  [key: number]: T;
-}
-
-export interface ActionResponse {
-  actionId: number;
-  action: proto.Action;
-  physicalExecTime: Date;
-}
-
-/**
- * Converts a `FillMode` enum to its corresponding protobuf representation.
- *
- * @param x - The fill mode to convert.
- * @returns The corresponding protobuf fill mode.
- * @throws Will throw an error if provided with an invalid fill mode.
- */
-export function fillModeToProtoFillMode(x: FillMode): proto.FillMode {
-  if (x === FillMode.Limit) return proto.FillMode.LIMIT;
-  if (x === FillMode.PostOnly) return proto.FillMode.POST_ONLY;
-  if (x === FillMode.ImmediateOrCancel) {
-    return proto.FillMode.IMMEDIATE_OR_CANCEL;
-  }
-  if (x === FillMode.FillOrKill) return proto.FillMode.FILL_OR_KILL;
-  throw new Error("Invalid fill mode");
-}
-
-/**
- * Orderbook entry representing price and size
- */
-export interface OrderbookEntry {
-  price: number;
-  size: number;
-}
-
-/**
- * Query parameters for orderbook
- *
- * Note: While you can provide either symbol or market_id, the API endpoint only accepts market_id.
- * If you provide a symbol, it will be converted to a market_id internally.
- */
-export interface OrderbookQuery {
-  symbol?: string;
-  marketId?: number;
-}
-
-/**
- * Response for timestamp query
- */
-export interface TimestampResponse {
-  timestamp: number; // engine's current logical timestamp
-}
-
-/**
- * Response for action nonce query
- */
-export interface ActionNonceResponse {
-  nonce: number; // next expected action nonce
-}
-
-/**
- * WebSocket message types
- */
-export enum WebSocketMessageType {
-  TradeUpdate = "trades",
-  DeltaUpdate = "delta",
-  AccountUpdate = "account",
-}
-
-/**
- * WebSocket trade update message
- */
-export interface WebSocketTradeUpdate {
-  e: WebSocketMessageType.TradeUpdate;
-  symbol: string;
-  trades: StreamTrade[];
-  timestamp: number;
-}
-
-/**
- * WebSocket delta update message
- */
-export interface WebSocketDeltaUpdate {
-  e: WebSocketMessageType.DeltaUpdate;
-  last_update_id: number;
-  update_id: number;
-  market_symbol: string;
-  asks: OrderbookEntry[];
-  bids: OrderbookEntry[];
-  timestamp: number;
-}
-
-/**
- * WebSocket user update message
- */
-export interface WebSocketAccountUpdate {
-  e: WebSocketMessageType.AccountUpdate;
-  accountId: number;
-  account: Account;
-  timestamp: number;
-}
-
-export type WebSocketMessage =
-  | WebSocketTradeUpdate
-  | WebSocketDeltaUpdate
-  | WebSocketAccountUpdate;
-
-export interface SPLTokenInfo {
-  mint: string;
-  precision: number;
-  tokenId: number;
-  name: string;
-}
-
-// Positive decimal price and size.
-// Example:
-// ```
-// const limit = new QuoteSize(new Decimal(114000), new Decimal(0.00035)),
-//```
-// Gives 40$ USD limit.
-//
-// Given price is same(or very close) to the market price,
-// limit gives size tick as close as possible to settlemnt size tick.
-
-// If you want to get smaller tick on client (on server it will not change),
-// do `new QuoteSize(new Decimal(114000/2), new Decimal(0.00070))`.
-// It will be 40$ limit, but may help if BTC suddently moves fast.
-export class QuoteSize {
-  price: Decimal;
-  size: Decimal;
-  /// Input can be only positive values.
-  constructor(quotePrice: Decimal.Value, quoteSize: Decimal.Value) {
-    const p = new Decimal(quotePrice);
-    const s = new Decimal(quoteSize);
-    if (!p.isPositive() || !s.isPositive()) {
-      throw new Error("quotePrice and quoteSize must be positive");
-    }
-    this.price = p;
-    this.size = s;
-  }
-
-  // USD value of limit, use for debug
-  value(): Decimal {
-    return this.price.mul(this.size);
-  }
-
-  // Converts to wire format to be send to server, scaling price and size according to market decimals.
-  toWire(
-    marketPriceDecimals: number,
-    marketSizeDecimals: number,
-  ): { price: bigint; size: bigint } {
-    return {
-      price: toScaledU64(this.price, marketPriceDecimals),
-      size: toScaledU64(this.size, marketSizeDecimals),
-    };
-  }
-}

package/src/utils.ts

@@ -1,266 +0,0 @@
-import { Decimal } from "decimal.js";
-import { type Market, type Token } from "./types";
-import { sizeDelimitedPeek } from "@bufbuild/protobuf/wire";
-import { fromBinary, type Message } from "@bufbuild/protobuf";
-import type { GenMessage } from "@bufbuild/protobuf/codegenv2";
-import { ethers } from "ethers";
-import fetch from "node-fetch";
-import { RequestInfo, RequestInit, Response } from "node-fetch";
-import { Keypair } from "@solana/web3.js";
-import bs58 from "bs58";
-import * as solana from "@solana/web3.js";
-
-export const SESSION_TTL: bigint = 60n * 60n * 24n * 30n;
-export const ZERO_DECIMAL = new Decimal(0);
-export const MAX_BUFFER_LEN = 10_000;
-
-// Max size of data returned from Nord endpoints
-const MAX_PAYLOAD_SIZE = 100 * 1024; // 100 kB
-
-/** Any type convertible to bigint */
-export type BigIntValue = bigint | number | string;
-
-export function panic(message: string): never {
-  throw new Error(message);
-}
-
-export function isRfc3339(s: string): boolean {
-  const REGEX =
-    /^((?:(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?))(Z|[\+-]\d{2}:\d{2})?)$/;
-  return REGEX.test(s);
-}
-
-export function assert(
-  predicate: boolean,
-  message?: string,
-): asserts predicate {
-  if (!predicate) panic(message ?? "Assertion violated");
-}
-/**
- * Extracts value out of optional if it's defined, or throws error if it's not
- * @param value   Optional value to unwrap
- * @param message Error message
- * @returns       Unwrapped value
- */
-export function optExpect<T>(value: T | undefined, message: string): T {
-  if (value === undefined) throw new Error(message);
-  return value as T;
-}
-/** Behaves same as `node-fetch/fetch` but throws if response is a failure
- *
- * @param url   Request HTTP URL
- * @param init  Request parameters
- * @returns     Raw response if fetch succeeded
- * @throws      If response wasn't Ok
- */
-export async function checkedFetch(
-  url: RequestInfo,
-  init?: RequestInit,
-): Promise<Response> {
-  const resp = await fetch(url, init);
-  assert(resp.ok, `Request failed with ${resp.status}: ${resp.statusText}`);
-  return resp;
-}
-
-/**
- * Constructs wallet signing function, usable with `NordUser` type
- *
- * @param walletKey   Either raw signing key as bytes array or hex string prefixed with `"0x"`
- * @returns           Async function which accepts arbitrary message, generates its digets,
- *                    then signs it with provided user wallet key and returns signature
- *                    as hex string prefixed with `"0x"`
- */
-export function makeWalletSignFn(
-  walletKey: ethers.BytesLike,
-): (message: Uint8Array | string) => Promise<string> {
-  const signingKey = new ethers.SigningKey(walletKey);
-  return async (message) =>
-    signingKey.sign(ethers.hashMessage(message)).serialized;
-}
-
-// Returned numbers do fit into specified bits range, or error is thrown.
-function makeToScaledBigUint(params: {
-  precision: number;
-  exponent: number;
-  bits: number;
-}): (x: Decimal.Value, decimals: number) => bigint {
-  const Dec = Decimal.clone({
-    precision: params.precision,
-    toExpPos: params.exponent,
-    toExpNeg: -params.exponent,
-  });
-
-  const Ten = new Dec(10);
-
-  const Max = new Dec(((1n << BigInt(params.bits)) - 1n).toString());
-
-  return (x, decimals) => {
-    const dec = new Dec(x);
-
-    if (dec.isZero()) {
-      return 0n;
-    }
-
-    if (dec.isNeg()) {
-      throw new Error(`Number is negative`);
-    }
-
-    const scaled = Ten.pow(decimals).mul(dec).truncated();
-    if (scaled.isZero()) {
-      throw new Error(
-        `Precision loss when converting ${dec} to scaled integer`,
-      );
-    }
-
-    if (scaled.greaterThan(Max)) {
-      throw new Error(
-        `Integer is out of range: ${scaled} exceeds limit ${Max}`,
-      );
-    }
-
-    return BigInt(scaled.toString());
-  };
-}
-/**
- * Converts decimal value into rescaled 64-bit unsigned integer
- * by scaling it up by specified number of decimal digits.
- *
- * Ensures that number won't accidentally become zero
- * or exceed U64's value range
- *
- * @param x         Decimal value to rescale
- * @param decimals  Number of decimal digits
- * @returns         Rescaled unsigned integer
- */
-export const toScaledU64 = makeToScaledBigUint({
-  bits: 64,
-  precision: 20,
-  exponent: 28,
-});
-/**
- * Converts decimal value into rescaled 128-bit unsigned integer
- * by scaling it up by specified number of decimal digits.
- *
- * Ensures that number won't accidentally become zero
- * or exceed U128's value range
- *
- * @param x         Decimal value to rescale
- * @param decimals  Number of decimal digits
- * @returns         Rescaled unsigned integer
- */
-export const toScaledU128 = makeToScaledBigUint({
-  bits: 128,
-  precision: 40,
-  exponent: 56,
-});
-
-/**
- * Decodes any protobuf message from a length-delimited format,
- * i.e. prefixed with its length encoded as varint
- *
- * @param   bytes  Byte array with encoded message
- * @param   schema Message schema for decoding
- * @returns        Decoded message
- */
-export function decodeLengthDelimited<T extends Message>(
-  bytes: Uint8Array,
-  schema: GenMessage<T>,
-): T {
-  // use sizeDelimitedPeek to extract the message length and offset
-  const peekResult = sizeDelimitedPeek(bytes);
-
-  if (peekResult.size === null || peekResult.offset === null) {
-    throw new Error("Failed to parse size-delimited message");
-  }
-
-  if (peekResult.size > MAX_PAYLOAD_SIZE) {
-    throw new Error(
-      `Encoded message size (${peekResult.size} bytes) is greater than max payload size (${MAX_PAYLOAD_SIZE} bytes).`,
-    );
-  }
-
-  if (peekResult.offset + peekResult.size > bytes.length) {
-    throw new Error(
-      `Encoded message size (${peekResult.size} bytes) is greater than remaining buffer size (${bytes.length - peekResult.offset} bytes).`,
-    );
-  }
-
-  // decode the message using the offset and size from peek
-  return fromBinary(
-    schema,
-    bytes.slice(peekResult.offset, peekResult.offset + peekResult.size),
-  );
-}
-
-export function decodeHex(value: string): Uint8Array {
-  const hex = value.startsWith("0x") ? value.slice(2) : value;
-  return Uint8Array.from(Buffer.from(hex, "hex"));
-}
-
-export function findMarket(markets: Market[], marketId: number): Market {
-  if (marketId < 0 || markets.length - 1 < marketId) {
-    throw new Error(`The market with marketId=${marketId} not found`);
-  }
-  return markets[marketId];
-}
-
-export function findToken(tokens: Token[], tokenId: number): Token {
-  if (tokenId < 0 || tokens.length - 1 < tokenId) {
-    throw new Error(`The token with tokenId=${tokenId} not found`);
-  }
-  return tokens[tokenId];
-}
-
-export function keypairFromPrivateKey(
-  privateKey: string | Uint8Array,
-): Keypair {
-  if (typeof privateKey === "string") {
-    if (!privateKey.startsWith("0x")) {
-      return Keypair.fromSecretKey(bs58.decode(privateKey));
-    }
-    const hex = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
-    const bytes = new Uint8Array(
-      hex.match(/.{1,2}/g)!.map((byte) => parseInt(byte, 16)),
-    );
-    return Keypair.fromSecretKey(bytes);
-  }
-  return Keypair.fromSecretKey(privateKey);
-}
-
-export async function signUserPayload({
-  payload,
-  user,
-  signTransaction,
-}: Readonly<{
-  payload: Uint8Array;
-  user: solana.PublicKey;
-  signTransaction: (tx: solana.Transaction) => Promise<solana.Transaction>;
-}>): Promise<Uint8Array> {
-  const tx = new solana.Transaction({
-    blockhash: bs58.encode(new Uint8Array(32)),
-    lastValidBlockHeight: 0,
-    feePayer: user,
-  });
-  tx.add(
-    new solana.TransactionInstruction({
-      keys: [],
-      programId: user,
-      data: Buffer.from(payload),
-    }),
-  );
-  const signedTx = await signTransaction(tx);
-  const sig = signedTx.signatures[0];
-  assert(
-    sig.signature !== null,
-    "signature must be non-null; check your signTransaction function",
-  );
-  assert(
-    sig.signature.length === 64, //.
-    "signature must be 64 bytes",
-  );
-  assert(
-    sig.publicKey.equals(user),
-    `signature is for ${sig.publicKey}, expected ${user}`,
-  );
-  return sig.signature;
-}