@hashgraphonline/standards-sdk 0.0.18 → 0.0.19

package/dist/es/hcs-10/index.d.ts

@@ -3,3 +3,4 @@ export * from './errors';
 export * from './agent-builder';
 export * from './base-client';
 export * from './registrations';
+export * from './browser';

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

@@ -32982,11 +32982,607 @@ class AgentBuilder {
     return this.config;
   }
 }
+class BrowserHCSClient extends HCS10BaseClient {
+  constructor(config) {
+    super({
+      network: config.network,
+      logLevel: config.logLevel
+    });
+    this.guardedRegistryBaseUrl = config.guardedRegistryBaseUrl || "https://moonscape.tech";
+    this.hwc = config.hwc;
+    this.logger = Logger$1.getInstance({
+      level: config.logLevel || "info",
+      module: "HCS-Browser"
+    });
+    const { accountId, signer } = this.getAccountAndSigner();
+    this.hcs11Client = new HCS11Client({
+      network: config.network,
+      auth: {
+        operatorId: accountId,
+        signer
+      },
+      logLevel: config.logLevel
+    });
+  }
+  async sendMessage(connectionTopicId, operatorId, data, memo) {
+    this.logger.info("Sending message");
+    const payload = {
+      p: "hcs-10",
+      op: "message",
+      operator_id: operatorId,
+      data,
+      m: memo
+    };
+    await this.submitPayload(connectionTopicId, payload);
+  }
+  async submitConnectionRequest(inboundTopicId, requestingAccountId, operatorId, memo) {
+    var _a, _b;
+    this.logger.info("Submitting connection request");
+    const connectionRequestMessage = {
+      p: "hcs-10",
+      op: "connection_request",
+      requesting_account_id: requestingAccountId,
+      operator_id: operatorId,
+      m: memo
+    };
+    const response = await this.submitPayload(
+      inboundTopicId,
+      connectionRequestMessage
+    );
+    this.logger.info(
+      `Submitted connection request to topic ID: ${inboundTopicId}`
+    );
+    const outboundTopic = await this.retrieveOutboundConnectTopic(
+      requestingAccountId
+    );
+    if (!(outboundTopic == null ? void 0 : outboundTopic.outboundTopic)) {
+      this.logger.error(
+        `Failed to retrieve outbound topic for account ID: ${requestingAccountId}`
+      );
+      throw new Error(
+        `Failed to retrieve outbound topic for account ID: ${requestingAccountId}`
+      );
+    }
+    this.logger.info(
+      `Retrieved outbound topic ID: ${outboundTopic.outboundTopic} for account ID: ${requestingAccountId}`
+    );
+    const responseSequenceNumber = (_b = (_a = response == null ? void 0 : response.result) == null ? void 0 : _a.topicSequenceNumber) == null ? void 0 : _b.toNumber();
+    if (!responseSequenceNumber) {
+      throw new Error("Failed to get response sequence number");
+    }
+    await this.submitPayload(outboundTopic.outboundTopic, {
+      ...connectionRequestMessage,
+      outbound_topic_id: inboundTopicId,
+      connection_request_id: responseSequenceNumber
+    });
+    return response.result;
+  }
+  async recordOutboundConnectionConfirmation({
+    outboundTopicId,
+    connectionRequestId,
+    confirmedRequestId,
+    connectionTopicId,
+    operatorId,
+    memo
+  }) {
+    const payload = {
+      p: "hcs-10",
+      op: "connection_created",
+      connection_topic_id: connectionTopicId,
+      outbound_topic_id: outboundTopicId,
+      confirmed_request_id: confirmedRequestId,
+      connection_request_id: connectionRequestId,
+      operator_id: operatorId,
+      m: memo
+    };
+    return await this.submitPayload(outboundTopicId, payload);
+  }
+  async getPublicKey(accountId) {
+    return await this.mirrorNode.getPublicKey(accountId);
+  }
+  async handleConnectionRequest(inboundTopicId, requestingAccountId, connectionId, connectionMemo = "Connection accepted. Looking forward to collaborating!") {
+    this.logger.info("Handling connection request");
+    const userAccountId = this.hwc.getAccountInfo().accountId;
+    if (!userAccountId) {
+      throw new Error("Failed to retrieve user account ID");
+    }
+    const requesterKey = await this.mirrorNode.getPublicKey(
+      requestingAccountId
+    );
+    const accountKey = await this.mirrorNode.getPublicKey(userAccountId);
+    if (!accountKey) {
+      throw new Error("Failed to retrieve public key");
+    }
+    const thresholdKey = new KeyList([accountKey, requesterKey], 1);
+    const memo = `hcs-10:${inboundTopicId}:${connectionId}`;
+    const transaction = new TopicCreateTransaction().setTopicMemo(memo).setAdminKey(thresholdKey).setSubmitKey(thresholdKey);
+    this.logger.debug("Executing topic creation transaction");
+    const receipt = await this.hwc.executeTransactionWithErrorHandling(
+      transaction,
+      false
+    );
+    if (receipt.error) {
+      this.logger.error(receipt.error);
+      throw new Error(receipt.error);
+    }
+    const result = receipt.result;
+    if (!(result == null ? void 0 : result.topicId)) {
+      this.logger.error("Failed to create topic: topicId is null");
+      throw new Error("Failed to create topic: topicId is null");
+    }
+    const connectionTopicId = result.topicId.toString();
+    const operatorId = `${inboundTopicId}@${userAccountId}`;
+    const confirmedConnectionSequenceNumber = await this.confirmConnection(
+      inboundTopicId,
+      connectionTopicId,
+      requestingAccountId,
+      connectionId,
+      operatorId,
+      connectionMemo
+    );
+    return {
+      connectionTopicId,
+      confirmedConnectionSequenceNumber,
+      operatorId
+    };
+  }
+  async confirmConnection(inboundTopicId, connectionTopicId, connectedAccountId, connectionId, operatorId, memo) {
+    var _a;
+    this.logger.info("Confirming connection");
+    const payload = {
+      p: "hcs-10",
+      op: "connection_created",
+      connection_topic_id: connectionTopicId,
+      connected_account_id: connectedAccountId,
+      operator_id: operatorId,
+      connection_id: connectionId,
+      m: memo
+    };
+    const transactionResponse = await this.submitPayload(
+      inboundTopicId,
+      payload
+    );
+    if (!((_a = transactionResponse == null ? void 0 : transactionResponse.result) == null ? void 0 : _a.topicSequenceNumber)) {
+      this.logger.error(
+        "Failed to confirm connection: sequence number is null"
+      );
+      throw new Error("Failed to confirm connection: sequence number is null");
+    }
+    return transactionResponse.result.topicSequenceNumber.toNumber();
+  }
+  async submitMessage(topicId, content, metadata = {}, memo = "") {
+    this.logger.info("Submitting message");
+    const payload = {
+      p: "hcs-10",
+      op: "message",
+      data: {
+        content,
+        metadata
+      },
+      m: memo
+    };
+    return await this.submitPayload(topicId, payload);
+  }
+  async createAgent(pfpBuffer, pfpFileName, agentName, agentDescription, capabilities, metadata) {
+    try {
+      const outboundTopicResult = await this.createTopic(
+        "hcs-10:0:60:1",
+        true,
+        true
+      );
+      if (!outboundTopicResult.success || !outboundTopicResult.topicId) {
+        return {
+          outboundTopicId: "",
+          inboundTopicId: "",
+          pfpTopicId: "",
+          profileTopicId: "",
+          error: outboundTopicResult.error || "Failed to create outbound topic",
+          success: false
+        };
+      }
+      const inboundTopicResult = await this.createTopic(
+        `hcs-10:0:60:0:${outboundTopicResult.topicId}`
+      );
+      if (!inboundTopicResult.success || !inboundTopicResult.topicId) {
+        return {
+          outboundTopicId: outboundTopicResult.topicId,
+          inboundTopicId: "",
+          pfpTopicId: "",
+          profileTopicId: "",
+          error: inboundTopicResult.error || "Failed to create inbound topic",
+          success: false
+        };
+      }
+      const pfpResult = await this.inscribePfp(pfpBuffer, pfpFileName);
+      if (!pfpResult.success) {
+        return {
+          outboundTopicId: outboundTopicResult.topicId,
+          inboundTopicId: inboundTopicResult.topicId,
+          pfpTopicId: "",
+          profileTopicId: "",
+          error: pfpResult.error || "Failed to inscribe profile picture",
+          success: false
+        };
+      }
+      const profileResult = await this.storeHCS11Profile(
+        agentName,
+        agentDescription,
+        inboundTopicResult.topicId,
+        outboundTopicResult.topicId,
+        capabilities,
+        metadata,
+        pfpBuffer,
+        pfpFileName
+      );
+      if (!profileResult.success) {
+        return {
+          outboundTopicId: outboundTopicResult.topicId,
+          inboundTopicId: inboundTopicResult.topicId,
+          pfpTopicId: pfpResult.pfpTopicId,
+          profileTopicId: "",
+          error: profileResult.error || "Failed to store profile",
+          success: false
+        };
+      }
+      return {
+        outboundTopicId: outboundTopicResult.topicId,
+        inboundTopicId: inboundTopicResult.topicId,
+        pfpTopicId: pfpResult.pfpTopicId,
+        profileTopicId: profileResult.profileTopicId,
+        success: true
+      };
+    } catch (error) {
+      return {
+        outboundTopicId: "",
+        inboundTopicId: "",
+        pfpTopicId: "",
+        profileTopicId: "",
+        error: error.message,
+        success: false
+      };
+    }
+  }
+  async createAndRegisterAgent(name, description, capabilities, metadata, pfpBuffer, pfpFileName, network) {
+    const { accountId } = this.getAccountAndSigner();
+    const {
+      outboundTopicId,
+      inboundTopicId,
+      pfpTopicId,
+      profileTopicId,
+      error,
+      success
+    } = await this.createAgent(
+      pfpBuffer,
+      pfpFileName,
+      name,
+      description,
+      capabilities,
+      metadata
+    );
+    if (!success || error) {
+      throw new Error(error || "Failed to create agent");
+    }
+    const operatorId = `${inboundTopicId}@${accountId}`;
+    await this.registerAgentWithGuardedRegistry(
+      accountId,
+      inboundTopicId,
+      network
+    );
+    return {
+      accountId,
+      operatorId,
+      inboundTopicId,
+      outboundTopicId,
+      profileTopicId,
+      pfpTopicId,
+      client: this
+    };
+  }
+  async registerAgentWithGuardedRegistry(accountId, inboundTopicId, network = this.network, maxAttempts = 60, delayMs = 2e3) {
+    try {
+      this.logger.info("Registering agent with guarded registry");
+      const registrationResult = await this.executeRegistration(
+        accountId,
+        inboundTopicId,
+        network,
+        this.guardedRegistryBaseUrl,
+        this.logger
+      );
+      if (!registrationResult.success) {
+        return registrationResult;
+      }
+      if (registrationResult.transaction) {
+        const transaction = Transaction.fromBytes(
+          Buffer2.from(registrationResult.transaction, "base64")
+        );
+        this.logger.info(`Processing registration transaction`);
+        const txResult = await this.hwc.executeTransactionWithErrorHandling(
+          transaction,
+          false
+        );
+        if (txResult.error) {
+          return {
+            ...registrationResult,
+            error: txResult.error,
+            success: false
+          };
+        }
+        this.logger.info(`Successfully processed registration transaction`);
+      }
+      const confirmed = await this.waitForRegistrationConfirmation(
+        registrationResult.transactionId,
+        network,
+        this.guardedRegistryBaseUrl,
+        maxAttempts,
+        delayMs
+      );
+      return {
+        ...registrationResult,
+        confirmed
+      };
+    } catch (error) {
+      return {
+        error: `Error during registration: ${error.message}`,
+        success: false
+      };
+    }
+  }
+  async storeHCS11Profile(agentName, agentDescription, inboundTopicId, outboundTopicId, capabilities = [], metadata = {}, pfpBuffer, pfpFileName) {
+    try {
+      let pfpTopicId;
+      if (pfpBuffer && pfpFileName) {
+        const pfpResult = await this.inscribePfp(pfpBuffer, pfpFileName);
+        if (!pfpResult.success) {
+          this.logger.error(
+            "Failed to inscribe profile picture, continuing without PFP"
+          );
+        } else {
+          pfpTopicId = pfpResult.pfpTopicId;
+        }
+      }
+      const agentType = this.hcs11Client.getAgentTypeFromMetadata({
+        type: metadata.type || "autonomous"
+      });
+      const formattedSocials = [];
+      if (metadata.socials) {
+        if (metadata.socials.twitter) {
+          formattedSocials.push({
+            platform: "twitter",
+            handle: metadata.socials.twitter
+          });
+        }
+        if (metadata.socials.discord) {
+          formattedSocials.push({
+            platform: "discord",
+            handle: metadata.socials.discord
+          });
+        }
+        if (metadata.socials.github) {
+          formattedSocials.push({
+            platform: "github",
+            handle: metadata.socials.github
+          });
+        }
+        if (metadata.socials.website) {
+          formattedSocials.push({
+            platform: "website",
+            handle: metadata.socials.website
+          });
+        }
+        if (metadata.socials.x) {
+          formattedSocials.push({
+            platform: "twitter",
+            handle: metadata.socials.x
+          });
+        }
+        if (metadata.socials.linkedin) {
+          formattedSocials.push({
+            platform: "linkedin",
+            handle: metadata.socials.linkedin
+          });
+        }
+        if (metadata.socials.youtube) {
+          formattedSocials.push({
+            platform: "youtube",
+            handle: metadata.socials.youtube
+          });
+        }
+        if (metadata.socials.telegram) {
+          formattedSocials.push({
+            platform: "telegram",
+            handle: metadata.socials.telegram
+          });
+        }
+      }
+      const profile = this.hcs11Client.createAIAgentProfile(
+        agentName,
+        agentType,
+        capabilities,
+        metadata.model || "unknown",
+        {
+          alias: agentName.toLowerCase().replace(/\s+/g, "_"),
+          bio: agentDescription,
+          profileImage: pfpTopicId ? `hcs://1/${pfpTopicId}` : void 0,
+          socials: formattedSocials.length > 0 ? formattedSocials : void 0,
+          properties: {
+            description: agentDescription,
+            version: metadata.version || "1.0.0",
+            creator: metadata.creator || "Unknown",
+            supported_languages: metadata.supported_languages || ["en"],
+            permissions: metadata.permissions || [],
+            model_details: metadata.model_details,
+            training: metadata.training,
+            capabilities_description: metadata.capabilities_description,
+            ...metadata
+          },
+          inboundTopicId,
+          outboundTopicId,
+          creator: metadata.creator
+        }
+      );
+      const profileResult = await this.hcs11Client.createAndInscribeProfile(
+        profile,
+        true
+      );
+      if (!profileResult.success) {
+        return {
+          profileTopicId: "",
+          success: false,
+          error: profileResult.error || "Failed to inscribe profile"
+        };
+      }
+      return {
+        profileTopicId: profileResult.profileTopicId,
+        pfpTopicId,
+        success: true
+      };
+    } catch (error) {
+      return {
+        profileTopicId: "",
+        success: false,
+        error: error.message
+      };
+    }
+  }
+  async createTopic(memo, adminKey, submitKey) {
+    this.logger.info("Creating topic");
+    const { accountId, signer } = this.getAccountAndSigner();
+    const transaction = new TopicCreateTransaction().setTopicMemo(memo);
+    const publicKey = await this.mirrorNode.getPublicKey(accountId);
+    if (adminKey && publicKey) {
+      transaction.setAdminKey(publicKey);
+      transaction.setAutoRenewAccountId(accountId);
+    }
+    if (submitKey && publicKey) {
+      transaction.setSubmitKey(publicKey);
+    }
+    const transactionResponse = await this.hwc.executeTransactionWithErrorHandling(
+      transaction,
+      false
+    );
+    const error = transactionResponse.error;
+    if (error) {
+      this.logger.error(error);
+      return {
+        success: false,
+        error
+      };
+    }
+    const result = transactionResponse.result;
+    if (!(result == null ? void 0 : result.topicId)) {
+      this.logger.error("Failed to create topic: topicId is null");
+      return {
+        success: false,
+        error: "Failed to create topic: topicId is null"
+      };
+    }
+    return {
+      success: true,
+      topicId: result.topicId.toString()
+    };
+  }
+  async submitPayload(topicId, payload) {
+    this.logger.debug("Submitting payload");
+    const transaction = new TopicMessageSubmitTransaction().setTopicId(topicId).setMessage(JSON.stringify(payload));
+    return await this.hwc.executeTransactionWithErrorHandling(
+      // @ts-ignore
+      transaction,
+      false
+    );
+  }
+  async inscribeFile(buffer2, fileName) {
+    const { accountId, signer } = this.getAccountAndSigner();
+    const mimeType = mimeTypes.lookup(fileName) || "application/octet-stream";
+    const sdk = await InscriptionSDK.createWithAuth({
+      type: "client",
+      accountId,
+      signer,
+      network: this.network
+    });
+    const result = await sdk.inscribe(
+      {
+        file: {
+          type: "base64",
+          base64: buffer2.toString("base64"),
+          fileName,
+          mimeType
+        },
+        holderId: accountId.toString(),
+        mode: "file",
+        network: this.network
+      },
+      signer
+    );
+    if (!result.transactionId || !result.jobId) {
+      this.logger.error("Failed to inscribe, no transaction ID or job ID.");
+      throw new Error("Failed to inscribe, no transaction ID or job ID.");
+    }
+    if (result.transactionId && result.jobId) {
+      this.logger.info(
+        `Transaction ID: ${result.transactionId}, Job ID: ${result.jobId}`
+      );
+    }
+    const status = await sdk.waitForInscription(result.jobId, 30, 4e3, true);
+    return status;
+  }
+  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) {
+      this.logger.error("Failed to find signer");
+      throw new Error("Failed to find signer");
+    }
+    return { accountId, signer };
+  }
+  /**
+   * Inscribes a profile picture file to the Hedera network
+   * @param buffer File buffer to inscribe
+   * @param fileName Filename for the inscription
+   * @returns Object containing the topic ID and success status
+   */
+  async inscribePfp(buffer2, fileName) {
+    try {
+      this.logger.info("Inscribing profile picture using HCS-11 client");
+      const imageResult = await this.hcs11Client.inscribeImage(
+        buffer2,
+        fileName
+      );
+      if (!imageResult.success) {
+        this.logger.error(
+          `Failed to inscribe profile picture: ${imageResult.error}`
+        );
+        return {
+          pfpTopicId: "",
+          success: false,
+          error: imageResult.error || "Failed to inscribe profile picture"
+        };
+      }
+      this.logger.info(
+        `Successfully inscribed profile picture with topic ID: ${imageResult.imageTopicId}`
+      );
+      return {
+        pfpTopicId: imageResult.imageTopicId,
+        success: true
+      };
+    } catch (error) {
+      this.logger.error(`Error inscribing profile picture: ${error.message}`);
+      return {
+        pfpTopicId: "",
+        success: false,
+        error: error.message
+      };
+    }
+  }
+}
 export {
   AIAgentCapability,
   AIAgentType,
   AccountCreationError,
   AgentBuilder,
+  BrowserHCSClient,
   ConnectionConfirmationError,
   EVMBridge,
   EndpointType,