@mentaproject/client 0.1.14 → 0.1.16

package/dist/managers/PersistenceManager.d.ts

@@ -1,8 +1,8 @@
 import { Address } from '@mentaproject/core/types';
 import { IPersistenceAdapter } from '../types/PersistenceAdapter';
 import { Account } from '../structures/Account';
-import { MentaClient, Transaction } from '../structures';
-import { GetTransactionsParams } from 'src/types';
+import { MentaClient } from '../structures';
+import { GetTransactionsParams, JSONTransaction } from 'src/types';
 /**
  * Manages the persistence of data, including transactions, using a specified persistence adapter.
  * It handles fetching data from both local storage and remote sources, and synchronizing them.
@@ -21,12 +21,13 @@ export declare class PersistenceManager {
      * @param params - Parameters for retrieving transactions.
      * @returns A promise that resolves to an array of transactions with associated account information.
      */
-    getTransactions(address: Address, params: GetTransactionsParams): Promise<Transaction[]>;
+    getTransactions(address: Address, params: GetTransactionsParams): Promise<JSONTransaction[]>;
     /**
      * Synchronizes an account's transactions from the remote source to the local persistence.
      * It fetches new transactions starting from the last synced block and updates the local storage.
      * @param account - The account whose transactions are to be synchronized.
+     * @param limit - The maximum number of transactions to fetch.
      * @returns A promise that resolves when the synchronization is complete.
      */
-    syncTransactions(account: Account, toBlock?: bigint): Promise<void>;
+    syncTransactions(account: Account, limit?: number): Promise<void>;
 }

package/dist/managers/PersistenceManager.js

@@ -27,16 +27,18 @@ export class PersistenceManager {
      * Synchronizes an account's transactions from the remote source to the local persistence.
      * It fetches new transactions starting from the last synced block and updates the local storage.
      * @param account - The account whose transactions are to be synchronized.
+     * @param limit - The maximum number of transactions to fetch.
      * @returns A promise that resolves when the synchronization is complete.
      */
-    async syncTransactions(account, toBlock) {
-        const lastBlock = toBlock ?? (await getBlockNumber(this.client.rpc));
+    async syncTransactions(account, limit = 100000) {
         const lastSyncedBlock = await this.persistenceAdapter.getLastSyncedBlock(account.address);
-        const fromBlock = lastSyncedBlock ? lastSyncedBlock + 1n : 0n;
+        const lastBlock = lastSyncedBlock ?? 0n;
+        const fromBlock = lastSyncedBlock ? lastSyncedBlock + 1n : (await getBlockNumber(this.client.rpc));
         const newTransactions = await account.transactions({
             fromBlock: fromBlock,
-            toBlock: lastBlock
-        });
+            toBlock: lastBlock,
+            limit: limit
+        }, true);
         if (newTransactions.length > 0) {
             await this.persistenceAdapter.upsertTransactions(newTransactions);
             const latestBlock = bigIntMax(...newTransactions.map(t => t.blockNumber || 0n));

package/dist/structures/Account.d.ts

@@ -65,18 +65,19 @@ export declare class Account implements AccountData {
      * @param {number} [options.page] - The page number for paginated results.
      * @param {number} [options.offset] - The number of items to skip from the beginning of the result set.
      * @param {'asc' | 'desc'} [options.sort] - The sorting order for transactions based on block number ('asc' for ascending, 'desc' for descending).
+     * @param {boolean} [forceFetch=false] - Forces the method to fetch transactions from the remote source even if they are already cached. (mostly used internally)
      * @returns {Promise<Transaction[]>} A promise that resolves to an array of transactions.
      */
-    transactions(params: GetTransactionsParams): Promise<Transaction[]>;
+    transactions(params: GetTransactionsParams, forceFetch?: boolean): Promise<Transaction[]>;
     /**
      * Synchronizes the account's transactions with the remote data source using the configured `PersistenceManager`.
      * @description This method initiates a synchronization process to ensure that the local cache of transactions
      * for this account is up-to-date with the blockchain.
-     * @param {bigint} [toBlock] The block number up to which to synchronize transactions.
+     * @param {number} [limit] The maximum number of transactions to synchronize.
      * @returns {Promise<void>} A promise that resolves when the synchronization process is complete.
      * @throws {Error} If the persistence module is not configured.
      */
-    syncTransactions(toBlock?: bigint): Promise<void>;
+    syncTransactions(limit?: number): Promise<void>;
     /**
      * Retrieves transactions involving a specific token. (not implemented yet)
      * @description This method queries the persistence adapter to retrieve transactions involving a specific token.

package/dist/structures/Account.js

@@ -1,4 +1,5 @@
 import { fetchByBlockRange, getBalance, getBlockNumber, getCode, getTransaction, getTransactionCount, sendTransaction, traceFilter } from "@mentaproject/core/actions";
+import { Transaction } from "./Transaction";
 import { toHex } from "@mentaproject/core/utils";
 import { getContractType } from "@mentaproject/contracts";
 import { toJSON } from "../utils/toJSON";
@@ -91,30 +92,31 @@ export class Account {
      * @param {number} [options.page] - The page number for paginated results.
      * @param {number} [options.offset] - The number of items to skip from the beginning of the result set.
      * @param {'asc' | 'desc'} [options.sort] - The sorting order for transactions based on block number ('asc' for ascending, 'desc' for descending).
+     * @param {boolean} [forceFetch=false] - Forces the method to fetch transactions from the remote source even if they are already cached. (mostly used internally)
      * @returns {Promise<Transaction[]>} A promise that resolves to an array of transactions.
      */
-    async transactions(params) {
-        if (!this.persistenceManager) {
+    async transactions(params, forceFetch = false) {
+        if (!this.persistenceManager || forceFetch) {
             // If persistence is not configured, fetch directly from remote
             const hashes = await this._fetchTransactions(params);
             const transactions = await Promise.all(hashes.map(hash => this.client.transactions.get({ hash })));
             return transactions;
         }
         const cachedTransactions = await this.persistenceManager.getTransactions(this.address, params);
-        return cachedTransactions;
+        return cachedTransactions.map(t => new Transaction(this.client, t));
     }
     /**
      * Synchronizes the account's transactions with the remote data source using the configured `PersistenceManager`.
      * @description This method initiates a synchronization process to ensure that the local cache of transactions
      * for this account is up-to-date with the blockchain.
-     * @param {bigint} [toBlock] The block number up to which to synchronize transactions.
+     * @param {number} [limit] The maximum number of transactions to synchronize.
      * @returns {Promise<void>} A promise that resolves when the synchronization process is complete.
      * @throws {Error} If the persistence module is not configured.
      */
-    async syncTransactions(toBlock) {
+    async syncTransactions(limit = 1000) {
         if (!this.persistenceManager)
             throw new Error("The persistence module is not configured.");
-        await this.persistenceManager.syncTransactions(this, toBlock);
+        await this.persistenceManager.syncTransactions(this, limit);
     }
     /**
      * Retrieves transactions involving a specific token. (not implemented yet)
@@ -138,11 +140,11 @@ export class Account {
     async toJSON(depth = 1) {
         return await toJSON({
             obj: {
-                ...this,
-                isContract: this.isContract,
-                contractType: this.contractType,
-                ETHBalance: this.ETHBalance,
-                transactionCount: this.transactionCount,
+                address: this.address,
+                isContract: this.isContract.bind(this),
+                contractType: this.contractType.bind(this),
+                ETHBalance: this.ETHBalance.bind(this),
+                transactionCount: this.transactionCount.bind(this),
             },
             depth
         });
@@ -166,12 +168,8 @@ export class Account {
                 toBlock: toHex(toBlock),
                 toAddress: this.address
             });
-            const traces = outgoing.concat(incoming);
-            return traces.map(t => ({
-                blockNumber: BigInt(t.blockNumber),
-                index: t.transactionPosition,
-                hash: t.transactionHash
-            }));
+            const traces = outgoing.concat(incoming).sort((a, b) => a.blockNumber - b.blockNumber);
+            return traces.map(t => t.transactionHash);
         };
         return await fetchByBlockRange({
             toBlock: BigInt(toBlock !== undefined ? toBlock : 0),

package/dist/types/Account.d.ts

@@ -33,5 +33,6 @@ export type AccountData = {
 export type JSONAccount = AccountData & {
     isContract: boolean;
     ETHBalance: string;
+    contractType: string;
     transactionCount: number;
 };

package/dist/types/PersistenceAdapter.d.ts

@@ -1,6 +1,7 @@
 import { Address } from '@mentaproject/core/types';
 import { Transaction } from '../structures/Transaction';
 import { GetTransactionsParams } from './Account';
+import { JSONTransaction } from './Transaction';
 /**
  * @interface IPersistenceAdapter
  * @description Defines the contract for persistence layers, ensuring consistent data storage and retrieval operations.
@@ -19,7 +20,7 @@ export interface IPersistenceAdapter {
      * @param {GetTransactionsFilters} filters - An object containing filters for retrieving transactions, such as account address, block range, pagination, and sort order.
      * @returns {Promise<Transaction[]>} A Promise that resolves with an array of transactions matching the filters.
      */
-    getTransactions(address: Address, params: GetTransactionsParams): Promise<Transaction[]>;
+    getTransactions(address: Address, params: GetTransactionsParams): Promise<JSONTransaction[]>;
     /**
      * @method getLastSyncedBlock
      * @description Retrieves the last synced block number for a given account. This is used to track the synchronization progress of an account's transactions.

package/dist/utils/withCache.js

@@ -23,7 +23,7 @@ export function withCache(client, cache) {
     // 3. We replace the client's `request` method
     client.request = (async (args) => {
         const { method, params } = args;
-        const cacheKey = `${client.chain.id}:${method}:${JSON.stringify(params || [])}`;
+        const cacheKey = `${client.chain.id}:${method}:${JSON.stringify(params || [], (_, v) => typeof v === 'bigint' ? v.toString() : v)}`;
         let result;
         if (method !== "eth_blockNumber")
             result = cache.get(cacheKey);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentaproject/client",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "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.9",
-    "@mentaproject/core": "^0.5.2",
+    "@mentaproject/core": "^0.5.3",
     "@modelcontextprotocol/sdk": "^1.13.0",
     "@shazow/whatsabi": "^0.21.1"
   },

package/test.ts

@@ -1,24 +1,28 @@
-import { http } from "@mentaproject/core";
-import { MentaClient } from "./src";
+import { Address, checksumAddress, http } from "@mentaproject/core";
+import { MentaClient, Transaction } from "./src";
 import { privateKeyToAccount, generatePrivateKey } from "viem/accounts"
 import { mainnet } from "@mentaproject/core/chains";
 import { MemoryCache } from "./src/structures/Cache";
 import { watchBlockNumber, watchBlocks } from "@mentaproject/core/actions";
 import { writeFileSync } from "fs";
+import { JSONTransaction } from "./src/types";
 
 const viemAccount = privateKeyToAccount(generatePrivateKey());
 
 let counter = 0;
+let lastSyncedBlock = new Map<Address, bigint>();
+let transactions = new Map<Address, JSONTransaction[]>();
+
 const client = new MentaClient({
     account: viemAccount,
     transport: http("https://ethereum-rpc.publicnode.com", {
         batch: {
-            batchSize: 5,
-            wait: 500,
+            batchSize: 50,
+            wait: 20,
         },
         onFetchRequest: async (r) => {
-            const data = await r.json();
-            console.log(data);
+            // const data = await r.json();
+            // console.log(data.map(j => `${j.method}(${j.params?.map(p => JSON.stringify(p)).join(', ')})`).join('\n'));
             // console.log(`>> ${counter} requests`);
 
             // console.log(`>> ${r.url}\n>> ${req.map(j => j.method).join(', ')}\n>> ${delay / 1000}s\n`)
@@ -26,14 +30,55 @@ const client = new MentaClient({
         // onFetchResponse: (r) => console.log(`<<: ${r.url}`),
     }),
     cache: new MemoryCache(0n, { maxSize: 1000, defaultTtl: 1 }),
+    persistenceAdapter: {
+        getLastSyncedBlock: async (accountAddress: Address) => {
+            return lastSyncedBlock.get(accountAddress) ?? null;
+        },
+        getTransactions: async (address: Address, params) => {
+            return transactions.get(address) ?? [];
+        },
+        upsertTransactions: async (txs: Transaction[]) => {
+            console.log("upsertTransactions", txs.length);
+            for (const transaction of txs) {
+                const fromAddress = transaction.from?.address;
+                const toAddress = transaction.to?.address;
+
+                if (fromAddress) {
+                    const checksumed = checksumAddress(fromAddress);
+
+                    if (!transactions.has(checksumed)) {
+                        transactions.set(checksumed, []);
+                    };
+
+                    const jsonTransaction = await transaction.toJSON();
+                    transactions.get(checksumed)?.push(jsonTransaction);
+                };
+
+                if (toAddress) {
+                    const checksumed = checksumAddress(toAddress);
+
+                    if (!transactions.has(checksumed)) {
+                        transactions.set(checksumed, []);
+                    };
+
+                    const jsonTransaction = await transaction.toJSON();
+                    transactions.get(checksumed)?.push(jsonTransaction);
+                }
+            }
+        },
+        setLastSyncedBlock: async (accountAddress: Address, blockNumber: bigint) => {
+            lastSyncedBlock.set(accountAddress, blockNumber);
+        },
+    },
     chain: mainnet
 });
 
 (async () => {
     console.log("Watching for new blocks and block numbers...");
 
-    const item = await client.transactions.get({ hash: "0x2ac872604f7ce5e132417b881bfa80a66836ca669c0720e8ce2cc40c9c92a696" });
-    const json = await item.toJSON(1);
+    const account = client.accounts.get("0x53b9B72DC6f96Eb4B54143B211B22e2548e4cf5c");
+    await account.syncTransactions(20)
+    const res = await account.transactions({ limit: 20 });
 
-    writeFileSync("./test.json", JSON.stringify(json, null, 2));
+    console.log(res.length);
 })();

package/tests/structures/Account.test.ts

@@ -8,6 +8,7 @@ import { Address, Hash } from '@mentaproject/core/types';
 
 // Mocking the core actions
 jest.mock('@mentaproject/core/actions', () => ({
+  getBlock: jest.fn(),
   getCode: jest.fn(),
   getContractType: jest.fn(),
   sendTransaction: jest.fn(),
@@ -24,26 +25,27 @@ jest.mock('@mentaproject/contracts', () => ({
   getContractType: jest.fn(),
 }));
 
-// Mocking the MentaClient and its dependencies
-const mockMentaClient = {
-  rpc: {},
-  transactions: {
-    parse: jest.fn((data) => new Transaction(mockMentaClient as any, data)),
-    get: jest.fn(),
-  },
-} as unknown as MentaClient;
+jest.mock('../../src/structures/MentaClient');
+jest.mock('../../src/managers/PersistenceManager');
 
-const mockPersistenceManager = {
-  getTransactions: jest.fn(),
-  syncTransactions: jest.fn(),
-} as unknown as PersistenceManager;
+const MockedMentaClient = MentaClient as jest.MockedClass<typeof MentaClient>;
+const MockedPersistenceManager = PersistenceManager as jest.MockedClass<typeof PersistenceManager>;
 
 describe('Account', () => {
   const mockAddress: Address = '0x1234567890123456789012345678901234567890';
   let account: Account;
+  let mockMentaClient: jest.Mocked<MentaClient>;
+  let mockPersistenceManager: jest.Mocked<PersistenceManager>;
 
   beforeEach(() => {
     jest.clearAllMocks();
+    mockMentaClient = new MockedMentaClient({} as any) as jest.Mocked<MentaClient>;
+    mockMentaClient.transactions = {
+      get: jest.fn(),
+      parse: jest.fn().mockImplementation((data) => new Transaction(mockMentaClient, data)),
+      send: jest.fn(),
+    } as any;
+    mockPersistenceManager = new MockedPersistenceManager(mockMentaClient, {} as any) as jest.Mocked<PersistenceManager>;
     account = new Account(mockMentaClient, mockAddress, mockPersistenceManager);
   });
 
@@ -82,8 +84,28 @@ describe('Account', () => {
 
   describe('sendETH', () => {
     it('should send ETH and return a Transaction object', async () => {
-      const mockTxHash: Hash = '0x987654321';
-      const mockTxData = { hash: mockTxHash, from: mockAddress, to: mockAddress, value: 1000n };
+      const mockTxHash: Hash = '0x98765432109876543210987654321098765432109876543210987654321098765';
+      const mockTxData: import('@mentaproject/core/types').Transaction = {
+        blockHash: '0xblockhash',
+        blockNumber: 123n,
+        from: mockAddress,
+        gas: 21000n,
+        gasPrice: 1000000000n,
+        hash: mockTxHash,
+        input: '0x',
+        nonce: 1,
+        r: '0xr',
+        s: '0xs',
+        to: mockAddress,
+        transactionIndex: 0,
+        type: 'legacy',
+        v: 27n,
+        value: 1000n,
+        accessList: undefined,
+        typeHex: null,
+      };
+      
+      (coreActions.sendTransaction as jest.Mock).mockResolvedValue(mockTxHash);
       
       (coreActions.sendTransaction as jest.Mock).mockResolvedValue(mockTxHash);
       (coreActions.getTransaction as jest.Mock).mockResolvedValue(mockTxData);
@@ -120,27 +142,45 @@ describe('Account', () => {
 
   describe('transactions', () => {
     it('should fetch transactions from persistence manager if available', async () => {
-      const mockTransactions = [new Transaction(mockMentaClient, { hash: '0x1' } as any)];
-      (mockPersistenceManager.getTransactions as jest.Mock).mockResolvedValue(mockTransactions);
+      const mockTxJSONs = [{ hash: '0x1' }];
+      (mockPersistenceManager.getTransactions as jest.Mock).mockResolvedValue(mockTxJSONs as any);
 
       const result = await account.transactions({});
       expect(mockPersistenceManager.getTransactions).toHaveBeenCalledWith(mockAddress, {});
-      expect(result).toEqual(mockTransactions);
+      expect(result.map(tx => tx.hash)).toEqual(mockTxJSONs.map(tx => tx.hash));
     });
 
     it('should fetch transactions from remote if persistence is not configured', async () => {
         const localAccount = new Account(mockMentaClient, mockAddress); // No persistenceManager
         const mockHashes: Hash[] = ['0x1', '0x2'];
-        const mockTx1 = new Transaction(mockMentaClient, { hash: '0x1' } as any);
-        const mockTx2 = new Transaction(mockMentaClient, { hash: '0x2' } as any);
+        const mockBaseTx = {
+            blockHash: '0xblockhash',
+            blockNumber: 123n,
+            from: mockAddress,
+            gas: 21000n,
+            gasPrice: 1000000000n,
+            input: '0x',
+            nonce: 1,
+            r: '0xr',
+            s: '0xs',
+            to: mockAddress,
+            transactionIndex: 0,
+            type: 'legacy',
+            v: 27n,
+            value: 1000n,
+            accessList: undefined,
+            typeHex: null,
+        };
+        const mockTx1 = new Transaction(mockMentaClient, { ...mockBaseTx, hash: '0x1' } as any);
+        const mockTx2 = new Transaction(mockMentaClient, { ...mockBaseTx, hash: '0x2' } as any);
   
         jest.spyOn(localAccount as any, '_fetchTransactions').mockResolvedValue(mockHashes);
-        (mockMentaClient.transactions.get as jest.Mock).mockImplementation(({ hash }) => {
-            if (hash === '0x1') return Promise.resolve(mockTx1);
-            if (hash === '0x2') return Promise.resolve(mockTx2);
-            return Promise.resolve(null);
+        (mockMentaClient.transactions.get as jest.Mock).mockImplementation(async ({ hash }) => {
+            if (hash === '0x1') return mockTx1;
+            if (hash === '0x2') return mockTx2;
+            return null as any;
         });
-  
+
         const result = await localAccount.transactions({});
         expect(localAccount['_fetchTransactions']).toHaveBeenCalled();
         expect(mockMentaClient.transactions.get).toHaveBeenCalledTimes(2);
@@ -150,8 +190,8 @@ describe('Account', () => {
 
   describe('syncTransactions', () => {
     it('should call syncTransactions on the persistence manager', async () => {
-      await account.syncTransactions(1n);
-      expect(mockPersistenceManager.syncTransactions).toHaveBeenCalledWith(account, 1n);
+      await account.syncTransactions(1);
+      expect(mockPersistenceManager.syncTransactions).toHaveBeenCalledWith(account, 1);
     });
 
     it('should throw an error if persistence manager is not configured', async () => {

package/tests/structures/Block.test.ts

@@ -2,8 +2,8 @@ import { Block } from '../../src/structures/Block';
 import { MentaClient } from '../../src/structures/MentaClient';
 import { Account } from '../../src/structures/Account';
 import { Transaction } from '../../src/structures/Transaction';
-import { IBlockData } from '../../src/types/Block';
 import { Address, Hash } from '@mentaproject/core/types';
+import { BlockData } from '../../src/types';
 
 // Mocking MentaClient
 const mockMentaClient = {
@@ -21,7 +21,7 @@ describe('Block', () => {
   const mockMinerAddress: Address = '0xminer123';
   const mockTxHash: Hash = '0xhash123';
 
-  const mockBlockData: IBlockData = {
+  const mockBlockData: BlockData = {
     number: 123n,
     hash: '0xblockhash',
     parentHash: '0xparenthash',

package/tests/structures/Transaction.test.ts

@@ -3,7 +3,7 @@ import { MentaClient } from '../../src/structures/MentaClient';
 import { Account } from '../../src/structures/Account';
 import { Block } from '../../src/structures/Block';
 import * as coreActions from '@mentaproject/core/actions';
-import { RawTransaction, Hash, Address } from '@mentaproject/core/types';
+import { Transaction as RawTransaction, Hash, Address } from '@mentaproject/core/types';
 
 // Mocking core actions
 jest.mock('@mentaproject/core/actions', () => ({
@@ -83,8 +83,8 @@ describe('Transaction', () => {
 
       expect(coreActions.traceTransaction).toHaveBeenCalledWith(mockMentaClient.rpc, mockTxHash);
       expect(calls).toHaveLength(1);
-      expect(calls[0].value).toBe(100n);
-      expect(calls[0].from).toBeInstanceOf(Account);
+      expect(calls![0].value).toBe(100n);
+      expect(calls![0].from).toBeInstanceOf(Account);
     });
   });
 

package/tests/utils/toJSON.test.ts

@@ -63,7 +63,7 @@ describe('toJSON', () => {
       a: 1,
       toJSON: () => ({}),
       constructor: () => {},
-      rpcClient: {},
+      client: {},
     };
     const json = await toJSON({ obj });
     expect(json).toEqual({ a: 1 });