@mentaproject/client 0.1.25 → 0.1.29

package/dist/structures/MentaClient.d.ts

@@ -8,6 +8,7 @@ import { ContractManager } from "../managers/ContractManager";
 import { AccountManager } from "../managers/AccountManager";
 import { PersistenceManager } from "../managers/PersistenceManager";
 import { ClientEvents, GetListenerCallback, MentaClientConfig } from "../types/MentaClient";
+import { Account } from "./Account";
 /**
  * The main client for interacting with the Menta API.
  * It provides managers for blocks, transactions, contracts, and accounts.
@@ -44,6 +45,7 @@ export declare class MentaClient {
      * @description Provides methods to manage and interact with blockchain accounts.
      */
     accounts: AccountManager;
+    account: Account;
     /**
      * Subscribes to a specific client event.
      * @template TEvent The type of the event to listen for.

package/dist/structures/MentaClient.js

@@ -88,6 +88,7 @@ export class MentaClient {
         else {
             this.accounts = new AccountManager(this);
         }
+        this.account = this.accounts.get(this.rpc.account.address);
     }
     async init() {
         let coreClient = createClient(this.params);
@@ -97,6 +98,7 @@ export class MentaClient {
         this._rpc = await createMentaAccount(coreClient, {
             signer: this.params.signer,
             bundlerTransport: this.params.bundlerTransport,
+            publicTransport: this.params.transport,
         });
     }
 }

package/dist/utils/withCache.d.ts

@@ -1,4 +1,4 @@
-import { CoreClient } from "../types";
+import type { CoreClient } from "@mentaproject/core/types";
 import { ICache } from "../types/Cache";
 /**
  * A higher-order function that enhances a class method with caching capabilities.
@@ -9,4 +9,4 @@ import { ICache } from "../types/Cache";
  * @param cache The cache implementation (ICache) to use for storing and retrieving responses.
  * @returns The enhanced CoreClient instance with caching enabled.
  */
-export declare function withCache(client: CoreClient, cache: ICache): CoreClient;
+export declare function withCache<T extends CoreClient>(client: T, cache: ICache): T;

package/dist/utils/withCache.js

@@ -39,4 +39,3 @@ export function withCache(client, cache) {
     });
     return client;
 }
-;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentaproject/client",
-  "version": "0.1.25",
+  "version": "0.1.29",
   "description": "High level EVM library used into the Menta App to facilitate Blockchain interactions. ",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -32,7 +32,7 @@
   "license": "ISC",
   "dependencies": {
     "@mentaproject/contracts": "^0.0.11",
-    "@mentaproject/core": "^0.5.13",
+    "@mentaproject/core": "^0.6.1",
     "@modelcontextprotocol/sdk": "^1.13.0",
     "@shazow/whatsabi": "^0.21.1"
   },

package/src/structures/MentaClient.ts

@@ -1,7 +1,7 @@
 /**
  * @module MentaClient
  */
-import type { CoreClient, MentaAccountClient } from "@mentaproject/core/types";
+import type { MentaAccountClient } from "@mentaproject/core/types";
 import { createMentaAccount } from "@mentaproject/core/clients";
 
 import { BlockManager } from "../managers/BlockManager";
@@ -16,6 +16,7 @@ import {
 } from "../types/MentaClient";
 import { withCache } from "../utils/withCache";
 import { createClient } from "@mentaproject/core";
+import { Account } from "./Account";
 
 /**
  * The main client for interacting with the Menta API.
@@ -59,6 +60,8 @@ export class MentaClient {
    */
   public accounts!: AccountManager;
 
+  public account: Account;
+
   /**
    * Subscribes to a specific client event.
    * @template TEvent The type of the event to listen for.
@@ -128,10 +131,12 @@ export class MentaClient {
     } else {
       this.accounts = new AccountManager(this);
     }
+
+    this.account = this.accounts.get(this.rpc.account.address);
   }
 
   async init() {
-    let coreClient = createClient(this.params) as CoreClient;
+    let coreClient = createClient(this.params);
 
     if (this.params.cache) {
       coreClient = withCache(coreClient, this.params.cache);
@@ -140,6 +145,7 @@ export class MentaClient {
     this._rpc = await createMentaAccount(coreClient, {
       signer: this.params.signer,
       bundlerTransport: this.params.bundlerTransport,
+      publicTransport: this.params.transport,
     });
   }
 

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);
   });
-});
+});