@ic-reactor/core 2.0.0-alpha.0 → 2.0.1

package/dist/classes/adapter/index.js

@@ -1,21 +1,15 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CandidAdapter = void 0;
 const agent_1 = require("@dfinity/agent");
 const constants_1 = require("../../utils/constants");
 const utils_1 = require("../../utils");
 class CandidAdapter {
+    agent;
+    didjsCanisterId;
+    parserModule;
+    unsubscribeAgent = utils_1.noop;
     constructor({ agentManager, agent, didjsCanisterId, }) {
-        this.unsubscribeAgent = () => { };
         if (agent) {
             this.agent = agent;
         }
@@ -31,119 +25,104 @@ class CandidAdapter {
         }
         this.didjsCanisterId = didjsCanisterId || this.getDefaultDidJsId();
     }
-    initializeParser(module) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (module !== undefined) {
-                this.parserModule = module;
-                return;
-            }
-            try {
-                this.parserModule = require("@ic-reactor/parser");
-                if (typeof this.parserModule !== "undefined" &&
-                    "default" in this.parserModule) {
-                    yield this.parserModule.default();
-                }
-            }
-            catch (error) {
-                throw new Error(`Error initializing parser: ${error}`);
+    async initializeParser(module) {
+        if (module !== undefined) {
+            this.parserModule = module;
+            return;
+        }
+        try {
+            this.parserModule = require("@ic-reactor/parser");
+            if (typeof this.parserModule !== "undefined" &&
+                "default" in this.parserModule) {
+                await this.parserModule.default();
             }
-        });
+        }
+        catch (error) {
+            throw new Error(`Error initializing parser: ${error}`);
+        }
     }
     getDefaultDidJsId() {
-        var _a, _b;
-        return ((_b = (_a = this.agent).isLocal) === null || _b === void 0 ? void 0 : _b.call(_a)) === true
+        return this.agent.isLocal?.() === true
             ? constants_1.DEFAULT_LOCAL_DIDJS_ID
             : constants_1.DEFAULT_IC_DIDJS_ID;
     }
-    fetchCandidDefinition(canisterId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let candidDef = "";
-            // First attempt: Try getting Candid definition from metadata
-            try {
-                candidDef = yield this.getFromMetadata(canisterId);
-                if (!candidDef) {
-                    throw new Error("Cannot retrieve Candid definition from metadata");
-                }
-            }
-            catch (error) {
-                // Second attempt: Try the temporary hack method
-                candidDef = yield this.getFromTmpHack(canisterId).catch(() => {
-                    return undefined;
-                });
-            }
+    async fetchCandidDefinition(canisterId) {
+        let candidDef = "";
+        // First attempt: Try getting Candid definition from metadata
+        try {
+            candidDef = await this.getFromMetadata(canisterId);
             if (!candidDef) {
-                throw new Error("Failed to retrieve Candid definition by any method.");
+                throw new Error("Cannot retrieve Candid definition from metadata");
             }
-            return candidDef;
-        });
+        }
+        catch (error) {
+            // Second attempt: Try the temporary hack method
+            candidDef = await this.getFromTmpHack(canisterId).catch(() => {
+                return undefined;
+            });
+        }
+        if (!candidDef) {
+            throw new Error("Failed to retrieve Candid definition by any method.");
+        }
+        return candidDef;
     }
-    getCandidDefinition(canisterId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const candidDef = yield this.fetchCandidDefinition(canisterId);
-                return this.dynamicEvalJs(candidDef);
-            }
-            catch (error) {
-                throw new Error(`Error fetching canister ${canisterId}: ${error}`);
-            }
-        });
+    async getCandidDefinition(canisterId) {
+        try {
+            const candidDef = await this.fetchCandidDefinition(canisterId);
+            return this.evaluateCandidDefinition(candidDef);
+        }
+        catch (error) {
+            throw new Error(`Error fetching canister ${canisterId}: ${error}`);
+        }
     }
-    getFromMetadata(canisterId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const status = yield agent_1.CanisterStatus.request({
-                agent: this.agent,
-                canisterId: canisterId,
-                paths: ["candid"],
-            });
-            return status.get("candid");
+    async getFromMetadata(canisterId) {
+        const status = await agent_1.CanisterStatus.request({
+            agent: this.agent,
+            canisterId: canisterId,
+            paths: ["candid"],
         });
+        return status.get("candid");
     }
-    getFromTmpHack(canisterId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const commonInterface = ({ IDL }) => IDL.Service({
-                __get_candid_interface_tmp_hack: IDL.Func([], [IDL.Text], ["query"]),
-            });
-            const actor = agent_1.Actor.createActor(commonInterface, {
-                agent: this.agent,
-                canisterId,
-            });
-            return (yield actor.__get_candid_interface_tmp_hack());
+    async getFromTmpHack(canisterId) {
+        const commonInterface = ({ IDL }) => IDL.Service({
+            __get_candid_interface_tmp_hack: IDL.Func([], [IDL.Text], ["query"]),
+        });
+        const actor = agent_1.Actor.createActor(commonInterface, {
+            agent: this.agent,
+            canisterId,
         });
+        return (await actor.__get_candid_interface_tmp_hack());
     }
-    dynamicEvalJs(data) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async evaluateCandidDefinition(data) {
+        try {
+            let candidDef = "";
             try {
-                let candidDef = "";
-                try {
-                    candidDef = this.parseDidToJs(data);
-                    if (candidDef === "") {
-                        throw new Error("Cannot compile Candid to JavaScript");
-                    }
-                }
-                catch (error) {
-                    candidDef = (yield this.fetchDidTojs(data))[0];
-                }
-                if (JSON.stringify(candidDef) === JSON.stringify([])) {
+                candidDef = this.parseDidToJs(data);
+                if (candidDef === "") {
                     throw new Error("Cannot compile Candid to JavaScript");
                 }
-                return yield (0, utils_1.importCandidDefinition)(candidDef);
             }
             catch (error) {
-                throw new Error(`Error evaluating Candid definition: ${error}`);
+                candidDef = (await this.fetchDidTojs(data))[0];
             }
-        });
+            if (JSON.stringify(candidDef) === JSON.stringify([])) {
+                throw new Error("Cannot compile Candid to JavaScript");
+            }
+            return await (0, utils_1.importCandidDefinition)(candidDef);
+        }
+        catch (error) {
+            throw new Error(`Error evaluating Candid definition: ${error}`);
+        }
     }
-    fetchDidTojs(candidSource, didjsCanisterId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const didjsInterface = ({ IDL }) => IDL.Service({
-                did_to_js: IDL.Func([IDL.Text], [IDL.Opt(IDL.Text)], ["query"]),
-            });
-            const didjs = agent_1.Actor.createActor(didjsInterface, {
-                agent: this.agent,
-                canisterId: didjsCanisterId || this.didjsCanisterId,
-            });
-            return didjs.did_to_js(candidSource);
+    async fetchDidTojs(candidSource, didjsCanisterId) {
+        const didjsInterface = ({ IDL }) => IDL.Service({
+            did_to_js: IDL.Func([IDL.Text], [IDL.Opt(IDL.Text)], ["query"]),
+        });
+        const didjs = agent_1.Actor.createActor(didjsInterface, {
+            agent: this.agent,
+            canisterId: didjsCanisterId || this.didjsCanisterId,
         });
+        return didjs.did_to_js(candidSource);
     }
     parseDidToJs(candidSource) {
         if (!this.parserModule) {

package/dist/classes/agent/index.d.ts

@@ -1,20 +1,17 @@
 import { HttpAgent } from "@dfinity/agent";
 import { AuthClient } from "@dfinity/auth-client";
 import type { AuthClientLoginOptions } from "../../types";
-import type { AgentStore, AgentManagerParameters, UpdateAgentParameters, AuthState, AuthStore } from "./types";
+import type { AgentStore, AgentManagerParameters, UpdateAgentParameters, AuthStore } from "./types";
 export declare class AgentManager {
-    private _anonymousAgent;
     private _agent;
     private _auth;
     private _subscribers;
     agentStore: AgentStore;
     authStore: AuthStore;
-    private initialAgentState;
-    private initialAuthState;
     private updateAgentState;
-    updateAuthState: (newState: Partial<AuthState>, action?: string) => void;
+    private updateAuthState;
     constructor(options?: AgentManagerParameters);
-    private initializeAgent;
+    initializeAgent: () => Promise<void>;
     subscribeAgent: (callback: (agent: HttpAgent) => void, initialize?: boolean) => () => void;
     unsubscribeAgent: (callback: (agent: HttpAgent) => void) => void;
     private notifySubscribers;
@@ -28,6 +25,7 @@ export declare class AgentManager {
     getAgentHost: () => URL | undefined;
     getAgentHostName: () => string;
     getIsLocal: () => boolean;
+    isAuthClientInitialized: () => boolean;
     getNetwork: () => "local" | "remote" | "ic";
     getAgentState: AgentStore["getState"];
     subscribeAgentState: AgentStore["subscribe"];
@@ -35,5 +33,5 @@ export declare class AgentManager {
     subscribeAuthState: AuthStore["subscribe"];
     getAuth: () => AuthClient | null;
     getIdentity: () => import("@dfinity/agent").Identity | null;
-    getPrincipal: () => import("@dfinity/principal").Principal | null;
+    getPrincipal: () => import("@dfinity/principal/lib/esm/principal").Principal | null;
 }

package/dist/classes/agent/index.js

@@ -1,24 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentManager = void 0;
 /* eslint-disable no-console */
@@ -26,166 +6,36 @@ const agent_1 = require("@dfinity/agent");
 const helper_1 = require("../../utils/helper");
 const auth_client_1 = require("@dfinity/auth-client");
 const constants_1 = require("../../utils/constants");
+const AGENT_INITIAL_STATE = {
+    initialized: false,
+    isInitialized: false,
+    initializing: false,
+    isInitializing: false,
+    error: undefined,
+    network: undefined,
+};
+const AUTH_INITIAL_STATE = {
+    identity: null,
+    authenticating: false,
+    isAuthenticating: false,
+    authenticated: false,
+    isAuthenticated: false,
+    error: undefined,
+};
 class AgentManager {
+    _agent;
+    _auth = null;
+    _subscribers = [];
+    agentStore;
+    authStore;
+    updateAgentState = (newState, action) => {
+        this.agentStore.setState((state) => ({ ...state, ...newState }), false, action);
+    };
+    updateAuthState = (newState, action) => {
+        this.authStore.setState((state) => ({ ...state, ...newState }), false, action);
+    };
     constructor(options) {
-        var _a;
-        this._auth = null;
-        this._subscribers = [];
-        this.initialAgentState = {
-            initialized: false,
-            initializing: false,
-            error: undefined,
-            network: "ic",
-        };
-        this.initialAuthState = {
-            identity: null,
-            authenticating: false,
-            authenticated: false,
-            error: undefined,
-        };
-        this.updateAgentState = (newState, action) => {
-            this.agentStore.setState((state) => (Object.assign(Object.assign({}, state), newState)), false, action);
-        };
-        //TODO: make it private
-        this.updateAuthState = (newState, action) => {
-            this.authStore.setState((state) => (Object.assign(Object.assign({}, state), newState)), false, action);
-        };
-        this.initializeAgent = () => __awaiter(this, void 0, void 0, function* () {
-            const network = this.getNetwork();
-            this.updateAgentState({
-                initializing: true,
-                error: undefined,
-                network,
-            }, "initializing");
-            if (network !== "ic") {
-                try {
-                    yield this._agent.fetchRootKey();
-                    yield this._anonymousAgent.fetchRootKey();
-                }
-                catch (error) {
-                    this.updateAgentState({ error: error, initializing: false }, "error");
-                }
-            }
-            this.updateAgentState({ initialized: true, initializing: false }, "initialized");
-        });
-        this.subscribeAgent = (callback, initialize = true) => {
-            if (initialize) {
-                callback(this._agent);
-            }
-            this._subscribers.push(callback);
-            return () => this.unsubscribeAgent(callback);
-        };
-        this.unsubscribeAgent = (callback) => {
-            this._subscribers = this._subscribers.filter((sub) => sub !== callback);
-        };
-        this.notifySubscribers = () => __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all(this._subscribers.map((callback) => __awaiter(this, void 0, void 0, function* () { return callback(this._agent); })));
-        });
-        this.updateAgent = (options) => __awaiter(this, void 0, void 0, function* () {
-            const { agent } = options || {};
-            if (agent) {
-                this._agent = agent;
-            }
-            else if (options) {
-                this._agent = agent_1.HttpAgent.createSync(options);
-                yield this.initializeAgent();
-            }
-            yield this.notifySubscribers();
-        });
-        this.authenticate = () => __awaiter(this, void 0, void 0, function* () {
-            console.log(`Authenticating on ${this.getNetwork()} network`);
-            this.updateAuthState({ authenticating: true }, "authenticating");
-            try {
-                this._auth = yield auth_client_1.AuthClient.create();
-                const authenticated = yield this._auth.isAuthenticated();
-                const identity = this._auth.getIdentity();
-                this._agent.replaceIdentity(identity);
-                this.notifySubscribers();
-                this.updateAuthState({
-                    authenticated,
-                    identity,
-                    authenticating: false,
-                }, "authenticated");
-                return identity;
-            }
-            catch (error) {
-                this.updateAuthState({ error: error, authenticating: false }, "error");
-                throw error;
-            }
-        });
-        this.login = (options) => __awaiter(this, void 0, void 0, function* () {
-            this.updateAuthState({ authenticating: true }, "login");
-            if (!this._auth) {
-                yield this.authenticate();
-            }
-            if (!this._auth) {
-                throw new Error("Auth client not initialized");
-            }
-            yield this._auth.login(Object.assign(Object.assign({ identityProvider: this.getIsLocal()
-                    ? constants_1.LOCAL_INTERNET_IDENTITY_PROVIDER
-                    : constants_1.IC_INTERNET_IDENTITY_PROVIDER }, options), { onSuccess: (msg) => __awaiter(this, void 0, void 0, function* () {
-                    var _c;
-                    yield this.authenticate();
-                    (_c = options === null || options === void 0 ? void 0 : options.onSuccess) === null || _c === void 0 ? void 0 : _c.call(options, msg);
-                }) }));
-        });
-        this.logout = (options) => __awaiter(this, void 0, void 0, function* () {
-            if (!this._auth) {
-                throw new Error("Auth client not initialized");
-            }
-            yield this._auth.logout(options);
-            yield this.authenticate();
-        });
-        // agent store
-        this.getAgent = () => {
-            return this._agent;
-        };
-        this.getAgentHost = () => {
-            return this._agent.host;
-        };
-        this.getAgentHostName = () => {
-            var _a;
-            return ((_a = this.getAgentHost()) === null || _a === void 0 ? void 0 : _a.hostname) || "";
-        };
-        this.getIsLocal = () => {
-            return this.getNetwork() !== "ic";
-        };
-        this.getNetwork = () => {
-            const hostname = this.getAgentHostName();
-            if (constants_1.LOCAL_HOSTS.some((host) => hostname.endsWith(host))) {
-                return "local";
-            }
-            else if (constants_1.REMOTE_HOSTS.some((host) => hostname.endsWith(host))) {
-                return "remote";
-            }
-            else {
-                return "ic";
-            }
-        };
-        this.getAgentState = () => {
-            return this.agentStore.getState();
-        };
-        this.subscribeAgentState = (listener) => {
-            return this.agentStore.subscribe(listener);
-        };
-        // auth store
-        this.getAuthState = () => {
-            return this.authStore.getState();
-        };
-        this.subscribeAuthState = (listener) => {
-            return this.authStore.subscribe(listener);
-        };
-        this.getAuth = () => {
-            return this._auth;
-        };
-        this.getIdentity = () => {
-            return this.authStore.getState().identity;
-        };
-        this.getPrincipal = () => {
-            const identity = this.authStore.getState().identity;
-            return identity ? identity.getPrincipal() : null;
-        };
-        const _b = options || {}, { withDevtools, port = 4943, withLocalEnv, withProcessEnv } = _b, agentOptions = __rest(_b, ["withDevtools", "port", "withLocalEnv", "withProcessEnv"]);
+        const { withDevtools, port = 4943, withLocalEnv, withProcessEnv, initializeOnCreate = true, ...agentOptions } = options || {};
         if (withProcessEnv) {
             const processNetwork = (0, helper_1.getProcessEnvNetwork)();
             agentOptions.host =
@@ -195,21 +45,177 @@ class AgentManager {
             agentOptions.host = `http://127.0.0.1:${port}`;
         }
         else {
-            agentOptions.host = (_a = agentOptions.host) !== null && _a !== void 0 ? _a : constants_1.IC_HOST_NETWORK_URI;
+            agentOptions.host = agentOptions.host ?? constants_1.IC_HOST_NETWORK_URI;
         }
-        this.agentStore = (0, helper_1.createStoreWithOptionalDevtools)(this.initialAgentState, {
+        this.agentStore = (0, helper_1.createStoreWithOptionalDevtools)(AGENT_INITIAL_STATE, {
             withDevtools,
             name: "reactor-agent",
             store: "agent",
         });
-        this.authStore = (0, helper_1.createStoreWithOptionalDevtools)(this.initialAuthState, {
+        this.authStore = (0, helper_1.createStoreWithOptionalDevtools)(AUTH_INITIAL_STATE, {
             withDevtools,
             name: "reactor-agent",
             store: "auth",
         });
-        this._anonymousAgent = agent_1.HttpAgent.createSync(agentOptions);
         this._agent = agent_1.HttpAgent.createSync(agentOptions);
-        this.initializeAgent();
+        if (initializeOnCreate) {
+            this.initializeAgent();
+        }
     }
+    initializeAgent = async () => {
+        const network = this.getNetwork();
+        this.updateAgentState({
+            initializing: true,
+            isInitializing: true,
+            error: undefined,
+            network,
+        }, "initializing");
+        if (network !== "ic") {
+            try {
+                await this._agent.fetchRootKey();
+            }
+            catch (error) {
+                this.updateAgentState({
+                    error: error,
+                    initializing: false,
+                    isInitializing: false,
+                }, "error");
+            }
+        }
+        this.updateAgentState({
+            initialized: true,
+            isInitialized: true,
+            initializing: false,
+            isInitializing: false,
+        }, "initialized");
+    };
+    subscribeAgent = (callback, initialize = true) => {
+        if (initialize) {
+            callback(this._agent);
+        }
+        this._subscribers.push(callback);
+        return () => this.unsubscribeAgent(callback);
+    };
+    unsubscribeAgent = (callback) => {
+        this._subscribers = this._subscribers.filter((sub) => sub !== callback);
+    };
+    notifySubscribers = async () => {
+        await Promise.all(this._subscribers.map(async (callback) => callback(this._agent)));
+    };
+    updateAgent = async (options) => {
+        const { agent } = options || {};
+        if (agent) {
+            this._agent = agent;
+        }
+        else if (options) {
+            this._agent = agent_1.HttpAgent.createSync(options);
+            await this.initializeAgent();
+        }
+        await this.notifySubscribers();
+    };
+    authenticate = async () => {
+        console.log(`Authenticating on ${this.getNetwork()} network`);
+        this.updateAuthState({ isAuthenticating: true, authenticating: true }, "authenticating");
+        try {
+            this._auth = await auth_client_1.AuthClient.create();
+            const isAuthenticated = await this._auth.isAuthenticated();
+            const identity = this._auth.getIdentity();
+            this._agent.replaceIdentity(identity);
+            this.notifySubscribers();
+            this.updateAuthState({
+                authenticated: isAuthenticated,
+                isAuthenticated,
+                identity,
+                authenticating: false,
+                isAuthenticating: false,
+            }, "authenticated");
+            return identity;
+        }
+        catch (error) {
+            this.updateAuthState({
+                error: error,
+                isAuthenticating: false,
+                authenticating: false,
+            }, "error");
+            throw error;
+        }
+    };
+    login = async (options) => {
+        this.updateAuthState({ isAuthenticating: true, authenticating: true }, "login");
+        if (!this._auth) {
+            await this.authenticate();
+        }
+        if (!this._auth) {
+            throw new Error("Auth client not initialized");
+        }
+        await this._auth.login({
+            identityProvider: this.getIsLocal()
+                ? constants_1.LOCAL_INTERNET_IDENTITY_PROVIDER
+                : constants_1.IC_INTERNET_IDENTITY_PROVIDER,
+            ...options,
+            onSuccess: async (msg) => {
+                await this.authenticate();
+                options?.onSuccess?.(msg);
+            },
+        });
+    };
+    logout = async (options) => {
+        if (!this._auth) {
+            throw new Error("Auth client not initialized");
+        }
+        await this._auth.logout(options);
+        await this.authenticate();
+    };
+    // agent store
+    getAgent = () => {
+        return this._agent;
+    };
+    getAgentHost = () => {
+        return this._agent.host;
+    };
+    getAgentHostName = () => {
+        return this.getAgentHost()?.hostname || "";
+    };
+    getIsLocal = () => {
+        return this.getNetwork() !== "ic";
+    };
+    isAuthClientInitialized = () => {
+        return this.getAgentState().isInitialized && this._auth !== null;
+    };
+    getNetwork = () => {
+        const hostname = this.getAgentHostName();
+        return (0, helper_1.getNetworkByHostname)(hostname);
+    };
+    getAgentState = () => {
+        return this.agentStore.getState();
+    };
+    // @ts-expect-error: Overrides subscribe method signature
+    subscribeAgentState = (selectorOrListener, listener, options) => {
+        if (listener) {
+            return this.agentStore.subscribe(selectorOrListener, listener, options);
+        }
+        return this.agentStore.subscribe(selectorOrListener);
+    };
+    // auth store
+    getAuthState = () => {
+        return this.authStore.getState();
+    };
+    // @ts-expect-error: Overrides subscribe method signature
+    subscribeAuthState = (selectorOrListener, listener, options) => {
+        if (listener) {
+            return this.authStore.subscribe(selectorOrListener, listener, options);
+        }
+        return this.authStore.subscribe(selectorOrListener);
+    };
+    getAuth = () => {
+        return this._auth;
+    };
+    getIdentity = () => {
+        return this.authStore.getState().identity;
+    };
+    getPrincipal = () => {
+        const identity = this.authStore.getState().identity;
+        return identity ? identity.getPrincipal() : null;
+    };
 }
 exports.AgentManager = AgentManager;