@hashgraphonline/standards-sdk 0.0.96 → 0.0.98

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

@@ -1,411 +1,340 @@
 import Buffer from "./standards-sdk.es24.js";
-import { I as InscriptionSDK } from "./standards-sdk.es25.js";
-import { Logger } from "./standards-sdk.es15.js";
-import { ProgressReporter } from "./standards-sdk.es17.js";
-async function inscribe(input, clientConfig, options, existingSDK) {
-  const logger = Logger.getInstance({
-    module: "Inscriber",
-    ...options.logging
-  });
-  logger.info("Starting inscription process", {
-    type: input.type,
-    mode: options.mode || "file",
-    ...input.type === "url" ? { url: input.url } : {},
-    ...input.type === "file" ? { path: input.path } : {},
-    ...input.type === "buffer" ? { fileName: input.fileName, bufferSize: input.buffer.byteLength } : {}
-  });
-  try {
-    if (options.mode === "hashinal" && options.metadata) {
-      validateHashinalMetadata(options.metadata, logger);
+import { PublicKey, Timestamp } from "@hashgraph/sdk";
+import "./standards-sdk.es29.js";
+import { proto } from "@hashgraph/proto";
+import axios from "./standards-sdk.es30.js";
+class HederaMirrorNode {
+  constructor(network, logger) {
+    this.network = network;
+    this.baseUrl = this.getMirrorNodeUrl();
+    this.logger = logger;
+    this.isServerEnvironment = typeof window === "undefined";
+  }
+  getMirrorNodeUrl() {
+    return this.network === "mainnet" ? "https://mainnet-public.mirrornode.hedera.com" : "https://testnet.mirrornode.hedera.com";
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Retrieves the public key for a given account ID from the mirror node.
+   * @param accountId The ID of the account to retrieve the public key for.
+   * @returns A promise that resolves to the public key for the given account.
+   * @throws An error if the account ID is invalid or the public key cannot be retrieved.
+   */
+  async getPublicKey(accountId) {
+    this.logger.info(`Getting public key for account ${accountId}`);
+    const accountInfo = await this.requestAccount(accountId);
+    try {
+      if (!accountInfo || !accountInfo.key) {
+        throw new Error(
+          `Failed to retrieve public key for account ID: ${accountId}`
+        );
+      }
+      return PublicKey.fromString(accountInfo.key.key);
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error fetching public key from Mirror Node: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
     }
-    let sdk;
-    if (existingSDK) {
-      logger.debug("Using existing InscriptionSDK instance");
-      sdk = existingSDK;
-    } else if (options.apiKey) {
-      logger.debug("Initializing InscriptionSDK with API key");
-      sdk = new InscriptionSDK({
-        apiKey: options.apiKey,
-        network: clientConfig.network || "mainnet"
-      });
-    } else {
-      logger.debug("Initializing InscriptionSDK with server auth");
-      sdk = await InscriptionSDK.createWithAuth({
-        type: "server",
-        accountId: clientConfig.accountId,
-        privateKey: clientConfig.privateKey,
-        network: clientConfig.network || "mainnet"
-      });
+  }
+  /**
+   * Retrieves the memo for a given account ID from the mirror node.
+   * @param accountId The ID of the account to retrieve the memo for.
+   * @returns A promise that resolves to the memo for the given account.
+   * @throws An error if the account ID is invalid or the memo cannot be retrieved.
+   */
+  async getAccountMemo(accountId) {
+    const maxRetries = 3;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const accountInfoUrl = `${this.baseUrl}/api/v1/accounts/${accountId}`;
+        const response = await axios.get(accountInfoUrl);
+        const accountInfo = response.data;
+        if (accountInfo && accountInfo.memo) {
+          return accountInfo.memo;
+        }
+        this.logger.error(`No memo found for account ${accountId}`);
+        if (attempt < maxRetries - 1) {
+          await new Promise((resolve) => setTimeout(resolve, 2e3));
+        }
+      } catch (e) {
+        const error = e;
+        const logMessage = `Error getting account memo (attempt ${attempt + 1}): ${error.message}`;
+        this.logger.error(logMessage);
+        if (attempt < maxRetries - 1) {
+          await new Promise((resolve) => setTimeout(resolve, 2e3));
+        }
+      }
     }
-    const baseRequest = {
-      holderId: clientConfig.accountId,
-      metadata: options.metadata || {},
-      tags: options.tags || [],
-      mode: options.mode || "file",
-      chunkSize: options.chunkSize
-    };
-    let request;
-    switch (input.type) {
-      case "url":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "url",
-            url: input.url
-          }
-        };
-        break;
-      case "file":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "path",
-            path: input.path
-          }
-        };
-        break;
-      case "buffer":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "base64",
-            base64: Buffer.from(input.buffer).toString("base64"),
-            fileName: input.fileName,
-            mimeType: input.mimeType
-          }
-        };
-        break;
+    return null;
+  }
+  /**
+   * Retrieves topic information for a given topic ID from the mirror node.
+   * @param topicId The ID of the topic to retrieve information for.
+   * @returns A promise that resolves to the topic information.
+   * @throws An error if the topic ID is invalid or the information cannot be retrieved.
+   */
+  async getTopicInfo(topicId) {
+    try {
+      const topicInfoUrl = `${this.baseUrl}/api/v1/topics/${topicId}`;
+      const response = await axios.get(topicInfoUrl);
+      return response.data;
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error retrieving topic information: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
     }
-    if (options.mode === "hashinal") {
-      request.metadataObject = options.metadata;
-      request.creator = options.metadata?.creator || clientConfig.accountId;
-      request.description = options.metadata?.description;
-      if (options.jsonFileURL) {
-        request.jsonFileURL = options.jsonFileURL;
-      }
+  }
+  /**
+   * Retrieves custom fees for a given topic ID from the mirror node.
+   * @param topicId The ID of the topic to retrieve custom fees for.
+   * @returns A promise that resolves to the custom fees for the given topic.
+   * @throws An error if the topic ID is invalid or the custom fees cannot be retrieved.
+   */
+  async getTopicFees(topicId) {
+    try {
+      const topicInfo = await this.getTopicInfo(topicId);
+      return topicInfo.custom_fees;
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error retrieving topic fees: ${error.message}`;
+      this.logger.error(logMessage);
+      return null;
     }
-    logger.debug("Preparing to inscribe content", {
-      type: input.type,
-      mode: options.mode || "file",
-      holderId: clientConfig.accountId
-    });
-    const result = await sdk.inscribeAndExecute(request, clientConfig);
-    logger.info("Starting to inscribe.", {
-      type: input.type,
-      mode: options.mode || "file",
-      transactionId: result.jobId
-    });
-    if (options.waitForConfirmation) {
-      logger.debug("Waiting for inscription confirmation", {
-        transactionId: result.jobId,
-        maxAttempts: options.waitMaxAttempts,
-        intervalMs: options.waitIntervalMs
-      });
-      const inscription = await waitForInscriptionConfirmation(
-        sdk,
-        result.jobId,
-        options.waitMaxAttempts,
-        options.waitIntervalMs,
-        options.progressCallback
+  }
+  /**
+   * Retrieves the current HBAR price from the mirror node.
+   * @param date The date to retrieve the HBAR price for.
+   * @returns A promise that resolves to the HBAR price for the given date.
+   * @throws An error if the date is invalid or the price cannot be retrieved.
+   */
+  async getHBARPrice(date) {
+    try {
+      const timestamp = Timestamp.fromDate(date).toString();
+      const request = await fetch(
+        `https://mainnet-public.mirrornode.hedera.com/api/v1/network/exchangerate?timestamp=${timestamp}`
       );
-      logger.info("Inscription confirmation received", {
-        transactionId: result.jobId
-      });
-      return {
-        confirmed: true,
-        result,
-        inscription,
-        sdk
-      };
+      const response = await request.json();
+      const usdPrice = Number(response?.current_rate?.cent_equivalent) / Number(response?.current_rate?.hbar_equivalent) / 100;
+      return usdPrice;
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error retrieving HBAR price: ${error.message}`;
+      this.logger.error(logMessage);
+      return null;
     }
-    return {
-      confirmed: false,
-      result,
-      sdk
-    };
-  } catch (error) {
-    logger.error("Error during inscription process", error);
-    throw error;
   }
-}
-async function inscribeWithSigner(input, signer, options, existingSDK) {
-  const logger = Logger.getInstance({
-    module: "Inscriber",
-    ...options.logging
-  });
-  logger.info("Starting inscription process with signer", {
-    type: input.type,
-    mode: options.mode || "file",
-    ...input.type === "url" ? { url: input.url } : {},
-    ...input.type === "file" ? { path: input.path } : {},
-    ...input.type === "buffer" ? { fileName: input.fileName, bufferSize: input.buffer.byteLength } : {}
-  });
-  try {
-    if (options.mode === "hashinal" && options.metadata) {
-      validateHashinalMetadata(options.metadata, logger);
-    }
-    const accountId = signer.getAccountId().toString();
-    logger.debug("Using account ID from signer", { accountId });
-    let sdk;
-    if (existingSDK) {
-      logger.debug("Using existing InscriptionSDK instance");
-      sdk = existingSDK;
-    } else if (options.apiKey) {
-      logger.debug("Initializing InscriptionSDK with API key");
-      sdk = new InscriptionSDK({
-        apiKey: options.apiKey,
-        network: options.network || "mainnet"
-      });
-    } else {
-      logger.debug("Initializing InscriptionSDK with client auth");
-      sdk = await InscriptionSDK.createWithAuth({
-        type: "client",
-        accountId,
-        signer,
-        network: options.network || "mainnet"
-      });
+  /**
+   * Retrieves token information for a given token ID from the mirror node.
+   * @param tokenId The ID of the token to retrieve information for.
+   * @returns A promise that resolves to the token information.
+   * @throws An error if the token ID is invalid or the information cannot be retrieved.
+   */
+  async getTokenInfo(tokenId) {
+    this.logger.debug(`Fetching token info for ${tokenId}`);
+    try {
+      const tokenInfoUrl = `${this.baseUrl}/api/v1/tokens/${tokenId}`;
+      const response = await axios.get(tokenInfoUrl);
+      if (response.data) {
+        this.logger.trace(`Token info found for ${tokenId}:`, response.data);
+        return response.data;
+      }
+      this.logger.warn(`No token info found for ${tokenId}`);
+      return null;
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error fetching token info for ${tokenId}: ${error.message}`;
+      this.logger.error(logMessage);
+      return null;
     }
-    const baseRequest = {
-      holderId: accountId,
-      metadata: options.metadata || {},
-      tags: options.tags || [],
-      mode: options.mode || "file",
-      chunkSize: options.chunkSize
-    };
-    let request;
-    switch (input.type) {
-      case "url":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "url",
-            url: input.url
-          }
-        };
-        break;
-      case "file":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "path",
-            path: input.path
-          }
-        };
-        break;
-      case "buffer":
-        request = {
-          ...baseRequest,
-          file: {
-            type: "base64",
-            base64: Buffer.from(input.buffer).toString("base64"),
-            fileName: input.fileName,
-            mimeType: input.mimeType
+  }
+  /**
+   * Retrieves messages for a given topic ID from the mirror node.
+   * @param topicId The ID of the topic to retrieve messages for.
+   * @returns A promise that resolves to the messages for the given topic.
+   * @throws An error if the topic ID is invalid or the messages cannot be retrieved.
+   */
+  async getTopicMessages(topicId) {
+    this.logger.trace(`Querying messages for topic ${topicId}`);
+    let nextUrl = `${this.baseUrl}/api/v1/topics/${topicId}/messages`;
+    const messages = [];
+    while (nextUrl) {
+      try {
+        const response = await axios.get(nextUrl);
+        const data = response.data;
+        if (data.messages && data.messages.length > 0) {
+          for (const message of data.messages) {
+            try {
+              if (!message.message) {
+                continue;
+              }
+              let messageContent;
+              try {
+                if (this.isServerEnvironment) {
+                  messageContent = Buffer.from(
+                    message.message,
+                    "base64"
+                  ).toString("utf-8");
+                } else {
+                  messageContent = new TextDecoder().decode(
+                    Uint8Array.from(
+                      atob(message.message),
+                      (c) => c.charCodeAt(0)
+                    )
+                  );
+                }
+              } catch (error) {
+                const logMessage = `Error decoding message: ${error}`;
+                this.logger.error(logMessage);
+                continue;
+              }
+              let messageJson;
+              try {
+                messageJson = JSON.parse(messageContent);
+              } catch (error) {
+                const logMessage = `Invalid JSON message content: ${messageContent}`;
+                this.logger.error(logMessage);
+                return;
+              }
+              messageJson.sequence_number = message.sequence_number;
+              messages.push({
+                ...messageJson,
+                consensus_timestamp: message.consensus_timestamp,
+                sequence_number: message.sequence_number,
+                created: new Date(Number(message.consensus_timestamp) * 1e3)
+              });
+            } catch (error) {
+              const logMessage = `Error processing message: ${error.message}`;
+              this.logger.error(logMessage);
+            }
           }
-        };
-        break;
+        }
+        nextUrl = data.links?.next ? `${this.baseUrl}${data.links.next}` : "";
+      } catch (e) {
+        const error = e;
+        const logMessage = `Error querying topic messages: ${error.message} on ${topicId}`;
+        this.logger.error(logMessage);
+        throw new Error(logMessage);
+      }
     }
-    if (options.mode === "hashinal") {
-      request.metadataObject = options.metadata;
-      request.creator = options.metadata?.creator || accountId;
-      request.description = options.metadata?.description;
-      if (options.jsonFileURL) {
-        request.jsonFileURL = options.jsonFileURL;
+    return messages;
+  }
+  /**
+   * Requests account information for a given account ID from the mirror node.
+   * @param accountId The ID of the account to retrieve information for.
+   * @returns A promise that resolves to the account information.
+   * @throws An error if the account ID is invalid or the information cannot be retrieved.
+   */
+  async requestAccount(accountId) {
+    try {
+      const accountInfoUrl = `${this.baseUrl}/api/v1/accounts/${accountId}`;
+      const response = await axios.get(accountInfoUrl);
+      if (!response.data) {
+        throw new Error(
+          `Failed to make request to mirror node for account: ${accountId}`
+        );
       }
+      return response.data;
+    } catch (e) {
+      const error = e;
+      const logMessage = `Failed to fetch account: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
     }
-    logger.debug("Preparing to inscribe content with signer", {
-      type: input.type,
-      mode: options.mode || "file",
-      holderId: accountId
-    });
-    const result = await sdk.inscribe(
-      {
-        ...request,
-        holderId: accountId
-      },
-      signer
-    );
-    logger.info("Inscription started", {
-      type: input.type,
-      mode: options.mode || "file",
-      transactionId: result.jobId
-    });
-    if (options.waitForConfirmation) {
-      logger.debug("Waiting for inscription confirmation", {
-        transactionId: result.jobId,
-        maxAttempts: options.waitMaxAttempts,
-        intervalMs: options.waitIntervalMs
-      });
-      const inscription = await waitForInscriptionConfirmation(
-        sdk,
-        result.jobId,
-        options.waitMaxAttempts,
-        options.waitIntervalMs,
-        options.progressCallback
-      );
-      logger.info("Inscription confirmation received", {
-        transactionId: result.jobId
-      });
-      return {
-        confirmed: true,
-        result,
-        inscription,
-        sdk
-      };
+  }
+  /**
+   * Checks if a user has access to a given key list.
+   * @param keyBytes The key list to check access for.
+   * @param userPublicKey The public key of the user to check access for.
+   * @returns A promise that resolves to true if the user has access, false otherwise.
+   */
+  async checkKeyListAccess(keyBytes, userPublicKey) {
+    try {
+      const key = proto.Key.decode(keyBytes);
+      return this.evaluateKeyAccess(key, userPublicKey);
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error decoding protobuf key: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
     }
-    return {
-      confirmed: false,
-      result,
-      sdk
-    };
-  } catch (error) {
-    logger.error("Error during inscription process", error);
-    throw error;
   }
-}
-async function retrieveInscription(transactionId, options) {
-  const logger = Logger.getInstance({
-    module: "Inscriber",
-    ...options?.logging || {}
-  });
-  const formattedTransactionId = transactionId.includes("@") ? `${transactionId.split("@")[0]}-${transactionId.split("@")[1].replace(/\./g, "-")}` : transactionId;
-  logger.info("Retrieving inscription", {
-    originalTransactionId: transactionId,
-    formattedTransactionId
-  });
-  try {
-    let sdk;
-    if (options?.apiKey) {
-      logger.debug("Initializing InscriptionSDK with API key");
-      sdk = new InscriptionSDK({
-        apiKey: options.apiKey,
-        network: options.network || "mainnet"
-      });
-    } else if (options?.accountId && options?.privateKey) {
-      logger.debug("Initializing InscriptionSDK with server auth");
-      sdk = await InscriptionSDK.createWithAuth({
-        type: "server",
-        accountId: options.accountId,
-        privateKey: options.privateKey,
-        network: options.network || "mainnet"
-      });
-    } else {
-      const error = new Error(
-        "Either API key or account ID and private key are required for retrieving inscriptions"
-      );
-      logger.error("Missing authentication credentials", {
-        hasApiKey: Boolean(options?.apiKey),
-        hasAccountId: Boolean(options?.accountId),
-        hasPrivateKey: Boolean(options?.privateKey)
-      });
-      throw error;
+  /**
+   * Evaluates the access of a given key to a user's public key.
+   * @param key The key to evaluate access for.
+   * @param userPublicKey The public key of the user to evaluate access for.
+   * @returns A promise that resolves to true if the key has access, false otherwise.
+   */
+  async evaluateKeyAccess(key, userPublicKey) {
+    if (key.ed25519) {
+      return this.compareEd25519Key(key.ed25519, userPublicKey);
     }
-    logger.debug("Initialized SDK for inscription retrieval", {
-      formattedTransactionId,
-      network: options.network || "mainnet"
-    });
-    const result = await sdk.retrieveInscription(formattedTransactionId);
-    logger.info("Successfully retrieved inscription", {
-      formattedTransactionId
-    });
-    return result;
-  } catch (error) {
-    logger.error("Error retrieving inscription", {
-      formattedTransactionId,
-      error
-    });
-    throw error;
+    if (key.keyList) {
+      return this.evaluateKeyList(key.keyList, userPublicKey);
+    }
+    if (key.thresholdKey && key.thresholdKey.keys) {
+      return this.evaluateKeyList(key.thresholdKey.keys, userPublicKey);
+    }
+    return false;
   }
-}
-function validateHashinalMetadata(metadata, logger) {
-  const requiredFields = ["name", "creator", "description", "type"];
-  const missingFields = requiredFields.filter((field) => !metadata[field]);
-  if (missingFields.length > 0) {
-    const error = new Error(
-      `Missing required Hashinal metadata fields: ${missingFields.join(", ")}`
-    );
-    logger.error("Hashinal metadata validation failed", { missingFields });
-    throw error;
+  /**
+   * Evaluates the access of a given key list to a user's public key.
+   * @param keyList The key list to evaluate access for.
+   * @param userPublicKey The public key of the user to evaluate access for.
+   * @returns A promise that resolves to true if the key list has access, false otherwise.
+   */
+  async evaluateKeyList(keyList, userPublicKey) {
+    const keys = keyList.keys || [];
+    for (const listKey of keys) {
+      if (!listKey) continue;
+      if (listKey.ed25519) {
+        if (this.compareEd25519Key(listKey.ed25519, userPublicKey)) {
+          return true;
+        }
+      } else if (listKey.keyList || listKey.thresholdKey) {
+        try {
+          const nestedKeyBytes = proto.Key.encode({
+            ...listKey.keyList ? { keyList: listKey.keyList } : {},
+            ...listKey.thresholdKey ? { thresholdKey: listKey.thresholdKey } : {}
+          }).finish();
+          const hasNestedAccess = await this.checkKeyListAccess(
+            Buffer.from(nestedKeyBytes),
+            userPublicKey
+          );
+          if (hasNestedAccess) {
+            return true;
+          }
+        } catch (e) {
+          const error = e;
+          const logMessage = `Error in nested key: ${error.message}`;
+          this.logger.debug(logMessage);
+        }
+      }
+    }
+    return false;
   }
-  logger.debug("Hashinal metadata validation passed", {
-    name: metadata.name,
-    creator: metadata.creator,
-    description: metadata.description,
-    type: metadata.type,
-    hasAttributes: !!metadata.attributes,
-    hasProperties: !!metadata.properties
-  });
-}
-async function waitForInscriptionConfirmation(sdk, transactionId, maxAttempts = 30, intervalMs = 4e3, progressCallback) {
-  const logger = Logger.getInstance({ module: "Inscriber" });
-  const progressReporter = new ProgressReporter({
-    module: "Inscriber",
-    logger,
-    callback: progressCallback
-  });
-  try {
-    logger.debug("Waiting for inscription confirmation", {
-      transactionId,
-      maxAttempts,
-      intervalMs
-    });
-    progressReporter.preparing("Preparing for inscription confirmation", 5, {
-      transactionId,
-      maxAttempts,
-      intervalMs
-    });
+  /**
+   * Compares an Ed25519 key with a user's public key.
+   * @param keyData The Ed25519 key data to compare.
+   * @param userPublicKey The public key of the user to compare with.
+   * @returns A boolean indicating whether the key matches the user's public key.
+   */
+  compareEd25519Key(keyData, userPublicKey) {
     try {
-      const waitMethod = sdk.waitForInscription.bind(sdk);
-      const wrappedCallback = (data) => {
-        const stage = data.stage || "confirming";
-        const message = data.message || "Processing inscription";
-        const percent = data.progressPercent || 50;
-        progressReporter.report({
-          stage,
-          message,
-          progressPercent: percent,
-          details: {}
-        });
-      };
-      return await waitMethod(
-        transactionId,
-        maxAttempts,
-        intervalMs,
-        true,
-        wrappedCallback
-      );
+      const decodedKey = PublicKey.fromBytes(Buffer.from(keyData));
+      return decodedKey.toString() === userPublicKey.toString();
     } catch (e) {
-      console.log(e);
-      logger.debug("Falling back to standard waitForInscription method", {
-        error: e
-      });
-      progressReporter.verifying("Verifying inscription status", 50, {
-        error: e
-      });
-      return await sdk.waitForInscription(
-        transactionId,
-        maxAttempts,
-        intervalMs,
-        true
-      );
+      const error = e;
+      const logMessage = `Error comparing Ed25519 key: ${error.message}`;
+      this.logger.debug(logMessage);
+      return false;
     }
-  } catch (error) {
-    logger.error("Error waiting for inscription confirmation", {
-      transactionId,
-      maxAttempts,
-      intervalMs,
-      error
-    });
-    progressReporter.failed("Inscription confirmation failed", {
-      transactionId,
-      error
-    });
-    throw error;
   }
 }
 export {
-  inscribe,
-  inscribeWithSigner,
-  retrieveInscription,
-  waitForInscriptionConfirmation
+  HederaMirrorNode
 };
 //# sourceMappingURL=standards-sdk.es20.js.map