@hashgraphonline/standards-sdk 0.1.160 → 0.1.162

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

@@ -1,368 +1,407 @@
-import { Logger } from "./standards-sdk.es116.js";
-import { HederaMirrorNode } from "./standards-sdk.es137.js";
-import "path";
-import "buffer";
-import "crypto";
-import "@noble/curves/secp256k1.js";
-import "./standards-sdk.es138.js";
-import "./standards-sdk.es140.js";
-import "zod";
-import { HCS20_CONSTANTS, HCS20MessageSchema } from "./standards-sdk.es77.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 { TopicMessageSubmitTransaction, TopicId, Hbar } from "@hashgraph/sdk";
+import { HCS20BaseClient } from "./standards-sdk.es81.js";
+import { PointsValidationError, TopicRegistrationError } from "./standards-sdk.es80.js";
+import { BrowserHCS2Client } from "./standards-sdk.es76.js";
+class BrowserHCS20Client extends HCS20BaseClient {
+  constructor(config) {
+    super({
+      network: config.network,
+      logger: config.logger,
+      mirrorNodeUrl: config.mirrorNodeUrl,
+      registryTopicId: config.registryTopicId,
+      publicTopicId: config.publicTopicId
     });
-    this.mirrorNode = new HederaMirrorNode(network, this.logger, {
-      customUrl: mirrorNodeUrl
-    });
-    this.state = this.initializeState();
-  }
-  /**
-   * Initialize empty state
-   */
-  initializeState() {
-    return {
-      deployedPoints: /* @__PURE__ */ new Map(),
-      balances: /* @__PURE__ */ new Map(),
-      transactions: [],
-      lastProcessedSequence: 0,
-      lastProcessedTimestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
+    this.hwc = config.hwc;
+    this.feeAmount = config.feeAmount || 20;
   }
   /**
-   * Get current state snapshot
+   * Get operator account ID
    */
-  getState() {
-    return {
-      ...this.state,
-      deployedPoints: new Map(this.state.deployedPoints),
-      balances: new Map(this.state.balances),
-      transactions: [...this.state.transactions]
-    };
-  }
-  /**
-   * Get points info for a specific tick
-   */
-  getPointsInfo(tick) {
-    return this.state.deployedPoints.get(this.normalizeTick(tick));
+  getOperatorId() {
+    const accountInfo = this.hwc.getAccountInfo();
+    if (!accountInfo?.accountId) {
+      throw new Error("Wallet not connected");
+    }
+    return accountInfo.accountId;
   }
-  /**
-   * Get balance for an account and tick
-   */
-  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() {
+    const hcs2Client = new BrowserHCS2Client({
+      hwc: this.hwc,
+      network: this.network
+    });
+    const topicCreateResponse = await hcs2Client.createRegistry();
+    if (!topicCreateResponse.success) {
+      throw new Error("Failed to create topic");
+    }
+    return topicCreateResponse.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) {
+    const operatorId = this.getOperatorId();
+    const { progressCallback } = options;
+    try {
+      progressCallback?.({
+        stage: "creating-topic",
+        percentage: 20
+      });
+      let topicId;
+      if (options.usePrivateTopic) {
+        const publicKey = await this.mirrorNode.getPublicKey(operatorId);
+        const hcs2Client = new BrowserHCS2Client({
+          hwc: this.hwc,
+          network: this.network
+        });
+        const topicCreateResponse = await hcs2Client.createRegistry({
+          submitKey: publicKey.toString(),
+          adminKey: publicKey.toString()
+        });
+        if (!topicCreateResponse.success) {
+          throw new Error("Failed to create topic");
+        }
+        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
-    );
+      const deployResult = await this.submitPayload(
+        topicId,
+        deployMessage,
+        options.usePrivateTopic
+      );
+      const deployTxId = deployResult.transactionHash?.toString() || "";
+      progressCallback?.({
+        stage: "confirming",
+        percentage: 80,
+        topicId,
+        deployTxId
+      });
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        topicId,
+        deployTxId
+      });
+      return {
+        name: options.name,
+        tick: this.normalizeTick(options.tick),
+        maxSupply: options.maxSupply,
+        limitPerMint: options.limitPerMint,
+        metadata: options.metadata,
+        topicId,
+        deployerAccountId: operatorId,
+        currentSupply: "0",
+        deploymentTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        isPrivate: options.usePrivateTopic || false
+      };
+    } catch (error) {
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
+    }
   }
   /**
-   * Stop indexing process
+   * Mint points
    */
-  stopIndexing() {
-    this.isProcessing = false;
-    this.logger.info("Indexing stopped");
+  async mintPoints(options) {
+    const { progressCallback } = options;
+    try {
+      progressCallback?.({
+        stage: "validating",
+        percentage: 20
+      });
+      progressCallback?.({
+        stage: "submitting",
+        percentage: 50
+      });
+      const mintMessage = {
+        p: "hcs-20",
+        op: "mint",
+        tick: this.normalizeTick(options.tick),
+        amt: options.amount,
+        to: this.accountToString(options.to),
+        m: options.memo
+      };
+      const topicId = options.topicId || this.publicTopicId;
+      const mintResult = await this.submitPayload(topicId, mintMessage, false);
+      const mintTxId = mintResult.transactionHash?.toString() || "";
+      progressCallback?.({
+        stage: "confirming",
+        percentage: 80,
+        mintTxId
+      });
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        mintTxId
+      });
+      return {
+        id: mintTxId,
+        operation: "mint",
+        tick: this.normalizeTick(options.tick),
+        amount: options.amount,
+        to: this.accountToString(options.to),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sequenceNumber: 0,
+        topicId,
+        transactionId: mintTxId,
+        memo: options.memo
+      };
+    } catch (error) {
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
+    }
   }
   /**
-   * Index topics and update state
+   * Transfer points
    */
-  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);
+  async transferPoints(options) {
+    const { progressCallback } = options;
+    try {
+      progressCallback?.({
+        stage: "validating-balance",
+        percentage: 20
+      });
+      progressCallback?.({
+        stage: "submitting",
+        percentage: 50
+      });
+      const transferMessage = {
+        p: "hcs-20",
+        op: "transfer",
+        tick: this.normalizeTick(options.tick),
+        amt: options.amount,
+        from: this.accountToString(options.from),
+        to: this.accountToString(options.to),
+        m: options.memo
+      };
+      const topicId = options.topicId || this.publicTopicId;
+      const transferResult = await this.submitPayload(
+        topicId,
+        transferMessage,
+        false
+      );
+      const transferTxId = transferResult.transactionHash?.toString() || "";
+      progressCallback?.({
+        stage: "confirming",
+        percentage: 80,
+        transferTxId
+      });
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        transferTxId
+      });
+      return {
+        id: transferTxId,
+        operation: "transfer",
+        tick: this.normalizeTick(options.tick),
+        amount: options.amount,
+        from: this.accountToString(options.from),
+        to: this.accountToString(options.to),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sequenceNumber: 0,
+        topicId,
+        transactionId: transferTxId,
+        memo: options.memo
+      };
+    } 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
+   * Burn points
    */
-  async getRegisteredTopics(registryTopicId) {
-    const topics = [];
+  async burnPoints(options) {
+    const { progressCallback } = options;
     try {
-      const messages = await this.mirrorNode.getTopicMessages(registryTopicId, {
-        limit: 100,
-        order: "asc"
+      progressCallback?.({
+        stage: "validating-balance",
+        percentage: 20
       });
-      messages.filter(
-        (message) => message.p === "hcs-20" && message.op === "register" && typeof message.t_id === "string"
-      ).forEach((message) => {
-        topics.push(message.t_id);
+      progressCallback?.({
+        stage: "submitting",
+        percentage: 50
       });
+      const burnMessage = {
+        p: "hcs-20",
+        op: "burn",
+        tick: this.normalizeTick(options.tick),
+        amt: options.amount,
+        from: this.accountToString(options.from),
+        m: options.memo
+      };
+      const topicId = options.topicId || this.publicTopicId;
+      const burnResult = await this.submitPayload(topicId, burnMessage, false);
+      const burnTxId = burnResult.transactionHash?.toString() || "";
+      progressCallback?.({
+        stage: "confirming",
+        percentage: 80,
+        burnTxId
+      });
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        burnTxId
+      });
+      return {
+        id: burnTxId,
+        operation: "burn",
+        tick: this.normalizeTick(options.tick),
+        amount: options.amount,
+        from: this.accountToString(options.from),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sequenceNumber: 0,
+        topicId,
+        transactionId: burnTxId,
+        memo: options.memo
+      };
     } 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
+   * Register a topic in the registry
    */
-  async indexTopic(topicId, isPrivate) {
+  async registerTopic(options) {
+    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",
+        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 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 (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 registerResult = await this.submitPayload(
+        this.registryTopicId,
+        registerMessage,
+        false
+      );
+      const registerTxId = registerResult.transactionHash?.toString() || "";
+      progressCallback?.({
+        stage: "confirming",
+        percentage: 80,
+        registerTxId
+      });
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        registerTxId
+      });
     } catch (error) {
-      this.logger.error(`Failed to index topic ${topicId}:`, error);
+      progressCallback?.({
+        stage: "complete",
+        percentage: 100,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw new TopicRegistrationError(
+        error instanceof Error ? error.message : "Unknown error",
+        this.topicToString(options.topicId)
+      );
     }
   }
   /**
-   * Process a single message
+   * Submit payload to topic using HWC
    */
-  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;
+  async submitPayload(topicId, payload, requiresFee) {
+    this.logger.debug(`Submitting payload to topic ${topicId}`);
+    let message;
+    if (typeof payload === "string") {
+      message = payload;
+    } else {
+      message = JSON.stringify(payload);
     }
-  }
-  /**
-   * Process deploy message
-   */
-  processDeployMessage(msg, hcsMsg, topicId, isPrivate) {
-    const normalizedTick = this.normalizeTick(msg.tick);
-    if (this.state.deployedPoints.has(normalizedTick)) {
-      return;
+    const transaction = new TopicMessageSubmitTransaction().setTopicId(TopicId.fromString(topicId)).setMessage(message);
+    if (requiresFee) {
+      this.logger.info(
+        "Topic requires fee payment, setting max transaction fee"
+      );
+      transaction.setMaxTransactionFee(new Hbar(this.feeAmount));
     }
-    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);
+    const transactionResponse = await this.hwc.executeTransactionWithErrorHandling(
+      transaction,
+      false
+    );
+    if (transactionResponse?.error) {
+      this.logger.error(
+        `Failed to submit payload: ${transactionResponse.error}`
+      );
+      throw new Error(`Failed to submit payload: ${transactionResponse.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
-   */
-  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
-      });
+    if (!transactionResponse?.result) {
+      this.logger.error(
+        "Failed to submit message: receipt is null or undefined"
+      );
+      throw new Error("Failed to submit message: receipt is null or undefined");
     }
-    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();
+    this.logger.debug("Payload submitted successfully via HWC");
+    return transactionResponse.result;
   }
 }
 export {
-  HCS20PointsIndexer
+  BrowserHCS20Client
 };
 //# sourceMappingURL=standards-sdk.es82.js.map