@mentaproject/client 0.1.38 → 0.2.1

package/dist/index.cjs

@@ -141,14 +141,14 @@ var src_exports = {};
 __export(src_exports, {
   Account: () => Account,
   AccountManager: () => AccountManager,
-  Action: () => Action,
   Block: () => Block,
   BlockManager: () => BlockManager,
   ContractManager: () => ContractManager,
+  GasManager: () => GasManager,
   MemoryCache: () => MemoryCache,
   MentaClient: () => MentaClient,
-  Transaction: () => Transaction,
   TransactionManager: () => TransactionManager,
+  TransactionRecord: () => TransactionRecord,
   bigIntMax: () => bigIntMax,
   bigIntMin: () => bigIntMin,
   bigIntReviver: () => bigIntReviver,
@@ -158,38 +158,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");
 
@@ -261,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) {
@@ -269,7 +250,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 +260,36 @@ 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.
+   * 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 import_transactions.Transaction(this.client.rpc, {
       to: this.address,
       value: amount
     });
+    return withGasSupport(tx, this.client.gas);
   }
   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 +332,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 +347,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",
@@ -371,15 +357,15 @@ var Account = class {
   }
 };
 
-// src/structures/Transaction.ts
-var import_actions3 = require("@mentaproject/core/actions");
+// 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 Transaction = 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.
@@ -416,7 +402,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 +421,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 +433,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 +446,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 +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 Transaction(this.client, data2));
+      const parsed = data.transactions.map((data2) => typeof data2 === "string" ? data2 : new TransactionRecord(this.client, data2));
       this.transactions = parsed;
     }
   }
@@ -553,7 +539,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 +577,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 +640,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
-   * 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")))
+   *   .withGas("fast")
+   *   .execute();
+   * ```
+   */
+  create() {
+    const tx = new import_transactions2.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
+   * ```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 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);
@@ -691,35 +693,14 @@ 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 (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 +798,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 +827,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,
@@ -860,23 +841,53 @@ 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_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 +895,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);
     },
@@ -916,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,
@@ -952,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) {
@@ -962,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) {
@@ -970,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];
@@ -1011,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);
   }
 };
 
@@ -1112,14 +1099,14 @@ var MemoryCache = class {
 0 && (module.exports = {
   Account,
   AccountManager,
-  Action,
   Block,
   BlockManager,
   ContractManager,
+  GasManager,
   MemoryCache,
   MentaClient,
-  Transaction,
   TransactionManager,
+  TransactionRecord,
   bigIntMax,
   bigIntMin,
   bigIntReviver,