@hashgraphonline/standards-sdk 0.1.143 → 0.1.144-feat-solana-register.canary.d5edcec.80

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

@@ -1,347 +1,362 @@
-import { RegistryType } from "./standards-sdk.es30.js";
-import { inscribe, inscribeWithSigner } from "./standards-sdk.es125.js";
-import "./standards-sdk.es139.js";
-class BaseRegistry {
-  constructor(networkType, logger, registryType, topicId, client) {
-    this.entries = /* @__PURE__ */ new Map();
-    this.networkType = networkType;
-    this.logger = logger;
-    this.registryType = registryType;
-    this.topicId = topicId;
-    this.client = client;
+import { RegistryType } from "./standards-sdk.es29.js";
+import { BaseRegistry } from "./standards-sdk.es30.js";
+import { retrieveInscription } from "./standards-sdk.es124.js";
+import "./standards-sdk.es148.js";
+import { getCryptoAdapter } from "./standards-sdk.es119.js";
+import { isSSREnvironment } from "./standards-sdk.es117.js";
+import { validateActionRegistration } from "./standards-sdk.es42.js";
+import { ZodError } from "zod";
+class ActionRegistry extends BaseRegistry {
+  constructor(networkType, logger, topicId, client) {
+    super(networkType, logger, RegistryType.ACTION, topicId, client);
+    this.actionsByHash = /* @__PURE__ */ new Map();
+    this.cryptoAdapter = getCryptoAdapter();
   }
   /**
-   * Retrieve an entry by ID
+   * Register a WASM module with its binary via HCS-1
    */
-  async getEntry(id) {
-    const cached = this.entries.get(id);
-    if (cached) return cached;
-    if (this.topicId && this.client) {
-      await this.sync();
-      return this.entries.get(id) || null;
+  async registerWithWasm(wasmBinary, moduleInfo, sourceVerification) {
+    let wasmHash;
+    let infoHash;
+    if (isSSREnvironment()) {
+      wasmHash = this.createSSRSafeHash(wasmBinary, "wasm");
+      const infoString2 = JSON.stringify(moduleInfo);
+      infoHash = this.createSSRSafeHash(Buffer.from(infoString2), "info");
+    } else {
+      const wasmHasher = this.cryptoAdapter.createHash("sha256");
+      const wasmResult = wasmHasher.update(wasmBinary).digest("hex");
+      const wasmHashValue = wasmResult instanceof Promise ? await wasmResult : wasmResult;
+      wasmHash = typeof wasmHashValue === "string" ? wasmHashValue : wasmHashValue.toString("hex");
+      const infoString2 = JSON.stringify(moduleInfo);
+      const infoHasher = this.cryptoAdapter.createHash("sha256");
+      const infoResult = infoHasher.update(Buffer.from(infoString2)).digest("hex");
+      const infoHashValue = infoResult instanceof Promise ? await infoResult : infoResult;
+      infoHash = typeof infoHashValue === "string" ? infoHashValue : infoHashValue.toString("hex");
     }
-    return null;
+    const wasmTopicId = await this.inscribeContent(
+      wasmBinary,
+      "application/octet-stream",
+      {
+        name: moduleInfo.name,
+        version: moduleInfo.version,
+        hash: wasmHash,
+        fileType: "wasm"
+      }
+    );
+    let infoTopicId;
+    const infoString = JSON.stringify(moduleInfo);
+    if (Buffer.byteLength(infoString, "utf8") > 1024) {
+      infoTopicId = await this.inscribeContent(infoString, "application/json", {
+        name: `${moduleInfo.name}-info`,
+        version: moduleInfo.version
+      });
+    }
+    const registration = {
+      p: "hcs-12",
+      op: "register",
+      t_id: wasmTopicId,
+      hash: infoHash,
+      wasm_hash: wasmHash,
+      info_t_id: infoTopicId,
+      source_verification: sourceVerification,
+      m: `${moduleInfo.name} v${moduleInfo.version}`
+    };
+    await this.register(registration);
+    return registration;
   }
   /**
-   * Get the latest entry from a specific topic ID (for non-indexed topics)
+   * Register a new WASM action
    */
-  async getLatestEntry(topicId) {
-    if (!this.client) {
-      return null;
-    }
-    try {
-      const messages = await this.client.mirrorNode.getTopicMessagesByFilter(
-        topicId,
-        {
-          order: "desc",
-          limit: 1
-        }
+  async register(registration) {
+    this.validateRegistration(registration);
+    if (this.topicId && this.client) {
+      this.logger.info("Submitting action registration to HCS", {
+        topicId: this.topicId,
+        hash: registration.hash,
+        wasmHash: registration.wasm_hash
+      });
+      const result = await this.client.submitMessage(
+        this.topicId,
+        JSON.stringify(registration)
       );
-      if (!messages || messages.length === 0) {
-        return null;
-      }
-      const latestMessage = messages[0];
-      let data;
-      if (latestMessage.raw_content) {
-        data = JSON.parse(latestMessage.raw_content);
-      } else {
-        const msgAny = latestMessage;
-        if (msgAny.p === "hcs-12" && msgAny.op) {
-          data = {
-            p: msgAny.p,
-            op: msgAny.op,
-            name: msgAny.name,
-            version: msgAny.version,
-            description: msgAny.description,
-            permissions: msgAny.permissions,
-            metadata: msgAny.metadata,
-            data: msgAny.data,
-            category: msgAny.category,
-            source: msgAny.source,
-            inputs: msgAny.inputs,
-            outputs: msgAny.outputs,
-            tags: msgAny.tags,
-            fields: msgAny.fields,
-            styles: msgAny.styles,
-            actions: msgAny.actions,
-            blocks: msgAny.blocks,
-            refs: msgAny.refs
-          };
-          Object.keys(data).forEach((key) => {
-            if (data[key] === void 0) {
-              delete data[key];
-            }
-          });
-        } else {
-          return null;
-        }
+      const sequenceNumber = result.sequenceNumber;
+      if (!sequenceNumber) {
+        throw new Error("No sequence number returned from submission");
       }
-      return {
-        id: latestMessage.sequence_number.toString(),
-        sequenceNumber: latestMessage.sequence_number,
-        timestamp: latestMessage.consensus_timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-        submitter: latestMessage.payer || "unknown",
-        data
+      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: registration
       };
-    } catch (error) {
-      this.logger.error("Failed to get latest entry", { topicId, error });
-      return null;
+      this.entries.set(entry.id, entry);
+      this.actionsByHash.set(registration.hash, registration);
+      this.logger.info("Action registered", {
+        hash: registration.hash,
+        sequenceNumber,
+        hasSourceVerification: !!registration.source_verification
+      });
+      return sequenceNumber.toString();
+    } else {
+      const sequenceNumber = this.entries.size + 1;
+      const entry = {
+        id: sequenceNumber.toString(),
+        sequenceNumber,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        submitter: "local",
+        data: registration
+      };
+      this.entries.set(entry.id, entry);
+      this.actionsByHash.set(registration.hash, registration);
+      return sequenceNumber.toString();
     }
   }
   /**
-   * List all entries with optional filtering
+   * Retrieve action by hash
    */
-  async listEntries(filter) {
+  async getAction(hash) {
+    const cached = this.actionsByHash.get(hash);
+    if (cached) return cached;
     if (this.topicId && this.client) {
       await this.sync();
+      return this.actionsByHash.get(hash) || null;
     }
-    const entries = Array.from(this.entries.values());
-    if (!filter) return entries;
-    return entries.filter((entry) => {
-      if (filter.submitter && entry.submitter !== filter.submitter) {
-        return false;
-      }
-      if (filter.afterTimestamp && entry.timestamp < filter.afterTimestamp) {
-        return false;
+    return null;
+  }
+  /**
+   * Retrieve action by topic ID
+   */
+  async getActionByTopicId(topicId) {
+    this.logger.debug("getActionByTopicId called", { topicId });
+    console.log("DEBUG: getActionByTopicId called", {
+      topicId,
+      cacheSize: this.actionsByHash.size,
+      cachedTopicIds: Array.from(this.actionsByHash.values()).map((a) => a.t_id)
+    });
+    for (const action of this.actionsByHash.values()) {
+      if (action.t_id === topicId) {
+        this.logger.debug("Action found in cache", { topicId, action });
+        console.log("DEBUG: Action found in cache", { topicId, action });
+        return action;
       }
-      if (filter.beforeTimestamp && entry.timestamp > filter.beforeTimestamp) {
-        return false;
+    }
+    if (this.topicId && this.client) {
+      this.logger.debug("Action not in cache, syncing...", { topicId });
+      console.log("DEBUG: Action not in cache, syncing...");
+      await this.sync();
+      console.log("DEBUG: After sync", {
+        cacheSize: this.actionsByHash.size,
+        cachedTopicIds: Array.from(this.actionsByHash.values()).map(
+          (a) => a.t_id
+        )
+      });
+      for (const action of this.actionsByHash.values()) {
+        if (action.t_id === topicId) {
+          this.logger.debug("Action found after sync", { topicId, action });
+          console.log("DEBUG: Action found after sync", { topicId, action });
+          return action;
+        }
       }
-      return true;
-    });
+    }
+    this.logger.warn("Action not found", { topicId });
+    console.log("DEBUG: Action not found", { topicId });
+    return null;
   }
   /**
-   * Sync entries from the network
+   * Retrieve action info by hash
    */
-  async sync() {
-    if (!this.topicId || !this.client) {
-      this.logger.warn("Cannot sync without topic ID and client");
-      return;
-    }
-    this.logger.info("Syncing registry entries", {
-      topicId: this.topicId,
-      registryType: RegistryType[this.registryType],
-      lastSync: this.lastSyncTimestamp
-    });
+  async getActionInfo(hash) {
+    const action = await this.getAction(hash);
+    if (!action) return null;
     try {
-      const messages = await this.client.mirrorNode.getTopicMessagesByFilter(
-        this.topicId,
-        {
-          startTime: this.lastSyncTimestamp,
-          order: "asc",
-          limit: 100
+      let infoString;
+      if (action.info_t_id) {
+        if (!this.client) {
+          this.logger.error("Client not initialized - cannot fetch INFO");
+          return null;
         }
-      );
-      for (const msg of messages) {
-        try {
-          let data;
-          if (msg.raw_content) {
-            data = JSON.parse(msg.raw_content);
-          } else {
-            const msgAny = msg;
-            if (msgAny.p === "hcs-12" && msgAny.op) {
-              data = {
-                p: msgAny.p,
-                op: msgAny.op,
-                name: msgAny.name,
-                version: msgAny.version,
-                description: msgAny.description,
-                permissions: msgAny.permissions,
-                metadata: msgAny.metadata,
-                data: msgAny.data,
-                category: msgAny.category,
-                source: msgAny.source,
-                inputs: msgAny.inputs,
-                outputs: msgAny.outputs,
-                tags: msgAny.tags,
-                fields: msgAny.fields,
-                styles: msgAny.styles,
-                actions: msgAny.actions,
-                blocks: msgAny.blocks,
-                refs: msgAny.refs,
-                t_id: msgAny.t_id,
-                hash: msgAny.hash,
-                wasm_hash: msgAny.wasm_hash,
-                info_t_id: msgAny.info_t_id,
-                validation_rules: msgAny.validation_rules,
-                js_t_id: msgAny.js_t_id,
-                js_hash: msgAny.js_hash,
-                interface_version: msgAny.interface_version,
-                title: msgAny.title,
-                template: msgAny.template,
-                author: msgAny.author,
-                m: msgAny.m
-              };
-              Object.keys(data).forEach((key) => {
-                if (data[key] === void 0) {
-                  delete data[key];
-                }
-              });
-            } 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 || "unknown",
-            data
-          };
-          this.entries.set(entry.id, entry);
-        } catch (error) {
-          this.logger.warn("Failed to parse registry message", {
-            sequenceNumber: msg.sequence_number,
-            error
+        let inscription;
+        if ("getOperatorAccountId" in this.client) {
+          inscription = await retrieveInscription(action.info_t_id, {
+            accountId: this.client.getOperatorAccountId(),
+            privateKey: this.client.getOperatorPrivateKey(),
+            network: this.networkType
+          });
+        } else {
+          const { accountId } = await this.client.getAccountAndSigner();
+          inscription = await retrieveInscription(action.info_t_id, {
+            accountId,
+            network: this.networkType
           });
         }
+        if (!inscription.content) {
+          this.logger.error("No content in inscription response");
+          return null;
+        }
+        infoString = typeof inscription.content === "string" ? inscription.content : Buffer.from(inscription.content).toString("utf8");
+      } else {
+        this.logger.warn("Inline INFO storage not yet implemented");
+        return null;
       }
-      if (messages.length > 0) {
-        this.lastSyncTimestamp = messages[messages.length - 1].consensus_timestamp || (/* @__PURE__ */ new Date()).toISOString();
+      const moduleInfo = JSON.parse(infoString);
+      let computedHash;
+      if (isSSREnvironment()) {
+        computedHash = this.createSSRSafeHash(Buffer.from(infoString), "info");
       } else {
-        this.lastSyncTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+        const hasher = this.cryptoAdapter.createHash("sha256");
+        const result = hasher.update(Buffer.from(infoString)).digest("hex");
+        const hashValue = result instanceof Promise ? await result : result;
+        computedHash = typeof hashValue === "string" ? hashValue : hashValue.toString("hex");
       }
-      this.logger.info("Registry sync completed", {
-        topicId: this.topicId,
-        messageCount: messages.length,
-        lastSync: this.lastSyncTimestamp
-      });
+      if (computedHash !== action.hash) {
+        this.logger.error("INFO hash mismatch", {
+          expected: action.hash,
+          computed: computedHash
+        });
+        throw new Error("Module info verification failed");
+      }
+      return moduleInfo;
     } catch (error) {
-      this.logger.error("Failed to sync registry", { error });
-      throw error;
+      this.logger.error("Failed to fetch action INFO", {
+        hash,
+        error
+      });
+      return null;
     }
   }
   /**
-   * Get the registry topic memo format
+   * Retrieve action WASM binary
    */
-  getTopicMemo() {
-    const indexed = 1;
-    const ttl = 60;
-    const type = this.registryType;
-    return `hcs-12:${indexed}:${ttl}:${type}`;
-  }
-  /**
-   * Create a new registry topic
-   */
-  async createRegistryTopic() {
+  async getActionWasm(hash) {
+    const action = await this.getAction(hash);
+    if (!action) return null;
     if (!this.client) {
-      throw new Error("Client required to create topic");
+      this.logger.error("Client not initialized - cannot fetch WASM");
+      return null;
+    }
+    try {
+      let inscription;
+      if ("getOperatorAccountId" in this.client) {
+        inscription = await retrieveInscription(action.t_id, {
+          accountId: this.client.getOperatorAccountId(),
+          privateKey: this.client.getOperatorPrivateKey(),
+          network: this.networkType
+        });
+      } else {
+        const { accountId } = await this.client.getAccountAndSigner();
+        inscription = await retrieveInscription(action.t_id, {
+          accountId,
+          network: this.networkType
+        });
+      }
+      if (!inscription.content) {
+        this.logger.error("No content in inscription response");
+        return null;
+      }
+      const wasmBuffer = typeof inscription.content === "string" ? Buffer.from(inscription.content, "base64") : Buffer.from(inscription.content);
+      let computedHash;
+      if (isSSREnvironment()) {
+        computedHash = this.createSSRSafeHash(wasmBuffer, "wasm");
+      } else {
+        const hasher = this.cryptoAdapter.createHash("sha256");
+        const result = hasher.update(wasmBuffer).digest("hex");
+        const hashValue = result instanceof Promise ? await result : result;
+        computedHash = typeof hashValue === "string" ? hashValue : hashValue.toString("hex");
+      }
+      if (computedHash !== action.wasm_hash) {
+        this.logger.error("WASM hash mismatch", {
+          expected: action.wasm_hash,
+          computed: computedHash
+        });
+        throw new Error("WASM binary verification failed");
+      }
+      return new Uint8Array(wasmBuffer);
+    } catch (error) {
+      this.logger.error("Failed to fetch WASM from HCS-1", {
+        topicId: action.t_id,
+        error
+      });
+      return null;
     }
-    const topicId = await this.client.createRegistryTopic(this.registryType);
-    this.topicId = topicId;
-    return topicId;
   }
   /**
-   * Get registry configuration
+   * Search actions by criteria
    */
-  getConfig() {
-    return {
-      type: this.registryType,
-      indexed: false,
-      ttl: 60,
-      topicId: this.topicId,
-      memo: this.getTopicMemo()
-    };
+  async searchActions(criteria) {
+    const entries = await this.listEntries({
+      submitter: criteria.creator,
+      afterTimestamp: criteria.afterTimestamp,
+      beforeTimestamp: criteria.beforeTimestamp
+    });
+    return entries.map((entry) => entry.data).filter((action) => {
+      if (criteria.hasSourceVerification !== void 0) {
+        const hasVerification = !!action.source_verification;
+        if (hasVerification !== criteria.hasSourceVerification) return false;
+      }
+      return true;
+    });
   }
   /**
-   * Store large content via HCS-1 inscription
+   * Get actions by version chain
    */
-  async inscribeContent(content, mimeType, metadata) {
-    if (!this.client) {
-      throw new Error("Client required for inscription");
-    }
-    const buffer = typeof content === "string" ? Buffer.from(content) : content;
-    this.logger.info("Inscribing content via HCS-1", {
-      size: buffer.length,
-      mimeType,
-      registryType: RegistryType[this.registryType]
-    });
-    let response;
-    if ("getOperatorAccountId" in this.client) {
-      response = await inscribe(
-        {
-          type: "buffer",
-          buffer,
-          fileName: mimeType === "application/octet-stream" && metadata?.fileType === "wasm" ? `${metadata?.name || "content"}.wasm` : metadata?.name || "content",
-          mimeType
-        },
-        {
-          accountId: this.client.getOperatorAccountId(),
-          privateKey: this.client.getOperatorPrivateKey(),
-          network: this.networkType
-        },
-        {
-          mode: "file",
-          metadata,
-          waitForConfirmation: true
-        }
-      );
-    } else {
-      const { accountId, signer } = await this.client.getAccountAndSigner();
-      response = await inscribeWithSigner(
-        {
-          type: "buffer",
-          buffer,
-          fileName: mimeType === "application/octet-stream" && metadata?.fileType === "wasm" ? `${metadata?.name || "content"}.wasm` : metadata?.name || "content",
-          mimeType
-        },
-        signer,
-        {
-          mode: "file",
-          metadata,
-          waitForConfirmation: true
-        }
-      );
+  async getVersionChain(latestHash) {
+    const chain = [];
+    let currentHash = latestHash;
+    while (currentHash) {
+      const action = await this.getAction(currentHash);
+      if (!action) break;
+      chain.push(action);
+      currentHash = void 0;
     }
-    if (!response.confirmed) {
-      throw new Error("Failed to inscribe content");
-    }
-    const topicId = response.inscription.topic_id;
-    if (!topicId) {
-      throw new Error("No topic ID in inscription response");
-    }
-    this.logger.info("Content inscribed successfully", {
-      topicId
-    });
-    return topicId;
+    return chain;
   }
   /**
-   * Validate common registration fields
+   * Validate action registration using Zod schema
    */
-  validateBaseRegistration(data) {
-    if (!data.p || data.p !== "hcs-12") {
-      throw new Error("Invalid protocol identifier");
+  validateRegistration(registration) {
+    try {
+      validateActionRegistration(registration);
+    } catch (error) {
+      if (error instanceof ZodError) {
+        const firstError = error.errors[0];
+        throw new Error(
+          `Validation failed: ${firstError.path.join(".")} - ${firstError.message}`
+        );
+      }
+      throw error;
     }
-    if (!data.op || data.op !== "register") {
-      throw new Error("Invalid operation");
+  }
+  /**
+   * Override sync to handle action-specific processing
+   */
+  async sync() {
+    await super.sync();
+    this.actionsByHash.clear();
+    for (const entry of this.entries.values()) {
+      const action = entry.data;
+      this.actionsByHash.set(action.hash, action);
     }
   }
   /**
-   * Clear local cache
+   * Override clear cache to also clear action hash index
    */
   clearCache() {
-    this.entries.clear();
-    this.lastSyncTimestamp = void 0;
-    this.logger.info("Registry cache cleared", {
-      registryType: RegistryType[this.registryType]
-    });
+    super.clearCache();
+    this.actionsByHash.clear();
   }
   /**
-   * Get registry statistics
+   * Create SSR-safe hash
    */
-  getStats() {
-    return {
-      entryCount: this.entries.size,
-      lastSync: this.lastSyncTimestamp,
-      topicId: this.topicId,
-      registryType: RegistryType[this.registryType]
-    };
+  createSSRSafeHash(data, type) {
+    let hash = 0;
+    for (let i = 0; i < Math.min(data.length, 256); i++) {
+      hash = (hash << 5) - hash + data[i] & 4294967295;
+    }
+    return `ssr-${type}-${data.length}-${Math.abs(hash).toString(16).padStart(8, "0")}`;
   }
 }
 export {
-  BaseRegistry
+  ActionRegistry
 };
 //# sourceMappingURL=standards-sdk.es31.js.map