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

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

@@ -1,396 +1,259 @@
-import { TopicCreateTransaction, TransactionId, AccountId, PublicKey, KeyList, TopicMessageSubmitTransaction, TopicId } from "@hashgraph/sdk";
-import { HCS12BaseClient } from "./standards-sdk.es36.js";
-import { RegistryType } from "./standards-sdk.es30.js";
-import { inscribeWithSigner } from "./standards-sdk.es125.js";
-import { InscriptionSDK } from "./standards-sdk.es139.js";
-import { ActionRegistry } from "./standards-sdk.es32.js";
-import { BlockLoader } from "./standards-sdk.es33.js";
-import { AssemblyRegistry } from "./standards-sdk.es34.js";
-import { HashLinksRegistry } from "./standards-sdk.es35.js";
-import * as mime from "mime-types";
-class HCS12BrowserClient extends HCS12BaseClient {
-  constructor(config) {
-    super(config);
-    this.hwc = config.hwc;
-    this.updateAccountFromWallet();
-    this.logger.info("HCS-12 Browser Client initialized", {
-      network: config.network,
-      accountId: this.accountId
-    });
+import { getCryptoAdapter } from "./standards-sdk.es119.js";
+import { isSSREnvironment } from "./standards-sdk.es117.js";
+class ActionBuilder {
+  constructor(logger) {
+    this.cryptoAdapter = getCryptoAdapter();
+    this.logger = logger;
+    this.registration = {
+      p: "hcs-12",
+      op: "register"
+    };
   }
   /**
-   * Update account ID from wallet connect session
+   * Set HCS-1 topic ID for WASM storage
    */
-  async updateAccountFromWallet() {
-    try {
-      const { accountId } = await this.getAccountAndSigner();
-      this.accountId = accountId;
-    } catch (error) {
-      this.logger.warn("No active wallet connection");
+  setTopicId(topicId) {
+    if (!this.isValidTopicId(topicId)) {
+      throw new Error("Invalid topic ID format");
     }
+    this.registration.t_id = topicId;
+    return this;
   }
   /**
-   * Get account and signer from wallet connect
+   * Set alias for this action in the assembly
    */
-  async getAccountAndSigner() {
-    const accountInfo = this?.hwc?.getAccountInfo();
-    const accountId = accountInfo?.accountId?.toString();
-    const signer = this?.hwc?.dAppConnector?.signers?.find((s) => {
-      return s.getAccountId().toString() === accountId;
-    });
-    if (!signer || !accountId) {
-      this.logger.error("Failed to find signer", {
-        accountId,
-        signers: this?.hwc?.dAppConnector?.signers,
-        accountInfo
-      });
-      throw new Error("Failed to find signer or account");
-    }
-    return { accountId, signer };
+  setAlias(alias) {
+    this.alias = alias;
+    return this;
   }
   /**
-   * Get operator account ID (throws in browser)
+   * Set INFO hash
    */
-  getOperatorAccountId() {
-    throw new Error("Browser client does not have operator account");
+  setHash(hash) {
+    if (!this.isValidHash(hash)) {
+      throw new Error("Invalid hash format");
+    }
+    this.registration.hash = hash;
+    return this;
   }
   /**
-   * Get operator private key (throws in browser)
+   * Set WASM hash
    */
-  getOperatorPrivateKey() {
-    throw new Error("Browser client does not have operator private key");
+  setWasmHash(hash) {
+    if (!this.isValidHash(hash)) {
+      throw new Error("Invalid hash format");
+    }
+    this.registration.wasm_hash = hash;
+    return this;
   }
   /**
-   * Initialize registries with optional existing topic IDs
+   * Set optional INFO topic ID
    */
-  initializeRegistries(topicIds) {
-    super.initializeRegistries(topicIds);
-    this._actionRegistry = new ActionRegistry(
-      this.network,
-      this.logger,
-      this.actionRegistryTopicId,
-      this
-    );
-    this._blockLoader = new BlockLoader(this.network, this.logger, this);
-    this._assemblyRegistry = new AssemblyRegistry(
-      this.network,
-      this.logger,
-      this._assemblyRegistryTopicId,
-      this
-    );
-    this._hashLinksRegistry = new HashLinksRegistry(
-      this.network,
-      this.logger,
-      this._hashLinksRegistryTopicId,
-      this
-    );
-    this.logger.info("Registries initialized with signer", {
-      actionTopicId: this.actionRegistryTopicId,
-      assemblyTopicId: this._assemblyRegistryTopicId,
-      hashLinksTopicId: this._hashLinksRegistryTopicId
-    });
+  setInfoTopicId(topicId) {
+    if (!this.isValidTopicId(topicId)) {
+      throw new Error("Invalid topic ID format");
+    }
+    this.registration.info_t_id = topicId;
+    return this;
   }
   /**
-   * Create a new HCS topic for a registry
+   * Set JavaScript wrapper topic ID
    */
-  async createRegistryTopic(registryType, adminKey, submitKey) {
-    const { accountId, signer } = await this.getAccountAndSigner();
-    const memos = {
-      [RegistryType.ACTION]: "hcs-12:1:60:0",
-      [RegistryType.ASSEMBLY]: "hcs-12:1:60:2",
-      [RegistryType.HASHLINKS]: "hcs-12:1:60:3"
-    };
-    const memo = memos[registryType];
-    this.logger.info("Creating registry topic via wallet", {
-      registryType: RegistryType[registryType],
-      memo,
-      accountId
-    });
-    const transaction = new TopicCreateTransaction().setTopicMemo(memo).setTransactionId(TransactionId.generate(accountId));
-    if (adminKey) {
-      if (typeof adminKey === "boolean" && adminKey) {
-        const publicKey = await signer.getAccountKey();
-        transaction.setAdminKey(publicKey);
-        transaction.setAutoRenewAccountId(AccountId.fromString(accountId));
-      } else if (adminKey instanceof PublicKey || adminKey instanceof KeyList) {
-        transaction.setAdminKey(adminKey);
-        transaction.setAutoRenewAccountId(AccountId.fromString(accountId));
-      }
-    }
-    if (submitKey) {
-      if (typeof submitKey === "boolean" && submitKey) {
-        const publicKey = await signer.getAccountKey();
-        transaction.setSubmitKey(publicKey);
-      } else if (submitKey instanceof PublicKey || submitKey instanceof KeyList) {
-        transaction.setSubmitKey(submitKey);
-      }
+  setJsTopicId(topicId) {
+    if (!this.isValidTopicId(topicId)) {
+      throw new Error("Invalid topic ID format");
     }
-    const signedTx = await transaction.freezeWithSigner(signer);
-    const txResponse = await signedTx.executeWithSigner(signer);
-    const receipt = await txResponse.getReceiptWithSigner(signer);
-    if (!receipt.topicId) {
-      throw new Error("Failed to create topic: topicId is null");
-    }
-    const topicId = receipt.topicId.toString();
-    this.logger.info("Registry topic created via wallet", {
-      topicId,
-      registryType: RegistryType[registryType]
-    });
-    switch (registryType) {
-      case RegistryType.ACTION:
-        this.actionRegistryTopicId = topicId;
-        break;
-      case RegistryType.ASSEMBLY:
-        this._assemblyRegistryTopicId = topicId;
-        break;
-      case RegistryType.HASHLINKS:
-        break;
+    this.registration.js_t_id = topicId;
+    return this;
+  }
+  /**
+   * Set JavaScript wrapper hash
+   */
+  setJsHash(hash) {
+    if (!this.isValidHash(hash)) {
+      throw new Error("Invalid hash format");
     }
-    return topicId;
+    this.registration.js_hash = hash;
+    return this;
   }
   /**
-   * Create a new assembly topic
+   * Set interface version (wasm-bindgen version)
    */
-  async createAssemblyTopic() {
-    this.logger.info("Creating new assembly topic");
-    const topicId = await this.createRegistryTopic(RegistryType.ASSEMBLY);
-    return topicId;
+  setInterfaceVersion(version) {
+    if (!this.isValidVersion(version)) {
+      throw new Error("Invalid version format");
+    }
+    this.registration.interface_version = version;
+    return this;
   }
   /**
-   * Register an assembly on its own topic
+   * Add validation rule for an action
    */
-  async registerAssemblyDirect(assemblyTopicId, registration) {
-    this.logger.info("Registering assembly", {
-      topicId: assemblyTopicId,
-      name: registration.name,
-      version: registration.version
-    });
-    return this._submitMessage(assemblyTopicId, JSON.stringify(registration));
+  addValidationRule(action, rule) {
+    if (!this.registration.validation_rules) {
+      this.registration.validation_rules = {};
+    }
+    this.registration.validation_rules[action] = rule;
+    return this;
   }
   /**
-   * Add a block to an assembly
+   * Set source verification data
    */
-  async addBlockToAssembly(assemblyTopicId, block) {
-    this.logger.info("Adding block to assembly", {
-      assemblyTopicId,
-      blockTopicId: block.block_t_id
-    });
-    return this._submitMessage(assemblyTopicId, JSON.stringify(block));
+  setSourceVerification(verification) {
+    if (!this.isValidTopicId(verification.source_t_id)) {
+      throw new Error("Invalid source topic ID");
+    }
+    if (!this.isValidHash(verification.source_hash)) {
+      throw new Error("Invalid source hash");
+    }
+    if (verification.target !== "wasm32-unknown-unknown") {
+      throw new Error("Invalid compilation target");
+    }
+    this.registration.source_verification = verification;
+    return this;
   }
   /**
-   * Add an action to an assembly
+   * Build the action registration
    */
-  async addActionToAssembly(assemblyTopicId, action) {
-    this.logger.info("Adding action to assembly", {
-      assemblyTopicId,
-      actionTopicId: action.t_id,
-      alias: action.alias
-    });
-    return this._submitMessage(assemblyTopicId, JSON.stringify(action));
+  build(options = { validate: true }) {
+    if (options.validate !== false) {
+      this.validate();
+    }
+    return { ...this.registration };
   }
   /**
-   * Update assembly metadata
+   * Reset the builder
    */
-  async updateAssembly(assemblyTopicId, update) {
-    this.logger.info("Updating assembly", {
-      assemblyTopicId,
-      update
-    });
-    return this._submitMessage(assemblyTopicId, JSON.stringify(update));
+  reset() {
+    this.registration = {
+      p: "hcs-12",
+      op: "register"
+    };
+    this.alias = void 0;
+    return this;
   }
   /**
-   * Store a block (definition and template) via HCS-1
+   * Get the alias
    */
-  async storeBlock(template, definition) {
-    if (!this.blockLoader) {
-      throw new Error("Block loader not initialized");
+  getAlias() {
+    if (!this.alias) {
+      throw new Error("Action alias not set");
     }
-    return this.blockLoader.storeBlock(template, definition);
+    return this.alias;
   }
   /**
-   * Submit a message to an HCS topic
-   * @deprecated Use operation-specific methods instead
+   * Get the topic ID
    */
-  async submitMessage(topicId, message, submitKey) {
-    this.logger.warn(
-      "submitMessage is deprecated. Use operation-specific methods instead."
-    );
-    return this._submitMessage(topicId, message, submitKey);
+  getTopicId() {
+    if (!this.registration.t_id) {
+      throw new Error("Action topic ID not set");
+    }
+    return this.registration.t_id;
   }
   /**
-   * Internal method to submit a message to an HCS topic
+   * Generate WASM hash from binary data
    */
-  async _submitMessage(topicId, message, submitKey) {
-    const { accountId, signer } = await this.getAccountAndSigner();
-    this.logger.debug("Submitting message to topic via wallet", {
-      topicId,
-      messageLength: message.length,
-      accountId
-    });
-    const transaction = new TopicMessageSubmitTransaction().setTopicId(TopicId.fromString(topicId)).setMessage(message).setTransactionId(TransactionId.generate(accountId));
-    if (submitKey) {
-      this.logger.warn(
-        "Submit key parameter ignored in browser client - using wallet signer"
-      );
+  async generateWasmHash(wasmData) {
+    if (isSSREnvironment()) {
+      return this.createSSRSafeHash(wasmData, "wasm");
     }
-    const signedTx = await transaction.freezeWithSigner(signer);
-    const txResponse = await signedTx.executeWithSigner(signer);
-    const receipt = await txResponse.getReceiptWithSigner(signer);
-    this.logger.info("Message submitted successfully via wallet", {
-      topicId,
-      transactionId: txResponse.transactionId.toString(),
-      sequenceNumber: receipt.topicSequenceNumber?.toString()
-    });
-    return {
-      transactionId: txResponse.transactionId.toString(),
-      sequenceNumber: receipt.topicSequenceNumber ? Number(receipt.topicSequenceNumber) : void 0
-    };
+    const hasher = this.cryptoAdapter.createHash("sha256");
+    const result = hasher.update(Buffer.from(wasmData)).digest("hex");
+    const hash = result instanceof Promise ? await result : result;
+    return typeof hash === "string" ? hash : hash.toString("hex");
   }
   /**
-   * Get the HashConnect instance
+   * Generate INFO hash from module info
    */
-  getHashConnect() {
-    return this.hwc;
+  async generateInfoHash(info) {
+    const infoJson = JSON.stringify(info, Object.keys(info).sort());
+    if (isSSREnvironment()) {
+      return this.createSSRSafeHash(Buffer.from(infoJson), "info");
+    }
+    const hasher = this.cryptoAdapter.createHash("sha256");
+    const result = hasher.update(Buffer.from(infoJson)).digest("hex");
+    const hash = result instanceof Promise ? await result : result;
+    return typeof hash === "string" ? hash : hash.toString("hex");
   }
   /**
-   * Get connected account ID
+   * Calculate hash for any data
    */
-  getAccountId() {
-    return this.accountId;
+  async calculateHash(data) {
+    const buffer = typeof data === "string" ? Buffer.from(data) : data instanceof Uint8Array ? Buffer.from(data) : data;
+    if (isSSREnvironment()) {
+      return this.createSSRSafeHash(buffer, "data");
+    }
+    const hasher = this.cryptoAdapter.createHash("sha256");
+    const result = hasher.update(buffer).digest("hex");
+    const hash = result instanceof Promise ? await result : result;
+    return typeof hash === "string" ? hash : hash.toString("hex");
   }
   /**
-   * Check if wallet is connected
+   * Create SSR-safe hash
    */
-  async isConnected() {
-    try {
-      await this.getAccountAndSigner();
-      return true;
-    } catch {
-      return false;
+  createSSRSafeHash(data, type) {
+    const buffer = data instanceof Uint8Array ? Buffer.from(data) : data;
+    let hash = 0;
+    for (let i = 0; i < Math.min(buffer.length, 256); i++) {
+      hash = (hash << 5) - hash + buffer[i] & 4294967295;
     }
+    return `ssr-${type}-${buffer.length}-${Math.abs(hash).toString(16).padStart(8, "0")}`;
   }
   /**
-   * Inscribe a file using HCS-1 via wallet signer (browser)
+   * Create registration from WASM and INFO data
    */
-  async inscribeFile(buffer, fileName, options) {
-    const { accountId, signer } = await this.getAccountAndSigner();
-    this.logger.info("Inscribing file via HCS-1 (browser)", { fileName });
-    const mimeType = mime.lookup(fileName) || "application/octet-stream";
-    const sdk = await InscriptionSDK.createWithAuth({
-      type: "client",
-      accountId,
-      signer,
-      network: this.network
-    });
-    const inscriptionOptions = {
-      mode: "file",
-      waitForConfirmation: true,
-      waitMaxAttempts: options?.waitMaxAttempts || 30,
-      waitIntervalMs: options?.waitIntervalMs || 4e3,
-      progressCallback: options?.progressCallback,
-      logging: {
-        level: this.logger.getLevel ? this.logger.getLevel() : "info"
-      },
-      network: this.network
-    };
-    const response = await inscribeWithSigner(
-      {
-        type: "buffer",
-        buffer,
-        fileName,
-        mimeType
-      },
-      signer,
-      inscriptionOptions,
-      sdk
-    );
-    if (!response.confirmed || !response.inscription) {
-      throw new Error("Inscription failed to confirm");
-    }
-    return response.inscription;
+  async createFromWasmAndInfo(topicId, wasmData, info) {
+    const wasmHash = await this.generateWasmHash(wasmData);
+    const infoHash = await this.generateInfoHash(info);
+    const jsTopicId = this.registration.js_t_id;
+    const jsHash = this.registration.js_hash;
+    const interfaceVersion = this.registration.interface_version;
+    this.reset().setTopicId(topicId).setHash(infoHash).setWasmHash(wasmHash);
+    if (jsTopicId) this.setJsTopicId(jsTopicId);
+    if (jsHash) this.setJsHash(jsHash);
+    if (interfaceVersion) this.setInterfaceVersion(interfaceVersion);
+    return this.build();
   }
   /**
-   * Register an action built with ActionBuilder
+   * Check if registration is complete
    */
-  async registerAction(builder) {
-    const registration = builder.build();
-    if (!this._actionRegistry) {
-      throw new Error("Action registry not initialized");
-    }
-    const result = await this._submitMessage(
-      this.actionRegistryTopicId,
-      JSON.stringify(registration)
-    );
-    this.logger.info("Action registered (browser)", {
-      topicId: registration.t_id,
-      transactionId: result.transactionId
-    });
-    return builder;
+  isComplete(registration) {
+    return !!(registration.p === "hcs-12" && registration.op === "register" && registration.t_id && registration.hash && registration.wasm_hash);
   }
   /**
-   * Register a block built with BlockBuilder
+   * Validate the current registration
    */
-  async registerBlock(builder) {
-    const templateBuffer = builder.getTemplate();
-    if (templateBuffer) {
-      const templateResult = await this.inscribeFile(
-        templateBuffer,
-        `${builder.getName() || "block"}-template.html`
-      );
-      builder.setTemplateTopicId(templateResult.topic_id);
+  validate() {
+    if (!this.registration.t_id) {
+      throw new Error("Topic ID is required");
+    }
+    if (!this.registration.hash) {
+      throw new Error("INFO hash is required");
     }
-    const definition = builder.build();
-    if (!definition.template_t_id) {
-      throw new Error(
-        "Block must have either a template buffer (via setTemplate) or template_t_id"
-      );
+    if (!this.registration.wasm_hash) {
+      throw new Error("WASM hash is required");
     }
-    const definitionResult = await this.inscribeFile(
-      Buffer.from(JSON.stringify(definition, null, 2)),
-      `${definition.name}-definition.json`
-    );
-    this.logger.info("Block registered (browser)", {
-      name: definition.name,
-      definitionTopicId: definitionResult.topic_id,
-      templateTopicId: definition.template_t_id
-    });
-    builder.setTopicId(definitionResult.topic_id);
-    return builder;
   }
   /**
-   * Create an assembly using AssemblyBuilder and wallet signer
+   * Validate topic ID format
    */
-  async createAssembly(builder) {
-    if (!builder) {
-      return this.createAssemblyTopic();
-    }
-    const registration = builder.build();
-    const assemblyTopicId = await this.createAssemblyTopic();
-    await this.registerAssemblyDirect(assemblyTopicId, registration);
-    const operations = builder.getOperations();
-    for (const operation of operations) {
-      switch (operation.op) {
-        case "add-block":
-          await this.addBlockToAssembly(assemblyTopicId, operation);
-          break;
-        case "add-action":
-          await this.addActionToAssembly(assemblyTopicId, operation);
-          break;
-        case "update":
-          await this.updateAssembly(assemblyTopicId, operation);
-          break;
-      }
-    }
-    this.logger.info("Assembly created (browser)", {
-      topicId: assemblyTopicId,
-      name: registration.name,
-      version: registration.version,
-      operations: operations.length
-    });
-    return assemblyTopicId;
+  isValidTopicId(topicId) {
+    return /^\d+\.\d+\.\d+$/.test(topicId);
+  }
+  /**
+   * Validate hash format
+   */
+  isValidHash(hash) {
+    return /^[a-f0-9]{64}$/.test(hash);
+  }
+  /**
+   * Validate semantic version format
+   */
+  isValidVersion(version) {
+    return /^\d+\.\d+\.\d+$/.test(version);
   }
 }
 export {
-  HCS12BrowserClient
+  ActionBuilder
 };
 //# sourceMappingURL=standards-sdk.es38.js.map