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

package/dist/utils/polling.js

@@ -0,0 +1,170 @@
+/**
+ * @module polling
+ * @description
+ * Polling strategy for Internet Computer (Dfinity) agent update calls.
+ *
+ * This module provides a configurable, intelligent polling mechanism that:
+ * - Starts with rapid polling for quick responses (fast phase)
+ * - Gradually increases delay intervals (ramp phase)
+ * - Settles into steady-state polling (plateau phase)
+ * - Adds jitter to prevent thundering herd problems
+ * - Provides structured logging with elapsed time and status
+ * - Supports graceful cancellation via AbortSignal
+ *
+ * @example
+ * ```typescript
+ * const strategy = createPollingStrategy({
+ *   context: "signer-creation",
+ *   fastAttempts: 10,
+ *   plateauDelayMs: 5000
+ * });
+ *
+ * const result = await actor.createSigner(params, {
+ *   pollingOptions: { strategy }
+ * });
+ * ```
+ */
+import { RequestStatusResponseStatus, } from "@icp-sdk/core/agent";
+/**
+ * Creates an polling strategy for Internet Computer agent update calls.
+ *
+ * The strategy implements three phases:
+ * 1. **Fast Phase**: Initial rapid polling (default: 10 attempts @ 100ms intervals)
+ * 2. **Ramp Phase**: Exponential backoff growth (default: up to 20s elapsed)
+ * 3. **Plateau Phase**: Steady-state polling (default: 5s intervals)
+ *
+ * The strategy continues polling while request status is RECEIVED/PROCESSING,
+ * and only terminates on REPLIED/REJECTED/DONE status or when aborted.
+ *
+ * @param {PollingConfig} [cfg={}] - Configuration options
+ * @returns {PollStrategy} - Async strategy function compatible with agent pollingOptions.strategy
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const strategy = createPollingStrategy();
+ *
+ * // Custom configuration for long-running operations
+ * const strategy = createPollingStrategy({
+ *   context: "blockchain-sync",
+ *   fastAttempts: 5,
+ *   fastDelayMs: 200,
+ *   rampUntilMs: 30_000,
+ *   plateauDelayMs: 10_000,
+ *   jitterRatio: 0.3
+ * });
+ *
+ * // With abort signal
+ * const controller = new AbortController();
+ * const strategy = createPollingStrategy({
+ *   context: "transaction-signing",
+ *   abortSignal: controller.signal
+ * });
+ * // Later: controller.abort();
+ * ```
+ *
+ * @throws {Error} When abortSignal is triggered during polling
+ */
+export function createPollingStrategy(cfg = {}) {
+    const { context = "operation", logPrefix = "[Polling]", fastAttempts = 10, fastDelayMs = 100, rampUntilMs = 20000, plateauDelayMs = 5000, jitterRatio = 0.4, maxLogIntervalMs = 15000, abortSignal, } = cfg;
+    let attempt = 0;
+    const start = Date.now();
+    let lastLog = 0;
+    /**
+     * Structured logging function that outputs polling state information.
+     * Implements intelligent log throttling to prevent console spam while ensuring
+     * periodic heartbeat logs for long-running operations.
+     *
+     * @param {string} phase - Current polling phase ("fast", "ramp", or "plateau")
+     * @param {string | undefined} statusKind - Request status from IC agent
+     * @param {number} nextDelay - Calculated delay until next poll (ms)
+     */
+    const log = (phase, statusKind, nextDelay) => {
+        const now = Date.now();
+        // Suppress ultra-noisy logs: skip if < 1s since last log and not in fast phase
+        if (now - lastLog < 1000 && phase !== "fast" && nextDelay < 1000)
+            return;
+        // Force a heartbeat log if too much time has passed (prevents silent operations)
+        if (now - lastLog > maxLogIntervalMs) {
+            phase += "+heartbeat";
+        }
+        lastLog = now;
+        // eslint-disable-next-line no-console
+        console.info(`${logPrefix} ${context} attempt=${attempt} elapsed=${now - start}ms status=${statusKind} phase=${phase} nextDelay=${Math.round(nextDelay)}ms`);
+    };
+    /**
+     * Computes the next polling delay based on elapsed time and attempt count.
+     * Implements three-phase strategy:
+     * - Fast: Initial rapid polling
+     * - Ramp: Exponential growth with power curve
+     * - Plateau: Steady-state polling
+     *
+     * @param {number} elapsed - Milliseconds elapsed since start
+     * @param {number} a - Current attempt number
+     * @returns {{ delay: number; phase: string }} - Calculated delay and phase name
+     */
+    const computeDelay = (elapsed, a) => {
+        // Phase 1: Fast initial polling
+        if (a < fastAttempts) {
+            return { delay: withJitter(fastDelayMs), phase: "fast" };
+        }
+        // Phase 2: Ramp with exponential growth (power curve 0.7 for smooth acceleration)
+        if (elapsed < rampUntilMs) {
+            const progress = elapsed / rampUntilMs; // Normalized progress: 0..1
+            const base = fastDelayMs + (plateauDelayMs - fastDelayMs) * Math.pow(progress, 0.7);
+            return { delay: withJitter(base), phase: "ramp" };
+        }
+        // Phase 3: Plateau - steady-state polling
+        return { delay: withJitter(plateauDelayMs), phase: "plateau" };
+    };
+    /**
+     * Applies random jitter to prevent synchronized polling across multiple clients.
+     * Uses configured jitterRatio to add ±N% randomness to the base delay.
+     *
+     * @param {number} base - Base delay in milliseconds
+     * @returns {number} - Jittered delay, minimum 50ms
+     */
+    const withJitter = (base) => {
+        const spread = base * jitterRatio;
+        return Math.max(50, base - spread + Math.random() * spread * 2);
+    };
+    /**
+     * Async strategy function invoked by the IC agent on each polling cycle.
+     * Determines whether to continue waiting based on request status.
+     *
+     * @param {Principal} _canisterId - Target canister principal (unused but required by interface)
+     * @param {RequestId} _requestId - Request identifier (unused but required by interface)
+     * @param {RequestStatusResponseStatus} [rawStatus] - Current request status from IC
+     * @returns {Promise<void>} - Resolves after calculated delay, or immediately for terminal states
+     * @throws {Error} - If abortSignal is triggered
+     */
+    return async function strategy(_canisterId, _requestId, rawStatus) {
+        // Check for external cancellation
+        if (abortSignal?.aborted) {
+            throw new Error(`${context} polling aborted`);
+        }
+        attempt++;
+        const statusKind = rawStatus;
+        // Terminal states: Stop polling immediately
+        // - Replied: Request completed successfully
+        // - Rejected: Request was rejected by canister
+        // - Done: Request processing complete
+        // Note: Agent typically stops before we reach here, but we handle defensively
+        if (statusKind === RequestStatusResponseStatus.Replied ||
+            statusKind === RequestStatusResponseStatus.Rejected ||
+            statusKind === RequestStatusResponseStatus.Done) {
+            return;
+        }
+        // Continue polling for:
+        // - Received: Request received but not yet processed
+        // - Processing: Request is being processed
+        // - Unknown: Status not yet available
+        // - undefined: No status information yet
+        const elapsed = Date.now() - start;
+        const { delay, phase } = computeDelay(elapsed, attempt);
+        log(phase, statusKind, delay);
+        // Sleep for calculated delay before next poll
+        await new Promise((r) => setTimeout(r, delay));
+    };
+}
+//# sourceMappingURL=polling.js.map

package/dist/utils/polling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"polling.js","sourceRoot":"","sources":["../../src/utils/polling.ts"],"names":[],"mappings":"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"}

package/dist/version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Library version - automatically synced from package.json.
+ */
+export declare const VERSION = "3.0.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,OAAO,UAAU,CAAA"}

package/dist/version.js

@@ -0,0 +1,5 @@
+/**
+ * Library version - automatically synced from package.json.
+ */
+export const VERSION = "3.0.0";
+//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAA"}

package/package.json

@@ -1,60 +1,86 @@
 {
   "name": "@ic-reactor/core",
-  "version": "2.0.0",
-  "description": "A library for intracting with the Internet Computer canisters",
+  "version": "3.0.0-beta.1",
+  "description": "IC Reactor Core Library",
   "main": "dist/index.js",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
   "files": [
-    "dist/*"
+    "dist",
+    "README.md"
   ],
+  "scripts": {
+    "build": "rm -rf dist tsconfig.tsbuildinfo && tsc -b",
+    "test": "vitest run",
+    "version:sync": "node -e \"const pkg = require('./package.json'); const fs = require('fs'); fs.writeFileSync('./src/version.ts', '/**\\n * Library version - automatically synced from package.json.\\n */\\nexport const VERSION = \\\"' + pkg.version + '\\\"\\n');\"",
+    "size": "size-limit",
+    "analyze": "size-limit --why"
+  },
   "repository": {
     "type": "git",
-    "url": "git@github.com:B3Pay/ic-reactor.git"
+    "url": "https://github.com/B3Pay/ic-reactor",
+    "directory": "packages/core"
   },
+  "bugs": {
+    "url": "https://github.com/B3Pay/ic-reactor/issues"
+  },
+  "homepage": "https://ic-reactor.dev",
   "keywords": [
-    "actor",
-    "react",
-    "candid",
+    "internet-computer",
+    "icp",
     "dfinity",
     "web3",
-    "dapp"
+    "blockchain",
+    "canister",
+    "actor",
+    "reactor",
+    "tanstack-query"
   ],
-  "author": "b3hr4d",
+  "author": "Behrad Deylami",
   "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/b3hr4d/ic-reactor/issues"
-  },
-  "homepage": "https://b3pay.github.io/ic-reactor/modules/core.html",
   "dependencies": {
-    "@dfinity/agent": "^3.1.0",
-    "@dfinity/auth-client": "^3.1.0",
-    "@dfinity/candid": "^3.1.0",
-    "@dfinity/identity": "^3.1.0",
-    "@dfinity/principal": "^3.1.0",
-    "zustand": "5.0.6"
+    "@noble/curves": "^2.0.1",
+    "zod": "^4.3.2"
   },
   "peerDependencies": {
-    "@dfinity/agent": ">=3.1.0",
-    "@dfinity/auth-client": ">=3.1.0",
-    "@dfinity/candid": ">=3.1.0",
-    "@dfinity/identity": ">=3.1.0",
-    "@dfinity/principal": ">=3.1.0"
+    "@icp-sdk/core": "^5.0.0",
+    "@icp-sdk/auth": "^5.0.0",
+    "@tanstack/query-core": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@icp-sdk/auth": {
+      "optional": true
+    },
+    "@tanstack/query-core": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@ic-reactor/parser": "0.4.5"
+    "@icp-sdk/auth": "^5.0.0",
+    "@icp-sdk/core": "^5.0.0",
+    "@size-limit/preset-small-lib": "^11.2.0",
+    "@tanstack/query-core": "^5.90",
+    "@tanstack/react-query": "^5.90",
+    "@types/node": "^24.10.1",
+    "fake-indexeddb": "^6.2.5",
+    "size-limit": "^11.2.0",
+    "vitest": "^4.0.16"
   },
-  "scripts": {
-    "test": "bun test",
-    "start": "bun run tsc --watch",
-    "build:tsc": "bun run tsc",
-    "build": "bun run build:tsc && bun run bundle",
-    "bundle": "bun run bundle:dev && bun run bundle:prod",
-    "bundle:dev": "bun run webpack-cli --mode development",
-    "bundle:prod": "bun run webpack-cli --mode production",
-    "clean": "bun run rimraf dist && bun run rimraf umd && bun run rimraf node_modules"
-  },
-  "engines": {
-    "node": ">=22.0.0"
-  },
-  "gitHead": "2677a090df726dc4f4216eb406b135a32334507b"
+  "size-limit": [
+    {
+      "name": "Core Library",
+      "path": "dist/index.js",
+      "limit": "50 KB",
+      "gzip": true
+    }
+  ]
 }

package/LICENSE.md

@@ -1,8 +0,0 @@
-The MIT License (MIT)
-Copyright © 2023 B3Pay
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,283 +0,0 @@
-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
-
-To get started with `@ic-reactor/core`, you can install the package using npm or Yarn:
-
-**Using npm:**
-
-```bash
-npm install @ic-reactor/core
-```
-
-**Using Yarn:**
-
-```bash
-yarn add @ic-reactor/core
-```
-
-or you can use the UMD version:
-
-```html
-<script src="https://github.com/B3Pay/ic-reactor/releases/download/v1.15.0/ic-reactor-core.min.js"></script>
-```
-
-### Using `createReactorCore`
-
-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 { createReactorCore } from "@ic-reactor/core"
-import { candid, canisterId, idlFactory } from "./declarations/candid"
-
-type Candid = typeof candid
-
-const { queryCall, updateCall, getPrincipal, login } =
-  createReactorCore<Candid>({
-    canisterId,
-    idlFactory,
-    withProcessEnv: true, // will use process.env.DFX_NETWORK
-  })
-```
-
-You can find All available methods are returned from the `createReactorCore` function [here](https://b3pay.github.io/ic-reactor/interfaces/core.types.CreateReactorCoreReturnType.html).
-
-```typescript
-// later in your code
-await login({
-  onSuccess: () => {
-    console.log("Logged in successfully")
-  },
-  onError: (error) => {
-    console.error("Failed to login:", error)
-  },
-})
-
-// queryCall, will automatically call and return a promise with the result
-const { dataPromise, call } = queryCall({
-  functionName: "icrc1_balance_of",
-  args: [{ owner: getPrincipal(), subaccount: [] }],
-})
-
-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 })
-})
-
-const result = await call()
-console.log(result)
-```
-
-### Managing Multiple Actors
-
-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:
-
-Fist you need to create a agent manager:
-
-```typescript
-// agent.ts
-import { createAgentManager } from "@ic-reactor/core"
-
-export const agentManager = createAgentManager() // Connects to IC network by default
-```
-
-Then you can create a Actor for each canister:
-
-```typescript
-// Assuming you've already set up `candidA`, `candidB`, and `agentManager`
-import { createActorManager } from "@ic-reactor/core"
-import * as candidA from "./declarations/candidA"
-import * as candidB from "./declarations/candidB"
-import { agentManager } from "./agent"
-
-type CandidA = typeof candidA.candidA
-type CandidB = typeof candidB.candidB
-
-const actorA = createActorManager<CandidA>({
-  agentManager,
-  canisterId: candidA.canisterId,
-  idlFactory: candidA.idlFactory,
-})
-
-const actorB = createActorManager<CandidB>({
-  agentManager,
-  canisterId: candidB.canisterId,
-  idlFactory: candidB.idlFactory,
-})
-```
-
-You can now use the `actorA` and `actorB` instances to interact with their respective canisters:
-
-```typescript
-const { dataPromise: version } = actorA.queryCall({
-  functionName: "version",
-})
-console.log("Response from CanisterA method:", await version)
-
-const { dataPromise: balance } = actorB.queryCall({
-  functionName: "balance",
-  args: [principal, []],
-})
-console.log("Response from CanisterB method:", await balance)
-```
-
-### Using Candid Adapter
-
-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.
-
-```typescript
-import { createCandidAdapter } from "@ic-reactor/core"
-import { agentManager } from "./agent"
-
-const candidAdapter = createCandidAdapter({ agentManager })
-
-const canisterId = "ryjl3-tyaaa-aaaaa-aaaba-cai"
-
-// Usage example
-try {
-  const definition = await candidAdapter.getCandidDefinition(canisterId)
-  console.log(definition)
-} catch (error) {
-  console.error(error)
-}
-```
-
-### Using `createReactorCore` with `CandidAdapter`
-
-You can use the `candidAdapter` to fetch the Candid definition and then pass it to the `createReactorCore` function.
-
-```typescript
-import { createReactorCore, createCandidAdapter } from "@ic-reactor/core"
-import { agentManager } from "./agent"
-
-const candidAdapter = createCandidAdapter({ agentManager })
-
-const canisterId = "ryjl3-tyaaa-aaaaa-aaaba-cai" // NNS ICP Ledger Canister
-
-// Usage example
-try {
-  const { idlFactory } = await candidAdapter.getCandidDefinition(canisterId)
-  const { callMethod } = createReactorCore({
-    agentManager,
-    canisterId,
-    idlFactory,
-  })
-
-  const name = await callMethod("name")
-  console.log(name) // { name: 'Internet Computer' }
-} catch (error) {
-  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.getAuth()
-
-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({
-  withLocalEnv: 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/classes/actor/index.d.ts

@@ -1,34 +0,0 @@
-import type { CallConfig } from "@dfinity/agent";
-import type { ActorMethodParameters, ActorMethodReturnType, ActorStore, ActorManagerParameters, FunctionName, VisitService, BaseActor, ActorMethodState, MethodAttributes } from "./types";
-import { IDL } from "@dfinity/candid";
-import type { AgentManager } from "../agent";
-import type { UpdateAgentParameters } from "../types";
-export declare class ActorManager<A = BaseActor> {
-    private _actor;
-    private _idlFactory;
-    private _agentManager;
-    private _unsubscribeAgent;
-    private _subscribers;
-    canisterId: string;
-    actorStore: ActorStore<A>;
-    visitFunction: VisitService<A>;
-    methodAttributes: MethodAttributes<A>;
-    private updateState;
-    updateMethodState: (method: FunctionName<A>, hash: string, newState: Partial<ActorMethodState<A, typeof method>[string]>) => void;
-    constructor(actorConfig: ActorManagerParameters);
-    initialize: (options?: UpdateAgentParameters) => Promise<void>;
-    extractInterface: () => IDL.ServiceClass;
-    extractMethodAttributes: () => MethodAttributes<A>;
-    extractVisitor: () => VisitService<A>;
-    private initializeActor;
-    private _getActorMethod;
-    callMethod: <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
-    callMethodWithOptions: (options: CallConfig) => <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
-    call: <M extends FunctionName<A>>(functionName: M, ...args: ActorMethodParameters<A[M]>) => Promise<ActorMethodReturnType<A[M]>>;
-    get agentManager(): AgentManager;
-    getActor: () => A | null;
-    getState: ActorStore<A>["getState"];
-    subscribeActorState: ActorStore<A>["subscribe"];
-    setState: ActorStore<A>["setState"];
-    cleanup: () => void;
-}