@mentaproject/client 0.1.18 → 0.1.20

package/dist/index.d.ts

@@ -16,3 +16,4 @@ export * from './managers';
  * Re-exports the Cache structure for managing cached data.
  */
 export * from './structures/Cache';
+export * from "./utils/bigint";

package/dist/index.js

@@ -16,3 +16,4 @@ export * from './managers';
  * Re-exports the Cache structure for managing cached data.
  */
 export * from './structures/Cache';
+export * from "./utils/bigint";

package/dist/managers/PersistenceManager.d.ts

@@ -1,6 +1,6 @@
-import { Address, Transaction as RawTransaction } from '@mentaproject/core/types';
+import { Address } from '@mentaproject/core/types';
 import { Account } from '../structures/Account';
-import { MentaClient } from '../structures';
+import { MentaClient, Transaction } from '../structures';
 import { GetTransactionsParams, IPersistenceAdapter } from 'src/types';
 /**
  * Manages the persistence of data, including transactions, using a specified persistence adapter.
@@ -20,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<RawTransaction[]>;
+    getTransactions(address: Address, params: GetTransactionsParams): Promise<Transaction[]>;
     /**
      * 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/TransactionManager.d.ts

@@ -1,9 +1,10 @@
 /**
  * @module TransactionManager
  */
-import { GetTransactionParameters, Transaction as RawTransaction, SendTransactionParameters } from "@mentaproject/core/types";
+import { GetTransactionParameters, SendTransactionParameters } from "@mentaproject/core/types";
 import { Transaction } from "../structures/Transaction";
 import { MentaClient } from "../structures";
+import { JSONTransaction } from "src/types";
 /**
  * Manages blockchain transaction-related operations, providing methods to retrieve and send transactions.
  * @class
@@ -34,20 +35,12 @@ export declare class TransactionManager {
      */
     get(params: GetTransactionParameters): Promise<Transaction>;
     /**
-     * Parses a transaction object from a raw transaction data object.
-     * @description This method takes a raw transaction data object and returns a Transaction instance.
-     * @param {ITransactionData} params - The raw transaction data object.
-     * @returns {Transaction} A Transaction instance representing the parsed transaction.
-     * @example
-     *
-     * const transactionData: ITransactionData = {
-     *   // data here
-     * };
+     * Parse a transaction object from a JSON converted transaction data object.
      *
-     * const transaction = client.transactions.parse(transactionData);
-     * console.log(transaction);
+     * @param {J} data - The JSON converted transaction data object.
+     * @returns {Transaction} A Transaction instance representing the parsed transaction.
      */
-    parse(params: RawTransaction): Transaction;
+    parse<J extends JSONTransaction<number>>(data: J): Transaction;
     /**
      * Sends a transaction to the blockchain network.
      * @description This method submits a new transaction to the blockchain. After the transaction

package/dist/managers/TransactionManager.js

@@ -1,5 +1,6 @@
 import { Transaction } from "../structures/Transaction";
 import { getTransaction, sendTransaction } from "@mentaproject/core/actions";
+import { parseBingints } from "src/utils/bigint";
 /**
  * Manages blockchain transaction-related operations, providing methods to retrieve and send transactions.
  * @class
@@ -32,25 +33,23 @@ export class TransactionManager {
      */
     async get(params) {
         const data = await getTransaction(this.client.rpc, params);
-        return this.parse(data);
+        return new Transaction(this.client, data);
     }
     ;
     /**
-     * Parses a transaction object from a raw transaction data object.
-     * @description This method takes a raw transaction data object and returns a Transaction instance.
-     * @param {ITransactionData} params - The raw transaction data object.
-     * @returns {Transaction} A Transaction instance representing the parsed transaction.
-     * @example
-     *
-     * const transactionData: ITransactionData = {
-     *   // data here
-     * };
+     * Parse a transaction object from a JSON converted transaction data object.
      *
-     * const transaction = client.transactions.parse(transactionData);
-     * console.log(transaction);
+     * @param {J} data - The JSON converted transaction data object.
+     * @returns {Transaction} A Transaction instance representing the parsed transaction.
      */
-    parse(params) {
-        return new Transaction(this.client, params);
+    parse(data) {
+        const parsed = parseBingints(data);
+        const rawData = {
+            ...parsed,
+            from: parsed.from.address,
+            to: parsed.to ? parsed.to.address : null,
+        };
+        return new Transaction(this.client, rawData);
     }
     ;
     /**

package/dist/structures/Account.d.ts

@@ -93,7 +93,7 @@ export declare class Account implements AccountData {
      * @param {number} [depth=1] The depth to which nested objects should be converted. A depth of 1 means only direct properties are included.
      * @returns {Promise<object>} A promise that resolves to the JSON representation of the account.
      */
-    toJSON(depth?: number): Promise<JSONAccount>;
+    toJSON<D extends number = 1>(depth: D): Promise<JSONAccount<D>>;
     /**
      * Fetches transactions from the account using a block range exploration with trace_filter calls.
      *

package/dist/structures/Account.js

@@ -59,7 +59,7 @@ export class Account {
                 }]
         });
         const data = await getTransaction(this.client.rpc, { hash });
-        return this.client.transactions.parse(data);
+        return new Transaction(this.client, data);
     }
     ;
     /**
@@ -102,8 +102,7 @@ export class Account {
             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.map(t => new Transaction(this.client, t));
+        return await this.persistenceManager.getTransactions(this.address, params);
     }
     /**
      * Synchronizes the account's transactions with the remote data source using the configured `PersistenceManager`.
@@ -137,7 +136,7 @@ export class Account {
      * @param {number} [depth=1] The depth to which nested objects should be converted. A depth of 1 means only direct properties are included.
      * @returns {Promise<object>} A promise that resolves to the JSON representation of the account.
      */
-    async toJSON(depth = 1) {
+    async toJSON(depth) {
         return await toJSON({
             obj: {
                 address: this.address,

package/dist/structures/Block.d.ts

@@ -1,13 +1,13 @@
-import { Hash, Hex, Withdrawal } from "@mentaproject/core/types";
+import { Block as RawBlock, Hash, Hex, Withdrawal } from "@mentaproject/core";
 import { Account } from "./Account";
 import { Transaction } from "./Transaction";
-import { BlockData, JSONBlock } from "../types/Block";
+import { JSONBlock } from "../types/Block";
 import { MentaClient } from "./MentaClient";
 /**
  * @description Represents a blockchain block with its properties and methods.
  * This class provides a structured way to access block-related data and interact with the blockchain client.
  */
-export declare class Block implements Omit<BlockData, "miner" | "transactions"> {
+export declare class Block implements Omit<RawBlock, "miner" | "transactions"> {
     client: MentaClient;
     /**
      * @description The base fee per gas for the block.
@@ -36,15 +36,15 @@ export declare class Block implements Omit<BlockData, "miner" | "transactions">
     /**
      * @description The gas used in the block.
      */
-    gasUsed?: bigint;
+    gasUsed: bigint;
     /**
      * @description The hash of the block.
      */
-    hash?: Hash | null;
+    hash: Hash | null;
     /**
      * @description The logs bloom filter for the block.
      */
-    logsBloom?: Hex | null;
+    logsBloom: Hex | null;
     /**
      * @description The mix hash of the block.
      */
@@ -52,15 +52,15 @@ export declare class Block implements Omit<BlockData, "miner" | "transactions">
     /**
      * @description The nonce of the block.
      */
-    nonce?: Hex | null;
+    nonce: Hex | null;
     /**
      * @description The block number.
      */
-    number?: bigint | null;
+    number: bigint | null;
     /**
      * @description The parent beacon block root.
      */
-    parentBeaconBlockRoot?: Hex | undefined;
+    parentBeaconBlockRoot?: Hex;
     /**
      * @description The hash of the parent block.
      */
@@ -92,7 +92,7 @@ export declare class Block implements Omit<BlockData, "miner" | "transactions">
     /**
      * @description The total difficulty of the chain up to this block.
      */
-    totalDifficulty?: bigint | null;
+    totalDifficulty: bigint | null;
     /**
      * @description The root of the transactions trie.
      */
@@ -108,7 +108,7 @@ export declare class Block implements Omit<BlockData, "miner" | "transactions">
     /**
      * @description The root of the withdrawals trie.
      */
-    withdrawalsRoot?: Hex | null;
+    withdrawalsRoot?: Hex;
     /**
      * @description The miner of the block, represented as an Account instance.
      */
@@ -123,7 +123,7 @@ export declare class Block implements Omit<BlockData, "miner" | "transactions">
      * @param data The raw block data conforming to IBlockData.
      * @param includeTransactions Whether to include full transaction objects. Defaults to false.
      */
-    constructor(client: MentaClient, data: BlockData);
+    constructor(client: MentaClient, data: RawBlock);
     protected includeTransactions(): this is this & {
         transactions: Transaction[];
     };
@@ -134,5 +134,5 @@ export declare class Block implements Omit<BlockData, "miner" | "transactions">
      * @param depth The depth of the conversion. Defaults to 1.
      * @returns A promise that resolves to the JSON representation of the block.
      */
-    toJSON(depth?: number): Promise<JSONBlock>;
+    toJSON<D extends number = 1>(depth: D): Promise<JSONBlock<D>>;
 }

package/dist/structures/Block.js

@@ -1,4 +1,5 @@
 import { Account } from "./Account";
+import { Transaction } from "./Transaction";
 import { toJSON } from "../utils/toJSON";
 /**
  * @description Represents a blockchain block with its properties and methods.
@@ -40,7 +41,7 @@ export class Block {
         this.withdrawalsRoot = data.withdrawalsRoot;
         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));
+            const parsed = data.transactions.map((data) => typeof data === "string" ? data : new Transaction(this.client, data));
             this.transactions = parsed;
         }
     }
@@ -57,7 +58,7 @@ export class Block {
      * @param depth The depth of the conversion. Defaults to 1.
      * @returns A promise that resolves to the JSON representation of the block.
      */
-    async toJSON(depth = 1) {
+    async toJSON(depth) {
         return await toJSON({
             obj: {
                 ...this,

package/dist/structures/Transaction.d.ts

@@ -134,5 +134,5 @@ export declare class Transaction implements Omit<RawTransaction, "from" | "to">
      * @param {number} [depth=1] The depth of the conversion. Controls how deeply nested objects are serialized.
      * @returns {Promise<object>} A promise that resolves to the JSON representation of the transaction.
      */
-    toJSON(depth?: number): Promise<JSONTransaction>;
+    toJSON<D extends number = 1>(depth: D): Promise<JSONTransaction<D>>;
 }

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 = 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;
+        this.from = data.from ? this.client.accounts.get(data.from) : undefined;
+        this.to = data.to ? this.client.accounts.get(data.to) : undefined;
     }
     ;
     /**
@@ -107,7 +107,7 @@ export class Transaction {
      * @param {number} [depth=1] The depth of the conversion. Controls how deeply nested objects are serialized.
      * @returns {Promise<object>} A promise that resolves to the JSON representation of the transaction.
      */
-    async toJSON(depth = 1) {
+    async toJSON(depth) {
         return await toJSON({
             obj: {
                 ...this,

package/dist/types/Account.d.ts

@@ -30,7 +30,7 @@ export type FetchTransactionParams = {
 export type AccountData = {
     address: Address;
 };
-export type JSONAccount = AccountData & {
+export type JSONAccount<depth extends number> = depth extends 0 ? AccountData : AccountData & {
     isContract: boolean;
     ETHBalance: string;
     contractType: string;

package/dist/types/Block.d.ts

@@ -1,67 +1,11 @@
-import { Address, Hash, Hex, Transaction as RawTransaction, Withdrawal } from "@mentaproject/core/types";
+import { Hash } from "@mentaproject/core/types";
+import { Block as RawBlock } from "@mentaproject/core";
 import { JSONAccount } from "./Account";
-import { Transaction } from "../structures";
-/**
- * @interface BlockData
- * Represents the raw data structure of a blockchain block.
- */
-export type BlockData = {
-    /** Base fee per gas */
-    baseFeePerGas: bigint | null;
-    /** Total used blob gas by all transactions in this block */
-    blobGasUsed: bigint;
-    /** Difficulty for this block */
-    difficulty: bigint;
-    /** Excess blob gas */
-    excessBlobGas: bigint;
-    /** "Extra data" field of this block */
-    extraData: Hex;
-    /** Maximum gas allowed in this block */
-    gasLimit: bigint;
-    /** Total used gas by all transactions in this block */
-    gasUsed?: bigint;
-    /** Block hash or `null` if pending */
-    hash?: Hash | null;
-    /** Logs bloom filter or `null` if pending */
-    logsBloom?: Hex | null;
-    /** Address that received this block’s mining rewards, COINBASE address */
-    miner: Address;
-    /** Unique identifier for the block. */
-    mixHash: Hash;
-    /** Proof-of-work hash or `null` if pending */
-    nonce?: Hex | null;
-    /** Block number or `null` if pending */
-    number?: bigint | null;
-    /** Root of the parent beacon chain block. */
-    parentBeaconBlockRoot?: Hex;
-    /** Hash of the parent block. */
-    parentHash: Hash;
-    /** Root of the receipts trie for this block. */
-    receiptsRoot: Hex;
-    /** List of seal fields. */
-    sealFields: Hex[];
-    /** SHA3 hash of the uncles data in this block. */
-    sha3Uncles: Hash;
-    /** Size of this block in bytes. */
-    size: bigint;
-    /** Root of the final state trie for this block. */
-    stateRoot: Hash;
-    /** Unix timestamp of when this block was collated. */
-    timestamp: bigint;
-    /** Total difficulty of the chain until this block. */
-    totalDifficulty?: bigint | null;
-    /** List of transaction objects or hashes included in this block. */
-    transactions: RawTransaction[] | Hash[];
-    /** Root of the transaction trie for this block. */
-    transactionsRoot: Hash;
-    /** List of uncle hashes. */
-    uncles: Hash[];
-    /** List of withdrawal objects included in this block. */
-    withdrawals?: Withdrawal[];
-    /** Root of the withdrawals trie for this block. */
-    withdrawalsRoot?: Hex | null;
-};
-export type JSONBlock = BlockData & {
-    miner: JSONAccount;
-    transactions?: Transaction[] | Hash[];
+import { WithBigintStringified } from "./Utils";
+import { JSONTransaction } from "./Transaction";
+export type JSONBlock<depth extends number> = depth extends 0 ? WithBigintStringified<Omit<RawBlock, "miner" | "transactions">> & {
+    transactions?: JSONTransaction<depth>[] | Hash[];
+} : WithBigintStringified<Omit<RawBlock, "miner" | "transactions">> & {
+    miner: JSONAccount<depth>;
+    transactions?: JSONTransaction<depth>[] | Hash[];
 };

package/dist/types/PersistenceAdapter.d.ts

@@ -1,4 +1,4 @@
-import { Address, Transaction as RawTransaction } from '@mentaproject/core/types';
+import { Address } from '@mentaproject/core/types';
 import { Transaction } from '../structures/Transaction';
 import { GetTransactionsParams } from './Account';
 /**
@@ -17,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<RawTransaction[]>} A Promise that resolves with transactions data.
+     * @returns {Promise<Transaction[]>} A Promise that resolves with transactions objects.
      */
-    getTransactions(address: Address, params: GetTransactionsParams): Promise<RawTransaction[]>;
+    getTransactions(address: Address, params: GetTransactionsParams): Promise<Transaction[]>;
     /**
      * @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/types/Transaction.d.ts

@@ -3,8 +3,9 @@
  */
 import { Hex, TransactionReceipt, Transaction as RawTransaction } from "@mentaproject/core";
 import { Account } from "../structures";
-import { BlockData } from "./Block";
+import { JSONBlock } from "./Block";
 import { JSONAccount } from "./Account";
+import { WithBigintStringified } from "./Utils";
 /**
  * Defines the direction of a transaction relative to an account.
  * "in" for incoming transactions, "out" for outgoing transactions.
@@ -32,10 +33,13 @@ export type TransactionCall = {
     gas: bigint;
     callType: string;
 };
-export type JSONTransaction = RawTransaction & {
-    from: JSONAccount;
-    to?: JSONAccount;
-    block: BlockData;
-    receipt: TransactionReceipt;
-    calls?: TransactionCall[];
+export type JSONTransaction<depth extends number> = depth extends 0 ? WithBigintStringified<Omit<RawTransaction, 'from' | 'to'>> & {
+    from: JSONAccount<depth>;
+    to?: JSONAccount<depth>;
+} : WithBigintStringified<Omit<RawTransaction, 'from' | 'to'>> & {
+    from: JSONAccount<depth>;
+    to?: JSONAccount<depth>;
+    block: JSONBlock<depth>;
+    receipt: WithBigintStringified<TransactionReceipt>;
+    calls?: WithBigintStringified<TransactionCall>[];
 };

package/dist/types/Utils.d.ts

@@ -0,0 +1,7 @@
+export type BigintStringified = `${number}n`;
+export type WithBigintStringified<T> = T extends bigint ? BigintStringified : T extends (infer E)[] ? Array<WithBigintStringified<E>> : T extends object ? {
+    [K in keyof T]: WithBigintStringified<T[K]>;
+} : T;
+export type WithoutBigintStringified<T> = T extends BigintStringified ? bigint : T extends (infer E)[] ? Array<WithoutBigintStringified<E>> : T extends object ? {
+    [K in keyof T]: WithoutBigintStringified<T[K]>;
+} : T;

package/dist/types/Utils.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/bigint.d.ts

@@ -1,2 +1,8 @@
+import { WithoutBigintStringified } from "src/types/Utils";
 export declare const bigIntMax: (...args: bigint[]) => bigint;
 export declare const bigIntMin: (...args: bigint[]) => bigint;
+export declare function bigIntReviver(key: string, value: any): any;
+export declare function stringifyBingints(obj: any): any;
+export declare function parseBingints<T extends {
+    [key: string]: any;
+}>(obj: T): WithoutBigintStringified<T>;

package/dist/utils/bigint.js

@@ -1,2 +1,54 @@
 export const bigIntMax = (...args) => args.reduce((m, e) => e > m ? e : m);
 export const bigIntMin = (...args) => args.reduce((m, e) => e < m ? e : m);
+export function bigIntReviver(key, value) {
+    if (typeof value === 'string') {
+        if (value.endsWith('n')) {
+            try {
+                return BigInt(value.slice(0, -1));
+            }
+            catch (e) {
+                return value;
+            }
+        }
+        ;
+    }
+    ;
+    return value;
+}
+;
+export function stringifyBingints(obj) {
+    if (typeof obj === 'bigint') {
+        return obj.toString() + "n";
+    }
+    if (typeof obj === 'object') {
+        for (const key in obj) {
+            obj[key] = stringifyBingints(obj[key]);
+        }
+    }
+    if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+            obj[i] = stringifyBingints(obj[i]);
+        }
+    }
+    return obj;
+}
+;
+export function parseBingints(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item, index) => bigIntReviver(index.toString(), parseBingints(item)));
+    }
+    const newObj = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const value = obj[key];
+            const processedValue = parseBingints(value);
+            newObj[key] = bigIntReviver(key, processedValue);
+        }
+    }
+    ;
+    return newObj;
+}
+;

package/dist/utils/toJSON.js

@@ -24,7 +24,7 @@ function isClassInstance(obj) {
  */
 function convertBigintsToStrings(obj) {
     if (typeof obj === 'bigint') {
-        return obj.toString();
+        return obj.toString() + "n";
     }
     if (typeof obj === 'object') {
         for (const key in obj) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentaproject/client",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "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

@@ -3,15 +3,13 @@ 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[]>();
+let transactions = new Map<Address, Transaction[]>();
 
 const client = new MentaClient({
     account: viemAccount,
@@ -34,7 +32,7 @@ const client = new MentaClient({
         getLastSyncedBlock: async (accountAddress: Address) => {
             return lastSyncedBlock.get(accountAddress) ?? null;
         },
-        getTransactions: async (address: Address, params) => {
+        getTransactions: async (address: Address, params): Promise<Transaction[]> => {
             return transactions.get(address) ?? [];
         },
         upsertTransactions: async (txs: Transaction[]) => {
@@ -51,7 +49,9 @@ const client = new MentaClient({
                     };
 
                     const jsonTransaction = await transaction.toJSON(0);
-                    transactions.get(checksumed)?.push(jsonTransaction);
+                    const parsed = client.transactions.parse(jsonTransaction);
+
+                    transactions.get(checksumed)?.push(parsed);
                 };
 
                 if (toAddress) {
@@ -61,8 +61,10 @@ const client = new MentaClient({
                         transactions.set(checksumed, []);
                     };
 
-                    const jsonTransaction = await transaction.toJSON();
-                    transactions.get(checksumed)?.push(jsonTransaction);
+                    const jsonTransaction = await transaction.toJSON(0);
+                    const parsed = client.transactions.parse(jsonTransaction);
+
+                    transactions.get(checksumed)?.push(parsed);
                 }
             }
         },
@@ -77,8 +79,11 @@ const client = new MentaClient({
     console.log("Watching for new blocks and block numbers...");
 
     const account = client.accounts.get("0x53b9B72DC6f96Eb4B54143B211B22e2548e4cf5c");
-    await account.syncTransactions(20)
-    const res = await account.transactions({ limit: 20 });
+    await account.syncTransactions(50)
+    const res = await account.transactions({ limit: 50 });
+    console.log(res.map(r => r.blockNumber));
+    const json = await Promise.all(res.map(async t => await t.toJSON(0)));
 
-    console.log(res[0]);
+    writeFileSync("transactions.json", JSON.stringify(json, null, 2));
+    console.log("Done");
 })();

package/tests/structures/Account.test.ts

@@ -221,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',
@@ -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

@@ -140,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();