@mentaproject/client 0.1.38 → 0.2.0

package/dist/index.cjs

@@ -141,13 +141,12 @@ var src_exports = {};
 __export(src_exports, {
   Account: () => Account,
   AccountManager: () => AccountManager,
-  Action: () => Action,
   Block: () => Block,
   BlockManager: () => BlockManager,
   ContractManager: () => ContractManager,
   MemoryCache: () => MemoryCache,
   MentaClient: () => MentaClient,
-  Transaction: () => Transaction,
+  Transaction: () => Transaction2,
   TransactionManager: () => TransactionManager,
   bigIntMax: () => bigIntMax,
   bigIntMin: () => bigIntMin,
@@ -158,38 +157,8 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/structures/Account.ts
-var import_actions2 = require("@mentaproject/core/actions");
-
-// src/structures/Action.ts
 var import_actions = require("@mentaproject/core/actions");
-var Action = class {
-  constructor(client, _call) {
-    this.client = client;
-    this._call = _call;
-  }
-  /**
-   * Returns the Call object for use with TransactionBuilder.
-   */
-  call() {
-    return this._call;
-  }
-  /**
-   * Simulates the action without executing.
-   */
-  async simulate() {
-    return (0, import_actions.simulateCalls)(this.client, { calls: [this._call] });
-  }
-  /**
-   * Executes the action directly.
-   *
-   * @returns Transaction hash
-   */
-  async execute() {
-    return this.client.sendTransaction(this._call);
-  }
-};
-
-// src/structures/Account.ts
+var import_transactions = require("@mentaproject/transactions");
 var import_utils = require("@mentaproject/core/utils");
 var import_contracts = require("@mentaproject/contracts");
 
@@ -269,7 +238,7 @@ var Account = class {
     this.persistenceManager = persistenceManager;
   }
   async isContract() {
-    const code = await (0, import_actions2.getCode)(this.client.rpc, { address: this.address });
+    const code = await (0, import_actions.getCode)(this.client.rpc, { address: this.address });
     if (!code || code === "0x") return false;
     return true;
   }
@@ -279,31 +248,32 @@ var Account = class {
     return await (0, import_contracts.getContractType)(this.client.rpc, this.address);
   }
   /**
-   * Creates an Action to send ETH to this account.
+   * Creates a Transaction to send ETH to this account.
    *
    * @param amount The amount of ETH to send, in wei.
-   * @returns An Action with .call(), .simulate(), and .execute() methods.
+   * @returns A Transaction with .call(), .simulate(), and .execute() methods.
    *
    * @example
    * ```ts
    * // Direct execution
-   * await account.sendEth(parseEther("1")).execute();
+   * const pending = await account.sendEth(parseEther("1")).execute();
+   * const receipt = await pending.confirm();
    *
-   * // Batch with TransactionBuilder
-   * builder.addCall(account.sendEth(parseEther("1")));
+   * // Batch with MulticallTransaction
+   * multicall.addCall(account.sendEth(parseEther("1")));
    * ```
    */
   sendEth(amount) {
-    return new Action(this.client.rpc, {
+    return new import_transactions.Transaction(this.client.rpc, {
       to: this.address,
       value: amount
     });
   }
   async ETHBalance() {
-    return await (0, import_actions2.getBalance)(this.client.rpc, { address: this.address });
+    return await (0, import_actions.getBalance)(this.client.rpc, { address: this.address });
   }
   async transactionCount() {
-    return await (0, import_actions2.getTransactionCount)(this.client.rpc, { address: this.address });
+    return await (0, import_actions.getTransactionCount)(this.client.rpc, { address: this.address });
   }
   async transactions(params, forceFetch = false) {
     if (!this.persistenceManager || forceFetch) {
@@ -346,14 +316,14 @@ var Account = class {
     toBlock,
     limit = 50
   }) {
-    const lastBlock = await (0, import_actions2.getBlockNumber)(this.client.rpc);
+    const lastBlock = await (0, import_actions.getBlockNumber)(this.client.rpc);
     const onBlockRange = async ({ fromBlock: fromBlock2, toBlock: toBlock2 }, stop) => {
-      const outgoing = await (0, import_actions2.traceFilter)(this.client.rpc, {
+      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_actions2.traceFilter)(this.client.rpc, {
+      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
@@ -361,7 +331,7 @@ var Account = class {
       const traces = outgoing.concat(incoming).sort((a, b) => a.blockNumber - b.blockNumber);
       return traces.map((t) => t.transactionHash);
     };
-    return await (0, import_actions2.fetchByBlockRange)({
+    return await (0, import_actions.fetchByBlockRange)({
       toBlock: BigInt(toBlock !== void 0 ? toBlock : 0),
       fromBlock: BigInt(fromBlock !== void 0 ? fromBlock : lastBlock),
       direction: "backward",
@@ -372,14 +342,14 @@ var Account = class {
 };
 
 // src/structures/Transaction.ts
-var import_actions3 = require("@mentaproject/core/actions");
+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 Transaction = class {
+var Transaction2 = class {
   /**
    * Creates an instance of Transaction.
    * @description Initializes a new Transaction instance with the provided RPC client and transaction data.
@@ -416,7 +386,7 @@ 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_actions3.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) => ({
@@ -435,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_actions3.waitForTransactionReceipt)(this.client.rpc, {
+    return await (0, import_actions2.waitForTransactionReceipt)(this.client.rpc, {
       hash: this.hash,
       confirmations: confirmations || 1
     });
@@ -447,7 +417,7 @@ var Transaction = class {
    */
   async receipt() {
     try {
-      return await (0, import_actions3.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;
@@ -460,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_actions3.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);
   }
   /**
@@ -523,7 +493,7 @@ var Block = class {
     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));
+      const parsed = data.transactions.map((data2) => typeof data2 === "string" ? data2 : new Transaction2(this.client, data2));
       this.transactions = parsed;
     }
   }
@@ -553,7 +523,7 @@ var import_clients = require("@mentaproject/core/clients");
 var import_core = require("@mentaproject/core");
 
 // src/managers/BlockManager.ts
-var import_actions4 = require("@mentaproject/core/actions");
+var import_actions3 = require("@mentaproject/core/actions");
 var BlockManager = class {
   /**
    * Creates an instance of BlockManager.
@@ -591,13 +561,14 @@ var BlockManager = class {
    * fetchBlock();
    */
   async get(params) {
-    const data = await (0, import_actions4.getBlock)(this.client.rpc, params);
+    const data = await (0, import_actions3.getBlock)(this.client.rpc, params);
     return new Block(this.client, data);
   }
 };
 
 // src/managers/TransactionManager.ts
-var import_actions5 = require("@mentaproject/core/actions");
+var import_transactions2 = require("@mentaproject/transactions");
+var import_actions4 = require("@mentaproject/core/actions");
 
 // src/utils/bigint.ts
 var bigIntMax = (...args) => args.reduce((m, e) => e > m ? e : m);
@@ -653,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
-   * 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 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
+   * ```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_actions5.getTransaction)(this.client.rpc, params);
-    return new Transaction(this.client, data);
+    const data = await (0, import_actions4.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);
@@ -691,35 +675,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 (0, import_actions5.sendTransaction)(this.client.rpc, params);
+    const hash = await (0, import_actions4.sendTransaction)(this.client.rpc, params);
     return await this.get({ hash });
   }
 };
@@ -817,7 +780,7 @@ var AccountManager = class {
 };
 
 // src/managers/PersistenceManager.ts
-var import_actions6 = require("@mentaproject/core/actions");
+var import_actions5 = require("@mentaproject/core/actions");
 var PersistenceManager = class {
   /**
    * Creates an instance of PersistenceManager.
@@ -846,7 +809,7 @@ var PersistenceManager = class {
   async syncTransactions(account, limit = 1e5) {
     const lastSyncedBlock = await this.persistenceAdapter.getLastSyncedBlock(account.address);
     const lastBlock = lastSyncedBlock ?? 0n;
-    const fromBlock = lastSyncedBlock ? lastSyncedBlock + 1n : await (0, import_actions6.getBlockNumber)(this.client.rpc);
+    const fromBlock = lastSyncedBlock ? lastSyncedBlock + 1n : await (0, import_actions5.getBlockNumber)(this.client.rpc);
     const newTransactions = await account.transactions({
       fromBlock,
       toBlock: lastBlock,
@@ -861,22 +824,22 @@ var PersistenceManager = class {
 };
 
 // src/types/MentaClient.ts
-var import_actions7 = require("@mentaproject/core/actions");
+var import_actions6 = require("@mentaproject/core/actions");
 var ClientEvents = {
   /**
    * Event for new blocks.
    * Uses the {@link watchBlocks} function from `@mentaproject/core`.
    */
-  block: import_actions7.watchBlocks,
+  block: import_actions6.watchBlocks,
   /**
    * Event for new block numbers.
    * Uses the {@link watchBlockNumber} function from `@mentaproject/core`.
    */
-  blockNumber: import_actions7.watchBlockNumber
+  blockNumber: import_actions6.watchBlockNumber
 };
 
 // src/utils/withCache.ts
-var import_actions8 = require("@mentaproject/core/actions");
+var import_actions7 = require("@mentaproject/core/actions");
 var GET_NONCE_SELECTOR = "0x35567e1a";
 function isNonceCall(method, params) {
   if (method !== "eth_call") return false;
@@ -884,7 +847,7 @@ function isNonceCall(method, params) {
   return typeof callData === "string" && callData.startsWith(GET_NONCE_SELECTOR);
 }
 function withCache(client, cache) {
-  (0, import_actions8.watchBlockNumber)(client, {
+  (0, import_actions7.watchBlockNumber)(client, {
     onBlockNumber: (blockNumber) => {
       cache.setBlockNumber(blockNumber);
     },
@@ -1112,7 +1075,6 @@ var MemoryCache = class {
 0 && (module.exports = {
   Account,
   AccountManager,
-  Action,
   Block,
   BlockManager,
   ContractManager,