upshift-finance 1.0.0

package/lib/core/analytics/sanitize.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeString = sanitizeString;
+exports.sanitizeError = sanitizeError;
+exports.sanitizeForLogging = sanitizeForLogging;
+exports.computeArgShape = computeArgShape;
+exports.sanitizeArgs = sanitizeArgs;
+exports.sanitizeObject = sanitizeObject;
+/** Keys that should never be sent to logging/observability sinks */
+const SENSITIVE_KEYS = [
+    'apikey',
+    'api_key',
+    'apiKey',
+    'x-api-key',
+    'password',
+    'secret',
+    'token',
+    'bearer',
+    'authorization',
+    'proxy-authorization',
+    'cookie',
+    'set-cookie',
+    'privatekey',
+    'private_key',
+    'privateKey',
+    'mnemonic',
+    'seed',
+    // RPC endpoints can carry the API key in the path (e.g. Alchemy `/v2/<key>`),
+    // so a `sorobanRpcUrl` / `rpcUrl` argument must never reach telemetry. Matched
+    // as a substring, so it also covers `sorobanRpcUrls` and snake_case variants.
+    'rpcurl',
+    'rpc_url',
+];
+/** Regex patterns applied in order to scrub secrets from free-form strings. */
+const STRING_REDACTION_PATTERNS = [
+    [/(authorization\s*[:=]\s*)(bearer|basic|token)\s+\S+/gi, '$1$2 [REDACTED]'],
+    [
+        /([?&](?:api[-_]?key|apikey|access[-_]?token|token|key|auth)=)[^&\s#]+/gi,
+        '$1[REDACTED]',
+    ],
+    [/(gateway\.thegraph\.com\/api\/)[A-Za-z0-9]{20,}(\/)/g, '$1[REDACTED]$2'],
+    // Provider path-embedded API keys (e.g. Alchemy `…/v2/<key>`, Infura `…/v3/<key>`):
+    // a 16+ char token right after a `/vN/` segment is a key, not a resource path.
+    [/(\/v\d+\/)[A-Za-z0-9_-]{16,}/g, '$1[REDACTED]'],
+    [/eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, '[REDACTED_JWT]'],
+    [/\bnpm_[A-Za-z0-9]{30,}\b/g, '[REDACTED_NPM_TOKEN]'],
+    // Stop value match at & # so adjacent query params aren't swallowed.
+    [
+        /(\b(?:api[-_]?key|apikey|password|secret|private[-_]?key|mnemonic|seed)\s*[:=]\s*)["']?[^\s"',;}&#]+["']?/gi,
+        '$1[REDACTED]',
+    ],
+];
+/**
+ * Redact secrets from a free-form string (error messages, URLs, log lines).
+ *
+ * @example
+ *   sanitizeString('Request failed: https://api.example.com/v1?api_key=abc123')
+ *   // → 'Request failed: https://api.example.com/v1?api_key=[REDACTED]'
+ */
+function sanitizeString(input) {
+    if (!input)
+        return input;
+    let out = input;
+    for (const [pattern, replacement] of STRING_REDACTION_PATTERNS) {
+        out = out.replace(pattern, replacement);
+    }
+    return out;
+}
+/**
+ * Return a redacted clone of `err`. Preserves prototype (so `instanceof` checks
+ * keep working), `name`, all own properties (`code`, `status`, `correlationId`,
+ * …), and `cause`. Subclass constructors are NOT invoked — they may have
+ * positional signatures (`new AugustAuthError(code, message, opts)`) that would
+ * misalign if we naively passed the sanitized message as the first arg.
+ */
+function sanitizeError(err) {
+    if (!(err instanceof Error))
+        return err;
+    const safe = Object.create(Object.getPrototypeOf(err));
+    for (const key of Object.getOwnPropertyNames(err)) {
+        const value = err[key];
+        if (key === 'message' && typeof value === 'string') {
+            safe[key] = sanitizeString(value);
+        }
+        else if (key === 'stack' && typeof value === 'string') {
+            safe[key] = sanitizeString(value);
+        }
+        else {
+            safe[key] = value;
+        }
+    }
+    if (!safe.message && typeof err.message === 'string') {
+        safe.message = sanitizeString(err.message);
+    }
+    if (!safe.stack && typeof err.stack === 'string') {
+        safe.stack = sanitizeString(err.stack);
+    }
+    safe.name = err.name;
+    return safe;
+}
+/** Sanitize arbitrary log input (strings, errors, objects, arrays, primitives). */
+function sanitizeForLogging(input, depth = 0) {
+    if (input === null || input === undefined)
+        return input;
+    if (depth > 3)
+        return '[TRUNCATED]';
+    if (typeof input === 'string')
+        return sanitizeString(input);
+    if (typeof input === 'number' || typeof input === 'boolean')
+        return input;
+    if (input instanceof Error)
+        return sanitizeError(input);
+    if (Array.isArray(input)) {
+        return input.slice(0, 10).map((v) => sanitizeForLogging(v, depth + 1));
+    }
+    if (typeof input === 'object') {
+        return sanitizeObject(input, depth);
+    }
+    return `[${typeof input}]`;
+}
+/**
+ * Compute a value-free structural signature for a list of arguments — used
+ * as the `sdk.argShape` Sentry tag so dashboards can count which overload of
+ * a method partners call without ingesting wallet addresses or other PII.
+ *
+ * Tokens: primitives keep their `typeof` name; 0x-prefixed strings narrow to
+ * `'address'` / `'tx-hash'` / `'hex'`; arrays render as `'array(<length>)'`;
+ * objects render as `'options{<sorted,keys>}'`, capped at 12 keys.
+ *
+ * @param args - The `arguments` array of an instrumented method.
+ * @returns Shape tokens, one per arg, in argument order.
+ *
+ * @example
+ *   computeArgShape(['0xabc…ef', { vault: '0x…', chainId: 1 }])
+ *   // → ['address', 'options{chainId,vault}']
+ */
+function computeArgShape(args) {
+    return args.map((arg) => shapeOf(arg));
+}
+function shapeOf(value) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    const t = typeof value;
+    if (t === 'boolean' || t === 'number' || t === 'bigint' || t === 'function') {
+        return t;
+    }
+    if (t === 'string') {
+        const s = value;
+        if (/^0x[a-fA-F0-9]{40}$/.test(s))
+            return 'address';
+        if (/^0x[a-fA-F0-9]{64}$/.test(s))
+            return 'tx-hash';
+        if (/^0x[a-fA-F0-9]{6,}$/.test(s))
+            return 'hex';
+        return 'string';
+    }
+    if (Array.isArray(value)) {
+        return `array(${value.length})`;
+    }
+    if (t === 'object') {
+        const keys = Object.keys(value).sort();
+        const capped = keys.slice(0, 12);
+        const more = keys.length > 12 ? `,+${keys.length - 12}` : '';
+        return `options{${capped.join(',')}${more}}`;
+    }
+    return t;
+}
+/**
+ * Sanitize method arguments for safe logging to Sentry.
+ * Removes sensitive data and truncates large values.
+ */
+function sanitizeArgs(args) {
+    const sanitized = {};
+    args.forEach((arg, index) => {
+        const key = `arg${index}`;
+        if (arg === null || arg === undefined) {
+            sanitized[key] = arg;
+            return;
+        }
+        if (typeof arg === 'string') {
+            // Scrub embedded secrets, then truncate long strings.
+            const scrubbed = sanitizeString(arg);
+            sanitized[key] =
+                scrubbed.length > 100 ? `${scrubbed.substring(0, 100)}...` : scrubbed;
+            return;
+        }
+        if (typeof arg === 'number' || typeof arg === 'boolean') {
+            sanitized[key] = arg;
+            return;
+        }
+        if (typeof arg === 'object') {
+            sanitized[key] = sanitizeObject(arg);
+            return;
+        }
+        // For functions or other types, just note the type
+        sanitized[key] = `[${typeof arg}]`;
+    });
+    return sanitized;
+}
+/**
+ * Recursively sanitize an object, removing sensitive keys.
+ */
+function sanitizeObject(obj, depth = 0) {
+    // Prevent deep recursion
+    if (depth > 3) {
+        return { _truncated: true };
+    }
+    const sanitized = {};
+    for (const [key, value] of Object.entries(obj)) {
+        // Skip sensitive keys
+        if (SENSITIVE_KEYS.some((sk) => key.toLowerCase().includes(sk.toLowerCase()))) {
+            sanitized[key] = '[REDACTED]';
+            continue;
+        }
+        if (value === null || value === undefined) {
+            sanitized[key] = value;
+            continue;
+        }
+        if (typeof value === 'string') {
+            // Check if value looks like a private key or sensitive data
+            if (value.length > 64 && /^[a-fA-F0-9]+$/.test(value)) {
+                sanitized[key] = '[REDACTED_HEX]';
+                continue;
+            }
+            // Scrub embedded secrets (API keys in URL paths/queries, bearer tokens,
+            // JWTs, …) from free-form values before truncating — key-name matching
+            // alone misses a secret carried inside a value under a benign key.
+            const scrubbedValue = sanitizeString(value);
+            sanitized[key] =
+                scrubbedValue.length > 100
+                    ? `${scrubbedValue.substring(0, 100)}...`
+                    : scrubbedValue;
+            continue;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            sanitized[key] = value;
+            continue;
+        }
+        if (Array.isArray(value)) {
+            sanitized[key] =
+                value.length > 10
+                    ? { _type: 'array', length: value.length, _truncated: true }
+                    : value
+                        .slice(0, 10)
+                        .map((v) => typeof v === 'object' && v !== null
+                        ? sanitizeObject(v, depth + 1)
+                        : v);
+            continue;
+        }
+        if (typeof value === 'object') {
+            sanitized[key] = sanitizeObject(value, depth + 1);
+            continue;
+        }
+        sanitized[key] = `[${typeof value}]`;
+    }
+    return sanitized;
+}
+//# sourceMappingURL=sanitize.js.map

package/lib/core/analytics/sentry-runtime.d.ts

@@ -0,0 +1,15 @@
+import type * as SentryBrowser from '@sentry/browser';
+/**
+ * Returns the resolved Sentry SDK for the current runtime, or `null` if no
+ * SDK can be loaded. Idempotent and cached.
+ */
+export declare function getSentrySDK(): typeof SentryBrowser | null;
+/**
+ * Returns the detected runtime label (`'browser'` | `'node'` | `'unknown'`).
+ * Used to set the `sdk.runtime` Sentry tag.
+ */
+export declare function getSentryRuntime(): 'browser' | 'node' | 'unknown';
+/**
+ * Reset the cached SDK reference and runtime detection. Test-only.
+ */
+export declare function resetSentryRuntime(): void;

package/lib/core/analytics/sentry-runtime.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSentrySDK = getSentrySDK;
+exports.getSentryRuntime = getSentryRuntime;
+exports.resetSentryRuntime = resetSentryRuntime;
+const logger_1 = require("../logger");
+let cachedSdk = null;
+let detectedRuntime = 'unknown';
+function detectRuntime() {
+    try {
+        if (typeof window !== 'undefined' &&
+            typeof window.document !== 'undefined') {
+            return 'browser';
+        }
+        if (typeof process !== 'undefined' &&
+            process.versions?.node &&
+            typeof window === 'undefined') {
+            return 'node';
+        }
+    }
+    catch {
+        // Property access on locked-down globals can throw in some sandboxes.
+    }
+    return 'unknown';
+}
+function getNodeRequire() {
+    try {
+        // `new Function` is opaque to bundler static analysis (keeps
+        // @sentry/node out of browser bundles) AND blocked by strict
+        // script-src CSPs without 'unsafe-eval'. The CSP-blocked path falls
+        // through to @sentry/browser — do NOT replace with a direct
+        // `require('@sentry/node')`, which breaks the browser bundle.
+        const req = new Function('return typeof require === "function" ? require : null')();
+        return typeof req === 'function' ? req : null;
+    }
+    catch {
+        return null;
+    }
+}
+function loadSentrySDK() {
+    if (cachedSdk)
+        return cachedSdk;
+    detectedRuntime = detectRuntime();
+    if (detectedRuntime === 'node') {
+        const nodeRequire = getNodeRequire();
+        if (nodeRequire) {
+            try {
+                cachedSdk = nodeRequire('@sentry/node');
+                return cachedSdk;
+            }
+            catch (err) {
+                // Fall through to @sentry/browser, but surface it — running on Node
+                // without @sentry/node loses process-level exception capture.
+                logger_1.Logger.log.warn('analytics.runtime.sentry-node-missing', {
+                    error: err instanceof Error ? err.message : String(err),
+                    hint: 'Add @sentry/node to your dependencies for full Node telemetry coverage.',
+                });
+            }
+        }
+    }
+    try {
+        cachedSdk = require('@sentry/browser');
+    }
+    catch (err) {
+        logger_1.Logger.log.warn('analytics.runtime.sentry-browser-missing', {
+            runtime: detectedRuntime,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        cachedSdk = null;
+    }
+    return cachedSdk;
+}
+/**
+ * Returns the resolved Sentry SDK for the current runtime, or `null` if no
+ * SDK can be loaded. Idempotent and cached.
+ */
+function getSentrySDK() {
+    return loadSentrySDK();
+}
+/**
+ * Returns the detected runtime label (`'browser'` | `'node'` | `'unknown'`).
+ * Used to set the `sdk.runtime` Sentry tag.
+ */
+function getSentryRuntime() {
+    if (detectedRuntime === 'unknown') {
+        detectedRuntime = detectRuntime();
+    }
+    return detectedRuntime;
+}
+/**
+ * Reset the cached SDK reference and runtime detection. Test-only.
+ */
+function resetSentryRuntime() {
+    cachedSdk = null;
+    detectedRuntime = 'unknown';
+}
+//# sourceMappingURL=sentry-runtime.js.map

package/lib/core/analytics/sentry.d.ts

@@ -0,0 +1,67 @@
+import type * as Sentry from '@sentry/browser';
+import type { IEnv } from '../../types';
+import type { IAnalyticsConfig } from './types';
+/**
+ * Clear the error dedupe bookkeeping. Test-only — the rate limiter is process
+ * lifetime state and would otherwise leak between test cases.
+ *
+ * @internal
+ */
+export declare function resetErrorDedupe(): void;
+/**
+ * Initialize Sentry with SDK-specific configuration. Idempotent: re-calls
+ * only refresh user identity and the cached API-key hash.
+ *
+ * @param config - Analytics configuration. Pass `tracesSampleRate` to
+ *   override the default of `0.1`.
+ * @param environment - Current environment (DEV or PROD).
+ * @param walletAddress - Optional wallet address for user identification.
+ * @param apiKey - Optional API key (hashed for identification).
+ * @param appName - Optional app-name slug. Set as the global `app.name`
+ *   tag on every event; falls back to `'unverified:anonymous'` when
+ *   omitted.
+ */
+export declare function initializeSentry(config: IAnalyticsConfig, environment: IEnv, walletAddress?: string, apiKey?: string, appName?: string): void;
+/**
+ * Update the current user identity in Sentry.
+ * Called when wallet address changes.
+ *
+ * @param walletAddress - New wallet address (or undefined to clear)
+ * @param environment - Current environment
+ */
+export declare function updateUser(walletAddress?: string, environment?: IEnv): void;
+/**
+ * Clear wallet from user identity.
+ * Called when user disconnects wallet.
+ */
+export declare function clearUser(): void;
+/**
+ * Check if analytics is enabled and initialized.
+ */
+export declare function isAnalyticsEnabled(): boolean;
+/**
+ * Get the current Sentry instance for advanced usage.
+ * Returns null if analytics is disabled.
+ */
+export declare function getSentry(): typeof Sentry | null;
+/**
+ * Reset analytics state (useful for testing).
+ */
+export declare function resetAnalytics(): void;
+/**
+ * Capture an exception into Sentry with SDK-specific context. Use from
+ * top-level error handlers (CLI, middleware, unhandled rejections) to
+ * report failures that don't flow through the auto-instrumented method
+ * surface. No-ops when analytics is disabled.
+ *
+ * @param error - Thrown value. Non-Error values are wrapped.
+ * @param options - `surface` ('cli' | 'sdk' | 'react' | string), extra `tags`,
+ *   `extra` data, and a `flushTimeoutMs` to await before resolving (needed
+ *   in Node when the process is about to exit).
+ */
+export declare function captureSdkException(error: unknown, options?: {
+    surface?: 'cli' | 'sdk' | 'react' | string;
+    tags?: Record<string, string>;
+    extra?: Record<string, unknown>;
+    flushTimeoutMs?: number;
+}): Promise<void>;