@mentaproject/client 0.1.37 → 0.2.0

package/dist/index.js

@@ -10,15 +10,12 @@ import {
   getBalance,
   getBlockNumber,
   getCode,
-  getTransaction,
   getTransactionCount,
-  sendTransaction,
   traceFilter
 } from "@mentaproject/core/actions";
-
-// src/structures/Transaction.ts
-import { getBlock, getTransactionReceipt, traceTransaction, waitForTransactionReceipt } from "@mentaproject/core/actions";
-import { hexToBigInt } from "@mentaproject/core/utils";
+import { Transaction } from "@mentaproject/transactions";
+import { toHex } from "@mentaproject/core/utils";
+import { getContractType } from "@mentaproject/contracts";
 
 // src/utils/toJSON.ts
 function isClassInstance(obj) {
@@ -88,70 +85,121 @@ 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 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 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 Transaction(this.client.rpc, {
+      to: this.address,
+      value: amount
+    });
+  }
+  async ETHBalance() {
+    return await getBalance(this.client.rpc, { address: this.address });
+  }
+  async transactionCount() {
+    return await 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 getBlockNumber(this.client.rpc);
+    const onBlockRange = async ({ fromBlock: fromBlock2, toBlock: toBlock2 }, stop) => {
+      const outgoing = await traceFilter(this.client.rpc, {
+        fromBlock: toHex(fromBlock2),
+        toBlock: toHex(toBlock2),
+        fromAddress: this.address
+      });
+      const incoming = await traceFilter(this.client.rpc, {
+        fromBlock: toHex(fromBlock2),
+        toBlock: 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 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 {
+import { getBlock, getTransactionReceipt, traceTransaction, waitForTransactionReceipt } from "@mentaproject/core/actions";
+import { hexToBigInt } from "@mentaproject/core/utils";
+var Transaction2 = class {
   /**
    * Creates an instance of Transaction.
    * @description Initializes a new Transaction instance with the provided RPC client and transaction data.
@@ -258,187 +306,66 @@ var Transaction = class {
   }
 };
 
-// src/structures/Account.ts
-import { toHex } from "@mentaproject/core/utils";
-import { getContractType } from "@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 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 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 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() {
-    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() {
-    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, 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 getBlockNumber(this.client.rpc);
-    const onBlockRange = async ({ fromBlock: fromBlock2, toBlock: toBlock2 }, stop) => {
-      const outgoing = await traceFilter(this.client.rpc, {
-        fromBlock: toHex(fromBlock2),
-        toBlock: toHex(toBlock2),
-        fromAddress: this.address
-      });
-      const incoming = await traceFilter(this.client.rpc, {
-        fromBlock: toHex(fromBlock2),
-        toBlock: 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 fetchByBlockRange({
-      toBlock: BigInt(toBlock !== void 0 ? toBlock : 0),
-      fromBlock: BigInt(fromBlock !== void 0 ? fromBlock : lastBlock),
-      direction: "backward",
-      itemLimit: limit,
-      onBlockRange
-    });
-  }
 };
 
 // src/structures/MentaClient.ts
@@ -490,7 +417,8 @@ var BlockManager = class {
 };
 
 // src/managers/TransactionManager.ts
-import { getTransaction as getTransaction2, sendTransaction as sendTransaction2 } from "@mentaproject/core/actions";
+import { MulticallTransaction } from "@mentaproject/transactions";
+import { getTransaction, sendTransaction } from "@mentaproject/core/actions";
 
 // src/utils/bigint.ts
 var bigIntMax = (...args) => args.reduce((m, e) => e > m ? e : m);
@@ -546,36 +474,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
-   * const txHash = '0x...'; // Replace with a valid transaction hash
-   * const transaction = await client.transactions.get({ hash: txHash });
-   * console.log(transaction);
+   * ```ts
+   * const pending = await client.transactions.create()
+   *   .addCall(account.sendEth(parseEther("1")))
+   *   .addCall(erc20.transfer(to, amount))
+   *   .execute();
+   * ```
+   */
+  create() {
+    return new 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
+   * ```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 getTransaction2(this.client.rpc, params);
-    return new Transaction(this.client, data);
+    const data = await getTransaction(this.client.rpc, params);
+    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);
@@ -584,35 +525,14 @@ 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 sendTransaction2(this.client.rpc, params);
+    const hash = await sendTransaction(this.client.rpc, params);
     return await this.get({ hash });
   }
 };
@@ -1009,7 +929,7 @@ export {
   ContractManager,
   MemoryCache,
   MentaClient,
-  Transaction,
+  Transaction2 as Transaction,
   TransactionManager,
   bigIntMax,
   bigIntMin,