@hashgraphonline/standards-sdk 0.0.111 → 0.0.112-canary.0

package/dist/es/standards-sdk.es21.js

@@ -4,18 +4,26 @@ import axios from "axios";
 import { Logger } from "./standards-sdk.es15.js";
 import { proto } from "@hashgraph/proto";
 class HederaMirrorNode {
-  constructor(network, logger) {
+  constructor(network, logger, config) {
     this.maxRetries = 3;
     this.initialDelayMs = 1e3;
     this.maxDelayMs = 3e4;
     this.backoffFactor = 2;
     this.network = network;
-    this.baseUrl = this.getMirrorNodeUrl();
+    this.apiKey = config?.apiKey;
+    this.customHeaders = config?.headers || {};
+    this.baseUrl = config?.customUrl || this.getMirrorNodeUrl();
     this.logger = logger || new Logger({
       level: "debug",
       module: "MirrorNode"
     });
     this.isServerEnvironment = typeof window === "undefined";
+    if (config?.customUrl) {
+      this.logger.info(`Using custom mirror node URL: ${config.customUrl}`);
+    }
+    if (config?.apiKey) {
+      this.logger.info("Using API key for mirror node requests");
+    }
   }
   /**
    * Configures the retry mechanism for API requests.
@@ -30,6 +38,36 @@ class HederaMirrorNode {
       `Retry configuration updated: maxRetries=${this.maxRetries}, initialDelayMs=${this.initialDelayMs}, maxDelayMs=${this.maxDelayMs}, backoffFactor=${this.backoffFactor}`
     );
   }
+  /**
+   * Updates the mirror node configuration.
+   * @param config The new mirror node configuration.
+   */
+  configureMirrorNode(config) {
+    if (config.customUrl) {
+      this.baseUrl = config.customUrl;
+      this.logger.info(`Updated mirror node URL: ${config.customUrl}`);
+    }
+    if (config.apiKey) {
+      this.apiKey = config.apiKey;
+      this.logger.info("Updated API key for mirror node requests");
+    }
+    if (config.headers) {
+      this.customHeaders = { ...this.customHeaders, ...config.headers };
+      this.logger.info("Updated custom headers for mirror node requests");
+    }
+  }
+  /**
+   * Constructs a full URL for API requests, handling custom providers with API keys in the path.
+   * @param endpoint The API endpoint (e.g., '/api/v1/accounts/0.0.123')
+   * @returns The full URL for the request
+   */
+  constructUrl(endpoint) {
+    if (this.baseUrl.includes("<API-KEY>") && this.apiKey) {
+      const baseUrlWithKey = this.baseUrl.replace("<API-KEY>", this.apiKey);
+      return endpoint.startsWith("/") ? `${baseUrlWithKey}${endpoint}` : `${baseUrlWithKey}/${endpoint}`;
+    }
+    return endpoint.startsWith("/") ? `${this.baseUrl}${endpoint}` : `${this.baseUrl}/${endpoint}`;
+  }
   getMirrorNodeUrl() {
     return this.network === "mainnet" ? "https://mainnet-public.mirrornode.hedera.com" : "https://testnet.mirrornode.hedera.com";
   }
@@ -67,7 +105,7 @@ class HederaMirrorNode {
    */
   async getAccountMemo(accountId) {
     this.logger.info(`Getting account memo for account ID: ${accountId}`);
-    const accountInfoUrl = `${this.baseUrl}/api/v1/accounts/${accountId}`;
+    const accountInfoUrl = this.constructUrl(`/api/v1/accounts/${accountId}`);
     try {
       const accountInfo = await this._requestWithRetry(
         accountInfoUrl
@@ -93,7 +131,7 @@ class HederaMirrorNode {
    */
   async getTopicInfo(topicId) {
     try {
-      const topicInfoUrl = `${this.baseUrl}/api/v1/topics/${topicId}`;
+      const topicInfoUrl = this.constructUrl(`/api/v1/topics/${topicId}`);
       this.logger.debug(`Fetching topic info from ${topicInfoUrl}`);
       const data = await this._requestWithRetry(topicInfoUrl);
       return data;
@@ -151,7 +189,7 @@ class HederaMirrorNode {
   async getTokenInfo(tokenId) {
     this.logger.debug(`Fetching token info for ${tokenId}`);
     try {
-      const tokenInfoUrl = `${this.baseUrl}/api/v1/tokens/${tokenId}`;
+      const tokenInfoUrl = this.constructUrl(`/api/v1/tokens/${tokenId}`);
       const data = await this._requestWithRetry(
         tokenInfoUrl
       );
@@ -176,7 +214,7 @@ class HederaMirrorNode {
    */
   async getTopicMessages(topicId) {
     this.logger.trace(`Querying messages for topic ${topicId}`);
-    let nextUrl = `${this.baseUrl}/api/v1/topics/${topicId}/messages`;
+    let nextUrl = this.constructUrl(`/api/v1/topics/${topicId}/messages`);
     const messages = [];
     while (nextUrl) {
       try {
@@ -230,7 +268,7 @@ class HederaMirrorNode {
             }
           }
         }
-        nextUrl = data.links?.next ? `${this.baseUrl}${data.links.next}` : "";
+        nextUrl = data.links?.next ? this.constructUrl(data.links.next) : "";
       } catch (e) {
         const error = e;
         const logMessage = `Error querying topic messages for topic ${topicId} (URL: ${nextUrl}) after retries: ${error.message}`;
@@ -248,7 +286,7 @@ class HederaMirrorNode {
    */
   async requestAccount(accountId) {
     try {
-      const accountInfoUrl = `${this.baseUrl}/api/v1/accounts/${accountId}`;
+      const accountInfoUrl = this.constructUrl(`/api/v1/accounts/${accountId}`);
       this.logger.debug(`Requesting account info from ${accountInfoUrl}`);
       const data = await this._requestWithRetry(
         accountInfoUrl
@@ -445,9 +483,23 @@ class HederaMirrorNode {
   async _requestWithRetry(url, axiosConfig) {
     let attempt = 0;
     let delay = this.initialDelayMs;
+    const config = {
+      ...axiosConfig,
+      headers: {
+        ...this.customHeaders,
+        ...axiosConfig?.headers
+      }
+    };
+    if (this.apiKey) {
+      config.headers = {
+        ...config.headers,
+        Authorization: `Bearer ${this.apiKey}`,
+        "X-API-Key": this.apiKey
+      };
+    }
     while (attempt < this.maxRetries) {
       try {
-        const response = await axios.get(url, axiosConfig);
+        const response = await axios.get(url, config);
         return response.data;
       } catch (error) {
         attempt++;
@@ -482,9 +534,33 @@ class HederaMirrorNode {
   async _fetchWithRetry(url, fetchOptions) {
     let attempt = 0;
     let delay = this.initialDelayMs;
+    const headers = {
+      ...this.customHeaders
+    };
+    if (fetchOptions?.headers) {
+      if (fetchOptions.headers instanceof Headers) {
+        fetchOptions.headers.forEach((value, key) => {
+          headers[key] = value;
+        });
+      } else if (Array.isArray(fetchOptions.headers)) {
+        fetchOptions.headers.forEach(([key, value]) => {
+          headers[key] = value;
+        });
+      } else {
+        Object.assign(headers, fetchOptions.headers);
+      }
+    }
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+      headers["X-API-Key"] = this.apiKey;
+    }
+    const options = {
+      ...fetchOptions,
+      headers
+    };
     while (attempt < this.maxRetries) {
       try {
-        const request = await fetch(url, fetchOptions);
+        const request = await fetch(url, options);
         if (!request.ok) {
           if (request.status >= 400 && request.status < 500 && request.status !== 429) {
             this.logger.error(
@@ -832,6 +908,578 @@ class HederaMirrorNode {
       return null;
     }
   }
+  /**
+   * Retrieves token airdrops for a given account ID.
+   * @param accountId The ID of the account to retrieve airdrops for.
+   * @param limit The maximum number of airdrops to return.
+   * @returns A promise that resolves to an array of TokenAirdrop or null.
+   */
+  async getTokenAirdrops(accountId, limit = 100) {
+    this.logger.info(`Getting token airdrops for account ${accountId}`);
+    const url = `${this.baseUrl}/api/v1/accounts/${accountId}/airdrops/tokens?limit=${limit}`;
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.airdrops || [];
+    } catch (error) {
+      this.logger.error(
+        `Error fetching token airdrops for account ${accountId}: ${error.message}`
+      );
+      return null;
+    }
+  }
+  /**
+   * Retrieves blocks from the network.
+   * @param options Optional parameters for filtering blocks.
+   * @returns A promise that resolves to an array of Block or null.
+   */
+  async getBlocks(options) {
+    this.logger.info("Getting blocks from the network");
+    let url = `${this.baseUrl}/api/v1/blocks`;
+    const params = new URLSearchParams();
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    if (options?.timestamp) {
+      params.append("timestamp", options.timestamp);
+    }
+    if (options?.blockNumber) {
+      params.append("block.number", options.blockNumber);
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.blocks || [];
+    } catch (error) {
+      this.logger.error(`Error fetching blocks: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * Retrieves a specific block by number or hash.
+   * @param blockNumberOrHash The block number or hash.
+   * @returns A promise that resolves to a Block or null.
+   */
+  async getBlock(blockNumberOrHash) {
+    this.logger.info(`Getting block ${blockNumberOrHash}`);
+    const url = `${this.baseUrl}/api/v1/blocks/${blockNumberOrHash}`;
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching block ${blockNumberOrHash}: ${error.message}`
+      );
+      return null;
+    }
+  }
+  /**
+   * Retrieves contract entities from the network.
+   * @param options Optional parameters for filtering contracts.
+   * @returns A promise that resolves to an array of ContractEntity or null.
+   */
+  async getContracts(options) {
+    this.logger.info("Getting contracts from the network");
+    let url = `${this.baseUrl}/api/v1/contracts`;
+    const params = new URLSearchParams();
+    if (options?.contractId) {
+      params.append("contract.id", options.contractId);
+    }
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.contracts || [];
+    } catch (error) {
+      this.logger.error(`Error fetching contracts: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * Retrieves a specific contract by ID or address.
+   * @param contractIdOrAddress The contract ID or EVM address.
+   * @param timestamp Optional timestamp for historical data.
+   * @returns A promise that resolves to a ContractEntity or null.
+   */
+  async getContract(contractIdOrAddress, timestamp) {
+    this.logger.info(`Getting contract ${contractIdOrAddress}`);
+    let url = `${this.baseUrl}/api/v1/contracts/${contractIdOrAddress}`;
+    if (timestamp) {
+      url += `?timestamp=${timestamp}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching contract ${contractIdOrAddress}: ${error.message}`
+      );
+      return null;
+    }
+  }
+  /**
+   * Retrieves contract results from the network.
+   * @param options Optional parameters for filtering contract results.
+   * @returns A promise that resolves to an array of ContractResult or null.
+   */
+  async getContractResults(options) {
+    this.logger.info("Getting contract results from the network");
+    let url = `${this.baseUrl}/api/v1/contracts/results`;
+    const params = new URLSearchParams();
+    if (options?.from) {
+      params.append("from", options.from);
+    }
+    if (options?.blockHash) {
+      params.append("block.hash", options.blockHash);
+    }
+    if (options?.blockNumber) {
+      params.append("block.number", options.blockNumber);
+    }
+    if (options?.internal !== void 0) {
+      params.append("internal", options.internal.toString());
+    }
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    if (options?.timestamp) {
+      params.append("timestamp", options.timestamp);
+    }
+    if (options?.transactionIndex) {
+      params.append("transaction.index", options.transactionIndex.toString());
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    try {
+      const response = await this._requestWithRetry(
+        url
+      );
+      return response.results || [];
+    } catch (error) {
+      this.logger.error(`Error fetching contract results: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * Retrieves a specific contract result by transaction ID or hash.
+   * @param transactionIdOrHash The transaction ID or hash.
+   * @param nonce Optional nonce filter.
+   * @returns A promise that resolves to a ContractResult or null.
+   */
+  async getContractResult(transactionIdOrHash, nonce) {
+    this.logger.info(`Getting contract result for ${transactionIdOrHash}`);
+    let url = `${this.baseUrl}/api/v1/contracts/results/${transactionIdOrHash}`;
+    if (nonce !== void 0) {
+      url += `?nonce=${nonce}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching contract result for ${transactionIdOrHash}: ${error.message}`
+      );
+      return null;
+    }
+  }
+  /**
+   * Retrieves contract results for a specific contract.
+   * @param contractIdOrAddress The contract ID or EVM address.
+   * @param options Optional parameters for filtering.
+   * @returns A promise that resolves to an array of ContractResult or null.
+   */
+  async getContractResultsByContract(contractIdOrAddress, options) {
+    this.logger.info(
+      `Getting contract results for contract ${contractIdOrAddress}`
+    );
+    let url = `${this.baseUrl}/api/v1/contracts/${contractIdOrAddress}/results`;
+    const params = new URLSearchParams();
+    if (options?.blockHash) {
+      params.append("block.hash", options.blockHash);
+    }
+    if (options?.blockNumber) {
+      params.append("block.number", options.blockNumber);
+    }
+    if (options?.from) {
+      params.append("from", options.from);
+    }
+    if (options?.internal !== void 0) {
+      params.append("internal", options.internal.toString());
+    }
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    if (options?.timestamp) {
+      params.append("timestamp", options.timestamp);
+    }
+    if (options?.transactionIndex) {
+      params.append("transaction.index", options.transactionIndex.toString());
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    try {
+      const response = await this._requestWithRetry(
+        url
+      );
+      return response.results || [];
+    } catch (error) {
+      this.logger.error(
+        `Error fetching contract results for ${contractIdOrAddress}: ${error.message}`
+      );
+      return null;
+    }
+  }
+  /**
+   * Retrieves contract state for a specific contract.
+   * @param contractIdOrAddress The contract ID or EVM address.
+   * @param options Optional parameters for filtering.
+   * @returns A promise that resolves to an array of ContractState or null.
+   */
+  async getContractState(contractIdOrAddress, options) {
+    this.logger.info(`Getting contract state for ${contractIdOrAddress}`);
+    let url = `${this.baseUrl}/api/v1/contracts/${contractIdOrAddress}/state`;
+    const params = new URLSearchParams();
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    if (options?.slot) {
+      params.append("slot", options.slot);
+    }
+    if (options?.timestamp) {
+      params.append("timestamp", options.timestamp);
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.state || [];
+    } catch (error) {
+      this.logger.error(
+        `Error fetching contract state for ${contractIdOrAddress}: ${error.message}`
+      );
+      return null;
+    }
+  }
+  /**
+   * Retrieves contract actions for a specific transaction.
+   * @param transactionIdOrHash The transaction ID or hash.
+   * @param options Optional parameters for filtering.
+   * @returns A promise that resolves to an array of ContractAction or null.
+   */
+  async getContractActions(transactionIdOrHash, options) {
+    this.logger.info(`Getting contract actions for ${transactionIdOrHash}`);
+    let url = `${this.baseUrl}/api/v1/contracts/results/${transactionIdOrHash}/actions`;
+    const params = new URLSearchParams();
+    if (options?.index) {
+      params.append("index", options.index);
+    }
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    try {
+      const response = await this._requestWithRetry(
+        url
+      );
+      return response.actions || [];
+    } catch (error) {
+      this.logger.error(
+        `Error fetching contract actions for ${transactionIdOrHash}: ${error.message}`
+      );
+      return null;
+    }
+  }
+  /**
+   * Retrieves contract logs from the network.
+   * @param options Optional parameters for filtering logs.
+   * @returns A promise that resolves to an array of ContractLog or null.
+   */
+  async getContractLogs(options) {
+    this.logger.info("Getting contract logs from the network");
+    let url = `${this.baseUrl}/api/v1/contracts/results/logs`;
+    const params = new URLSearchParams();
+    if (options?.index) {
+      params.append("index", options.index);
+    }
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    if (options?.timestamp) {
+      params.append("timestamp", options.timestamp);
+    }
+    if (options?.topic0) {
+      params.append("topic0", options.topic0);
+    }
+    if (options?.topic1) {
+      params.append("topic1", options.topic1);
+    }
+    if (options?.topic2) {
+      params.append("topic2", options.topic2);
+    }
+    if (options?.topic3) {
+      params.append("topic3", options.topic3);
+    }
+    if (options?.transactionHash) {
+      params.append("transaction.hash", options.transactionHash);
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.logs || [];
+    } catch (error) {
+      this.logger.error(`Error fetching contract logs: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * Retrieves contract logs for a specific contract.
+   * @param contractIdOrAddress The contract ID or EVM address.
+   * @param options Optional parameters for filtering logs.
+   * @returns A promise that resolves to an array of ContractLog or null.
+   */
+  async getContractLogsByContract(contractIdOrAddress, options) {
+    this.logger.info(
+      `Getting contract logs for contract ${contractIdOrAddress}`
+    );
+    let url = `${this.baseUrl}/api/v1/contracts/${contractIdOrAddress}/results/logs`;
+    const params = new URLSearchParams();
+    if (options?.index) {
+      params.append("index", options.index);
+    }
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    if (options?.timestamp) {
+      params.append("timestamp", options.timestamp);
+    }
+    if (options?.topic0) {
+      params.append("topic0", options.topic0);
+    }
+    if (options?.topic1) {
+      params.append("topic1", options.topic1);
+    }
+    if (options?.topic2) {
+      params.append("topic2", options.topic2);
+    }
+    if (options?.topic3) {
+      params.append("topic3", options.topic3);
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.logs || [];
+    } catch (error) {
+      this.logger.error(
+        `Error fetching contract logs for ${contractIdOrAddress}: ${error.message}`
+      );
+      return null;
+    }
+  }
+  /**
+   * Retrieves opcode traces for a specific transaction.
+   * @param transactionIdOrHash The transaction ID or hash.
+   * @param options Optional parameters for trace details.
+   * @returns A promise that resolves to an OpcodeTraceResponse or null.
+   */
+  async getOpcodeTraces(transactionIdOrHash, options) {
+    this.logger.info(`Getting opcode traces for ${transactionIdOrHash}`);
+    let url = `${this.baseUrl}/api/v1/contracts/results/${transactionIdOrHash}/opcodes`;
+    const params = new URLSearchParams();
+    if (options?.stack !== void 0) {
+      params.append("stack", options.stack.toString());
+    }
+    if (options?.memory !== void 0) {
+      params.append("memory", options.memory.toString());
+    }
+    if (options?.storage !== void 0) {
+      params.append("storage", options.storage.toString());
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching opcode traces for ${transactionIdOrHash}: ${error.message}`
+      );
+      return null;
+    }
+  }
+  /**
+   * Retrieves NFT information by token ID and serial number.
+   * @param tokenId The token ID.
+   * @param serialNumber The serial number of the NFT.
+   * @returns A promise that resolves to an NftInfo or null.
+   */
+  async getNftInfo(tokenId, serialNumber) {
+    this.logger.info(`Getting NFT info for ${tokenId}/${serialNumber}`);
+    const url = `${this.baseUrl}/api/v1/tokens/${tokenId}/nfts/${serialNumber}`;
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.nft;
+    } catch (error) {
+      this.logger.error(
+        `Error fetching NFT info for ${tokenId}/${serialNumber}: ${error.message}`
+      );
+      return null;
+    }
+  }
+  /**
+   * Retrieves NFTs for a specific token.
+   * @param tokenId The token ID.
+   * @param options Optional parameters for filtering NFTs.
+   * @returns A promise that resolves to an array of NftInfo or null.
+   */
+  async getNftsByToken(tokenId, options) {
+    this.logger.info(`Getting NFTs for token ${tokenId}`);
+    let url = `${this.baseUrl}/api/v1/tokens/${tokenId}/nfts`;
+    const params = new URLSearchParams();
+    if (options?.accountId) {
+      params.append("account.id", options.accountId);
+    }
+    if (options?.limit) {
+      params.append("limit", options.limit.toString());
+    }
+    if (options?.order) {
+      params.append("order", options.order);
+    }
+    if (options?.serialNumber) {
+      params.append("serialnumber", options.serialNumber);
+    }
+    const queryString = params.toString();
+    if (queryString) {
+      url += `?${queryString}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response.nfts || [];
+    } catch (error) {
+      this.logger.error(
+        `Error fetching NFTs for token ${tokenId}: ${error.message}`
+      );
+      return null;
+    }
+  }
+  /**
+   * Retrieves network information.
+   * @returns A promise that resolves to NetworkInfo or null.
+   */
+  async getNetworkInfo() {
+    this.logger.info("Getting network information");
+    const url = `${this.baseUrl}/api/v1/network/nodes`;
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(`Error fetching network info: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * Retrieves network fees.
+   * @param timestamp Optional timestamp for historical fees.
+   * @returns A promise that resolves to NetworkFees or null.
+   */
+  async getNetworkFees(timestamp) {
+    this.logger.info("Getting network fees");
+    let url = `${this.baseUrl}/api/v1/network/fees`;
+    if (timestamp) {
+      url += `?timestamp=${timestamp}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(`Error fetching network fees: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * Retrieves network supply information.
+   * @param timestamp Optional timestamp for historical supply data.
+   * @returns A promise that resolves to NetworkSupply or null.
+   */
+  async getNetworkSupply(timestamp) {
+    this.logger.info("Getting network supply");
+    let url = `${this.baseUrl}/api/v1/network/supply`;
+    if (timestamp) {
+      url += `?timestamp=${timestamp}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(`Error fetching network supply: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * Retrieves network stake information.
+   * @param timestamp Optional timestamp for historical stake data.
+   * @returns A promise that resolves to NetworkStake or null.
+   */
+  async getNetworkStake(timestamp) {
+    this.logger.info("Getting network stake");
+    let url = `${this.baseUrl}/api/v1/network/stake`;
+    if (timestamp) {
+      url += `?timestamp=${timestamp}`;
+    }
+    try {
+      const response = await this._requestWithRetry(url);
+      return response;
+    } catch (error) {
+      this.logger.error(`Error fetching network stake: ${error.message}`);
+      return null;
+    }
+  }
 }
 export {
   HederaMirrorNode