@hashgraphonline/standards-sdk 0.1.144 → 0.1.145

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

@@ -1,491 +1,172 @@
-import { RegistryType } from "./standards-sdk.es30.js";
-import { BaseRegistry } from "./standards-sdk.es31.js";
-import { validateAssemblyMessage } from "./standards-sdk.es43.js";
-import { ZodError } from "zod";
-class AssemblyRegistry extends BaseRegistry {
+import { BaseRegistry } from "./standards-sdk.es30.js";
+import { RegistryType } from "./standards-sdk.es29.js";
+import { validateWithSchema, hashLinksRegistrationSchema } from "./standards-sdk.es42.js";
+class HashLinksRegistry extends BaseRegistry {
   constructor(networkType, logger, topicId, client) {
-    super(networkType, logger, RegistryType.ASSEMBLY, topicId, client);
-    this.assemblyStates = /* @__PURE__ */ new Map();
+    super(networkType, logger, RegistryType.HASHLINKS, topicId, client);
   }
   /**
-   * Override getTopicMemo to indicate indexed registry
+   * Register a new HashLink in the global directory
    */
-  getTopicMemo() {
-    const indexed = 0;
-    const ttl = 60;
-    const type = this.registryType;
-    return `hcs-12:${indexed}:${ttl}:${type}`;
-  }
-  /**
-   * Register a new assembly
-   */
-  async register(registration) {
-    return this.submitMessage(registration);
+  async register(data) {
+    this.validateRegistration(data);
+    const id = `${this.topicId || "local"}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    const entry = {
+      id,
+      sequenceNumber: 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      submitter: this.client && "getHashConnect" in this.client ? "browser" : this.client?.getOperatorAccountId() || "local",
+      data
+    };
+    this.entries.set(id, entry);
+    if (this.client && this.topicId) {
+      try {
+        const message = JSON.stringify(data);
+        const result = await this.client.submitMessage(this.topicId, message);
+        if (result.sequenceNumber) {
+          entry.sequenceNumber = result.sequenceNumber;
+          entry.id = result.sequenceNumber.toString();
+          this.entries.delete(id);
+          this.entries.set(entry.id, entry);
+        }
+        this.logger.info("HashLink submitted to HCS", {
+          transactionId: result.transactionId,
+          sequenceNumber: result.sequenceNumber,
+          topicId: this.topicId
+        });
+        return entry.id;
+      } catch (error) {
+        this.logger.error("Failed to submit HashLink to HCS", { error });
+        this.entries.delete(id);
+        throw error;
+      }
+    }
+    this.logger.info("HashLink registered in directory", {
+      id,
+      name: data.name,
+      assemblyTopicId: data.t_id,
+      tags: data.tags
+    });
+    return id;
   }
   /**
-   * Create a new assembly topic
+   * Search HashLinks by tags
    */
-  async createAssemblyTopic() {
-    const topicId = await this.createRegistryTopic();
-    this.topicId = topicId;
-    return topicId;
+  async searchByTags(tags) {
+    const entries = await this.listEntries();
+    return entries.map((entry) => entry.data).filter((hashLink) => {
+      if (!hashLink.tags || hashLink.tags.length === 0) {
+        return false;
+      }
+      return tags.some((tag) => hashLink.tags?.includes(tag));
+    });
   }
   /**
-   * Add an action to the assembly
+   * Search HashLinks by name (partial match)
    */
-  async addAction(message) {
-    return this.submitMessage(message);
+  async searchByName(searchTerm) {
+    const entries = await this.listEntries();
+    const lowerSearchTerm = searchTerm.toLowerCase();
+    return entries.map((entry) => entry.data).filter(
+      (hashLink) => hashLink.name.toLowerCase().includes(lowerSearchTerm) || (hashLink.description?.toLowerCase().includes(lowerSearchTerm) ?? false)
+    );
   }
   /**
-   * Add a block to the assembly
+   * Get featured HashLinks
    */
-  async addBlock(message) {
-    return this.submitMessage(message);
+  async getFeatured() {
+    const entries = await this.listEntries();
+    return entries.map((entry) => entry.data).filter((hashLink) => hashLink.featured === true);
   }
   /**
-   * Update assembly metadata
+   * Get HashLinks by category
    */
-  async update(message) {
-    return this.submitMessage(message);
+  async getByCategory(category) {
+    const entries = await this.listEntries();
+    return entries.map((entry) => entry.data).filter((hashLink) => hashLink.category === category);
   }
   /**
-   * Submit any assembly operation message
+   * Get all unique categories
    */
-  async submitMessage(message) {
-    this.validateMessage(message);
-    if (!this.topicId) {
-      throw new Error("Assembly topic ID not found");
-    }
-    if (!this.client) {
-      throw new Error("Client not found");
-    }
-    this.logger.info("Submitting assembly message to HCS", {
-      topicId: this.topicId,
-      op: message.op
-    });
-    const result = await this.client.submitMessage(
-      this.topicId,
-      JSON.stringify(message)
-    );
-    const sequenceNumber = result.sequenceNumber;
-    if (!sequenceNumber) {
-      throw new Error("No sequence number returned from submission");
-    }
-    const entry = {
-      id: sequenceNumber.toString(),
-      sequenceNumber,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      submitter: "getHashConnect" in this.client ? (await this.client.getAccountAndSigner()).accountId : this.client.getOperatorAccountId(),
-      data: message
-    };
-    this.entries.set(entry.id, entry);
-    await this.processMessage(entry);
-    this.logger.info("Assembly message processed", {
-      op: message.op,
-      sequenceNumber
+  async getCategories() {
+    const entries = await this.listEntries();
+    const categories = /* @__PURE__ */ new Set();
+    entries.forEach((entry) => {
+      const hashLink = entry.data;
+      if (hashLink.category) {
+        categories.add(hashLink.category);
+      }
     });
-    return sequenceNumber.toString();
+    return Array.from(categories).sort();
   }
   /**
-   * Process a message to update assembly state
+   * Get all unique tags
    */
-  async processMessage(entry) {
-    const message = entry.data;
-    if (!this.topicId) return;
-    let state = this.assemblyStates.get(this.topicId);
-    switch (message.op) {
-      case "register":
-        const reg = message;
-        state = {
-          topicId: this.topicId,
-          name: reg.name,
-          version: reg.version,
-          description: reg.description,
-          tags: reg.tags,
-          author: reg.author,
-          actions: [],
-          blocks: [],
-          created: entry.timestamp,
-          updated: entry.timestamp
-        };
-        this.assemblyStates.set(this.topicId, state);
-        break;
-      case "add-action":
-        if (!state) {
-          this.logger.warn("Cannot add action without assembly registration");
-          return;
-        }
-        const addAction = message;
-        const action = {
-          t_id: addAction.t_id,
-          alias: addAction.alias,
-          config: addAction.config,
-          data: addAction.data
-        };
-        state.actions.push(action);
-        state.updated = entry.timestamp;
-        break;
-      case "add-block":
-        if (!state) {
-          this.logger.warn("Cannot add block without assembly registration");
-          return;
-        }
-        const addBlock = message;
-        const block = {
-          block_t_id: addBlock.block_t_id,
-          actions: addBlock.actions,
-          attributes: addBlock.attributes,
-          children: addBlock.children,
-          data: addBlock.data
-        };
-        state.blocks.push(block);
-        state.updated = entry.timestamp;
-        break;
-      case "update":
-        if (!state) {
-          this.logger.warn("Cannot update without assembly registration");
-          return;
-        }
-        const update = message;
-        if (update.description !== void 0) {
-          state.description = update.description;
-        }
-        if (update.tags !== void 0) {
-          state.tags = update.tags;
-        }
-        state.updated = entry.timestamp;
-        break;
-    }
-  }
-  /**
-   * Get the current state of an assembly
-   */
-  async getAssemblyState(topicId) {
-    const targetTopicId = topicId || this.topicId;
-    if (!targetTopicId || !this.client) return null;
-    let state = this.assemblyStates.get(targetTopicId);
-    if (state) return state;
-    if (targetTopicId === this.topicId && this.entries.size > 0) {
-      this.logger.debug("Building state from existing entries", {
-        topicId: targetTopicId,
-        entriesCount: this.entries.size
-      });
-      this.assemblyStates.clear();
-      for (const entry of this.entries.values()) {
-        this.processAssemblyMessage(targetTopicId, entry);
+  async getAllTags() {
+    const entries = await this.listEntries();
+    const tags = /* @__PURE__ */ new Set();
+    entries.forEach((entry) => {
+      const hashLink = entry.data;
+      if (hashLink.tags) {
+        hashLink.tags.forEach((tag) => tags.add(tag));
       }
-      const builtState = this.assemblyStates.get(targetTopicId) || null;
-      this.logger.debug("Built state from entries", {
-        topicId: targetTopicId,
-        hasState: !!builtState,
-        name: builtState?.name
-      });
-      return builtState;
-    }
-    this.logger.info("Syncing assembly state from topic", {
-      topicId: targetTopicId
     });
-    try {
-      const messages = await this.client.mirrorNode.getTopicMessagesByFilter(
-        targetTopicId,
-        {
-          order: "asc",
-          limit: 1e3
-        }
-      );
-      const messageArray = Array.isArray(messages) ? messages : [];
-      this.logger.info("Processing assembly messages", {
-        topicId: targetTopicId,
-        messageCount: messageArray.length
-      });
-      for (const msg of messageArray) {
-        try {
-          let data;
-          if (msg.message) {
-            try {
-              let messageContent;
-              const isServerEnvironment = typeof window === "undefined";
-              if (isServerEnvironment) {
-                messageContent = Buffer.from(
-                  msg.message,
-                  "base64"
-                ).toString("utf-8");
-              } else {
-                messageContent = new TextDecoder().decode(
-                  Uint8Array.from(
-                    atob(msg.message),
-                    (c) => c.charCodeAt(0)
-                  )
-                );
-              }
-              data = JSON.parse(messageContent);
-              this.logger.debug("Successfully parsed message", {
-                sequenceNumber: msg.sequence_number,
-                op: data.op,
-                p: data.p
-              });
-            } catch (error) {
-              this.logger.debug("Failed to decode/parse message", {
-                sequenceNumber: msg.sequence_number,
-                error
-              });
-              continue;
-            }
-          } else {
-            continue;
-          }
-          if (data.p !== "hcs-12") {
-            this.logger.debug("Skipping non-HCS-12 message", {
-              sequenceNumber: msg.sequence_number,
-              protocol: data.p
-            });
-            continue;
-          }
-          const entry = {
-            id: msg.sequence_number.toString(),
-            sequenceNumber: msg.sequence_number,
-            timestamp: msg.consensus_timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-            submitter: msg.payer_account_id || "unknown",
-            data
-          };
-          this.processAssemblyMessage(targetTopicId, entry);
-          this.logger.debug("Processed message for assembly", {
-            topicId: targetTopicId,
-            sequenceNumber: entry.sequenceNumber,
-            op: entry.data.op
-          });
-        } catch (error) {
-          this.logger.warn("Failed to parse assembly message", {
-            sequenceNumber: msg.sequence_number,
-            error
-          });
-        }
-      }
-      const finalState = this.assemblyStates.get(targetTopicId) || null;
-      this.logger.info("Assembly state after sync", {
-        topicId: targetTopicId,
-        hasState: !!finalState,
-        name: finalState?.name,
-        version: finalState?.version,
-        actionsCount: finalState?.actions?.length || 0,
-        blocksCount: finalState?.blocks?.length || 0
-      });
-      return finalState;
-    } catch (error) {
-      this.logger.error("Failed to sync assembly state", {
-        topicId: targetTopicId,
-        error
-      });
-      return null;
-    }
+    return Array.from(tags).sort();
   }
   /**
-   * Process a message for a specific assembly topic
+   * Validate HashLinks registration data
    */
-  processAssemblyMessage(topicId, entry) {
-    const message = entry.data;
-    let state = this.assemblyStates.get(topicId);
-    this.logger.debug("Processing assembly message", {
-      topicId,
-      op: message.op,
-      hasState: !!state
-    });
-    switch (message.op) {
-      case "register":
-        const reg = message;
-        state = {
-          topicId,
-          name: reg.name,
-          version: reg.version,
-          description: reg.description,
-          tags: reg.tags,
-          author: reg.author,
-          actions: [],
-          blocks: [],
-          created: entry.timestamp,
-          updated: entry.timestamp
-        };
-        this.assemblyStates.set(topicId, state);
-        this.logger.debug("Assembly registered", {
-          topicId,
-          name: reg.name,
-          version: reg.version
-        });
-        break;
-      case "add-action":
-        if (!state) {
-          this.logger.warn("Cannot add action without assembly registration");
-          return;
-        }
-        const addAction = message;
-        const action = {
-          t_id: addAction.t_id,
-          alias: addAction.alias,
-          config: addAction.config,
-          data: addAction.data
-        };
-        state.actions.push(action);
-        state.updated = entry.timestamp;
-        break;
-      case "add-block":
-        if (!state) {
-          this.logger.warn("Cannot add block without assembly registration");
-          return;
-        }
-        const addBlock = message;
-        const block = {
-          block_t_id: addBlock.block_t_id,
-          actions: addBlock.actions,
-          attributes: addBlock.attributes,
-          children: addBlock.children,
-          data: addBlock.data
-        };
-        state.blocks.push(block);
-        state.updated = entry.timestamp;
-        break;
-      case "update":
-        if (!state) {
-          this.logger.warn("Cannot update without assembly registration");
-          return;
-        }
-        const update = message;
-        if (update.description !== void 0) {
-          state.description = update.description;
-        }
-        if (update.tags !== void 0) {
-          state.tags = update.tags;
-        }
-        state.updated = entry.timestamp;
-        break;
+  validateRegistration(data) {
+    this.validateBaseRegistration(data);
+    const validation = validateWithSchema(data, hashLinksRegistrationSchema);
+    if (!validation.isValid) {
+      throw new Error(
+        `HashLinks validation failed: ${validation.errors.join(", ")}`
+      );
     }
-  }
-  /**
-   * Override sync to rebuild state from all messages
-   */
-  async sync() {
-    if (!this.topicId || !this.client) {
-      this.logger.warn("Cannot sync without topic ID and client");
-      return;
+    if (!data.t_id || !data.t_id.match(/^\d+\.\d+\.\d+$/)) {
+      throw new Error("Valid assembly topic ID (t_id) is required");
     }
-    this.entries.clear();
-    this.assemblyStates.delete(this.topicId);
-    this.logger.info("Syncing assembly messages", {
-      topicId: this.topicId
-    });
-    try {
-      const messages = await this.client.mirrorNode.getTopicMessagesByFilter(
-        this.topicId,
-        {
-          order: "asc",
-          limit: 1e3
-        }
-      );
-      const messageArray = Array.isArray(messages) ? messages : [];
-      this.logger.info("Processing assembly messages", {
-        topicId: this.topicId,
-        messageCount: messageArray.length
-      });
-      for (const msg of messageArray) {
-        try {
-          let data;
-          if (msg.message) {
-            try {
-              let messageContent;
-              const isServerEnvironment = typeof window === "undefined";
-              if (isServerEnvironment) {
-                messageContent = Buffer.from(
-                  msg.message,
-                  "base64"
-                ).toString("utf-8");
-              } else {
-                messageContent = new TextDecoder().decode(
-                  Uint8Array.from(
-                    atob(msg.message),
-                    (c) => c.charCodeAt(0)
-                  )
-                );
-              }
-              data = JSON.parse(messageContent);
-            } catch (error) {
-              this.logger.debug("Failed to decode/parse message in sync", {
-                sequenceNumber: msg.sequence_number,
-                error
-              });
-              continue;
-            }
-          } else if (msg.raw_content) {
-            try {
-              data = JSON.parse(msg.raw_content);
-            } catch {
-              continue;
-            }
-          } else {
-            const msgAny = msg;
-            if (msgAny.p && msgAny.op) {
-              data = { ...msgAny };
-              delete data.consensus_timestamp;
-              delete data.sequence_number;
-              delete data.payer_account_id;
-              delete data.topic_id;
-              delete data.running_hash;
-              delete data.running_hash_version;
-              delete data.chunk_info;
-              delete data.created;
-              delete data.payer;
-            } else {
-              continue;
-            }
-          }
-          if (data.p !== "hcs-12") {
-            continue;
-          }
-          const entry = {
-            id: msg.sequence_number.toString(),
-            sequenceNumber: msg.sequence_number,
-            timestamp: msg.consensus_timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-            submitter: msg.payer_account_id || "unknown",
-            data
-          };
-          this.entries.set(entry.id, entry);
-          await this.processMessage(entry);
-          this.logger.debug("Processed sync message", {
-            sequenceNumber: entry.sequenceNumber,
-            op: entry.data.op
-          });
-        } catch (error) {
-          this.logger.warn("Failed to parse assembly message", {
-            sequenceNumber: msg.sequence_number,
-            error
-          });
-        }
-      }
-      this.logger.info("Assembly sync completed", {
-        topicId: this.topicId,
-        messageCount: messageArray.length
-      });
-    } catch (error) {
-      this.logger.error("Failed to sync assembly", { error });
-      throw error;
+    if (data.tags && data.tags.length > 10) {
+      throw new Error("Maximum 10 tags allowed");
+    }
+    if (data.name.length > 100) {
+      throw new Error("Name must be 100 characters or less");
+    }
+    if (data.description && data.description.length > 500) {
+      throw new Error("Description must be 500 characters or less");
     }
   }
   /**
-   * Validate an assembly message
+   * Get registry statistics with HashLinks-specific metrics
    */
-  validateMessage(message) {
-    try {
-      validateAssemblyMessage(message);
-    } catch (error) {
-      if (error instanceof ZodError) {
-        const issues = error.errors.map(
-          (e) => `${e.path.join(".")}: ${e.message}`
-        );
-        throw new Error(`Assembly validation failed: ${issues.join("; ")}`);
+  getStats() {
+    const baseStats = super.getStats();
+    const entries = Array.from(this.entries.values());
+    const categories = /* @__PURE__ */ new Set();
+    const tags = /* @__PURE__ */ new Set();
+    let featuredCount = 0;
+    entries.forEach((entry) => {
+      const hashLink = entry.data;
+      if (hashLink.category) {
+        categories.add(hashLink.category);
       }
-      throw error;
-    }
+      if (hashLink.tags) {
+        hashLink.tags.forEach((tag) => tags.add(tag));
+      }
+      if (hashLink.featured) {
+        featuredCount++;
+      }
+    });
+    return {
+      ...baseStats,
+      categories: categories.size,
+      totalTags: tags.size,
+      featuredCount
+    };
   }
 }
 export {
-  AssemblyRegistry
+  HashLinksRegistry
 };
 //# sourceMappingURL=standards-sdk.es34.js.map