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

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

@@ -1,74 +1,925 @@
-import { Logger } from "./standards-sdk.es106.js";
-class FloraBuilder {
-  constructor() {
-    this.config = {
+import { Client, Status, PrivateKey, AccountUpdateTransaction } from "@hashgraph/sdk";
+import { inscribeWithSigner, inscribe } from "./standards-sdk.es124.js";
+import "./standards-sdk.es149.js";
+import { Logger } from "./standards-sdk.es105.js";
+import { HederaMirrorNode } from "./standards-sdk.es126.js";
+import { ProgressReporter } from "./standards-sdk.es108.js";
+import "axios";
+import "./standards-sdk.es127.js";
+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 "buffer";
+import "crypto";
+import "@noble/curves/secp256k1.js";
+import { z } from "zod";
+import "./standards-sdk.es148.js";
+import "./standards-sdk.es138.js";
+import "@hashgraph/proto";
+import "ethers";
+import "./standards-sdk.es122.js";
+import "./standards-sdk.es113.js";
+import { getTopicId } from "./standards-sdk.es114.js";
+import * as mime from "mime-types";
+import { isHederaNetwork, toHederaCaip10 } from "./standards-sdk.es57.js";
+import { createNodeOperatorContext } from "./standards-sdk.es146.js";
+import { AIAgentCapability, AIAgentType, VerificationType, MCPServerCapability, ProfileType, capabilityNameToCapabilityMap } from "./standards-sdk.es28.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: 3
+      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
     };
-    this.logger = Logger.getInstance({
-      module: "FloraBuilder"
+  }
+  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
+      }
+    };
   }
-  setDisplayName(displayName) {
-    this.config.display_name = displayName;
-    return this;
+  /**
+   * 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
+    };
   }
-  setBio(bio) {
-    this.config.bio = bio;
-    return this;
+  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);
   }
-  setMembers(members) {
-    this.config.members = members;
-    return this;
+  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;
+    }
   }
-  setThreshold(threshold) {
-    this.config.threshold = threshold;
-    return this;
+  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"
+      };
+    }
   }
-  setTopics(topics) {
-    this.config.topics = topics;
-    this.config.inboundTopicId = topics.communication;
-    this.config.outboundTopicId = topics.transaction;
-    return this;
+  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"
+      };
+    }
   }
-  setPolicies(policies) {
-    this.config.policies = policies;
-    return this;
+  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"
+      };
+    }
   }
-  setMetadata(metadata) {
-    this.config.metadata = metadata;
-    return this;
+  async attachUaidIfMissing(profile) {
+    if (profile.uaid) {
+      return;
+    }
+    if (!isHederaNetwork(this.network)) {
+      return;
+    }
+    try {
+      const { HCS14Client } = await import("./standards-sdk.es145.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
+      );
+    }
   }
-  addMetadata(key, value) {
-    if (!this.config.metadata) {
-      this.config.metadata = {};
+  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"
+      };
     }
-    this.config.metadata[key] = value;
-    return this;
   }
-  build() {
-    if (!this.config.display_name) {
-      throw new Error("Flora display name is required");
+  /**
+   * 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;
     }
-    if (!this.config.members || this.config.members.length === 0) {
-      throw new Error("Flora must have at least one member");
+    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
+        };
+      }
     }
-    if (!this.config.threshold || this.config.threshold < 1) {
-      throw new Error("Flora threshold must be at least 1");
+    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];
     }
-    if (this.config.threshold > this.config.members.length) {
-      throw new Error("Flora threshold cannot exceed number of members");
+    for (const capabilityName of capabilityNames) {
+      const capability = capabilityNameToCapabilityMap[capabilityName.toLowerCase()];
+      if (capability !== void 0 && !capabilities.includes(capability)) {
+        capabilities.push(capability);
+      }
     }
-    if (!this.config.topics) {
-      throw new Error("Flora topics are required");
+    if (capabilities.length === 0) {
+      capabilities.push(AIAgentCapability.TEXT_GENERATION);
     }
-    if (!this.config.inboundTopicId || !this.config.outboundTopicId) {
-      throw new Error("Flora inbound and outbound topic IDs are required");
+    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}`
+      };
     }
-    return this.config;
   }
 }
 export {
-  FloraBuilder
+  AIAgentDetailsSchema,
+  AIAgentProfileSchema,
+  BaseProfileSchema,
+  HCS11Client,
+  HCS11ProfileSchema,
+  MCPServerConnectionInfoSchema,
+  MCPServerDetailsSchema,
+  MCPServerHostSchema,
+  MCPServerProfileSchema,
+  MCPServerResourceSchema,
+  MCPServerToolSchema,
+  MCPServerVerificationSchema,
+  PersonalProfileSchema,
+  SocialLinkSchema
 };
 //# sourceMappingURL=standards-sdk.es27.js.map