@ic-reactor/core 0.5.3 → 1.0.0

package/dist/agent/index.js

@@ -0,0 +1,187 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 = exports.LOCAL_HOST_NETWORK_URI = exports.IC_HOST_NETWORK_URI = void 0;
+const agent_1 = require("@dfinity/agent");
+const helper_1 = require("../tools/helper");
+__exportStar(require("./types"), exports);
+exports.IC_HOST_NETWORK_URI = "https://ic0.app";
+exports.LOCAL_HOST_NETWORK_URI = "http://127.0.0.1:4943";
+class AgentManager {
+    constructor(options) {
+        this._subscribers = [];
+        this.initialAgentState = {
+            initialized: false,
+            initializing: false,
+            error: undefined,
+        };
+        this.initialAuthState = {
+            identity: null,
+            authClient: null,
+            authenticating: false,
+            authenticated: false,
+            error: undefined,
+        };
+        this.updateAgentState = (newState) => {
+            this.agentStore.setState((state) => (Object.assign(Object.assign({}, state), newState)));
+        };
+        this.updateAuthState = (newState) => {
+            this.authStore.setState((state) => (Object.assign(Object.assign({}, state), newState)));
+        };
+        this.initializeAgent = () => __awaiter(this, void 0, void 0, function* () {
+            this.updateAgentState({ initializing: true });
+            if (this.isLocalEnv) {
+                try {
+                    yield this._agent.fetchRootKey();
+                    this.updateAgentState({ initialized: true, initializing: false });
+                }
+                catch (error) {
+                    this.updateAgentState({ error: error, initializing: false });
+                }
+            }
+        });
+        this.subscribeAgent = (callback) => {
+            this._subscribers.push(callback);
+            return () => this.unsubscribeAgent(callback);
+        };
+        this.unsubscribeAgent = (callback) => {
+            this._subscribers = this._subscribers.filter((sub) => sub !== callback);
+        };
+        this.notifySubscribers = () => {
+            this._subscribers.forEach((callback) => 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 = new agent_1.HttpAgent(options);
+                this.isLocalEnv = this._agent.isLocal();
+                yield this.initializeAgent();
+            }
+            this.notifySubscribers();
+        });
+        this.authenticate = () => __awaiter(this, void 0, void 0, function* () {
+            this.updateAuthState({ authenticating: true });
+            try {
+                const { AuthClient } = yield Promise.resolve().then(() => __importStar(require("@dfinity/auth-client"))).catch((error) => {
+                    // eslint-disable-next-line no-console
+                    console.error("Failed to import @dfinity/auth-client:", error);
+                    throw new Error("Authentication failed: @dfinity/auth-client package is missing.");
+                });
+                const authClient = yield AuthClient.create();
+                const authenticated = yield authClient.isAuthenticated();
+                const identity = authClient.getIdentity();
+                this._agent.replaceIdentity(identity);
+                this.notifySubscribers();
+                this.updateAuthState({
+                    authClient,
+                    authenticated,
+                    identity,
+                    authenticating: false,
+                });
+                return identity;
+            }
+            catch (error) {
+                this.updateAuthState({ error: error, authenticating: false });
+                throw error;
+            }
+        });
+        // agent store
+        this.getAgent = () => {
+            return this._agent;
+        };
+        this.getAgentStore = () => {
+            return this.agentStore;
+        };
+        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.getAuthClient = () => {
+            return this.authStore.getState().authClient;
+        };
+        this.getIdentity = () => {
+            return this.authStore.getState().identity;
+        };
+        this.getPrincipal = () => {
+            const identity = this.authStore.getState().identity;
+            return identity ? identity.getPrincipal() : null;
+        };
+        const _a = options || {}, { withDevtools, port = 4943, isLocalEnv, host: optionHost } = _a, agentOptions = __rest(_a, ["withDevtools", "port", "isLocalEnv", "host"]);
+        const host = isLocalEnv
+            ? `http://127.0.0.1:${port}`
+            : optionHost
+                ? optionHost.includes("localhost")
+                    ? optionHost.replace("localhost", "127.0.0.1")
+                    : optionHost
+                : exports.IC_HOST_NETWORK_URI;
+        this.agentStore = (0, helper_1.createStoreWithOptionalDevtools)(this.initialAgentState, {
+            withDevtools,
+            store: "agent",
+        });
+        this.authStore = (0, helper_1.createStoreWithOptionalDevtools)(this.initialAuthState, {
+            withDevtools,
+            store: "auth",
+        });
+        this._agent = new agent_1.HttpAgent(Object.assign(Object.assign({}, agentOptions), { host }));
+        this.isLocalEnv = this._agent.isLocal();
+        this.initializeAgent();
+    }
+}
+exports.AgentManager = AgentManager;

package/dist/agent/types.d.ts

@@ -0,0 +1,26 @@
+import type { HttpAgent, HttpAgentOptions, Identity } from "@dfinity/agent";
+import type { AuthClient } from "@dfinity/auth-client";
+import type { StoreApi } from "zustand";
+export { HttpAgentOptions, AuthClient, Identity };
+export interface AgentManagerOptions extends HttpAgentOptions {
+    port?: number;
+    isLocalEnv?: boolean;
+    withDevtools?: boolean;
+}
+export interface AgentState {
+    initialized: boolean;
+    initializing: boolean;
+    error: Error | undefined;
+}
+export interface AuthState {
+    identity: Identity | null;
+    authClient: AuthClient | null;
+    authenticating: boolean;
+    authenticated: boolean;
+    error: Error | undefined;
+}
+export interface UpdateAgentOptions extends HttpAgentOptions {
+    agent?: HttpAgent;
+}
+export type AgentStore = StoreApi<AgentState>;
+export type AuthStore = StoreApi<AuthState>;

package/dist/agent/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -1,20 +1,56 @@
-import type { CreateReActorOptions } from "@ic-reactor/store";
-import { ActorQuery, ActorUpdate } from "./types";
-export declare const createReActor: <A extends unknown>(options: CreateReActorOptions) => {
-    canisterId: import("@ic-reactor/store").CanisterId;
-    withServiceFields: boolean;
-    serviceFields?: import("@ic-reactor/store").ExtractedService<A> | undefined;
-    unsubscribeActor: () => void;
-    initialize: (options?: import("@ic-reactor/store").UpdateAgentOptions | undefined) => Promise<void>;
-    updateMethodState: (newState: Partial<import("@ic-reactor/store").ActorMethodStates<A>>) => void;
-    isLocalEnv: boolean;
-    subscribeAgent: (callback: (agent: import("@ic-reactor/store").HttpAgent) => void) => () => void;
-    unsubscribeAgent: (callback: (agent: import("@ic-reactor/store").HttpAgent) => void) => void;
-    updateAgent: (options?: import("@ic-reactor/store").UpdateAgentOptions | undefined) => Promise<void>;
-    authenticate: () => Promise<import("@ic-reactor/store").Identity>;
-    getAgent: () => import("@ic-reactor/store").HttpAgent;
-    actorStore: import("@ic-reactor/store").ActorStore<A>;
-    authStore: import("@ic-reactor/store").AgentAuthStore;
-    queryCall: ActorQuery<A>;
-    updateCall: ActorUpdate<A>;
-};
+import type { ActorManagerOptions, BaseActor } from "./actor/types";
+import type { AgentManagerOptions } from "./agent/types";
+import { ActorManager } from "./actor";
+import { AgentManager } from "./agent";
+import type { ActorCoreActions, CreateReActorOptions, CreateReActorStoreOptions } from "./types";
+import { CandidAdapter, CandidAdapterOptions } from "./tools";
+export * from "./types";
+export * from "./actor";
+export * from "./agent";
+export * from "./tools";
+/**
+ * Create a new actor manager with the given options.
+ * Its create a new agent manager if not provided.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:30-91
+ */
+export declare const createReActor: <A = BaseActor>({ isLocalEnv, withProcessEnv, ...options }: CreateReActorOptions) => ActorCoreActions<A>;
+/**
+ * Create a new actor manager with the given options.
+ * Its create a new agent manager if not provided.
+ * It also creates a new actor manager with the given options.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:32-45
+ */
+export declare const createReActorStore: <A = BaseActor>(options: CreateReActorStoreOptions) => ActorManager<A>;
+/**
+ * Agent manager handles the lifecycle of the `@dfinity/agent`.
+ * It is responsible for creating agent and managing the agent's state.
+ * You can use it to subscribe to the agent changes.
+ * login and logout to the internet identity.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:55-86
+ */
+export declare const createAgentManager: (options?: AgentManagerOptions) => AgentManager;
+/**
+ * Actor manager handles the lifecycle of the actors.
+ * It is responsible for creating and managing the actors.
+ * You can use it to call and visit the actor's methods.
+ * It also provides a way to interact with the actor's state.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:94-109
+ */
+export declare const createActorManager: <A = BaseActor>(options: ActorManagerOptions) => ActorManager<A>;
+/**
+ * The `CandidAdapter` class is used to interact with a canister and retrieve its Candid interface definition.
+ * It provides methods to fetch the Candid definition either from the canister's metadata or by using a temporary hack method.
+ * If both methods fail, it throws an error.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:164-205
+ */
+export declare const createCandidAdapter: (options: CandidAdapterOptions) => CandidAdapter;

package/dist/index.js

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 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) {
@@ -20,36 +34,40 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createReActor = void 0;
-const store_1 = require("@ic-reactor/store");
-const createReActor = (options) => {
-    const _a = (0, store_1.createReActorStore)(options), { agentManager, callMethod, actorStore } = _a, rest = __rest(_a, ["agentManager", "callMethod", "actorStore"]);
-    const { authStore } = agentManager, agentRest = __rest(agentManager, ["authStore"]);
-    const updateMethodState = (method, args = [], newState) => {
-        const hash = (0, store_1.generateRequestHash)(args);
-        actorStore.setState((state) => {
-            if (!state.methodState) {
-                console.error("Actor not initialized");
-                return state;
-            }
-            if (!state.methodState[method]) {
-                console.error(`Method ${String(method)} not found`);
-                return state;
-            }
-            const currentMethodState = state.methodState[method][hash] || {
-                loading: false,
-                data: undefined,
-                error: undefined,
-            };
-            return Object.assign(Object.assign({}, state), { methodState: Object.assign(Object.assign({}, state.methodState), { [method]: Object.assign(Object.assign({}, state.methodState[method]), { states: Object.assign(Object.assign({}, state.methodState[method].states), { [hash]: Object.assign(Object.assign({}, currentMethodState), newState) }) }) }) });
-        });
-        return hash;
-    };
+exports.createCandidAdapter = exports.createActorManager = exports.createAgentManager = exports.createReActorStore = exports.createReActor = void 0;
+const actor_1 = require("./actor");
+const agent_1 = require("./agent");
+const tools_1 = require("./tools");
+__exportStar(require("./types"), exports);
+__exportStar(require("./actor"), exports);
+__exportStar(require("./agent"), exports);
+__exportStar(require("./tools"), exports);
+/**
+ * Create a new actor manager with the given options.
+ * Its create a new agent manager if not provided.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:30-91
+ */
+const createReActor = (_a) => {
+    var { isLocalEnv, withProcessEnv = false } = _a, options = __rest(_a, ["isLocalEnv", "withProcessEnv"]);
+    isLocalEnv =
+        isLocalEnv ||
+            (withProcessEnv
+                ? typeof process !== "undefined" &&
+                    (process.env.DFX_NETWORK === "local" ||
+                        process.env.NODE_ENV === "development")
+                : false);
+    const _b = (0, exports.createReActorStore)(Object.assign({ isLocalEnv }, options)), { subscribeActorState, updateMethodState, callMethod, getState, agentManager } = _b, rest = __rest(_b, ["subscribeActorState", "updateMethodState", "callMethod", "getState", "agentManager"]);
     const reActorMethod = (functionName, ...args) => {
+        const requestHash = (0, tools_1.generateRequestHash)(args);
+        const updateState = (newState = {}) => {
+            updateMethodState(functionName, requestHash, newState);
+        };
+        updateState();
         try {
-            const requestHash = updateMethodState(functionName, args);
-            const getState = (key) => {
-                const state = actorStore.getState().methodState[functionName][requestHash];
+            const methodState = ((key) => {
+                const state = getState().methodState[functionName][requestHash];
                 switch (key) {
                     case "data":
                         return state.data;
@@ -60,9 +78,9 @@ const createReActor = (options) => {
                     default:
                         return state;
                 }
-            };
+            });
             const subscribe = (callback) => {
-                const unsubscribe = actorStore.subscribe((state) => {
+                const unsubscribe = subscribeActorState((state) => {
                     const methodState = state.methodState[functionName];
                     const methodStateHash = methodState[requestHash];
                     if (methodStateHash) {
@@ -72,57 +90,138 @@ const createReActor = (options) => {
                 return unsubscribe;
             };
             const call = (replaceArgs) => __awaiter(void 0, void 0, void 0, function* () {
-                updateMethodState(functionName, args, {
+                updateState({
                     loading: true,
                     error: undefined,
                 });
                 try {
                     const data = yield callMethod(functionName, ...(replaceArgs !== null && replaceArgs !== void 0 ? replaceArgs : args));
-                    updateMethodState(functionName, args, { data, loading: false });
+                    updateState({ data, loading: false });
                     return data;
                 }
                 catch (error) {
-                    updateMethodState(functionName, args, {
+                    updateState({
                         error: error,
                         loading: false,
                     });
-                    console.error(error);
+                    throw error;
                 }
             });
             return {
                 requestHash,
                 subscribe,
-                getState,
+                getState: methodState,
                 call,
             };
         }
         catch (error) {
-            updateMethodState(functionName, args, {
+            updateState({
                 error: error,
                 loading: false,
             });
             throw error;
         }
     };
-    const queryCall = ({ functionName, args = [], callOnMount = false, autoRefresh = false, refreshInterval = 5000, }) => {
+    const queryCall = ({ functionName, args = [], refetchOnMount = true, refetchInterval = false, }) => {
         let intervalId = null;
         const _a = reActorMethod(functionName, ...args), { call } = _a, rest = __rest(_a, ["call"]);
-        if (autoRefresh) {
+        if (refetchInterval) {
             intervalId = setInterval(() => {
                 call();
-            }, refreshInterval);
+            }, refetchInterval);
         }
-        let initialData = Promise.resolve();
-        if (callOnMount)
-            initialData = call();
-        return Object.assign(Object.assign({}, rest), { call, initialData, intervalId });
+        let dataPromise = Promise.resolve();
+        if (refetchOnMount)
+            dataPromise = call();
+        return Object.assign(Object.assign({}, rest), { call, dataPromise, intervalId });
     };
     const updateCall = ({ functionName, args = [] }) => {
         return reActorMethod(functionName, ...args);
     };
-    return Object.assign(Object.assign({ actorStore,
-        authStore,
-        queryCall,
-        updateCall }, agentRest), rest);
+    const login = (options) => __awaiter(void 0, void 0, void 0, function* () {
+        const authClient = agentManager.getAuthClient();
+        if (!authClient) {
+            yield agentManager.authenticate();
+        }
+        yield authClient.login(Object.assign({ identityProvider: isLocalEnv
+                ? "https://identity.ic0.app/#authorize"
+                : "http://rdmx6-jaaaa-aaaaa-aaadq-cai.localhost:4943/#authorize" }, options));
+    });
+    const logout = (options) => __awaiter(void 0, void 0, void 0, function* () {
+        const authClient = agentManager.getAuthClient();
+        if (!authClient) {
+            throw new Error("Auth client not initialized");
+        }
+        yield authClient.logout(options);
+        yield agentManager.authenticate();
+    });
+    return Object.assign(Object.assign({ queryCall,
+        updateCall,
+        callMethod,
+        getState,
+        login,
+        logout,
+        subscribeActorState }, agentManager), rest);
 };
 exports.createReActor = createReActor;
+/**
+ * Create a new actor manager with the given options.
+ * Its create a new agent manager if not provided.
+ * It also creates a new actor manager with the given options.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:32-45
+ */
+const createReActorStore = (options) => {
+    const { idlFactory, canisterId, withDevtools = false, initializeOnCreate = true, withVisitor = false, agentManager: maybeAgentManager } = options, agentOptions = __rest(options, ["idlFactory", "canisterId", "withDevtools", "initializeOnCreate", "withVisitor", "agentManager"]);
+    const agentManager = maybeAgentManager ||
+        (0, exports.createAgentManager)(Object.assign({ withDevtools }, agentOptions));
+    const actorManager = (0, exports.createActorManager)({
+        idlFactory,
+        canisterId,
+        agentManager,
+        withVisitor,
+        withDevtools,
+        initializeOnCreate,
+    });
+    return actorManager;
+};
+exports.createReActorStore = createReActorStore;
+/**
+ * Agent manager handles the lifecycle of the `@dfinity/agent`.
+ * It is responsible for creating agent and managing the agent's state.
+ * You can use it to subscribe to the agent changes.
+ * login and logout to the internet identity.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:55-86
+ */
+const createAgentManager = (options) => {
+    return new agent_1.AgentManager(options);
+};
+exports.createAgentManager = createAgentManager;
+/**
+ * Actor manager handles the lifecycle of the actors.
+ * It is responsible for creating and managing the actors.
+ * You can use it to call and visit the actor's methods.
+ * It also provides a way to interact with the actor's state.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:94-109
+ */
+const createActorManager = (options) => {
+    return new actor_1.ActorManager(options);
+};
+exports.createActorManager = createActorManager;
+/**
+ * The `CandidAdapter` class is used to interact with a canister and retrieve its Candid interface definition.
+ * It provides methods to fetch the Candid definition either from the canister's metadata or by using a temporary hack method.
+ * If both methods fail, it throws an error.
+ *
+ * @category Main
+ * @includeExample ./packages/core/README.md:164-205
+ */
+const createCandidAdapter = (options) => {
+    return new tools_1.CandidAdapter(options);
+};
+exports.createCandidAdapter = createCandidAdapter;

package/dist/tools/candid.d.ts

@@ -0,0 +1,15 @@
+import { HttpAgent } from "@dfinity/agent";
+import { CanisterId } from "../actor";
+import { CandidAdapterOptions, CandidDefenition } from "./types";
+export declare const DEFAULT_LOCAL_DIDJS_ID = "bd3sg-teaaa-aaaaa-qaaba-cai";
+export declare const DEFAULT_IC_DIDJS_ID = "a4gq6-oaaaa-aaaab-qaa4q-cai";
+export declare class CandidAdapter {
+    agent: HttpAgent;
+    didjsCanisterId: string;
+    constructor({ agentManager, agent, didjsCanisterId }: CandidAdapterOptions);
+    private getDefaultDidJsId;
+    getCandidDefinition(canisterId: CanisterId): Promise<CandidDefenition>;
+    getFromMetadata(canisterId: CanisterId): Promise<CandidDefenition | undefined>;
+    getFromTmpHack(canisterId: CanisterId): Promise<CandidDefenition | undefined>;
+    didTojs(candidSource: string): Promise<CandidDefenition>;
+}

package/dist/tools/candid.js

@@ -0,0 +1,97 @@
+"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 = exports.DEFAULT_IC_DIDJS_ID = exports.DEFAULT_LOCAL_DIDJS_ID = void 0;
+const agent_1 = require("@dfinity/agent");
+const principal_1 = require("@dfinity/principal");
+exports.DEFAULT_LOCAL_DIDJS_ID = "bd3sg-teaaa-aaaaa-qaaba-cai";
+exports.DEFAULT_IC_DIDJS_ID = "a4gq6-oaaaa-aaaab-qaa4q-cai";
+class CandidAdapter {
+    constructor({ agentManager, agent, didjsCanisterId }) {
+        if (agent) {
+            this.agent = agent;
+        }
+        else if (agentManager) {
+            this.agent = agentManager.getAgent();
+            agentManager.subscribeAgent((agent) => {
+                this.agent = agent;
+                this.didjsCanisterId = didjsCanisterId || this.getDefaultDidJsId();
+            });
+        }
+        else {
+            throw new Error("No agent or agentManager provided");
+        }
+        this.didjsCanisterId = didjsCanisterId || this.getDefaultDidJsId();
+    }
+    getDefaultDidJsId() {
+        return this.agent.isLocal() ? exports.DEFAULT_LOCAL_DIDJS_ID : exports.DEFAULT_IC_DIDJS_ID;
+    }
+    getCandidDefinition(canisterId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // First attempt: Try getting Candid definition from metadata
+            const fromMetadata = yield this.getFromMetadata(canisterId);
+            if (fromMetadata)
+                return fromMetadata;
+            // Second attempt: Try the temporary hack method
+            const fromTmpHack = yield this.getFromTmpHack(canisterId);
+            if (fromTmpHack)
+                return fromTmpHack;
+            // If both attempts fail, throw an error
+            throw new Error("Failed to retrieve Candid definition by any method.");
+        });
+    }
+    getFromMetadata(canisterId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof canisterId === "string") {
+                canisterId = principal_1.Principal.fromText(canisterId);
+            }
+            const status = yield agent_1.CanisterStatus.request({
+                agent: this.agent,
+                canisterId,
+                paths: ["candid"],
+            });
+            const did = status.get("candid");
+            return did ? this.didTojs(did) : undefined;
+        });
+    }
+    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,
+            });
+            const data = (yield actor.__get_candid_interface_tmp_hack());
+            return data ? this.didTojs(data) : undefined;
+        });
+    }
+    didTojs(candidSource) {
+        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: this.didjsCanisterId,
+            });
+            const js = yield didjs.did_to_js(candidSource);
+            if (JSON.stringify(js) === JSON.stringify([])) {
+                throw new Error("Cannot fetch candid file");
+            }
+            const dataUri = "data:text/javascript;charset=utf-8," +
+                encodeURIComponent(js[0]);
+            return eval('import("' + dataUri + '")');
+        });
+    }
+}
+exports.CandidAdapter = CandidAdapter;