@hashgraphonline/standards-sdk 0.1.144 → 0.1.146-chore-jsr-improvements.canary.74bacb9.89

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

@@ -1,499 +1,375 @@
-import { AccountId, Client, Status, TopicCreateTransaction } from "@hashgraph/sdk";
-import { HCS20BaseClient } from "./standards-sdk.es75.js";
-import { PointsDeploymentError, PointsValidationError, PointsTransferError, PointsBurnError } from "./standards-sdk.es74.js";
-import { sleep } from "./standards-sdk.es116.js";
-import { createNodeOperatorContext } from "./standards-sdk.es145.js";
-import { HCS2Client } from "./standards-sdk.es69.js";
-import { buildHcs20DeployTx, buildHcs20MintTx, buildHcs20TransferTx, buildHcs20BurnTx, buildHcs20RegisterTx } from "./standards-sdk.es79.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
+import { Logger } from "./standards-sdk.es105.js";
+import { HederaMirrorNode } from "./standards-sdk.es126.js";
+import "./standards-sdk.es127.js";
+import "./standards-sdk.es128.js";
+import "./standards-sdk.es129.js";
+import "./standards-sdk.es130.js";
+import "./standards-sdk.es131.js";
+import "./standards-sdk.es132.js";
+import "./standards-sdk.es133.js";
+import "./standards-sdk.es134.js";
+import "buffer";
+import "crypto";
+import "@noble/curves/secp256k1.js";
+import "zod";
+import "./standards-sdk.es149.js";
+import "./standards-sdk.es138.js";
+import { HCS20_CONSTANTS, HCS20MessageSchema } from "./standards-sdk.es72.js";
+class HCS20PointsIndexer {
+  constructor(network, logger, mirrorNodeUrl) {
+    this.isProcessing = false;
+    this.lastIndexedSequence = /* @__PURE__ */ new Map();
+    this.logger = logger || new Logger({
+      level: "info",
+      module: "HCS20PointsIndexer"
     });
-    this.client = this.operatorCtx.client;
-    void this.operatorCtx.ensureInitialized();
+    this.mirrorNode = new HederaMirrorNode(network, this.logger, {
+      customUrl: mirrorNodeUrl
+    });
+    this.state = this.initializeState();
   }
   /**
-   * Ensure operator is initialized before operations
+   * Initialize empty state
    */
-  async ensureInitialized() {
-    await this.operatorCtx.ensureInitialized();
+  initializeState() {
+    return {
+      deployedPoints: /* @__PURE__ */ new Map(),
+      balances: /* @__PURE__ */ new Map(),
+      transactions: [],
+      lastProcessedSequence: 0,
+      lastProcessedTimestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
   }
   /**
-   * Submit a payload to a topic
+   * Get current state snapshot
    */
-  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");
-    }
+  getState() {
     return {
-      receipt,
-      transactionId: transactionResponse.transactionId.toString()
+      ...this.state,
+      deployedPoints: new Map(this.state.deployedPoints),
+      balances: new Map(this.state.balances),
+      transactions: [...this.state.transactions]
     };
   }
   /**
-   * Create a public topic for HCS-20 (for testnet)
+   * Get points info for a specific 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;
+  getPointsInfo(tick) {
+    return this.state.deployedPoints.get(this.normalizeTick(tick));
   }
   /**
-   * Create a registry topic for HCS-20
+   * Get balance for an account and tick
    */
-  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;
+  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";
   }
   /**
-   * Deploy new points
+   * Start indexing process
    */
-  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;
-      }
-      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
+  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);
       }
-      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;
+      if (this.isProcessing) {
+        setTimeout(pollTopics, pollInterval);
+      }
+    };
+    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);
     }
+    this.logger.debug("Indexing cycle complete");
   }
   /**
-   * Mint points
+   * Get registered topics from registry
    */
-  async mintPoints(options) {
-    await this.ensureInitialized();
-    const { progressCallback } = options;
+  async getRegisteredTopics(registryTopicId) {
+    const topics = [];
     try {
-      progressCallback?.({
-        stage: "validating",
-        percentage: 20
-      });
-      const normalizedTick = this.normalizeTick(options.tick);
-      progressCallback?.({
-        stage: "submitting",
-        percentage: 50
+      const messages = await this.mirrorNode.getTopicMessages(registryTopicId, {
+        limit: 100,
+        order: "asc"
       });
-      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
+      messages.filter(
+        (message) => message.p === "hcs-20" && message.op === "register" && typeof message.t_id === "string"
+      ).forEach((message) => {
+        topics.push(message.t_id);
       });
-      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) {
-      progressCallback?.({
-        stage: "complete",
-        percentage: 100,
-        error: error instanceof Error ? error.message : "Unknown error"
-      });
-      throw error;
+      this.logger.error("Failed to fetch registry messages:", error);
     }
+    return topics;
   }
   /**
-   * Transfer points
+   * Index a single topic
    */
-  async transferPoints(options) {
-    await this.ensureInitialized();
-    const { progressCallback } = options;
+  async indexTopic(topicId, isPrivate) {
     try {
-      progressCallback?.({
-        stage: "validating-balance",
-        percentage: 20
+      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"
       });
-      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
+      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}`
         );
+        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) {
-      progressCallback?.({
-        stage: "complete",
-        percentage: 100,
-        error: error instanceof Error ? error.message : "Unknown error"
-      });
-      throw error;
+      this.logger.error(`Failed to index topic ${topicId}:`, error);
     }
   }
   /**
-   * Burn points
+   * Process a single message
    */
-  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,
-        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;
+  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;
     }
   }
   /**
-   * Register a topic in the registry
+   * Process deploy message
    */
-  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;
+  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}`);
   }
   /**
-   * Wait for mirror node to index a message
+   * Process mint message
    */
-  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);
+  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);
     }
-    this.logger.warn(
-      `Transaction ${transactionId} not found on mirror node after ${maxRetries} attempts`
-    );
+    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
+   */
+  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, {
+        tick: normalizedTick,
+        accountId: msg.to,
+        balance: msg.amt,
+        lastUpdated: hcsMsg.consensus_timestamp
+      });
+    }
+    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
+   */
+  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
+    });
+  }
+  /**
+   * Normalize tick to lowercase and trim
+   */
+  normalizeTick(tick) {
+    return tick.toLowerCase().trim();
   }
 }
 export {
-  HCS20Client
+  HCS20PointsIndexer
 };
 //# sourceMappingURL=standards-sdk.es77.js.map