@basedone/core 0.1.8 → 0.2.0

package/lib/ecommerce/utils/errors.ts

@@ -0,0 +1,113 @@
+/**
+ * Ecommerce API Error Utilities
+ * 
+ * This module contains error handling utilities for the ecommerce API.
+ */
+
+/**
+ * Ecommerce API error class
+ */
+export class EcommerceApiError extends Error {
+  /** HTTP status code */
+  public statusCode?: number;
+  
+  /** Response data */
+  public data?: any;
+  
+  /** Is network error */
+  public isNetworkError: boolean;
+  
+  /** Is timeout error */
+  public isTimeoutError: boolean;
+  
+  /** Is authentication error */
+  public isAuthError: boolean;
+
+  constructor(
+    message: string,
+    statusCode?: number,
+    data?: any,
+    isNetworkError = false,
+    isTimeoutError = false
+  ) {
+    super(message);
+    this.name = "EcommerceApiError";
+    this.statusCode = statusCode;
+    this.data = data;
+    this.isNetworkError = isNetworkError;
+    this.isTimeoutError = isTimeoutError;
+    this.isAuthError = statusCode === 401 || statusCode === 403;
+    
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, EcommerceApiError);
+    }
+  }
+}
+
+/**
+ * Parse error from axios error or API response
+ */
+export function parseError(error: any): EcommerceApiError {
+  // Network error
+  if (error.code === "ECONNABORTED" || error.code === "ETIMEDOUT") {
+    return new EcommerceApiError(
+      "Request timeout",
+      undefined,
+      undefined,
+      false,
+      true
+    );
+  }
+  
+  if (error.code === "ERR_NETWORK" || !error.response) {
+    return new EcommerceApiError(
+      error.message || "Network error",
+      undefined,
+      undefined,
+      true,
+      false
+    );
+  }
+  
+  // API error
+  const response = error.response;
+  const statusCode = response?.status;
+  const data = response?.data;
+  
+  const message = 
+    data?.error || 
+    data?.message || 
+    error.message || 
+    `API error (${statusCode})`;
+  
+  return new EcommerceApiError(message, statusCode, data);
+}
+
+/**
+ * Check if error is retryable
+ */
+export function isRetryableError(error: EcommerceApiError): boolean {
+  // Retry on network errors
+  if (error.isNetworkError) {
+    return true;
+  }
+  
+  // Retry on timeout
+  if (error.isTimeoutError) {
+    return true;
+  }
+  
+  // Retry on 5xx errors
+  if (error.statusCode && error.statusCode >= 500) {
+    return true;
+  }
+  
+  // Retry on 429 (rate limit)
+  if (error.statusCode === 429) {
+    return true;
+  }
+  
+  return false;
+}
+

package/lib/ecommerce/utils/helpers.ts

@@ -0,0 +1,131 @@
+/**
+ * Ecommerce API Helper Utilities
+ * 
+ * This module contains helper functions for the ecommerce API.
+ */
+
+/**
+ * Build query string from params object
+ */
+export function buildQueryString(params: Record<string, any>): string {
+  const searchParams = new URLSearchParams();
+  
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== undefined && value !== null) {
+      if (Array.isArray(value)) {
+        // Handle arrays (e.g., ids, tags)
+        searchParams.append(key, value.join(","));
+      } else {
+        searchParams.append(key, String(value));
+      }
+    }
+  });
+  
+  const queryString = searchParams.toString();
+  return queryString ? `?${queryString}` : "";
+}
+
+/**
+ * Sleep for specified milliseconds
+ */
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Calculate exponential backoff delay
+ */
+export function getBackoffDelay(attempt: number, baseDelay = 1000): number {
+  return Math.min(baseDelay * Math.pow(2, attempt), 30000);
+}
+
+/**
+ * Retry function with exponential backoff
+ */
+export async function retryWithBackoff<T>(
+  fn: () => Promise<T>,
+  maxRetries = 3,
+  baseDelay = 1000,
+  shouldRetry?: (error: any) => boolean
+): Promise<T> {
+  let lastError: any;
+  
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      
+      // Check if we should retry
+      if (attempt < maxRetries && (!shouldRetry || shouldRetry(error))) {
+        const delay = getBackoffDelay(attempt, baseDelay);
+        await sleep(delay);
+        continue;
+      }
+      
+      throw error;
+    }
+  }
+  
+  throw lastError;
+}
+
+/**
+ * Format price for display
+ */
+export function formatPrice(price: string | number, decimals = 2): string {
+  const num = typeof price === "string" ? parseFloat(price) : price;
+  return num.toFixed(decimals);
+}
+
+/**
+ * Validate email address
+ */
+export function isValidEmail(email: string): boolean {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+
+/**
+ * Validate Ethereum address
+ */
+export function isValidAddress(address: string): boolean {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+
+/**
+ * Truncate address for display
+ */
+export function truncateAddress(address: string, start = 6, end = 4): string {
+  if (!address || address.length < start + end) {
+    return address;
+  }
+  return `${address.slice(0, start)}...${address.slice(-end)}`;
+}
+
+/**
+ * Calculate discount amount
+ */
+export function calculateDiscountAmount(
+  price: number,
+  discountType: "PERCENTAGE" | "FIXED_AMOUNT",
+  discountValue: number
+): number {
+  if (discountType === "PERCENTAGE") {
+    return (price * discountValue) / 100;
+  }
+  return Math.min(discountValue, price);
+}
+
+/**
+ * Calculate final price after discount
+ */
+export function calculateFinalPrice(
+  price: number,
+  discountType: "PERCENTAGE" | "FIXED_AMOUNT",
+  discountValue: number
+): number {
+  const discountAmount = calculateDiscountAmount(price, discountType, discountValue);
+  return Math.max(0, price - discountAmount);
+}
+

package/lib/fee.ts

@@ -15,8 +15,8 @@ export const TARGET_APPROVED_MAX_BUILDER_FEE_PERCENT = `0.1%`;
 
 /**
  * Get the amount of builder fee to approve for
- * @param perpetualTradingFee - Perp fee in percentage
- * @param spotTradingFee - Spot fee in percentage
+ * @param perpetualTradingFee - Perp fee in percentage (0.025 means 0.025% perp fee)
+ * @param spotTradingFee - Spot fee in percentage (0.01 means 0.01% spot fee)
  * @param feeDiscount - Discount fee in percentage (0.9 means 90% discount)
  * @returns {
  *   amount: number;  - The amount of builder fee to approve in 1/10 of a basis point
@@ -75,19 +75,19 @@ export const getApprovalAmount = ({
     .mul(discountMultiplier)
     .toNumber();
 
-  // ensure perp fee is either 0 or between 0.01% and 0.1%
-  if (validatedPerpFeePct > 0 && validatedPerpFeePct < 0.01) {
-    console.warn("Perp fee is less than 0.01%, setting to 0.01%");
-    validatedPerpFeePct = 0.01;
-  }
-  if (validatedPerpFeePct < 0) {
-    console.warn("Perp fee is less than 0, setting to 0");
-    validatedPerpFeePct = 0;
+  // ensure perp fee is either 0 or between 0.001%
+  if (validatedPerpFeePct > 0 && validatedPerpFeePct < 0.001) {
+    console.warn("Perp fee is less than 0.001%, setting to 0.001%");
+    validatedPerpFeePct = 0.001;
   }
   if (validatedPerpFeePct > 0.1) {
     console.warn("Perp fee is greater than 0.1%, setting to 0.1%");
     validatedPerpFeePct = 0.1;
   }
+  if (validatedPerpFeePct < 0) {
+    console.warn("Perp fee is less than 0, setting to 0");
+    validatedPerpFeePct = 0;
+  }
 
   let validatedSpotFeePct = spotTradingFee;
 

package/lib/hip3/market-info.ts

@@ -1,17 +1,45 @@
-import { PerpsMeta, InfoClient } from "@nktkas/hyperliquid";
+import { InfoClient, PerpsAssetCtx, MarginTables } from "@nktkas/hyperliquid";
 
-export type PerpsMetaWithCollateralToken = PerpsMeta & {
-  collateralToken?: number; // spot token index
-};
+export interface PerpsMeta {
+  collateralToken: number;
+  /** Trading universes available for perpetual trading. */
+  universe: PerpsUniverse[];
+  /** Margin requirement tables for different leverage tiers. */
+  marginTables: MarginTables;
+}
+/** Metadata and context for perpetual assets. */
+export type PerpsMetaAndAssetCtxs = [
+  /** Metadata for assets. */
+  PerpsMeta,
+  /** Context for each perpetual asset. */
+  PerpsAssetCtx[],
+];
+/** Trading universe parameters for perpetual assets. */
+export interface PerpsUniverse {
+  /** Minimum decimal places for order sizes. */
+  szDecimals: number;
+  /** Name of the universe. */
+  name: string;
+  /** Maximum allowed leverage. */
+  maxLeverage: number;
+  /** Unique identifier for the margin requirements table. */
+  marginTableId: number;
+  /** Indicates if only isolated margin trading is allowed. */
+  onlyIsolated?: true;
+  /** Indicates if the universe is delisted. */
+  isDelisted?: true;
+  /** Indicates if the universe is in growth mode, eligible for discounted fees */
+  growthMode?: "enabled";
+  /** Margin mode for the universe. */
+  marginMode?: "strictIsolated" | "noCross";
+}
 
-export type AllPerpsMeta = PerpsMetaWithCollateralToken[];
+export type AllPerpsMeta = PerpsMeta[];
 
 export async function getAllPerpsMeta(
   infoClient: InfoClient,
 ): Promise<AllPerpsMeta> {
   return infoClient.transport.request<AllPerpsMeta>("info", {
-    action: {
-      type: "allPerpMetas",
-    },
+    type: "allPerpMetas",
   });
 }

package/lib/hip3/utils.ts

@@ -99,7 +99,7 @@ export async function getHip3DexAbstraction(client: InfoClient, user: string) {
 
 const dexToCollateralTokenSymbol = {
   rrrrr: "USDEEE",
-  hyena: "USDE",
+  hyna: "USDE",
   flx: "USDH",
   vntl: "USDH",
 };
@@ -150,7 +150,20 @@ export function getDisplayMarketSymbol(
   showCollateralTokenSymbol: boolean = true,
   collateralTokenSymbol?: string,
 ) {
-  if (!coin || isSpotSymbol(coin)) return coin;
+  if (!coin) return coin;
+
+  if (isSpotSymbol(coin)) {
+    if (coin.includes("/")) {
+      const [baseToken, quoteToken] = coin.split("/");
+
+      if (showCollateralTokenSymbol) {
+        return `${baseToken}/${collateralTokenSymbol ?? quoteToken}`;
+      } else {
+        return baseToken;
+      }
+    }
+    return coin;
+  }
 
   if (isHip3Symbol(coin)) {
     const [_, symbol] = coin.split(":");