@hashgraphonline/standards-sdk 0.1.144 → 0.1.145

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

@@ -1,430 +1,308 @@
-import { HCS6BaseClient } from "./standards-sdk.es7.js";
-import { buildHcs6Hrl } from "./standards-sdk.es4.js";
-import { AccountId, Client, TopicMessageSubmitTransaction, TopicId, PrivateKey, PublicKey, TokenMintTransaction, TokenId } from "@hashgraph/sdk";
-import { buildHcs6CreateRegistryTx } from "./standards-sdk.es8.js";
-import { createNodeOperatorContext, NodeOperatorResolver } from "./standards-sdk.es145.js";
-import { inscribe } from "./standards-sdk.es125.js";
-class HCS6Client extends HCS6BaseClient {
+import { HCS6BaseClient } from "./standards-sdk.es6.js";
+import { HCS6RegistryType } from "./standards-sdk.es3.js";
+import { inscribeWithSigner } from "./standards-sdk.es124.js";
+import { getTopicId } from "./standards-sdk.es114.js";
+class HCS6BrowserClient extends HCS6BaseClient {
+  /**
+   * Create a new HCS-6 browser client
+   * @param config Client configuration
+   */
   constructor(config) {
-    super({
-      network: config.network,
-      logLevel: config.logLevel,
-      silent: config.silent,
-      mirrorNodeUrl: config.mirrorNodeUrl,
-      logger: config.logger
-    });
-    this.operatorId = typeof config.operatorId === "string" ? AccountId.fromString(config.operatorId) : config.operatorId;
-    this.operatorCtx = createNodeOperatorContext({
-      network: this.network,
-      operatorId: this.operatorId,
-      operatorKey: config.operatorKey,
-      keyType: config.keyType,
-      mirrorNode: this.mirrorNode,
-      logger: this.logger,
-      client: this.createClient(config.network)
-    });
-    this.client = this.operatorCtx.client;
+    super(config);
+    this.hwc = config.hwc;
+    this.signer = config.signer;
   }
-  async ensureInitialized() {
-    await this.operatorCtx.ensureInitialized();
-  }
-  createClient(network) {
-    if (network === "mainnet") {
-      return Client.forMainnet();
-    } else {
-      return Client.forTestnet();
+  ensureConnected() {
+    const info = this.hwc.getAccountInfo();
+    const accountId = info?.accountId;
+    if (!accountId) {
+      throw new Error(
+        "No active wallet connection: wallet integration required to perform write operations"
+      );
     }
+    return accountId;
   }
-  close() {
-    this.logger.info("HCS-6 client closed.");
-  }
-  getKeyType() {
-    return this.operatorCtx.keyType;
-  }
-  getOperatorKey() {
-    return this.operatorCtx.operatorKey;
-  }
-  async submitMessage(topicId, payload) {
-    return this.submitMessageWithKey(topicId, payload, void 0);
-  }
-  async submitMessageWithKey(topicId, payload, submitKey) {
-    const { valid, errors } = this.validateMessage(payload);
-    if (!valid) {
-      throw new Error(`Invalid HCS-6 message: ${errors.join(", ")}`);
+  getSigner() {
+    const explicit = this.signer;
+    if (explicit) {
+      return explicit;
+    }
+    this.ensureConnected();
+    const dc = this.hwc.dAppConnector;
+    const signer = dc?.signers?.[0];
+    if (!signer) {
+      throw new Error("No active wallet signer");
     }
-    let tx = new TopicMessageSubmitTransaction().setTopicId(TopicId.fromString(topicId)).setMessage(JSON.stringify(payload));
-    if (!submitKey) {
-      const txResponse = await tx.execute(this.client);
-      return await txResponse.getReceipt(this.client);
+    return signer;
+  }
+  /**
+   * Create a new HCS-6 registry topic (for dynamic hashinals)
+   * Note: In browser environment, this would typically be called through a wallet or proxy service
+   * @param options Registry creation options
+   * @returns Promise resolving to the transaction result
+   */
+  async createRegistry(options) {
+    try {
+      this.ensureConnected();
+      const ttl = options?.ttl ?? 86400;
+      const memo = this.generateRegistryMemo(ttl);
+      const topicId = await this.hwc.createTopic(memo);
+      this.logger.info(
+        `Created HCS-6 registry topic via wallet: ${topicId} (TTL ${ttl})`
+      );
+      return { success: true, topicId };
+    } catch (error) {
+      this.logger.error(`Failed to create HCS-6 registry: ${error}`);
+      return { success: false, error: String(error) };
     }
-    const privateKey = typeof submitKey === "string" ? PrivateKey.fromString(submitKey) : submitKey;
-    const frozen = await tx.freezeWith(this.client);
-    await frozen.sign(privateKey);
-    const resp = await frozen.execute(this.client);
-    return await resp.getReceipt(this.client);
   }
-  async registerEntryWithKey(registryTopicId, options, submitKey) {
+  /**
+   * Register a new dynamic hashinal update in the registry
+   * Note: In browser environment, this would typically be called through a wallet or proxy service
+   * @param registryTopicId The topic ID of the HCS-6 registry
+   * @param options Registration options
+   * @returns Promise resolving to the operation result
+   */
+  async registerEntry(registryTopicId, options) {
     try {
-      const payload = this.createRegisterMessage(
+      const valid = await this.validateHCS6Topic(registryTopicId);
+      if (!valid) {
+        throw new Error(
+          `Topic ${registryTopicId} is not a valid HCS-6 registry`
+        );
+      }
+      const message = this.createRegisterMessage(
         options.targetTopicId,
         options.memo
       );
-      const receipt = await this.submitMessageWithKey(
-        registryTopicId,
-        payload,
-        submitKey
-      );
-      const sequenceNumber = receipt.topicSequenceNumber?.toNumber();
+      const receipt = await this.submitMessage(registryTopicId, message);
+      const seqField = receipt.topicSequenceNumber;
+      const sequenceNumber = typeof seqField === "number" ? seqField : seqField?.low;
       return { success: true, receipt, sequenceNumber };
     } catch (error) {
       this.logger.error(`Failed to register HCS-6 entry: ${error}`);
       return { success: false, error: String(error) };
     }
   }
-  async createRegistry(options = {}) {
+  /**
+   * Get the latest entry from a HCS-6 registry (non-indexed, so only latest matters)
+   * @param topicId The topic ID of the registry
+   * @param options Query options
+   * @returns Promise resolving to the registry information
+   */
+  async getRegistry(topicId, options = {}) {
     try {
-      await this.ensureInitialized();
-      const ttl = options.ttl ?? 86400;
-      if (!(ttl >= 3600)) {
-        throw new Error("TTL must be at least 3600 seconds (1 hour)");
-      }
-      let submitKeyPublic;
-      let submitKeyPrivate;
-      if (options.submitKey) {
-        if (typeof options.submitKey === "string") {
-          try {
-            submitKeyPublic = PublicKey.fromString(options.submitKey);
-          } catch {
-            const keyBytes = Buffer.from(
-              options.submitKey.replace(/^0x/i, ""),
-              "hex"
-            );
-            submitKeyPublic = this.operatorCtx.keyType === "ed25519" ? PublicKey.fromBytesED25519(keyBytes) : PublicKey.fromBytesECDSA(keyBytes);
-          }
-        } else if (typeof options.submitKey === "boolean") {
-          submitKeyPublic = this.operatorCtx.operatorKey.publicKey;
-        } else {
-          submitKeyPublic = options.submitKey.publicKey;
-          submitKeyPrivate = options.submitKey;
-        }
-      }
-      let transaction = buildHcs6CreateRegistryTx({
-        ttl,
-        submitKey: submitKeyPublic,
-        adminKey: this.operatorCtx.operatorKey.publicKey,
-        operatorPublicKey: this.operatorCtx.operatorKey.publicKey
-      });
-      const frozenTx = await transaction.freezeWith(this.client);
-      if (submitKeyPrivate) {
-        await frozenTx.sign(submitKeyPrivate);
-      }
-      const txResponse = await frozenTx.execute(this.client);
-      const receipt = await txResponse.getReceipt(this.client);
-      const topicId = receipt.topicId;
-      if (!topicId) {
+      const topicInfo = await this.mirrorNode.getTopicInfo(topicId);
+      this.logger.debug(
+        `Retrieved topic info for HCS-6 ${topicId}: ${JSON.stringify(topicInfo)}`
+      );
+      const memoInfo = this.parseRegistryTypeFromMemo(topicInfo.memo);
+      if (!memoInfo) {
         throw new Error(
-          "Failed to create HCS-6 registry: No topic ID in receipt"
+          `Topic ${topicId} is not an HCS-6 registry (invalid memo format)`
         );
       }
-      return {
-        success: true,
-        topicId: topicId.toString(),
-        transactionId: txResponse.transactionId.toString()
-      };
+      this.logger.debug(
+        `Retrieving messages for HCS-6 topic ${topicId} with limit ${options.limit ?? 100}`
+      );
+      const rawMessagesResult = await this.mirrorNode.getTopicMessages(
+        topicId,
+        {
+          sequenceNumber: options.skip && options.skip > 0 ? `gt:${options.skip}` : void 0,
+          limit: options.limit ?? 100,
+          order: options.order ?? "asc"
+        }
+      );
+      const rawMessages = options.limit ? rawMessagesResult.slice(0, options.limit) : rawMessagesResult;
+      this.logger.debug(
+        `Retrieved ${rawMessagesResult.length} messages, using ${rawMessages.length} after applying limit.`
+      );
+      return this.parseRegistryEntries(
+        topicId,
+        rawMessages,
+        memoInfo.registryType,
+        memoInfo.ttl
+      );
     } catch (error) {
-      this.logger.error(`Failed to create HCS-6 registry: ${error}`);
-      return {
-        success: false,
-        error: `Failed to create HCS-6 registry: ${error}`
-      };
+      this.logger.error(`Failed to get HCS-6 registry: ${error}`);
+      throw error;
     }
   }
-  async registerEntry(registryTopicId, options) {
-    await this.ensureInitialized();
-    return this.registerEntryWithKey(registryTopicId, options, void 0);
-  }
-  async getRegistry(topicId, options = {}) {
-    await this.ensureInitialized();
-    const topicInfo = await this.mirrorNode.getTopicInfo(topicId);
-    const memo = topicInfo.memo || "";
-    const match = memo.match(/^hcs-6:(\d):(\d+)$/);
-    if (!match) {
-      throw new Error(
-        `Topic ${topicId} is not an HCS-6 registry (invalid memo format)`
-      );
+  /**
+   * Submit a message to a HCS-6 topic
+   * Note: In browser environment, this would typically be called through a wallet or proxy service
+   * @param topicId The topic ID to submit to
+   * @param payload The message payload
+   * @returns Promise resolving to the transaction receipt
+   */
+  async submitMessage(topicId, payload) {
+    this.ensureConnected();
+    const { valid, errors } = this.validateMessage(payload);
+    if (!valid) {
+      throw new Error(`Invalid HCS-6 message: ${errors.join(", ")}`);
     }
-    const ttl = parseInt(match[2]);
-    const regType = parseInt(match[1]);
-    const messages = await this.mirrorNode.getTopicMessages(topicId, {
-      sequenceNumber: options.skip && options.skip > 0 ? `gt:${options.skip}` : void 0,
-      limit: options.limit ?? 100,
-      order: options.order ?? "asc"
-    });
-    const entries = messages.map((m) => {
-      try {
-        const decoded = m;
-        const { valid } = this.validateMessage(
-          decoded
-        );
-        if (!valid) return null;
-        return {
-          topicId,
-          sequence: decoded.sequence_number,
-          timestamp: decoded.consensus_timestamp || "",
-          payer: decoded.payer || "",
-          message: decoded,
-          consensus_timestamp: decoded.consensus_timestamp || "",
-          registry_type: regType
-        };
-      } catch {
-        return null;
-      }
-    }).filter(
-      (v) => Boolean(v)
-    );
-    const latest = entries.length > 0 ? entries[entries.length - 1] : void 0;
-    return {
+    const receipt = await this.hwc.submitMessageToTopic(
       topicId,
-      registryType: regType,
-      ttl,
-      entries,
-      latestEntry: latest
-    };
+      JSON.stringify(payload)
+    );
+    return receipt;
   }
-  async mint(options) {
+  /**
+   * Create a complete dynamic hashinal with inscription and registry
+   * Note: In browser environment, this would typically be called through a wallet or proxy service
+   * @param options Options for creating the dynamic hashinal
+   * @returns Promise resolving to the creation response
+   */
+  async createHashinal(options) {
     try {
-      await this.ensureInitialized();
-      if (!options.metadataTopicId) {
+      if (!this.signer) {
         return {
           success: false,
-          error: "metadataTopicId is required for mint()"
+          error: "No signer configured for browser createHashinal"
         };
       }
-      const metadata = buildHcs6Hrl(options.metadataTopicId);
-      let tx = new TokenMintTransaction().setTokenId(TokenId.fromString(options.tokenId)).setMetadata([Buffer.from(metadata)]);
-      const frozen = await tx.freezeWith(this.client);
-      if (options.supplyKey) {
-        const resolver = new NodeOperatorResolver({
-          mirrorNode: this.mirrorNode,
-          logger: this.logger
-        });
-        const privKey = typeof options.supplyKey === "string" ? await resolver.resolveSupplyKey(
-          options.tokenId,
-          options.supplyKey,
-          this.operatorCtx.keyType
-        ) : options.supplyKey;
-        await frozen.sign(privKey);
-      }
-      const resp = await frozen.execute(this.client);
-      const receipt = await resp.getReceipt(this.client);
-      const serial = receipt.serials && receipt.serials[0] ? Number(receipt.serials[0].toString()) : void 0;
-      return {
-        success: true,
-        serialNumber: serial,
-        transactionId: resp.transactionId?.toString?.(),
-        metadata
-      };
-    } catch (e) {
-      return { success: false, error: String(e) };
-    }
-  }
-  async inscribeAndMint(options) {
-    try {
-      await this.ensureInitialized();
-      const inscribeOptions = {
-        ...options.inscriptionOptions,
-        mode: "hashinal",
-        waitForConfirmation: true
-      };
-      const result = await inscribe(
-        options.inscriptionInput,
-        {
-          accountId: this.operatorId.toString(),
-          privateKey: this.operatorCtx.operatorKey,
-          network: this.network
-        },
-        inscribeOptions
-      );
-      if (!result.confirmed || !result.inscription) {
-        return { success: false, error: "Failed to inscribe content" };
-      }
-      const topicId = result.inscription.jsonTopicId || result.inscription.topic_id;
-      if (!topicId) {
-        return { success: false, error: "No topic ID from inscription" };
-      }
-      return await this.mint({
-        tokenId: options.tokenId,
-        metadataTopicId: topicId,
-        supplyKey: options.supplyKey,
-        memo: options.memo
-      });
-    } catch (e) {
-      return { success: false, error: String(e) };
-    }
-  }
-  async createHashinal(options) {
-    try {
-      await this.ensureInitialized();
-      let registryTopicId;
-      let registryTransactionId;
-      if (options.registryTopicId) {
-        registryTopicId = options.registryTopicId;
-        const topicInfo = await this.mirrorNode.getTopicInfo(registryTopicId);
-        const memo = topicInfo.memo || "";
-        if (!/^hcs-6:\d:\d+$/.test(memo)) {
-          throw new Error(
-            `Topic ${registryTopicId} is not a valid HCS-6 registry`
-          );
-        }
-      } else {
-        const res = await this.createRegistry({
-          ttl: options.ttl,
-          submitKey: true
-        });
-        if (!res.success || !res.topicId) {
-          throw new Error(res.error || "Failed to create HCS-6 registry");
-        }
-        registryTopicId = res.topicId;
-        registryTransactionId = res.transactionId;
-      }
-      const inscriptionBuffer = Buffer.from(JSON.stringify(options.metadata));
-      const inscribeOptions = {
+      const inscriptionOptions = {
         ...options.inscriptionOptions,
         mode: "hashinal",
         metadata: options.metadata,
-        waitForConfirmation: true
+        waitForConfirmation: true,
+        network: this.network
       };
-      const result = await inscribe(
-        {
-          type: "buffer",
-          buffer: inscriptionBuffer,
-          fileName: "metadata.json",
-          mimeType: "application/json"
-        },
-        {
-          accountId: this.operatorId.toString(),
-          privateKey: this.operatorCtx.operatorKey,
-          network: this.network
-        },
-        inscribeOptions
+      const input = {
+        type: "buffer",
+        buffer: Buffer.from(JSON.stringify(options.metadata)),
+        fileName: "metadata.json",
+        mimeType: "application/json"
+      };
+      const res = await inscribeWithSigner(
+        input,
+        this.signer,
+        inscriptionOptions
       );
-      if (!result.confirmed || !result.inscription) {
-        throw new Error("Failed to inscribe metadata");
+      const inscriptionTopicId = res.inscription?.jsonTopicId || getTopicId(res.inscription);
+      if (!inscriptionTopicId) {
+        return { success: false, error: "Failed to inscribe metadata" };
       }
-      const topicId = result.inscription.jsonTopicId || result.inscription.topic_id;
-      if (!topicId) {
-        throw new Error("No inscription topic ID available");
-      }
-      const reg = await this.registerEntryWithKey(
-        registryTopicId,
-        {
-          targetTopicId: topicId,
-          memo: options.memo || "Dynamic hashinal registration"
-        },
-        options.submitKey
-      );
-      if (!reg.success) {
-        throw new Error(reg.error || "Failed to register entry");
+      let registryTopicId = options.registryTopicId;
+      if (!registryTopicId) {
+        const reg = await this.createRegistry({ ttl: options.ttl });
+        if (!reg.success || !reg.topicId)
+          return { success: false, error: reg.error };
+        registryTopicId = reg.topicId;
       }
+      const regRes = await this.registerEntry(registryTopicId, {
+        targetTopicId: inscriptionTopicId,
+        memo: options.memo || "Initial dynamic hashinal registration"
+      });
+      if (!regRes.success) return { success: false, error: regRes.error };
       return {
         success: true,
         registryTopicId,
-        inscriptionTopicId: topicId,
-        transactionId: registryTransactionId
+        inscriptionTopicId
       };
-    } catch (e) {
-      return { success: false, error: String(e) };
+    } catch (error) {
+      this.logger.error(`Failed to create dynamic hashinal: ${error}`);
+      return { success: false, error: String(error) };
     }
   }
+  /**
+   * Register a dynamic hashinal with combined inscription and registry creation
+   * Note: In browser environment, this would typically be called through a wallet or proxy service
+   * @param options Options for registering the dynamic hashinal
+   * @returns Promise resolving to the creation response
+   */
   async register(options) {
     try {
-      await this.ensureInitialized();
-      let registryTopicId;
-      let registryTransactionId;
-      if (options.registryTopicId) {
-        registryTopicId = options.registryTopicId;
-        const topicInfo = await this.mirrorNode.getTopicInfo(registryTopicId);
-        const memo = topicInfo.memo || "";
-        if (!/^hcs-6:\d:\d+$/.test(memo)) {
-          throw new Error(
-            `Topic ${registryTopicId} is not a valid HCS-6 registry`
-          );
-        }
-      } else {
-        const res = await this.createRegistry({
-          ttl: options.ttl,
-          submitKey: true
-        });
-        if (!res.success || !res.topicId) {
-          throw new Error(res.error || "Failed to create HCS-6 registry");
-        }
-        registryTopicId = res.topicId;
-        registryTransactionId = res.transactionId;
+      if (!this.signer) {
+        return {
+          success: false,
+          error: "No signer configured for browser register"
+        };
       }
-      let inscriptionInput;
+      let input;
       if (options.data?.base64) {
-        const buffer = Buffer.from(options.data.base64, "base64");
-        inscriptionInput = {
+        input = {
           type: "buffer",
-          buffer,
-          fileName: `data.${options.data.mimeType?.split("/")[1] || "bin"}`,
+          buffer: Buffer.from(options.data.base64, "base64"),
+          fileName: "data." + (options.data.mimeType?.split("/")[1] || "bin"),
           mimeType: options.data.mimeType || "application/octet-stream"
         };
       } else if (options.data?.url) {
-        inscriptionInput = { type: "url", url: options.data.url };
+        input = { type: "url", url: options.data.url };
       } else {
-        inscriptionInput = {
+        input = {
           type: "buffer",
           buffer: Buffer.from(JSON.stringify(options.metadata)),
           fileName: "metadata.json",
           mimeType: "application/json"
         };
       }
-      const inscribeOptions = {
+      const inscriptionOptions = {
         ...options.inscriptionOptions,
         mode: "hashinal",
         metadata: options.metadata,
-        waitForConfirmation: true
+        waitForConfirmation: true,
+        network: this.network
       };
-      const result = await inscribe(
-        inscriptionInput,
-        {
-          accountId: this.operatorId.toString(),
-          privateKey: this.operatorCtx.operatorKey,
-          network: this.network
-        },
-        inscribeOptions
+      const res = await inscribeWithSigner(
+        input,
+        this.signer,
+        inscriptionOptions
       );
-      if (!result.confirmed || !result.inscription) {
-        throw new Error("Failed to inscribe data");
-      }
-      const topicId = result.inscription.jsonTopicId || result.inscription.topic_id;
-      if (!topicId) {
-        throw new Error("No inscription topic ID available");
-      }
-      const reg = await this.registerEntryWithKey(
-        registryTopicId,
-        {
-          targetTopicId: topicId,
-          memo: options.memo || "Dynamic hashinal registration"
-        },
-        options.submitKey
-      );
-      if (!reg.success) {
-        throw new Error(reg.error || "Failed to register entry");
+      const inscriptionTopicId = res.inscription?.jsonTopicId || getTopicId(res.inscription);
+      if (!inscriptionTopicId)
+        return { success: false, error: "Failed to inscribe data" };
+      let registryTopicId = options.registryTopicId;
+      if (!registryTopicId) {
+        const reg = await this.createRegistry({ ttl: options.ttl });
+        if (!reg.success || !reg.topicId)
+          return { success: false, error: reg.error };
+        registryTopicId = reg.topicId;
       }
+      const regRes = await this.registerEntry(registryTopicId, {
+        targetTopicId: inscriptionTopicId,
+        memo: options.memo || "Dynamic hashinal registration"
+      });
+      if (!regRes.success) return { success: false, error: regRes.error };
       return {
         success: true,
         registryTopicId,
-        inscriptionTopicId: topicId,
-        transactionId: registryTransactionId
+        inscriptionTopicId
       };
-    } catch (e) {
-      return { success: false, error: String(e) };
+    } catch (error) {
+      this.logger.error(`Failed to register dynamic hashinal: ${error}`);
+      return { success: false, error: String(error) };
+    }
+  }
+  /**
+   * Validate that a topic is a valid HCS-6 registry
+   * @param topicId The topic ID to validate
+   * @returns Promise resolving to true if valid, false otherwise
+   */
+  async validateHCS6Topic(topicId) {
+    try {
+      const topicInfo = await this.mirrorNode.getTopicInfo(topicId);
+      const memoInfo = this.parseRegistryTypeFromMemo(topicInfo.memo);
+      if (!memoInfo) {
+        this.logger.warn(
+          `Topic ${topicId} is not a valid HCS-6 registry (invalid memo format)`
+        );
+        return false;
+      }
+      if (memoInfo.registryType !== HCS6RegistryType.NON_INDEXED) {
+        this.logger.warn(
+          `Topic ${topicId} is not a valid HCS-6 registry (must be non-indexed)`
+        );
+        return false;
+      }
+      return true;
+    } catch (error) {
+      this.logger.error(`Error validating HCS-6 topic ${topicId}: ${error}`);
+      return false;
     }
   }
 }
 export {
-  HCS6Client
+  HCS6BrowserClient
 };
 //# sourceMappingURL=standards-sdk.es5.js.map