@mentaproject/client 0.1.37 → 0.2.0

package/dist/index.cjs

@@ -146,7 +146,7 @@ __export(src_exports, {
   ContractManager: () => ContractManager,
   MemoryCache: () => MemoryCache,
   MentaClient: () => MentaClient,
-  Transaction: () => Transaction,
+  Transaction: () => Transaction2,
   TransactionManager: () => TransactionManager,
   bigIntMax: () => bigIntMax,
   bigIntMin: () => bigIntMin,
@@ -157,14 +157,10 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/structures/Account.ts
-var import_actions2 = require("@mentaproject/core/actions");
-
-// src/structures/Transaction.ts
 var import_actions = require("@mentaproject/core/actions");
+var import_transactions = require("@mentaproject/transactions");
 var import_utils = require("@mentaproject/core/utils");
-
-// node_modules/viem/_esm/index.js
-init_transaction();
+var import_contracts = require("@mentaproject/contracts");
 
 // src/utils/toJSON.ts
 function isClassInstance(obj) {
@@ -234,70 +230,126 @@ async function toJSON({ obj, depth = 0 }) {
   return convertBigintsToStrings(data);
 }
 
-// src/structures/Block.ts
-var Block = class {
-  /**
-   * @description Creates an instance of Block.
-   * @param client - The instance of MentaClient used to interact with the blockchain.
-   * @param data The raw block data conforming to IBlockData.
-   * @param includeTransactions Whether to include full transaction objects. Defaults to false.
-   */
-  constructor(client, data) {
+// src/structures/Account.ts
+var Account = class {
+  constructor(client, data, persistenceManager) {
     this.client = client;
-    this.baseFeePerGas = data.baseFeePerGas;
-    this.blobGasUsed = data.blobGasUsed;
-    this.difficulty = data.difficulty;
-    this.excessBlobGas = data.excessBlobGas;
-    this.extraData = data.extraData;
-    this.gasLimit = data.gasLimit;
-    this.gasUsed = data.gasUsed;
-    this.hash = data.hash;
-    this.logsBloom = data.logsBloom;
-    this.mixHash = data.mixHash;
-    this.nonce = data.nonce;
-    this.number = data.number;
-    this.parentBeaconBlockRoot = data.parentBeaconBlockRoot;
-    this.parentHash = data.parentHash;
-    this.receiptsRoot = data.receiptsRoot;
-    this.sealFields = data.sealFields;
-    this.sha3Uncles = data.sha3Uncles;
-    this.size = data.size;
-    this.stateRoot = data.stateRoot;
-    this.timestamp = data.timestamp;
-    this.totalDifficulty = data.totalDifficulty;
-    this.transactionsRoot = data.transactionsRoot;
-    this.uncles = data.uncles;
-    this.withdrawals = data.withdrawals;
-    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((data2) => typeof data2 === "string" ? data2 : new Transaction(this.client, data2));
-      this.transactions = parsed;
-    }
+    this.address = data.address;
+    this.persistenceManager = persistenceManager;
   }
-  includeTransactions() {
-    if (!this.transactions || this.transactions.length === 0) return false;
+  async isContract() {
+    const code = await (0, import_actions.getCode)(this.client.rpc, { address: this.address });
+    if (!code || code === "0x") return false;
     return true;
   }
+  async contractType() {
+    const isContract = await this.isContract();
+    if (!isContract) return void 0;
+    return await (0, import_contracts.getContractType)(this.client.rpc, this.address);
+  }
   /**
-   * @description Converts the Block instance to a JSON representation.
-   * This method serializes the block's properties into a plain JavaScript object,
-   * suitable for JSON serialization.
-   * @param depth The depth of the conversion. Defaults to 1.
-   * @returns A promise that resolves to the JSON representation of the block.
+   * Creates a Transaction to send ETH to this account.
+   *
+   * @param amount The amount of ETH to send, in wei.
+   * @returns A Transaction with .call(), .simulate(), and .execute() methods.
+   *
+   * @example
+   * ```ts
+   * // Direct execution
+   * const pending = await account.sendEth(parseEther("1")).execute();
+   * const receipt = await pending.confirm();
+   *
+   * // Batch with MulticallTransaction
+   * multicall.addCall(account.sendEth(parseEther("1")));
+   * ```
    */
+  sendEth(amount) {
+    return new import_transactions.Transaction(this.client.rpc, {
+      to: this.address,
+      value: amount
+    });
+  }
+  async ETHBalance() {
+    return await (0, import_actions.getBalance)(this.client.rpc, { address: this.address });
+  }
+  async transactionCount() {
+    return await (0, import_actions.getTransactionCount)(this.client.rpc, { address: this.address });
+  }
+  async transactions(params, forceFetch = false) {
+    if (!this.persistenceManager || forceFetch) {
+      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));
+  }
+  async syncTransactions(limit = 1e3) {
+    if (!this.persistenceManager)
+      throw new Error("The persistence module is not configured.");
+    await this.persistenceManager.syncTransactions(this, limit);
+  }
+  async tokenTransactions(tokenAddress) {
+    if (!this.persistenceManager)
+      throw new Error("The persistence module is not configured.");
+    return {};
+  }
   async toJSON(depth) {
     return await toJSON({
       obj: {
-        ...this
+        address: this.address,
+        isContract: this.isContract.bind(this),
+        contractType: this.contractType.bind(this),
+        ETHBalance: this.ETHBalance.bind(this),
+        transactionCount: this.transactionCount.bind(this)
       },
       depth
     });
   }
+  async _fetchTransactions({
+    fromBlock,
+    toBlock,
+    limit = 50
+  }) {
+    const lastBlock = await (0, import_actions.getBlockNumber)(this.client.rpc);
+    const onBlockRange = async ({ fromBlock: fromBlock2, toBlock: toBlock2 }, stop) => {
+      const outgoing = await (0, import_actions.traceFilter)(this.client.rpc, {
+        fromBlock: (0, import_utils.toHex)(fromBlock2),
+        toBlock: (0, import_utils.toHex)(toBlock2),
+        fromAddress: this.address
+      });
+      const incoming = await (0, import_actions.traceFilter)(this.client.rpc, {
+        fromBlock: (0, import_utils.toHex)(fromBlock2),
+        toBlock: (0, import_utils.toHex)(toBlock2),
+        toAddress: this.address
+      });
+      const traces = outgoing.concat(incoming).sort((a, b) => a.blockNumber - b.blockNumber);
+      return traces.map((t) => t.transactionHash);
+    };
+    return await (0, import_actions.fetchByBlockRange)({
+      toBlock: BigInt(toBlock !== void 0 ? toBlock : 0),
+      fromBlock: BigInt(fromBlock !== void 0 ? fromBlock : lastBlock),
+      direction: "backward",
+      itemLimit: limit,
+      onBlockRange
+    });
+  }
 };
 
 // src/structures/Transaction.ts
-var Transaction = class {
+var import_actions2 = require("@mentaproject/core/actions");
+var import_utils2 = require("@mentaproject/core/utils");
+
+// node_modules/viem/_esm/index.js
+init_transaction();
+
+// src/structures/Transaction.ts
+var Transaction2 = class {
   /**
    * Creates an instance of Transaction.
    * @description Initializes a new Transaction instance with the provided RPC client and transaction data.
@@ -334,15 +386,15 @@ var Transaction = class {
    * @returns {Promise<TransactionCall[] | undefined>} A promise that resolves to an array of call objects, each representing an internal call with sender, recipient, value, input data, gas used, and call type.
    */
   async calls() {
-    const traces = await (0, import_actions.traceTransaction)(this.client.rpc, this.hash);
+    const traces = await (0, import_actions2.traceTransaction)(this.client.rpc, this.hash);
     if (!traces) return void 0;
     const calls = traces.filter((t) => t.type === "call" && t.action !== void 0);
     return calls.map((c) => ({
       from: new Account(this.client, { address: c.action.from }),
       to: new Account(this.client, { address: c.action.to }),
-      value: (0, import_utils.hexToBigInt)(c.action.value),
+      value: (0, import_utils2.hexToBigInt)(c.action.value),
       input: c.action.input,
-      gas: (0, import_utils.hexToBigInt)(c.action.gas),
+      gas: (0, import_utils2.hexToBigInt)(c.action.gas),
       callType: c.action.callType
     }));
   }
@@ -353,7 +405,7 @@ var Transaction = class {
    * @returns {Promise<WaitForTransactionReceiptReturnType>} A promise that resolves to the transaction receipt once the specified number of confirmations are met.
    */
   async waitForReceipt(confirmations) {
-    return await (0, import_actions.waitForTransactionReceipt)(this.client.rpc, {
+    return await (0, import_actions2.waitForTransactionReceipt)(this.client.rpc, {
       hash: this.hash,
       confirmations: confirmations || 1
     });
@@ -365,7 +417,7 @@ var Transaction = class {
    */
   async receipt() {
     try {
-      return await (0, import_actions.getTransactionReceipt)(this.client.rpc, { hash: this.hash });
+      return await (0, import_actions2.getTransactionReceipt)(this.client.rpc, { hash: this.hash });
     } catch (error) {
       if (error instanceof TransactionReceiptNotFoundError) {
         return void 0;
@@ -378,7 +430,7 @@ var Transaction = class {
    * @returns {Promise<Block>} A promise that resolves to a Block instance representing the block that includes this transaction.
    */
   async block() {
-    const data = await (0, import_actions.getBlock)(this.client.rpc, { blockHash: this.blockHash });
+    const data = await (0, import_actions2.getBlock)(this.client.rpc, { blockHash: this.blockHash });
     return new Block(this.client, data);
   }
   /**
@@ -404,187 +456,66 @@ var Transaction = class {
   }
 };
 
-// src/structures/Account.ts
-var import_utils2 = require("@mentaproject/core/utils");
-var import_contracts = require("@mentaproject/contracts");
-var Account = class {
+// src/structures/Block.ts
+var Block = class {
   /**
-   * 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.
+   * @description Creates an instance of Block.
+   * @param client - The instance of MentaClient used to interact with the blockchain.
+   * @param data The raw block data conforming to IBlockData.
+   * @param includeTransactions Whether to include full transaction objects. Defaults to false.
    */
-  constructor(client, data, persistenceManager) {
+  constructor(client, data) {
     this.client = client;
-    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() {
-    const code = await (0, import_actions2.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() {
-    const isContract = await this.isContract();
-    if (!isContract) return void 0;
-    return await (0, import_contracts.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) {
-    const hash = await (0, import_actions2.sendTransaction)(this.client.rpc, {
-      calls: [
-        {
-          to: this.address,
-          value: amount
-        }
-      ]
-    });
-    const data = await (0, import_actions2.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() {
-    return await (0, import_actions2.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() {
-    return await (0, import_actions2.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, forceFetch = false) {
-    if (!this.persistenceManager || forceFetch) {
-      const hashes = await this._fetchTransactions(params);
-      const transactions = await Promise.all(
-        hashes.map((hash) => this.client.transactions.get({ hash }))
-      );
-      return transactions;
+    this.baseFeePerGas = data.baseFeePerGas;
+    this.blobGasUsed = data.blobGasUsed;
+    this.difficulty = data.difficulty;
+    this.excessBlobGas = data.excessBlobGas;
+    this.extraData = data.extraData;
+    this.gasLimit = data.gasLimit;
+    this.gasUsed = data.gasUsed;
+    this.hash = data.hash;
+    this.logsBloom = data.logsBloom;
+    this.mixHash = data.mixHash;
+    this.nonce = data.nonce;
+    this.number = data.number;
+    this.parentBeaconBlockRoot = data.parentBeaconBlockRoot;
+    this.parentHash = data.parentHash;
+    this.receiptsRoot = data.receiptsRoot;
+    this.sealFields = data.sealFields;
+    this.sha3Uncles = data.sha3Uncles;
+    this.size = data.size;
+    this.stateRoot = data.stateRoot;
+    this.timestamp = data.timestamp;
+    this.totalDifficulty = data.totalDifficulty;
+    this.transactionsRoot = data.transactionsRoot;
+    this.uncles = data.uncles;
+    this.withdrawals = data.withdrawals;
+    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((data2) => typeof data2 === "string" ? data2 : new Transaction2(this.client, data2));
+      this.transactions = parsed;
     }
-    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 = 1e3) {
-    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) {
-    if (!this.persistenceManager)
-      throw new Error("The persistence module is not configured.");
-    return {};
+  includeTransactions() {
+    if (!this.transactions || this.transactions.length === 0) return false;
+    return true;
   }
   /**
-   * 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.
+   * @description Converts the Block instance to a JSON representation.
+   * This method serializes the block's properties into a plain JavaScript object,
+   * suitable for JSON serialization.
+   * @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) {
     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)
+        ...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.
-   */
-  async _fetchTransactions({
-    fromBlock,
-    toBlock,
-    limit = 50
-  }) {
-    const lastBlock = await (0, import_actions2.getBlockNumber)(this.client.rpc);
-    const onBlockRange = async ({ fromBlock: fromBlock2, toBlock: toBlock2 }, stop) => {
-      const outgoing = await (0, import_actions2.traceFilter)(this.client.rpc, {
-        fromBlock: (0, import_utils2.toHex)(fromBlock2),
-        toBlock: (0, import_utils2.toHex)(toBlock2),
-        fromAddress: this.address
-      });
-      const incoming = await (0, import_actions2.traceFilter)(this.client.rpc, {
-        fromBlock: (0, import_utils2.toHex)(fromBlock2),
-        toBlock: (0, import_utils2.toHex)(toBlock2),
-        toAddress: this.address
-      });
-      const traces = outgoing.concat(incoming).sort((a, b) => a.blockNumber - b.blockNumber);
-      return traces.map((t) => t.transactionHash);
-    };
-    return await (0, import_actions2.fetchByBlockRange)({
-      toBlock: BigInt(toBlock !== void 0 ? toBlock : 0),
-      fromBlock: BigInt(fromBlock !== void 0 ? fromBlock : lastBlock),
-      direction: "backward",
-      itemLimit: limit,
-      onBlockRange
-    });
-  }
 };
 
 // src/structures/MentaClient.ts
@@ -636,6 +567,7 @@ var BlockManager = class {
 };
 
 // src/managers/TransactionManager.ts
+var import_transactions2 = require("@mentaproject/transactions");
 var import_actions4 = require("@mentaproject/core/actions");
 
 // src/utils/bigint.ts
@@ -692,36 +624,49 @@ function parseBingints(obj) {
 
 // src/managers/TransactionManager.ts
 var TransactionManager = class {
-  /**
-   * Creates an instance of `TransactionManager`.
-   * @constructor
-   * @param {MentaClient} client - The instance of MentaClient used to interact with the blockchain.
-   */
   constructor(client) {
     this.client = client;
   }
   /**
-   * 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.
+   * Creates a new MulticallTransaction for batching multiple calls.
+   *
+   * @returns A MulticallTransaction builder
+   *
+   * @example
+   * ```ts
+   * const pending = await client.transactions.create()
+   *   .addCall(account.sendEth(parseEther("1")))
+   *   .addCall(erc20.transfer(to, amount))
+   *   .execute();
+   * ```
+   */
+  create() {
+    return new import_transactions2.MulticallTransaction(this.client.rpc);
+  }
+  /**
+   * Retrieves a rich transaction by its hash.
+   *
+   * @param hash - The transaction hash
+   * @returns A rich Transaction with receipt, block, etc.
+   *
    * @example
-   * const txHash = '0x...'; // Replace with a valid transaction hash
-   * const transaction = await client.transactions.get({ hash: txHash });
-   * console.log(transaction);
+   * ```ts
+   * const tx = await client.transactions.fromHash(hash);
+   * console.log(tx.from, tx.to, tx.value);
+   * ```
+   */
+  async fromHash(hash) {
+    return this.get({ hash });
+  }
+  /**
+   * Retrieves a transaction by its hash or block number and index.
    */
   async get(params) {
     const data = await (0, import_actions4.getTransaction)(this.client.rpc, params);
-    return new Transaction(this.client, data);
+    return new Transaction2(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(data) {
     const parsed = parseBingints(data);
@@ -730,32 +675,11 @@ var TransactionManager = class {
       from: parsed.from.address,
       to: parsed.to ? parsed.to.address : null
     };
-    return new Transaction(this.client, rawData);
+    return new Transaction2(this.client, rawData);
   }
   /**
    * 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);
+   * @deprecated Use client.transactions.create() for new transactions
    */
   async send(params) {
     const hash = await (0, import_actions4.sendTransaction)(this.client.rpc, params);