@hashgraphonline/standards-sdk 0.1.161 → 0.1.163

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

@@ -1,12 +1,18 @@
-import { TopicCreateTransaction, PublicKey } from "@hashgraph/sdk";
-import { HCS2BaseClient } from "./standards-sdk.es76.js";
-import { HCS2RegistryType, HCS2Operation } from "./standards-sdk.es73.js";
-import { isBrowser } from "./standards-sdk.es130.js";
-import { KeyTypeDetector } from "./standards-sdk.es125.js";
-import { buildMessageTx } from "./standards-sdk.es153.js";
-class BrowserHCS2Client extends HCS2BaseClient {
+import { AccountId, Client, PublicKey } from "@hashgraph/sdk";
+import { randomUUID } from "crypto";
+import { HCS2BaseClient } from "./standards-sdk.es77.js";
+import { HCS2Operation, HCS2RegistryType } from "./standards-sdk.es74.js";
+import { createNodeOperatorContext } from "./standards-sdk.es153.js";
+import { buildMessageTx } from "./standards-sdk.es154.js";
+import { buildHcs2CreateRegistryTx } from "./standards-sdk.es78.js";
+import { inscribe } from "./standards-sdk.es137.js";
+import { InscriptionSDK } from "./standards-sdk.es155.js";
+import { getTopicId } from "./standards-sdk.es127.js";
+const MAX_PAYLOAD_BYTES = 1024;
+const HCS1_HRL_PATTERN = /^hcs:\/\/1\/(\d+\.\d+\.\d+)$/;
+const _HCS2Client = class _HCS2Client extends HCS2BaseClient {
   /**
-   * Create a new browser HCS-2 client
+   * Create a new HCS-2 client
    * @param config Client configuration
    */
   constructor(config) {
@@ -17,25 +23,36 @@ class BrowserHCS2Client extends HCS2BaseClient {
       mirrorNodeUrl: config.mirrorNodeUrl,
       logger: config.logger
     });
-    this.hwc = config.hwc;
-    if (!isBrowser) {
-      this.logger.error(
-        "BrowserHCS2Client initialized in server environment - browser-specific features will not be available. Use HCS2Client instead."
-      );
-    } else {
-      this.logger.info("HCS-2 browser client initialized successfully");
-    }
+    this.registryTypeCache = /* @__PURE__ */ new Map();
+    this.operatorId = typeof config.operatorId === "string" ? AccountId.fromString(config.operatorId) : config.operatorId;
+    this.operatorCtx = createNodeOperatorContext({
+      network: this.network,
+      operatorId: this.operatorId,
+      operatorKey: config.operatorKey,
+      keyType: config.keyType,
+      mirrorNode: this.mirrorNode,
+      logger: this.logger,
+      client: this.createClient(config.network)
+    });
+    this.client = this.operatorCtx.client;
   }
   /**
-   * Get the operator account ID
-   * @returns The operator account ID
+   * Initialize the Hedera client with operator information
    */
-  getOperatorId() {
-    const accountInfo = this.hwc.getAccountInfo();
-    if (!accountInfo || !accountInfo.accountId) {
-      throw new Error("No connected account found");
+  async ensureInitialized() {
+    await this.operatorCtx.ensureInitialized();
+  }
+  /**
+   * Create a Hedera client for the specified network
+   * @param network The network to connect to
+   * @returns The Hedera client
+   */
+  createClient(network) {
+    if (network === "mainnet") {
+      return Client.forMainnet();
+    } else {
+      return Client.forTestnet();
     }
-    return accountInfo.accountId;
   }
   /**
    * Create a new registry topic
@@ -44,70 +61,79 @@ class BrowserHCS2Client extends HCS2BaseClient {
    */
   async createRegistry(options = {}) {
     try {
+      await this.ensureInitialized();
       const registryType = options.registryType ?? HCS2RegistryType.INDEXED;
       const ttl = options.ttl ?? 86400;
       const memo = this.generateRegistryMemo(registryType, ttl);
-      let transaction = new TopicCreateTransaction().setTopicMemo(memo);
+      let adminKeyPrivate;
+      let adminPublicKey;
       if (options.adminKey) {
-        let adminPublicKey;
         if (typeof options.adminKey === "string") {
           try {
             adminPublicKey = PublicKey.fromString(options.adminKey);
           } catch {
-            const keyInfo = KeyTypeDetector.detect(options.adminKey);
-            if (keyInfo.rawBytes) {
-              adminPublicKey = keyInfo.type === "ed25519" ? PublicKey.fromBytesED25519(keyInfo.rawBytes) : PublicKey.fromBytesECDSA(keyInfo.rawBytes);
-            } else {
-              throw new Error("Failed to parse admin public key");
-            }
+            const keyBytes = Buffer.from(
+              options.adminKey.replace(/^0x/i, ""),
+              "hex"
+            );
+            adminPublicKey = this.operatorCtx.keyType === "ed25519" ? PublicKey.fromBytesED25519(keyBytes) : PublicKey.fromBytesECDSA(keyBytes);
           }
         } else if (typeof options.adminKey === "boolean") {
-          adminPublicKey = await this.mirrorNode.getPublicKey(
-            this.getOperatorId()
-          );
+          adminPublicKey = this.operatorCtx.operatorKey.publicKey;
         } else {
           adminPublicKey = options.adminKey.publicKey;
+          adminKeyPrivate = options.adminKey;
         }
-        transaction = transaction.setAdminKey(adminPublicKey);
       }
+      let submitKeyPrivate;
+      let submitPublicKey;
       if (options.submitKey) {
-        let submitPublicKey;
         if (typeof options.submitKey === "string") {
           try {
             submitPublicKey = PublicKey.fromString(options.submitKey);
           } catch {
-            const keyInfo = KeyTypeDetector.detect(options.submitKey);
-            if (keyInfo.rawBytes) {
-              submitPublicKey = keyInfo.type === "ed25519" ? PublicKey.fromBytesED25519(keyInfo.rawBytes) : PublicKey.fromBytesECDSA(keyInfo.rawBytes);
-            } else {
-              throw new Error("Failed to parse submit public key");
-            }
+            const keyBytes = Buffer.from(
+              options.submitKey.replace(/^0x/i, ""),
+              "hex"
+            );
+            submitPublicKey = this.operatorCtx.keyType === "ed25519" ? PublicKey.fromBytesED25519(keyBytes) : PublicKey.fromBytesECDSA(keyBytes);
           }
         } else if (typeof options.submitKey === "boolean") {
-          submitPublicKey = await this.mirrorNode.getPublicKey(
-            this.getOperatorId()
-          );
+          submitPublicKey = this.operatorCtx.operatorKey.publicKey;
         } else {
           submitPublicKey = options.submitKey.publicKey;
+          submitKeyPrivate = options.submitKey;
         }
-        transaction = transaction.setSubmitKey(submitPublicKey);
       }
-      const txResponse = await this.executeWithWallet(transaction);
-      if (txResponse?.error) {
-        throw new Error(txResponse.error);
+      const transaction = buildHcs2CreateRegistryTx({
+        registryType,
+        ttl,
+        adminKey: adminPublicKey,
+        submitKey: submitPublicKey,
+        operatorPublicKey: this.operatorCtx.operatorKey.publicKey
+      });
+      const frozenTx = await transaction.freezeWith(this.client);
+      if (adminKeyPrivate) {
+        await frozenTx.sign(adminKeyPrivate);
+      }
+      if (submitKeyPrivate) {
+        await frozenTx.sign(submitKeyPrivate);
       }
-      const resultReceipt = txResponse?.result;
-      if (!resultReceipt?.topicId) {
+      const txResponse = await frozenTx.execute(this.client);
+      const receipt = await txResponse.getReceipt(this.client);
+      const topicId = receipt.topicId;
+      if (!topicId) {
         throw new Error("Failed to create registry: No topic ID in receipt");
       }
-      const topicId = resultReceipt.topicId.toString();
+      const topicIdStr = topicId.toString();
+      this.registryTypeCache.set(topicIdStr, registryType);
       this.logger.info(
-        `Created registry topic: ${topicId} (${registryType === HCS2RegistryType.INDEXED ? "Indexed" : "Non-indexed"}, TTL: ${ttl}s)`
+        `Created registry topic: ${topicIdStr} (${registryType === HCS2RegistryType.INDEXED ? "Indexed" : "Non-indexed"}, TTL: ${ttl}s)`
       );
       return {
         success: true,
-        topicId,
-        transactionId: txResponse.transactionId || "unknown"
+        topicId: topicIdStr,
+        transactionId: txResponse.transactionId.toString()
       };
     } catch (error) {
       this.logger.error(`Failed to create registry: ${error}`);
@@ -121,23 +147,28 @@ class BrowserHCS2Client extends HCS2BaseClient {
    * Register a new entry in the registry
    * @param registryTopicId The topic ID of the registry
    * @param options Registration options
+   * @param protocol Optional protocol version (defaults to 'hcs-2')
    * @returns Promise resolving to the operation result
    */
-  async registerEntry(registryTopicId, options) {
+  async registerEntry(registryTopicId, options, protocol = "hcs-2") {
     try {
+      await this.ensureInitialized();
       const message = this.createRegisterMessage(
         options.targetTopicId,
         options.metadata,
-        options.memo
+        options.memo,
+        protocol
+      );
+      const registryType = options.registryType ?? await this.resolveRegistryType(registryTopicId);
+      this.registryTypeCache.set(registryTopicId, registryType);
+      const analyticsMemo = options.analyticsMemo ?? this.buildAnalyticsMemo(HCS2Operation.REGISTER, registryType);
+      const receipt = await this.submitMessage(
+        registryTopicId,
+        message,
+        analyticsMemo
       );
-      if (message.op !== HCS2Operation.REGISTER) {
-        throw new Error(
-          `Invalid operation type: ${message.op}, expected ${HCS2Operation.REGISTER}`
-        );
-      }
-      const receipt = await this.submitMessage(registryTopicId, message);
       this.logger.info(
-        `Registered entry in registry ${registryTopicId} pointing to topic ${options.targetTopicId}`
+        `Registered entry in registry ${registryTopicId} pointing to topic ${options.targetTopicId} using protocol ${protocol}`
       );
       return {
         success: true,
@@ -160,6 +191,7 @@ class BrowserHCS2Client extends HCS2BaseClient {
    */
   async updateEntry(registryTopicId, options) {
     try {
+      await this.ensureInitialized();
       const registryInfo = await this.mirrorNode.getTopicInfo(registryTopicId);
       const memoInfo = this.parseRegistryTypeFromMemo(registryInfo.memo);
       if (!memoInfo || memoInfo.registryType !== HCS2RegistryType.INDEXED) {
@@ -173,7 +205,14 @@ class BrowserHCS2Client extends HCS2BaseClient {
         options.metadata,
         options.memo
       );
-      const receipt = await this.submitMessage(registryTopicId, message);
+      const registryType = options.registryType ?? await this.resolveRegistryType(registryTopicId);
+      this.registryTypeCache.set(registryTopicId, registryType);
+      const analyticsMemo = options.analyticsMemo ?? this.buildAnalyticsMemo(HCS2Operation.UPDATE, registryType);
+      const receipt = await this.submitMessage(
+        registryTopicId,
+        message,
+        analyticsMemo
+      );
       this.logger.info(
         `Updated entry with UID ${options.uid} in registry ${registryTopicId}`
       );
@@ -184,10 +223,7 @@ class BrowserHCS2Client extends HCS2BaseClient {
       };
     } catch (error) {
       this.logger.error(`Failed to update entry: ${error}`);
-      return {
-        success: false,
-        error: `Failed to update entry: ${error}`
-      };
+      throw error;
     }
   }
   /**
@@ -198,6 +234,7 @@ class BrowserHCS2Client extends HCS2BaseClient {
    */
   async deleteEntry(registryTopicId, options) {
     try {
+      await this.ensureInitialized();
       const registryInfo = await this.mirrorNode.getTopicInfo(registryTopicId);
       const memoInfo = this.parseRegistryTypeFromMemo(registryInfo.memo);
       if (!memoInfo || memoInfo.registryType !== HCS2RegistryType.INDEXED) {
@@ -206,7 +243,14 @@ class BrowserHCS2Client extends HCS2BaseClient {
         );
       }
       const message = this.createDeleteMessage(options.uid, options.memo);
-      const receipt = await this.submitMessage(registryTopicId, message);
+      const registryType = options.registryType ?? await this.resolveRegistryType(registryTopicId);
+      this.registryTypeCache.set(registryTopicId, registryType);
+      const analyticsMemo = options.analyticsMemo ?? this.buildAnalyticsMemo(HCS2Operation.DELETE, registryType);
+      const receipt = await this.submitMessage(
+        registryTopicId,
+        message,
+        analyticsMemo
+      );
       this.logger.info(
         `Deleted entry with UID ${options.uid} from registry ${registryTopicId}`
       );
@@ -217,10 +261,7 @@ class BrowserHCS2Client extends HCS2BaseClient {
       };
     } catch (error) {
       this.logger.error(`Failed to delete entry: ${error}`);
-      return {
-        success: false,
-        error: `Failed to delete entry: ${error}`
-      };
+      throw error;
     }
   }
   /**
@@ -231,12 +272,20 @@ class BrowserHCS2Client extends HCS2BaseClient {
    */
   async migrateRegistry(registryTopicId, options) {
     try {
+      await this.ensureInitialized();
       const message = this.createMigrateMessage(
         options.targetTopicId,
         options.metadata,
         options.memo
       );
-      const receipt = await this.submitMessage(registryTopicId, message);
+      const registryType = options.registryType ?? await this.resolveRegistryType(registryTopicId);
+      this.registryTypeCache.set(registryTopicId, registryType);
+      const analyticsMemo = options.analyticsMemo ?? this.buildAnalyticsMemo(HCS2Operation.MIGRATE, registryType);
+      const receipt = await this.submitMessage(
+        registryTopicId,
+        message,
+        analyticsMemo
+      );
       this.logger.info(
         `Migrated registry ${registryTopicId} to ${options.targetTopicId}`
       );
@@ -247,10 +296,7 @@ class BrowserHCS2Client extends HCS2BaseClient {
       };
     } catch (error) {
       this.logger.error(`Failed to migrate registry: ${error}`);
-      return {
-        success: false,
-        error: `Failed to migrate registry: ${error}`
-      };
+      throw error;
     }
   }
   /**
@@ -261,67 +307,246 @@ class BrowserHCS2Client extends HCS2BaseClient {
    */
   async getRegistry(topicId, options = {}) {
     try {
+      await this.ensureInitialized();
       const topicInfo = await this.mirrorNode.getTopicInfo(topicId);
+      this.logger.debug(
+        `Retrieved topic info for ${topicId}: ${JSON.stringify(topicInfo)}`
+      );
       const memoInfo = this.parseRegistryTypeFromMemo(topicInfo.memo);
       if (!memoInfo) {
         throw new Error(
           `Topic ${topicId} is not an HCS-2 registry (invalid memo format)`
         );
       }
-      const messagesResult = await this.mirrorNode.getTopicMessages(topicId, {
-        sequenceNumber: options.skip && options.skip > 0 ? `gt:${options.skip}` : void 0,
-        limit: options.limit ?? 100,
-        order: options.order ?? "asc"
-      });
-      const messages = options.limit ? messagesResult.slice(0, options.limit) : messagesResult;
-      return this.parseRegistryEntries(
+      this.logger.debug(
+        `Retrieving messages for topic ${topicId} with limit ${options.limit ?? 100}`
+      );
+      const rawMessagesResult = await this.mirrorNode.getTopicMessages(
         topicId,
-        messages,
-        memoInfo.registryType,
-        memoInfo.ttl
+        {
+          sequenceNumber: options.skip && options.skip > 0 ? `gt:${options.skip}` : void 0,
+          limit: options.limit ?? 100,
+          order: options.order ?? "asc"
+        }
       );
+      const rawMessages = options.limit ? rawMessagesResult.slice(0, options.limit) : rawMessagesResult;
+      this.logger.debug(
+        `Retrieved ${rawMessagesResult.length} messages, using ${rawMessages.length} after applying limit.`
+      );
+      const entries = [];
+      let latestEntry;
+      for (const msg of rawMessages) {
+        try {
+          let message;
+          message = {
+            p: msg.p || "hcs-2",
+            op: msg.op,
+            t_id: msg.t_id,
+            uid: msg.uid,
+            metadata: msg.metadata,
+            m: msg.m
+          };
+          if (options.resolveOverflow && typeof msg.metadata === "string" && HCS1_HRL_PATTERN.test(msg.metadata)) {
+            const hrlMatch = msg.metadata.match(HCS1_HRL_PATTERN);
+            if (hrlMatch) {
+              const refTopicId = hrlMatch[1];
+              try {
+                const refMessages = await this.mirrorNode.getTopicMessages(refTopicId);
+                if (refMessages.length > 0) {
+                  const resolvedMsg = refMessages[0];
+                  message = {
+                    p: resolvedMsg.p || "hcs-2",
+                    op: resolvedMsg.op,
+                    t_id: resolvedMsg.t_id,
+                    uid: resolvedMsg.uid,
+                    metadata: resolvedMsg.metadata,
+                    m: resolvedMsg.m
+                  };
+                }
+              } catch (resolveErr) {
+                this.logger.warn(
+                  `Failed to resolve overflow ${msg.metadata}: ${resolveErr}`
+                );
+              }
+            }
+          }
+          const { valid, errors } = this.validateMessage(message);
+          if (!valid) {
+            this.logger.warn(`Invalid HCS-2 message: ${errors.join(", ")}`);
+            continue;
+          }
+          const entry = {
+            topicId,
+            sequence: msg.sequence_number,
+            timestamp: msg.consensus_timestamp,
+            payer: msg.payer_account_id || msg.payer || "",
+            message,
+            consensus_timestamp: msg.consensus_timestamp,
+            registry_type: memoInfo.registryType
+          };
+          entries.push(entry);
+          if (memoInfo.registryType === HCS2RegistryType.NON_INDEXED || !latestEntry || entry.timestamp > latestEntry.timestamp) {
+            latestEntry = entry;
+          }
+        } catch (error) {
+          this.logger.warn(`Error processing message: ${error}`);
+        }
+      }
+      this.logger.debug(
+        `Processed ${entries.length} valid entries for registry ${topicId}`
+      );
+      const registry = {
+        topicId,
+        registryType: memoInfo.registryType,
+        ttl: memoInfo.ttl,
+        entries: memoInfo.registryType === HCS2RegistryType.INDEXED ? entries : latestEntry ? [latestEntry] : [],
+        latestEntry
+      };
+      return registry;
     } catch (error) {
       this.logger.error(`Failed to get registry: ${error}`);
       throw error;
     }
   }
+  buildAnalyticsMemo(operation, registryType) {
+    const opCode = _HCS2Client.operationAnalyticsCode[operation];
+    return `hcs-2:op:${opCode}:${registryType}`;
+  }
+  async resolveRegistryType(topicId) {
+    const cached = this.registryTypeCache.get(topicId);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const topicInfo = await this.mirrorNode.getTopicInfo(topicId);
+    const memoInfo = this.parseRegistryTypeFromMemo(topicInfo.memo);
+    if (!memoInfo) {
+      throw new Error(
+        `Topic ${topicId} is not an HCS-2 registry (invalid memo format)`
+      );
+    }
+    this.registryTypeCache.set(topicId, memoInfo.registryType);
+    return memoInfo.registryType;
+  }
   /**
-   * Submit a message to a topic
+   * Submit a message to a topic.
+   * If the serialized payload exceeds 1024 bytes, the full message is
+   * inscribed via HCS-1 (using the Inscriber) and a compact overflow
+   * wrapper containing the HRL reference + SHA-256 digest is submitted
+   * instead.
    * @param topicId The topic ID to submit to
    * @param payload The message payload
+   * @param analyticsMemo Optional analytics memo for the transaction
    * @returns Promise resolving to the transaction receipt
    */
-  async submitMessage(topicId, payload) {
+  async submitMessage(topicId, payload, analyticsMemo) {
     try {
+      await this.ensureInitialized();
       const { valid, errors } = this.validateMessage(payload);
       if (!valid) {
         throw new Error(`Invalid HCS-2 message: ${errors.join(", ")}`);
       }
+      let messageString = JSON.stringify(payload);
+      if (Buffer.byteLength(messageString, "utf8") > MAX_PAYLOAD_BYTES) {
+        this.logger.info(
+          `HCS-2 payload exceeds ${MAX_PAYLOAD_BYTES} bytes, inscribing via HCS-1`
+        );
+        const contentBuffer = Buffer.from(messageString, "utf8");
+        const fileName = `hcs2-overflow-${randomUUID()}.json`;
+        if (this.network !== "testnet" && this.network !== "mainnet") {
+          throw new Error(
+            `Overflow inscription is only supported on testnet and mainnet, but network is ${this.network}`
+          );
+        }
+        const authOptions = {
+          accountId: this.operatorId.toString(),
+          privateKey: this.operatorCtx.operatorKey,
+          network: this.network
+        };
+        if (!this.inscriptionSDK) {
+          this.inscriptionSDK = await InscriptionSDK.createWithAuth({
+            type: "server",
+            ...authOptions
+          });
+        }
+        const inscriptionResult = await inscribe(
+          {
+            type: "buffer",
+            buffer: contentBuffer,
+            fileName,
+            mimeType: "application/json"
+          },
+          authOptions,
+          {
+            mode: "file",
+            waitForConfirmation: true,
+            waitMaxAttempts: 30,
+            waitIntervalMs: 4e3
+          },
+          this.inscriptionSDK
+        );
+        const inscriptionTopicId = getTopicId(inscriptionResult?.inscription);
+        if (!inscriptionTopicId) {
+          throw new Error(
+            "Failed to inscribe overflow HCS-2 payload: no topic ID returned"
+          );
+        }
+        const hrl = `hcs://1/${inscriptionTopicId}`;
+        const overflowMessage = {
+          ...payload,
+          metadata: hrl
+        };
+        this.logger.info(
+          `HCS-2 payload inscribed to ${hrl}, submitting overflow wrapper`
+        );
+        messageString = JSON.stringify(overflowMessage);
+      }
       const transaction = buildMessageTx({
         topicId,
-        message: JSON.stringify(payload)
+        message: messageString,
+        transactionMemo: analyticsMemo
       });
-      const txResponse = await this.executeWithWallet(transaction);
-      if (txResponse?.error) {
-        throw new Error(txResponse.error);
-      }
-      return txResponse.result;
+      const txResponse = await transaction.execute(this.client);
+      const receipt = await txResponse.getReceipt(this.client);
+      return receipt;
     } catch (error) {
       this.logger.error(`Failed to submit message: ${error}`);
       throw error;
     }
   }
-  async executeWithWallet(transaction) {
-    const maybeExec = this.hwc.executeTransactionWithErrorHandling;
-    if (!maybeExec) {
-      throw new Error(
-        "Wallet SDK does not support executeTransactionWithErrorHandling"
-      );
-    }
-    return await maybeExec.call(this.hwc, transaction, false);
+  /**
+   * @param topicId The topic ID to query
+   * @returns Promise resolving to the topic information
+   */
+  async getTopicInfo(topicId) {
+    return this.mirrorNode.getTopicInfo(topicId);
+  }
+  /**
+   * Close the client and release resources
+   */
+  close() {
+    this.logger.info("HCS-2 client closed.");
+  }
+  /**
+   * Get the configured key type (ed25519 or ecdsa)
+   */
+  getKeyType() {
+    return this.operatorCtx.keyType;
   }
-}
+  /**
+   * Get the configured operator private key
+   */
+  getOperatorKey() {
+    return this.operatorCtx.operatorKey;
+  }
+};
+_HCS2Client.operationAnalyticsCode = {
+  [HCS2Operation.REGISTER]: 0,
+  [HCS2Operation.UPDATE]: 1,
+  [HCS2Operation.DELETE]: 2,
+  [HCS2Operation.MIGRATE]: 3
+};
+let HCS2Client = _HCS2Client;
 export {
-  BrowserHCS2Client
+  HCS2Client
 };
 //# sourceMappingURL=standards-sdk.es75.js.map