@mentaproject/client 0.2.0 → 0.2.2

package/dist/index.cjs

@@ -144,10 +144,11 @@ __export(src_exports, {
   Block: () => Block,
   BlockManager: () => BlockManager,
   ContractManager: () => ContractManager,
+  GasManager: () => GasManager,
   MemoryCache: () => MemoryCache,
   MentaClient: () => MentaClient,
-  Transaction: () => Transaction2,
   TransactionManager: () => TransactionManager,
+  TransactionRecord: () => TransactionRecord,
   bigIntMax: () => bigIntMax,
   bigIntMin: () => bigIntMin,
   bigIntReviver: () => bigIntReviver,
@@ -230,6 +231,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) {
@@ -249,14 +261,17 @@ var Account = class {
   }
   /**
    * 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 A Transaction with .call(), .simulate(), and .execute() methods.
+   * @returns A Transaction with withGas(), .call(), .simulate(), and .execute() methods.
    *
    * @example
    * ```ts
-   * // Direct execution
-   * const pending = 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 MulticallTransaction
@@ -264,10 +279,11 @@ var Account = class {
    * ```
    */
   sendEth(amount) {
-    return new import_transactions.Transaction(this.client.rpc, {
+    const tx = new import_transactions.Transaction(this.client.rpc, {
       to: this.address,
       value: amount
     });
+    return withGasSupport(tx, this.client.gas);
   }
   async ETHBalance() {
     return await (0, import_actions.getBalance)(this.client.rpc, { address: this.address });
@@ -341,15 +357,15 @@ var Account = class {
   }
 };
 
-// src/structures/Transaction.ts
+// src/structures/TransactionRecord.ts
 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 {
+// src/structures/TransactionRecord.ts
+var TransactionRecord = class {
   /**
    * Creates an instance of Transaction.
    * @description Initializes a new Transaction instance with the provided RPC client and transaction data.
@@ -493,7 +509,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 Transaction2(this.client, data2));
+      const parsed = data.transactions.map((data2) => typeof data2 === "string" ? data2 : new TransactionRecord(this.client, data2));
       this.transactions = parsed;
     }
   }
@@ -629,25 +645,27 @@ var TransactionManager = class {
   }
   /**
    * Creates a new MulticallTransaction for batching multiple calls.
+   * Enhanced with withGas() support for easy gas configuration.
    *
-   * @returns A MulticallTransaction builder
+   * @returns A MulticallTransaction builder with withGas() support
    *
    * @example
    * ```ts
    * const pending = await client.transactions.create()
    *   .addCall(account.sendEth(parseEther("1")))
-   *   .addCall(erc20.transfer(to, amount))
+   *   .withGas("fast")
    *   .execute();
    * ```
    */
   create() {
-    return new import_transactions2.MulticallTransaction(this.client.rpc);
+    const tx = new import_transactions2.MulticallTransaction(this.client.rpc);
+    return withGasSupport(tx, this.client.gas);
   }
   /**
-   * Retrieves a rich transaction by its hash.
+   * Retrieves a transaction record by its hash.
    *
    * @param hash - The transaction hash
-   * @returns A rich Transaction with receipt, block, etc.
+   * @returns A TransactionRecord with receipt, block, etc.
    *
    * @example
    * ```ts
@@ -663,7 +681,7 @@ var TransactionManager = class {
    */
   async get(params) {
     const data = await (0, import_actions4.getTransaction)(this.client.rpc, params);
-    return new Transaction2(this.client, data);
+    return new TransactionRecord(this.client, data);
   }
   /**
    * Parse a transaction object from a JSON converted transaction data object.
@@ -675,7 +693,7 @@ var TransactionManager = class {
       from: parsed.from.address,
       to: parsed.to ? parsed.to.address : null
     };
-    return new Transaction2(this.client, rawData);
+    return new TransactionRecord(this.client, rawData);
   }
   /**
    * Sends a transaction to the blockchain network.
@@ -823,6 +841,36 @@ var PersistenceManager = class {
   }
 };
 
+// src/managers/GasManager.ts
+var import_transactions3 = require("@mentaproject/transactions");
+var GasManager = class {
+  constructor(client) {
+    this.client = client;
+    this.tracker = new import_transactions3.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
 var import_actions6 = require("@mentaproject/core/actions");
 var ClientEvents = {
@@ -879,30 +927,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,
@@ -915,7 +948,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) {
@@ -925,7 +957,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) {
@@ -933,25 +964,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];
@@ -974,6 +997,7 @@ var MentaClient = class {
       validatorAddress: this.params.validatorAddress
     });
     this._account = this.accounts.get(this.rpc.account.address);
+    this._gas = new GasManager(this.rpc);
   }
 };
 
@@ -1078,10 +1102,11 @@ var MemoryCache = class {
   Block,
   BlockManager,
   ContractManager,
+  GasManager,
   MemoryCache,
   MentaClient,
-  Transaction,
   TransactionManager,
+  TransactionRecord,
   bigIntMax,
   bigIntMin,
   bigIntReviver,