@mentaproject/client 0.1.24 → 0.1.28

package/src/structures/MentaClient.ts

@@ -1,16 +1,21 @@
 /**
  * @module MentaClient
  */
-import type { CoreClient } from "@mentaproject/core/types";
-import { createClient } from "@mentaproject/core";
+import type { MentaAccountClient } from "@mentaproject/core/types";
+import { createMentaAccount } from "@mentaproject/core/clients";
 
 import { BlockManager } from "../managers/BlockManager";
 import { TransactionManager } from "../managers/TransactionManager";
 import { ContractManager } from "../managers/ContractManager";
 import { AccountManager } from "../managers/AccountManager";
 import { PersistenceManager } from "../managers/PersistenceManager";
-import { ClientEvents, GetListenerCallback, MentaClientConfig } from "../types/MentaClient";
+import {
+  ClientEvents,
+  GetListenerCallback,
+  MentaClientConfig,
+} from "../types/MentaClient";
 import { withCache } from "../utils/withCache";
+import { createClient } from "@mentaproject/core";
 
 /**
  * The main client for interacting with the Menta API.
@@ -21,107 +26,128 @@ import { withCache } from "../utils/withCache";
  * simplifying common operations.
  */
 export class MentaClient {
-    /**
-     * The underlying RPC client used for blockchain interactions.
-     * @description This client is responsible for low-level communication with the RPC node.
-     */
-    public rpc: CoreClient;
+  protected _rpc?: MentaAccountClient;
+  /**
+   * The underlying RPC client used for blockchain interactions.
+   * @description This client is responsible for low-level communication with the RPC node.
+   */
+  public get rpc(): MentaAccountClient {
+    if (!this._rpc) {
+      throw new Error("RPC client not initialized");
+    }
+    return this._rpc;
+  }
 
-    /**
-     * Manager for block-related operations.
-     * @description Provides methods to query and interact with blockchain blocks.
-     */
-    public blocks!: BlockManager;
-    /**
-     * Manager for transaction-related operations.
-     * @description Provides methods to send, query, and manage blockchain transactions.
-     */
-    public transactions!: TransactionManager;
-    /**
-     * Manager for contract-related operations.
-     * @description Provides methods to deploy, interact with, and query smart contracts.
-     */
-    public contracts!: ContractManager;
-    /**
-     * Manager for account-related operations.
-     * @description Provides methods to manage and interact with blockchain accounts.
-     */
-    public accounts!: AccountManager;
+  /**
+   * Manager for block-related operations.
+   * @description Provides methods to query and interact with blockchain blocks.
+   */
+  public blocks!: BlockManager;
+  /**
+   * Manager for transaction-related operations.
+   * @description Provides methods to send, query, and manage blockchain transactions.
+   */
+  public transactions!: TransactionManager;
+  /**
+   * Manager for contract-related operations.
+   * @description Provides methods to deploy, interact with, and query smart contracts.
+   */
+  public contracts!: ContractManager;
+  /**
+   * Manager for account-related operations.
+   * @description Provides methods to manage and interact with blockchain accounts.
+   */
+  public accounts!: AccountManager;
 
-    /**
-     * Subscribes to a specific client event.
-     * @template TEvent The type of the event to listen for.
-     * @param {TEvent} event - The event to listen for (e.g., 'block', 'transaction').
-     * @param {GetListenerCallback<TEvent>} callback - The callback function to execute when the event is triggered.
-     * @returns {() => void} An unsubscribe function to stop listening to the event.
-     * @description This method allows the client to listen for real-time events from the blockchain, such as new blocks or transactions.
-     * @example
-     * import { MentaClient } from '@mentaproject/client';
-     *
-     * const client = new MentaClient({ url: 'http://rpcurlhere.com' });
-     *
-     * // Subscribe to new blocks
-     * const unsubscribe = client.on('block', (block) => {
-     *   console.log('New block received:', block);
-     * });
-     *
-     * // To stop listening
-     * // unsubscribe();
-     */
-    on<TEvent extends keyof typeof ClientEvents>(
-        event: TEvent,
-        callback: GetListenerCallback<TEvent>
-    ) {
-        const eventFunction = ClientEvents[event];
-        const capitalizedEvent = event.charAt(0).toUpperCase() + event.slice(1);
-        const params = {
-            [`on${capitalizedEvent}`]: callback,
-            pollingInterval: 1000,
-        };
+  /**
+   * Subscribes to a specific client event.
+   * @template TEvent The type of the event to listen for.
+   * @param {TEvent} event - The event to listen for (e.g., 'block', 'transaction').
+   * @param {GetListenerCallback<TEvent>} callback - The callback function to execute when the event is triggered.
+   * @returns {() => void} An unsubscribe function to stop listening to the event.
+   * @description This method allows the client to listen for real-time events from the blockchain, such as new blocks or transactions.
+   * @example
+   * import { MentaClient } from '@mentaproject/client';
+   *
+   * const client = new MentaClient({ url: 'http://rpcurlhere.com' });
+   *
+   * // Subscribe to new blocks
+   * const unsubscribe = client.on('block', (block) => {
+   *   console.log('New block received:', block);
+   * });
+   *
+   * // To stop listening
+   * // unsubscribe();
+   */
+  on<TEvent extends keyof typeof ClientEvents>(
+    event: TEvent,
+    callback: GetListenerCallback<TEvent>,
+  ) {
+    const eventFunction = ClientEvents[event];
+    const capitalizedEvent = event.charAt(0).toUpperCase() + event.slice(1);
+    const params = {
+      [`on${capitalizedEvent}`]: callback,
+      pollingInterval: 1000,
+    };
 
-        return (eventFunction as any)(this.rpc, params);
+    return (eventFunction as any)(this.rpc, params);
+  }
+
+  /**
+   * Creates an instance of MentaClient.
+   * @param {MentaClientConfig} params - The configuration parameters for the client.
+   * @description The constructor initializes the RPC client and the various managers based on the provided configuration.
+   * It also applies caching and persistence if specified in the configuration.
+   * @example
+   * import { MentaClient } from '@mentaproject/client';
+   *
+   * // Basic initialization
+   * const client = new MentaClient({
+   *   url: 'http://rpcurlhere.com',
+   * });
+   *
+   * // Initialization with a persistent cache
+   * const clientWithCache = new MentaClient({
+   *   url: 'http://rpcurlhere.com',
+   *   cache: {
+   *     ttl: 60000, // 1 minute
+   *   },
+   * });
+   */
+  constructor(protected params: MentaClientConfig) {
+    this.blocks = new BlockManager(this);
+    this.transactions = new TransactionManager(this);
+    this.contracts = new ContractManager(this);
+
+    if (params.persistenceAdapter) {
+      this.persistenceManager = new PersistenceManager(
+        this,
+        params.persistenceAdapter,
+      );
+      this.accounts = new AccountManager(this, this.persistenceManager);
+    } else {
+      this.accounts = new AccountManager(this);
     }
+  }
 
-    /**
-     * Creates an instance of MentaClient.
-     * @param {MentaClientConfig} params - The configuration parameters for the client.
-     * @description The constructor initializes the RPC client and the various managers based on the provided configuration.
-     * It also applies caching and persistence if specified in the configuration.
-     * @example
-     * import { MentaClient } from '@mentaproject/client';
-     *
-     * // Basic initialization
-     * const client = new MentaClient({
-     *   url: 'http://rpcurlhere.com',
-     * });
-     *
-     * // Initialization with a persistent cache
-     * const clientWithCache = new MentaClient({
-     *   url: 'http://rpcurlhere.com',
-     *   cache: {
-     *     ttl: 60000, // 1 minute
-     *   },
-     * });
-     */
-    constructor(params: MentaClientConfig) {
-        this.rpc = createClient(params) as CoreClient;
-        if (params.cache) this.rpc = withCache(this.rpc, params.cache);
+  async init() {
+    let coreClient = createClient(this.params);
 
-        this.blocks = new BlockManager(this);
-        this.transactions = new TransactionManager(this);
-        this.contracts = new ContractManager(this);
-        if (params.persistenceAdapter) {
-            this.persistenceManager = new PersistenceManager(this, params.persistenceAdapter);
-            this.accounts = new AccountManager(this, this.persistenceManager);
-        } else {
-            this.accounts = new AccountManager(this);
-        }
+    if (this.params.cache) {
+      coreClient = withCache(coreClient, this.params.cache);
     }
 
-    /**
-     * Optional manager for persistence-related operations.
-     * @description This manager is initialized if a persistence adapter is provided in the client configuration,
-     * allowing for data storage and retrieval.
-     */
-    public persistenceManager?: PersistenceManager;
-}
+    this._rpc = await createMentaAccount(coreClient, {
+      signer: this.params.signer,
+      bundlerTransport: this.params.bundlerTransport,
+      publicTransport: this.params.transport,
+    });
+  }
+
+  /**
+   * Optional manager for persistence-related operations.
+   * @description This manager is initialized if a persistence adapter is provided in the client configuration,
+   * allowing for data storage and retrieval.
+   */
+  public persistenceManager?: PersistenceManager;
+}

package/src/types/MentaClient.ts

@@ -1,7 +1,11 @@
 /**
  * @module MentaClientTypes
  */
-import { CoreClientConfig } from "@mentaproject/core/types";
+import {
+  CoreClientConfig,
+  PasskeySigner,
+  Transport,
+} from "@mentaproject/core/types";
 import { ICache } from "./Cache";
 import { watchBlockNumber, watchBlocks } from "@mentaproject/core/actions";
 import { IPersistenceAdapter } from "./PersistenceAdapter";
@@ -11,13 +15,13 @@ import { IPersistenceAdapter } from "./PersistenceAdapter";
  * @interface CacheConfig
  */
 export interface CacheConfig {
-    /**
-     * Time-to-live policies for different RPC methods.
-     * Keys are RPC method names (e.g., "eth_getBlockByNumber"), and values are
-     * the TTL in milliseconds for caching responses from those methods.
-     */
-    ttl_policies: Record<string, number>;
-};
+  /**
+   * Time-to-live policies for different RPC methods.
+   * Keys are RPC method names (e.g., "eth_getBlockByNumber"), and values are
+   * the TTL in milliseconds for caching responses from those methods.
+   */
+  ttl_policies: Record<string, number>;
+}
 
 /**
  * Configuration options for the MentaClient.
@@ -25,33 +29,41 @@ export interface CacheConfig {
  * @interface MentaClientConfig
  */
 export interface MentaClientConfig extends CoreClientConfig {
-    /**
-     * Optional cache implementation for the client.
-     * If provided, the client will use this cache for RPC responses.
-     */
-    cache?: ICache;
-    /**
-     * Optional persistence adapter for local data storage.
-     * If provided, the client will use this adapter to persist and retrieve data.
-     */
-    persistenceAdapter?: IPersistenceAdapter;
-};
+  /**
+   * Optional cache implementation for the client.
+   * If provided, the client will use this cache for RPC responses.
+   */
+  cache?: ICache;
+  /**
+   * Optional persistence adapter for local data storage.
+   * If provided, the client will use this adapter to persist and retrieve data.
+   */
+  persistenceAdapter?: IPersistenceAdapter;
+  /**
+   * Bundler transport used for userOperations
+   */
+  bundlerTransport: Transport;
+  /**
+   * Passkey compatible signer used for signing user operations
+   */
+  signer: PasskeySigner;
+}
 
 /**
  * Defines the available client events and their corresponding watch functions.
  * These functions are used to subscribe to real-time updates from the client.
  */
 export const ClientEvents = {
-    /**
-     * Event for new blocks.
-     * Uses the {@link watchBlocks} function from `@mentaproject/core`.
-     */
-    block: watchBlocks,
-    /**
-     * Event for new block numbers.
-     * Uses the {@link watchBlockNumber} function from `@mentaproject/core`.
-     */
-    blockNumber: watchBlockNumber,
+  /**
+   * Event for new blocks.
+   * Uses the {@link watchBlocks} function from `@mentaproject/core`.
+   */
+  block: watchBlocks,
+  /**
+   * Event for new block numbers.
+   * Uses the {@link watchBlockNumber} function from `@mentaproject/core`.
+   */
+  blockNumber: watchBlockNumber,
 };
 
 /**
@@ -60,8 +72,8 @@ export const ClientEvents = {
  * @template TEvent The name of the event (e.g., 'block' or 'blockNumber') for which to get the listener callback type.
  */
 export type GetListenerCallback<TEvent extends keyof typeof ClientEvents> =
-    Parameters<typeof ClientEvents[TEvent]>[1] extends infer P
-        ? P extends { [K in `on${Capitalize<TEvent>}`]: infer TCallback }
-            ? TCallback
-            : never
-        : never;
+  Parameters<(typeof ClientEvents)[TEvent]>[1] extends infer P
+    ? P extends { [K in `on${Capitalize<TEvent>}`]: infer TCallback }
+      ? TCallback
+      : never
+    : never;

package/src/utils/withCache.ts

@@ -2,7 +2,7 @@
  * @module withCache
  */
 import { watchBlockNumber } from "@mentaproject/core/actions";
-import { CoreClient } from "../types";
+import type { CoreClient } from "@mentaproject/core/types";
 import { ICache } from "../types/Cache";
 import { Methods } from "../types/JsonRPC";
 
@@ -15,7 +15,7 @@ import { Methods } from "../types/JsonRPC";
  * @param cache The cache implementation (ICache) to use for storing and retrieving responses.
  * @returns The enhanced CoreClient instance with caching enabled.
  */
-export function withCache(client: CoreClient, cache: ICache) {
+export function withCache<T extends CoreClient>(client: T, cache: ICache): T {
     watchBlockNumber(client, {
         onBlockNumber: (blockNumber) => {
             cache.setBlockNumber(blockNumber);
@@ -47,4 +47,4 @@ export function withCache(client: CoreClient, cache: ICache) {
     }) as any;
 
     return client;
-};
+}

package/tests/structures/MentaClient.test.ts

@@ -8,6 +8,23 @@ import { PersistenceManager } from '../../src/managers/PersistenceManager';
 import { MentaClientConfig } from '../../src/types/MentaClient';
 import { http } from '@mentaproject/core';
 import { mainnet } from 'viem/chains';
+import type { PasskeySigner } from '@mentaproject/core/types';
+
+// Mock passkey signer for testing
+const mockSigner = {
+  address: '0x0000000000000000000000000000000000000000',
+  type: 'local',
+  source: 'custom',
+  publicKey: '0x00',
+  pubX: 0n,
+  pubY: 0n,
+  authenticatorId: 'mock-authenticator',
+  authenticatorIdHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
+  rpID: 'localhost',
+  signMessage: async () => '0x00',
+  signTransaction: async () => '0x00',
+  signTypedData: async () => '0x00',
+} as unknown as PasskeySigner;
 
 describe('MentaClient', () => {
   let client: MentaClient;
@@ -15,6 +32,8 @@ describe('MentaClient', () => {
     transport: http('http://localhost:8545'),
     chain: mainnet,
     persistenceAdapter: mockPersistenceAdapter,
+    bundlerTransport: http('http://localhost:4337'),
+    signer: mockSigner,
   };
 
   beforeEach(() => {
@@ -33,8 +52,10 @@ describe('MentaClient', () => {
     const clientWithoutPersistence = new MentaClient({
       transport: http('http://localhost:8545'),
       chain: mainnet,
+      bundlerTransport: http('http://localhost:4337'),
+      signer: mockSigner,
     });
     expect(clientWithoutPersistence.persistenceManager).toBeUndefined();
     expect(clientWithoutPersistence.accounts).toBeInstanceOf(AccountManager);
   });
-});
+});