@mentaproject/client 0.1.38 → 0.2.1

package/dist/index.js

@@ -13,37 +13,7 @@ import {
   getTransactionCount,
   traceFilter
 } from "@mentaproject/core/actions";
-
-// src/structures/Action.ts
-import { simulateCalls } from "@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 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
+import { Transaction } from "@mentaproject/transactions";
 import { toHex } from "@mentaproject/core/utils";
 import { getContractType } from "@mentaproject/contracts";
 
@@ -115,6 +85,17 @@ async function toJSON({ obj, depth = 0 }) {
   return convertBigintsToStrings(data);
 }
 
+// src/utils/withGasSupport.ts
+function withGasSupport(tx, gasManager) {
+  const enhanced = tx;
+  enhanced.withGas = async (strategy) => {
+    const config = await gasManager.estimate(strategy);
+    tx.withGasConfig(config);
+    return tx;
+  };
+  return enhanced;
+}
+
 // src/structures/Account.ts
 var Account = class {
   constructor(client, data, persistenceManager) {
@@ -133,25 +114,30 @@ var Account = class {
     return await getContractType(this.client.rpc, this.address);
   }
   /**
-   * Creates an Action to send ETH to this account.
+   * Creates a Transaction to send ETH to this account.
+   * Enhanced with withGas() support for easy gas configuration.
    *
    * @param amount The amount of ETH to send, in wei.
-   * @returns An Action with .call(), .simulate(), and .execute() methods.
+   * @returns A Transaction with withGas(), .call(), .simulate(), and .execute() methods.
    *
    * @example
    * ```ts
-   * // Direct execution
-   * await account.sendEth(parseEther("1")).execute();
+   * // With gas config
+   * const pending = await account.sendEth(parseEther("1"))
+   *   .withGas("fast")
+   *   .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, {
+    const tx = new Transaction(this.client.rpc, {
       to: this.address,
       value: amount
     });
+    return withGasSupport(tx, this.client.gas);
   }
   async ETHBalance() {
     return await getBalance(this.client.rpc, { address: this.address });
@@ -225,10 +211,10 @@ var Account = class {
   }
 };
 
-// src/structures/Transaction.ts
+// src/structures/TransactionRecord.ts
 import { getBlock, getTransactionReceipt, traceTransaction, waitForTransactionReceipt } from "@mentaproject/core/actions";
 import { hexToBigInt } from "@mentaproject/core/utils";
-var Transaction = class {
+var TransactionRecord = class {
   /**
    * Creates an instance of Transaction.
    * @description Initializes a new Transaction instance with the provided RPC client and transaction data.
@@ -372,7 +358,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 TransactionRecord(this.client, data2));
       this.transactions = parsed;
     }
   }
@@ -446,6 +432,7 @@ var BlockManager = class {
 };
 
 // src/managers/TransactionManager.ts
+import { MulticallTransaction } from "@mentaproject/transactions";
 import { getTransaction, sendTransaction } from "@mentaproject/core/actions";
 
 // src/utils/bigint.ts
@@ -502,36 +489,51 @@ 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.
+   * Enhanced with withGas() support for easy gas configuration.
+   *
+   * @returns A MulticallTransaction builder with withGas() support
+   *
+   * @example
+   * ```ts
+   * const pending = await client.transactions.create()
+   *   .addCall(account.sendEth(parseEther("1")))
+   *   .withGas("fast")
+   *   .execute();
+   * ```
+   */
+  create() {
+    const tx = new MulticallTransaction(this.client.rpc);
+    return withGasSupport(tx, this.client.gas);
+  }
+  /**
+   * Retrieves a transaction record by its hash.
+   *
+   * @param hash - The transaction hash
+   * @returns A TransactionRecord 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 getTransaction(this.client.rpc, params);
-    return new Transaction(this.client, data);
+    return new TransactionRecord(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);
@@ -540,32 +542,11 @@ var TransactionManager = class {
       from: parsed.from.address,
       to: parsed.to ? parsed.to.address : null
     };
-    return new Transaction(this.client, rawData);
+    return new TransactionRecord(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 sendTransaction(this.client.rpc, params);
@@ -709,6 +690,36 @@ var PersistenceManager = class {
   }
 };
 
+// src/managers/GasManager.ts
+import { GasTracker } from "@mentaproject/transactions";
+var GasManager = class {
+  constructor(client) {
+    this.client = client;
+    this.tracker = new GasTracker(client);
+  }
+  /**
+   * Gets all gas price estimates (slow, medium, fast).
+   */
+  async getPrices() {
+    return this.tracker.getEstimates();
+  }
+  /**
+   * Gets a specific gas estimate by strategy.
+   *
+   * @param strategy - "slow", "medium", or "fast"
+   */
+  async estimate(strategy) {
+    const prices = await this.getPrices();
+    return prices[strategy];
+  }
+  /**
+   * Gets the underlying GasTracker for advanced usage.
+   */
+  getTracker() {
+    return this.tracker;
+  }
+};
+
 // src/types/MentaClient.ts
 import { watchBlockNumber, watchBlocks } from "@mentaproject/core/actions";
 var ClientEvents = {
@@ -765,30 +776,15 @@ function withCache(client, cache) {
 var MentaClient = class {
   /**
    * Creates an instance of MentaClient.
-   * @param {MentaClientConfig} params - The configuration parameters for the client.
-   * @description The constructor initializes the RPC client and the various managers based on the provided configuration.
-   * It also applies caching and persistence if specified in the configuration.
-   * @example
-   * import { MentaClient } from '@mentaproject/client';
-   *
-   * // Basic initialization
-   * const client = new MentaClient({
-   *   url: 'http://rpcurlhere.com',
-   * });
-   *
-   * // Initialization with a persistent cache
-   * const clientWithCache = new MentaClient({
-   *   url: 'http://rpcurlhere.com',
-   *   cache: {
-   *     ttl: 60000, // 1 minute
-   *   },
-   * });
    */
   constructor(params) {
     this.params = params;
     this.blocks = new BlockManager(this);
     this.transactions = new TransactionManager(this);
     this.contracts = new ContractManager(this);
+    if (params.gas?.strategy) {
+      this.defaultGasStrategy = params.gas.strategy;
+    }
     if (params.persistenceAdapter) {
       this.persistenceManager = new PersistenceManager(
         this,
@@ -801,7 +797,6 @@ var MentaClient = class {
   }
   /**
    * The underlying RPC client used for blockchain interactions.
-   * @description This client is responsible for low-level communication with the RPC node.
    */
   get rpc() {
     if (!this._rpc) {
@@ -811,7 +806,6 @@ var MentaClient = class {
   }
   /**
    * The account associated with the client.
-   * @description This account is used for signing transactions and interacting with the blockchain.
    */
   get account() {
     if (!this._account) {
@@ -819,25 +813,17 @@ var MentaClient = class {
     }
     return this._account;
   }
+  /**
+   * Manager for gas estimation and configuration.
+   */
+  get gas() {
+    if (!this._gas) {
+      throw new Error("Gas manager not initialized");
+    }
+    return this._gas;
+  }
   /**
    * Subscribes to a specific client event.
-   * @template TEvent The type of the event to listen for.
-   * @param {TEvent} event - The event to listen for (e.g., 'block', 'transaction').
-   * @param {GetListenerCallback<TEvent>} callback - The callback function to execute when the event is triggered.
-   * @returns {() => void} An unsubscribe function to stop listening to the event.
-   * @description This method allows the client to listen for real-time events from the blockchain, such as new blocks or transactions.
-   * @example
-   * import { MentaClient } from '@mentaproject/client';
-   *
-   * const client = new MentaClient({ url: 'http://rpcurlhere.com' });
-   *
-   * // Subscribe to new blocks
-   * const unsubscribe = client.on('block', (block) => {
-   *   console.log('New block received:', block);
-   * });
-   *
-   * // To stop listening
-   * // unsubscribe();
    */
   on(event, callback) {
     const eventFunction = ClientEvents[event];
@@ -860,6 +846,7 @@ var MentaClient = class {
       validatorAddress: this.params.validatorAddress
     });
     this._account = this.accounts.get(this.rpc.account.address);
+    this._gas = new GasManager(this.rpc);
   }
 };
 
@@ -960,14 +947,14 @@ var MemoryCache = class {
 export {
   Account,
   AccountManager,
-  Action,
   Block,
   BlockManager,
   ContractManager,
+  GasManager,
   MemoryCache,
   MentaClient,
-  Transaction,
   TransactionManager,
+  TransactionRecord,
   bigIntMax,
   bigIntMin,
   bigIntReviver,