@hashgraphonline/standards-sdk 0.0.57 → 0.0.58

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

@@ -1,236 +1,410 @@
 import Buffer from "./standards-sdk.es19.js";
-import { PublicKey, Timestamp } from "@hashgraph/sdk";
-import "./standards-sdk.es23.js";
-import { proto } from "@hashgraph/proto";
-import axios from "./standards-sdk.es24.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;
-  }
-  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 (error) {
-      throw new Error(
-        `Error fetching public key from Mirror Node: ${error.message}`
-      );
+import { InscriptionSDK } from "./standards-sdk.es22.js";
+import { Logger } from "./standards-sdk.es14.js";
+import { ProgressReporter } from "./standards-sdk.es16.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);
     }
-  }
-  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 (error) {
-        this.logger.error(
-          `Error getting account memo (attempt ${attempt + 1}): ${error.message}`
-        );
-        if (attempt < maxRetries - 1) {
-          await new Promise((resolve) => setTimeout(resolve, 2e3));
-        }
-      }
+    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"
+      });
     }
-    return null;
-  }
-  async getTopicInfo(topicId) {
-    try {
-      const topicInfoUrl = `${this.baseUrl}/api/v1/topics/${topicId}`;
-      const response = await axios.get(topicInfoUrl);
-      return response.data;
-    } catch (error) {
-      this.logger.error(`Error retrieving topic information: ${error.message}`);
-      throw new Error(`Failed to retrieve topic information: ${error.message}`);
+    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;
     }
-  }
-  async getTopicFees(topicId) {
-    try {
-      const topicInfo = await this.getTopicInfo(topicId);
-      return topicInfo.custom_fees;
-    } catch (error) {
-      this.logger.error(`Error retrieving topic fees: ${error.message}`);
-      return null;
+    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;
+      }
     }
-  }
-  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.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
       );
-      const response = await request.json();
-      const usdPrice = Number(response?.current_rate?.cent_equivalent) / Number(response?.current_rate?.hbar_equivalent) / 100;
-      return usdPrice;
-    } catch (e) {
-      return null;
+      logger.info("Inscription confirmation received", {
+        transactionId: result.jobId
+      });
+      return {
+        confirmed: true,
+        result,
+        inscription,
+        sdk
+      };
     }
+    return {
+      confirmed: false,
+      result,
+      sdk
+    };
+  } catch (error) {
+    logger.error("Error during inscription process", error);
+    throw error;
   }
-  async getTopicMessages(topicId) {
-    this.logger.info(`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) {
-                this.logger.error(`Error decoding message: ${error}`);
-                continue;
-              }
-              let messageJson;
-              try {
-                messageJson = JSON.parse(messageContent);
-              } catch (error) {
-                this.logger.error(
-                  `Invalid JSON message content: ${messageContent}`
-                );
-                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) {
-              this.logger.error(`Error processing message: ${error.message}`);
-            }
+}
+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"
+      });
+    }
+    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
           }
-        }
-        nextUrl = data.links?.next ? `${this.baseUrl}${data.links.next}` : "";
-      } catch (error) {
-        this.logger.error(`Error querying topic messages: ${error.message}`);
-        throw new Error(`Failed to query topic messages: ${error.message}`);
-      }
+        };
+        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 messages;
-  }
-  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}`
-        );
+    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 response.data;
-    } catch (error) {
-      this.logger.error(`Failed to fetch account: ${error.message}`);
-      throw new Error(`Failed to fetch account: ${error.message}`);
     }
-  }
-  async checkKeyListAccess(keyBytes, userPublicKey) {
-    try {
-      const key = proto.Key.decode(keyBytes);
-      return this.evaluateKeyAccess(key, userPublicKey);
-    } catch (error) {
-      this.logger.error(
-        `Error decoding protobuf key: ${error instanceof Error ? error.message : String(error)}`
+    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
       );
-      return false;
+      logger.info("Inscription confirmation received", {
+        transactionId: result.jobId
+      });
+      return {
+        confirmed: true,
+        result,
+        inscription,
+        sdk
+      };
     }
+    return {
+      confirmed: false,
+      result,
+      sdk
+    };
+  } catch (error) {
+    logger.error("Error during inscription process", error);
+    throw error;
   }
-  async evaluateKeyAccess(key, userPublicKey) {
-    if (key.ed25519) {
-      return this.compareEd25519Key(key.ed25519, userPublicKey);
-    }
-    if (key.keyList) {
-      return this.evaluateKeyList(key.keyList, userPublicKey);
-    }
-    if (key.thresholdKey && key.thresholdKey.keys) {
-      return this.evaluateKeyList(key.thresholdKey.keys, userPublicKey);
+}
+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;
     }
-    return false;
+    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;
   }
-  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 (err) {
-          this.logger.debug(
-            `Error in nested key: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
-      }
-    }
-    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;
   }
-  compareEd25519Key(keyData, userPublicKey) {
+  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
+    });
     try {
-      const decodedKey = PublicKey.fromBytes(Buffer.from(keyData));
-      return decodedKey.toString() === userPublicKey.toString();
-    } catch (err) {
-      return false;
+      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
+      );
+    } 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
+      );
     }
+  } catch (error) {
+    logger.error("Error waiting for inscription confirmation", {
+      transactionId,
+      maxAttempts,
+      intervalMs,
+      error
+    });
+    progressReporter.failed("Inscription confirmation failed", {
+      transactionId,
+      error
+    });
+    throw error;
   }
 }
 export {
-  HederaMirrorNode
+  inscribe,
+  inscribeWithSigner,
+  retrieveInscription
 };
 //# sourceMappingURL=standards-sdk.es17.js.map