@ic-reactor/core 2.0.0 → 3.0.0-beta.1

package/dist/client.d.ts

@@ -0,0 +1,161 @@
+import type { Identity } from "@icp-sdk/core/agent";
+import type { AuthClientLoginOptions } from "@icp-sdk/auth/client";
+import type { ClientManagerParameters, AgentState, AuthState } from "./types/client";
+import type { Principal } from "@icp-sdk/core/principal";
+import type { QueryClient } from "@tanstack/react-query";
+import { HttpAgent } from "@icp-sdk/core/agent";
+/**
+ * ClientManager is a central class for managing the Internet Computer (IC) agent and authentication state.
+ *
+ * It initializes the agent (connecting to local or mainnet), handles authentication via AuthClient,
+ * and integrates with TanStack Query's QueryClient for state management.
+ *
+ * @example
+ * ```typescript
+ * import { ClientManager } from "@ic-reactor/core";
+ * import { QueryClient } from "@tanstack/react-query";
+ *
+ * const queryClient = new QueryClient();
+ * const clientManager = new ClientManager({
+ *   queryClient,
+ *   withLocalEnv: true, // Use local replica
+ * });
+ *
+ * await clientManager.initialize();
+ * ```
+ */
+export declare class ClientManager {
+    #private;
+    /**
+     * The TanStack QueryClient used for managing cached canister data and invalidating queries on identity changes.
+     */
+    queryClient: QueryClient;
+    /**
+     * Current state of the HttpAgent, including initialization status, network, and error information.
+     */
+    agentState: AgentState;
+    /**
+     * Current authentication state, including the active identity, authentication progress, and errors.
+     */
+    authState: AuthState;
+    private initPromise?;
+    private authPromise?;
+    /**
+     * Creates a new instance of ClientManager.
+     *
+     * @param parameters - Configuration options for the agent and network environment.
+     */
+    constructor({ port, withLocalEnv, withProcessEnv, agentOptions, queryClient, authClient, }: ClientManagerParameters);
+    /**
+     * Orchestrates the complete initialization of the ClientManager.
+     * This method awaits the agent's core initialization (e.g., fetching root keys)
+     * and triggers the authentication (session restoration) in the background.
+     *
+     * @returns A promise that resolves to the ClientManager instance when core initialization is complete.
+     */
+    initialize(): Promise<this>;
+    /**
+     * Specifically initializes the HttpAgent.
+     * On local networks, this includes fetching the root key for certificate verification.
+     *
+     * @returns A promise that resolves when the agent is fully initialized.
+     */
+    initializeAgent(): Promise<void>;
+    private authModuleMissing;
+    /**
+     * Attempts to initialize the authentication client and restore a previous session.
+     *
+     * If an `AuthClient` is already initialized (passed in constructor or previously created),
+     * it uses that instance. Otherwise, it dynamically imports the `@icp-sdk/auth` module
+     * and creates a new AuthClient.
+     *
+     * If the module is missing and no client is provided, it fails gracefully by marking authentication as unavailable.
+     *
+     * @returns A promise that resolves to the restored Identity, or undefined if auth fails or is unavailable.
+     */
+    authenticate: () => Promise<Identity | undefined>;
+    /**
+     * Triggers the login flow using the Internet Identity provider.
+     *
+     * @param loginOptions - Options for the login flow, including identity provider and callbacks.
+     * @throws An error if the authentication module is not installed.
+     */
+    login: (loginOptions?: AuthClientLoginOptions) => Promise<void>;
+    /**
+     * Logs out the user and reverts the agent to an anonymous identity.
+     *
+     * @throws An error if the authentication module is not installed.
+     */
+    logout: () => Promise<void>;
+    /**
+     * The underlying HttpAgent managed by this class.
+     */
+    get agent(): HttpAgent;
+    /**
+     * The host URL of the current IC agent.
+     */
+    get agentHost(): URL | undefined;
+    /**
+     * The hostname of the current IC agent.
+     */
+    get agentHostName(): string;
+    /**
+     * Returns true if the agent is connecting to a local environment.
+     */
+    get isLocal(): boolean;
+    /**
+     * Returns the current network type ('ic' or 'local').
+     */
+    get network(): "local" | "remote" | "ic";
+    /**
+     * Returns the current user's Principal identity.
+     */
+    getUserPrincipal(): Promise<Principal>;
+    /**
+     * Registers a canister ID that this agent will interact with.
+     * This is used for informational purposes and network detection.
+     */
+    registerCanisterId(canisterId: string, name?: string): void;
+    /**
+     * Returns a list of all canister IDs registered with this agent.
+     */
+    connectedCanisterIds(): string[];
+    /**
+     * Get the subnet ID for a canister.
+     */
+    getSubnetIdFromCanister(canisterId: string): Promise<Principal>;
+    /**
+     * Sync time with a specific subnet.
+     */
+    syncTimeWithSubnet(subnetId: Principal): Promise<void>;
+    private getDefaultIdentityProvider;
+    /**
+     * Subscribes to identity changes (e.g., after login/logout).
+     * @param callback - Function called with the new identity.
+     * @returns An unsubscribe function.
+     */
+    subscribe(callback: (identity: Identity) => void): () => void;
+    /**
+     * Subscribes to changes in the agent's initialization state.
+     * @param callback - Function called with the updated agent state.
+     * @returns An unsubscribe function.
+     */
+    subscribeAgentState(callback: (state: AgentState) => void): () => void;
+    /**
+     * Subscribes to changes in the authentication state.
+     * @param callback - Function called with the updated authentication state.
+     * @returns An unsubscribe function.
+     */
+    subscribeAuthState(callback: (state: AuthState) => void): () => void;
+    /**
+     * Replaces the current agent's identity and invalidates TanStack queries.
+     * @param identity - The new identity to use.
+     */
+    updateAgent(identity: Identity): void;
+    private notifySubscribers;
+    private notifyAgentStateSubscribers;
+    private notifyAuthStateSubscribers;
+    private updateAgentState;
+    private updateAuthState;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,KAAK,EAAc,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAC9E,OAAO,KAAK,EACV,uBAAuB,EACvB,UAAU,EACV,SAAS,EACV,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAQ/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,aAAa;;IAQxB;;OAEG;IACI,WAAW,EAAE,WAAW,CAAA;IAC/B;;OAEG;IACI,UAAU,EAAE,UAAU,CAAA;IAC7B;;OAEG;IACI,SAAS,EAAE,SAAS,CAAA;IAE3B,OAAO,CAAC,WAAW,CAAC,CAAe;IACnC,OAAO,CAAC,WAAW,CAAC,CAA+B;IAEnD;;;;OAIG;gBACS,EACV,IAAW,EACX,YAAY,EACZ,cAAc,EACd,YAAiB,EACjB,WAAW,EACX,UAAU,GACX,EAAE,uBAAuB;IAkD1B;;;;;;OAMG;IACU,UAAU;IAMvB;;;;;OAKG;IACU,eAAe;IAuC5B,OAAO,CAAC,iBAAiB,CAAQ;IAEjC;;;;;;;;;;OAUG;IACI,YAAY,QAAa,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CA2D5D;IAED;;;;;OAKG;IACI,KAAK,GAAU,eAAe,sBAAsB,mBAqD1D;IAED;;;;OAIG;IACI,MAAM,sBAiBZ;IAED;;OAEG;IACH,IAAI,KAAK,cAER;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,GAAG,GAAG,SAAS,CAE/B;IAED;;OAEG;IACH,IAAI,aAAa,WAEhB;IAED;;OAEG;IACH,IAAI,OAAO,YAEV;IAED;;OAEG;IACH,IAAI,OAAO,8BAGV;IAED;;OAEG;IACI,gBAAgB;IAIvB;;;OAGG;IACI,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI;IAiBlE;;OAEG;IACI,oBAAoB,IAAI,MAAM,EAAE;IAIvC;;OAEG;IACI,uBAAuB,CAAC,UAAU,EAAE,MAAM;IAIjD;;OAEG;IACI,kBAAkB,CAAC,QAAQ,EAAE,SAAS;IAI7C,OAAO,CAAC,0BAA0B;IAQlC;;;;OAIG;IACI,SAAS,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI;IASvD;;;;OAIG;IACI,mBAAmB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI;IAShE;;;;OAIG;IACI,kBAAkB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI;IAS9D;;;OAGG;IACI,WAAW,CAAC,QAAQ,EAAE,QAAQ;IAwBrC,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,2BAA2B;IAInC,OAAO,CAAC,0BAA0B;IAIlC,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,eAAe;CAKxB"}

package/dist/client.js

@@ -0,0 +1,499 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ClientManager_agent, _ClientManager_authClient, _ClientManager_identitySubscribers, _ClientManager_agentStateSubscribers, _ClientManager_authStateSubscribers, _ClientManager_targetCanisterIds;
+import { HttpAgent } from "@icp-sdk/core/agent";
+import { IC_HOST_NETWORK_URI, IC_INTERNET_IDENTITY_PROVIDER, LOCAL_INTERNET_IDENTITY_PROVIDER, } from "./utils/constants";
+import { getNetworkByHostname, getProcessEnvNetwork } from "./utils/helper";
+/**
+ * ClientManager is a central class for managing the Internet Computer (IC) agent and authentication state.
+ *
+ * It initializes the agent (connecting to local or mainnet), handles authentication via AuthClient,
+ * and integrates with TanStack Query's QueryClient for state management.
+ *
+ * @example
+ * ```typescript
+ * import { ClientManager } from "@ic-reactor/core";
+ * import { QueryClient } from "@tanstack/react-query";
+ *
+ * const queryClient = new QueryClient();
+ * const clientManager = new ClientManager({
+ *   queryClient,
+ *   withLocalEnv: true, // Use local replica
+ * });
+ *
+ * await clientManager.initialize();
+ * ```
+ */
+export class ClientManager {
+    /**
+     * Creates a new instance of ClientManager.
+     *
+     * @param parameters - Configuration options for the agent and network environment.
+     */
+    constructor({ port = 4943, withLocalEnv, withProcessEnv, agentOptions = {}, queryClient, authClient, }) {
+        _ClientManager_agent.set(this, void 0);
+        _ClientManager_authClient.set(this, void 0);
+        _ClientManager_identitySubscribers.set(this, []);
+        _ClientManager_agentStateSubscribers.set(this, []);
+        _ClientManager_authStateSubscribers.set(this, []);
+        _ClientManager_targetCanisterIds.set(this, new Set()
+        /**
+         * The TanStack QueryClient used for managing cached canister data and invalidating queries on identity changes.
+         */
+        );
+        /**
+         * The TanStack QueryClient used for managing cached canister data and invalidating queries on identity changes.
+         */
+        Object.defineProperty(this, "queryClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Current state of the HttpAgent, including initialization status, network, and error information.
+         */
+        Object.defineProperty(this, "agentState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Current authentication state, including the active identity, authentication progress, and errors.
+         */
+        Object.defineProperty(this, "authState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "initPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "authPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "authModuleMissing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /**
+         * Attempts to initialize the authentication client and restore a previous session.
+         *
+         * If an `AuthClient` is already initialized (passed in constructor or previously created),
+         * it uses that instance. Otherwise, it dynamically imports the `@icp-sdk/auth` module
+         * and creates a new AuthClient.
+         *
+         * If the module is missing and no client is provided, it fails gracefully by marking authentication as unavailable.
+         *
+         * @returns A promise that resolves to the restored Identity, or undefined if auth fails or is unavailable.
+         */
+        Object.defineProperty(this, "authenticate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async () => {
+                if (this.authState.isAuthenticated) {
+                    return this.authState.identity || undefined;
+                }
+                if (this.authPromise) {
+                    return this.authPromise;
+                }
+                if (this.authModuleMissing) {
+                    return undefined;
+                }
+                this.authPromise = (async () => {
+                    if (typeof window !== "undefined") {
+                        console.info(`%cic-reactor:%c Authenticating...`, "color: #3b82f6; font-weight: bold", "color: inherit", {
+                            network: this.network,
+                            authClient: __classPrivateFieldGet(this, _ClientManager_authClient, "f") ? "Shared Instance" : "Dynamic Import",
+                        });
+                    }
+                    this.updateAuthState({ isAuthenticating: true });
+                    try {
+                        if (!__classPrivateFieldGet(this, _ClientManager_authClient, "f")) {
+                            const authModule = await import("@icp-sdk/auth/client").catch(() => {
+                                this.authModuleMissing = true;
+                                return null;
+                            });
+                            if (!authModule) {
+                                this.authModuleMissing = true;
+                                this.updateAuthState({ isAuthenticating: false });
+                                return undefined;
+                            }
+                            const { AuthClient } = authModule;
+                            __classPrivateFieldSet(this, _ClientManager_authClient, await AuthClient.create(), "f");
+                        }
+                        const identity = __classPrivateFieldGet(this, _ClientManager_authClient, "f").getIdentity();
+                        this.updateAgent(identity);
+                        this.updateAuthState({
+                            identity,
+                            isAuthenticated: !identity.getPrincipal().isAnonymous(),
+                            isAuthenticating: false,
+                        });
+                        return identity;
+                    }
+                    catch (error) {
+                        this.updateAuthState({ error: error, isAuthenticating: false });
+                        console.error("Authentication failed:", error);
+                        throw error;
+                    }
+                    finally {
+                        this.authPromise = undefined;
+                    }
+                })();
+                return this.authPromise;
+            }
+        });
+        /**
+         * Triggers the login flow using the Internet Identity provider.
+         *
+         * @param loginOptions - Options for the login flow, including identity provider and callbacks.
+         * @throws An error if the authentication module is not installed.
+         */
+        Object.defineProperty(this, "login", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (loginOptions) => {
+                try {
+                    // Ensure agent is initialized before login
+                    if (!this.agentState.isInitialized) {
+                        await this.initializeAgent();
+                    }
+                    if (!__classPrivateFieldGet(this, _ClientManager_authClient, "f")) {
+                        await this.authenticate();
+                    }
+                    if (!__classPrivateFieldGet(this, _ClientManager_authClient, "f")) {
+                        throw new Error("Authentication module is missing or failed to initialize. To use login, please install the auth package: npm install @icp-sdk/auth");
+                    }
+                    this.updateAuthState({ isAuthenticating: true, error: undefined });
+                    // Auto-detect identity provider based on network if not provided
+                    const identityProvider = loginOptions?.identityProvider || this.getDefaultIdentityProvider();
+                    await __classPrivateFieldGet(this, _ClientManager_authClient, "f").login({
+                        ...loginOptions,
+                        identityProvider,
+                        onSuccess: () => {
+                            const identity = __classPrivateFieldGet(this, _ClientManager_authClient, "f").getIdentity();
+                            if (identity) {
+                                this.updateAgent(identity);
+                                this.updateAuthState({
+                                    identity,
+                                    isAuthenticated: true,
+                                    isAuthenticating: false,
+                                });
+                            }
+                            ;
+                            loginOptions?.onSuccess?.();
+                        },
+                        onError: (error) => {
+                            this.updateAuthState({
+                                error: new Error(error),
+                                isAuthenticating: false,
+                            });
+                            loginOptions?.onError?.(error);
+                        },
+                    });
+                }
+                catch (error) {
+                    this.updateAuthState({
+                        error: error,
+                        isAuthenticating: false,
+                    });
+                    throw error;
+                }
+            }
+        });
+        /**
+         * Logs out the user and reverts the agent to an anonymous identity.
+         *
+         * @throws An error if the authentication module is not installed.
+         */
+        Object.defineProperty(this, "logout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async () => {
+                if (!__classPrivateFieldGet(this, _ClientManager_authClient, "f")) {
+                    throw new Error("Authentication module is missing or failed to initialize. To use logout, please install the auth package: npm install @icp-sdk/auth");
+                }
+                this.updateAuthState({ isAuthenticating: true, error: undefined });
+                await __classPrivateFieldGet(this, _ClientManager_authClient, "f").logout();
+                const identity = __classPrivateFieldGet(this, _ClientManager_authClient, "f").getIdentity();
+                if (identity) {
+                    this.updateAgent(identity);
+                    this.updateAuthState({
+                        identity,
+                        isAuthenticated: false,
+                        isAuthenticating: false,
+                    });
+                }
+            }
+        });
+        this.queryClient = queryClient;
+        this.agentState = {
+            isInitialized: false,
+            isInitializing: false,
+            error: undefined,
+            network: undefined,
+            isLocalhost: false,
+        };
+        this.authState = {
+            identity: null,
+            isAuthenticating: false,
+            isAuthenticated: false,
+            error: undefined,
+        };
+        if (withProcessEnv) {
+            const processNetwork = getProcessEnvNetwork();
+            if (processNetwork === "ic") {
+                agentOptions.host = IC_HOST_NETWORK_URI;
+            }
+            else if (processNetwork === "local") {
+                agentOptions.host =
+                    typeof process !== "undefined" && process.env.IC_HOST
+                        ? process.env.IC_HOST
+                        : `http://127.0.0.1:${port}`;
+            }
+        }
+        else if (withLocalEnv) {
+            agentOptions.host = `http://127.0.0.1:${port}`;
+        }
+        else {
+            agentOptions.host = agentOptions.host ?? IC_HOST_NETWORK_URI;
+        }
+        __classPrivateFieldSet(this, _ClientManager_agent, HttpAgent.createSync(agentOptions), "f");
+        this.updateAgentState({ isLocalhost: this.isLocal });
+        if (authClient) {
+            __classPrivateFieldSet(this, _ClientManager_authClient, authClient, "f");
+            const identity = __classPrivateFieldGet(this, _ClientManager_authClient, "f").getIdentity();
+            this.updateAgent(identity);
+            this.authState = {
+                identity,
+                isAuthenticated: !identity.getPrincipal().isAnonymous(),
+                isAuthenticating: false,
+                error: undefined,
+            };
+        }
+    }
+    /**
+     * Orchestrates the complete initialization of the ClientManager.
+     * This method awaits the agent's core initialization (e.g., fetching root keys)
+     * and triggers the authentication (session restoration) in the background.
+     *
+     * @returns A promise that resolves to the ClientManager instance when core initialization is complete.
+     */
+    async initialize() {
+        await this.initializeAgent();
+        this.authenticate();
+        return this;
+    }
+    /**
+     * Specifically initializes the HttpAgent.
+     * On local networks, this includes fetching the root key for certificate verification.
+     *
+     * @returns A promise that resolves when the agent is fully initialized.
+     */
+    async initializeAgent() {
+        if (this.agentState.isInitialized) {
+            return;
+        }
+        if (this.agentState.isInitializing) {
+            return this.initPromise;
+        }
+        this.initPromise = (async () => {
+            this.updateAgentState({ isInitializing: true });
+            if (typeof window !== "undefined") {
+                console.info(`%cic-reactor:%c Initializing agent for ${this.network} network`, "color: #3b82f6; font-weight: bold", "color: inherit", {
+                    host: this.agentHost?.toString(),
+                    isLocal: this.isLocal,
+                });
+            }
+            try {
+                if (this.isLocal) {
+                    await __classPrivateFieldGet(this, _ClientManager_agent, "f").fetchRootKey();
+                }
+                this.updateAgentState({ isInitialized: true, isInitializing: false });
+            }
+            catch (error) {
+                this.updateAgentState({
+                    error: error,
+                    isInitializing: false,
+                });
+                this.initPromise = undefined;
+                throw error;
+            }
+        })();
+        return this.initPromise;
+    }
+    /**
+     * The underlying HttpAgent managed by this class.
+     */
+    get agent() {
+        return __classPrivateFieldGet(this, _ClientManager_agent, "f");
+    }
+    /**
+     * The host URL of the current IC agent.
+     */
+    get agentHost() {
+        return __classPrivateFieldGet(this, _ClientManager_agent, "f").host;
+    }
+    /**
+     * The hostname of the current IC agent.
+     */
+    get agentHostName() {
+        return this.agentHost?.hostname || "";
+    }
+    /**
+     * Returns true if the agent is connecting to a local environment.
+     */
+    get isLocal() {
+        return this.network !== "ic";
+    }
+    /**
+     * Returns the current network type ('ic' or 'local').
+     */
+    get network() {
+        const hostname = this.agentHostName;
+        return getNetworkByHostname(hostname);
+    }
+    /**
+     * Returns the current user's Principal identity.
+     */
+    getUserPrincipal() {
+        return __classPrivateFieldGet(this, _ClientManager_agent, "f").getPrincipal();
+    }
+    /**
+     * Registers a canister ID that this agent will interact with.
+     * This is used for informational purposes and network detection.
+     */
+    registerCanisterId(canisterId, name) {
+        if (typeof window !== "undefined") {
+            const actorName = name || canisterId;
+            console.info(`%cic-reactor:%c Adding actor ${actorName}`, "color: #3b82f6; font-weight: bold", "color: inherit", {
+                network: this.network,
+                canisterId,
+                ...(name && { name }),
+            });
+        }
+        __classPrivateFieldGet(this, _ClientManager_targetCanisterIds, "f").add(canisterId);
+    }
+    /**
+     * Returns a list of all canister IDs registered with this agent.
+     */
+    connectedCanisterIds() {
+        return Array.from(__classPrivateFieldGet(this, _ClientManager_targetCanisterIds, "f"));
+    }
+    /**
+     * Get the subnet ID for a canister.
+     */
+    getSubnetIdFromCanister(canisterId) {
+        return __classPrivateFieldGet(this, _ClientManager_agent, "f").getSubnetIdFromCanister(canisterId);
+    }
+    /**
+     * Sync time with a specific subnet.
+     */
+    syncTimeWithSubnet(subnetId) {
+        return __classPrivateFieldGet(this, _ClientManager_agent, "f").syncTimeWithSubnet(subnetId);
+    }
+    getDefaultIdentityProvider() {
+        if (this.isLocal) {
+            return LOCAL_INTERNET_IDENTITY_PROVIDER;
+        }
+        else {
+            return IC_INTERNET_IDENTITY_PROVIDER;
+        }
+    }
+    /**
+     * Subscribes to identity changes (e.g., after login/logout).
+     * @param callback - Function called with the new identity.
+     * @returns An unsubscribe function.
+     */
+    subscribe(callback) {
+        __classPrivateFieldGet(this, _ClientManager_identitySubscribers, "f").push(callback);
+        return () => {
+            __classPrivateFieldSet(this, _ClientManager_identitySubscribers, __classPrivateFieldGet(this, _ClientManager_identitySubscribers, "f").filter((sub) => sub !== callback), "f");
+        };
+    }
+    /**
+     * Subscribes to changes in the agent's initialization state.
+     * @param callback - Function called with the updated agent state.
+     * @returns An unsubscribe function.
+     */
+    subscribeAgentState(callback) {
+        __classPrivateFieldGet(this, _ClientManager_agentStateSubscribers, "f").push(callback);
+        return () => {
+            __classPrivateFieldSet(this, _ClientManager_agentStateSubscribers, __classPrivateFieldGet(this, _ClientManager_agentStateSubscribers, "f").filter((sub) => sub !== callback), "f");
+        };
+    }
+    /**
+     * Subscribes to changes in the authentication state.
+     * @param callback - Function called with the updated authentication state.
+     * @returns An unsubscribe function.
+     */
+    subscribeAuthState(callback) {
+        __classPrivateFieldGet(this, _ClientManager_authStateSubscribers, "f").push(callback);
+        return () => {
+            __classPrivateFieldSet(this, _ClientManager_authStateSubscribers, __classPrivateFieldGet(this, _ClientManager_authStateSubscribers, "f").filter((sub) => sub !== callback), "f");
+        };
+    }
+    /**
+     * Replaces the current agent's identity and invalidates TanStack queries.
+     * @param identity - The new identity to use.
+     */
+    updateAgent(identity) {
+        if (typeof window !== "undefined") {
+            console.info(`%cic-reactor:%c Updating agent identity`, "color: #3b82f6; font-weight: bold", "color: inherit", {
+                principal: identity.getPrincipal().toText(),
+            });
+        }
+        // Cancel all queries for connected canisters to prevent race conditions
+        // with the old identity
+        this.connectedCanisterIds().forEach((canisterId) => {
+            this.queryClient.cancelQueries({
+                queryKey: [canisterId],
+            });
+        });
+        __classPrivateFieldGet(this, _ClientManager_agent, "f").replaceIdentity(identity);
+        this.notifySubscribers(identity);
+        this.queryClient.invalidateQueries();
+    }
+    notifySubscribers(identity) {
+        __classPrivateFieldGet(this, _ClientManager_identitySubscribers, "f").forEach((sub) => sub(identity));
+    }
+    notifyAgentStateSubscribers(state) {
+        __classPrivateFieldGet(this, _ClientManager_agentStateSubscribers, "f").forEach((sub) => sub(state));
+    }
+    notifyAuthStateSubscribers(state) {
+        __classPrivateFieldGet(this, _ClientManager_authStateSubscribers, "f").forEach((sub) => sub(state));
+    }
+    updateAgentState(newState) {
+        this.agentState = { ...this.agentState, ...newState };
+        this.notifyAgentStateSubscribers(this.agentState);
+    }
+    updateAuthState(newState) {
+        console.debug("Updating Auth State:", newState);
+        this.authState = { ...this.authState, ...newState };
+        this.notifyAuthStateSubscribers(this.authState);
+    }
+}
+_ClientManager_agent = new WeakMap(), _ClientManager_authClient = new WeakMap(), _ClientManager_identitySubscribers = new WeakMap(), _ClientManager_agentStateSubscribers = new WeakMap(), _ClientManager_authStateSubscribers = new WeakMap(), _ClientManager_targetCanisterIds = new WeakMap();
+//# sourceMappingURL=client.js.map