@hashgraphonline/standards-sdk 0.1.161 → 0.1.162

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

@@ -1,368 +1,499 @@
-import { Logger } from "./standards-sdk.es117.js";
-import { HederaMirrorNode } from "./standards-sdk.es138.js";
-import "path";
-import "buffer";
-import "crypto";
-import "@noble/curves/secp256k1.js";
-import "./standards-sdk.es139.js";
-import "./standards-sdk.es141.js";
-import "zod";
-import { HCS20_CONSTANTS, HCS20MessageSchema } from "./standards-sdk.es78.js";
-class HCS20PointsIndexer {
-  constructor(network, logger, mirrorNodeUrl) {
-    this.isProcessing = false;
-    this.lastIndexedSequence = /* @__PURE__ */ new Map();
-    this.logger = logger || new Logger({
-      level: "info",
-      module: "HCS20PointsIndexer"
+import { AccountId, Client, Status, TopicCreateTransaction } from "@hashgraph/sdk";
+import { HCS20BaseClient } from "./standards-sdk.es81.js";
+import { PointsDeploymentError, PointsValidationError, PointsTransferError, PointsBurnError } from "./standards-sdk.es80.js";
+import { sleep } from "./standards-sdk.es128.js";
+import { createNodeOperatorContext } from "./standards-sdk.es153.js";
+import { HCS2Client } from "./standards-sdk.es75.js";
+import { buildHcs20DeployTx, buildHcs20MintTx, buildHcs20TransferTx, buildHcs20BurnTx, buildHcs20RegisterTx } from "./standards-sdk.es85.js";
+class HCS20Client extends HCS20BaseClient {
+  constructor(config) {
+    super(config);
+    this.operatorAccountId = typeof config.operatorId === "string" ? AccountId.fromString(config.operatorId) : config.operatorId;
+    this.operatorId = this.operatorAccountId.toString();
+    const baseClient = this.network === "mainnet" ? Client.forMainnet() : Client.forTestnet();
+    this.operatorCtx = createNodeOperatorContext({
+      network: this.network,
+      operatorId: this.operatorId,
+      operatorKey: config.operatorKey,
+      keyType: config.keyType,
+      mirrorNode: this.mirrorNode,
+      logger: this.logger,
+      client: baseClient
     });
-    this.mirrorNode = new HederaMirrorNode(network, this.logger, {
-      customUrl: mirrorNodeUrl
-    });
-    this.state = this.initializeState();
+    this.client = this.operatorCtx.client;
+    void this.operatorCtx.ensureInitialized();
   }
   /**
-   * Initialize empty state
+   * Ensure operator is initialized before operations
    */
-  initializeState() {
-    return {
-      deployedPoints: /* @__PURE__ */ new Map(),
-      balances: /* @__PURE__ */ new Map(),
-      transactions: [],
-      lastProcessedSequence: 0,
-      lastProcessedTimestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
+  async ensureInitialized() {
+    await this.operatorCtx.ensureInitialized();
   }
   /**
-   * Get current state snapshot
+   * Submit a payload to a topic
    */
-  getState() {
+  async submitPayload(transaction, submitKey) {
+    let transactionResponse;
+    if (submitKey) {
+      const frozenTransaction = transaction.freezeWith(this.client);
+      const signedTransaction = await frozenTransaction.sign(submitKey);
+      transactionResponse = await signedTransaction.execute(this.client);
+    } else {
+      transactionResponse = await transaction.execute(this.client);
+    }
+    const receipt = await transactionResponse.getReceipt(this.client);
+    if (!receipt || receipt.status !== Status.Success) {
+      throw new Error("Failed to submit message to topic");
+    }
     return {
-      ...this.state,
-      deployedPoints: new Map(this.state.deployedPoints),
-      balances: new Map(this.state.balances),
-      transactions: [...this.state.transactions]
+      receipt,
+      transactionId: transactionResponse.transactionId.toString()
     };
   }
   /**
-   * Get points info for a specific tick
+   * Create a public topic for HCS-20 (for testnet)
    */
-  getPointsInfo(tick) {
-    return this.state.deployedPoints.get(this.normalizeTick(tick));
+  async createPublicTopic(memo) {
+    await this.ensureInitialized();
+    this.logger.info("Creating public HCS-20 topic...");
+    const topicCreateTx = await new TopicCreateTransaction().setTopicMemo(memo || "HCS-20 Public Topic").execute(this.client);
+    const receipt = await topicCreateTx.getReceipt(this.client);
+    if (receipt.status !== Status.Success || !receipt.topicId) {
+      throw new Error("Failed to create public topic");
+    }
+    const topicId = receipt.topicId.toString();
+    this.logger.info(`Created public topic: ${topicId}`);
+    this.publicTopicId = topicId;
+    return topicId;
   }
   /**
-   * Get balance for an account and tick
+   * Create a registry topic for HCS-20
    */
-  getBalance(tick, accountId) {
-    const normalizedTick = this.normalizeTick(tick);
-    const tickBalances = this.state.balances.get(normalizedTick);
-    if (!tickBalances) return "0";
-    const balance = tickBalances.get(accountId);
-    return balance?.balance || "0";
+  async createRegistryTopic() {
+    await this.ensureInitialized();
+    this.logger.info("Creating HCS-20 registry topic...");
+    const hcs2Client = new HCS2Client({
+      operatorId: this.operatorId,
+      operatorKey: this.operatorCtx.operatorKey,
+      network: this.network
+    });
+    const topicCreateResponse = await hcs2Client.createRegistry({
+      submitKey: this.operatorCtx.operatorKey,
+      adminKey: this.operatorCtx.operatorKey
+    });
+    if (!topicCreateResponse.success) {
+      throw new Error("Failed to create registry topic");
+    }
+    const topicId = topicCreateResponse.topicId;
+    this.logger.info(`Created registry topic: ${topicId}`);
+    this.registryTopicId = topicId;
+    return topicId;
   }
   /**
-   * Start indexing process
+   * Deploy new points
    */
-  async startIndexing(options) {
-    if (this.isProcessing) {
-      this.logger.warn("Indexing already in progress");
-      return;
-    }
-    this.isProcessing = true;
-    const includePublicTopic = options?.includePublicTopic !== false;
-    const includeRegistryTopic = options?.includeRegistryTopic !== false;
-    const publicTopicId = includePublicTopic ? options?.publicTopicId || HCS20_CONSTANTS.PUBLIC_TOPIC_ID : null;
-    const registryTopicId = includeRegistryTopic ? options?.registryTopicId || HCS20_CONSTANTS.REGISTRY_TOPIC_ID : null;
-    const pollInterval = options?.pollInterval || 3e4;
-    await this.indexTopics(
-      publicTopicId,
-      registryTopicId,
-      options?.privateTopics
-    );
-    const pollTopics = async () => {
-      if (!this.isProcessing) return;
-      try {
-        await this.indexTopics(
-          publicTopicId,
-          registryTopicId,
-          options?.privateTopics
-        );
-      } catch (error) {
-        this.logger.error("Polling error:", error);
+  async deployPoints(options) {
+    await this.ensureInitialized();
+    const { progressCallback } = options;
+    try {
+      progressCallback?.({
+        stage: "creating-topic",
+        percentage: 20
+      });
+      let topicId;
+      const hcs2Client = new HCS2Client({
+        operatorId: this.operatorId,
+        operatorKey: this.operatorCtx.operatorKey,
+        network: this.network
+      });
+      if (options.usePrivateTopic) {
+        const topicCreateResponse = await hcs2Client.createRegistry({
+          submitKey: this.operatorCtx.operatorKey,
+          adminKey: this.operatorCtx.operatorKey
+        });
+        if (!topicCreateResponse.success) {
+          throw new PointsDeploymentError(
+            "Failed to create topic",
+            options.tick
+          );
+        }
+        topicId = topicCreateResponse.topicId;
+        this.logger.info(`Created private topic: ${topicId}`);
+      } else {
+        topicId = this.publicTopicId;
       }
-      if (this.isProcessing) {
-        setTimeout(pollTopics, pollInterval);
+      progressCallback?.({
+        stage: "submitting-deploy",
+        percentage: 50,
+        topicId
+      });
+      const deployMessage = {
+        p: "hcs-20",
+        op: "deploy",
+        name: options.name,
+        tick: this.normalizeTick(options.tick),
+        max: options.maxSupply,
+        lim: options.limitPerMint,
+        metadata: options.metadata,
+        m: options.topicMemo
+      };
+      const validation = this.validateMessage(deployMessage);
+      if (!validation.valid) {
+        throw new PointsValidationError(
+          "Invalid deploy message",
+          validation.errors
+        );
       }
-    };
-    setTimeout(pollTopics, pollInterval);
-  }
-  /**
-   * Index topics once and wait for completion
-   */
-  async indexOnce(options) {
-    const includePublicTopic = options?.includePublicTopic !== false;
-    const includeRegistryTopic = options?.includeRegistryTopic !== false;
-    const publicTopicId = includePublicTopic ? options?.publicTopicId || HCS20_CONSTANTS.PUBLIC_TOPIC_ID : null;
-    const registryTopicId = includeRegistryTopic ? options?.registryTopicId || HCS20_CONSTANTS.REGISTRY_TOPIC_ID : null;
-    await this.indexTopics(
-      publicTopicId,
-      registryTopicId,
-      options?.privateTopics
-    );
-  }
-  /**
-   * Stop indexing process
-   */
-  stopIndexing() {
-    this.isProcessing = false;
-    this.logger.info("Indexing stopped");
-  }
-  /**
-   * Index topics and update state
-   */
-  async indexTopics(publicTopicId, registryTopicId, privateTopics) {
-    this.logger.debug("Starting indexing cycle");
-    if (publicTopicId) {
-      await this.indexTopic(publicTopicId, false);
-    }
-    const registeredTopics = registryTopicId ? await this.getRegisteredTopics(registryTopicId) : [];
-    const topicsToIndex = [...registeredTopics, ...privateTopics || []];
-    for (const topicId of topicsToIndex) {
-      await this.indexTopic(topicId, true);
+      const deployTransaction = buildHcs20DeployTx({
+        topicId,
+        name: options.name,
+        tick: options.tick,
+        max: options.maxSupply,
+        lim: options.limitPerMint,
+        metadata: options.metadata,
+        memo: options.topicMemo
+      });
+      const { transactionId: deployTxId } = await this.submitPayload(deployTransaction);
+      progressCallback?.({
+        stage: "confirming",
+        percentage: 80,
+        topicId,
+        deployTxId
+      });
+      await this.waitForMirrorNodeConfirmation(topicId, deployTxId);
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        topicId,
+        deployTxId
+      });
+      const pointsInfo = {
+        name: options.name,
+        tick: this.normalizeTick(options.tick),
+        maxSupply: options.maxSupply,
+        limitPerMint: options.limitPerMint,
+        metadata: options.metadata,
+        topicId,
+        deployerAccountId: this.operatorId,
+        currentSupply: "0",
+        deploymentTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        isPrivate: options.usePrivateTopic || false
+      };
+      return pointsInfo;
+    } catch (error) {
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
     }
-    this.logger.debug("Indexing cycle complete");
   }
   /**
-   * Get registered topics from registry
+   * Mint points
    */
-  async getRegisteredTopics(registryTopicId) {
-    const topics = [];
+  async mintPoints(options) {
+    await this.ensureInitialized();
+    const { progressCallback } = options;
     try {
-      const messages = await this.mirrorNode.getTopicMessages(registryTopicId, {
-        limit: 100,
-        order: "asc"
+      progressCallback?.({
+        stage: "validating",
+        percentage: 20
+      });
+      const normalizedTick = this.normalizeTick(options.tick);
+      progressCallback?.({
+        stage: "submitting",
+        percentage: 50
       });
-      messages.filter(
-        (message) => message.p === "hcs-20" && message.op === "register" && typeof message.t_id === "string"
-      ).forEach((message) => {
-        topics.push(message.t_id);
+      const topicId = options.topicId ? this.topicToString(options.topicId) : this.publicTopicId;
+      const mintTransaction = buildHcs20MintTx({
+        topicId,
+        tick: options.tick,
+        amt: options.amount,
+        to: this.accountToString(options.to),
+        memo: options.memo
       });
+      const { transactionId: mintTxId } = await this.submitPayload(mintTransaction);
+      progressCallback?.({
+        stage: "confirming",
+        percentage: 80,
+        mintTxId
+      });
+      if (!options.disableMirrorCheck) {
+        await this.waitForMirrorNodeConfirmation(topicId, mintTxId);
+      }
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        mintTxId
+      });
+      const transaction = {
+        id: mintTxId,
+        operation: "mint",
+        tick: normalizedTick,
+        amount: options.amount,
+        to: this.accountToString(options.to),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sequenceNumber: 0,
+        topicId,
+        transactionId: mintTxId,
+        memo: options.memo
+      };
+      return transaction;
     } catch (error) {
-      this.logger.error("Failed to fetch registry messages:", error);
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
     }
-    return topics;
   }
   /**
-   * Index a single topic
+   * Transfer points
    */
-  async indexTopic(topicId, isPrivate) {
+  async transferPoints(options) {
+    await this.ensureInitialized();
+    const { progressCallback } = options;
     try {
-      const lastSequence = this.lastIndexedSequence.get(topicId);
-      this.logger.debug(
-        `Indexing topic ${topicId}, starting from sequence ${lastSequence || 0}`
-      );
-      const messages = await this.mirrorNode.getTopicMessages(topicId, {
-        sequenceNumber: lastSequence ? lastSequence + 1 : void 0,
-        limit: 1e3,
-        order: "asc"
+      progressCallback?.({
+        stage: "validating-balance",
+        percentage: 20
       });
-      this.logger.debug(
-        `Fetched ${messages.length} messages from topic ${topicId}`
-      );
-      let maxSequence = lastSequence || 0;
-      for (const message of messages) {
-        if (message.p !== "hcs-20") {
-          continue;
-        }
-        const parseResult = HCS20MessageSchema.safeParse(message);
-        if (!parseResult.success) {
-          this.logger.debug("Skipping message due to schema mismatch");
-          continue;
-        }
-        const parsedMsg = parseResult.data;
-        const sequenceNumber = message.sequence_number ?? 0;
-        this.logger.debug(
-          `Found HCS-20 message: op=${parsedMsg.op}, sequence=${sequenceNumber}`
+      const normalizedTick = this.normalizeTick(options.tick);
+      const fromAccount = this.accountToString(options.from);
+      const toAccount = this.accountToString(options.to);
+      if (fromAccount !== this.operatorId) {
+        throw new PointsTransferError(
+          "For public topics, transaction payer must match sender",
+          options.tick,
+          fromAccount,
+          toAccount,
+          options.amount
         );
-        if (sequenceNumber > maxSequence) {
-          maxSequence = sequenceNumber;
-        }
-        const topicMessage = {
-          consensus_timestamp: message.consensus_timestamp ?? "",
-          sequence_number: sequenceNumber,
-          payer_account_id: message.payer_account_id ?? message.payer ?? "",
-          transaction_id: message.transaction_id ?? ""
-        };
-        this.processMessage(parsedMsg, topicMessage, topicId, isPrivate);
-        this.state.lastProcessedSequence++;
-        this.state.lastProcessedTimestamp = message.consensus_timestamp || "";
-      }
-      if (maxSequence > (lastSequence || 0)) {
-        this.lastIndexedSequence.set(topicId, maxSequence);
       }
+      progressCallback?.({
+        stage: "submitting",
+        percentage: 50
+      });
+      const topicId = options.topicId ? this.topicToString(options.topicId) : this.publicTopicId;
+      const transferTransaction = buildHcs20TransferTx({
+        topicId,
+        tick: options.tick,
+        amt: options.amount,
+        from: fromAccount,
+        to: toAccount,
+        memo: options.memo
+      });
+      const { transactionId: transferTxId } = await this.submitPayload(transferTransaction);
+      progressCallback?.({
+        stage: "confirming",
+        percentage: 80,
+        transferTxId
+      });
+      await this.waitForMirrorNodeConfirmation(topicId, transferTxId);
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        transferTxId
+      });
+      const transaction = {
+        id: transferTxId,
+        operation: "transfer",
+        tick: normalizedTick,
+        amount: options.amount,
+        from: fromAccount,
+        to: toAccount,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sequenceNumber: 0,
+        topicId,
+        transactionId: transferTxId,
+        memo: options.memo
+      };
+      return transaction;
     } catch (error) {
-      this.logger.error(`Failed to index topic ${topicId}:`, error);
-    }
-  }
-  /**
-   * Process a single message
-   */
-  processMessage(msg, hcsMsg, topicId, isPrivate) {
-    switch (msg.op) {
-      case "deploy":
-        this.processDeployMessage(msg, hcsMsg, topicId, isPrivate);
-        break;
-      case "mint":
-        this.processMintMessage(msg, hcsMsg, topicId, isPrivate);
-        break;
-      case "transfer":
-        this.processTransferMessage(msg, hcsMsg, topicId, isPrivate);
-        break;
-      case "burn":
-        this.processBurnMessage(msg, hcsMsg, topicId, isPrivate);
-        break;
-    }
-  }
-  /**
-   * Process deploy message
-   */
-  processDeployMessage(msg, hcsMsg, topicId, isPrivate) {
-    const normalizedTick = this.normalizeTick(msg.tick);
-    if (this.state.deployedPoints.has(normalizedTick)) {
-      return;
-    }
-    const pointsInfo = {
-      name: msg.name,
-      tick: normalizedTick,
-      maxSupply: msg.max,
-      limitPerMint: msg.lim,
-      metadata: msg.metadata,
-      topicId,
-      deployerAccountId: hcsMsg.payer_account_id,
-      currentSupply: "0",
-      deploymentTimestamp: hcsMsg.consensus_timestamp,
-      isPrivate
-    };
-    this.state.deployedPoints.set(normalizedTick, pointsInfo);
-    this.logger.info(`Deployed points: ${normalizedTick}`);
-  }
-  /**
-   * Process mint message
-   */
-  processMintMessage(msg, hcsMsg, topicId, isPrivate) {
-    const normalizedTick = this.normalizeTick(msg.tick);
-    const pointsInfo = this.state.deployedPoints.get(normalizedTick);
-    if (!pointsInfo) return;
-    const mintAmount = BigInt(msg.amt);
-    const currentSupply = BigInt(pointsInfo.currentSupply);
-    const maxSupply = BigInt(pointsInfo.maxSupply);
-    if (currentSupply + mintAmount > maxSupply) return;
-    if (pointsInfo.limitPerMint && mintAmount > BigInt(pointsInfo.limitPerMint))
-      return;
-    pointsInfo.currentSupply = (currentSupply + mintAmount).toString();
-    let tickBalances = this.state.balances.get(normalizedTick);
-    if (!tickBalances) {
-      tickBalances = /* @__PURE__ */ new Map();
-      this.state.balances.set(normalizedTick, tickBalances);
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
     }
-    const currentBalance = tickBalances.get(msg.to);
-    const newBalance = currentBalance ? (BigInt(currentBalance.balance) + mintAmount).toString() : msg.amt;
-    tickBalances.set(msg.to, {
-      tick: normalizedTick,
-      accountId: msg.to,
-      balance: newBalance,
-      lastUpdated: hcsMsg.consensus_timestamp
-    });
-    this.state.transactions.push({
-      id: hcsMsg.transaction_id || `${topicId}-${hcsMsg.sequence_number}`,
-      operation: "mint",
-      tick: normalizedTick,
-      amount: msg.amt,
-      to: msg.to,
-      timestamp: hcsMsg.consensus_timestamp,
-      sequenceNumber: hcsMsg.sequence_number,
-      topicId,
-      transactionId: hcsMsg.transaction_id || "",
-      memo: msg.m
-    });
   }
   /**
-   * Process transfer message
+   * Burn points
    */
-  processTransferMessage(msg, hcsMsg, topicId, isPrivate) {
-    const normalizedTick = this.normalizeTick(msg.tick);
-    const tickBalances = this.state.balances.get(normalizedTick);
-    if (!tickBalances) return;
-    if (!isPrivate && hcsMsg.payer_account_id !== msg.from) return;
-    const senderBalance = tickBalances.get(msg.from);
-    if (!senderBalance || BigInt(senderBalance.balance) < BigInt(msg.amt))
-      return;
-    const transferAmount = BigInt(msg.amt);
-    senderBalance.balance = (BigInt(senderBalance.balance) - transferAmount).toString();
-    senderBalance.lastUpdated = hcsMsg.consensus_timestamp;
-    const receiverBalance = tickBalances.get(msg.to);
-    if (receiverBalance) {
-      receiverBalance.balance = (BigInt(receiverBalance.balance) + transferAmount).toString();
-      receiverBalance.lastUpdated = hcsMsg.consensus_timestamp;
-    } else {
-      tickBalances.set(msg.to, {
+  async burnPoints(options) {
+    await this.ensureInitialized();
+    const { progressCallback } = options;
+    try {
+      progressCallback?.({
+        stage: "validating-balance",
+        percentage: 20
+      });
+      const normalizedTick = this.normalizeTick(options.tick);
+      const fromAccount = this.accountToString(options.from);
+      if (fromAccount !== this.operatorId) {
+        throw new PointsBurnError(
+          "For public topics, transaction payer must match burner",
+          options.tick,
+          fromAccount,
+          options.amount
+        );
+      }
+      progressCallback?.({
+        stage: "submitting",
+        percentage: 50
+      });
+      const topicId = options.topicId ? this.topicToString(options.topicId) : this.publicTopicId;
+      const burnTransaction = buildHcs20BurnTx({
+        topicId,
+        tick: options.tick,
+        amt: options.amount,
+        from: fromAccount,
+        memo: options.memo
+      });
+      const { transactionId: burnTxId } = await this.submitPayload(burnTransaction);
+      progressCallback?.({
+        stage: "confirming",
+        percentage: 80,
+        burnTxId
+      });
+      await this.waitForMirrorNodeConfirmation(topicId, burnTxId);
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        burnTxId
+      });
+      const transaction = {
+        id: burnTxId,
+        operation: "burn",
         tick: normalizedTick,
-        accountId: msg.to,
-        balance: msg.amt,
-        lastUpdated: hcsMsg.consensus_timestamp
+        amount: options.amount,
+        from: fromAccount,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sequenceNumber: 0,
+        topicId,
+        transactionId: burnTxId,
+        memo: options.memo
+      };
+      return transaction;
+    } catch (error) {
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        error: error instanceof Error ? error.message : "Unknown error"
       });
+      throw error;
     }
-    this.state.transactions.push({
-      id: hcsMsg.transaction_id || `${topicId}-${hcsMsg.sequence_number}`,
-      operation: "transfer",
-      tick: normalizedTick,
-      amount: msg.amt,
-      from: msg.from,
-      to: msg.to,
-      timestamp: hcsMsg.consensus_timestamp,
-      sequenceNumber: hcsMsg.sequence_number,
-      topicId,
-      transactionId: hcsMsg.transaction_id || "",
-      memo: msg.m
-    });
   }
   /**
-   * Process burn message
+   * Register a topic in the registry
    */
-  processBurnMessage(msg, hcsMsg, topicId, isPrivate) {
-    const normalizedTick = this.normalizeTick(msg.tick);
-    const pointsInfo = this.state.deployedPoints.get(normalizedTick);
-    const tickBalances = this.state.balances.get(normalizedTick);
-    if (!pointsInfo || !tickBalances) return;
-    if (!isPrivate && hcsMsg.payer_account_id !== msg.from) return;
-    const accountBalance = tickBalances.get(msg.from);
-    if (!accountBalance || BigInt(accountBalance.balance) < BigInt(msg.amt))
-      return;
-    const burnAmount = BigInt(msg.amt);
-    accountBalance.balance = (BigInt(accountBalance.balance) - burnAmount).toString();
-    accountBalance.lastUpdated = hcsMsg.consensus_timestamp;
-    pointsInfo.currentSupply = (BigInt(pointsInfo.currentSupply) - burnAmount).toString();
-    this.state.transactions.push({
-      id: hcsMsg.transaction_id || `${topicId}-${hcsMsg.sequence_number}`,
-      operation: "burn",
-      tick: normalizedTick,
-      amount: msg.amt,
-      from: msg.from,
-      timestamp: hcsMsg.consensus_timestamp,
-      sequenceNumber: hcsMsg.sequence_number,
-      topicId,
-      transactionId: hcsMsg.transaction_id || "",
-      memo: msg.m
-    });
+  async registerTopic(options) {
+    await this.ensureInitialized();
+    const { progressCallback } = options;
+    try {
+      progressCallback?.({
+        stage: "validating",
+        percentage: 20
+      });
+      const registerMessage = {
+        p: "hcs-20",
+        op: "register",
+        name: options.name,
+        metadata: options.metadata,
+        private: options.isPrivate,
+        t_id: this.topicToString(options.topicId),
+        m: options.memo
+      };
+      const validation = this.validateMessage(registerMessage);
+      if (!validation.valid) {
+        throw new PointsValidationError(
+          "Invalid register message",
+          validation.errors
+        );
+      }
+      if (!this.registryTopicId) {
+        throw new PointsDeploymentError(
+          "Registry topic not available",
+          options.name
+        );
+      }
+      progressCallback?.({
+        stage: "submitting",
+        percentage: 50
+      });
+      const registerTransaction = buildHcs20RegisterTx({
+        registryTopicId: this.registryTopicId,
+        name: options.name,
+        topicId: this.topicToString(options.topicId),
+        isPrivate: options.isPrivate,
+        metadata: options.metadata,
+        memo: options.memo
+      });
+      const { transactionId: registerTxId } = await this.submitPayload(
+        registerTransaction,
+        this.operatorCtx.operatorKey
+      );
+      progressCallback?.({
+        stage: "confirming",
+        percentage: 80,
+        registerTxId
+      });
+      await this.waitForMirrorNodeConfirmation(
+        this.registryTopicId,
+        registerTxId
+      );
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        registerTxId
+      });
+      this.logger.info(`Registered topic ${options.topicId} in registry`);
+    } catch (error) {
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
+    }
   }
   /**
-   * Normalize tick to lowercase and trim
+   * Wait for mirror node to index a message
    */
-  normalizeTick(tick) {
-    return tick.toLowerCase().trim();
+  async waitForMirrorNodeConfirmation(topicId, transactionId, maxRetries = 10) {
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        const messages = await this.mirrorNode.getTopicMessages(topicId, {
+          limit: 10,
+          order: "desc"
+        });
+        const found = messages.some((message) => {
+          if (typeof message !== "object" || message === null) {
+            return false;
+          }
+          const candidate = message;
+          return typeof candidate.consensus_timestamp === "string";
+        });
+        if (found) {
+          this.logger.debug(
+            `Transaction ${transactionId} confirmed on mirror node`
+          );
+          return;
+        }
+      } catch (error) {
+        this.logger.debug(`Mirror node check attempt ${i + 1} failed:`, error);
+      }
+      await sleep(2e3);
+    }
+    this.logger.warn(
+      `Transaction ${transactionId} not found on mirror node after ${maxRetries} attempts`
+    );
   }
 }
 export {
-  HCS20PointsIndexer
+  HCS20Client
 };
 //# sourceMappingURL=standards-sdk.es83.js.map