@upshiftfinance/sdk 0.0.0-stage → 0.2.0

package/lib/core/analytics/app-name.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAppName = validateAppName;
+const errors_1 = require("../errors");
+/**
+ * Validate an `appName` slug at SDK boundary points (the `UpshiftSDK`
+ * constructor and the standalone {@link initializeSentry} entry point).
+ *
+ * Rules (kept intentionally narrow so the value is safe to use as a Sentry
+ * tag, an HTTP header value, and a filesystem-safe identifier — this is
+ * why we accept slugs only, not display names):
+ *  - non-empty after trim
+ *  - 3..64 characters
+ *  - only `[a-zA-Z0-9._-]`
+ *  - not shaped like an EVM address (`0x` + 40 hex chars) — an address
+ *    passes the character rules but is a high-cardinality wallet
+ *    identifier, not an application name. This also catches callers of
+ *    `initializeSentry` still passing the pre-v9 positional argument
+ *    order, where a wallet address occupied the slot `appName` now holds.
+ *
+ * Throws a descriptive `UpshiftValidationError` (code `INVALID_INPUT`) that
+ * names the failed rule and includes a remediation hint pointing at the
+ * docs link.
+ *
+ * @param value - The candidate app name, as received from the caller.
+ * @returns The trimmed, validated slug.
+ * @throws UpshiftValidationError when the value is missing, empty,
+ *   mis-typed, out of the 3–64 length range, contains disallowed
+ *   characters, or is shaped like an EVM address.
+ */
+function validateAppName(value) {
+    const docsHint = 'See https://docs.augustdigital.io/developers/typescript-sdk/javascript-sdk#app-name';
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new errors_1.UpshiftValidationError('INVALID_INPUT', `Upshift SDK: \`appName\` is required. Pass a stable kebab-case slug identifying your application (e.g. "acme-trader"). ${docsHint}`);
+    }
+    const trimmed = value.trim();
+    if (trimmed.length < 3 || trimmed.length > 64) {
+        throw new errors_1.UpshiftValidationError('INVALID_INPUT', `Upshift SDK: \`appName\` must be 3-64 characters (got ${trimmed.length}). ${docsHint}`);
+    }
+    if (!/^[a-zA-Z0-9._-]+$/.test(trimmed)) {
+        throw new errors_1.UpshiftValidationError('INVALID_INPUT', `Upshift SDK: \`appName\` may only contain letters, digits, '.', '_' and '-' (got "${trimmed}"). Use a slug like "acme-trader", not a display name. ${docsHint}`);
+    }
+    if (/^0x[0-9a-fA-F]{40}$/.test(trimmed)) {
+        throw new errors_1.UpshiftValidationError('INVALID_INPUT', `Upshift SDK: \`appName\` looks like a wallet address ("${trimmed}"). Pass an application slug like "acme-trader" — if you are calling initializeSentry directly, note that since v9 the argument order is (config, environment, appName, walletAddress?, apiKey?). ${docsHint}`);
+    }
+    return trimmed;
+}
+//# sourceMappingURL=app-name.js.map

package/lib/core/analytics/chain-name.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Map a numeric `chainId` to a stable lowercase slug for use as a Sentry tag
+ * value. Resolves both EVM chains ({@link NETWORKS}) and synthetic non-EVM
+ * chain IDs ({@link SPECIAL_CHAINS}); unknown IDs return `'unknown:<id>'`.
+ *
+ * @param chainId - Numeric chain ID, including negative IDs for non-EVM chains.
+ * @returns Slugified chain label (e.g. `'ethereum'`, `'arbitrum-one'`, `'solana'`).
+ */
+export declare function chainIdToTagValue(chainId: number | undefined): string;

package/lib/core/analytics/chain-name.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainIdToTagValue = chainIdToTagValue;
+const web3_1 = require("../constants/web3");
+/**
+ * Map a numeric `chainId` to a stable lowercase slug for use as a Sentry tag
+ * value. Resolves both EVM chains ({@link NETWORKS}) and synthetic non-EVM
+ * chain IDs ({@link SPECIAL_CHAINS}); unknown IDs return `'unknown:<id>'`.
+ *
+ * @param chainId - Numeric chain ID, including negative IDs for non-EVM chains.
+ * @returns Slugified chain label (e.g. `'ethereum'`, `'arbitrum-one'`, `'solana'`).
+ */
+function chainIdToTagValue(chainId) {
+    if (chainId === undefined || chainId === null || Number.isNaN(chainId)) {
+        return 'unknown';
+    }
+    for (const entry of Object.values(web3_1.SPECIAL_CHAINS)) {
+        if (entry.chainId === chainId) {
+            return slugify(entry.name);
+        }
+    }
+    const network = web3_1.NETWORKS[chainId];
+    if (network) {
+        return slugify(network.name);
+    }
+    return `unknown:${chainId}`;
+}
+function slugify(input) {
+    return input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+//# sourceMappingURL=chain-name.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * Sentry DSN for SDK analytics.
+ * This is an internal constant - not exposed to SDK users.
+ */
+export declare const SENTRY_DSN = "https://ca39246016d0b43154f0640314cbd3b5@o4507215496609792.ingest.de.sentry.io/4511864614813776";
+/**
+ * `appName` slugs of applications Upshift operate themselves.
+ *
+ * Traffic from these is tagged `partner.tier: 'internal'` so that
+ * `partner.tier:unverified` in Sentry already means "external integrator"
+ * before the backend verification endpoint exists. Anything not listed stays
+ * `unverified`; the future verified flow adds a `verified` tier alongside
+ * rather than replacing this list.
+ */
+export declare const FIRST_PARTY_APP_NAMES: ReadonlySet<string>;

package/lib/core/analytics/constants.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIRST_PARTY_APP_NAMES = exports.SENTRY_DSN = void 0;
+/**
+ * Sentry DSN for SDK analytics.
+ * This is an internal constant - not exposed to SDK users.
+ */
+exports.SENTRY_DSN = 'https://ca39246016d0b43154f0640314cbd3b5@o4507215496609792.ingest.de.sentry.io/4511864614813776';
+/**
+ * `appName` slugs of applications Upshift operate themselves.
+ *
+ * Traffic from these is tagged `partner.tier: 'internal'` so that
+ * `partner.tier:unverified` in Sentry already means "external integrator"
+ * before the backend verification endpoint exists. Anything not listed stays
+ * `unverified`; the future verified flow adds a `verified` tier alongside
+ * rather than replacing this list.
+ */
+exports.FIRST_PARTY_APP_NAMES = new Set([
+    'upshift-web-app',
+    'upshift-earn',
+    'upshift-prime',
+    'upshift-cli',
+    'upshift-mcp',
+    // Legacy slugs still emitted by pre-rebrand CLI/MCP installs.
+    'august-cli',
+    'august-mcp',
+]);
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1,46 @@
+/**
+ * Environment-variable gates for analytics. Pure functions — safe to import
+ * anywhere, no Sentry side effects. Tested directly in `analytics.test.js`.
+ */
+/**
+ * Read a process env var without crashing in browsers or in bundles where
+ * `process.env` is a frozen / proxied object that throws on missing keys.
+ */
+export declare function readEnv(name: string): string | undefined;
+/**
+ * `UPSHIFT_SDK_FORCE_ANALYTICS=1` bypasses the dev/test and localhost gates.
+ * Used by our own smoke-test script and by partners deliberately exercising
+ * telemetry in a non-prod environment.
+ */
+export declare function isAnalyticsForcedOnViaEnv(): boolean;
+/**
+ * `UPSHIFT_SDK_DISABLE_ANALYTICS=1` is the env equivalent of passing
+ * `analytics: { enabled: false }`. Useful when partners can't easily plumb
+ * config through (CI runners, ops scripts).
+ */
+export declare function isAnalyticsDisabledViaEnv(): boolean;
+/**
+ * True when `NODE_ENV` is `'development'` or `'test'`. The SDK auto-disables
+ * analytics in these environments so partners' local dev runs and Jest suites
+ * don't pollute the production Sentry project.
+ *
+ * `NODE_ENV` undefined / `'production'` / `'staging'` / anything else → false.
+ */
+export declare function isNodeDevOrTestEnv(): boolean;
+/**
+ * True when the page is being served from a developer's own machine or private
+ * network.
+ *
+ * The browser counterpart to {@link isNodeDevOrTestEnv}: bundlers strip or
+ * stub `process.env`, so `NODE_ENV` cannot tell a `next dev` tab apart from a
+ * production deploy. The hostname can. Always false in Node, where
+ * `NODE_ENV` is the gate.
+ *
+ * Recognises `localhost` and the `.localhost` TLD (RFC 6761 reserves both for
+ * loopback), mDNS `.local` names, and any loopback / private / link-local IP
+ * literal in either address family. Anything else — including a public host
+ * that merely *contains* one of those names, like `localhost.acme.com` — is
+ * treated as a real deployment, because suppressing a genuine production
+ * origin is the more costly mistake of the two.
+ */
+export declare function isLocalhost(): boolean;

package/lib/core/analytics/env.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Environment-variable gates for analytics. Pure functions — safe to import
+ * anywhere, no Sentry side effects. Tested directly in `analytics.test.js`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEnv = readEnv;
+exports.isAnalyticsForcedOnViaEnv = isAnalyticsForcedOnViaEnv;
+exports.isAnalyticsDisabledViaEnv = isAnalyticsDisabledViaEnv;
+exports.isNodeDevOrTestEnv = isNodeDevOrTestEnv;
+exports.isLocalhost = isLocalhost;
+/**
+ * Read a process env var without crashing in browsers or in bundles where
+ * `process.env` is a frozen / proxied object that throws on missing keys.
+ */
+function readEnv(name) {
+    try {
+        if (typeof process !== 'undefined' && process.env) {
+            return process.env[name];
+        }
+    }
+    catch {
+        // Bundlers occasionally throw on `process.env` access. Treat as unset.
+    }
+    return undefined;
+}
+function isTruthyEnv(value) {
+    if (!value)
+        return false;
+    const v = value.toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+}
+/**
+ * `UPSHIFT_SDK_FORCE_ANALYTICS=1` bypasses the dev/test and localhost gates.
+ * Used by our own smoke-test script and by partners deliberately exercising
+ * telemetry in a non-prod environment.
+ */
+function isAnalyticsForcedOnViaEnv() {
+    return isTruthyEnv(readEnv('UPSHIFT_SDK_FORCE_ANALYTICS'));
+}
+/**
+ * `UPSHIFT_SDK_DISABLE_ANALYTICS=1` is the env equivalent of passing
+ * `analytics: { enabled: false }`. Useful when partners can't easily plumb
+ * config through (CI runners, ops scripts).
+ */
+function isAnalyticsDisabledViaEnv() {
+    return isTruthyEnv(readEnv('UPSHIFT_SDK_DISABLE_ANALYTICS'));
+}
+/**
+ * True when `NODE_ENV` is `'development'` or `'test'`. The SDK auto-disables
+ * analytics in these environments so partners' local dev runs and Jest suites
+ * don't pollute the production Sentry project.
+ *
+ * `NODE_ENV` undefined / `'production'` / `'staging'` / anything else → false.
+ */
+function isNodeDevOrTestEnv() {
+    const env = readEnv('NODE_ENV');
+    return env === 'development' || env === 'test';
+}
+/** Dotted-quad IPv4 literal. Anchored, so `10.acme.com` is not an address. */
+const IPV4_LITERAL = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
+/**
+ * True for an IPv4 literal that cannot be a public production origin: loopback
+ * (`127.0.0.0/8` — `127.0.0.1` is only the most common of 16.7M), the
+ * "this host" block (`0.0.0.0/8`), the three RFC 1918 private ranges, and
+ * link-local (`169.254.0.0/16`).
+ *
+ * Ranges are checked by octet rather than by string prefix on purpose: a
+ * `startsWith('10.')` test both misses `172.20.0.2` (a default Docker bridge
+ * address, and a very ordinary way to reach a container) and misfires on a
+ * public host that merely begins with those digits.
+ */
+function isPrivateIpv4(hostname) {
+    const octets = IPV4_LITERAL.exec(hostname);
+    if (!octets)
+        return false;
+    const [a, b, c, d] = octets.slice(1).map(Number);
+    // The regex counts digits, not values, so an out-of-range quad still matches
+    // its shape. `127.0.0.999` is not an address — the URL parser rejects it
+    // rather than handing it over as a `hostname` — so it is a name, and names
+    // that are not the reserved ones are treated as deployed.
+    if (a > 255 || b > 255 || c > 255 || d > 255)
+        return false;
+    return (a === 127 ||
+        a === 0 ||
+        a === 10 ||
+        (a === 172 && b >= 16 && b <= 31) ||
+        (a === 192 && b === 168) ||
+        (a === 169 && b === 254));
+}
+/**
+ * True for an IPv6 literal that cannot be a public production origin:
+ * loopback (`::1`, in either notation), the unspecified address, an
+ * IPv4-mapped private address, unique-local (`fc00::/7`) and link-local
+ * (`fe80::/10`).
+ *
+ * `hostname` carries the brackets for an IPv6 host — `http://[::1]:3000/`
+ * yields `[::1]`, per the URL standard's host serialization — so they are
+ * stripped before matching.
+ */
+function isLocalIpv6(hostname) {
+    const host = hostname.replace(/^\[/, '').replace(/\]$/, '');
+    if (!host.includes(':'))
+        return false;
+    if (host === '::1' || host === '::')
+        return true;
+    if (/^(?:0{1,4}:){7}0{0,3}1$/.test(host))
+        return true;
+    if (host.startsWith('::ffff:'))
+        return isPrivateIpv4(host.slice(7));
+    return /^f[cd]/.test(host) || /^fe[89ab]/.test(host);
+}
+/**
+ * True when the page is being served from a developer's own machine or private
+ * network.
+ *
+ * The browser counterpart to {@link isNodeDevOrTestEnv}: bundlers strip or
+ * stub `process.env`, so `NODE_ENV` cannot tell a `next dev` tab apart from a
+ * production deploy. The hostname can. Always false in Node, where
+ * `NODE_ENV` is the gate.
+ *
+ * Recognises `localhost` and the `.localhost` TLD (RFC 6761 reserves both for
+ * loopback), mDNS `.local` names, and any loopback / private / link-local IP
+ * literal in either address family. Anything else — including a public host
+ * that merely *contains* one of those names, like `localhost.acme.com` — is
+ * treated as a real deployment, because suppressing a genuine production
+ * origin is the more costly mistake of the two.
+ */
+function isLocalhost() {
+    try {
+        if (typeof window !== 'undefined' && window.location) {
+            // Hostnames are case-insensitive; browsers normalize, other runtimes
+            // hosting a `window` shim may not.
+            const hostname = String(window.location.hostname).toLowerCase();
+            return (hostname === 'localhost' ||
+                hostname.endsWith('.localhost') ||
+                hostname.endsWith('.local') ||
+                isPrivateIpv4(hostname) ||
+                isLocalIpv6(hostname));
+        }
+    }
+    catch {
+        // Some embedded/sandboxed runtimes throw on `window.location`. Not local.
+    }
+    return false;
+}
+//# sourceMappingURL=env.js.map

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

@@ -0,0 +1,39 @@
+/**
+ * Analytics module for SDK usage tracking via Sentry.
+ *
+ * Features:
+ * - User identification (API key hash, wallet, domain, fingerprint, session)
+ * - Method call tracking with timing, classified by {@link METHOD_CATEGORIES}
+ * - Application attribution (`app.name`, `partner.id`, `partner.tier`,
+ *   `sdk.surface`) on every event and span
+ * - API response time tracking
+ * - Chain/network usage distribution
+ *
+ * @example
+ * ```typescript
+ * // Analytics enabled by default
+ * const sdk = new UpshiftSDK({
+ *   appName: 'acme-trader',
+ *   providers: { 1: 'https://...' },
+ *   keys: { upshift: '...' },
+ * });
+ *
+ * // Opt-out of analytics
+ * const sdk = new UpshiftSDK({
+ *   appName: 'acme-trader',
+ *   providers: { 1: 'https://...' },
+ *   keys: { upshift: '...' },
+ *   analytics: { enabled: false },
+ * });
+ * ```
+ */
+export type { IAnalyticsConfig, IUserIdentity, IMethodCallMetrics, } from './types';
+export { hashApiKey, getSessionId, generateFingerprint, createUserIdentity, getUserId, } from './user-identity';
+export { initializeSentry, updateUser, clearUser, isAnalyticsEnabled, getSentry, resetAnalytics, captureSdkException, } from './sentry';
+export { getSentrySDK, getSentryRuntime } from './sentry-runtime';
+export { readEnv, isAnalyticsDisabledViaEnv, isAnalyticsForcedOnViaEnv, isNodeDevOrTestEnv, } from './env';
+export { trackApiCall, trackNetworkSwitch, trackKeyVerification, getCacheStats, resetCacheStats, } from './metrics';
+export { sanitizeArgs, sanitizeObject, computeArgShape } from './sanitize';
+export { withMethodTracking, withSyncMethodTracking, instrumentClass, } from './instrumentation';
+export { METHOD_CATEGORIES, getMethodCategory, type MethodCategory, } from './method-taxonomy';
+export { chainIdToTagValue } from './chain-name';

package/lib/core/analytics/index.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Analytics module for SDK usage tracking via Sentry.
+ *
+ * Features:
+ * - User identification (API key hash, wallet, domain, fingerprint, session)
+ * - Method call tracking with timing, classified by {@link METHOD_CATEGORIES}
+ * - Application attribution (`app.name`, `partner.id`, `partner.tier`,
+ *   `sdk.surface`) on every event and span
+ * - API response time tracking
+ * - Chain/network usage distribution
+ *
+ * @example
+ * ```typescript
+ * // Analytics enabled by default
+ * const sdk = new UpshiftSDK({
+ *   appName: 'acme-trader',
+ *   providers: { 1: 'https://...' },
+ *   keys: { upshift: '...' },
+ * });
+ *
+ * // Opt-out of analytics
+ * const sdk = new UpshiftSDK({
+ *   appName: 'acme-trader',
+ *   providers: { 1: 'https://...' },
+ *   keys: { upshift: '...' },
+ *   analytics: { enabled: false },
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainIdToTagValue = exports.getMethodCategory = exports.METHOD_CATEGORIES = exports.instrumentClass = exports.withSyncMethodTracking = exports.withMethodTracking = exports.computeArgShape = exports.sanitizeObject = exports.sanitizeArgs = exports.resetCacheStats = exports.getCacheStats = exports.trackKeyVerification = exports.trackNetworkSwitch = exports.trackApiCall = exports.isNodeDevOrTestEnv = exports.isAnalyticsForcedOnViaEnv = exports.isAnalyticsDisabledViaEnv = exports.readEnv = exports.getSentryRuntime = exports.getSentrySDK = exports.captureSdkException = exports.resetAnalytics = exports.getSentry = exports.isAnalyticsEnabled = exports.clearUser = exports.updateUser = exports.initializeSentry = exports.getUserId = exports.createUserIdentity = exports.generateFingerprint = exports.getSessionId = exports.hashApiKey = void 0;
+// User identity utilities
+var user_identity_1 = require("./user-identity");
+Object.defineProperty(exports, "hashApiKey", { enumerable: true, get: function () { return user_identity_1.hashApiKey; } });
+Object.defineProperty(exports, "getSessionId", { enumerable: true, get: function () { return user_identity_1.getSessionId; } });
+Object.defineProperty(exports, "generateFingerprint", { enumerable: true, get: function () { return user_identity_1.generateFingerprint; } });
+Object.defineProperty(exports, "createUserIdentity", { enumerable: true, get: function () { return user_identity_1.createUserIdentity; } });
+Object.defineProperty(exports, "getUserId", { enumerable: true, get: function () { return user_identity_1.getUserId; } });
+// Sentry core
+var sentry_1 = require("./sentry");
+Object.defineProperty(exports, "initializeSentry", { enumerable: true, get: function () { return sentry_1.initializeSentry; } });
+Object.defineProperty(exports, "updateUser", { enumerable: true, get: function () { return sentry_1.updateUser; } });
+Object.defineProperty(exports, "clearUser", { enumerable: true, get: function () { return sentry_1.clearUser; } });
+Object.defineProperty(exports, "isAnalyticsEnabled", { enumerable: true, get: function () { return sentry_1.isAnalyticsEnabled; } });
+Object.defineProperty(exports, "getSentry", { enumerable: true, get: function () { return sentry_1.getSentry; } });
+Object.defineProperty(exports, "resetAnalytics", { enumerable: true, get: function () { return sentry_1.resetAnalytics; } });
+Object.defineProperty(exports, "captureSdkException", { enumerable: true, get: function () { return sentry_1.captureSdkException; } });
+// Isomorphic Sentry runtime resolver
+var sentry_runtime_1 = require("./sentry-runtime");
+Object.defineProperty(exports, "getSentrySDK", { enumerable: true, get: function () { return sentry_runtime_1.getSentrySDK; } });
+Object.defineProperty(exports, "getSentryRuntime", { enumerable: true, get: function () { return sentry_runtime_1.getSentryRuntime; } });
+// Env-variable gates
+var env_1 = require("./env");
+Object.defineProperty(exports, "readEnv", { enumerable: true, get: function () { return env_1.readEnv; } });
+Object.defineProperty(exports, "isAnalyticsDisabledViaEnv", { enumerable: true, get: function () { return env_1.isAnalyticsDisabledViaEnv; } });
+Object.defineProperty(exports, "isAnalyticsForcedOnViaEnv", { enumerable: true, get: function () { return env_1.isAnalyticsForcedOnViaEnv; } });
+Object.defineProperty(exports, "isNodeDevOrTestEnv", { enumerable: true, get: function () { return env_1.isNodeDevOrTestEnv; } });
+// Metrics tracking
+var metrics_1 = require("./metrics");
+Object.defineProperty(exports, "trackApiCall", { enumerable: true, get: function () { return metrics_1.trackApiCall; } });
+Object.defineProperty(exports, "trackNetworkSwitch", { enumerable: true, get: function () { return metrics_1.trackNetworkSwitch; } });
+Object.defineProperty(exports, "trackKeyVerification", { enumerable: true, get: function () { return metrics_1.trackKeyVerification; } });
+Object.defineProperty(exports, "getCacheStats", { enumerable: true, get: function () { return metrics_1.getCacheStats; } });
+Object.defineProperty(exports, "resetCacheStats", { enumerable: true, get: function () { return metrics_1.resetCacheStats; } });
+// Sanitization utilities
+var sanitize_1 = require("./sanitize");
+Object.defineProperty(exports, "sanitizeArgs", { enumerable: true, get: function () { return sanitize_1.sanitizeArgs; } });
+Object.defineProperty(exports, "sanitizeObject", { enumerable: true, get: function () { return sanitize_1.sanitizeObject; } });
+Object.defineProperty(exports, "computeArgShape", { enumerable: true, get: function () { return sanitize_1.computeArgShape; } });
+// Method instrumentation
+var instrumentation_1 = require("./instrumentation");
+Object.defineProperty(exports, "withMethodTracking", { enumerable: true, get: function () { return instrumentation_1.withMethodTracking; } });
+Object.defineProperty(exports, "withSyncMethodTracking", { enumerable: true, get: function () { return instrumentation_1.withSyncMethodTracking; } });
+Object.defineProperty(exports, "instrumentClass", { enumerable: true, get: function () { return instrumentation_1.instrumentClass; } });
+// Method taxonomy
+var method_taxonomy_1 = require("./method-taxonomy");
+Object.defineProperty(exports, "METHOD_CATEGORIES", { enumerable: true, get: function () { return method_taxonomy_1.METHOD_CATEGORIES; } });
+Object.defineProperty(exports, "getMethodCategory", { enumerable: true, get: function () { return method_taxonomy_1.getMethodCategory; } });
+// Chain name helper
+var chain_name_1 = require("./chain-name");
+Object.defineProperty(exports, "chainIdToTagValue", { enumerable: true, get: function () { return chain_name_1.chainIdToTagValue; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,29 @@
+/**
+ * Higher-order function to wrap SDK methods with performance tracking.
+ * Tracks method calls, timing, chain usage, and errors.
+ *
+ * @param methodName - Name of the method being wrapped
+ * @param method - The original async method
+ * @param getChainId - Function to get current chain ID
+ * @returns Wrapped method with tracking
+ */
+export declare function withMethodTracking<T extends (...args: unknown[]) => Promise<unknown>>(methodName: string, method: T, getChainId?: () => number | undefined): T;
+/**
+ * Higher-order function to wrap synchronous SDK methods with tracking.
+ * Uses breadcrumbs for tracking since spans require async context.
+ *
+ * @param methodName - Name of the method being wrapped
+ * @param method - The original sync method
+ * @param getChainId - Function to get current chain ID
+ * @returns Wrapped method with tracking
+ */
+export declare function withSyncMethodTracking<T extends (...args: unknown[]) => unknown>(methodName: string, method: T, getChainId?: () => number | undefined): T;
+/**
+ * Instrument all methods on a class instance with tracking.
+ * This auto-wraps all public methods (both async and sync) without boilerplate.
+ *
+ * @param instance - The class instance to instrument
+ * @param getChainId - Function to get current chain ID
+ * @returns The same instance with instrumented methods
+ */
+export declare function instrumentClass<T extends object>(instance: T, getChainId: () => number | undefined): T;