@ic-reactor/core 1.0.1 → 1.0.3

package/README.md

@@ -1,4 +1,4 @@
-The `@ic-reactor/core` package provides a streamlined way to interact with the Internet Computer (IC) by simplifying agent and actor management. It offers utilities for creating and managing IC agents, enabling seamless communication with canisters through a friendly API.
+The `@ic-reactor/core` package provides a streamlined way to interact with the Internet Computer (IC). It simplifies agent and actor management, ensuring type-safe communication with canisters. This package offers utilities for creating and managing IC agents, enabling seamless interaction through a friendly API.
 
 ## Installation
 
@@ -16,111 +16,92 @@ npm install @ic-reactor/core
 yarn add @ic-reactor/core
 ```
 
-## Usage
+### Using `createReactorCore`
 
-`@ic-reactor/core` can be utilized in two primary ways: automatic agent creation and manual agent management. Below are examples of both approaches to suit your project's needs.
-
-### Automatic Agent Creation
-
-For ease of use, the `createReActorStore` factory function automatically sets up a new ReActor store instance, managing the agent and its state internally.
+For ease of use, the `createReactorCore` factory function automatically sets up a new Reactor instance, managing the agent and its state internally, and providing a simple API for authenticating, querying, and updating actors.
 
 **Example:**
 
 ```typescript
-import { createReActorStore } from "@ic-reactor/core"
-import { candid, canisterId, idlFactory } from "./candid"
+import { createReactorCore } from "@ic-reactor/core"
+import { candid, canisterId, idlFactory } from "./declarations/candid"
 
 type Candid = typeof candid
 
-const { callMethod, authenticate } = createReActor<Candid>({
-  canisterId,
-  idlFactory,
-})
-
-// Usage example
-const identity = await authenticate()
-const data = await callMethod("version")
-console.log(data)
-```
-
-### Manual Agent Creation
-
-If you require more control over the agent's lifecycle or configuration, `@ic-reactor/core` provides the `createAgentManager` function for manual agent instantiation.
-
-**IC Agent Example:**
-
-```typescript
-// agent.ts
-import { createAgentManager } from "@ic-reactor/core"
-
-export const agentManager = createAgentManager() // Connects to IC network by default
-
-// Usage example
-await agentManager.authenticate()
-// Then use the store to access the authClient, identity, and more...
-const { authClient, identity, authenticating } =
-  agentManager.authStore.getState()
+const { queryCall, updateCall, getPrincipal, login } =
+  createReactorCore<Candid>({
+    canisterId,
+    idlFactory,
+    withProcessEnv: true, // will use process.env.DFX_NETWORK
+  })
 ```
 
-**Local Agent Example:**
-
-For development purposes, you might want to connect to a local instance of the IC network:
+You can find All available methods are returned from the `createReactorCore` function here: [ReactorCore](https://b3pay.github.io/ic-reactor/interfaces/core.types.ReactorCore.html)
 
 ```typescript
-// agent.ts
-import { createAgentManager } from "@ic-reactor/core"
-
-export const agentManager = createAgentManager({
-  isLocalEnv: true,
-  port: 8000, // Default port is 4943
+// later in your code
+await login({
+  onSuccess: () => {
+    console.log("Logged in successfully")
+  },
+  onError: (error) => {
+    console.error("Failed to login:", error)
+  },
 })
-```
 
-Alternatively, you can specify a host directly:
-
-```typescript
-export const agentManager = createAgentManager({
-  host: "http://localhost:8000",
+// queryCall, will automatically call and return a promise with the result
+const { dataPromise, call } = queryCall({
+  functionName: "icrc1_balance_of",
+  args: [{ owner: getPrincipal(), subaccount: [] }],
 })
-```
-
-### Creating an Actor Manager
-
-Once you have an agent manager, use `createActorManager` to instantiate an actor manager for calling methods on your canisters.
-
-```typescript
-// actor.ts
-import { createActorManager } from "@ic-reactor/core"
-import { candid, canisterId, idlFactory } from "./candid"
-import { agentManager } from "./agent"
 
-type Candid = typeof candid
-
-const candidActor = createActorManager<Candid>({
-  agentManager,
-  canisterId,
-  idlFactory,
+console.log(await dataPromise)
+
+// updateCall
+const { call, subscribe } = updateCall({
+  functionName: "icrc1_transfer",
+  args: [
+    {
+      to: { owner: getPrincipal(), subaccount: [] },
+      amount: BigInt(10000000000),
+      fee: [],
+      memo: [],
+      created_at_time: [],
+      from_subaccount: [],
+    },
+  ],
+})
+// subscribe to the update call
+subscribe(({ loading, error, data }) => {
+  console.log({ loading, error, data })
 })
 
-// Usage example
-const data = await candidActor.callMethod("version")
-console.log(data)
+const result = await call()
+console.log(result)
 ```
 
 ### Managing Multiple Actors
 
-When interacting with multiple canisters using `@ic-reactor/core`, you can create separate actor managers for each canister. This enables modular interaction with different services on the Internet Computer. Here's how to adjust the example to handle methods that require multiple arguments:
+When interacting with multiple canisters using `@ic-reactor/core`, you need one agent manager for each canister. This way, you can create separate reactor for each canister. This enables modular interaction with different services on the Internet Computer,
+and allows you to manage the state of each actor independently.
+Here's how to adjust the example to handle methods that require multiple arguments:
 
-**Creating Actor Managers:**
-
-First, ensure you have your actor managers set up for each canister:
+Fist you need to create a agent manager:
 
 ```typescript
-// Assuming you've already set up `candidA`, `candidB`, `canisterIdA`, `canisterIdB`, and `agentManager`
+// agent.ts
+import { createAgentManager } from "@ic-reactor/core"
 
+export const agentManager = createAgentManager() // Connects to IC network by default
+```
+
+Then you can create a reactor for each canister:
+
+```typescript
+// Assuming you've already set up `candidA`, `candidB`, and `agentManager`
 import { createActorManager } from "@ic-reactor/core"
-import { candidA, canisterIdA } from "./candidA"
-import { candidB, canisterIdB } from "./candidB"
+import candidA from "./declarations/candidA"
+import candidB from "./declarations/candidB"
 import { agentManager } from "./agent"
 
 type CandidA = typeof candidA
@@ -139,18 +120,20 @@ const actorB = createActorManager<CandidB>({
 })
 ```
 
-### Using `callMethod` with Multiple Arguments
-
-To call a method on a canister that requires multiple arguments, pass the method name followed by the arguments as separate parameters to `callMethod`:
+You can now use the `actorA` and `actorB` instances to interact with their respective canisters:
 
 ```typescript
 // Example usage with CanisterA calling a method that requires one argument
-const responseA = await actorA.callMethod("otherMethod", "arg1")
-console.log("Response from CanisterA method:", responseA)
+const { dataPromise: versionActorA } = actorA.queryCall({
+  functionName: "version",
+})
+console.log("Response from CanisterA method:", await versionActorA)
 
 // Example usage with CanisterB calling a different method also with two arguments
-const responseB = await actorB.callMethod("anotherMethod", "arg1", "arg2")
-console.log("Response from CanisterB method:", responseB)
+const { dataPromise: versionActorB } = actorB.queryCall({
+  functionName: "version",
+})
+console.log("Response from CanisterB method:", await versionActorB)
 ```
 
 ### Using Candid Adapter
@@ -175,12 +158,12 @@ try {
 }
 ```
 
-### Using `createReActorStore` with `CandidAdapter`
+### Using `createReactorCore` with `CandidAdapter`
 
-You can use the `candidAdapter` to fetch the Candid definition and then pass it to the `createReActorStore` function.
+You can use the `candidAdapter` to fetch the Candid definition and then pass it to the `createReactorCore` function.
 
 ```typescript
-import { createReActorStore, createCandidAdapter } from "@ic-reactor/core"
+import { createReactorCore, createCandidAdapter } from "@ic-reactor/core"
 import { agentManager } from "./agent"
 
 const candidAdapter = createCandidAdapter({ agentManager })
@@ -190,7 +173,7 @@ const canisterId = "ryjl3-tyaaa-aaaaa-aaaba-cai" // NNS ICP Ledger Canister
 // Usage example
 try {
   const { idlFactory } = await candidAdapter.getCandidDefinition(canisterId)
-  const { callMethod } = createReActorStore({
+  const { callMethod } = createReactorCore({
     agentManager,
     canisterId,
     idlFactory,
@@ -202,3 +185,94 @@ try {
   console.error(error)
 }
 ```
+
+### Using store to lower level control
+
+If you require more control over the state management, you can use the `createReactorStore` function to create a store that provides methods for querying and updating actors.
+
+```typescript
+import { createReactorStore } from "@ic-reactor/core"
+import { candid, canisterId, idlFactory } from "./declarations/candid"
+
+type Candid = typeof candid
+
+const { agentManager, callMethod } = createReactorStore<Candid>({
+  canisterId,
+  idlFactory,
+})
+
+// Usage example
+await agentManager.authenticate()
+const authClient = agentManager.getAuthClient()
+
+authClient?.login({
+  onSuccess: () => {
+    console.log("Logged in successfully")
+  },
+  onError: (error) => {
+    console.error("Failed to login:", error)
+  },
+})
+
+// Call a method
+const version = callMethod("version")
+
+console.log("Response from version method:", await version)
+```
+
+**IC Agent Example:**
+
+```typescript
+// agent.ts
+import { createAgentManager } from "@ic-reactor/core"
+
+export const agentManager = createAgentManager() // Connects to IC network by default
+```
+
+**Local Agent Example:**
+
+For development purposes, you might want to connect to a local instance of the IC network:
+
+```typescript
+// agent.ts
+import { createAgentManager } from "@ic-reactor/core"
+
+export const agentManager = createAgentManager({
+  isLocalEnv: true,
+  port: 8000, // Default port is 4943
+})
+```
+
+Alternatively, you can specify a host directly:
+
+```typescript
+// agent.ts
+import { createAgentManager } from "@ic-reactor/core"
+
+export const agentManager = createAgentManager({
+  host: "http://localhost:8000",
+})
+```
+
+### Creating an Actor Manager
+
+You can use Actor Managers to create your implementation of an actor. This allows you to manage the actor's lifecycle and state, as well as interact with the actor's methods.
+
+```typescript
+// actor.ts
+import { createActorManager } from "@ic-reactor/core"
+import { candid, canisterId, idlFactory } from "./declarations/candid"
+import { agentManager } from "./agent"
+
+type Candid = typeof candid
+
+const candidActor = createActorManager<Candid>({
+  agentManager,
+  canisterId,
+  idlFactory,
+})
+
+// Usage example
+const data = await candidActor.callMethod("version")
+console.log(data)
+```

package/dist/actor/index.d.ts

@@ -1,4 +1,3 @@
-import type { HttpAgent } from "@dfinity/agent";
 import type { CanisterId, ActorMethodArgs, ActorMethodReturnType, ActorStore, ActorManagerOptions, FunctionName, VisitService, BaseActor, ActorMethodState } from "./types";
 import type { AgentManager } from "../agent";
 import type { UpdateAgentOptions } from "../types";
@@ -10,7 +9,6 @@ export declare class ActorManager<A = BaseActor> {
     actorStore: ActorStore<A>;
     visitFunction: VisitService<A>;
     private initialState;
-    unsubscribeActor: () => void;
     private updateState;
     updateMethodState: (method: FunctionName<A>, hash: string, newState: Partial<{
         data: ActorMethodReturnType<A[FunctionName<A>]> | undefined;
@@ -23,7 +21,6 @@ export declare class ActorManager<A = BaseActor> {
     private initializeActor;
     callMethod: <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodArgs<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
     get agentManager(): AgentManager;
-    getAgent: () => HttpAgent;
     getActor: () => A | null;
     getState: ActorStore<A>["getState"];
     subscribeActorState: ActorStore<A>["subscribe"];

package/dist/actor/index.js

@@ -29,11 +29,7 @@ class ActorManager {
         this.updateMethodState = (method, hash, newState) => {
             this.actorStore.setState((state) => {
                 const methodState = state.methodState[method] || {};
-                const currentMethodState = methodState[hash] || {
-                    loading: false,
-                    data: undefined,
-                    error: undefined,
-                };
+                const currentMethodState = methodState[hash] || DEFAULT_STATE;
                 const updatedMethodState = Object.assign(Object.assign({}, methodState), { [hash]: Object.assign(Object.assign({}, currentMethodState), newState) });
                 return Object.assign(Object.assign({}, state), { methodState: Object.assign(Object.assign({}, state.methodState), { [method]: updatedMethodState }) });
             });
@@ -82,9 +78,6 @@ class ActorManager {
             const data = yield method(...args);
             return data;
         });
-        this.getAgent = () => {
-            return this._agentManager.getAgent();
-        };
         // actor store
         this.getActor = () => {
             return this._actor;
@@ -100,11 +93,11 @@ class ActorManager {
         };
         const { agentManager, canisterId, idlFactory, withVisitor = false, withDevtools = false, initializeOnCreate = true, } = actorConfig;
         this._agentManager = agentManager;
-        this.unsubscribeActor = this._agentManager.subscribeAgent(this.initializeActor);
+        this._agentManager.subscribeAgent(this.initializeActor);
         this.canisterId = canisterId;
         this._idlFactory = idlFactory;
         if (withVisitor) {
-            this.visitFunction = this.extractService();
+            this.visitFunction = withVisitor ? this.extractService() : emptyVisitor;
         }
         else {
             this.visitFunction = emptyVisitor;
@@ -140,3 +133,4 @@ const emptyVisitor = new Proxy({}, {
         throw new Error(`Cannot visit function "${String(prop)}" without initializing the actor with the visitor option, please set the withVisitor option to true when creating the actor manager.`);
     },
 });
+const DEFAULT_STATE = { data: undefined, error: undefined, loading: false };

package/dist/actor/types.d.ts

@@ -26,21 +26,21 @@ export type VisitService<A = BaseActor, M extends FunctionName<A> = FunctionName
 };
 export type ActorMethodArgs<T> = T extends ActorMethod<infer Args, any> ? Args : never;
 export type ActorMethodReturnType<T> = T extends ActorMethod<any, infer Ret> ? Ret : never;
-export interface ActorMethodState<A, M extends keyof A> {
+export interface ActorMethodState<A = BaseActor, M extends FunctionName<A> = FunctionName<A>> {
     [key: string]: {
         data: ActorMethodReturnType<A[M]> | undefined;
         loading: boolean;
         error: Error | undefined;
     };
 }
-export type ActorMethodStates<A> = {
-    [M in keyof A]: ActorMethodState<A, M>;
+export type ActorMethodStates<A = BaseActor> = {
+    [M in FunctionName<A>]: ActorMethodState<A, M>;
 };
-export type ActorState<A> = {
+export type ActorState<A = BaseActor> = {
     initialized: boolean;
     initializing: boolean;
     error: Error | undefined;
     methodState: ActorMethodStates<A>;
 };
 export type ActorStore<A = BaseActor> = StoreApi<ActorState<A>>;
-export type CallActorMethod<A = BaseActor> = <M extends keyof A>(functionName: M, ...args: ActorMethodArgs<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
+export type CallActorMethod<A = BaseActor> = <M extends FunctionName<A> = FunctionName<A>>(functionName: M, ...args: ActorMethodArgs<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;

package/dist/agent/index.d.ts

@@ -1,7 +1,5 @@
 import { HttpAgent } from "@dfinity/agent";
 import type { AgentStore, AgentManagerOptions, UpdateAgentOptions, AuthStore } from "./types";
-export declare const IC_HOST_NETWORK_URI = "https://ic0.app";
-export declare const LOCAL_HOST_NETWORK_URI = "http://127.0.0.1:4943";
 export declare class AgentManager {
     private _agent;
     private _subscribers;
@@ -20,7 +18,6 @@ export declare class AgentManager {
     updateAgent: (options?: UpdateAgentOptions) => Promise<void>;
     authenticate: () => Promise<import("@dfinity/agent").Identity>;
     getAgent: () => HttpAgent;
-    getAgentStore: () => AgentStore;
     getAgentState: AgentStore["getState"];
     subscribeAgentState: AgentStore["subscribe"];
     getAuthState: AuthStore["getState"];

package/dist/agent/index.js

@@ -43,11 +43,10 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentManager = exports.LOCAL_HOST_NETWORK_URI = exports.IC_HOST_NETWORK_URI = void 0;
+exports.AgentManager = void 0;
 const agent_1 = require("@dfinity/agent");
 const helper_1 = require("../tools/helper");
-exports.IC_HOST_NETWORK_URI = "https://ic0.app";
-exports.LOCAL_HOST_NETWORK_URI = "http://127.0.0.1:4943";
+const constants_1 = require("../tools/constants");
 class AgentManager {
     constructor(options) {
         this._subscribers = [];
@@ -133,9 +132,6 @@ class AgentManager {
         this.getAgent = () => {
             return this._agent;
         };
-        this.getAgentStore = () => {
-            return this.agentStore;
-        };
         this.getAgentState = () => {
             return this.agentStore.getState();
         };
@@ -166,7 +162,7 @@ class AgentManager {
                 ? optionHost.includes("localhost")
                     ? optionHost.replace("localhost", "127.0.0.1")
                     : optionHost
-                : exports.IC_HOST_NETWORK_URI;
+                : constants_1.IC_HOST_NETWORK_URI;
         this.agentStore = (0, helper_1.createStoreWithOptionalDevtools)(this.initialAgentState, {
             withDevtools,
             store: "agent",

package/dist/{tools/candid.d.ts → candid/index.d.ts}

@@ -1,7 +1,5 @@
 import { HttpAgent } from "@dfinity/agent";
 import type { CanisterId, 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;

package/dist/{tools/candid.js → candid/index.js}

@@ -9,11 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CandidAdapter = exports.DEFAULT_IC_DIDJS_ID = exports.DEFAULT_LOCAL_DIDJS_ID = void 0;
+exports.CandidAdapter = 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";
+const constants_1 = require("../tools/constants");
 class CandidAdapter {
     constructor({ agentManager, agent, didjsCanisterId }) {
         if (agent) {
@@ -32,7 +31,7 @@ class CandidAdapter {
         this.didjsCanisterId = didjsCanisterId || this.getDefaultDidJsId();
     }
     getDefaultDidJsId() {
-        return this.agent.isLocal() ? exports.DEFAULT_LOCAL_DIDJS_ID : exports.DEFAULT_IC_DIDJS_ID;
+        return this.agent.isLocal() ? constants_1.DEFAULT_LOCAL_DIDJS_ID : constants_1.DEFAULT_IC_DIDJS_ID;
     }
     getCandidDefinition(canisterId) {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/index.d.ts

@@ -1,49 +1,8 @@
-import { ActorManager } from "./actor";
-import { AgentManager } from "./agent";
-import { CandidAdapter } from "./tools";
-import type { ActorManagerOptions, BaseActor, AgentManagerOptions, ActorCoreActions, CreateReActorOptions, CreateReActorStoreOptions, CandidAdapterOptions } from "./types";
-/**
- * Create a new actor manager with the given options.
- * Its create a new agent manager if not provided.
- *
- * @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.
- *
- * @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.
- *
- * @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.
- *
- * @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.
- *
- * @includeExample ./packages/core/README.md:164-205
- */
-export declare const createCandidAdapter: (options: CandidAdapterOptions) => CandidAdapter;
+export * from "./main";
+export * from "./store";
+export * from "./other";
+export * from "./actor";
+export * from "./agent";
+export * from "./candid";
 export * as types from "./types";
-export * as actor from "./actor";
-export * as agent from "./agent";
 export * as tools from "./tools";

package/dist/index.js

@@ -15,6 +15,9 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 = {};
@@ -22,210 +25,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.tools = exports.agent = exports.actor = exports.types = 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");
-/**
- * Create a new actor manager with the given options.
- * Its create a new agent manager if not provided.
- *
- * @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 methodState = ((key) => {
-                const state = getState().methodState[functionName][requestHash];
-                switch (key) {
-                    case "data":
-                        return state.data;
-                    case "loading":
-                        return state.loading;
-                    case "error":
-                        return state.error;
-                    default:
-                        return state;
-                }
-            });
-            const subscribe = (callback) => {
-                const unsubscribe = subscribeActorState((state) => {
-                    const methodState = state.methodState[functionName];
-                    const methodStateHash = methodState[requestHash];
-                    if (methodStateHash) {
-                        callback(methodStateHash);
-                    }
-                });
-                return unsubscribe;
-            };
-            const call = (replaceArgs) => __awaiter(void 0, void 0, void 0, function* () {
-                updateState({
-                    loading: true,
-                    error: undefined,
-                });
-                try {
-                    const data = yield callMethod(functionName, ...(replaceArgs !== null && replaceArgs !== void 0 ? replaceArgs : args));
-                    updateState({ data, loading: false });
-                    return data;
-                }
-                catch (error) {
-                    updateState({
-                        error: error,
-                        loading: false,
-                    });
-                    throw error;
-                }
-            });
-            return {
-                requestHash,
-                subscribe,
-                getState: methodState,
-                call,
-            };
-        }
-        catch (error) {
-            updateState({
-                error: error,
-                loading: false,
-            });
-            throw error;
-        }
-    };
-    const queryCall = ({ functionName, args = [], refetchOnMount = true, refetchInterval = false, }) => {
-        let intervalId = null;
-        const _a = reActorMethod(functionName, ...args), { call } = _a, rest = __rest(_a, ["call"]);
-        if (refetchInterval) {
-            intervalId = setInterval(() => {
-                call();
-            }, refetchInterval);
-        }
-        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);
-    };
-    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.
- *
- * @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.
- *
- * @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.
- *
- * @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.
- *
- * @includeExample ./packages/core/README.md:164-205
- */
-const createCandidAdapter = (options) => {
-    return new tools_1.CandidAdapter(options);
-};
-exports.createCandidAdapter = createCandidAdapter;
+exports.tools = exports.types = void 0;
+__exportStar(require("./main"), exports);
+__exportStar(require("./store"), exports);
+__exportStar(require("./other"), exports);
+__exportStar(require("./actor"), exports);
+__exportStar(require("./agent"), exports);
+__exportStar(require("./candid"), exports);
 exports.types = __importStar(require("./types"));
-exports.actor = __importStar(require("./actor"));
-exports.agent = __importStar(require("./agent"));
 exports.tools = __importStar(require("./tools"));

package/dist/main.d.ts

@@ -0,0 +1,10 @@
+import type { BaseActor, ReactorCore, CreateReactorOptions } from "./types";
+/**
+ * The Core module is the main entry point for the library.
+ * 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:26-80
+ */
+export declare const createReactorCore: <A = BaseActor>({ isLocalEnv, withProcessEnv, ...options }: CreateReactorOptions) => ReactorCore<A>;

package/dist/main.js

@@ -0,0 +1,146 @@
+"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.createReactorCore = void 0;
+const constants_1 = require("./tools/constants");
+const tools_1 = require("./tools");
+const store_1 = require("./store");
+/**
+ * The Core module is the main entry point for the library.
+ * 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:26-80
+ */
+const createReactorCore = (_a) => {
+    var { isLocalEnv, withProcessEnv = false } = _a, options = __rest(_a, ["isLocalEnv", "withProcessEnv"]);
+    isLocalEnv = isLocalEnv || (withProcessEnv ? (0, tools_1.isInLocalOrDevelopment)() : false);
+    const _b = (0, store_1.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 methodState = ((key) => {
+                const state = getState().methodState[functionName][requestHash];
+                switch (key) {
+                    case "data":
+                        return state.data;
+                    case "loading":
+                        return state.loading;
+                    case "error":
+                        return state.error;
+                    default:
+                        return state;
+                }
+            });
+            const subscribe = (callback) => {
+                const unsubscribe = subscribeActorState((state) => {
+                    const methodState = state.methodState[functionName];
+                    const methodStateHash = methodState[requestHash];
+                    if (methodStateHash) {
+                        callback(methodStateHash);
+                    }
+                });
+                return unsubscribe;
+            };
+            const call = (replaceArgs) => __awaiter(void 0, void 0, void 0, function* () {
+                updateState({
+                    loading: true,
+                    error: undefined,
+                });
+                try {
+                    const data = yield callMethod(functionName, ...(replaceArgs !== null && replaceArgs !== void 0 ? replaceArgs : args));
+                    updateState({ data, loading: false });
+                    return data;
+                }
+                catch (error) {
+                    updateState({
+                        error: error,
+                        loading: false,
+                    });
+                    throw error;
+                }
+            });
+            return {
+                requestHash,
+                subscribe,
+                getState: methodState,
+                call,
+            };
+        }
+        catch (error) {
+            updateState({
+                error: error,
+                loading: false,
+            });
+            throw error;
+        }
+    };
+    const queryCall = ({ functionName, args = [], refetchOnMount = true, refetchInterval = false, }) => {
+        let intervalId = null;
+        const _a = reActorMethod(functionName, ...args), { call } = _a, rest = __rest(_a, ["call"]);
+        if (refetchInterval) {
+            intervalId = setInterval(() => {
+                call();
+            }, refetchInterval);
+        }
+        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);
+    };
+    const login = (options) => __awaiter(void 0, void 0, void 0, function* () {
+        const authClient = agentManager.getAuthClient();
+        if (!authClient) {
+            yield agentManager.authenticate();
+        }
+        if (!authClient) {
+            throw new Error("Auth client not initialized");
+        }
+        yield authClient.login(Object.assign({ identityProvider: isLocalEnv
+                ? constants_1.IC_INTERNET_IDENTITY_PROVIDER
+                : constants_1.LOCAL_INTERNET_IDENTITY_PROVIDER }, 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.createReactorCore = createReactorCore;

package/dist/other.d.ts

@@ -0,0 +1,33 @@
+import { ActorManager } from "./actor";
+import { AgentManager } from "./agent";
+import { CandidAdapter } from "./candid";
+import { ActorManagerOptions, AgentManagerOptions, BaseActor, CandidAdapterOptions } from "./types";
+/**
+ * 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:145-186
+ */
+export declare const createCandidAdapter: (options: CandidAdapterOptions) => CandidAdapter;
+/**
+ * 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:226-254
+ */
+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:262-277
+ */
+export declare const createActorManager: <A = BaseActor>(options: ActorManagerOptions) => ActorManager<A>;

package/dist/other.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActorManager = exports.createAgentManager = exports.createCandidAdapter = void 0;
+const actor_1 = require("./actor");
+const agent_1 = require("./agent");
+const candid_1 = require("./candid");
+/**
+ * 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:145-186
+ */
+const createCandidAdapter = (options) => {
+    return new candid_1.CandidAdapter(options);
+};
+exports.createCandidAdapter = createCandidAdapter;
+/**
+ * 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:226-254
+ */
+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:262-277
+ */
+const createActorManager = (options) => {
+    return new actor_1.ActorManager(options);
+};
+exports.createActorManager = createActorManager;

package/dist/store.d.ts

@@ -0,0 +1,11 @@
+import { ActorManager } from "./actor";
+import type { BaseActor, CreateReactorStoreOptions } from "./types";
+/**
+ * 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:194-220
+ */
+export declare const createReactorStore: <A = BaseActor>(options: CreateReactorStoreOptions) => ActorManager<A>;

package/dist/store.js

@@ -0,0 +1,38 @@
+"use strict";
+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.createReactorStore = void 0;
+const other_1 = require("./other");
+/**
+ * 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:194-220
+ */
+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, other_1.createAgentManager)(Object.assign({ withDevtools }, agentOptions));
+    const actorManager = (0, other_1.createActorManager)({
+        idlFactory,
+        canisterId,
+        agentManager,
+        withVisitor,
+        withDevtools,
+        initializeOnCreate,
+    });
+    return actorManager;
+};
+exports.createReactorStore = createReactorStore;

package/dist/tools/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const IC_HOST_NETWORK_URI = "https://ic0.app";
+export declare const LOCAL_HOST_NETWORK_URI = "http://127.0.0.1:4943";
+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 const IC_INTERNET_IDENTITY_PROVIDER = "https://identity.ic0.app/#authorize";
+export declare const LOCAL_INTERNET_IDENTITY_PROVIDER = "http://rdmx6-jaaaa-aaaaa-aaadq-cai.localhost:4943/#authorize";

package/dist/tools/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCAL_INTERNET_IDENTITY_PROVIDER = exports.IC_INTERNET_IDENTITY_PROVIDER = exports.DEFAULT_IC_DIDJS_ID = exports.DEFAULT_LOCAL_DIDJS_ID = exports.LOCAL_HOST_NETWORK_URI = exports.IC_HOST_NETWORK_URI = void 0;
+exports.IC_HOST_NETWORK_URI = "https://ic0.app";
+exports.LOCAL_HOST_NETWORK_URI = "http://127.0.0.1:4943";
+exports.DEFAULT_LOCAL_DIDJS_ID = "bd3sg-teaaa-aaaaa-qaaba-cai";
+exports.DEFAULT_IC_DIDJS_ID = "a4gq6-oaaaa-aaaab-qaa4q-cai";
+exports.IC_INTERNET_IDENTITY_PROVIDER = "https://identity.ic0.app/#authorize";
+exports.LOCAL_INTERNET_IDENTITY_PROVIDER = "http://rdmx6-jaaaa-aaaaa-aaadq-cai.localhost:4943/#authorize";

package/dist/tools/helper.d.ts

@@ -8,7 +8,8 @@ export declare function createStoreWithOptionalDevtools<T>(initialState: T, opti
         type: string;
     }>(partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean | undefined, action?: A | undefined): void;
 };
-export declare function jsonToString(json: unknown): string;
+export declare const isInLocalOrDevelopment: () => boolean;
+export declare const jsonToString: (json: unknown) => string;
 export declare const generateRequestHash: (args?: unknown[]) => `0x${string}`;
 export declare const generateHash: (field?: unknown) => `0x${string}`;
 export declare const generateActorHash: (actor: BaseActor) => `0x${string}`;

package/dist/tools/helper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringToHash = exports.generateActorHash = exports.generateHash = exports.generateRequestHash = exports.jsonToString = exports.createStoreWithOptionalDevtools = void 0;
+exports.stringToHash = exports.generateActorHash = exports.generateHash = exports.generateRequestHash = exports.jsonToString = exports.isInLocalOrDevelopment = exports.createStoreWithOptionalDevtools = void 0;
 const agent_1 = require("@dfinity/agent");
 const candid_1 = require("@dfinity/candid");
 const middleware_1 = require("zustand/middleware");
@@ -8,7 +8,7 @@ const vanilla_1 = require("zustand/vanilla");
 function createStoreWithOptionalDevtools(initialState, options) {
     if (options.withDevtools) {
         return (0, vanilla_1.createStore)((0, middleware_1.devtools)(() => initialState, {
-            name: "ReActor",
+            name: "Reactor",
             store: options.store,
         }));
     }
@@ -17,9 +17,15 @@ function createStoreWithOptionalDevtools(initialState, options) {
     }
 }
 exports.createStoreWithOptionalDevtools = createStoreWithOptionalDevtools;
-function jsonToString(json) {
+const isInLocalOrDevelopment = () => {
+    return (typeof process !== "undefined" &&
+        (process.env.DFX_NETWORK === "local" ||
+            process.env.NODE_ENV === "development"));
+};
+exports.isInLocalOrDevelopment = isInLocalOrDevelopment;
+const jsonToString = (json) => {
     return JSON.stringify(json, (_, value) => (typeof value === "bigint" ? `BigInt(${value})` : value), 2);
-}
+};
 exports.jsonToString = jsonToString;
 const generateRequestHash = (args = []) => {
     const serializedArgs = args

package/dist/tools/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./candid";
 export * from "./helper";
+export * from "./constants";

package/dist/tools/index.js

@@ -14,5 +14,5 @@ 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);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./candid"), exports);
 __exportStar(require("./helper"), exports);
+__exportStar(require("./constants"), exports);

package/dist/types.d.ts

@@ -8,13 +8,13 @@ import type { AgentManager } from "./agent";
 import type { AuthClientLoginOptions } from "@dfinity/auth-client";
 export * from "./agent/types";
 export * from "./actor/types";
-export * from "./tools/types";
+export * from "./candid/types";
 export type { ActorMethod, HttpAgentOptions, ActorSubclass, Principal, HttpAgent, Identity, IDL, };
-export interface CreateReActorOptions extends CreateReActorStoreOptions {
+export interface CreateReactorOptions extends CreateReactorStoreOptions {
+    withProcessEnv?: boolean;
 }
-export interface CreateReActorStoreOptions extends HttpAgentOptions, Omit<ActorManagerOptions, "agentManager"> {
+export interface CreateReactorStoreOptions extends HttpAgentOptions, Omit<ActorManagerOptions, "agentManager"> {
     agentManager?: AgentManager;
-    withProcessEnv?: boolean;
     isLocalEnv?: boolean;
     port?: number;
 }
@@ -53,7 +53,7 @@ export type ActorUpdateArgs<A, M extends FunctionName<A>> = {
 export type ActorMethodCall<A = Record<string, ActorMethod>> = <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodArgs<A[M]>) => ActorUpdateReturn<A, M>;
 export type ActorQuery<A = Record<string, ActorMethod>> = <M extends FunctionName<A>>(options: ActorQueryArgs<A, M>) => ActorQueryReturn<A, M>;
 export type ActorUpdate<A = Record<string, ActorMethod>> = <M extends FunctionName<A>>(options: ActorUpdateArgs<A, M>) => ActorUpdateReturn<A, M>;
-export interface ActorCoreActions<A = BaseActor> extends AgentManager, Omit<ActorManager<A>, "updateMethodState"> {
+export interface ReactorCore<A = BaseActor> extends AgentManager, Omit<ActorManager<A>, "updateMethodState"> {
     login: (options?: AuthClientLoginOptions) => Promise<void>;
     logout: (options?: {
         returnTo?: string;

package/dist/types.js

@@ -16,4 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./agent/types"), exports);
 __exportStar(require("./actor/types"), exports);
-__exportStar(require("./tools/types"), exports);
+__exportStar(require("./candid/types"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ic-reactor/core",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "A library for intracting with the Internet Computer canisters",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -43,5 +43,5 @@
   "engines": {
     "node": ">=10"
   },
-  "gitHead": "54c9942a98bcad64e63c8d52788103f8b168720e"
+  "gitHead": "acf8b5da61713482264c9eb5c227dc94a7e43cbc"
 }