@hashgraphonline/standards-sdk 0.0.52 → 0.0.53

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

@@ -1,9 +1,10 @@
-import { Client, PrivateKey, AccountCreateTransaction, Hbar, CustomFixedFee, AccountId, KeyList, TopicCreateTransaction, PublicKey, TopicMessageSubmitTransaction, TopicId } from "@hashgraph/sdk";
+import Buffer from "./standards-sdk.es19.js";
+import { Client, PrivateKey, AccountCreateTransaction, Hbar, CustomFixedFee, AccountId, KeyList, TopicCreateTransaction, PublicKey, TopicMessageSubmitTransaction, TopicId, Transaction } from "@hashgraph/sdk";
 import { AccountCreationError, TopicCreationError, ConnectionConfirmationError, PayloadSizeError } from "./standards-sdk.es6.js";
-import { InscriptionSDK } from "./standards-sdk.es24.js";
+import { InscriptionSDK } from "./standards-sdk.es26.js";
 import { Logger } from "./standards-sdk.es13.js";
-import { HCS10BaseClient } from "./standards-sdk.es8.js";
-import { m as mimeTypesExports } from "./standards-sdk.es19.js";
+import { HCS10BaseClient, Hcs10MemoType } from "./standards-sdk.es8.js";
+import { m as mimeTypesExports } from "./standards-sdk.es20.js";
 import { InboundTopicType } from "./standards-sdk.es18.js";
 import { HCS11Client } from "./standards-sdk.es12.js";
 import { accountIdsToExemptKeys } from "./standards-sdk.es14.js";
@@ -12,13 +13,10 @@ class HCS10Client extends HCS10BaseClient {
     super({
       network: config.network,
       logLevel: config.logLevel,
-      prettyPrint: config.prettyPrint
+      prettyPrint: config.prettyPrint,
+      feeAmount: config.feeAmount
     });
-    if (config.network === "mainnet") {
-      this.client = Client.forMainnet();
-    } else {
-      this.client = Client.forTestnet();
-    }
+    this.client = config.network === "mainnet" ? Client.forMainnet() : Client.forTestnet();
     this.operatorPrivateKey = PrivateKey.fromString(config.operatorPrivateKey);
     this.network = config.network;
     this.client.setOperator(
@@ -69,37 +67,53 @@ class HCS10Client extends HCS10BaseClient {
     };
   }
   /**
-   * Creates an inbound topic with the specified configuration
-   * @param accountId Account ID associated with the topic
+   * Creates an inbound topic for an agent
+   * @param accountId The account ID associated with the inbound topic
    * @param topicType Type of inbound topic (public, controlled, or fee-based)
-   * @param feeConfig Optional fee configuration for fee-based topics
+   * @param ttl Optional Time-To-Live for the topic memo, defaults to 60
+   * @param feeConfigBuilder Optional fee configuration builder for fee-based topics
    * @returns The topic ID of the created inbound topic
    */
-  async createInboundTopic(accountId, topicType, feeConfig) {
-    this.logger.info(`Creating ${topicType} inbound topic`);
-    const memo = `hcs-10:0:60:0:${accountId}`;
+  async createInboundTopic(accountId, topicType, ttl = 60, feeConfigBuilder) {
+    const memo = this._generateHcs10Memo(Hcs10MemoType.INBOUND, {
+      accountId,
+      ttl
+    });
+    let submitKey;
+    let feeConfig;
     switch (topicType) {
       case InboundTopicType.PUBLIC:
-        return this.createTopic(memo, true, false);
+        submitKey = false;
+        break;
       case InboundTopicType.CONTROLLED:
-        return this.createTopic(memo, true, true);
+        submitKey = true;
+        break;
       case InboundTopicType.FEE_BASED:
-        if (!feeConfig) {
-          throw new Error("Fee configuration is required for fee-based topics");
+        submitKey = true;
+        if (!feeConfigBuilder) {
+          throw new Error(
+            "Fee configuration builder is required for fee-based topics"
+          );
         }
-        return this.createTopic(memo, true, true, feeConfig.build());
+        feeConfig = feeConfigBuilder.build();
+        break;
       default:
         throw new Error(`Unsupported inbound topic type: ${topicType}`);
     }
+    return this.createTopic(memo, true, submitKey, feeConfig);
   }
   /**
    * Creates a new agent with inbound and outbound topics
    * @param builder The agent builder object
+   * @param ttl Optional Time-To-Live for the topic memos, defaults to 60
    * @returns Object with topic IDs
    */
-  async createAgent(builder) {
+  async createAgent(builder, ttl = 60) {
     const config = builder.build();
-    const outboundTopicId = await this.createTopic("hcs-10:0:60:1", true, true);
+    const outboundMemo = this._generateHcs10Memo(Hcs10MemoType.OUTBOUND, {
+      ttl
+    });
+    const outboundTopicId = await this.createTopic(outboundMemo, true, true);
     this.logger.info(`Created new outbound topic ID: ${outboundTopicId}`);
     const accountId = this.client.operatorAccountId?.toString();
     if (!accountId) {
@@ -108,9 +122,9 @@ class HCS10Client extends HCS10BaseClient {
     const inboundTopicId = await this.createInboundTopic(
       accountId,
       config.inboundTopicType,
+      ttl,
       config.inboundTopicType === InboundTopicType.FEE_BASED ? config.feeConfig : void 0
     );
-    this.logger.info(`Created new inbound topic ID: ${inboundTopicId}`);
     let pfpTopicId = config.existingPfpTopicId || "";
     if (!pfpTopicId && config.pfpBuffer && config.pfpBuffer.length > 0) {
       this.logger.info("Inscribing new profile picture");
@@ -127,10 +141,6 @@ class HCS10Client extends HCS10BaseClient {
         `Using existing profile picture with topic ID: ${config.existingPfpTopicId}`
       );
     }
-    let pfpBufferToUse = void 0;
-    if (config.pfpBuffer && config.pfpBuffer.length > 0) {
-      pfpBufferToUse = config.pfpBuffer;
-    }
     const profileResult = await this.storeHCS11Profile(
       config.name,
       config.description,
@@ -138,15 +148,15 @@ class HCS10Client extends HCS10BaseClient {
       outboundTopicId,
       config.capabilities,
       config.metadata,
-      pfpBufferToUse,
+      config.pfpBuffer && config.pfpBuffer.length > 0 ? config.pfpBuffer : void 0,
       config.pfpFileName,
       config.existingPfpTopicId
     );
     const profileTopicId = profileResult.profileTopicId;
     this.logger.info(`Profile stored with topic ID: ${profileTopicId}`);
     return {
-      outboundTopicId,
       inboundTopicId,
+      outboundTopicId,
       pfpTopicId,
       profileTopicId
     };
@@ -223,16 +233,10 @@ class HCS10Client extends HCS10BaseClient {
       const agentType = this.hcs11Client.getAgentTypeFromMetadata({
         type: metadata.type || "autonomous"
       });
-      const formattedSocials = metadata.socials ? Object.entries(metadata.socials).filter(([_, handle]) => handle).map(([platform, handle]) => {
-        let resolvedPlatform = platform;
-        if (platform === "x") {
-          resolvedPlatform = "twitter";
-        }
-        return {
-          platform: resolvedPlatform,
-          handle
-        };
-      }) : void 0;
+      const formattedSocials = metadata.socials ? Object.entries(metadata.socials).filter(([_, handle]) => handle).map(([platform, handle]) => ({
+        platform: platform === "x" ? "twitter" : platform,
+        handle
+      })) : void 0;
       const profile = this.hcs11Client.createAIAgentProfile(
         agentName,
         agentType,
@@ -241,7 +245,7 @@ class HCS10Client extends HCS10BaseClient {
         {
           alias: agentName.toLowerCase().replace(/\s+/g, "_"),
           bio: agentDescription,
-          profileImage: void 0,
+          profileImage: pfpTopicId ? `hcs://1/${pfpTopicId}` : void 0,
           socials: formattedSocials,
           properties: metadata.properties,
           inboundTopicId,
@@ -249,9 +253,6 @@ class HCS10Client extends HCS10BaseClient {
           creator: metadata.creator
         }
       );
-      if (pfpTopicId) {
-        profile.profileImage = `hcs://1/${pfpTopicId}`;
-      }
       const profileResult = await this.hcs11Client.createAndInscribeProfile(
         profile,
         true
@@ -324,10 +325,15 @@ class HCS10Client extends HCS10BaseClient {
    * @param requestingAccountId Requesting account ID
    * @param connectionRequestId Connection request ID
    * @param connectionFeeConfig Optional fee configuration for the connection topic
+   * @param ttl Optional ttl parameter with default
    * @returns Response with connection details
    */
-  async handleConnectionRequest(inboundTopicId, requestingAccountId, connectionRequestId, connectionFeeConfig) {
-    const memo = `hcs-10:${inboundTopicId}:${connectionRequestId}`;
+  async handleConnectionRequest(inboundTopicId, requestingAccountId, connectionRequestId, connectionFeeConfig, ttl = 60) {
+    const memo = this._generateHcs10Memo(Hcs10MemoType.CONNECTION, {
+      ttl,
+      inboundTopicId,
+      connectionId: connectionRequestId
+    });
     this.logger.info(
       `Handling connection request ${connectionRequestId} from ${requestingAccountId}`
     );
@@ -395,7 +401,16 @@ class HCS10Client extends HCS10BaseClient {
       connection_id: connectionId,
       m: memo
     };
-    const result = await this.submitPayload(inboundTopicId, payload, submitKey);
+    const submissionCheck = await this.canSubmitToTopic(
+      inboundTopicId,
+      this.client.operatorAccountId?.toString() || ""
+    );
+    const result = await this.submitPayload(
+      inboundTopicId,
+      payload,
+      submitKey,
+      submissionCheck.requiresFee
+    );
     const sequenceNumber = result.topicSequenceNumber?.toNumber();
     if (!sequenceNumber) {
       throw new ConnectionConfirmationError(
@@ -404,6 +419,54 @@ class HCS10Client extends HCS10BaseClient {
     }
     return sequenceNumber;
   }
+  async sendMessage(connectionTopicId, operatorId, data, memo, submitKey) {
+    const submissionCheck = await this.canSubmitToTopic(
+      connectionTopicId,
+      this.client.operatorAccountId?.toString() || ""
+    );
+    const payload = {
+      p: "hcs-10",
+      op: "message",
+      operator_id: operatorId,
+      data,
+      m: memo
+    };
+    const payloadString = JSON.stringify(payload);
+    const isLargePayload = Buffer.from(payloadString).length > 1e3;
+    if (isLargePayload) {
+      this.logger.info(
+        "Message payload exceeds 1000 bytes, storing via inscription"
+      );
+      try {
+        const contentBuffer = Buffer.from(data);
+        const fileName = `message-${Date.now()}.json`;
+        const inscriptionResult = await this.inscribeFile(
+          contentBuffer,
+          fileName
+        );
+        if (inscriptionResult?.topic_id) {
+          payload.data = `hcs://1/${inscriptionResult.topic_id}`;
+          this.logger.info(
+            `Large message inscribed with topic ID: ${inscriptionResult.topic_id}`
+          );
+        } else {
+          throw new Error("Failed to inscribe large message content");
+        }
+      } catch (error) {
+        this.logger.error("Error inscribing large message:", error);
+        throw new Error(
+          `Failed to handle large message: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+    this.logger.info("Submitting message to connection topic", payload);
+    await this.submitPayload(
+      connectionTopicId,
+      payload,
+      submitKey,
+      submissionCheck.requiresFee
+    );
+  }
   async createTopic(memo, adminKey, submitKey, feeConfig) {
     this.logger.info("Creating topic");
     const transaction = new TopicCreateTransaction().setTopicMemo(memo);
@@ -438,25 +501,8 @@ class HCS10Client extends HCS10BaseClient {
     const topicId = receipt.topicId.toString();
     return topicId;
   }
-  async submitMessage(topicId, message, submitKey) {
-    const submissionCheck = await this.canSubmitToInboundTopic(
-      topicId,
-      this.client.operatorAccountId?.toString() || ""
-    );
-    return this.submitPayload(
-      topicId,
-      message,
-      submitKey,
-      submissionCheck.requiresFee
-    );
-  }
   async submitPayload(topicId, payload, submitKey, requiresFee = false) {
-    let message;
-    if (typeof payload === "string") {
-      message = payload;
-    } else {
-      message = JSON.stringify(payload);
-    }
+    const message = typeof payload === "string" ? payload : JSON.stringify(payload);
     const payloadSizeInBytes = Buffer.byteLength(message, "utf8");
     if (payloadSizeInBytes > 1e3) {
       throw new PayloadSizeError(
@@ -489,7 +535,7 @@ class HCS10Client extends HCS10BaseClient {
     return receipt;
   }
   async submitConnectionRequest(inboundTopicId, requestingAccountId, operatorId, memo) {
-    const submissionCheck = await this.canSubmitToInboundTopic(
+    const submissionCheck = await this.canSubmitToTopic(
       inboundTopicId,
       requestingAccountId
     );
@@ -530,7 +576,7 @@ class HCS10Client extends HCS10BaseClient {
     );
     return response;
   }
-  async inscribeFile(buffer, fileName, options) {
+  async inscribeFile(buffer, fileName) {
     this.logger.info("Inscribing file");
     if (!this.client.operatorAccountId) {
       this.logger.error("Operator account ID is not set");
@@ -547,14 +593,6 @@ class HCS10Client extends HCS10BaseClient {
       privateKey: this.operatorPrivateKey.toString(),
       network: this.network
     });
-    const progressCallback = options?.progressCallback;
-    if (progressCallback) {
-      progressCallback({
-        stage: "preparing",
-        message: "Preparing file for inscription",
-        progressPercent: 10
-      });
-    }
     const result = await sdk.inscribeAndExecute(
       {
         file: {
@@ -581,66 +619,8 @@ class HCS10Client extends HCS10BaseClient {
       this.logger.info(
         `Transaction ID: ${result.transactionId}, Job ID: ${result.jobId}`
       );
-      if (progressCallback) {
-        progressCallback({
-          stage: "submitting",
-          message: "Inscription transaction submitted",
-          progressPercent: 30,
-          details: {
-            transactionId: result.transactionId,
-            jobId: result.jobId
-          }
-        });
-      }
-    }
-    const maxAttempts = options?.waitMaxAttempts || 30;
-    const intervalMs = options?.waitIntervalMs || 4e3;
-    let wrappedProgressCallback = void 0;
-    if (progressCallback) {
-      wrappedProgressCallback = (data) => {
-        let stage;
-        if (data.confirmed) {
-          stage = "confirming";
-        } else if (data.status === "COMPLETED") {
-          stage = "completed";
-        } else {
-          stage = "verifying";
-        }
-        let attemptPercent;
-        if (data.currentAttempt) {
-          attemptPercent = data.currentAttempt / maxAttempts * 60 + 30;
-        } else if (data.confirmed) {
-          attemptPercent = 90;
-        } else if (data.status === "COMPLETED") {
-          attemptPercent = 100;
-        } else {
-          attemptPercent = 60;
-        }
-        progressCallback({
-          stage,
-          message: `Waiting for inscription confirmation (attempt ${data.currentAttempt || "?"}/${maxAttempts})`,
-          progressPercent: Math.min(attemptPercent, 100),
-          details: data
-        });
-      };
-    }
-    const status = await sdk.waitForInscription(
-      result.jobId,
-      maxAttempts,
-      intervalMs,
-      true,
-      wrappedProgressCallback
-    );
-    if (progressCallback && status.topic_id) {
-      progressCallback({
-        stage: "completed",
-        message: "Inscription completed successfully",
-        progressPercent: 100,
-        details: {
-          topicId: status.topic_id
-        }
-      });
     }
+    const status = await sdk.waitForInscription(result.jobId, 30, 4e3, true);
     return status;
   }
   /**
@@ -696,6 +676,302 @@ class HCS10Client extends HCS10BaseClient {
       signer: this.operatorPrivateKey
     };
   }
+  /**
+   * Creates and registers an agent with a Guarded registry.
+   *
+   * This function performs the following steps:
+   * 1. Creates a new account if no existing account is provided.
+   * 2. Initializes an HCS10 client with the new account.
+   * 3. Creates an agent on the client.
+   * 4. Registers the agent with the Hashgraph Online Guarded Registry.
+   *
+   * @param builder The agent builder object
+   * @param options Optional configuration including progress callback and state management
+   * @returns Agent registration result
+   */
+  async createAndRegisterAgent(builder, options) {
+    try {
+      const config = builder.build();
+      const progressCallback = options?.progressCallback;
+      const baseUrl = options?.baseUrl || this.guardedRegistryBaseUrl;
+      let state = options?.existingState || void 0;
+      if (progressCallback) {
+        progressCallback({
+          stage: "preparing",
+          message: "Preparing agent registration",
+          progressPercent: 10,
+          details: { state }
+        });
+      }
+      const account = config.existingAccount || await this.createAccount();
+      if (progressCallback) {
+        progressCallback({
+          stage: "preparing",
+          message: "Created account or using existing account",
+          progressPercent: 20,
+          details: { state, account }
+        });
+      }
+      const agentClient = new HCS10Client({
+        network: config.network,
+        operatorId: account.accountId,
+        operatorPrivateKey: account.privateKey,
+        operatorPublicKey: PrivateKey.fromString(
+          account.privateKey
+        ).publicKey.toString(),
+        logLevel: "info",
+        guardedRegistryBaseUrl: baseUrl
+      });
+      if (progressCallback) {
+        progressCallback({
+          stage: "preparing",
+          message: "Initialized agent client",
+          progressPercent: 30,
+          details: { state }
+        });
+      }
+      const { outboundTopicId, inboundTopicId, pfpTopicId, profileTopicId } = await agentClient.createAgent(builder);
+      if (progressCallback) {
+        progressCallback({
+          stage: "submitting",
+          message: "Created agent with topics and profile",
+          progressPercent: 60,
+          details: {
+            state,
+            outboundTopicId,
+            inboundTopicId,
+            pfpTopicId,
+            profileTopicId
+          }
+        });
+      }
+      const operatorId = `${inboundTopicId}@${account.accountId}`;
+      const registrationResult = await agentClient.registerAgentWithGuardedRegistry(
+        account.accountId,
+        config.network,
+        {
+          progressCallback: (data) => {
+            const adjustedPercent = 60 + (data.progressPercent || 0) * 0.4;
+            if (progressCallback) {
+              progressCallback({
+                stage: data.stage,
+                message: data.message,
+                progressPercent: adjustedPercent,
+                details: {
+                  ...data.details,
+                  outboundTopicId,
+                  inboundTopicId,
+                  pfpTopicId,
+                  profileTopicId,
+                  operatorId,
+                  state: data.details?.state || state
+                }
+              });
+            }
+          },
+          existingState: state
+        }
+      );
+      if (!registrationResult.success) {
+        return registrationResult;
+      }
+      if (progressCallback) {
+        progressCallback({
+          stage: "completed",
+          message: "Agent creation and registration complete",
+          progressPercent: 100,
+          details: {
+            outboundTopicId,
+            inboundTopicId,
+            pfpTopicId,
+            profileTopicId,
+            operatorId,
+            state: registrationResult.state
+          }
+        });
+      }
+      return {
+        ...registrationResult,
+        metadata: {
+          accountId: account.accountId,
+          privateKey: account.privateKey,
+          operatorId,
+          inboundTopicId,
+          outboundTopicId,
+          profileTopicId,
+          pfpTopicId
+        }
+      };
+    } catch (error) {
+      this.logger.error(
+        `Failed to create and register agent: ${error.message}`
+      );
+      return {
+        error: error.message,
+        success: false
+      };
+    }
+  }
+  /**
+   * Registers an agent with the guarded registry
+   * @param accountId Account ID to register
+   * @param inboundTopicId Inbound topic ID for the agent
+   * @param network Network type ('mainnet' or 'testnet')
+   * @param options Optional configuration including progress callback and confirmation settings
+   * @returns Registration result
+   */
+  async registerAgentWithGuardedRegistry(accountId, network = this.network, options) {
+    try {
+      this.logger.info("Registering agent with guarded registry");
+      const maxAttempts = options?.maxAttempts ?? 60;
+      const delayMs = options?.delayMs ?? 2e3;
+      const progressCallback = options?.progressCallback;
+      let state = options?.existingState || {
+        currentStage: "registration",
+        completedPercentage: 0,
+        createdResources: []
+      };
+      if (progressCallback) {
+        progressCallback({
+          stage: "preparing",
+          message: "Preparing agent registration",
+          progressPercent: 10,
+          details: {
+            state
+          }
+        });
+      }
+      const registrationResult = await this.executeRegistration(
+        accountId,
+        network,
+        this.guardedRegistryBaseUrl,
+        this.logger
+      );
+      if (!registrationResult.success) {
+        return {
+          ...registrationResult,
+          state
+        };
+      }
+      if (progressCallback) {
+        progressCallback({
+          stage: "submitting",
+          message: "Submitting registration to registry",
+          progressPercent: 30,
+          details: {
+            transactionId: registrationResult.transactionId,
+            state
+          }
+        });
+      }
+      if (registrationResult.transaction) {
+        const transaction = Transaction.fromBytes(
+          Buffer.from(registrationResult.transaction, "base64")
+        );
+        this.logger.info(`Processing registration transaction`);
+        await transaction.execute(this.client);
+        this.logger.info(`Successfully processed registration transaction`);
+      }
+      if (progressCallback) {
+        progressCallback({
+          stage: "confirming",
+          message: "Confirming registration transaction",
+          progressPercent: 60,
+          details: {
+            accountId,
+            transactionId: registrationResult.transactionId,
+            state
+          }
+        });
+      }
+      const confirmed = await this.waitForRegistrationConfirmation(
+        registrationResult.transactionId,
+        network,
+        this.guardedRegistryBaseUrl,
+        maxAttempts,
+        delayMs,
+        this.logger
+      );
+      state.currentStage = "complete";
+      state.completedPercentage = 100;
+      if (!state.createdResources) {
+        state.createdResources = [];
+      }
+      if (registrationResult.transactionId) {
+        state.createdResources.push(
+          `registration:${registrationResult.transactionId}`
+        );
+      }
+      if (progressCallback) {
+        progressCallback({
+          stage: "completed",
+          message: "Agent registration complete",
+          progressPercent: 100,
+          details: {
+            confirmed,
+            transactionId: registrationResult.transactionId,
+            state
+          }
+        });
+      }
+      return {
+        ...registrationResult,
+        confirmed,
+        state
+      };
+    } catch (error) {
+      this.logger.error(`Failed to register agent: ${error.message}`);
+      return {
+        error: error.message,
+        success: false
+      };
+    }
+  }
+  /**
+   * Registers an agent with the guarded registry. Should be called by a registry.
+   * @param registryTopicId - The topic ID of the guarded registry.
+   * @param accountId - The account ID of the agent
+   * @param inboundTopicId - The topic ID of the inbound topic
+   * @param memo - The memo of the agent
+   * @param submitKey - The submit key of the agent
+   */
+  async registerAgent(registryTopicId, accountId, inboundTopicId, memo, submitKey) {
+    this.logger.info("Registering agent");
+    const payload = {
+      p: "hcs-10",
+      op: "register",
+      account_id: accountId,
+      inbound_topic_id: inboundTopicId,
+      m: memo
+    };
+    await this.submitPayload(registryTopicId, payload, submitKey);
+  }
+  async getInboundTopicType(topicId) {
+    try {
+      const topicInfo = await this.mirrorNode.getTopicInfo(topicId);
+      if (!topicInfo) {
+        throw new Error("Topic does not exist");
+      }
+      const hasSubmitKey = topicInfo.submit_key && topicInfo.submit_key.key;
+      if (!hasSubmitKey) {
+        return InboundTopicType.PUBLIC;
+      }
+      const hasFeeScheduleKey = topicInfo.fee_schedule_key && topicInfo.fee_schedule_key.key;
+      if (hasFeeScheduleKey && topicInfo.custom_fees) {
+        const customFees = topicInfo.custom_fees;
+        if (customFees && customFees.fixed_fees && customFees.fixed_fees.length > 0) {
+          this.logger.info(
+            `Topic ${topicId} is fee-based with ${customFees.fixed_fees.length} custom fees`
+          );
+          return InboundTopicType.FEE_BASED;
+        }
+      }
+      return InboundTopicType.CONTROLLED;
+    } catch (error) {
+      this.logger.error(`Error determining topic type: ${error.message}`);
+      throw new Error(`Failed to determine topic type: ${error.message}`);
+    }
+  }
   getNetwork() {
     return this.network;
   }