@mentaproject/client 0.1.17 → 0.1.19

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.');
     });
 
@@ -218,12 +221,12 @@ describe('Account', () => {
         (coreActions.getBalance as jest.Mock).mockResolvedValue(100n);
         (coreActions.getTransactionCount as jest.Mock).mockResolvedValue(5);
 
-        const json = await account.toJSON();
+        const json = await account.toJSON(1);
         
         expect(json.address).toBe(mockAddress);
         expect(json.isContract).toBe(true);
         expect(json.contractType).toBe('ERC20');
-        expect(json.ETHBalance).toBe('100');
+        expect(json.ETHBalance).toBe('100n');
         expect(json.transactionCount).toBe(5);
     });
   });

package/tests/structures/Block.test.ts

@@ -3,7 +3,7 @@ import { MentaClient } from '../../src/structures/MentaClient';
 import { Account } from '../../src/structures/Account';
 import { Transaction } from '../../src/structures/Transaction';
 import { Address, Hash } from '@mentaproject/core/types';
-import { BlockData } from '../../src/types';
+import { Block as RawBloc } from '@mentaproject/core';
 
 // Mocking MentaClient
 const mockMentaClient = {
@@ -21,7 +21,7 @@ describe('Block', () => {
   const mockMinerAddress: Address = '0xminer123';
   const mockTxHash: Hash = '0xhash123';
 
-  const mockBlockData: BlockData = {
+  const mockBlockData: RawBloc = {
     number: 123n,
     hash: '0xblockhash',
     parentHash: '0xparenthash',
@@ -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);
     });
 
@@ -88,9 +88,9 @@ describe('Block', () => {
   describe('toJSON', () => {
     it('should return a JSON representation of the block', async () => {
       const block = new Block(mockMentaClient, mockBlockData);
-      const json = await block.toJSON();
+      const json = await block.toJSON(1);
 
-      expect(json.number).toBe('123');
+      expect(json.number).toBe('123n');
       expect(json.hash).toBe('0xblockhash');
       expect(json.miner).toBeUndefined();
     });

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);
     });
@@ -135,7 +140,7 @@ describe('Transaction', () => {
         jest.spyOn(transaction, 'receipt').mockResolvedValue({ toJSON: () => ({ receipt: 'data' }) } as any);
         jest.spyOn(transaction, 'calls').mockResolvedValue([{ toJSON: () => ({ call: 'data' }) } as any]);
 
-        const json = await transaction.toJSON();
+        const json = await transaction.toJSON(1);
 
         expect(json.hash).toBe(mockTxHash);
         expect(json.block).toBeDefined();

package/tests/utils/toJSON.test.ts

@@ -34,16 +34,16 @@ describe('toJSON', () => {
   it('should convert bigints to strings', async () => {
     const obj = { a: 1n, b: { c: 2n } };
     const json = await toJSON({ obj });
-    expect(json).toEqual({ a: '1', b: { c: '2' } });
+    expect(json).toEqual({ a: '1n', b: { c: '2n' } });
   });
 
   it('should handle nested class instances', async () => {
     const instance = new MockClass();
     const json = await toJSON({ obj: instance, depth: 1 });
     expect(json.a).toBe('a');
-    expect(json.c).toBe('123');
+    expect(json.c).toBe('123n');
     expect(json.d).toEqual({ value: 'sub' });
-    expect(json.e).toEqual({ f: '456' });
+    expect(json.e).toEqual({ f: '456n' });
   });
 
   it('should handle getters with depth > 0', async () => {
@@ -72,6 +72,6 @@ describe('toJSON', () => {
   it('should handle arrays with bigints', async () => {
     const obj = { data: [1n, 2n, { value: 3n }] };
     const json = await toJSON({ obj });
-    expect(json).toEqual({ data: ['1', '2', { value: '3' }] });
+    expect(json).toEqual({ data: ['1n', '2n', { value: '3n' }] });
   });
 });