@hashgraphonline/standards-sdk 0.1.158 → 0.1.160

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

@@ -1,146 +1,461 @@
-class HCS20Error extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "HCS20Error";
-  }
-}
-class PointsDeploymentError extends HCS20Error {
-  constructor(message, tick) {
-    super(message);
-    this.tick = tick;
-    this.name = "PointsDeploymentError";
-  }
-}
-class PointsMintError extends HCS20Error {
-  constructor(message, tick, requestedAmount, availableSupply) {
-    super(message);
-    this.tick = tick;
-    this.requestedAmount = requestedAmount;
-    this.availableSupply = availableSupply;
-    this.name = "PointsMintError";
-  }
-}
-class PointsTransferError extends HCS20Error {
-  constructor(message, tick, from, to, amount, availableBalance) {
-    super(message);
-    this.tick = tick;
-    this.from = from;
-    this.to = to;
-    this.amount = amount;
-    this.availableBalance = availableBalance;
-    this.name = "PointsTransferError";
-  }
-}
-class PointsBurnError extends HCS20Error {
-  constructor(message, tick, from, amount, availableBalance) {
-    super(message);
-    this.tick = tick;
-    this.from = from;
-    this.amount = amount;
-    this.availableBalance = availableBalance;
-    this.name = "PointsBurnError";
-  }
-}
-class PointsValidationError extends HCS20Error {
-  constructor(message, validationErrors) {
-    super(message);
-    this.validationErrors = validationErrors;
-    this.name = "PointsValidationError";
-  }
-}
-class PointsNotFoundError extends HCS20Error {
-  constructor(tick) {
-    super(`Points with tick "${tick}" not found`);
-    this.tick = tick;
-    this.name = "PointsNotFoundError";
-  }
-}
-class TopicRegistrationError extends HCS20Error {
-  constructor(message, topicId) {
-    super(message);
-    this.topicId = topicId;
-    this.name = "TopicRegistrationError";
-  }
-}
-class InsufficientBalanceError extends HCS20Error {
-  constructor(accountId, tick, required, available) {
-    super(
-      `Insufficient balance for ${tick}: required ${required}, available ${available}`
-    );
-    this.accountId = accountId;
-    this.tick = tick;
-    this.required = required;
-    this.available = available;
-    this.name = "InsufficientBalanceError";
-  }
-}
-class SupplyLimitExceededError extends HCS20Error {
-  constructor(tick, requested, maxSupply, currentSupply) {
-    super(
-      `Supply limit exceeded for ${tick}: max ${maxSupply}, current ${currentSupply}, requested ${requested}`
-    );
-    this.tick = tick;
-    this.requested = requested;
-    this.maxSupply = maxSupply;
-    this.currentSupply = currentSupply;
-    this.name = "SupplyLimitExceededError";
-  }
-}
-class MintLimitExceededError extends HCS20Error {
-  constructor(tick, requested, limit) {
-    super(
-      `Mint limit exceeded for ${tick}: requested ${requested}, limit ${limit}`
-    );
-    this.tick = tick;
-    this.requested = requested;
-    this.limit = limit;
-    this.name = "MintLimitExceededError";
-  }
-}
-class InvalidMessageFormatError extends HCS20Error {
-  constructor(message, messageData) {
-    super(message);
-    this.messageData = messageData;
-    this.name = "InvalidMessageFormatError";
-  }
-}
-class InvalidAccountFormatError extends HCS20Error {
-  constructor(account) {
-    super(`Invalid Hedera account format: ${account}`);
-    this.account = account;
-    this.name = "InvalidAccountFormatError";
-  }
-}
-class InvalidTickFormatError extends HCS20Error {
-  constructor(tick) {
-    super(`Invalid tick format: ${tick}`);
-    this.tick = tick;
-    this.name = "InvalidTickFormatError";
-  }
-}
-class InvalidNumberFormatError extends HCS20Error {
-  constructor(value, field) {
-    super(`Invalid number format for ${field}: ${value}`);
-    this.value = value;
-    this.field = field;
-    this.name = "InvalidNumberFormatError";
-  }
-}
+import { AccountId, Client, PublicKey } from "@hashgraph/sdk";
+import { HCS2BaseClient } from "./standards-sdk.es75.js";
+import { HCS2Operation, HCS2RegistryType } from "./standards-sdk.es72.js";
+import { createNodeOperatorContext } from "./standards-sdk.es151.js";
+import { buildMessageTx } from "./standards-sdk.es152.js";
+import { buildHcs2CreateRegistryTx } from "./standards-sdk.es76.js";
+const _HCS2Client = class _HCS2Client extends HCS2BaseClient {
+  /**
+   * Create a new HCS-2 client
+   * @param config Client configuration
+   */
+  constructor(config) {
+    super({
+      network: config.network,
+      logLevel: config.logLevel,
+      silent: config.silent,
+      mirrorNodeUrl: config.mirrorNodeUrl,
+      logger: config.logger
+    });
+    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;
+  }
+  /**
+   * Initialize the Hedera client with operator information
+   */
+  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();
+    }
+  }
+  /**
+   * Create a new registry topic
+   * @param options Registry creation options
+   * @returns Promise resolving to the transaction result
+   */
+  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 adminKeyPrivate;
+      let adminPublicKey;
+      if (options.adminKey) {
+        if (typeof options.adminKey === "string") {
+          try {
+            adminPublicKey = PublicKey.fromString(options.adminKey);
+          } catch {
+            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 = this.operatorCtx.operatorKey.publicKey;
+        } else {
+          adminPublicKey = options.adminKey.publicKey;
+          adminKeyPrivate = options.adminKey;
+        }
+      }
+      let submitKeyPrivate;
+      let submitPublicKey;
+      if (options.submitKey) {
+        if (typeof options.submitKey === "string") {
+          try {
+            submitPublicKey = PublicKey.fromString(options.submitKey);
+          } catch {
+            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 = this.operatorCtx.operatorKey.publicKey;
+        } else {
+          submitPublicKey = options.submitKey.publicKey;
+          submitKeyPrivate = options.submitKey;
+        }
+      }
+      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 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 topicIdStr = topicId.toString();
+      this.registryTypeCache.set(topicIdStr, registryType);
+      this.logger.info(
+        `Created registry topic: ${topicIdStr} (${registryType === HCS2RegistryType.INDEXED ? "Indexed" : "Non-indexed"}, TTL: ${ttl}s)`
+      );
+      return {
+        success: true,
+        topicId: topicIdStr,
+        transactionId: txResponse.transactionId.toString()
+      };
+    } catch (error) {
+      this.logger.error(`Failed to create registry: ${error}`);
+      return {
+        success: false,
+        error: `Failed to create registry: ${error}`
+      };
+    }
+  }
+  /**
+   * 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, protocol = "hcs-2") {
+    try {
+      await this.ensureInitialized();
+      const message = this.createRegisterMessage(
+        options.targetTopicId,
+        options.metadata,
+        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
+      );
+      this.logger.info(
+        `Registered entry in registry ${registryTopicId} pointing to topic ${options.targetTopicId} using protocol ${protocol}`
+      );
+      return {
+        success: true,
+        receipt,
+        sequenceNumber: receipt.topicSequenceNumber?.low ?? void 0
+      };
+    } catch (error) {
+      this.logger.error(`Failed to register entry: ${error}`);
+      return {
+        success: false,
+        error: `Failed to register entry: ${error}`
+      };
+    }
+  }
+  /**
+   * Update an existing entry in the registry (indexed registries only)
+   * @param registryTopicId The topic ID of the registry
+   * @param options Update options
+   * @returns Promise resolving to the operation result
+   */
+  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) {
+        throw new Error(
+          "Update operation is only valid for indexed registries"
+        );
+      }
+      const message = this.createUpdateMessage(
+        options.targetTopicId,
+        options.uid,
+        options.metadata,
+        options.memo
+      );
+      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}`
+      );
+      return {
+        success: true,
+        receipt,
+        sequenceNumber: receipt.topicSequenceNumber?.low ?? void 0
+      };
+    } catch (error) {
+      this.logger.error(`Failed to update entry: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Delete an entry from the registry (indexed registries only)
+   * @param registryTopicId The topic ID of the registry
+   * @param options Delete options
+   * @returns Promise resolving to the operation result
+   */
+  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) {
+        throw new Error(
+          "Delete operation is only valid for indexed registries"
+        );
+      }
+      const message = this.createDeleteMessage(options.uid, options.memo);
+      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}`
+      );
+      return {
+        success: true,
+        receipt,
+        sequenceNumber: receipt.topicSequenceNumber?.low ?? void 0
+      };
+    } catch (error) {
+      this.logger.error(`Failed to delete entry: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Migrate a registry to a new topic
+   * @param registryTopicId The topic ID of the registry
+   * @param options Migration options
+   * @returns Promise resolving to the operation result
+   */
+  async migrateRegistry(registryTopicId, options) {
+    try {
+      await this.ensureInitialized();
+      const message = this.createMigrateMessage(
+        options.targetTopicId,
+        options.metadata,
+        options.memo
+      );
+      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}`
+      );
+      return {
+        success: true,
+        receipt,
+        sequenceNumber: receipt.topicSequenceNumber?.low ?? void 0
+      };
+    } catch (error) {
+      this.logger.error(`Failed to migrate registry: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Get all entries from a registry
+   * @param topicId The topic ID of the registry
+   * @param options Query options
+   * @returns Promise resolving to the registry information
+   */
+  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)`
+        );
+      }
+      this.logger.debug(
+        `Retrieving messages for topic ${topicId} with limit ${options.limit ?? 100}`
+      );
+      const rawMessagesResult = 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 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 {
+          const message = {
+            p: "hcs-2",
+            op: msg.op,
+            t_id: msg.t_id,
+            uid: msg.uid,
+            metadata: msg.metadata,
+            m: msg.m
+          };
+          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
+   * @param topicId The topic ID to submit to
+   * @param payload The message payload
+   * @returns Promise resolving to the transaction receipt
+   */
+  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(", ")}`);
+      }
+      const transaction = buildMessageTx({
+        topicId,
+        message: JSON.stringify(payload),
+        transactionMemo: analyticsMemo
+      });
+      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;
+    }
+  }
+  /**
+   * @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 {
-  HCS20Error,
-  InsufficientBalanceError,
-  InvalidAccountFormatError,
-  InvalidMessageFormatError,
-  InvalidNumberFormatError,
-  InvalidTickFormatError,
-  MintLimitExceededError,
-  PointsBurnError,
-  PointsDeploymentError,
-  PointsMintError,
-  PointsNotFoundError,
-  PointsTransferError,
-  PointsValidationError,
-  SupplyLimitExceededError,
-  TopicRegistrationError
+  HCS2Client
 };
 //# sourceMappingURL=standards-sdk.es73.js.map