@hashgraphonline/standards-sdk 0.1.161 → 0.1.162

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

@@ -1,99 +1,45 @@
-import { AccountId, Client, Status, TopicCreateTransaction } from "@hashgraph/sdk";
-import { HCS20BaseClient } from "./standards-sdk.es80.js";
-import { PointsDeploymentError, PointsValidationError, PointsTransferError, PointsBurnError } from "./standards-sdk.es79.js";
-import { sleep } from "./standards-sdk.es127.js";
-import { createNodeOperatorContext } from "./standards-sdk.es152.js";
-import { HCS2Client } from "./standards-sdk.es74.js";
-import { buildHcs20DeployTx, buildHcs20MintTx, buildHcs20TransferTx, buildHcs20BurnTx, buildHcs20RegisterTx } from "./standards-sdk.es84.js";
-class HCS20Client extends HCS20BaseClient {
+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(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
+    super({
+      network: config.network,
+      logger: config.logger,
+      mirrorNodeUrl: config.mirrorNodeUrl,
+      registryTopicId: config.registryTopicId,
+      publicTopicId: config.publicTopicId
     });
-    this.client = this.operatorCtx.client;
-    void this.operatorCtx.ensureInitialized();
+    this.hwc = config.hwc;
+    this.feeAmount = config.feeAmount || 20;
   }
   /**
-   * Ensure operator is initialized before operations
+   * Get operator account ID
    */
-  async ensureInitialized() {
-    await this.operatorCtx.ensureInitialized();
-  }
-  /**
-   * Submit a payload to a topic
-   */
-  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");
+  getOperatorId() {
+    const accountInfo = this.hwc.getAccountInfo();
+    if (!accountInfo?.accountId) {
+      throw new Error("Wallet not connected");
     }
-    return {
-      receipt,
-      transactionId: transactionResponse.transactionId.toString()
-    };
+    return accountInfo.accountId;
   }
-  /**
-   * Create a public topic for HCS-20 (for testnet)
-   */
-  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;
-  }
-  /**
-   * Create a registry topic for HCS-20
-   */
   async createRegistryTopic() {
-    await this.ensureInitialized();
-    this.logger.info("Creating HCS-20 registry topic...");
-    const hcs2Client = new HCS2Client({
-      operatorId: this.operatorId,
-      operatorKey: this.operatorCtx.operatorKey,
+    const hcs2Client = new BrowserHCS2Client({
+      hwc: this.hwc,
       network: this.network
     });
-    const topicCreateResponse = await hcs2Client.createRegistry({
-      submitKey: this.operatorCtx.operatorKey,
-      adminKey: this.operatorCtx.operatorKey
-    });
+    const topicCreateResponse = await hcs2Client.createRegistry();
     if (!topicCreateResponse.success) {
-      throw new Error("Failed to create registry topic");
+      throw new Error("Failed to create topic");
     }
-    const topicId = topicCreateResponse.topicId;
-    this.logger.info(`Created registry topic: ${topicId}`);
-    this.registryTopicId = topicId;
-    return topicId;
+    return topicCreateResponse.topicId;
   }
   /**
    * Deploy new points
    */
   async deployPoints(options) {
-    await this.ensureInitialized();
+    const operatorId = this.getOperatorId();
     const { progressCallback } = options;
     try {
       progressCallback?.({
@@ -101,21 +47,18 @@ class HCS20Client extends HCS20BaseClient {
         percentage: 20
       });
       let topicId;
-      const hcs2Client = new HCS2Client({
-        operatorId: this.operatorId,
-        operatorKey: this.operatorCtx.operatorKey,
-        network: this.network
-      });
       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: this.operatorCtx.operatorKey,
-          adminKey: this.operatorCtx.operatorKey
+          submitKey: publicKey.toString(),
+          adminKey: publicKey.toString()
         });
         if (!topicCreateResponse.success) {
-          throw new PointsDeploymentError(
-            "Failed to create topic",
-            options.tick
-          );
+          throw new Error("Failed to create topic");
         }
         topicId = topicCreateResponse.topicId;
         this.logger.info(`Created private topic: ${topicId}`);
@@ -144,42 +87,37 @@ class HCS20Client extends HCS20BaseClient {
           validation.errors
         );
       }
-      const deployTransaction = buildHcs20DeployTx({
+      const deployResult = await this.submitPayload(
         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);
+        deployMessage,
+        options.usePrivateTopic
+      );
+      const deployTxId = deployResult.transactionHash?.toString() || "";
       progressCallback?.({
         stage: "confirming",
         percentage: 80,
         topicId,
         deployTxId
       });
-      await this.waitForMirrorNodeConfirmation(topicId, deployTxId);
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
       progressCallback?.({
         stage: "complete",
         percentage: 100,
         topicId,
         deployTxId
       });
-      const pointsInfo = {
+      return {
         name: options.name,
         tick: this.normalizeTick(options.tick),
         maxSupply: options.maxSupply,
         limitPerMint: options.limitPerMint,
         metadata: options.metadata,
         topicId,
-        deployerAccountId: this.operatorId,
+        deployerAccountId: operatorId,
         currentSupply: "0",
         deploymentTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
         isPrivate: options.usePrivateTopic || false
       };
-      return pointsInfo;
     } catch (error) {
       progressCallback?.({
         stage: "complete",
@@ -193,44 +131,42 @@ class HCS20Client extends HCS20BaseClient {
    * Mint points
    */
   async mintPoints(options) {
-    await this.ensureInitialized();
     const { progressCallback } = options;
     try {
       progressCallback?.({
         stage: "validating",
         percentage: 20
       });
-      const normalizedTick = this.normalizeTick(options.tick);
       progressCallback?.({
         stage: "submitting",
         percentage: 50
       });
-      const topicId = options.topicId ? this.topicToString(options.topicId) : this.publicTopicId;
-      const mintTransaction = buildHcs20MintTx({
-        topicId,
-        tick: options.tick,
+      const mintMessage = {
+        p: "hcs-20",
+        op: "mint",
+        tick: this.normalizeTick(options.tick),
         amt: options.amount,
         to: this.accountToString(options.to),
-        memo: options.memo
-      });
-      const { transactionId: mintTxId } = await this.submitPayload(mintTransaction);
+        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
       });
-      if (!options.disableMirrorCheck) {
-        await this.waitForMirrorNodeConfirmation(topicId, mintTxId);
-      }
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
       progressCallback?.({
         stage: "complete",
         percentage: 100,
         mintTxId
       });
-      const transaction = {
+      return {
         id: mintTxId,
         operation: "mint",
-        tick: normalizedTick,
+        tick: this.normalizeTick(options.tick),
         amount: options.amount,
         to: this.accountToString(options.to),
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -239,7 +175,6 @@ class HCS20Client extends HCS20BaseClient {
         transactionId: mintTxId,
         memo: options.memo
       };
-      return transaction;
     } catch (error) {
       progressCallback?.({
         stage: "complete",
@@ -253,64 +188,56 @@ class HCS20Client extends HCS20BaseClient {
    * Transfer points
    */
   async transferPoints(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);
-      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
-        );
-      }
       progressCallback?.({
         stage: "submitting",
         percentage: 50
       });
-      const topicId = options.topicId ? this.topicToString(options.topicId) : this.publicTopicId;
-      const transferTransaction = buildHcs20TransferTx({
-        topicId,
-        tick: options.tick,
+      const transferMessage = {
+        p: "hcs-20",
+        op: "transfer",
+        tick: this.normalizeTick(options.tick),
         amt: options.amount,
-        from: fromAccount,
-        to: toAccount,
-        memo: options.memo
-      });
-      const { transactionId: transferTxId } = await this.submitPayload(transferTransaction);
+        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 this.waitForMirrorNodeConfirmation(topicId, transferTxId);
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
       progressCallback?.({
         stage: "complete",
         percentage: 100,
         transferTxId
       });
-      const transaction = {
+      return {
         id: transferTxId,
         operation: "transfer",
-        tick: normalizedTick,
+        tick: this.normalizeTick(options.tick),
         amount: options.amount,
-        from: fromAccount,
-        to: toAccount,
+        from: this.accountToString(options.from),
+        to: this.accountToString(options.to),
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         sequenceNumber: 0,
         topicId,
         transactionId: transferTxId,
         memo: options.memo
       };
-      return transaction;
     } catch (error) {
       progressCallback?.({
         stage: "complete",
@@ -324,60 +251,50 @@ class HCS20Client extends HCS20BaseClient {
    * Burn points
    */
   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,
+      const burnMessage = {
+        p: "hcs-20",
+        op: "burn",
+        tick: this.normalizeTick(options.tick),
         amt: options.amount,
-        from: fromAccount,
-        memo: options.memo
-      });
-      const { transactionId: burnTxId } = await this.submitPayload(burnTransaction);
+        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 this.waitForMirrorNodeConfirmation(topicId, burnTxId);
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
       progressCallback?.({
         stage: "complete",
         percentage: 100,
         burnTxId
       });
-      const transaction = {
+      return {
         id: burnTxId,
         operation: "burn",
-        tick: normalizedTick,
+        tick: this.normalizeTick(options.tick),
         amount: options.amount,
-        from: fromAccount,
+        from: this.accountToString(options.from),
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         sequenceNumber: 0,
         topicId,
         transactionId: burnTxId,
         memo: options.memo
       };
-      return transaction;
     } catch (error) {
       progressCallback?.({
         stage: "complete",
@@ -391,7 +308,6 @@ class HCS20Client extends HCS20BaseClient {
    * Register a topic in the registry
    */
   async registerTopic(options) {
-    await this.ensureInitialized();
     const { progressCallback } = options;
     try {
       progressCallback?.({
@@ -414,86 +330,78 @@ class HCS20Client extends HCS20BaseClient {
           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
+      const registerResult = await this.submitPayload(
+        this.registryTopicId,
+        registerMessage,
+        false
       );
+      const registerTxId = registerResult.transactionHash?.toString() || "";
       progressCallback?.({
         stage: "confirming",
         percentage: 80,
         registerTxId
       });
-      await this.waitForMirrorNodeConfirmation(
-        this.registryTopicId,
-        registerTxId
-      );
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
       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;
+      throw new TopicRegistrationError(
+        error instanceof Error ? error.message : "Unknown error",
+        this.topicToString(options.topicId)
+      );
     }
   }
   /**
-   * Wait for mirror node to index a message
+   * Submit payload to topic using HWC
    */
-  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);
+  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);
+    }
+    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));
     }
-    this.logger.warn(
-      `Transaction ${transactionId} not found on mirror node after ${maxRetries} attempts`
+    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}`);
+    }
+    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.logger.debug("Payload submitted successfully via HWC");
+    return transactionResponse.result;
   }
 }
 export {
-  HCS20Client
+  BrowserHCS20Client
 };
 //# sourceMappingURL=standards-sdk.es82.js.map