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

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

@@ -1,925 +1,137 @@
-import { Client, Status, PrivateKey, AccountUpdateTransaction } from "@hashgraph/sdk";
-import { inscribeWithSigner, inscribe } from "./standards-sdk.es125.js";
-import "./standards-sdk.es150.js";
-import { Logger } from "./standards-sdk.es106.js";
-import { HederaMirrorNode } from "./standards-sdk.es127.js";
-import { ProgressReporter } from "./standards-sdk.es109.js";
-import "axios";
-import "./standards-sdk.es128.js";
-import "./standards-sdk.es129.js";
-import "./standards-sdk.es130.js";
-import "./standards-sdk.es131.js";
-import "./standards-sdk.es132.js";
-import "./standards-sdk.es133.js";
-import "./standards-sdk.es134.js";
-import "./standards-sdk.es135.js";
-import "buffer";
-import "crypto";
-import "@noble/curves/secp256k1.js";
-import { z } from "zod";
-import "./standards-sdk.es149.js";
-import "./standards-sdk.es139.js";
-import "@hashgraph/proto";
-import "ethers";
-import "./standards-sdk.es123.js";
-import "./standards-sdk.es114.js";
-import { getTopicId } from "./standards-sdk.es115.js";
-import * as mime from "mime-types";
-import { isHederaNetwork, toHederaCaip10 } from "./standards-sdk.es58.js";
-import { createNodeOperatorContext } from "./standards-sdk.es147.js";
-import { AIAgentCapability, AIAgentType, VerificationType, MCPServerCapability, ProfileType, capabilityNameToCapabilityMap } from "./standards-sdk.es29.js";
-const SocialLinkSchema = z.object({
-  platform: z.string().min(1),
-  handle: z.string().min(1)
-});
-const AIAgentDetailsSchema = z.object({
-  type: z.nativeEnum(AIAgentType),
-  capabilities: z.array(z.nativeEnum(AIAgentCapability)).min(1),
-  model: z.string().min(1),
-  creator: z.string().optional()
-});
-const MCPServerConnectionInfoSchema = z.object({
-  url: z.string().min(1),
-  transport: z.enum(["stdio", "sse"])
-});
-const MCPServerVerificationSchema = z.object({
-  type: z.nativeEnum(VerificationType),
-  value: z.string(),
-  dns_field: z.string().optional(),
-  challenge_path: z.string().optional()
-});
-const MCPServerHostSchema = z.object({
-  minVersion: z.string().optional()
-});
-const MCPServerResourceSchema = z.object({
-  name: z.string().min(1),
-  description: z.string().min(1)
-});
-const MCPServerToolSchema = z.object({
-  name: z.string().min(1),
-  description: z.string().min(1)
-});
-const MCPServerDetailsSchema = z.object({
-  version: z.string().min(1),
-  connectionInfo: MCPServerConnectionInfoSchema,
-  services: z.array(z.nativeEnum(MCPServerCapability)).min(1),
-  description: z.string().min(1),
-  verification: MCPServerVerificationSchema.optional(),
-  host: MCPServerHostSchema.optional(),
-  capabilities: z.array(z.string()).optional(),
-  resources: z.array(MCPServerResourceSchema).optional(),
-  tools: z.array(MCPServerToolSchema).optional(),
-  maintainer: z.string().optional(),
-  repository: z.string().optional(),
-  docs: z.string().optional()
-});
-const BaseProfileSchema = z.object({
-  version: z.string().min(1),
-  type: z.nativeEnum(ProfileType),
-  display_name: z.string().min(1),
-  alias: z.string().optional(),
-  bio: z.string().optional(),
-  socials: z.array(SocialLinkSchema).optional(),
-  profileImage: z.string().optional(),
-  uaid: z.string().optional(),
-  properties: z.record(z.any()).optional(),
-  inboundTopicId: z.string().optional(),
-  outboundTopicId: z.string().optional(),
-  base_account: z.string().optional()
-});
-const PersonalProfileSchema = BaseProfileSchema.extend({
-  type: z.literal(ProfileType.PERSONAL),
-  language: z.string().optional(),
-  timezone: z.string().optional()
-});
-const AIAgentProfileSchema = BaseProfileSchema.extend({
-  type: z.literal(ProfileType.AI_AGENT),
-  aiAgent: AIAgentDetailsSchema
-});
-const MCPServerProfileSchema = BaseProfileSchema.extend({
-  type: z.literal(ProfileType.MCP_SERVER),
-  mcpServer: MCPServerDetailsSchema
-});
-const FloraProfileSchema = z.object({
-  version: z.string(),
-  type: z.literal(ProfileType.FLORA),
-  display_name: z.string().min(1),
-  members: z.array(
-    z.object({
-      accountId: z.string(),
-      publicKey: z.string().optional(),
-      weight: z.number().optional()
-    })
-  ),
-  threshold: z.number().min(1),
-  topics: z.object({
-    communication: z.string(),
-    transaction: z.string(),
-    state: z.string()
-  }),
-  inboundTopicId: z.string(),
-  outboundTopicId: z.string(),
-  bio: z.string().optional(),
-  metadata: z.record(z.any()).optional(),
-  policies: z.record(z.any()).optional()
-});
-const HCS11ProfileSchema = z.union([
-  PersonalProfileSchema,
-  AIAgentProfileSchema,
-  MCPServerProfileSchema,
-  FloraProfileSchema
-]);
-class HCS11Client {
-  constructor(config) {
-    this.client = config.network === "mainnet" ? Client.forMainnet() : Client.forTestnet();
-    this.auth = config.auth;
-    this.network = config.network;
-    this.operatorId = config.auth.operatorId;
-    this.logger = Logger.getInstance({
-      level: config.logLevel || "info",
-      module: "HCS-11",
-      silent: config.silent
-    });
-    this.mirrorNode = new HederaMirrorNode(
-      this.network,
-      this.logger
-    );
-    if (this.auth.privateKey) {
-      this.operatorCtx = createNodeOperatorContext({
-        network: this.network,
-        operatorId: this.operatorId,
-        operatorKey: this.auth.privateKey,
-        keyType: config.keyType,
-        mirrorNode: this.mirrorNode,
-        logger: this.logger,
-        client: this.client
-      });
-      this.client = this.operatorCtx.client;
-      this.keyType = this.operatorCtx.keyType;
-      void this.operatorCtx.ensureInitialized();
-      this.client.setOperator(
-        this.operatorId.toString(),
-        this.operatorCtx.operatorKey
-      );
-    } else {
-      this.keyType = config.keyType || "ed25519";
-    }
-  }
-  getClient() {
-    return this.client;
-  }
-  getOperatorId() {
-    return this.auth.operatorId;
-  }
-  async initializeOperator() {
-    if (!this.operatorCtx) {
-      return;
-    }
-    try {
-      await this.operatorCtx.ensureInitialized();
-      this.keyType = this.operatorCtx.keyType;
-      this.client.setOperator(this.operatorId, this.operatorCtx.operatorKey);
-    } catch (error) {
-      this.logger.warn(
-        `Failed to verify operator key with mirror node: ${error.message}`
-      );
-    }
-  }
-  createPersonalProfile(displayName, options) {
-    return {
-      version: "1.0",
-      type: ProfileType.PERSONAL,
-      display_name: displayName,
-      alias: options?.alias,
-      bio: options?.bio,
-      socials: options?.socials,
-      profileImage: options?.profileImage,
-      properties: options?.properties,
-      inboundTopicId: options?.inboundTopicId,
-      outboundTopicId: options?.outboundTopicId,
-      base_account: options?.baseAccount
-    };
-  }
-  createAIAgentProfile(displayName, agentType, capabilities, model, options) {
-    const validation = this.validateProfile({
-      version: "1.0",
-      type: ProfileType.AI_AGENT,
-      display_name: displayName,
-      alias: options?.alias,
-      bio: options?.bio,
-      socials: options?.socials,
-      profileImage: options?.profileImage,
-      properties: options?.properties,
-      inboundTopicId: options?.inboundTopicId,
-      outboundTopicId: options?.outboundTopicId,
-      base_account: options?.baseAccount,
-      aiAgent: {
-        type: agentType,
-        capabilities,
-        model,
-        creator: options?.creator
-      }
-    });
-    if (!validation.valid) {
-      throw new Error(
-        `Invalid AI Agent Profile: ${validation.errors.join(", ")}`
-      );
-    }
-    return {
-      version: "1.0",
-      type: ProfileType.AI_AGENT,
-      display_name: displayName,
-      alias: options?.alias,
-      bio: options?.bio,
-      socials: options?.socials,
-      profileImage: options?.profileImage,
-      properties: options?.properties,
-      inboundTopicId: options?.inboundTopicId,
-      outboundTopicId: options?.outboundTopicId,
-      base_account: options?.baseAccount,
-      aiAgent: {
-        type: agentType,
-        capabilities,
-        model,
-        creator: options?.creator
-      }
-    };
-  }
-  /**
-   * Creates an MCP server profile.
-   *
-   * @param displayName - The display name for the MCP server
-   * @param serverDetails - The MCP server details
-   * @param options - Additional profile options
-   * @returns An MCPServerProfile object
-   */
-  createMCPServerProfile(displayName, serverDetails, options) {
-    const validation = this.validateProfile({
-      version: "1.0",
-      type: ProfileType.MCP_SERVER,
-      display_name: displayName,
-      alias: options?.alias,
-      bio: options?.bio,
-      socials: options?.socials,
-      profileImage: options?.profileImage,
-      properties: options?.properties,
-      inboundTopicId: options?.inboundTopicId,
-      outboundTopicId: options?.outboundTopicId,
-      mcpServer: serverDetails
-    });
-    if (!validation.valid) {
-      throw new Error(
-        `Invalid MCP Server Profile: ${validation.errors.join(", ")}`
-      );
-    }
-    return {
-      version: "1.0",
-      type: ProfileType.MCP_SERVER,
-      display_name: displayName,
-      alias: options?.alias,
-      bio: options?.bio,
-      socials: options?.socials,
-      profileImage: options?.profileImage,
-      properties: options?.properties,
-      inboundTopicId: options?.inboundTopicId,
-      outboundTopicId: options?.outboundTopicId,
-      mcpServer: serverDetails
-    };
-  }
-  validateProfile(profile) {
-    const result = HCS11ProfileSchema.safeParse(profile);
-    if (result.success) {
-      return { valid: true, errors: [] };
-    }
-    const formattedErrors = result.error.errors.map((err) => {
-      const path = err.path.join(".");
-      let message = err.message;
-      if (err.code === "invalid_type") {
-        message = `Expected ${err.expected}, got ${err.received}`;
-      } else if (err.code === "invalid_enum_value") {
-        const validOptions = err.options?.join(", ");
-        message = `Invalid value. Valid options are: ${validOptions}`;
-      } else if (err.code === "too_small" && err.type === "string") {
-        message = "Cannot be empty";
-      }
-      return `${path}: ${message}`;
-    });
-    return { valid: false, errors: formattedErrors };
-  }
-  profileToJSONString(profile) {
-    return JSON.stringify(profile);
-  }
-  parseProfileFromString(profileStr) {
-    try {
-      const parsedProfile = JSON.parse(profileStr);
-      const validation = this.validateProfile(parsedProfile);
-      if (!validation.valid) {
-        this.logger.error("Invalid profile format:", validation.errors);
-        return null;
-      }
-      return parsedProfile;
-    } catch (error) {
-      this.logger.error("Error parsing profile:");
-      return null;
-    }
-  }
-  setProfileForAccountMemo(topicId, topicStandard = 1) {
-    return `hcs-11:hcs://${topicStandard}/${topicId}`;
-  }
-  async executeTransaction(transaction) {
-    try {
-      if (this.auth.privateKey) {
-        const signedTx = await transaction.signWithOperator(this.client);
-        const response2 = await signedTx.execute(this.client);
-        const receipt2 = await response2.getReceipt(this.client);
-        if (receipt2.status.toString() !== Status.Success.toString()) {
-          return {
-            success: false,
-            error: `Transaction failed: ${receipt2.status.toString()}`
-          };
-        }
-        return {
-          success: true,
-          result: receipt2
-        };
-      }
-      if (!this.auth.signer) {
-        throw new Error("No valid authentication method provided");
-      }
-      const signer = this.auth.signer;
-      const frozenTransaction = await transaction.freezeWithSigner(signer);
-      const response = await frozenTransaction.executeWithSigner(signer);
-      const receipt = await response.getReceiptWithSigner(signer);
-      if (receipt.status.toString() !== Status.Success.toString()) {
-        return {
-          success: false,
-          error: `Transaction failed: ${receipt.status.toString()}: ${Status.Success.toString()}`
-        };
-      }
-      return {
-        success: true,
-        result: receipt
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error during transaction execution"
-      };
-    }
-  }
-  async inscribeImage(buffer, fileName, options) {
-    try {
-      const progressCallback = options?.progressCallback;
-      const progressReporter = new ProgressReporter({
-        module: "HCS11-Image",
-        logger: this.logger,
-        callback: progressCallback
-      });
-      progressReporter.preparing("Preparing to inscribe image", 0);
-      const mimeType = mime.lookup(fileName) || "application/octet-stream";
-      const waitForConfirmation = options?.waitForConfirmation ?? true;
-      let inscriptionResponse;
-      if (this.auth.signer) {
-        if ("accountId" in this.auth.signer) {
-          progressReporter.preparing("Using signer for inscription", 10);
-          inscriptionResponse = await inscribeWithSigner(
-            {
-              type: "buffer",
-              buffer,
-              fileName,
-              mimeType
-            },
-            this.auth.signer,
-            {
-              network: this.network,
-              waitForConfirmation,
-              waitMaxAttempts: 150,
-              waitIntervalMs: 4e3,
-              logging: {
-                level: "debug"
-              },
-              progressCallback: (data) => {
-                const adjustedPercent = 10 + (data.progressPercent || 0) * 0.8;
-                progressReporter.report({
-                  stage: data.stage,
-                  message: data.message,
-                  progressPercent: adjustedPercent,
-                  details: data.details
-                });
-              }
-            }
-          );
-        } else {
-          progressReporter.failed(
-            "Signer must be a DAppSigner for inscription"
-          );
-          throw new Error("Signer must be a DAppSigner for inscription");
-        }
-      } else {
-        if (!this.auth.privateKey) {
-          progressReporter.failed("Private key is required for inscription");
-          this.logger.error("Private key is required for inscription");
-          throw new Error("Private key is required for inscription");
-        }
-        progressReporter.preparing("Using private key for inscription", 10);
-        const PK = this.keyType === "ecdsa" ? PrivateKey.fromStringECDSA(this.auth.privateKey) : PrivateKey.fromStringED25519(this.auth.privateKey);
-        inscriptionResponse = await inscribe(
-          {
-            type: "buffer",
-            buffer,
-            fileName,
-            mimeType
-          },
-          {
-            accountId: this.auth.operatorId,
-            privateKey: PK,
-            network: this.network
-          },
-          {
-            waitForConfirmation,
-            waitMaxAttempts: 150,
-            waitIntervalMs: 2e3,
-            logging: {
-              level: "debug"
-            },
-            progressCallback: (data) => {
-              const adjustedPercent = 10 + (data.progressPercent || 0) * 0.8;
-              progressReporter.report({
-                stage: data.stage,
-                message: data.message,
-                progressPercent: adjustedPercent,
-                details: data.details
-              });
-            }
-          }
-        );
-      }
-      if (inscriptionResponse.confirmed) {
-        progressReporter.completed("Image inscription completed", {
-          topicId: getTopicId(inscriptionResponse.inscription)
-        });
-        return {
-          imageTopicId: getTopicId(inscriptionResponse.inscription) || "",
-          transactionId: inscriptionResponse.result.jobId,
-          success: true
-        };
-      } else {
-        const jobId = inscriptionResponse.quote ? "quote-only" : inscriptionResponse.result.jobId;
-        progressReporter.verifying("Waiting for inscription confirmation", 50, {
-          jobId
-        });
-        return {
-          imageTopicId: "",
-          transactionId: jobId,
-          success: false,
-          error: "Inscription not confirmed"
-        };
-      }
-    } catch (error) {
-      this.logger.error("Error inscribing image:", error);
-      return {
-        imageTopicId: "",
-        transactionId: "",
-        success: false,
-        error: error instanceof Error ? error.message : "Error inscribing image"
-      };
-    }
-  }
-  async inscribeProfile(profile, options) {
-    this.logger.info("Inscribing HCS-11 profile");
-    const progressCallback = options?.progressCallback;
-    const progressReporter = new ProgressReporter({
-      module: "HCS11-Profile",
-      logger: this.logger,
-      callback: progressCallback
-    });
-    await this.attachUaidIfMissing(profile);
-    progressReporter.preparing("Validating profile data", 5);
-    const validation = this.validateProfile(profile);
-    if (!validation.valid) {
-      progressReporter.failed(
-        `Invalid profile: ${validation.errors.join(", ")}`
-      );
-      return {
-        profileTopicId: "",
-        transactionId: "",
-        success: false,
-        error: `Invalid profile: ${validation.errors.join(", ")}`
-      };
-    }
-    progressReporter.preparing("Formatting profile for inscription", 15);
-    const profileJson = this.profileToJSONString(profile);
-    const fileName = `profile-${profile.display_name.toLowerCase().replace(/\s+/g, "-")}.json`;
-    try {
-      const contentBuffer = Buffer.from(profileJson, "utf-8");
-      const contentType = "application/json";
-      progressReporter.preparing("Preparing profile for inscription", 20);
-      const input = {
-        type: "buffer",
-        buffer: contentBuffer,
-        fileName,
-        mimeType: contentType
-      };
-      const inscriptionOptions = {
-        waitForConfirmation: true,
-        mode: "file",
-        network: this.network,
-        waitMaxAttempts: 100,
-        waitIntervalMs: 2e3,
-        progressCallback: (data) => {
-          const adjustedPercent = 20 + Number(data?.progressPercent || 0) * 0.75;
-          progressReporter?.report({
-            stage: data.stage,
-            message: data.message,
-            progressPercent: adjustedPercent,
-            details: data.details
-          });
-        }
-      };
-      progressReporter.submitting("Submitting profile to Hedera network", 30);
-      let inscriptionResponse;
-      if (this.auth.privateKey) {
-        const PK = this.keyType === "ecdsa" ? PrivateKey.fromStringECDSA(this.auth.privateKey) : PrivateKey.fromStringED25519(this.auth.privateKey);
-        inscriptionResponse = await inscribe(
-          input,
-          {
-            accountId: this.auth.operatorId,
-            privateKey: PK,
-            network: this.network
-          },
-          inscriptionOptions
-        );
-      } else if (this.auth.signer) {
-        inscriptionResponse = await inscribeWithSigner(
-          input,
-          this.auth.signer,
-          inscriptionOptions
-        );
-      } else {
-        throw new Error(
-          "No authentication method available - neither private key nor signer"
-        );
-      }
-      if (!inscriptionResponse.confirmed || !getTopicId(inscriptionResponse.inscription)) {
-        progressReporter.failed("Failed to inscribe profile content");
-        return {
-          profileTopicId: "",
-          transactionId: "",
-          success: false,
-          error: "Failed to inscribe profile content"
-        };
-      }
-      const topicId = getTopicId(inscriptionResponse.inscription);
-      progressReporter.completed("Profile inscription completed", {
-        topicId,
-        transactionId: inscriptionResponse.result.transactionId
-      });
-      return {
-        profileTopicId: topicId,
-        transactionId: inscriptionResponse.result.transactionId,
-        success: true,
-        totalCostHbar: inscriptionResponse.costSummary?.totalCostHbar
-      };
-    } catch (error) {
-      progressReporter.failed(
-        `Error inscribing profile: ${error.message || "Unknown error"}`
-      );
-      return {
-        profileTopicId: "",
-        transactionId: "",
-        success: false,
-        error: error.message || "Unknown error during inscription"
-      };
-    }
-  }
-  async attachUaidIfMissing(profile) {
-    if (profile.uaid) {
-      return;
-    }
-    if (!isHederaNetwork(this.network)) {
-      return;
-    }
-    try {
-      const { HCS14Client } = await import("./standards-sdk.es146.js");
-      const hcs14 = new HCS14Client({ client: this.client });
-      const did = await hcs14.createDid({
-        method: "hedera",
-        client: this.client
-      });
-      const nativeId = toHederaCaip10(this.network, this.auth.operatorId);
-      let uid = this.auth.operatorId;
-      const inboundFromProfile = profile.inboundTopicId;
-      if (inboundFromProfile && inboundFromProfile.trim().length > 0) {
-        uid = `${inboundFromProfile}@${this.auth.operatorId}`;
-      } else {
-        try {
-          const fetched = await this.fetchProfileByAccountId(
-            this.auth.operatorId,
-            this.network
-          );
-          const inbound = fetched?.topicInfo?.inboundTopic;
-          if (inbound && inbound.trim().length > 0) {
-            uid = `${inbound}@${this.auth.operatorId}`;
-          }
-        } catch {
-        }
-      }
-      const uaid = hcs14.createUaid(did, { proto: "hcs-10", nativeId, uid });
-      profile.uaid = uaid;
-    } catch (e) {
-      this.logger.warn(
-        "Hiero registrar not available; skipping UAID generation for profile",
-        e
-      );
-    }
-  }
-  async updateAccountMemoWithProfile(accountId, profileTopicId, signerKeys) {
-    try {
-      this.logger.info(
-        `Updating account memo for ${accountId} with profile ${profileTopicId}`
-      );
-      const memo = this.setProfileForAccountMemo(profileTopicId);
-      const transaction = new AccountUpdateTransaction().setAccountMemo(memo).setAccountId(accountId);
-      if (signerKeys && signerKeys.length > 0) {
-        const frozen = await transaction.freezeWith(this.client);
-        let signed = frozen;
-        for (const key of signerKeys) {
-          signed = await signed.sign(key);
-        }
-        const response = await signed.execute(this.client);
-        const receipt = await response.getReceipt(this.client);
-        if (receipt.status.toString() !== Status.Success.toString()) {
-          return {
-            success: false,
-            error: `Transaction failed: ${receipt.status.toString()}`
-          };
-        }
-        return {
-          success: true,
-          result: receipt
-        };
-      }
-      return this.executeTransaction(transaction);
-    } catch (error) {
-      this.logger.error(
-        `Error updating account memo: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error updating account memo"
-      };
-    }
-  }
-  /**
-   * Creates and inscribes a profile.
-   *
-   * @param profile - The profile to create and inscribe.
-   * @param updateAccountMemo - Whether to update the account memo with the profile.
-   * @param options - Optional configuration options.
-   * @returns A promise that resolves to the inscription result.
-   */
-  async createAndInscribeProfile(profile, updateAccountMemo = true, options) {
-    const progressCallback = options?.progressCallback;
-    const progressReporter = new ProgressReporter({
-      module: "HCS11-ProfileCreation",
-      logger: this.logger,
-      callback: progressCallback
-    });
-    progressReporter.preparing("Starting profile creation process", 0);
-    const inscriptionProgress = progressReporter.createSubProgress({
-      minPercent: 0,
-      maxPercent: 80,
-      logPrefix: "Inscription"
-    });
-    const inscriptionResult = await this.inscribeProfile(profile, {
-      ...options,
-      progressCallback: (data) => {
-        inscriptionProgress.report({
-          stage: data.stage,
-          message: data.message,
-          progressPercent: data.progressPercent,
-          details: data.details
-        });
-      }
-    });
-    if (!inscriptionResult?.success) {
-      progressReporter.failed("Profile inscription failed", {
-        error: inscriptionResult?.error
-      });
-      return inscriptionResult;
-    }
-    progressReporter.confirming("Profile inscribed, updating account memo", 85);
-    if (updateAccountMemo) {
-      const memoResult = await this.updateAccountMemoWithProfile(
-        this.auth.operatorId,
-        inscriptionResult.profileTopicId
-      );
-      if (!memoResult.success) {
-        progressReporter.failed("Failed to update account memo", {
-          error: memoResult?.error
-        });
-        return {
-          ...inscriptionResult,
-          success: false,
-          error: memoResult?.error
-        };
-      }
-    }
-    progressReporter.completed("Profile creation completed successfully", {
-      profileTopicId: inscriptionResult.profileTopicId,
-      transactionId: inscriptionResult.transactionId,
-      totalCostHbar: inscriptionResult.totalCostHbar
-    });
-    return inscriptionResult;
-  }
-  /**
-   * Gets the capabilities from the capability names.
-   *
-   * @param capabilityNames - The capability names to get the capabilities for.
-   * @returns The capabilities.
-   */
-  async getCapabilitiesFromTags(capabilityNames) {
-    const capabilities = [];
-    if (capabilityNames.length === 0) {
-      return [AIAgentCapability.TEXT_GENERATION];
-    }
-    for (const capabilityName of capabilityNames) {
-      const capability = capabilityNameToCapabilityMap[capabilityName.toLowerCase()];
-      if (capability !== void 0 && !capabilities.includes(capability)) {
-        capabilities.push(capability);
-      }
-    }
-    if (capabilities.length === 0) {
-      capabilities.push(AIAgentCapability.TEXT_GENERATION);
-    }
-    return capabilities;
-  }
-  /**
-   * Gets the agent type from the metadata.
-   *
-   * @param metadata - The metadata of the agent.
-   * @returns The agent type.
-   */
-  getAgentTypeFromMetadata(metadata) {
-    if (metadata.type === "autonomous") {
-      return AIAgentType.AUTONOMOUS;
-    } else {
-      return AIAgentType.MANUAL;
-    }
-  }
-  /**
-   * Fetches a profile from the account memo.
-   *
-   * @param accountId - The account ID of the agent to fetch the profile for.
-   * @param network - The network to use for the fetch.
-   * @returns A promise that resolves to the profile.
-   */
-  async fetchProfileByAccountId(accountId, network) {
-    try {
-      this.logger.debug(
-        `Fetching profile for account ${accountId.toString()} on ${this.network}`
-      );
-      const memo = await this.mirrorNode.getAccountMemo(accountId.toString());
-      this.logger.debug(`Got account memo: ${memo}`);
-      if (!memo?.startsWith("hcs-11:")) {
-        return {
-          success: false,
-          error: `Account ${accountId.toString()} does not have a valid HCS-11 memo. Current memo: ${memo || "empty"}`
-        };
-      }
-      this.logger.debug(`Found HCS-11 memo: ${memo}`);
-      const protocolReference = memo.substring(7);
-      if (protocolReference?.startsWith("hcs://")) {
-        const hcsFormat = protocolReference.match(/hcs:\/\/(\d+)\/(.+)/);
-        if (!hcsFormat) {
-          return {
-            success: false,
-            error: `Invalid HCS protocol reference format: ${protocolReference}`
-          };
-        }
-        const [_, protocolId, profileTopicId] = hcsFormat;
-        const networkParam = network || this.network || "mainnet";
-        this.logger.debug(
-          `Retrieving profile from Kiloscribe CDN: ${profileTopicId}`
-        );
-        const cdnUrl = `https://kiloscribe.com/api/inscription-cdn/${profileTopicId}?network=${networkParam}`;
-        try {
-          const response = await fetch(cdnUrl);
-          if (!response.ok) {
-            return {
-              success: false,
-              error: `Failed to fetch profile from Kiloscribe CDN: ${response.statusText}`
-            };
-          }
-          const profileData = await response.json();
-          if (!profileData) {
-            return {
-              success: false,
-              error: `No profile data found for topic ${profileTopicId}`
-            };
-          }
-          const parsed = HCS11ProfileSchema.safeParse(profileData);
-          if (!parsed.success) {
-            return {
-              success: false,
-              error: `Invalid HCS-11 profile data for topic ${profileTopicId}`
-            };
-          }
-          return {
-            success: true,
-            profile: parsed.data,
-            topicInfo: {
-              inboundTopic: parsed.data.inboundTopicId || "",
-              outboundTopic: parsed.data.outboundTopicId || "",
-              profileTopicId
-            }
-          };
-        } catch (cdnError) {
-          this.logger.error(
-            `Error retrieving from Kiloscribe CDN: ${cdnError.message}`
-          );
-          return {
-            success: false,
-            error: `Error retrieving from Kiloscribe CDN: ${cdnError.message}`
-          };
-        }
-      } else if (protocolReference.startsWith("ipfs://")) {
-        this.logger.warn("IPFS protocol references are not fully supported");
-        const response = await fetch(
-          `https://ipfs.io/ipfs/${protocolReference.replace("ipfs://", "")}`
-        );
-        const profileData = await response.json();
-        const parsed = HCS11ProfileSchema.safeParse(profileData);
-        if (!parsed.success) {
-          return {
-            success: false,
-            error: `Invalid HCS-11 profile data from IPFS reference ${protocolReference}`
-          };
-        }
-        return {
-          success: true,
-          profile: parsed.data,
-          topicInfo: {
-            inboundTopic: parsed.data.inboundTopicId || "",
-            outboundTopic: parsed.data.outboundTopicId || "",
-            profileTopicId: ""
-          }
-        };
-      } else if (protocolReference.startsWith("ar://")) {
-        const arTxId = protocolReference.replace("ar://", "");
-        const response = await fetch(`https://arweave.net/${arTxId}`);
-        if (!response.ok) {
-          return {
-            success: false,
-            error: `Failed to fetch profile from Arweave ${arTxId}: ${response.statusText}`
-          };
-        }
-        const profileData = await response.json();
-        const parsed = HCS11ProfileSchema.safeParse(profileData);
-        if (!parsed.success) {
-          return {
-            success: false,
-            error: `Invalid HCS-11 profile data from Arweave reference ${arTxId}`
-          };
-        }
-        return {
-          success: true,
-          profile: parsed.data,
-          topicInfo: {
-            inboundTopic: parsed.data.inboundTopicId || "",
-            outboundTopic: parsed.data.outboundTopicId || "",
-            profileTopicId: ""
-          }
-        };
-      } else {
-        return {
-          success: false,
-          error: `Invalid protocol reference format: ${protocolReference}`
-        };
-      }
-    } catch (error) {
-      this.logger.error(`Error fetching profile: ${error.message}`);
-      return {
-        success: false,
-        error: `Error fetching profile: ${error.message}`
-      };
-    }
-  }
-}
+var ProfileType = /* @__PURE__ */ ((ProfileType2) => {
+  ProfileType2[ProfileType2["PERSONAL"] = 0] = "PERSONAL";
+  ProfileType2[ProfileType2["AI_AGENT"] = 1] = "AI_AGENT";
+  ProfileType2[ProfileType2["MCP_SERVER"] = 2] = "MCP_SERVER";
+  ProfileType2[ProfileType2["FLORA"] = 3] = "FLORA";
+  return ProfileType2;
+})(ProfileType || {});
+var AIAgentType = /* @__PURE__ */ ((AIAgentType2) => {
+  AIAgentType2[AIAgentType2["MANUAL"] = 0] = "MANUAL";
+  AIAgentType2[AIAgentType2["AUTONOMOUS"] = 1] = "AUTONOMOUS";
+  return AIAgentType2;
+})(AIAgentType || {});
+var EndpointType = /* @__PURE__ */ ((EndpointType2) => {
+  EndpointType2[EndpointType2["REST"] = 0] = "REST";
+  EndpointType2[EndpointType2["WEBSOCKET"] = 1] = "WEBSOCKET";
+  EndpointType2[EndpointType2["GRPC"] = 2] = "GRPC";
+  return EndpointType2;
+})(EndpointType || {});
+var AIAgentCapability = /* @__PURE__ */ ((AIAgentCapability2) => {
+  AIAgentCapability2[AIAgentCapability2["TEXT_GENERATION"] = 0] = "TEXT_GENERATION";
+  AIAgentCapability2[AIAgentCapability2["IMAGE_GENERATION"] = 1] = "IMAGE_GENERATION";
+  AIAgentCapability2[AIAgentCapability2["AUDIO_GENERATION"] = 2] = "AUDIO_GENERATION";
+  AIAgentCapability2[AIAgentCapability2["VIDEO_GENERATION"] = 3] = "VIDEO_GENERATION";
+  AIAgentCapability2[AIAgentCapability2["CODE_GENERATION"] = 4] = "CODE_GENERATION";
+  AIAgentCapability2[AIAgentCapability2["LANGUAGE_TRANSLATION"] = 5] = "LANGUAGE_TRANSLATION";
+  AIAgentCapability2[AIAgentCapability2["SUMMARIZATION_EXTRACTION"] = 6] = "SUMMARIZATION_EXTRACTION";
+  AIAgentCapability2[AIAgentCapability2["KNOWLEDGE_RETRIEVAL"] = 7] = "KNOWLEDGE_RETRIEVAL";
+  AIAgentCapability2[AIAgentCapability2["DATA_INTEGRATION"] = 8] = "DATA_INTEGRATION";
+  AIAgentCapability2[AIAgentCapability2["MARKET_INTELLIGENCE"] = 9] = "MARKET_INTELLIGENCE";
+  AIAgentCapability2[AIAgentCapability2["TRANSACTION_ANALYTICS"] = 10] = "TRANSACTION_ANALYTICS";
+  AIAgentCapability2[AIAgentCapability2["SMART_CONTRACT_AUDIT"] = 11] = "SMART_CONTRACT_AUDIT";
+  AIAgentCapability2[AIAgentCapability2["GOVERNANCE_FACILITATION"] = 12] = "GOVERNANCE_FACILITATION";
+  AIAgentCapability2[AIAgentCapability2["SECURITY_MONITORING"] = 13] = "SECURITY_MONITORING";
+  AIAgentCapability2[AIAgentCapability2["COMPLIANCE_ANALYSIS"] = 14] = "COMPLIANCE_ANALYSIS";
+  AIAgentCapability2[AIAgentCapability2["FRAUD_DETECTION"] = 15] = "FRAUD_DETECTION";
+  AIAgentCapability2[AIAgentCapability2["MULTI_AGENT_COORDINATION"] = 16] = "MULTI_AGENT_COORDINATION";
+  AIAgentCapability2[AIAgentCapability2["API_INTEGRATION"] = 17] = "API_INTEGRATION";
+  AIAgentCapability2[AIAgentCapability2["WORKFLOW_AUTOMATION"] = 18] = "WORKFLOW_AUTOMATION";
+  return AIAgentCapability2;
+})(AIAgentCapability || {});
+var MCPServerCapability = /* @__PURE__ */ ((MCPServerCapability2) => {
+  MCPServerCapability2[MCPServerCapability2["RESOURCE_PROVIDER"] = 0] = "RESOURCE_PROVIDER";
+  MCPServerCapability2[MCPServerCapability2["TOOL_PROVIDER"] = 1] = "TOOL_PROVIDER";
+  MCPServerCapability2[MCPServerCapability2["PROMPT_TEMPLATE_PROVIDER"] = 2] = "PROMPT_TEMPLATE_PROVIDER";
+  MCPServerCapability2[MCPServerCapability2["LOCAL_FILE_ACCESS"] = 3] = "LOCAL_FILE_ACCESS";
+  MCPServerCapability2[MCPServerCapability2["DATABASE_INTEGRATION"] = 4] = "DATABASE_INTEGRATION";
+  MCPServerCapability2[MCPServerCapability2["API_INTEGRATION"] = 5] = "API_INTEGRATION";
+  MCPServerCapability2[MCPServerCapability2["WEB_ACCESS"] = 6] = "WEB_ACCESS";
+  MCPServerCapability2[MCPServerCapability2["KNOWLEDGE_BASE"] = 7] = "KNOWLEDGE_BASE";
+  MCPServerCapability2[MCPServerCapability2["MEMORY_PERSISTENCE"] = 8] = "MEMORY_PERSISTENCE";
+  MCPServerCapability2[MCPServerCapability2["CODE_ANALYSIS"] = 9] = "CODE_ANALYSIS";
+  MCPServerCapability2[MCPServerCapability2["CONTENT_GENERATION"] = 10] = "CONTENT_GENERATION";
+  MCPServerCapability2[MCPServerCapability2["COMMUNICATION"] = 11] = "COMMUNICATION";
+  MCPServerCapability2[MCPServerCapability2["DOCUMENT_PROCESSING"] = 12] = "DOCUMENT_PROCESSING";
+  MCPServerCapability2[MCPServerCapability2["CALENDAR_SCHEDULE"] = 13] = "CALENDAR_SCHEDULE";
+  MCPServerCapability2[MCPServerCapability2["SEARCH"] = 14] = "SEARCH";
+  MCPServerCapability2[MCPServerCapability2["ASSISTANT_ORCHESTRATION"] = 15] = "ASSISTANT_ORCHESTRATION";
+  return MCPServerCapability2;
+})(MCPServerCapability || {});
+var VerificationType = /* @__PURE__ */ ((VerificationType2) => {
+  VerificationType2["DNS"] = "dns";
+  VerificationType2["SIGNATURE"] = "signature";
+  VerificationType2["CHALLENGE"] = "challenge";
+  return VerificationType2;
+})(VerificationType || {});
+var InboundTopicType = /* @__PURE__ */ ((InboundTopicType2) => {
+  InboundTopicType2["PUBLIC"] = "PUBLIC";
+  InboundTopicType2["CONTROLLED"] = "CONTROLLED";
+  InboundTopicType2["FEE_BASED"] = "FEE_BASED";
+  return InboundTopicType2;
+})(InboundTopicType || {});
+const SUPPORTED_SOCIAL_PLATFORMS = [
+  "twitter",
+  "github",
+  "discord",
+  "telegram",
+  "linkedin",
+  "youtube",
+  "website",
+  "x"
+];
+const capabilityNameToCapabilityMap = {
+  text_generation: 0,
+  image_generation: 1,
+  audio_generation: 2,
+  video_generation: 3,
+  code_generation: 4,
+  language_translation: 5,
+  summarization: 6,
+  extraction: 6,
+  knowledge_retrieval: 7,
+  data_integration: 8,
+  data_visualization: 8,
+  market_intelligence: 9,
+  transaction_analytics: 10,
+  smart_contract_audit: 11,
+  governance: 12,
+  security_monitoring: 13,
+  compliance_analysis: 14,
+  fraud_detection: 15,
+  multi_agent: 16,
+  api_integration: 17,
+  workflow_automation: 18
+  /* WORKFLOW_AUTOMATION */
+};
+const mcpServiceNameToCapabilityMap = {
+  resource_provider: 0,
+  tool_provider: 1,
+  prompt_template_provider: 2,
+  local_file_access: 3,
+  database_integration: 4,
+  api_integration: 5,
+  web_access: 6,
+  knowledge_base: 7,
+  memory_persistence: 8,
+  code_analysis: 9,
+  content_generation: 10,
+  communication: 11,
+  document_processing: 12,
+  calendar_schedule: 13,
+  search: 14,
+  assistant_orchestration: 15
+  /* ASSISTANT_ORCHESTRATION */
+};
 export {
-  AIAgentDetailsSchema,
-  AIAgentProfileSchema,
-  BaseProfileSchema,
-  HCS11Client,
-  HCS11ProfileSchema,
-  MCPServerConnectionInfoSchema,
-  MCPServerDetailsSchema,
-  MCPServerHostSchema,
-  MCPServerProfileSchema,
-  MCPServerResourceSchema,
-  MCPServerToolSchema,
-  MCPServerVerificationSchema,
-  PersonalProfileSchema,
-  SocialLinkSchema
+  AIAgentCapability,
+  AIAgentType,
+  EndpointType,
+  InboundTopicType,
+  MCPServerCapability,
+  ProfileType,
+  SUPPORTED_SOCIAL_PLATFORMS,
+  VerificationType,
+  capabilityNameToCapabilityMap,
+  mcpServiceNameToCapabilityMap
 };
 //# sourceMappingURL=standards-sdk.es28.js.map