@mentaproject/client 0.1.17 → 0.1.18

package/dist/managers/AccountManager.js

@@ -42,7 +42,7 @@ export class AccountManager {
     * ```
      */
     get(address) {
-        return new Account(this.client, address, this.persistenceManager);
+        return new Account(this.client, { address: address }, this.persistenceManager);
     }
     ;
 }

package/dist/managers/PersistenceManager.d.ts

@@ -1,8 +1,7 @@
-import { Address } from '@mentaproject/core/types';
-import { IPersistenceAdapter } from '../types/PersistenceAdapter';
+import { Address, Transaction as RawTransaction } from '@mentaproject/core/types';
 import { Account } from '../structures/Account';
 import { MentaClient } from '../structures';
-import { GetTransactionsParams, JSONTransaction } from 'src/types';
+import { GetTransactionsParams, IPersistenceAdapter } 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,7 +20,7 @@ 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<JSONTransaction[]>;
+    getTransactions(address: Address, params: GetTransactionsParams): Promise<RawTransaction[]>;
     /**
      * 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.

package/dist/managers/PersistenceManager.js

@@ -20,8 +20,7 @@ export class PersistenceManager {
      * @returns A promise that resolves to an array of transactions with associated account information.
      */
     async getTransactions(address, params) {
-        const localTransactions = await this.persistenceAdapter.getTransactions(address, params);
-        return localTransactions;
+        return await this.persistenceAdapter.getTransactions(address, params);
     }
     /**
      * Synchronizes an account's transactions from the remote source to the local persistence.

package/dist/structures/Account.d.ts

@@ -20,7 +20,7 @@ export declare class Account implements AccountData {
      * @param address The blockchain address of the account.
      * @param persistenceManager An optional PersistenceManager instance for caching and data synchronization.
      */
-    constructor(client: MentaClient, address: Address, persistenceManager?: PersistenceManager);
+    constructor(client: MentaClient, data: AccountData, persistenceManager?: PersistenceManager);
     /**
      * Checks if the account's address belongs to a smart contract.
      * @description This method queries the blockchain for the code associated with the account's address.

package/dist/structures/Account.js

@@ -14,9 +14,9 @@ export class Account {
      * @param address The blockchain address of the account.
      * @param persistenceManager An optional PersistenceManager instance for caching and data synchronization.
      */
-    constructor(client, address, persistenceManager) {
+    constructor(client, data, persistenceManager) {
         this.client = client;
-        this.address = address;
+        this.address = data.address;
         this.persistenceManager = persistenceManager;
     }
     /**

package/dist/structures/Block.js

@@ -38,7 +38,7 @@ export class Block {
         this.uncles = data.uncles;
         this.withdrawals = data.withdrawals;
         this.withdrawalsRoot = data.withdrawalsRoot;
-        this.miner = new Account(this.client, data.miner);
+        this.miner = new Account(this.client, { address: data.miner });
         if (!data.transactions || data.transactions.length === 0) {
             const parsed = data.transactions.map((data) => typeof data === "string" ? data : this.client.transactions.parse(data));
             this.transactions = parsed;

package/dist/structures/Transaction.js

@@ -39,8 +39,8 @@ export class Transaction {
         this.blockHash = data.blockHash;
         this.blockNumber = data.blockNumber;
         this.typeHex = data.typeHex;
-        this.from = new Account(this.client, data.from);
-        this.to = data.to ? new Account(this.client, data.to) : undefined;
+        this.from = data.from ? this.client.accounts.get(typeof data.from === "string" ? data.from : data.from) : undefined;
+        this.to = data.to ? this.client.accounts.get(typeof data.to === "string" ? data.to : data.to) : undefined;
     }
     ;
     /**
@@ -54,8 +54,8 @@ export class Transaction {
             return undefined;
         const calls = traces.filter(t => t.type === "call" && t.action !== undefined);
         return calls.map(c => ({
-            from: new Account(this.client, c.action.from),
-            to: new Account(this.client, c.action.to),
+            from: new Account(this.client, { address: c.action.from }),
+            to: new Account(this.client, { address: c.action.to }),
             value: hexToBigInt(c.action.value),
             input: c.action.input,
             gas: hexToBigInt(c.action.gas),

package/dist/types/PersistenceAdapter.d.ts

@@ -1,7 +1,6 @@
-import { Address } from '@mentaproject/core/types';
+import { Address, Transaction as RawTransaction } 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.
@@ -18,9 +17,9 @@ export interface IPersistenceAdapter {
      * @method getTransactions
      * @description Retrieves a paginated list of transactions for a specific account based on provided filters.
      * @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.
+     * @returns {Promise<RawTransaction[]>} A Promise that resolves with transactions data.
      */
-    getTransactions(address: Address, params: GetTransactionsParams): Promise<JSONTransaction[]>;
+    getTransactions(address: Address, params: GetTransactionsParams): Promise<RawTransaction[]>;
     /**
      * @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/toJSON.js

@@ -52,7 +52,7 @@ export async function toJSON({ obj, depth = 0 }) {
     const promises = [];
     for (const key in obj) {
         // skip class related properties
-        if (key === "toJSON" || key === "constructor" || key === "client")
+        if (key === "toJSON" || key === "constructor" || key === "client" || key === "persistenceManager")
             continue;
         const prop = obj[key];
         if (typeof prop === "function") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentaproject/client",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "description": "High level EVM library used into the Menta App to facilitate Blockchain interactions. ",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/test.ts

@@ -50,7 +50,7 @@ const client = new MentaClient({
                         transactions.set(checksumed, []);
                     };
 
-                    const jsonTransaction = await transaction.toJSON();
+                    const jsonTransaction = await transaction.toJSON(0);
                     transactions.get(checksumed)?.push(jsonTransaction);
                 };
 
@@ -80,5 +80,5 @@ const client = new MentaClient({
     await account.syncTransactions(20)
     const res = await account.transactions({ limit: 20 });
 
-    console.log(res.length);
+    console.log(res[0]);
 })();

package/tests/structures/Account.test.ts

@@ -45,8 +45,11 @@ describe('Account', () => {
       parse: jest.fn().mockImplementation((data) => new Transaction(mockMentaClient, data)),
       send: jest.fn(),
     } as any;
+    mockMentaClient.accounts = {
+      get: jest.fn().mockImplementation((address) => new Account(mockMentaClient, { address: address })),
+    } as any;
     mockPersistenceManager = new MockedPersistenceManager(mockMentaClient, {} as any) as jest.Mocked<PersistenceManager>;
-    account = new Account(mockMentaClient, mockAddress, mockPersistenceManager);
+    account = new Account(mockMentaClient, { address: mockAddress }, mockPersistenceManager);
   });
 
   describe('constructor', () => {
@@ -151,7 +154,7 @@ describe('Account', () => {
     });
 
     it('should fetch transactions from remote if persistence is not configured', async () => {
-        const localAccount = new Account(mockMentaClient, mockAddress); // No persistenceManager
+        const localAccount = new Account(mockMentaClient, { address: mockAddress }); // No persistenceManager
         const mockHashes: Hash[] = ['0x1', '0x2'];
         const mockBaseTx = {
             blockHash: '0xblockhash',
@@ -195,14 +198,14 @@ describe('Account', () => {
     });
 
     it('should throw an error if persistence manager is not configured', async () => {
-      const localAccount = new Account(mockMentaClient, mockAddress);
+      const localAccount = new Account(mockMentaClient, { address: mockAddress });
       await expect(localAccount.syncTransactions()).rejects.toThrow('The persistence module is not configured.');
     });
   });
 
   describe('tokenTransactions', () => {
     it('should throw an error if persistence is not configured', async () => {
-        const localAccount = new Account(mockMentaClient, mockAddress);
+        const localAccount = new Account(mockMentaClient, { address: mockAddress });
         await expect(localAccount.tokenTransactions(mockAddress)).rejects.toThrow('The persistence module is not configured.');
     });
 

package/tests/structures/Block.test.ts

@@ -59,7 +59,7 @@ describe('Block', () => {
       expect(block).toBeInstanceOf(Block);
       expect(block.number).toBe(123n);
       expect(block.hash).toBe('0xblockhash');
-      expect(Account).toHaveBeenCalledWith(mockMentaClient, mockMinerAddress);
+      expect(Account).toHaveBeenCalledWith(mockMentaClient, { address: mockMinerAddress });
       expect(block.miner).toBeInstanceOf(Account);
     });
 

package/tests/structures/Transaction.test.ts

@@ -13,15 +13,17 @@ jest.mock('@mentaproject/core/actions', () => ({
   getBlock: jest.fn(),
 }));
 
-// Mocking MentaClient
-const mockMentaClient = {
-  rpc: {},
-} as unknown as MentaClient;
-
 // Mocking structures
 jest.mock('../../src/structures/Account');
 jest.mock('../../src/structures/Block');
 
+const mockMentaClient = {
+  rpc: {},
+  accounts: {
+    get: jest.fn(),
+  },
+} as unknown as MentaClient;
+
 describe('Transaction', () => {
   const mockTxHash: Hash = '0xabcdef123456';
   const mockFromAddress: Address = '0xfrom123';
@@ -50,6 +52,9 @@ describe('Transaction', () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    (mockMentaClient.accounts.get as jest.Mock).mockImplementation(
+      (address: Address) => new Account(mockMentaClient, { address }),
+    );
     transaction = new Transaction(mockMentaClient, mockRawTx);
   });
 
@@ -58,8 +63,8 @@ describe('Transaction', () => {
       expect(transaction).toBeInstanceOf(Transaction);
       expect(transaction.hash).toBe(mockTxHash);
       expect(transaction.value).toBe(1000n);
-      expect(Account).toHaveBeenCalledWith(mockMentaClient, mockFromAddress);
-      expect(Account).toHaveBeenCalledWith(mockMentaClient, mockToAddress);
+      expect(mockMentaClient.accounts.get).toHaveBeenCalledWith(mockFromAddress);
+      expect(mockMentaClient.accounts.get).toHaveBeenCalledWith(mockToAddress);
       expect(transaction.from).toBeInstanceOf(Account);
       expect(transaction.to).toBeInstanceOf(Account);
     });