@shadow-corp/nearconnect 1.0.0

package/build/actions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"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"}

package/build/actions/types.d.ts

@@ -0,0 +1,76 @@
+export interface CreateAccountAction {
+    type: "CreateAccount";
+}
+export interface DeployContractAction {
+    type: "DeployContract";
+    params: {
+        code: Uint8Array;
+    };
+}
+export interface FunctionCallAction {
+    type: "FunctionCall";
+    params: {
+        methodName: string;
+        args: object;
+        gas: string;
+        deposit: string;
+    };
+}
+export interface TransferAction {
+    type: "Transfer";
+    params: {
+        deposit: string;
+    };
+}
+export interface StakeAction {
+    type: "Stake";
+    params: {
+        stake: string;
+        publicKey: string;
+    };
+}
+export interface AddKeyAction {
+    type: "AddKey";
+    params: {
+        publicKey: string;
+        accessKey: {
+            nonce?: number;
+            permission: "FullAccess" | {
+                receiverId: string;
+                allowance?: string;
+                methodNames?: Array<string>;
+            };
+        };
+    };
+}
+export interface DeleteKeyAction {
+    type: "DeleteKey";
+    params: {
+        publicKey: string;
+    };
+}
+export interface DeleteAccountAction {
+    type: "DeleteAccount";
+    params: {
+        beneficiaryId: string;
+    };
+}
+export interface UseGlobalContractAction {
+    type: "UseGlobalContract";
+    params: {
+        contractIdentifier: {
+            accountId: string;
+        } | {
+            /** Base58 encoded code hash */
+            codeHash: string;
+        };
+    };
+}
+export interface DeployGlobalContractAction {
+    type: "DeployGlobalContract";
+    params: {
+        code: Uint8Array;
+        deployMode: "CodeHash" | "AccountId";
+    };
+}
+export type ConnectorAction = CreateAccountAction | DeployContractAction | FunctionCallAction | TransferAction | StakeAction | AddKeyAction | DeleteKeyAction | DeleteAccountAction | UseGlobalContractAction | DeployGlobalContractAction;

package/build/actions/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/build/actions/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/actions/types.ts"],"names":[],"mappings":""}

package/build/connection/health.d.ts

@@ -0,0 +1,213 @@
+import { Account } from "../types";
+/**
+ * Connection health status
+ */
+export type HealthStatus = "healthy" | "degraded" | "stale" | "lost";
+/**
+ * Connection health information
+ */
+export interface ConnectionHealth {
+    /** Current health status */
+    status: HealthStatus;
+    /** Timestamp of last successful heartbeat */
+    lastHeartbeat: number;
+    /** Timestamp of last user interaction */
+    lastInteraction: number;
+    /** Average response latency in ms */
+    latency: number;
+    /** Number of consecutive heartbeat failures */
+    consecutiveFailures: number;
+    /** Whether currently checking health */
+    checking: boolean;
+}
+/**
+ * Health check result
+ */
+export interface HealthCheckResult {
+    success: boolean;
+    latency: number;
+    accounts?: Account[];
+    error?: Error;
+    timestamp: number;
+}
+/**
+ * Health monitor configuration
+ */
+export interface HealthConfig {
+    /** Interval between heartbeats in ms (default: 30000 = 30s) */
+    heartbeatInterval: number;
+    /** Timeout for heartbeat response in ms (default: 10000 = 10s) */
+    heartbeatTimeout: number;
+    /** Time since last interaction to consider connection stale (default: 300000 = 5min) */
+    staleThreshold: number;
+    /** Number of consecutive failures before marking as lost (default: 3) */
+    maxConsecutiveFailures: number;
+    /** Whether to auto-reconnect on failure (default: true) */
+    autoReconnect: boolean;
+    /** Whether to sync account list on heartbeat (default: false) */
+    syncAccounts: boolean;
+    /** Interval for account sync in ms (default: 60000 = 1min) */
+    syncInterval: number;
+    /** Latency threshold for degraded status in ms (default: 5000) */
+    degradedLatencyThreshold: number;
+    /** Whether to disable heartbeat entirely (default: false) */
+    disabled: boolean;
+}
+/**
+ * Default health configuration
+ */
+export declare const DEFAULT_HEALTH_CONFIG: HealthConfig;
+/**
+ * Health event types
+ */
+export interface HealthEventMap {
+    "health:check": {
+        result: HealthCheckResult;
+    };
+    "health:status-changed": {
+        from: HealthStatus;
+        to: HealthStatus;
+        health: ConnectionHealth;
+    };
+    "health:degraded": {
+        latency: number;
+        threshold: number;
+    };
+    "health:stale": {
+        lastInteraction: number;
+        threshold: number;
+    };
+    "health:lost": {
+        failures: number;
+        lastError?: Error;
+    };
+    "health:restored": {
+        previousStatus: HealthStatus;
+    };
+    "accounts:synced": {
+        accounts: Account[];
+    };
+    "accounts:changed": {
+        previous: Account[];
+        current: Account[];
+    };
+}
+/**
+ * Health check function type
+ */
+export type HealthCheckFn = () => Promise<HealthCheckResult>;
+/**
+ * Connection Health Monitor
+ *
+ * Monitors the health of wallet connections through periodic heartbeats
+ * and tracks connection quality metrics
+ */
+export declare class HealthMonitor {
+    private config;
+    private health;
+    private heartbeatTimer;
+    private syncTimer;
+    private running;
+    private healthCheck;
+    private listeners;
+    private latencyHistory;
+    private maxLatencyHistory;
+    private lastAccounts;
+    constructor(healthCheck: HealthCheckFn, config?: Partial<HealthConfig>);
+    /**
+     * Create initial health state
+     */
+    private createInitialHealth;
+    /**
+     * Start health monitoring
+     */
+    start(): void;
+    /**
+     * Stop health monitoring
+     */
+    stop(): void;
+    /**
+     * Perform a health check
+     */
+    performCheck(): Promise<HealthCheckResult>;
+    /**
+     * Record user interaction
+     */
+    recordInteraction(): void;
+    /**
+     * Get current health state
+     */
+    getHealth(): ConnectionHealth;
+    /**
+     * Get current status
+     */
+    getStatus(): HealthStatus;
+    /**
+     * Check if connection is healthy
+     */
+    isHealthy(): boolean;
+    /**
+     * Update latency tracking
+     */
+    private updateLatency;
+    /**
+     * Update health status based on current metrics
+     */
+    private updateStatus;
+    /**
+     * Check for account changes
+     */
+    private checkAccountChanges;
+    /**
+     * Sync account list
+     */
+    private syncAccountList;
+    /**
+     * Event listener
+     */
+    on<K extends keyof HealthEventMap>(event: K, callback: (payload: HealthEventMap[K]) => void): () => void;
+    /**
+     * Emit event
+     */
+    private emit;
+    /**
+     * Promise with timeout wrapper
+     */
+    private withTimeout;
+    /**
+     * Force a status update
+     */
+    forceStatusUpdate(): void;
+    /**
+     * Reset health state
+     */
+    reset(): void;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<HealthConfig>): void;
+    /**
+     * Get average latency
+     */
+    getAverageLatency(): number;
+    /**
+     * Get latency percentile
+     */
+    getLatencyPercentile(percentile: number): number;
+    /**
+     * Get uptime percentage since last reset
+     */
+    getUptimePercentage(): number;
+    /**
+     * Cleanup
+     */
+    destroy(): void;
+}
+/**
+ * Create a basic health check function for NEAR wallets
+ */
+export declare function createWalletHealthCheck(getAccounts: () => Promise<Account[]>): HealthCheckFn;
+/**
+ * Create a health monitor with standard configuration
+ */
+export declare function createHealthMonitor(healthCheck: HealthCheckFn, config?: Partial<HealthConfig>): HealthMonitor;

package/build/connection/health.js

@@ -0,0 +1,391 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthMonitor = exports.DEFAULT_HEALTH_CONFIG = void 0;
+exports.createWalletHealthCheck = createWalletHealthCheck;
+exports.createHealthMonitor = createHealthMonitor;
+/**
+ * Default health configuration
+ */
+exports.DEFAULT_HEALTH_CONFIG = {
+    heartbeatInterval: 30000,
+    heartbeatTimeout: 10000,
+    staleThreshold: 300000, // 5 minutes
+    maxConsecutiveFailures: 3,
+    autoReconnect: true,
+    syncAccounts: false,
+    syncInterval: 60000,
+    degradedLatencyThreshold: 5000,
+    disabled: false,
+};
+/**
+ * Connection Health Monitor
+ *
+ * Monitors the health of wallet connections through periodic heartbeats
+ * and tracks connection quality metrics
+ */
+class HealthMonitor {
+    config;
+    health;
+    heartbeatTimer = null;
+    syncTimer = null;
+    running = false;
+    healthCheck;
+    listeners = new Map();
+    latencyHistory = [];
+    maxLatencyHistory = 10;
+    lastAccounts = [];
+    constructor(healthCheck, config = {}) {
+        this.healthCheck = healthCheck;
+        this.config = { ...exports.DEFAULT_HEALTH_CONFIG, ...config };
+        this.health = this.createInitialHealth();
+    }
+    /**
+     * Create initial health state
+     */
+    createInitialHealth() {
+        const now = Date.now();
+        return {
+            status: "healthy",
+            lastHeartbeat: now,
+            lastInteraction: now,
+            latency: 0,
+            consecutiveFailures: 0,
+            checking: false,
+        };
+    }
+    /**
+     * Start health monitoring
+     */
+    start() {
+        if (this.running || this.config.disabled)
+            return;
+        this.running = true;
+        this.health = this.createInitialHealth();
+        // Start heartbeat
+        this.heartbeatTimer = setInterval(() => this.performCheck(), this.config.heartbeatInterval);
+        // Start account sync if enabled
+        if (this.config.syncAccounts) {
+            this.syncTimer = setInterval(() => this.syncAccountList(), this.config.syncInterval);
+        }
+        // Perform initial check
+        this.performCheck();
+    }
+    /**
+     * Stop health monitoring
+     */
+    stop() {
+        this.running = false;
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.syncTimer) {
+            clearInterval(this.syncTimer);
+            this.syncTimer = null;
+        }
+    }
+    /**
+     * Perform a health check
+     */
+    async performCheck() {
+        if (!this.running) {
+            return {
+                success: false,
+                latency: 0,
+                error: new Error("Monitor not running"),
+                timestamp: Date.now(),
+            };
+        }
+        this.health.checking = true;
+        const startTime = Date.now();
+        try {
+            // Execute health check with timeout
+            const result = await this.withTimeout(this.healthCheck(), this.config.heartbeatTimeout);
+            // Update health state
+            this.health.lastHeartbeat = Date.now();
+            this.health.consecutiveFailures = 0;
+            this.updateLatency(result.latency);
+            // Check for account changes
+            if (result.accounts && this.config.syncAccounts) {
+                this.checkAccountChanges(result.accounts);
+            }
+            // Emit check event
+            this.emit("health:check", { result });
+            // Update status
+            this.updateStatus();
+            this.health.checking = false;
+            return result;
+        }
+        catch (error) {
+            const result = {
+                success: false,
+                latency: Date.now() - startTime,
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: Date.now(),
+            };
+            // Update failure count
+            this.health.consecutiveFailures++;
+            // Emit check event
+            this.emit("health:check", { result });
+            // Update status
+            this.updateStatus();
+            this.health.checking = false;
+            return result;
+        }
+    }
+    /**
+     * Record user interaction
+     */
+    recordInteraction() {
+        this.health.lastInteraction = Date.now();
+        this.updateStatus();
+    }
+    /**
+     * Get current health state
+     */
+    getHealth() {
+        return { ...this.health };
+    }
+    /**
+     * Get current status
+     */
+    getStatus() {
+        return this.health.status;
+    }
+    /**
+     * Check if connection is healthy
+     */
+    isHealthy() {
+        return this.health.status === "healthy";
+    }
+    /**
+     * Update latency tracking
+     */
+    updateLatency(latency) {
+        this.latencyHistory.push(latency);
+        if (this.latencyHistory.length > this.maxLatencyHistory) {
+            this.latencyHistory.shift();
+        }
+        // Calculate average latency
+        const sum = this.latencyHistory.reduce((a, b) => a + b, 0);
+        this.health.latency = Math.round(sum / this.latencyHistory.length);
+    }
+    /**
+     * Update health status based on current metrics
+     */
+    updateStatus() {
+        const previousStatus = this.health.status;
+        let newStatus;
+        if (this.health.consecutiveFailures >= this.config.maxConsecutiveFailures) {
+            newStatus = "lost";
+            this.emit("health:lost", {
+                failures: this.health.consecutiveFailures,
+            });
+        }
+        else if (Date.now() - this.health.lastInteraction > this.config.staleThreshold) {
+            newStatus = "stale";
+            this.emit("health:stale", {
+                lastInteraction: this.health.lastInteraction,
+                threshold: this.config.staleThreshold,
+            });
+        }
+        else if (this.health.latency > this.config.degradedLatencyThreshold) {
+            newStatus = "degraded";
+            this.emit("health:degraded", {
+                latency: this.health.latency,
+                threshold: this.config.degradedLatencyThreshold,
+            });
+        }
+        else {
+            newStatus = "healthy";
+        }
+        if (newStatus !== previousStatus) {
+            this.health.status = newStatus;
+            // Emit status change
+            this.emit("health:status-changed", {
+                from: previousStatus,
+                to: newStatus,
+                health: this.getHealth(),
+            });
+            // Emit restored event if recovering
+            if (newStatus === "healthy" &&
+                ["degraded", "stale", "lost"].includes(previousStatus)) {
+                this.emit("health:restored", { previousStatus });
+            }
+        }
+    }
+    /**
+     * Check for account changes
+     */
+    checkAccountChanges(accounts) {
+        // Compare account IDs
+        const prevIds = new Set(this.lastAccounts.map((a) => a.accountId));
+        const currIds = new Set(accounts.map((a) => a.accountId));
+        const hasChanges = prevIds.size !== currIds.size ||
+            [...prevIds].some((id) => !currIds.has(id));
+        if (hasChanges) {
+            this.emit("accounts:changed", {
+                previous: this.lastAccounts,
+                current: accounts,
+            });
+        }
+        this.lastAccounts = accounts;
+        this.emit("accounts:synced", { accounts });
+    }
+    /**
+     * Sync account list
+     */
+    async syncAccountList() {
+        try {
+            const result = await this.performCheck();
+            if (result.accounts) {
+                this.checkAccountChanges(result.accounts);
+            }
+        }
+        catch (e) {
+            // Silently fail sync
+        }
+    }
+    /**
+     * Event listener
+     */
+    on(event, callback) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(callback);
+        return () => {
+            this.listeners.get(event)?.delete(callback);
+        };
+    }
+    /**
+     * Emit event
+     */
+    emit(event, payload) {
+        const listeners = this.listeners.get(event);
+        if (listeners) {
+            for (const listener of listeners) {
+                try {
+                    listener(payload);
+                }
+                catch (e) {
+                    console.error(`Error in health event listener for ${event}:`, e);
+                }
+            }
+        }
+    }
+    /**
+     * Promise with timeout wrapper
+     */
+    async withTimeout(promise, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error(`Health check timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            promise
+                .then((result) => {
+                clearTimeout(timeoutId);
+                resolve(result);
+            })
+                .catch((error) => {
+                clearTimeout(timeoutId);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Force a status update
+     */
+    forceStatusUpdate() {
+        this.updateStatus();
+    }
+    /**
+     * Reset health state
+     */
+    reset() {
+        this.health = this.createInitialHealth();
+        this.latencyHistory = [];
+        this.lastAccounts = [];
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+        // Restart if running and interval changed
+        if (this.running) {
+            this.stop();
+            this.start();
+        }
+    }
+    /**
+     * Get average latency
+     */
+    getAverageLatency() {
+        if (this.latencyHistory.length === 0)
+            return 0;
+        const sum = this.latencyHistory.reduce((a, b) => a + b, 0);
+        return Math.round(sum / this.latencyHistory.length);
+    }
+    /**
+     * Get latency percentile
+     */
+    getLatencyPercentile(percentile) {
+        if (this.latencyHistory.length === 0)
+            return 0;
+        const sorted = [...this.latencyHistory].sort((a, b) => a - b);
+        const index = Math.ceil((percentile / 100) * sorted.length) - 1;
+        return sorted[Math.max(0, index)];
+    }
+    /**
+     * Get uptime percentage since last reset
+     */
+    getUptimePercentage() {
+        // This is a simplified calculation
+        // In production, you'd track actual check results
+        const maxFailures = this.config.maxConsecutiveFailures;
+        const failureRate = this.health.consecutiveFailures / maxFailures;
+        return Math.max(0, (1 - failureRate) * 100);
+    }
+    /**
+     * Cleanup
+     */
+    destroy() {
+        this.stop();
+        this.listeners.clear();
+    }
+}
+exports.HealthMonitor = HealthMonitor;
+/**
+ * Create a basic health check function for NEAR wallets
+ */
+function createWalletHealthCheck(getAccounts) {
+    return async () => {
+        const startTime = Date.now();
+        try {
+            const accounts = await getAccounts();
+            const latency = Date.now() - startTime;
+            return {
+                success: true,
+                latency,
+                accounts,
+                timestamp: Date.now(),
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                latency: Date.now() - startTime,
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: Date.now(),
+            };
+        }
+    };
+}
+/**
+ * Create a health monitor with standard configuration
+ */
+function createHealthMonitor(healthCheck, config) {
+    return new HealthMonitor(healthCheck, config);
+}
+//# sourceMappingURL=health.js.map