@reclaimprotocol/attestor-core 4.0.2 → 4.0.3

package/lib/utils/atomic-operations.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Atomic operations utility for preventing race conditions.
+ * Provides mutex-like locks using Promise-based mutual exclusion.
+ */
+export declare class AtomicOperations {
+    private static locks;
+    /**
+     * Execute a function with a named lock to prevent concurrent execution.
+     * @param lockName Unique identifier for the lock
+     * @param fn Function to execute atomically
+     * @returns Promise that resolves with the function's return value
+     */
+    static withLock<T>(lockName: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Check if a lock is currently held.
+     * @param lockName Name of the lock to check
+     * @returns True if the lock is currently held
+     */
+    static isLocked(lockName: string): boolean;
+    /**
+     * Clear all locks (for testing/cleanup).
+     */
+    static clearAllLocks(): void;
+}

package/lib/utils/atomic-operations.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Atomic operations utility for preventing race conditions.
+ * Provides mutex-like locks using Promise-based mutual exclusion.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtomicOperations = void 0;
+class AtomicOperations {
+    /**
+     * Execute a function with a named lock to prevent concurrent execution.
+     * @param lockName Unique identifier for the lock
+     * @param fn Function to execute atomically
+     * @returns Promise that resolves with the function's return value
+     */
+    static async withLock(lockName, fn) {
+        // Wait for any existing lock to complete
+        const existingLock = this.locks.get(lockName);
+        if (existingLock) {
+            await existingLock.catch(() => {
+                // Ignore errors from previous lock holders
+            });
+        }
+        // Create a new lock
+        let resolve;
+        let reject;
+        const lockPromise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        this.locks.set(lockName, lockPromise);
+        try {
+            // Execute the function
+            const result = await fn();
+            resolve();
+            return result;
+        }
+        catch (error) {
+            reject(error);
+            throw error;
+        }
+        finally {
+            // Clean up the lock if we're still the current holder
+            if (this.locks.get(lockName) === lockPromise) {
+                this.locks.delete(lockName);
+            }
+        }
+    }
+    /**
+     * Check if a lock is currently held.
+     * @param lockName Name of the lock to check
+     * @returns True if the lock is currently held
+     */
+    static isLocked(lockName) {
+        return this.locks.has(lockName);
+    }
+    /**
+     * Clear all locks (for testing/cleanup).
+     */
+    static clearAllLocks() {
+        this.locks.clear();
+    }
+}
+exports.AtomicOperations = AtomicOperations;
+AtomicOperations.locks = new Map();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXRvbWljLW9wZXJhdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvYXRvbWljLW9wZXJhdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7R0FHRzs7O0FBRUgsTUFBYSxnQkFBZ0I7SUFHNUI7Ozs7O09BS0c7SUFDSCxNQUFNLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBSSxRQUFnQixFQUFFLEVBQW9CO1FBQzlELHlDQUF5QztRQUN6QyxNQUFNLFlBQVksR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsQ0FBQTtRQUM3QyxJQUFJLFlBQVksRUFBRSxDQUFDO1lBQ2xCLE1BQU0sWUFBWSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUU7Z0JBQzdCLDJDQUEyQztZQUM1QyxDQUFDLENBQUMsQ0FBQTtRQUNILENBQUM7UUFFRCxvQkFBb0I7UUFDcEIsSUFBSSxPQUFtQixDQUFBO1FBQ3ZCLElBQUksTUFBNEIsQ0FBQTtRQUNoQyxNQUFNLFdBQVcsR0FBRyxJQUFJLE9BQU8sQ0FBTyxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsRUFBRTtZQUNsRCxPQUFPLEdBQUcsR0FBRyxDQUFBO1lBQ2IsTUFBTSxHQUFHLEdBQUcsQ0FBQTtRQUNiLENBQUMsQ0FBQyxDQUFBO1FBRUYsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsUUFBUSxFQUFFLFdBQVcsQ0FBQyxDQUFBO1FBRXJDLElBQUksQ0FBQztZQUNKLHVCQUF1QjtZQUN2QixNQUFNLE1BQU0sR0FBRyxNQUFNLEVBQUUsRUFBRSxDQUFBO1lBQ3pCLE9BQVEsRUFBRSxDQUFBO1lBQ1YsT0FBTyxNQUFNLENBQUE7UUFDZCxDQUFDO1FBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztZQUNoQixNQUFPLENBQUMsS0FBSyxDQUFDLENBQUE7WUFDZCxNQUFNLEtBQUssQ0FBQTtRQUNaLENBQUM7Z0JBQVMsQ0FBQztZQUNWLHNEQUFzRDtZQUN0RCxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxLQUFLLFdBQVcsRUFBRSxDQUFDO2dCQUM5QyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQTtZQUM1QixDQUFDO1FBQ0YsQ0FBQztJQUNGLENBQUM7SUFFRDs7OztPQUlHO0lBQ0gsTUFBTSxDQUFDLFFBQVEsQ0FBQyxRQUFnQjtRQUMvQixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFBO0lBQ2hDLENBQUM7SUFFRDs7T0FFRztJQUNILE1BQU0sQ0FBQyxhQUFhO1FBQ25CLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxFQUFFLENBQUE7SUFDbkIsQ0FBQzs7QUExREYsNENBMkRDO0FBMURlLHNCQUFLLEdBQUcsSUFBSSxHQUFHLEVBQXlCLENBQUEifQ==

package/lib/utils/connection-state-machine.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Connection state machine for managing atomic state transitions.
+ * Prevents race conditions in connection state management.
+ */
+export declare enum ConnectionState {
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    CLOSING = "closing",
+    CLOSED = "closed"
+}
+type StateChangeListener = (oldState: ConnectionState, newState: ConnectionState) => void;
+export declare class ConnectionStateMachine {
+    private currentState;
+    private listeners;
+    private transitionLock;
+    constructor(initialState?: ConnectionState);
+    /**
+     * Get current state.
+     */
+    getState(): ConnectionState;
+    /**
+     * Check if the connection is in any of the specified states.
+     */
+    isInState(...states: ConnectionState[]): boolean;
+    /**
+     * Register a state change listener.
+     */
+    onStateChange(listener: StateChangeListener): () => void;
+    /**
+     * Attempt to transition from allowed states to a new state.
+     * @param fromStates Allowed states to transition from
+     * @param toState Target state
+     * @param action Optional action to execute during transition
+     * @returns Promise that resolves to true if transition succeeded
+     */
+    transition(fromStates: ConnectionState | ConnectionState[], toState: ConnectionState, action?: () => Promise<void>): Promise<boolean>;
+    /**
+     * Force a state change without checking allowed transitions.
+     * Use with caution - mainly for error recovery.
+     */
+    forceState(newState: ConnectionState): Promise<void>;
+}
+export {};

package/lib/utils/connection-state-machine.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * Connection state machine for managing atomic state transitions.
+ * Prevents race conditions in connection state management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionStateMachine = exports.ConnectionState = void 0;
+var ConnectionState;
+(function (ConnectionState) {
+    ConnectionState["CONNECTING"] = "connecting";
+    ConnectionState["CONNECTED"] = "connected";
+    ConnectionState["CLOSING"] = "closing";
+    ConnectionState["CLOSED"] = "closed";
+})(ConnectionState || (exports.ConnectionState = ConnectionState = {}));
+class ConnectionStateMachine {
+    constructor(initialState = ConnectionState.CONNECTING) {
+        this.listeners = [];
+        this.transitionLock = null;
+        this.currentState = initialState;
+    }
+    /**
+     * Get current state.
+     */
+    getState() {
+        return this.currentState;
+    }
+    /**
+     * Check if the connection is in any of the specified states.
+     */
+    isInState(...states) {
+        return states.includes(this.currentState);
+    }
+    /**
+     * Register a state change listener.
+     */
+    onStateChange(listener) {
+        this.listeners.push(listener);
+        return () => {
+            const index = this.listeners.indexOf(listener);
+            if (index >= 0) {
+                this.listeners.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * Attempt to transition from allowed states to a new state.
+     * @param fromStates Allowed states to transition from
+     * @param toState Target state
+     * @param action Optional action to execute during transition
+     * @returns Promise that resolves to true if transition succeeded
+     */
+    async transition(fromStates, toState, action) {
+        // Wait for any existing transition to complete
+        if (this.transitionLock) {
+            await this.transitionLock.catch(() => {
+                // Ignore errors from previous transitions
+            });
+        }
+        // Create a new transition lock
+        let resolve;
+        let reject;
+        this.transitionLock = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        try {
+            const allowedStates = Array.isArray(fromStates) ? fromStates : [fromStates];
+            // Check if transition is allowed
+            if (!allowedStates.includes(this.currentState)) {
+                resolve();
+                return false;
+            }
+            // If already in target state, no need to transition
+            if (this.currentState === toState) {
+                resolve();
+                return true;
+            }
+            const oldState = this.currentState;
+            // Execute action if provided
+            if (action) {
+                await action();
+            }
+            // Update state
+            this.currentState = toState;
+            // Notify listeners
+            for (const listener of this.listeners) {
+                try {
+                    listener(oldState, toState);
+                }
+                catch (error) {
+                    // Don't let listener errors break the state machine
+                    console.error('Error in state change listener:', error);
+                }
+            }
+            resolve();
+            return true;
+        }
+        catch (error) {
+            reject(error);
+            throw error;
+        }
+        finally {
+            // Clear the transition lock
+            this.transitionLock = null;
+        }
+    }
+    /**
+     * Force a state change without checking allowed transitions.
+     * Use with caution - mainly for error recovery.
+     */
+    async forceState(newState) {
+        if (this.transitionLock) {
+            await this.transitionLock.catch(() => { });
+        }
+        const oldState = this.currentState;
+        this.currentState = newState;
+        // Notify listeners
+        for (const listener of this.listeners) {
+            try {
+                listener(oldState, newState);
+            }
+            catch (error) {
+                console.error('Error in state change listener:', error);
+            }
+        }
+    }
+}
+exports.ConnectionStateMachine = ConnectionStateMachine;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/resource-monitor.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Resource monitor for tracking resources and preventing leaks.
+ * Provides debugging capabilities and resource management.
+ */
+import type { Logger } from '../types';
+export interface ResourceInfo {
+    id: string;
+    type: string;
+    createdAt: Date;
+    metadata?: any;
+}
+export declare class ResourceMonitor {
+    private static instance;
+    private resources;
+    private logger;
+    private constructor();
+    /**
+     * Get or create the singleton ResourceMonitor instance.
+     */
+    static getInstance(logger: Logger): ResourceMonitor;
+    /**
+     * Track a new resource.
+     */
+    trackResource(id: string, type: string, metadata?: any): void;
+    /**
+     * Untrack a resource.
+     */
+    untrackResource(id: string): boolean;
+    /**
+     * Check if a resource is tracked.
+     */
+    isTracked(id: string): boolean;
+    /**
+     * Get information about a specific resource.
+     */
+    getResource(id: string): ResourceInfo | undefined;
+    /**
+     * Get all tracked resources.
+     */
+    getAllResources(): ResourceInfo[];
+    /**
+     * Get resources by type.
+     */
+    getResourcesByType(type: string): ResourceInfo[];
+    /**
+     * Get resources older than a specific age.
+     */
+    getResourcesOlderThan(ageMs: number): ResourceInfo[];
+    /**
+     * Log resource statistics.
+     */
+    logStats(): void;
+    /**
+     * Clear all tracked resources (for testing/cleanup).
+     */
+    clear(): void;
+    /**
+     * Reset the singleton instance (for testing).
+     */
+    static reset(): void;
+}

package/lib/utils/resource-monitor.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Resource monitor for tracking resources and preventing leaks.
+ * Provides debugging capabilities and resource management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceMonitor = void 0;
+class ResourceMonitor {
+    constructor(logger) {
+        this.resources = new Map();
+        this.logger = logger;
+    }
+    /**
+     * Get or create the singleton ResourceMonitor instance.
+     */
+    static getInstance(logger) {
+        if (!ResourceMonitor.instance) {
+            ResourceMonitor.instance = new ResourceMonitor(logger);
+        }
+        return ResourceMonitor.instance;
+    }
+    /**
+     * Track a new resource.
+     */
+    trackResource(id, type, metadata) {
+        const resource = {
+            id,
+            type,
+            createdAt: new Date(),
+            metadata
+        };
+        this.resources.set(id, resource);
+        this.logger.trace({ id, type, metadata }, 'Resource tracked');
+    }
+    /**
+     * Untrack a resource.
+     */
+    untrackResource(id) {
+        const resource = this.resources.get(id);
+        if (resource) {
+            this.resources.delete(id);
+            this.logger.trace({ id, type: resource.type }, 'Resource untracked');
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check if a resource is tracked.
+     */
+    isTracked(id) {
+        return this.resources.has(id);
+    }
+    /**
+     * Get information about a specific resource.
+     */
+    getResource(id) {
+        return this.resources.get(id);
+    }
+    /**
+     * Get all tracked resources.
+     */
+    getAllResources() {
+        return Array.from(this.resources.values());
+    }
+    /**
+     * Get resources by type.
+     */
+    getResourcesByType(type) {
+        return Array.from(this.resources.values()).filter(r => r.type === type);
+    }
+    /**
+     * Get resources older than a specific age.
+     */
+    getResourcesOlderThan(ageMs) {
+        const cutoff = new Date(Date.now() - ageMs);
+        return Array.from(this.resources.values()).filter(r => r.createdAt < cutoff);
+    }
+    /**
+     * Log resource statistics.
+     */
+    logStats() {
+        const byType = new Map();
+        for (const resource of this.resources.values()) {
+            byType.set(resource.type, (byType.get(resource.type) || 0) + 1);
+        }
+        const stats = Object.fromEntries(byType);
+        this.logger.info({
+            totalResources: this.resources.size,
+            byType: stats
+        }, 'Resource statistics');
+    }
+    /**
+     * Clear all tracked resources (for testing/cleanup).
+     */
+    clear() {
+        this.resources.clear();
+    }
+    /**
+     * Reset the singleton instance (for testing).
+     */
+    static reset() {
+        ResourceMonitor.instance = null;
+    }
+}
+exports.ResourceMonitor = ResourceMonitor;
+ResourceMonitor.instance = null;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reclaimprotocol/attestor-core",
-  "version": "4.0.2",
+  "version": "4.0.3",
   "description": "",
   "main": "lib/index",
   "scripts": {