@strkfarm/sdk 2.0.0-dev.5 → 2.0.0-dev.51

package/src/utils/cacheClass.ts

@@ -5,6 +5,7 @@ interface CacheData {
 }
 export class CacheClass {
     readonly cache: Map<string, CacheData> = new Map();
+    isCacheEnabled: boolean = true;
 
     setCache(key: string, data: any, ttl: number = 60000): void {
         const timestamp = Date.now();
@@ -13,7 +14,7 @@ export class CacheClass {
 
     getCache<T>(key: string): T | null {
         const cachedData = this.cache.get(key);
-        if (!cachedData || !this.isCacheValid(key)) {
+        if (!cachedData || !this.isCacheValid(key) || !this.isCacheEnabled) {
             return null;
         }
         return cachedData.data;
@@ -26,4 +27,12 @@ export class CacheClass {
         const { timestamp, ttl } = cachedData;
         return Date.now() - timestamp <= ttl;
     }
-}
+
+    disableCache(): void {
+        this.isCacheEnabled = false;
+    }
+
+    enableCache(): void {
+        this.isCacheEnabled = true;
+    }
+}

package/src/utils/health-factor-math.ts

@@ -82,8 +82,40 @@ export class HealthFactorMath {
     // => X * (HF - maxLTV) = 1 * cp * maxLTV
     // => X = 1 * cp * maxLTV / (HF - maxLTV)
     const numerator = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLTV);
+    logger.verbose(`HealthFactorMath: Max debt amount numerator: ${numerator.toNumber()}, collateralAmount: ${collateralAmount.toNumber()}, collateralPrice: ${collateralPrice}, maxLTV: ${maxLTV}, targetHF: ${targetHF}, debtPrice: ${debtPrice}`);
     const denominator = targetHF * debtPrice;
+    logger.verbose(`HealthFactorMath: Max debt amount denominator: ${denominator}, targetHF: ${targetHF}, debtPrice: ${debtPrice}`);
     const debtAmount = numerator.dividedBy(denominator);
+    logger.verbose(`HealthFactorMath: Max debt amount: ${debtAmount.toNumber()}, numerator: ${numerator.toNumber()}, denominator: ${denominator}`);
     return new Web3Number(debtAmount.toString(), debtTokenInfo.decimals);
   }
-}
+
+  static calculateDebtReductionAmountForWithdrawal = (
+    debtAmount: Web3Number,
+    collateralAmount: Web3Number,
+    maxLtv: number,
+    targetHF: number,
+    withdrawalAmount: Web3Number,
+    collateralPrice: number,
+    debtPrice: number,
+    collateralTokenInfo: TokenInfo,
+    debtTokenInfo: TokenInfo,
+  ) => {
+    const idealLTV = maxLtv / targetHF;
+    // formulae
+    // dDebt is change is debt.
+    // (current debt - dDebt) * debtPrice / (current collateral - withdrawAmount - (dDebt * debtPrice / collPrice)) = idealLTV
+    // (current debt - dDebt) * debtPrice = idealLTV * (current collateral - withdrawAmount) - (idealLTV * dDebt * debtPrice / collPrice))
+    // dDebt * (idealLTV * debtPrice / collPrice - debtPrice) = idealLTV * (current collateral - withdrawAmount) - current debt * debtPrice
+    // dDebt = (idealLTV * (current collateral - withdrawAmount) - current debt * debtPrice) / (idealLTV * debtPrice / collPrice - debtPrice)
+    const _dDebt = (collateralAmount.minus(withdrawalAmount).multipliedBy(idealLTV).minus(debtAmount.multipliedBy(debtPrice)).dividedBy((idealLTV * debtPrice / collateralPrice) - debtPrice));
+    const dDebt = Web3Number.fromWei(_dDebt.toWei(), debtTokenInfo.decimals);
+    if (dDebt.lessThan(0)) {
+      return { deltadebtAmountUnits: null };
+    }
+    if (dDebt.greaterThan(debtAmount)) {
+      return { deltadebtAmountUnits: debtAmount };
+    }
+    return { deltadebtAmountUnits: dDebt};
+  }
+}

package/src/utils/index.ts

@@ -1,6 +1,8 @@
-
 export * from '@/utils/logger';
 export * from './oz-merkle';
+export * from "./strategy-utils";
+export * from "./starknet-call-parser";
+export * from "./health-factor-math";
 
 // Utility type to make all optional properties required
 export type RequiredFields<T> = {

package/src/utils/logger.browser.ts

@@ -4,6 +4,20 @@ interface LeveledLogMethod {
   (message: any): void
 }
 
+export type LoggerLevel = "error" | "warn" | "info" | "verbose" | "debug";
+
+export interface LoggerConfig {
+  level?: LoggerLevel;
+  consoleLevel?: LoggerLevel;
+  fileLevel?: LoggerLevel;
+  filePath?: string;
+  enableConsole?: boolean;
+  enableFile?: boolean;
+  colorizeConsole?: boolean;
+  shortErrorsInConsole?: boolean;
+  emitConfigLog?: boolean;
+}
+
 interface MyLogger {
   error: LeveledLogMethod;
   warn: LeveledLogMethod;
@@ -13,8 +27,12 @@ interface MyLogger {
 }
 
 export const logger: MyLogger = {
-    ...console,
-    verbose(message: string) {
-        console.log(`[VERBOSE] ${message}`);
-    }
+  ...console,
+  verbose(message: string) {
+    console.log(`[VERBOSE] ${message}`);
+  }
 };
+
+export function configureLogger(_config: LoggerConfig = {}): MyLogger {
+  return logger;
+}

package/src/utils/logger.node.ts

@@ -1,35 +1,270 @@
+import fs from "fs";
+import path from "path";
 import winston, { format } from "winston";
 
+export type LoggerLevel = "error" | "warn" | "info" | "verbose" | "debug";
+
+export interface LoggerConfig {
+  level?: LoggerLevel;
+  consoleLevel?: LoggerLevel;
+  fileLevel?: LoggerLevel;
+  filePath?: string;
+  enableConsole?: boolean;
+  enableFile?: boolean;
+  colorizeConsole?: boolean;
+  shortErrorsInConsole?: boolean;
+  emitConfigLog?: boolean;
+}
+
 const colors = {
   error: "red",
   warn: "yellow",
   info: "blue",
-  verbose: "white",
-  debug: "white",
+  verbose: "cyan",
+  debug: "gray",
 };
-
-// Add custom colors to Winston
 winston.addColors(colors);
 
-export const logger = winston.createLogger({
-  level: "debug", // Set the minimum logging level
-  format: format.combine(
-    format.colorize({ all: true }), // Apply custom colors
-    format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), // Add timestamp to log messages
-    format.printf(({ timestamp, level, message, ...meta }) => {
-      let msg = `${timestamp} ${level}: ${message}`;
-      // Print stack trace if error is passed
-      if (meta && meta[Symbol.for("splat")]) {
-        for (const arg of meta[Symbol.for("splat")]) {
-          if (arg instanceof Error) {
-            msg += `\n${arg.stack}`;
-          }
-        }
+const stringifyUnknown = (value: unknown): string => {
+  if (typeof value === "string") return value;
+  if (typeof value === "undefined") return "undefined";
+  if (value === null) return "null";
+  if (value instanceof Error) return value.message || value.name || "Error";
+  try {
+    const encoded = JSON.stringify(value, (_, v) =>
+      typeof v === "bigint" ? v.toString() : v,
+    );
+    return encoded ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+
+const stripAnsi = (text: unknown): string =>
+  stringifyUnknown(text).replace(/\u001b\[[0-9;]*m/g, "");
+
+const escapeValue = (value: string): string =>
+  value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+
+const escapeMessageValue = (value: string): string =>
+  value
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, "'")
+    .replace(/\n/g, "\\n");
+
+const ANSI = {
+  reset: "\x1b[0m",
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+  green: "\x1b[32m",
+};
+
+const paint = (text: string, color: string): string =>
+  `${color}${text}${ANSI.reset}`;
+
+const highlightRoutes = (text: string): string =>
+  text.replace(/\b[A-Z][A-Z0-9_]{2,}\b/g, (token) => paint(token, ANSI.yellow));
+
+const highlightCases = (text: string): string =>
+  text.replace(/\[[A-Z][A-Z0-9_]+\]/g, (token) => paint(token, ANSI.green));
+
+const colorizeMessageForConsole = (message: string): string => {
+  const hasExtendedTradeContext =
+    /\bEXTENDED_(LIMIT|MARKET)_(BUY|SELL)\b/.test(message) ||
+    /\bEXTENDED_(INCREASE|DECREASE)_LEVER\b/.test(message);
+
+  if (hasExtendedTradeContext && /\b(SUCCESS|SUCCEEDED|FILLED)\b/i.test(message)) {
+    return paint(highlightRoutes(message), ANSI.green);
+  }
+
+  if (
+    hasExtendedTradeContext &&
+    /\b(INITIATED|PENDING|SUBMITTED|RETRY|PARTIAL)\b/i.test(message)
+  ) {
+    return paint(highlightRoutes(message), ANSI.yellow);
+  }
+
+  // Failure paths should dominate visually.
+  if (/\b(fail|failed|failure|error)\b/i.test(message)) {
+    return paint(highlightRoutes(highlightCases(message)), ANSI.red);
+  }
+
+  if (/Transaction sent/i.test(message)) {
+    return paint(message, ANSI.yellow);
+  }
+
+  if (/Transaction succeeded/i.test(message)) {
+    return paint(message, ANSI.green);
+  }
+
+  if (/Detected \d+ case\(s\)/i.test(message)) {
+    return paint(highlightRoutes(highlightCases(message)), ANSI.green);
+  }
+
+  if (/_executeStandardCase route/i.test(message)) {
+    return paint(highlightRoutes(message), ANSI.green);
+  }
+
+  // For route-heavy messages, keep routes highlighted in yellow.
+  if (/\broute\b/i.test(message)) {
+    return highlightRoutes(message);
+  }
+
+  return message;
+};
+
+const FIXED_TAG_WIDTH = 10;
+
+const toFixedTag = (rawTag: string): string => {
+  const compact = rawTag.replace(/[^A-Za-z0-9_-]/g, "");
+  if (!compact) return "general".slice(0, FIXED_TAG_WIDTH).padEnd(FIXED_TAG_WIDTH, " ");
+  return compact.slice(0, FIXED_TAG_WIDTH).padEnd(FIXED_TAG_WIDTH, " ");
+};
+
+const extractTagAndMessage = (rawMessage: string): { tag: string; body: string } => {
+  const normalized = stripAnsi(rawMessage).trim();
+
+  const bracketTagMatch = normalized.match(/^\[([^\]]+)\]\s*(.*)$/);
+  if (bracketTagMatch) {
+    return {
+      tag: toFixedTag(bracketTagMatch[1]),
+      body: bracketTagMatch[2] || normalized,
+    };
+  }
+
+  const scopeTagMatch = normalized.match(/^([A-Za-z0-9_-]+)::\s*(.*)$/);
+  if (scopeTagMatch) {
+    return {
+      tag: toFixedTag(scopeTagMatch[1]),
+      body: scopeTagMatch[2] || normalized,
+    };
+  }
+
+  return {
+    tag: toFixedTag("general"),
+    body: normalized,
+  };
+};
+
+const getStackFromMeta = (
+  stack: unknown,
+  meta: Record<string, unknown>,
+): string | undefined => {
+  if (typeof stack === "string" && stack.length > 0) {
+    return stack;
+  }
+  const splat = meta[Symbol.for("splat") as unknown as keyof typeof meta] as unknown;
+  if (Array.isArray(splat)) {
+    for (const item of splat) {
+      if (item instanceof Error && item.stack) {
+        return item.stack;
       }
-      return msg;
-    })
-  ),
-  transports: [
-    new winston.transports.Console(), // Output logs to the console
-  ],
+    }
+  }
+  return undefined;
+};
+
+const DEFAULT_LEVEL = (
+  process.env.LOG_LEVEL ||
+  process.env.SDK_LOG_LEVEL ||
+  "debug"
+).toLowerCase() as LoggerLevel;
+
+const DEFAULT_CONSOLE_LEVEL = (
+  process.env.LOG_CONSOLE_LEVEL || "info"
+).toLowerCase() as LoggerLevel;
+
+const DEFAULT_FILE_LEVEL = (
+  process.env.LOG_FILE_LEVEL || DEFAULT_LEVEL
+).toLowerCase() as LoggerLevel;
+
+const DEFAULT_FILE_PATH = process.env.LOG_FILE_PATH;
+
+export const logger = winston.createLogger({
+  level: DEFAULT_LEVEL,
+  transports: [],
 });
+
+export function configureLogger(config: LoggerConfig = {}): winston.Logger {
+  const level = config.level ?? DEFAULT_LEVEL;
+  const consoleLevel = config.consoleLevel ?? DEFAULT_CONSOLE_LEVEL;
+  const fileLevel = config.fileLevel ?? DEFAULT_FILE_LEVEL;
+  const filePath = config.filePath ?? DEFAULT_FILE_PATH;
+  const enableConsole = config.enableConsole ?? true;
+  const enableFile = config.enableFile ?? Boolean(filePath);
+  const colorizeConsole = config.colorizeConsole ?? true;
+  const shortErrorsInConsole = config.shortErrorsInConsole ?? true;
+  const emitConfigLog = config.emitConfigLog ?? false;
+
+  logger.clear();
+  logger.level = level;
+
+  if (enableConsole) {
+    logger.add(
+      new winston.transports.Console({
+        level: consoleLevel,
+        format: format.combine(
+          colorizeConsole ? format.colorize({ level: true }) : format.uncolorize(),
+          format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+          format.errors({ stack: true }),
+          format.printf(({ timestamp, level, message, stack, ...meta }) => {
+            const baseMessage = stringifyUnknown(message);
+            const { tag, body } = extractTagAndMessage(baseMessage);
+            const consoleBody = colorizeConsole
+              ? colorizeMessageForConsole(body)
+              : body;
+            let out = `ts="${timestamp}" level=${stringifyUnknown(level)} [${tag}] msg="${escapeMessageValue(consoleBody)}"`;
+            if (!shortErrorsInConsole) {
+              const derivedStack = getStackFromMeta(stack, meta);
+              if (derivedStack) {
+                out += ` stack="${escapeValue(derivedStack)}"`;
+              }
+            }
+            return out;
+          }),
+        ),
+      }),
+    );
+  }
+
+  if (enableFile && filePath) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    logger.add(
+      new winston.transports.File({
+        filename: filePath,
+        level: fileLevel,
+        format: format.combine(
+          format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+          format.errors({ stack: true }),
+          format.printf(({ timestamp, level, message, stack, ...meta }) => {
+            const parsedMessage = stringifyUnknown(message);
+            const normalizedMessage = stripAnsi(parsedMessage);
+            const { tag, body } = extractTagAndMessage(normalizedMessage);
+            let out = `ts="${timestamp}" level=${stripAnsi(level)} [${tag}] msg="${escapeMessageValue(body)}"`;
+            const derivedStack = getStackFromMeta(stack, meta);
+            if (derivedStack) {
+              out += ` stack="${escapeValue(stripAnsi(derivedStack))}"`;
+            }
+            const metaCopy = { ...meta } as Record<string, unknown>;
+            delete metaCopy[
+              Symbol.for("splat") as unknown as keyof typeof metaCopy
+            ];
+            if (Object.keys(metaCopy).length > 0) {
+              out += ` meta=${escapeValue(stringifyUnknown(metaCopy))}`;
+            }
+            return out;
+          }),
+        ),
+      }),
+    );
+  }
+
+  if (emitConfigLog) {
+    logger.info(
+      `[Logger] configured level=${level} console=${enableConsole ? consoleLevel : "off"} file=${enableFile ? fileLevel : "off"}${filePath ? ` path=${filePath}` : ""}`,
+    );
+  }
+  return logger;
+}
+
+configureLogger();