@eztra.services/engine 1.0.0-dev.20260202084348 → 1.0.0-dev.20260202093252

package/dist/index.js

@@ -240,15 +240,1380 @@ var ComposableController = class {
   }
 };
 
+// ../controller/dist/index.js
+var BaseController = class {
+  /**
+   * Controller version for state migrations
+   * Increment this when making breaking changes to state structure
+   */
+  static VERSION = 1;
+  /**
+   * Internal state storage
+   */
+  internalState;
+  /**
+   * Controller messenger for inter-controller communication
+   */
+  messenger;
+  /**
+   * State metadata (persistence, access control, validation)
+   * @deprecated Use StatePropertyMetadata instead
+   */
+  metadata;
+  /**
+   * Enhanced metadata with validators and migrators
+   * Override this in subclasses to define persistence rules
+   */
+  propertyMetadata = {};
+  /**
+   * Optional persistence service for state save/restore
+   */
+  persistenceService;
+  /**
+   * Create a new controller instance
+   *
+   * @param config - Controller configuration
+   * @param defaultState - Default state (provided by subclass)
+   */
+  constructor(config, defaultState) {
+    this.messenger = config.messenger;
+    this.metadata = config.metadata || {};
+    this.persistenceService = config.persistenceService;
+    this.internalState = { ...defaultState, ...config.state };
+  }
+  /**
+   * Get current state (returns a copy to prevent direct mutation)
+   */
+  get state() {
+    return { ...this.internalState };
+  }
+  /**
+   * Update controller state
+   * 
+   * @param stateUpdate - Partial state update or updater function
+   */
+  update(stateUpdate) {
+    const prevState = this.internalState;
+    if (typeof stateUpdate === "function") {
+      const draft = { ...this.internalState };
+      const result = stateUpdate(draft);
+      this.internalState = result ? { ...draft, ...result } : draft;
+    } else {
+      this.internalState = { ...this.internalState, ...stateUpdate };
+    }
+    const event = {
+      prevState,
+      newState: this.internalState
+    };
+    this.messenger.publish(`${this.name}:stateChange`, event);
+  }
+  /**
+   * Destroy controller (cleanup)
+   * Override this to clean up subscriptions, timers, etc.
+   */
+  destroy() {
+  }
+  /**
+   * Get metadata for a state property
+   */
+  getMetadata(key) {
+    return this.metadata[key];
+  }
+  /**
+   * Check if a state property should be persisted
+   */
+  shouldPersist(key) {
+    return this.getMetadata(key)?.persist ?? false;
+  }
+  /**
+   * Get persistable state (only properties with persist: true)
+   */
+  getPersistableState() {
+    const persistable = {};
+    for (const key in this.internalState) {
+      if (this.shouldPersist(key)) {
+        persistable[key] = this.internalState[key];
+      }
+    }
+    return persistable;
+  }
+  /**
+   * Get anonymous state (only properties with anonymous: true)
+   * Useful for public data that can be accessed without authentication
+   */
+  getAnonymousState() {
+    const anonymous = {};
+    const metadata = this.propertyMetadata || this.metadata;
+    for (const key in this.internalState) {
+      const meta = metadata[key];
+      if (meta?.anonymous === true) {
+        anonymous[key] = this.internalState[key];
+      }
+    }
+    return anonymous;
+  }
+  /**
+   * Get persistent state (only persisted properties)
+   * Uses propertyMetadata if available, falls back to legacy metadata
+   */
+  getPersistentState() {
+    const persistent = {};
+    const metadata = this.propertyMetadata || this.metadata;
+    for (const key in this.internalState) {
+      const meta = metadata[key];
+      if (meta?.persist === true) {
+        persistent[key] = this.internalState[key];
+      }
+    }
+    return persistent;
+  }
+  /**
+   * Validate state using metadata validators
+   * Override this method to add custom validation logic
+   *
+   * @param state - State to validate
+   * @returns Validated state or throws error
+   */
+  async validateState(state) {
+    const validatedState = { ...this.internalState, ...state };
+    const metadata = this.propertyMetadata;
+    for (const key in metadata) {
+      const meta = metadata[key];
+      if (meta?.validator && key in validatedState) {
+        const value = validatedState[key];
+        const isValid = meta.validator(value);
+        if (!isValid) {
+          throw new Error(
+            `Validation failed for property "${String(key)}" in controller "${this.name}"`
+          );
+        }
+      }
+      if (meta?.required && !(key in validatedState)) {
+        throw new Error(
+          `Required property "${String(key)}" is missing in controller "${this.name}"`
+        );
+      }
+    }
+    return validatedState;
+  }
+  /**
+   * Migrate state from an old version to the current version
+   * Override this method to handle version-specific migrations
+   *
+   * @param oldState - State from previous version
+   * @param fromVersion - Version number of old state
+   * @returns Migrated state
+   */
+  async migrateState(oldState, fromVersion) {
+    let migratedState = { ...oldState };
+    const metadata = this.propertyMetadata;
+    for (const key in metadata) {
+      const meta = metadata[key];
+      if (meta?.migrator && key in migratedState) {
+        migratedState[key] = meta.migrator(migratedState[key], fromVersion);
+      }
+    }
+    return this.validateState(migratedState);
+  }
+  /**
+   * Restore state from persisted data
+   * Handles validation and migration automatically
+   *
+   * @param persistedState - Persisted state data
+   * @param version - Version of persisted state
+   * @returns Restored and validated state
+   */
+  async restoreState(persistedState, version) {
+    const currentVersion = this.constructor.VERSION;
+    let stateToRestore = persistedState;
+    if (version !== void 0 && version < currentVersion) {
+      stateToRestore = await this.migrateState(persistedState, version);
+    }
+    const validatedState = await this.validateState(stateToRestore);
+    const prevState = this.internalState;
+    this.internalState = validatedState;
+    this.messenger.publish(`${this.name}:stateChange`, {
+      prevState,
+      newState: validatedState
+    });
+    return validatedState;
+  }
+  /**
+   * Check if state should be migrated
+   */
+  needsMigration(persistedVersion) {
+    const currentVersion = this.constructor.VERSION;
+    return persistedVersion !== void 0 && persistedVersion < currentVersion;
+  }
+  /**
+   * Get controller version
+   */
+  getVersion() {
+    return this.constructor.VERSION;
+  }
+  /**
+   * Persist current state to storage (if persistence service is available)
+   *
+   * @returns True if persisted successfully, false otherwise
+   */
+  async persist() {
+    if (!this.persistenceService) {
+      return false;
+    }
+    try {
+      const metadata = this.propertyMetadata || this.metadata;
+      const version = this.getVersion();
+      await this.persistenceService.persistController(
+        this.name,
+        this.internalState,
+        metadata,
+        version
+      );
+      return true;
+    } catch (error) {
+      console.error(`[${this.name}] Failed to persist state:`, error);
+      return false;
+    }
+  }
+  /**
+   * Load persisted state from storage (if persistence service is available)
+   *
+   * @returns True if loaded successfully, false otherwise
+   */
+  async loadPersistedState() {
+    if (!this.persistenceService) {
+      return false;
+    }
+    try {
+      const metadata = this.propertyMetadata || this.metadata;
+      const currentVersion = this.getVersion();
+      const persistedState = await this.persistenceService.restoreController(
+        this.name,
+        metadata,
+        currentVersion
+      );
+      if (persistedState) {
+        const persistedVersion = this.persistenceService.getPersistedVersion?.(this.name) ?? currentVersion;
+        await this.restoreState(persistedState, persistedVersion);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error(`[${this.name}] Failed to load persisted state:`, error);
+      return false;
+    }
+  }
+};
+var ControllerMessenger = class {
+  /**
+   * Registered action handlers
+   * Map: action name -> handler function
+   */
+  actionHandlers = /* @__PURE__ */ new Map();
+  /**
+   * Event subscriptions
+   * Map: event name -> Set of listener functions
+   */
+  eventSubscriptions = /* @__PURE__ */ new Map();
+  /**
+   * Register an action handler
+   *
+   * @param action - Action name (must be unique)
+   * @param handler - Handler function
+   * @throws Error if action is already registered
+   *
+   * @example
+   * ```typescript
+   * messenger.registerActionHandler(
+   *   'WalletController:createWallet',
+   *   async (mnemonic: string) => {
+   *     // Create wallet logic
+   *     return { id: '123', address: '0xabc...' };
+   *   }
+   * );
+   * ```
+   */
+  registerActionHandler(action, handler) {
+    if (this.actionHandlers.has(action)) {
+      throw new Error(
+        `Action handler for "${String(action)}" is already registered`
+      );
+    }
+    this.actionHandlers.set(action, handler);
+  }
+  /**
+   * Unregister an action handler
+   *
+   * @param action - Action name to unregister
+   *
+   * @example
+   * ```typescript
+   * messenger.unregisterActionHandler('WalletController:createWallet');
+   * ```
+   */
+  unregisterActionHandler(action) {
+    this.actionHandlers.delete(action);
+  }
+  /**
+   * Call an action (RPC-style)
+   *
+   * @param action - Action name to call
+   * @param params - Action parameters
+   * @returns Action result (typed based on action definition)
+   * @throws Error if action is not registered
+   *
+   * @example
+   * ```typescript
+   * // Synchronous action
+   * const wallet = messenger.call('WalletController:getActiveWallet');
+   *
+   * // Asynchronous action
+   * const balance = await messenger.call(
+   *   'WalletController:getBalance',
+   *   '0x123...'
+   * );
+   * ```
+   */
+  call(action, ...params) {
+    const handler = this.actionHandlers.get(action);
+    if (!handler) {
+      throw new Error(
+        `Action handler for "${String(action)}" is not registered`
+      );
+    }
+    try {
+      return handler(...params);
+    } catch (error) {
+      console.error(`Error executing action "${String(action)}":`, error);
+      throw error;
+    }
+  }
+  /**
+   * Subscribe to an event
+   *
+   * @param event - Event name to subscribe to
+   * @param listener - Listener function
+   * @returns Unsubscribe function
+   *
+   * @example
+   * ```typescript
+   * const unsubscribe = messenger.subscribe(
+   *   'WalletController:balanceUpdated',
+   *   (payload) => {
+   *     console.log(`New balance: ${payload.balance}`);
+   *   }
+   * );
+   *
+   * // Later, unsubscribe
+   * unsubscribe();
+   * ```
+   */
+  subscribe(event, listener) {
+    if (!this.eventSubscriptions.has(event)) {
+      this.eventSubscriptions.set(event, /* @__PURE__ */ new Set());
+    }
+    const listeners = this.eventSubscriptions.get(event);
+    listeners.add(listener);
+    return () => {
+      this.unsubscribe(event, listener);
+    };
+  }
+  /**
+   * Unsubscribe from an event
+   *
+   * @param event - Event name
+   * @param listener - Listener function to remove
+   *
+   * @example
+   * ```typescript
+   * const listener = (payload) => console.log(payload);
+   * messenger.subscribe('WalletController:balanceUpdated', listener);
+   *
+   * // Later...
+   * messenger.unsubscribe('WalletController:balanceUpdated', listener);
+   * ```
+   */
+  unsubscribe(event, listener) {
+    const listeners = this.eventSubscriptions.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        this.eventSubscriptions.delete(event);
+      }
+    }
+  }
+  /**
+   * Publish an event (pub/sub)
+   *
+   * All subscribed listeners are called asynchronously.
+   * Errors in listeners are caught and logged to prevent one listener from affecting others.
+   *
+   * @param event - Event name to publish
+   * @param payload - Event payload
+   *
+   * @example
+   * ```typescript
+   * messenger.publish('WalletController:balanceUpdated', {
+   *   address: '0x123...',
+   *   balance: '1000000000000000000'
+   * });
+   * ```
+   */
+  publish(event, payload) {
+    const listeners = this.eventSubscriptions.get(event);
+    if (listeners && listeners.size > 0) {
+      Promise.resolve().then(() => {
+        listeners.forEach((listener) => {
+          try {
+            listener(payload);
+          } catch (error) {
+            console.error(
+              `Error in event listener for "${String(event)}":`,
+              error
+            );
+          }
+        });
+      });
+    }
+  }
+  /**
+   * Clear all subscriptions for an event
+   *
+   * @param event - Event name
+   *
+   * @example
+   * ```typescript
+   * messenger.clearEventSubscriptions('WalletController:balanceUpdated');
+   * ```
+   */
+  clearEventSubscriptions(event) {
+    this.eventSubscriptions.delete(event);
+  }
+  /**
+   * Get a restricted messenger for a controller
+   *
+   * Restricted messengers enforce the principle of least privilege:
+   * - Controllers can only call actions they're explicitly allowed to call
+   * - Controllers can only subscribe to events they're explicitly allowed to subscribe to
+   * - Controllers can only publish events in their own namespace
+   * - Controllers can only register actions in their own namespace
+   *
+   * @param options - Restriction configuration
+   * @returns Restricted messenger instance
+   *
+   * @example
+   * ```typescript
+   * const walletMessenger = messenger.getRestricted({
+   *   name: 'WalletController',
+   *   allowedActions: ['WalletController:createWallet', 'WalletController:getBalance'],
+   *   allowedEvents: ['WalletController:balanceUpdated'],
+   *   externalActions: ['NetworkController:getActiveNetwork'],
+   *   externalEvents: ['NetworkController:networkChanged']
+   * });
+   *
+   * // WalletController can now:
+   * // - Register WalletController actions
+   * // - Call WalletController and NetworkController actions
+   * // - Publish WalletController events
+   * // - Subscribe to WalletController and NetworkController events
+   * ```
+   */
+  getRestricted(options) {
+    const {
+      name,
+      allowedActions = [],
+      allowedEvents = [],
+      externalActions = [],
+      externalEvents = []
+    } = options;
+    const allAllowedActions = /* @__PURE__ */ new Set([
+      ...allowedActions,
+      ...externalActions
+    ]);
+    const allAllowedEvents = /* @__PURE__ */ new Set([
+      ...allowedEvents,
+      ...externalEvents
+    ]);
+    return {
+      call: ((action, ...params) => {
+        if (!allAllowedActions.has(action)) {
+          throw new Error(
+            `Controller "${name}" is not allowed to call action "${action}"`
+          );
+        }
+        return this.call(action, ...params);
+      }),
+      registerActionHandler: ((action, handler) => {
+        const actionNamespace = String(action).split(":")[0];
+        if (actionNamespace !== name) {
+          throw new Error(
+            `Controller "${name}" can only register actions in its own namespace (${name}:*), attempted to register "${action}"`
+          );
+        }
+        if (!allowedActions.includes(action)) {
+          throw new Error(
+            `Controller "${name}" is not allowed to register action "${action}"`
+          );
+        }
+        return this.registerActionHandler(action, handler);
+      }),
+      unregisterActionHandler: ((action) => {
+        const actionNamespace = String(action).split(":")[0];
+        if (actionNamespace !== name) {
+          throw new Error(
+            `Controller "${name}" can only unregister actions in its own namespace`
+          );
+        }
+        return this.unregisterActionHandler(action);
+      }),
+      publish: ((event, payload) => {
+        const eventNamespace = String(event).split(":")[0];
+        if (eventNamespace !== name) {
+          throw new Error(
+            `Controller "${name}" can only publish events in its own namespace (${name}:*), attempted to publish "${event}"`
+          );
+        }
+        if (!allowedEvents.includes(event)) {
+          throw new Error(
+            `Controller "${name}" is not allowed to publish event "${event}"`
+          );
+        }
+        return this.publish(event, payload);
+      }),
+      subscribe: ((event, listener) => {
+        if (!allAllowedEvents.has(event)) {
+          throw new Error(
+            `Controller "${name}" is not allowed to subscribe to event "${event}"`
+          );
+        }
+        return this.subscribe(event, listener);
+      }),
+      unsubscribe: ((event, listener) => {
+        if (!allAllowedEvents.has(event)) {
+          throw new Error(
+            `Controller "${name}" is not allowed to unsubscribe from event "${event}"`
+          );
+        }
+        return this.unsubscribe(event, listener);
+      }),
+      clearEventSubscriptions: ((event) => {
+        if (!allAllowedEvents.has(event)) {
+          throw new Error(
+            `Controller "${name}" is not allowed to clear event subscriptions for "${event}"`
+          );
+        }
+        return this.clearEventSubscriptions(event);
+      })
+    };
+  }
+  /**
+   * Get all registered action names
+   * Useful for debugging and inspection
+   */
+  getRegisteredActions() {
+    return Array.from(this.actionHandlers.keys()).map(String);
+  }
+  /**
+   * Get all events that have active subscriptions
+   * Useful for debugging and inspection
+   */
+  getActiveEvents() {
+    return Array.from(this.eventSubscriptions.keys()).map(String);
+  }
+  /**
+   * Get subscriber count for an event
+   * Useful for debugging
+   */
+  getSubscriberCount(event) {
+    return this.eventSubscriptions.get(event)?.size ?? 0;
+  }
+  /**
+   * Clear all action handlers and event subscriptions
+   * Useful for cleanup and testing
+   */
+  clear() {
+    this.actionHandlers.clear();
+    this.eventSubscriptions.clear();
+  }
+};
+
+// ../infrastructure/storage/dist/index.js
+var StatePersistenceService = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  /**
+   * Persist controller state to storage
+   *
+   * Only properties with `persist: true` in metadata are saved.
+   *
+   * @param controllerName - Unique identifier for the controller
+   * @param state - Full controller state
+   * @param metadata - State property metadata (defines what to persist)
+   * @param version - State version number
+   */
+  async persistController(controllerName, state, metadata, version) {
+    try {
+      const persistableState = this.extractPersistableState(state, metadata);
+      const wrapper = {
+        data: persistableState,
+        version,
+        timestamp: Date.now()
+      };
+      const serialized = JSON.stringify(wrapper);
+      const key = this.getStorageKey(controllerName);
+      this.storage.set(key, serialized);
+    } catch (error) {
+      console.error(
+        `[StatePersistenceService] Failed to persist state for ${controllerName}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Restore controller state from storage
+   *
+   * Handles version mismatches and runs migrations if needed.
+   *
+   * @param controllerName - Unique identifier for the controller
+   * @param metadata - State property metadata (for migration)
+   * @param currentVersion - Current version of the controller
+   * @returns Restored state or null if not found
+   */
+  async restoreController(controllerName, metadata, currentVersion) {
+    try {
+      const key = this.getStorageKey(controllerName);
+      const serialized = this.storage.getString(key);
+      if (!serialized) {
+        console.log(
+          `[StatePersistenceService] No persisted state found for ${controllerName}`
+        );
+        return null;
+      }
+      const wrapper = JSON.parse(serialized);
+      if (wrapper.version < currentVersion) {
+        console.log(
+          `[StatePersistenceService] Migrating ${controllerName} state from v${wrapper.version} to v${currentVersion}`
+        );
+        return this.migrateState(wrapper.data, wrapper.version, currentVersion, metadata);
+      }
+      return wrapper.data;
+    } catch (error) {
+      console.error(
+        `[StatePersistenceService] Failed to restore state for ${controllerName}:`,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Delete persisted state for a controller
+   *
+   * @param controllerName - Unique identifier for the controller
+   */
+  async deleteController(controllerName) {
+    const key = this.getStorageKey(controllerName);
+    this.storage.delete(key);
+  }
+  /**
+   * Check if persisted state exists for a controller
+   *
+   * @param controllerName - Unique identifier for the controller
+   * @returns True if state exists
+   */
+  hasPersistedState(controllerName) {
+    const key = this.getStorageKey(controllerName);
+    return this.storage.contains(key);
+  }
+  /**
+   * Get the version of persisted state
+   *
+   * @param controllerName - Unique identifier for the controller
+   * @returns Version number or null if not found
+   */
+  getPersistedVersion(controllerName) {
+    try {
+      const key = this.getStorageKey(controllerName);
+      const serialized = this.storage.getString(key);
+      if (!serialized) {
+        return null;
+      }
+      const wrapper = JSON.parse(serialized);
+      return wrapper.version;
+    } catch (error) {
+      console.error(
+        `[StatePersistenceService] Failed to get version for ${controllerName}:`,
+        error
+      );
+      return null;
+    }
+  }
+  /**
+   * Clear all persisted controller states
+   */
+  async clearAll() {
+    const prefix = "controller:";
+    const allKeys = this.storage.getAllKeys();
+    const controllerKeys = allKeys.filter((key) => key.startsWith(prefix));
+    for (const key of controllerKeys) {
+      this.storage.delete(key);
+    }
+  }
+  /**
+   * Extract persistable state based on metadata
+   *
+   * @private
+   */
+  extractPersistableState(state, metadata) {
+    const persistable = {};
+    for (const key in metadata) {
+      const meta = metadata[key];
+      if (meta?.persist === true && key in state) {
+        persistable[key] = state[key];
+      }
+    }
+    return persistable;
+  }
+  /**
+   * Migrate state from old version to new version
+   *
+   * @private
+   */
+  migrateState(oldState, fromVersion, _toVersion, metadata) {
+    let migratedState = { ...oldState };
+    for (const key in metadata) {
+      const meta = metadata[key];
+      if (meta?.migrator && key in migratedState) {
+        try {
+          const oldValue = migratedState[key];
+          const newValue = meta.migrator(oldValue, fromVersion);
+          migratedState[key] = newValue;
+        } catch (error) {
+          console.error(
+            `[StatePersistenceService] Migration failed for property ${String(key)}:`,
+            error
+          );
+        }
+      }
+    }
+    return migratedState;
+  }
+  /**
+   * Get storage key for a controller
+   *
+   * @private
+   */
+  getStorageKey(controllerName) {
+    return `controller:${controllerName}`;
+  }
+};
+
+// ../networkController/dist/index.js
+var GET_ALL_RPC_ENDPOINTS_QUERY = `
+  query GetAllRpcEndpoints($q: QueryGetListInput) {
+    getAllRpcEndpoints(q: $q) {
+      data {
+        id
+        createdAt
+        updatedAt
+        name
+        rpcUrl
+        chainId
+        provider
+        status
+      }
+      total
+      pagination {
+        limit
+        offset
+        page
+        total
+      }
+    }
+  }
+`;
+var GET_ONE_RPC_ENDPOINT_QUERY = `
+  query GetOneRpcEndpoint($id: NonEmptyString!) {
+    getOneRpcEndpoint(id: $id) {
+      id
+      createdAt
+      updatedAt
+      name
+      rpcUrl
+      chainId
+      provider
+      status
+    }
+  }
+`;
+var RpcEndpointService = class _RpcEndpointService {
+  static apiUri = "https://dev-api.eztra.io";
+  /**
+   * Set the API URI for GraphQL requests
+   */
+  static setApiUri(uri) {
+    _RpcEndpointService.apiUri = uri;
+  }
+  /**
+   * Get the current API URI
+   */
+  static getApiUri() {
+    return _RpcEndpointService.apiUri;
+  }
+  /**
+   * Execute a GraphQL query
+   */
+  static async executeQuery(query, variables) {
+    try {
+      const response = await fetch(`${_RpcEndpointService.apiUri}/graphql`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          query,
+          variables
+        })
+      });
+      if (!response.ok) {
+        console.error("[RpcEndpointService] HTTP error:", response.status);
+        return null;
+      }
+      const result = await response.json();
+      if (result.errors && result.errors.length > 0) {
+        console.error("[RpcEndpointService] GraphQL errors:", result.errors);
+        return null;
+      }
+      return result.data ?? null;
+    } catch (error) {
+      console.error("[RpcEndpointService] Request failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Get all RPC endpoints with optional filtering
+   */
+  static async getAll(query) {
+    const result = await _RpcEndpointService.executeQuery(GET_ALL_RPC_ENDPOINTS_QUERY, { q: query });
+    return result?.getAllRpcEndpoints?.data ?? null;
+  }
+  /**
+   * Get all RPC endpoints with pagination info
+   */
+  static async getAllWithPagination(query) {
+    const result = await _RpcEndpointService.executeQuery(GET_ALL_RPC_ENDPOINTS_QUERY, { q: query });
+    return result?.getAllRpcEndpoints ?? null;
+  }
+  /**
+   * Get a single RPC endpoint by ID
+   */
+  static async getOne(id) {
+    const result = await _RpcEndpointService.executeQuery(GET_ONE_RPC_ENDPOINT_QUERY, { id });
+    return result?.getOneRpcEndpoint ?? null;
+  }
+  /**
+   * Get RPC endpoints by chain ID
+   */
+  static async getByChainId(chainId) {
+    return _RpcEndpointService.getAll({
+      filter: { chainId }
+    });
+  }
+  /**
+   * Get active RPC endpoints
+   */
+  static async getActive() {
+    return _RpcEndpointService.getAll({
+      filter: { status: "ACTIVE" }
+    });
+  }
+  /**
+   * Get active RPC endpoints by chain ID
+   */
+  static async getActiveByChainId(chainId) {
+    return _RpcEndpointService.getAll({
+      filter: { chainId, status: "ACTIVE" }
+    });
+  }
+};
+var RpcManager = class {
+  healthMap = /* @__PURE__ */ new Map();
+  healthCheckInterval = 3e4;
+  // 30 seconds
+  maxFailures = 3;
+  /**
+   * Get RPC URL for a specific wallet index (round-robin distribution)
+   * @param chainId - Chain ID to get RPC for
+   * @param endpoints - Available RPC endpoints
+   * @param walletIndex - Wallet index for round-robin selection
+   * @returns Selected RPC URL
+   */
+  getRpcForWalletIndex(chainId, endpoints, walletIndex) {
+    const chainEndpoints = endpoints.filter(
+      (ep) => ep.chainId === chainId && ep.status === "ACTIVE" && ep.rpcUrl
+    );
+    if (chainEndpoints.length === 0) {
+      console.warn(
+        `[RpcManager] No active RPC endpoints found for chain ${chainId}`
+      );
+      return "";
+    }
+    const healthyEndpoints = chainEndpoints.filter(
+      (ep) => this.isEndpointHealthy(ep.rpcUrl)
+    );
+    const availableEndpoints = healthyEndpoints.length > 0 ? healthyEndpoints : chainEndpoints;
+    const selectedIndex = walletIndex % availableEndpoints.length;
+    const selectedEndpoint = availableEndpoints[selectedIndex];
+    return selectedEndpoint.rpcUrl;
+  }
+  /**
+   * Get the best RPC URL for a chain (prioritizes healthy, low-latency endpoints)
+   * @param chainId - Chain ID to get RPC for
+   * @param endpoints - Available RPC endpoints
+   * @returns Best RPC URL
+   */
+  getBestRpc(chainId, endpoints) {
+    const chainEndpoints = endpoints.filter(
+      (ep) => ep.chainId === chainId && ep.status === "ACTIVE" && ep.rpcUrl
+    );
+    if (chainEndpoints.length === 0) {
+      return "";
+    }
+    const sorted = [...chainEndpoints].sort((a, b) => {
+      const healthA = this.healthMap.get(a.rpcUrl);
+      const healthB = this.healthMap.get(b.rpcUrl);
+      if (healthA?.isHealthy && !healthB?.isHealthy) return -1;
+      if (!healthA?.isHealthy && healthB?.isHealthy) return 1;
+      const timeA = healthA?.responseTime ?? Infinity;
+      const timeB = healthB?.responseTime ?? Infinity;
+      return timeA - timeB;
+    });
+    return sorted[0]?.rpcUrl ?? "";
+  }
+  /**
+   * Check if an endpoint is healthy
+   */
+  isEndpointHealthy(url) {
+    const health = this.healthMap.get(url);
+    if (!health) {
+      return true;
+    }
+    const now = Date.now();
+    if (now - health.lastChecked > this.healthCheckInterval) {
+      return true;
+    }
+    return health.isHealthy;
+  }
+  /**
+   * Mark an RPC endpoint as failed
+   */
+  markFailed(url) {
+    const existing = this.healthMap.get(url);
+    const failureCount = (existing?.failureCount ?? 0) + 1;
+    this.healthMap.set(url, {
+      url,
+      isHealthy: failureCount < this.maxFailures,
+      lastChecked: Date.now(),
+      responseTime: existing?.responseTime ?? Infinity,
+      failureCount
+    });
+  }
+  /**
+   * Mark an RPC endpoint as successful
+   */
+  markSuccess(url, responseTime) {
+    this.healthMap.set(url, {
+      url,
+      isHealthy: true,
+      lastChecked: Date.now(),
+      responseTime,
+      failureCount: 0
+    });
+  }
+  /**
+   * Reset health data for all endpoints
+   */
+  resetHealth() {
+    this.healthMap.clear();
+  }
+  /**
+   * Get health status for an endpoint
+   */
+  getHealth(url) {
+    return this.healthMap.get(url);
+  }
+  /**
+   * Get all health statuses
+   */
+  getAllHealth() {
+    return new Map(this.healthMap);
+  }
+};
+var NetworkController = class extends BaseController {
+  static VERSION = 1;
+  name = "NetworkController";
+  defaultState = {
+    selectedChainId: 1,
+    // Ethereum mainnet default
+    rpcEndpoints: [],
+    currentRpcUrl: null,
+    isLoading: false,
+    error: null,
+    walletIndex: 0
+  };
+  propertyMetadata = {
+    selectedChainId: { persist: true, anonymous: false },
+    rpcEndpoints: { persist: false, anonymous: true },
+    // Public data, fetched fresh
+    currentRpcUrl: { persist: false, anonymous: true },
+    isLoading: { persist: false, anonymous: true },
+    error: { persist: false, anonymous: true },
+    walletIndex: { persist: true, anonymous: false }
+  };
+  rpcManager;
+  constructor(config) {
+    super(
+      {
+        messenger: config.messenger,
+        persistenceService: config.persistenceService,
+        state: config.state
+      },
+      {
+        selectedChainId: config.defaultChainId ?? 1,
+        rpcEndpoints: [],
+        currentRpcUrl: null,
+        isLoading: false,
+        error: null,
+        walletIndex: 0
+      }
+    );
+    this.rpcManager = new RpcManager();
+    this.registerActions();
+  }
+  /**
+   * Register messenger actions
+   */
+  registerActions() {
+    this.messenger.registerActionHandler(
+      "NetworkController:setChainId",
+      this.setChainId.bind(this)
+    );
+    this.messenger.registerActionHandler(
+      "NetworkController:getActiveChainId",
+      this.getActiveChainId.bind(this)
+    );
+    this.messenger.registerActionHandler(
+      "NetworkController:getRpcUrl",
+      this.getRpcUrl.bind(this)
+    );
+    this.messenger.registerActionHandler(
+      "NetworkController:refreshEndpoints",
+      this.refreshEndpoints.bind(this)
+    );
+    this.messenger.registerActionHandler(
+      "NetworkController:setWalletIndex",
+      this.setWalletIndex.bind(this)
+    );
+  }
+  /**
+   * Initialize controller - load RPC endpoints
+   */
+  async initialize() {
+    console.log("[NetworkController] Initializing...");
+    if (this.persistenceService) {
+      await this.loadPersistedState();
+    }
+    await this.refreshEndpoints();
+    console.log("[NetworkController] Initialized");
+  }
+  /**
+   * Destroy controller - cleanup
+   */
+  destroy() {
+    this.messenger.unregisterActionHandler("NetworkController:setChainId");
+    this.messenger.unregisterActionHandler("NetworkController:getActiveChainId");
+    this.messenger.unregisterActionHandler("NetworkController:getRpcUrl");
+    this.messenger.unregisterActionHandler("NetworkController:refreshEndpoints");
+    this.messenger.unregisterActionHandler("NetworkController:setWalletIndex");
+    super.destroy();
+  }
+  /**
+   * Action: Set active chain ID
+   */
+  async setChainId(chainId) {
+    if (this.state.selectedChainId === chainId) {
+      return;
+    }
+    console.log(`[NetworkController] Switching to chain ${chainId}`);
+    this.update({ isLoading: true, error: null });
+    try {
+      const rpcUrl = this.getRpcUrl(chainId);
+      if (!rpcUrl) {
+        throw new Error(`No RPC endpoint available for chain ${chainId}`);
+      }
+      this.update({
+        selectedChainId: chainId,
+        currentRpcUrl: rpcUrl,
+        isLoading: false
+      });
+      this.messenger.publish("NetworkController:chainChanged", {
+        chainId,
+        rpcUrl
+      });
+      if (this.persistenceService) {
+        await this.persist();
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.update({
+        isLoading: false,
+        error: errorMessage
+      });
+      throw error;
+    }
+  }
+  /**
+   * Action: Get active chain ID
+   */
+  getActiveChainId() {
+    return this.state.selectedChainId;
+  }
+  /**
+   * Action: Get RPC URL for a chain
+   */
+  getRpcUrl(chainId) {
+    const { rpcEndpoints, walletIndex } = this.state;
+    const rpcUrl = this.rpcManager.getRpcForWalletIndex(
+      chainId,
+      rpcEndpoints,
+      walletIndex
+    );
+    return rpcUrl;
+  }
+  /**
+   * Action: Refresh RPC endpoints from service
+   */
+  async refreshEndpoints() {
+    console.log("[NetworkController] Refreshing RPC endpoints...");
+    this.update({ isLoading: true });
+    try {
+      const endpoints = await RpcEndpointService.getAll({});
+      this.update({
+        rpcEndpoints: endpoints || [],
+        isLoading: false,
+        error: null
+      });
+      this.messenger.publish("NetworkController:endpointsUpdated", {
+        count: endpoints?.length || 0
+      });
+      console.log(
+        `[NetworkController] Loaded ${endpoints?.length || 0} RPC endpoints`
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Failed to fetch endpoints";
+      this.update({
+        isLoading: false,
+        error: errorMessage
+      });
+      console.error("[NetworkController] Failed to refresh endpoints:", error);
+    }
+  }
+  /**
+   * Action: Set wallet index (affects RPC selection)
+   */
+  setWalletIndex(index) {
+    if (this.state.walletIndex === index) {
+      return;
+    }
+    this.update({ walletIndex: index });
+    const rpcUrl = this.getRpcUrl(this.state.selectedChainId);
+    if (rpcUrl && rpcUrl !== this.state.currentRpcUrl) {
+      this.update({ currentRpcUrl: rpcUrl });
+    }
+  }
+};
+
+// ../walletController/dist/index.js
+var WalletController = class extends BaseController {
+  static VERSION = 1;
+  name = "WalletController";
+  defaultState = {
+    wallets: [],
+    selectedWalletIndex: 0,
+    isLoading: false,
+    error: null,
+    isLocked: true
+  };
+  propertyMetadata = {
+    wallets: {
+      persist: true,
+      anonymous: false,
+      required: false
+    },
+    selectedWalletIndex: {
+      persist: true,
+      anonymous: false
+    },
+    isLoading: {
+      persist: false,
+      anonymous: true
+    },
+    error: {
+      persist: false,
+      anonymous: true
+    },
+    isLocked: {
+      persist: true,
+      anonymous: false
+    }
+  };
+  constructor(config) {
+    super(
+      {
+        messenger: config.messenger,
+        persistenceService: config.persistenceService,
+        state: config.state
+      },
+      {
+        wallets: [],
+        selectedWalletIndex: 0,
+        isLoading: false,
+        error: null,
+        isLocked: true
+      }
+    );
+    this.registerActions();
+    this.subscribeToEvents();
+  }
+  /**
+   * Register messenger actions
+   */
+  registerActions() {
+    this.messenger.registerActionHandler(
+      "WalletController:addWallet",
+      this.addWallet.bind(this)
+    );
+    this.messenger.registerActionHandler(
+      "WalletController:selectWallet",
+      this.selectWallet.bind(this)
+    );
+    this.messenger.registerActionHandler(
+      "WalletController:getActiveWallet",
+      this.getActiveWallet.bind(this)
+    );
+    this.messenger.registerActionHandler(
+      "WalletController:lockWallet",
+      this.lockWallet.bind(this)
+    );
+    this.messenger.registerActionHandler(
+      "WalletController:unlockWallet",
+      this.unlockWallet.bind(this)
+    );
+  }
+  /**
+   * Subscribe to events from other controllers
+   */
+  subscribeToEvents() {
+    this.messenger.subscribe(
+      "NetworkController:chainChanged",
+      this.onNetworkChanged.bind(this)
+    );
+  }
+  /**
+   * Initialize controller
+   */
+  async initialize() {
+    console.log("[WalletController] Initializing...");
+    if (this.persistenceService) {
+      await this.loadPersistedState();
+    }
+    const chainId = this.messenger.call("NetworkController:getActiveChainId");
+    console.log(`[WalletController] Active chain: ${chainId}`);
+    console.log("[WalletController] Initialized");
+  }
+  /**
+   * Destroy controller
+   */
+  destroy() {
+    this.messenger.unregisterActionHandler("WalletController:addWallet");
+    this.messenger.unregisterActionHandler("WalletController:selectWallet");
+    this.messenger.unregisterActionHandler("WalletController:getActiveWallet");
+    this.messenger.unregisterActionHandler("WalletController:lockWallet");
+    this.messenger.unregisterActionHandler("WalletController:unlockWallet");
+    super.destroy();
+  }
+  /**
+   * Event handler: Network changed
+   */
+  onNetworkChanged(event) {
+    console.log(
+      `[WalletController] Network changed to chain ${event.chainId}, may need to refresh balances`
+    );
+  }
+  /**
+   * Action: Add wallet
+   */
+  async addWallet(wallet) {
+    console.log(`[WalletController] Adding wallet: ${wallet.name}`);
+    const wallets = [...this.state.wallets, wallet];
+    this.update({ wallets });
+    if (this.persistenceService) {
+      await this.persist();
+    }
+  }
+  /**
+   * Action: Select wallet
+   */
+  async selectWallet(index) {
+    if (index < 0 || index >= this.state.wallets.length) {
+      throw new Error(`Invalid wallet index: ${index}`);
+    }
+    if (this.state.selectedWalletIndex === index) {
+      return;
+    }
+    const wallet = this.state.wallets[index];
+    this.update({ selectedWalletIndex: index });
+    this.messenger.publish("WalletController:walletSelected", {
+      index,
+      wallet
+    });
+    this.messenger.call("NetworkController:setWalletIndex", index);
+    if (this.persistenceService) {
+      await this.persist();
+    }
+    console.log(`[WalletController] Selected wallet: ${wallet.name}`);
+  }
+  /**
+   * Action: Get active wallet
+   */
+  getActiveWallet() {
+    const { wallets, selectedWalletIndex } = this.state;
+    if (wallets.length === 0) {
+      return null;
+    }
+    return wallets[selectedWalletIndex] || null;
+  }
+  /**
+   * Action: Lock wallet
+   */
+  lockWallet() {
+    this.update({ isLocked: true });
+    this.messenger.publish("WalletController:walletLocked", {});
+    console.log("[WalletController] Wallet locked");
+  }
+  /**
+   * Action: Unlock wallet
+   */
+  async unlockWallet(_password) {
+    this.update({ isLocked: false });
+    this.messenger.publish("WalletController:walletUnlocked", {});
+    console.log("[WalletController] Wallet unlocked");
+    return true;
+  }
+};
+
 // src/EztraEngine.ts
-import { ControllerMessenger } from "@eztra/controller";
-import { StatePersistenceService } from "@eztra/storage";
-import {
-  NetworkController
-} from "@eztra/network-controller";
-import {
-  WalletController
-} from "@eztra/wallet-controller";
 var EztraEngine = class {
   messenger;
   composableController;