Update ESLint rules and fix console errors

.eslintrc

@@ -8,7 +8,10 @@
     "prettier"
   ],
   "rules": {
-    "typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-unused-vars": [
+      "error",
+      { "argsIgnorePattern": "^_" }
+    ],
     "no-console": 1,
     "prettier/prettier": 2
   },

packages/store/src/actor/index.ts

@@ -1,6 +1,6 @@
 import { Actor } from "@dfinity/agent"
 import { createStoreWithOptionalDevtools } from "../helper"
-import type { ActorSubclass, HttpAgent } from "@dfinity/agent"
+import type { HttpAgent } from "@dfinity/agent"
 import type {
   CanisterId,
   ExtractActorMethodArgs,
@@ -9,16 +9,16 @@ import type {
   ActorStore,
   ActorMethodStates,
   ActorManagerOptions,
-  DefaultActorType,
   FunctionName,
   ExtractedService,
+  BaseActor,
 } from "./types"
 import { IDL } from "@dfinity/candid"
 import type { AgentManager, UpdateAgentOptions } from "../agent"
 
 export * from "./types"
 
-export class ActorManager<A extends ActorSubclass<any> = DefaultActorType> {
+export class ActorManager<A = BaseActor> {
   private actor: null | A = null
   private idlFactory: IDL.InterfaceFactory
 
@@ -67,7 +67,7 @@ export class ActorManager<A extends ActorSubclass<any> = DefaultActorType> {
 
     // Initialize stores
     this.actorStore = createStoreWithOptionalDevtools(
-      { ...this.DEFAULT_ACTOR_STATE },
+      this.DEFAULT_ACTOR_STATE,
       { withDevtools, store: `actor-${String(canisterId)}` }
     )
 
@@ -81,19 +81,22 @@ export class ActorManager<A extends ActorSubclass<any> = DefaultActorType> {
   }
 
   public extractService(): ExtractedService<A> {
-    return this.idlFactory({ IDL })._fields.reduce(
-      (acc, [functionName, type]) => {
-        acc[functionName as FunctionName<A>] = (extractorClass, data) => {
-          return type.accept(extractorClass, data || functionName)
-        }
-
-        return acc
-      },
-      {} as ExtractedService<A>
-    )
+    return this.idlFactory({ IDL })._fields.reduce((acc, service) => {
+      const functionName = service[0] as keyof A
+      const type = service[1]
+
+      const visit = ((extractorClass, data) => {
+        return type.accept(extractorClass, data || functionName)
+      }) as ExtractedService<A>[typeof functionName]
+
+      acc[functionName] = visit
+
+      return acc
+    }, {} as ExtractedService<A>)
   }
 
   private initializeActor = (agent: HttpAgent) => {
+    // eslint-disable-next-line no-console
     console.info(
       `Initializing actor ${this.canisterId} on ${
         agent.isLocal() ? "local" : "ic"
@@ -127,6 +130,7 @@ export class ActorManager<A extends ActorSubclass<any> = DefaultActorType> {
         initialized: true,
       })
     } catch (error) {
+      // eslint-disable-next-line no-console
       console.error("Error in initializeActor:", error)
       this.updateState({ error: error as Error, initializing: false })
     }
@@ -170,7 +174,7 @@ export class ActorManager<A extends ActorSubclass<any> = DefaultActorType> {
   }
 }
 
-const emptyVisitor = new Proxy({} as ExtractedService<any>, {
+const emptyVisitor = new Proxy({} as ExtractedService<never>, {
   get: function (_, prop) {
     throw new Error(
       `Cannot visit function "${String(

packages/store/src/actor/types.ts

@@ -3,15 +3,16 @@ import type { StoreApi } from "zustand"
 import type { AgentManager } from "../agent"
 import type { ActorMethod, ActorSubclass, Principal } from "../types"
 
-export type FunctionName<A = DefaultActorType> = keyof A & string
-
-export type FunctionType = "query" | "update"
-
 export interface DefaultActorType {
-  [key: string]: ActorMethod<any, any>
+  [key: string]: ActorMethod
 }
 
-// Type for identifying a canister
+export type BaseActor<T = DefaultActorType> = ActorSubclass<T>
+
+export type FunctionName<A = BaseActor> = keyof A & string
+
+export type FunctionType = "query" | "update"
+
 export type CanisterId = string | Principal
 
 export interface ActorManagerOptions {
@@ -23,33 +24,31 @@ export interface ActorManagerOptions {
   initializeOnCreate?: boolean
 }
 
-export type ExtractVisitorType<T> = T extends IDL.Visitor<infer U, infer V>
-  ? { data: U; return: V }
+export type ExtractVisitorType<V> = V extends IDL.Visitor<infer D, infer R>
+  ? { data: D; returnType: R }
   : never
 
-export type ExtractedService<
-  A = DefaultActorType,
-  M extends FunctionName<A> = FunctionName<A>
-> = {
-  [K in M]: <V extends IDL.Visitor<any, any>>(
+export type ExtractedService<A = BaseActor, M extends keyof A = keyof A> = {
+  [K in M]: <V extends IDL.Visitor<unknown, unknown>>(
     extractorClass: V,
     data?: ExtractVisitorType<V>["data"]
   ) => ReturnType<V["visitFunc"]>
 }
 
-// Utility types for extracting method arguments and return types
-export type ExtractActorMethodArgs<T> = T extends ActorMethod<infer A>
-  ? A
+// Extracts the argument types of an ActorMethod
+export type ExtractActorMethodArgs<T> = T extends ActorMethod<infer Args>
+  ? Args
   : never
 
+// Extracts the return type of an ActorMethod
 export type ExtractActorMethodReturnType<T> = T extends ActorMethod<
-  any,
-  infer R
+  unknown[],
+  infer Ret
 >
-  ? R
+  ? Ret
   : never
 
-export interface ActorMethodState<A, M extends FunctionName<A>> {
+export interface ActorMethodState<A, M extends keyof A> {
   [key: string]: {
     data: ExtractActorMethodReturnType<A[M]> | undefined
     loading: boolean
@@ -58,7 +57,7 @@ export interface ActorMethodState<A, M extends FunctionName<A>> {
 }
 
 export type ActorMethodStates<A> = {
-  [M in FunctionName<A>]: ActorMethodState<A, M>
+  [M in keyof A]: ActorMethodState<A, M>
 }
 
 // State structure for an actor in a ReActor
@@ -69,13 +68,10 @@ export type ActorState<A> = {
   methodState: ActorMethodStates<A>
 }
 
-export type ActorStore<A extends ActorSubclass<any> = DefaultActorType> =
-  StoreApi<ActorState<A>>
+export type ActorStore<A = BaseActor> = StoreApi<ActorState<A>>
 
 // Function type for directly calling a method on an actor
-export type CallActorMethod<A = Record<string, ActorMethod>> = <
-  M extends FunctionName<A>
->(
+export type CallActorMethod<A = BaseActor> = <M extends keyof A>(
   functionName: M,
   ...args: ExtractActorMethodArgs<A[M]>
 ) => Promise<ExtractActorMethodReturnType<A[M]>>

packages/store/src/agent/index.ts

@@ -67,7 +67,6 @@ export class AgentManager {
         this.updateState({ initialized: true, initializing: false })
       } catch (error) {
         this.updateState({ error: error as Error, initializing: false })
-        console.error("Error fetching root key:", error)
       }
     }
   }
@@ -105,6 +104,7 @@ export class AgentManager {
     try {
       const { AuthClient } = await import("@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."
@@ -130,8 +130,6 @@ export class AgentManager {
       return identity
     } catch (error) {
       this.updateState({ error: error as Error, authenticating: false })
-
-      console.error("Error in authenticate:", error)
       throw error
     }
   }

packages/store/src/helper.ts

@@ -2,15 +2,15 @@ import { hash } from "@dfinity/agent"
 import { toHexString } from "@dfinity/candid"
 import { devtools } from "zustand/middleware"
 import { createStore } from "zustand/vanilla"
-import type { ActorSubclass } from "./types"
+import { BaseActor } from "./actor"
 
 interface StoreOptions {
   withDevtools?: boolean
   store: string
 }
 
-export function createStoreWithOptionalDevtools(
-  initialState: any,
+export function createStoreWithOptionalDevtools<T>(
+  initialState: T,
   options: StoreOptions
 ) {
   if (options.withDevtools) {
@@ -25,15 +25,15 @@ export function createStoreWithOptionalDevtools(
   }
 }
 
-export function jsonToString(json: any) {
+export function jsonToString(json: never) {
   return JSON.stringify(
     json,
     (_, value) => (typeof value === "bigint" ? `BigInt(${value})` : value),
     2
   )
 }
 
-export const generateRequestHash = (args?: any[]) => {
+export const generateRequestHash = (args?: unknown[]) => {
   const serializedArgs = args
     ?.map((arg) => {
       if (typeof arg === "bigint") {
@@ -47,12 +47,12 @@ export const generateRequestHash = (args?: any[]) => {
   return stringToHash(serializedArgs ?? "")
 }
 
-export const generateHash = (field?: any) => {
+export const generateHash = (field?: never) => {
   const serializedArgs = JSON.stringify(field)
   return stringToHash(serializedArgs ?? "")
 }
 
-export const generateActorHash = (actor: ActorSubclass<any>) => {
+export const generateActorHash = (actor: BaseActor) => {
   const serializedArgs = JSON.stringify(actor)
   return stringToHash(serializedArgs ?? "")
 }

packages/store/src/index.ts

@@ -1,9 +1,9 @@
-import type { ActorManagerOptions, DefaultActorType } from "./actor/types"
+import type { ActorManagerOptions, BaseActor } from "./actor/types"
 import type { AgentManagerOptions } from "./agent/types"
 
 import { ActorManager } from "./actor"
 import { AgentManager } from "./agent"
-import { ActorSubclass, CreateReActorOptions } from "./types"
+import { CreateReActorOptions } from "./types"
 import { CandidAdapter, CandidAdapterOptions } from "./tools"
 
 export * from "./helper"
@@ -36,9 +36,7 @@ export const createAgentManager = (
  * @category Main
  * @includeExample ./packages/store/README.md:91-106
  */
-export const createActorManager = <
-  A extends ActorSubclass<any> = DefaultActorType
->(
+export const createActorManager = <A = BaseActor>(
   options: ActorManagerOptions
 ): ActorManager<A> => {
   return new ActorManager<A>(options)
@@ -52,9 +50,7 @@ export const createActorManager = <
  * @category Main
  * @includeExample ./packages/store/README.md:32-45
  */
-export const createReActorStore = <
-  A extends ActorSubclass<any> = DefaultActorType
->(
+export const createReActorStore = <A = BaseActor>(
   options: CreateReActorOptions
 ): ActorManager<A> => {
   const {

packages/store/src/tools/types.ts

@@ -9,5 +9,5 @@ export interface CandidAdapterOptions {
 
 export interface CandidDefenition {
   idlFactory: IDL.InterfaceFactory
-  init: ({ IDL }: { IDL: any }) => never[]
+  init: ({ idl }: { idl: typeof IDL }) => never[]
 }