@hashgraphonline/standards-sdk 0.1.144 → 0.1.145

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

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