@mentaproject/client 0.1.38 → 0.2.0

package/dist/managers/TransactionManager.d.ts

@@ -2,69 +2,69 @@
  * @module TransactionManager
  */
 import { GetTransactionParameters, SendTransactionParameters } from "@mentaproject/core/types";
-import { Transaction } from "../structures/Transaction";
+import { Transaction as RichTransaction } from "../structures/Transaction";
+import { MulticallTransaction } from "@mentaproject/transactions";
 import { MentaClient } from "../structures";
 import { JSONTransaction } from "../types";
 /**
- * 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.
+ * Manages blockchain transaction-related operations.
+ *
+ * @example
+ * ```ts
+ * // Create a multicall transaction
+ * const pending = await client.transactions.create()
+ *   .addCall(account.sendEth(parseEther("1")))
+ *   .addCall(erc20.transfer(to, amount))
+ *   .execute();
+ *
+ * const receipt = await pending.confirm();
+ *
+ * // Get a transaction by hash
+ * const tx = await client.transactions.fromHash(hash);
+ * console.log(tx.receipt, tx.block);
+ * ```
  */
 export declare class TransactionManager {
     client: MentaClient;
+    constructor(client: MentaClient);
     /**
-     * Creates an instance of `TransactionManager`.
-     * @constructor
-     * @param {MentaClient} client - The instance of MentaClient used to interact with the blockchain.
+     * 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();
+     * ```
      */
-    constructor(client: MentaClient);
+    create(): MulticallTransaction;
     /**
-     * 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.
+     * 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);
+     * ```
      */
-    get(params: GetTransactionParameters): Promise<Transaction>;
+    fromHash(hash: `0x${string}`): Promise<RichTransaction>;
+    /**
+     * Retrieves a transaction by its hash or block number and index.
+     */
+    get(params: GetTransactionParameters): Promise<RichTransaction>;
     /**
      * 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;
+    parse<J extends JSONTransaction<0>>(data: J): RichTransaction;
     /**
      * 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
      */
-    send(params: SendTransactionParameters): Promise<Transaction>;
+    send(params: SendTransactionParameters): Promise<RichTransaction>;
 }

package/dist/structures/Account.d.ts

@@ -1,6 +1,6 @@
 import type { Address, Hash } from "@mentaproject/core/types";
-import { Transaction } from "./Transaction";
-import { Action } from "./Action";
+import { Transaction as RichTransaction } from "./Transaction";
+import { Transaction } from "@mentaproject/transactions";
 import { AccountData, FetchTransactionParams, GetTransactionsParams, JSONAccount } from "../types/Account";
 import { PersistenceManager } from "../managers/PersistenceManager";
 import { MentaClient } from "./MentaClient";
@@ -15,24 +15,25 @@ export declare class Account implements AccountData {
     isContract(): Promise<boolean>;
     contractType(): Promise<any>;
     /**
-     * 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: bigint): Action;
+    sendEth(amount: bigint): Transaction;
     ETHBalance(): Promise<bigint>;
     transactionCount(): Promise<number>;
-    transactions(params: GetTransactionsParams, forceFetch?: boolean): Promise<Transaction[]>;
+    transactions(params: GetTransactionsParams, forceFetch?: boolean): Promise<RichTransaction[]>;
     syncTransactions(limit?: number): Promise<void>;
     tokenTransactions(tokenAddress: Address): Promise<any>;
     toJSON<D extends number = 1>(depth: D): Promise<JSONAccount<D>>;

package/dist/structures/Action.d.ts

@@ -1,5 +1,20 @@
-import { Call, Hex } from "@mentaproject/core";
+import { Call, Hex, TransactionReceipt } from "@mentaproject/core";
 import { MentaAccountClient } from "@mentaproject/core/types";
+/**
+ * Represents a transaction that has been sent but not yet confirmed.
+ */
+export declare class PendingTransaction {
+    private client;
+    readonly hash: Hex;
+    constructor(client: MentaAccountClient, hash: Hex);
+    /**
+     * Waits for the transaction to be confirmed.
+     *
+     * @param confirmations Number of block confirmations to wait for (default: 1)
+     * @returns The transaction receipt
+     */
+    confirm(confirmations?: number): Promise<TransactionReceipt>;
+}
 /**
  * Generic action object that wraps a single call.
  *
@@ -9,7 +24,8 @@ import { MentaAccountClient } from "@mentaproject/core/types";
  * @example
  * ```ts
  * // Direct execution
- * await account.sendEth(parseEther("1")).execute();
+ * const pending = await account.sendEth(parseEther("1")).execute();
+ * const receipt = await pending.confirm();
  *
  * // Batching with TransactionBuilder
  * new TransactionBuilder(client.rpc)
@@ -33,7 +49,7 @@ export declare class Action {
     /**
      * Executes the action directly.
      *
-     * @returns Transaction hash
+     * @returns A PendingTransaction with the hash and .confirm() method
      */
-    execute(): Promise<Hex>;
+    execute(): Promise<PendingTransaction>;
 }

package/dist/structures/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./Account";
-export * from "./Action";
 export * from "./Block";
 export * from "./MentaClient";
 export * from "./Transaction";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentaproject/client",
-  "version": "0.1.38",
+  "version": "0.2.0",
   "description": "High level EVM library used into the Menta App to facilitate Blockchain interactions. ",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -36,6 +36,7 @@
   "dependencies": {
     "@mentaproject/contracts": "^0.0.11",
     "@mentaproject/core": "^0.7.3",
+    "@mentaproject/transactions": "^0.0.3",
     "@modelcontextprotocol/sdk": "^1.13.0",
     "@shazow/whatsabi": "^0.21.1"
   },

package/src/managers/TransactionManager.ts

@@ -1,92 +1,97 @@
 /**
  * @module TransactionManager
  */
-import {  GetTransactionParameters, Transaction as RawTransaction, SendTransactionParameters } from "@mentaproject/core/types";
-import { Transaction } from "../structures/Transaction";
+import { GetTransactionParameters, Transaction as RawTransaction, SendTransactionParameters } from "@mentaproject/core/types";
+import { Transaction as RichTransaction } from "../structures/Transaction";
+import { MulticallTransaction } from "@mentaproject/transactions";
 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.
+ * Manages blockchain transaction-related operations.
+ *
+ * @example
+ * ```ts
+ * // Create a multicall transaction
+ * const pending = await client.transactions.create()
+ *   .addCall(account.sendEth(parseEther("1")))
+ *   .addCall(erc20.transfer(to, amount))
+ *   .execute();
+ *
+ * const receipt = await pending.confirm();
+ *
+ * // Get a transaction by hash
+ * const tx = await client.transactions.fromHash(hash);
+ * console.log(tx.receipt, tx.block);
+ * ```
  */
 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) {};
+  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);
-    };
+  /**
+   * 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(): MulticallTransaction {
+    return new MulticallTransaction(this.client.rpc);
+  }
 
-    /**
-     * 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);
+  /**
+   * 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: `0x${string}`): Promise<RichTransaction> {
+    return this.get({ hash });
+  }
 
-        const rawData = {
-            ...parsed,
-            from: parsed.from.address,
-            to: parsed.to ? parsed.to.address : null,
-        };
-        
-        return new Transaction(this.client, rawData as RawTransaction);
-    };
+  /**
+   * Retrieves a transaction by its hash or block number and index.
+   */
+  async get(params: GetTransactionParameters): Promise<RichTransaction> {
+    const data = await getTransaction(this.client.rpc, params);
+    return new RichTransaction(this.client, data);
+  }
+
+  /**
+   * Parse a transaction object from a JSON converted transaction data object.
+   */
+  parse<J extends JSONTransaction<0>>(data: J): RichTransaction {
+    const parsed = parseBingints(data);
 
-    /**
-     * 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 });
+    const rawData = {
+      ...parsed,
+      from: parsed.from.address,
+      to: parsed.to ? parsed.to.address : null,
     };
-};
+
+    return new RichTransaction(this.client, rawData as RawTransaction);
+  }
+
+  /**
+   * Sends a transaction to the blockchain network.
+   * @deprecated Use client.transactions.create() for new transactions
+   */
+  async send(params: SendTransactionParameters): Promise<RichTransaction> {
+    const hash = await sendTransaction(this.client.rpc, params);
+    return await this.get({ hash });
+  }
+}

package/src/structures/Account.ts

@@ -11,8 +11,8 @@ import type {
   Hash,
   onBlockRangeCallback,
 } from "@mentaproject/core/types";
-import { Transaction } from "./Transaction";
-import { Action } from "./Action";
+import { Transaction as RichTransaction } from "./Transaction";
+import { Transaction } from "@mentaproject/transactions";
 import { toHex } from "@mentaproject/core/utils";
 import {
   AccountData,
@@ -54,22 +54,23 @@ export class Account implements AccountData {
   }
 
   /**
-   * 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: bigint): Action {
-    return new Action(this.client.rpc, {
+  sendEth(amount: bigint): Transaction {
+    return new Transaction(this.client.rpc, {
       to: this.address,
       value: amount,
     });
@@ -86,7 +87,7 @@ export class Account implements AccountData {
   async transactions(
     params: GetTransactionsParams,
     forceFetch = false,
-  ): Promise<Transaction[]> {
+  ): Promise<RichTransaction[]> {
     if (!this.persistenceManager || forceFetch) {
       const hashes = await this._fetchTransactions(params);
       const transactions = await Promise.all(

package/src/structures/index.ts

@@ -1,5 +1,4 @@
 export * from "./Account";
-export * from "./Action";
 export * from "./Block";
 export * from "./MentaClient";
 export * from "./Transaction";

package/src/structures/Action.ts

@@ -1,51 +0,0 @@
-import { Call, Hex } from "@mentaproject/core";
-import { MentaAccountClient } from "@mentaproject/core/types";
-import { simulateCalls } from "@mentaproject/core/actions";
-
-/**
- * Generic action object that wraps a single call.
- *
- * Provides `.call()` for batching with TransactionBuilder
- * and `.execute()` for direct execution.
- *
- * @example
- * ```ts
- * // Direct execution
- * await account.sendEth(parseEther("1")).execute();
- *
- * // Batching with TransactionBuilder
- * new TransactionBuilder(client.rpc)
- *   .addCall(account.sendEth(parseEther("1")))
- *   .addCall(token.transfer(to, amount))
- *   .execute();
- * ```
- */
-export class Action {
-  constructor(
-    private client: MentaAccountClient,
-    private _call: Call,
-  ) {}
-
-  /**
-   * Returns the Call object for use with TransactionBuilder.
-   */
-  call(): Call {
-    return this._call;
-  }
-
-  /**
-   * Simulates the action without executing.
-   */
-  async simulate() {
-    return simulateCalls(this.client, { calls: [this._call] });
-  }
-
-  /**
-   * Executes the action directly.
-   *
-   * @returns Transaction hash
-   */
-  async execute(): Promise<Hex> {
-    return this.client.sendTransaction(this._call as any);
-  }
-}