@mentaproject/client 0.1.23 → 0.1.24

package/dist/managers/PersistenceManager.d.ts

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

@@ -40,7 +40,7 @@ export declare class TransactionManager {
      * @param {J} data - The JSON converted transaction data object.
      * @returns {Transaction} A Transaction instance representing the parsed transaction.
      */
-    parse<J extends JSONTransaction<number>>(data: J): Transaction;
+    parse<J extends JSONTransaction<0>>(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/structures/Account.js

@@ -102,7 +102,8 @@ export class Account {
             const transactions = await Promise.all(hashes.map(hash => this.client.transactions.get({ hash })));
             return transactions;
         }
-        return await this.persistenceManager.getTransactions(this.address, params);
+        const jsons = await this.persistenceManager.getTransactions(this.address, params);
+        return jsons.map(j => this.client.transactions.parse(j));
     }
     /**
      * Synchronizes the account's transactions with the remote data source using the configured `PersistenceManager`.

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.
@@ -17,9 +18,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 transactions objects.
+     * @returns {Promise<JSONTransaction[]>} A Promise that resolves with transactions objects.
      */
-    getTransactions(address: Address, params: GetTransactionsParams): Promise<Transaction[]>;
+    getTransactions(address: Address, params: GetTransactionsParams): Promise<JSONTransaction<0>[]>;
     /**
      * @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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentaproject/client",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "description": "High level EVM library used into the Menta App to facilitate Blockchain interactions. ",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -22,7 +22,7 @@
   },
   "scripts": {
     "test:file": "tsx test.ts",
-    "test": "jest",
+    "test": "jest -i",
     "build": "tsc --project tsconfig.json",
     "patch": "npm version patch && npm run build && npm publish --access public",
     "minor": "npm version minor && npm run build && npm publish --access public",

package/src/index.ts

@@ -0,0 +1,21 @@
+/**
+ * @module @mentaproject/client
+ * @description This library provides the client-side functionalities for interacting with the Menta blockchain.
+ * It includes managers for accounts, blocks, contracts, persistence, and transactions,
+ * as well as core data structures and utility types.
+ */
+
+/**
+ * Re-exports all core data structures like MentaClient, Account, Block, and Transaction.
+ */
+export * from './structures';
+/**
+ * Re-exports all manager classes for interacting with different aspects of the Menta blockchain.
+ */
+export * from './managers';
+/**
+ * Re-exports the Cache structure for managing cached data.
+ */
+export * from './structures/Cache';
+
+export * from "./utils/bigint";

package/src/managers/AccountManager.ts

@@ -0,0 +1,51 @@
+/**
+ * @module AccountManager
+ */
+import { Address } from "@mentaproject/core/types";
+import { Account } from "../structures/Account";
+import { PersistenceManager } from "./PersistenceManager";
+import { MentaClient } from "../structures";
+
+/**
+ * Manages blockchain account operations.
+ * This class provides methods to interact with accounts,
+ * including retrieving and managing them via an RPC client and a persistence manager.
+ *
+ * @class AccountManager
+ */
+export class AccountManager {
+    /**
+     * Creates an instance of AccountManager.
+     *
+     * @param {MentaClient} client - The instance of MentaClient used to interact with the blockchain.
+     * @param {persistenceManager} persistenceManager - The optional persistence manager to store and retrieve account data.
+     */
+    constructor(public client: MentaClient, private persistenceManager?: PersistenceManager) { };
+
+    /**
+     * Retrieves an account instance by its blockchain address.
+     * @param address - The blockchain address of the account to retrieve.
+     * @returns An instance of the `Account` class.
+     * @example
+    * ```typescript
+    * import { MentaClient } from '@mentaproject/client';
+    * import { http } from '@mentaproject/core';
+    *
+    * // Initialize the MentaClient
+    * const client = new MentaClient({
+    *     transport: http('http://rpcurlhere.com'),
+    * });
+    *
+    * // The address of the account to retrieve
+    * const accountAddress = '0x1234567890123456789012345678901234567890';
+    *
+    * // Retrieve the account instance using the account manager from the client
+    * const account = client.accounts.get(accountAddress);
+    *
+    * console.log(account.address); // 0x1234567890123456789012345678901234567890
+    * ```
+     */
+    get(address: Address): Account {
+        return new Account(this.client, { address: address }, this.persistenceManager);
+    };
+}

package/src/managers/BlockManager.ts

@@ -0,0 +1,51 @@
+/**
+ * @module BlockManager
+ */
+import { BlockTag, GetBlockParameters } from "@mentaproject/core/types";
+import { Block } from "../structures/Block";
+import { getBlock } from "@mentaproject/core/actions";
+import { MentaClient } from "../structures";
+
+/**
+ * Manages blockchain block-related operations, providing methods to interact with and retrieve block data.
+ */
+export class BlockManager {
+    /**
+     * Creates an instance of BlockManager.
+     * @param client - The instance of MentaClient used to interact with the blockchain.
+     */
+    constructor(public client: MentaClient) {};
+
+    /**
+     * Retrieves a block from the blockchain based on the provided parameters.
+     * This method uses the underlying RPC client to fetch block data and then
+     * encapsulates it within a {@link Block} instance.
+     * @param params The parameters for retrieving the block, including block hash, block number, or block tag.
+     * @returns A promise that resolves to a {@link Block} instance representing the retrieved block.
+     * @example
+     * import { http } from '@mentaproject/core';
+     * import { mainnet } from '@mentaproject/core/chains';
+     * import { MentaClient } from '@mentaproject/client';
+     *
+     * // Initialize the MentaClient
+     * const mentaClient = new MentaClient({ chain: mainnet, transport: http("http://rpcurlhere.com") });
+     *
+     * async function fetchBlock() {
+     *   // Retrieve the latest block
+     *   const latestBlock = await mentaClient.blocks.get({ blockTag: 'latest' });
+     *   console.log('Latest block number:', latestBlock.number);
+     *
+     *   // Retrieve a specific block by its number
+     *   if (latestBlock.number) {
+     *     const specificBlock = await mentaClient.blocks.get({ blockNumber: latestBlock.number - 10n });
+     *     console.log('Specific block hash:', specificBlock.hash);
+     *   }
+     * }
+     *
+     * fetchBlock();
+     */
+    async get(params: GetBlockParameters<boolean, BlockTag>): Promise<Block> {
+        const data = await getBlock(this.client.rpc, params);
+        return new Block(this.client, data);
+    };
+}

package/src/managers/ContractManager.ts

@@ -0,0 +1,60 @@
+/**
+ * @module ContractManager
+ */
+import type { AbiItem } from "@mentaproject/core/types";
+import { getContract, GetContractParameters } from "@mentaproject/contracts";
+import { MentaClient } from "../structures";
+
+/**
+ * Manages smart contract-related operations within the Menta client.
+ * This class provides methods to interact with smart contracts deployed on the blockchain,
+ * facilitating the retrieval of contract instances for various operations.
+ */
+export class ContractManager {
+    /**
+     * Creates an instance of ContractManager.
+     * @description Initializes the ContractManager with a CoreClient instance, which is used for RPC communication.
+     * @param client - The instance of MentaClient used to interact with the blockchain.
+     */
+    constructor(protected client: MentaClient) {};
+
+    /**
+     * Retrieves a contract instance to interact with it.
+     * @description This method fetches a contract instance based on the provided parameters, allowing for interaction with its methods and events.
+     * @template P The type of the contract retrieval parameters, extending `GetContractParameters` with `AbiItem` array.
+     * @param {P} params The parameters for retrieving the contract, including its Application Binary Interface (ABI) and address.
+     * @returns {ReturnType<typeof getContract<ReadonlyArray<AbiItem>, P>>} A contract instance that can be used to call contract methods or listen to events.
+     * @example
+     * import { MentaClient } from '@mentaproject/client';
+     * import { http } from '@mentaproject/core';
+     *
+     * // Initialize the MentaClient with a transport
+     * const client = new MentaClient({
+     *   transport: http('http://rpcurlhere.com'),
+     * });
+     *
+     * // Define the ABI and address for the smart contract
+     * const abi = [
+     *   {
+     *     "type": "function",
+     *     "name": "greet",
+     *     "stateMutability": "view",
+     *     "inputs": [],
+     *     "outputs": [{ "name": "", "type": "string" }]
+     *   }
+     * ] as const;
+     * const contractAddress = '0x...'; // Replace with your contract address
+     *
+     * // Retrieve the contract instance
+     * const contract = client.contracts.get({
+     *   abi,
+     *   address: contractAddress,
+     * });
+     *
+     * // Example of interacting with the contract
+     * const greeting = await contract.greet();
+     */
+    get<P extends GetContractParameters<ReadonlyArray<AbiItem>>>(params: P) {
+        return getContract(this.client.rpc, params);
+    };
+};

package/src/managers/PersistenceManager.ts

@@ -0,0 +1,59 @@
+import { getBlockNumber } from '@mentaproject/core/actions';
+import { Address } from '@mentaproject/core/types';
+
+import { Account } from '../structures/Account';
+import { MentaClient, Transaction } from '../structures';
+import { bigIntMax } from '../utils/bigint';
+import { GetTransactionsParams, IPersistenceAdapter, 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.
+ */
+export class PersistenceManager {
+    /**
+     * Creates an instance of PersistenceManager.
+     * @param client - The instance of MentaClient used to interact with the blockchain.
+     * @param persistenceAdapter - The adapter responsible for actual data persistence operations.
+     */
+    constructor(
+        private client: MentaClient,
+        private persistenceAdapter: IPersistenceAdapter
+    ) {}
+
+    /**
+     * Retrieves transactions for a given account, applying a "stale-while-revalidate" strategy.
+     * @param params - Parameters for retrieving transactions.
+     * @returns A promise that resolves to an array of transactions with associated account information.
+     */
+    public async getTransactions(address: Address, params: GetTransactionsParams): Promise<JSONTransaction<0>[]> {
+        return await this.persistenceAdapter.getTransactions(address, params);
+    }
+
+    /**
+     * 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.
+     */
+    public async syncTransactions(account: Account, limit: number = 100_000): Promise<void> {
+        const lastSyncedBlock = await this.persistenceAdapter.getLastSyncedBlock(account.address);
+        const lastBlock = lastSyncedBlock ?? 0n;
+
+        const fromBlock = lastSyncedBlock ? lastSyncedBlock + 1n : (await getBlockNumber(this.client.rpc));
+
+        const newTransactions = await account.transactions({
+            fromBlock: fromBlock,
+            toBlock: lastBlock,
+            limit: limit
+        }, true)
+
+        if (newTransactions.length > 0) {
+            await this.persistenceAdapter.upsertTransactions(newTransactions);
+            
+            const latestBlock = bigIntMax(...newTransactions.map(t => t.blockNumber || 0n));
+            await this.persistenceAdapter.setLastSyncedBlock(account.address, latestBlock);
+        }
+    }
+}

package/src/managers/TransactionManager.ts

@@ -0,0 +1,92 @@
+/**
+ * @module TransactionManager
+ */
+import {  GetTransactionParameters, Transaction as RawTransaction, SendTransactionParameters } from "@mentaproject/core/types";
+import { Transaction } from "../structures/Transaction";
+import { getTransaction, sendTransaction } from "@mentaproject/core/actions";
+import { MentaClient } from "../structures";
+import { JSONTransaction } from "../types";
+import { parseBingints } from "../utils/bigint";
+
+/**
+ * Manages blockchain transaction-related operations, providing methods to retrieve and send transactions.
+ * @class
+ * @description This class provides an interface to interact with blockchain transactions,
+ * allowing for retrieval of transaction details and submission of new transactions
+ * to the network via an RPC client.
+ */
+export class TransactionManager {
+    /**
+     * Creates an instance of `TransactionManager`.
+     * @constructor
+     * @param {MentaClient} client - The instance of MentaClient used to interact with the blockchain.
+     */
+    constructor(public client: MentaClient) {};
+
+    /**
+     * Retrieves a transaction by its hash or block number and index.
+     * @description This method fetches detailed information about a specific transaction
+     * from the blockchain using the provided parameters.
+     * @param {GetTransactionParameters} params - The parameters for retrieving the transaction,
+     * typically including `hash` or `blockNumber` and `index`.
+     * @returns {Promise<Transaction>} A promise that resolves to a {@link Transaction} instance
+     * containing the retrieved transaction data.
+     * @example
+     * const txHash = '0x...'; // Replace with a valid transaction hash
+     * const transaction = await client.transactions.get({ hash: txHash });
+     * console.log(transaction);
+     */
+    async get(params: GetTransactionParameters): Promise<Transaction> {
+        const data = await getTransaction(this.client.rpc, params);
+        return new Transaction(this.client, data);
+    };
+
+    /**
+     * Parse a transaction object from a JSON converted transaction data object.
+     * 
+     * @param {J} data - The JSON converted transaction data object.
+     * @returns {Transaction} A Transaction instance representing the parsed transaction.
+     */
+    parse<J extends JSONTransaction<0>>(data: J): Transaction {
+        const parsed = parseBingints(data);
+
+        const rawData = {
+            ...parsed,
+            from: parsed.from.address,
+            to: parsed.to ? parsed.to.address : null,
+        };
+        
+        return new Transaction(this.client, rawData as RawTransaction);
+    };
+
+    /**
+     * Sends a transaction to the blockchain network.
+     * @description This method submits a new transaction to the blockchain. After the transaction
+     * is successfully sent, it retrieves and returns the full transaction details.
+     * @param {SendTransactionParameters} params - The parameters required to send the transaction,
+     * such as `to`, `value`, `data`, `gasLimit`, etc.
+     * @returns {Promise<Transaction>} A promise that resolves to a {@link Transaction} instance
+     * representing the sent transaction, including its hash and other details.
+     * @example
+     * import { MentaClient } from '@mentaproject/client';
+     * import { http } from '@mentaproject/core';
+     *
+     * // This example assumes you have an account with funds, which is available to the client.
+     * const client = new MentaClient({
+     *   chain: 'mainnet',
+     *   transport: http('http://rpcurlhere.com')
+     * });
+     *
+     * const transactionResult = await client.transactions.send({
+     *   to: '0xRecipientAddress...', // Replace with a valid recipient address
+     *   value: 1000000000000000000n, // 1 ETH in wei
+     * });
+     *
+     * console.log('Transaction sent with hash:', transactionResult.hash);
+     */
+    async send(params: SendTransactionParameters): Promise<Transaction> {
+        const hash = await sendTransaction(this.client.rpc, params);
+        
+        return await this.get({ hash });
+    };
+};

package/src/managers/index.ts

@@ -0,0 +1,4 @@
+export * from './AccountManager';
+export * from './BlockManager';
+export * from './ContractManager';
+export * from './TransactionManager';

package/src/structures/Account.ts

@@ -0,0 +1,206 @@
+import { fetchByBlockRange, getBalance, getBlockNumber, getCode, getTransaction, getTransactionCount, sendTransaction, traceFilter } from "@mentaproject/core/actions";
+import type { Address, Hash, onBlockRangeCallback } from "@mentaproject/core/types";
+import { Transaction } from "./Transaction";
+import { toHex } from "@mentaproject/core/utils";
+import { AccountData, FetchTransactionParams, GetTransactionsParams, JSONAccount } from "../types/Account";
+import { getContractType } from "@mentaproject/contracts";
+import { toJSON } from "../utils/toJSON";
+import { PersistenceManager } from "../managers/PersistenceManager";
+import { MentaClient } from "./MentaClient";
+
+/**
+ * Represents a blockchain account with functionalities to interact with the Menta blockchain.
+ * This class provides methods to query account information, send transactions, and manage account-related data.
+ */
+export class Account implements AccountData {
+    /**
+     * The blockchain address of the account.
+     */
+    public address: Address;
+
+    private persistenceManager?: PersistenceManager;
+
+    /**
+     * Creates an instance of the Account class.
+     * @param client.rpc The CoreClient instance used for blockchain interactions.
+     * @param address The blockchain address of the account.
+     * @param persistenceManager An optional PersistenceManager instance for caching and data synchronization.
+     */
+    constructor(public client: MentaClient, data: AccountData, persistenceManager?: PersistenceManager) {
+        this.address = data.address;
+        this.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.
+     * If code is found, it indicates that the account is a contract.
+     * @returns {Promise<boolean>} A promise that resolves to `true` if the account is a contract, `false` otherwise.
+     */
+    async isContract(): Promise<boolean> {
+        const code = await getCode(this.client.rpc, { address: this.address });
+
+        if (!code || code === "0x") return false;
+        return true;
+    };
+
+    /**
+     * Retrieves the type of the contract if the account is a smart contract.
+     * @description This method first checks if the account is a contract using `isContract()`.
+     * If it is a contract, it then attempts to determine and return its type.
+     * @returns {Promise<any>} A promise that resolves to the contract type (e.g., 'ERC20', 'ERC721') or `undefined` if the account is not a contract or its type cannot be determined.
+     */
+    async contractType(): Promise<any> {
+        const isContract = await this.isContract();
+        if (!isContract) return undefined;
+
+        return await getContractType(this.client.rpc, this.address);
+    };
+
+    /**
+     * Sends a specified amount of native cryptocurrency (ETH) to this account.
+     * @description This method constructs and sends a transaction to transfer ETH to the account's address.
+     * @param {bigint} amount The amount of ETH to send, specified in wei (the smallest denomination of Ether).
+     * @returns {Promise<Transaction>} A promise that resolves to a `Transaction` object representing the sent transaction.
+     */
+    async sendETH(amount: bigint): Promise<Transaction> {
+        const hash = await sendTransaction(this.client.rpc, {
+            calls: [{
+                to: this.address,
+                value: amount,
+            }]
+        });
+
+        const data = await getTransaction(this.client.rpc, { hash });
+        return new Transaction(this.client, data);
+    };
+
+    /**
+     * Retrieves the current native cryptocurrency (ETH) balance of the account.
+     * @description This method queries the blockchain to get the balance associated with the account's address.
+     * @returns {Promise<bigint>} A promise that resolves to the ETH balance of the account, in wei.
+     */
+    async ETHBalance(): Promise<bigint> {
+        return await getBalance(this.client.rpc, {
+            address: this.address,
+        });
+    };
+
+    /**
+     * Retrieves the transaction count (nonce) for the account.
+     * @description The transaction count represents the number of transactions sent from this account,
+     * which is also used as the nonce for new transactions to prevent replay attacks.
+     * @returns {Promise<number>} A promise that resolves to the transaction count of the account.
+     */
+    async transactionCount(): Promise<number> {
+        return await getTransactionCount(this.client.rpc, { address: this.address });
+    }
+
+    /**
+     * Retrieves all transactions involving this account.
+     * @description If a `PersistenceManager` is configured, this method will first attempt to retrieve transactions from the local cache.
+     * If not found in cache or if no `PersistenceManager` is configured, it will fetch transactions directly from the remote RPC.
+     * @param {GetTransactionsOptions} [options] - Optional parameters for filtering, pagination, and sorting the transactions.
+     * @param {number} [options.startBlock] - The starting block number (inclusive) from which to retrieve transactions.
+     * @param {number} [options.endBlock] - The ending block number (inclusive) up to which to retrieve transactions.
+     * @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: GetTransactionsParams, forceFetch = false): Promise<Transaction[]> {
+        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 jsons = await this.persistenceManager.getTransactions(this.address, params);
+        return jsons.map(j => this.client.transactions.parse(j));
+    }
+
+    /**
+     * 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 {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(limit: number = 1000): Promise<void> {
+        if (!this.persistenceManager) throw new Error("The persistence module is not configured.");
+        await this.persistenceManager.syncTransactions(this, limit);
+    }
+
+    /**
+     * Retrieves transactions involving a specific token. (not implemented yet)
+     * @description This method queries the persistence adapter to retrieve transactions involving a specific token.
+     * @param {Address} tokenAddress The address of the token.
+     * @returns {Promise<any>} A promise that resolves to an array of transactions involving the token.
+     * @throws {Error} If the persistence module is not configured.
+     */
+    async tokenTransactions(tokenAddress: Address): Promise<any> {
+        if (!this.persistenceManager) throw new Error('The persistence module is not configured.');
+
+        return {};
+    }
+
+    /**
+     * Converts the Account instance into a JSON-serializable representation.
+     * @description This method leverages a utility function to convert the `Account` object,
+     * including its asynchronous properties (like `isContract`, `ETHBalance`), into a plain JSON object.
+     * @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<D extends number = 1>(depth: D): Promise<JSONAccount<D>> {
+        return await toJSON({
+            obj: {
+                address: this.address,
+                isContract: this.isContract.bind(this),
+                contractType: this.contractType.bind(this),
+                ETHBalance: this.ETHBalance.bind(this),
+                transactionCount: this.transactionCount.bind(this),
+            },
+            depth
+        });
+    }
+
+    /**
+     * Fetches transactions from the account using a block range exploration with trace_filter calls.
+     * 
+     *  @param params - The parameters for the block range exploration.
+     *  @returns A Promise that resolves to an array of transaction hashes.
+     */
+    protected async _fetchTransactions({ fromBlock, toBlock, limit = 50 }: FetchTransactionParams): Promise<Hash[]> {
+        const lastBlock = await getBlockNumber(this.client.rpc);
+
+        const onBlockRange: onBlockRangeCallback = async ({ fromBlock, toBlock }, stop) => {
+            const outgoing = await traceFilter(this.client.rpc, {
+                fromBlock: toHex(fromBlock),
+                toBlock: toHex(toBlock),
+                fromAddress: this.address
+            });
+
+            const incoming = await traceFilter(this.client.rpc, {
+                fromBlock: toHex(fromBlock),
+                toBlock: toHex(toBlock),
+                toAddress: this.address
+            });
+
+            const traces = outgoing.concat(incoming).sort((a, b) => a.blockNumber - b.blockNumber);
+
+            return traces.map(t => t.transactionHash as Hash)
+        };
+
+        return await fetchByBlockRange({
+            toBlock: BigInt(toBlock !== undefined ? toBlock : 0),
+            fromBlock: BigInt(fromBlock !== undefined ? fromBlock : lastBlock),
+            direction: "backward",
+            itemLimit: limit,
+            onBlockRange
+        });
+    }
+};