@hashgraphonline/standards-sdk 0.0.50 → 0.0.52

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

@@ -1,6 +1,6 @@
-import { Client, PrivateKey, AccountCreateTransaction, Hbar, CustomFixedFee, AccountId, KeyList, TopicCreateTransaction, PublicKey, TopicMessageSubmitTransaction, TopicId, Transaction } from "@hashgraph/sdk";
+import { Client, PrivateKey, AccountCreateTransaction, Hbar, CustomFixedFee, AccountId, KeyList, TopicCreateTransaction, PublicKey, TopicMessageSubmitTransaction, TopicId } from "@hashgraph/sdk";
 import { AccountCreationError, TopicCreationError, ConnectionConfirmationError, PayloadSizeError } from "./standards-sdk.es6.js";
-import { InscriptionSDK } from "./standards-sdk.es22.js";
+import { InscriptionSDK } from "./standards-sdk.es24.js";
 import { Logger } from "./standards-sdk.es13.js";
 import { HCS10BaseClient } from "./standards-sdk.es8.js";
 import { m as mimeTypesExports } from "./standards-sdk.es19.js";
@@ -14,7 +14,11 @@ class HCS10Client extends HCS10BaseClient {
       logLevel: config.logLevel,
       prettyPrint: config.prettyPrint
     });
-    this.client = config.network === "mainnet" ? Client.forMainnet() : Client.forTestnet();
+    if (config.network === "mainnet") {
+      this.client = Client.forMainnet();
+    } else {
+      this.client = Client.forTestnet();
+    }
     this.operatorPrivateKey = PrivateKey.fromString(config.operatorPrivateKey);
     this.network = config.network;
     this.client.setOperator(
@@ -26,7 +30,6 @@ class HCS10Client extends HCS10BaseClient {
       module: "HCS-SDK"
     });
     this.guardedRegistryBaseUrl = config.guardedRegistryBaseUrl || "https://moonscape.tech";
-    this.feeAmount = config.feeAmount || 5;
     this.hcs11Client = new HCS11Client({
       network: config.network,
       auth: {
@@ -116,9 +119,17 @@ class HCS10Client extends HCS10BaseClient {
         config.pfpFileName
       );
       pfpTopicId = pfpResult.pfpTopicId;
-      this.logger.info(`Profile picture inscribed with topic ID: ${pfpTopicId}`);
+      this.logger.info(
+        `Profile picture inscribed with topic ID: ${pfpTopicId}`
+      );
     } else if (config.existingPfpTopicId) {
-      this.logger.info(`Using existing profile picture with topic ID: ${config.existingPfpTopicId}`);
+      this.logger.info(
+        `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,
@@ -127,7 +138,7 @@ class HCS10Client extends HCS10BaseClient {
       outboundTopicId,
       config.capabilities,
       config.metadata,
-      config.pfpBuffer && config.pfpBuffer.length > 0 ? config.pfpBuffer : void 0,
+      pfpBufferToUse,
       config.pfpFileName,
       config.existingPfpTopicId
     );
@@ -198,20 +209,30 @@ class HCS10Client extends HCS10BaseClient {
         this.logger.info("Inscribing profile picture for HCS-11 profile");
         const pfpResult = await this.inscribePfp(pfpBuffer, pfpFileName);
         if (!pfpResult.success) {
-          this.logger.error("Failed to inscribe profile picture, continuing without PFP");
+          this.logger.error(
+            "Failed to inscribe profile picture, continuing without PFP"
+          );
         } else {
           pfpTopicId = pfpResult.pfpTopicId;
         }
       } else if (existingPfpTopicId) {
-        this.logger.info(`Using existing profile picture with topic ID: ${existingPfpTopicId} for HCS-11 profile`);
+        this.logger.info(
+          `Using existing profile picture with topic ID: ${existingPfpTopicId} for HCS-11 profile`
+        );
       }
       const agentType = this.hcs11Client.getAgentTypeFromMetadata({
         type: metadata.type || "autonomous"
       });
-      const formattedSocials = metadata.socials ? Object.entries(metadata.socials).filter(([_, handle]) => handle).map(([platform, handle]) => ({
-        platform: platform === "x" ? "twitter" : platform,
-        handle
-      })) : void 0;
+      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 profile = this.hcs11Client.createAIAgentProfile(
         agentName,
         agentType,
@@ -220,7 +241,7 @@ class HCS10Client extends HCS10BaseClient {
         {
           alias: agentName.toLowerCase().replace(/\s+/g, "_"),
           bio: agentDescription,
-          profileImage: pfpTopicId ? `hcs://1/${pfpTopicId}` : void 0,
+          profileImage: void 0,
           socials: formattedSocials,
           properties: metadata.properties,
           inboundTopicId,
@@ -228,6 +249,9 @@ class HCS10Client extends HCS10BaseClient {
           creator: metadata.creator
         }
       );
+      if (pfpTopicId) {
+        profile.profileImage = `hcs://1/${pfpTopicId}`;
+      }
       const profileResult = await this.hcs11Client.createAndInscribeProfile(
         profile,
         true
@@ -380,54 +404,6 @@ class HCS10Client extends HCS10BaseClient {
     }
     return sequenceNumber;
   }
-  async sendMessage(connectionTopicId, operatorId, data, memo, submitKey) {
-    const submissionCheck = await this.canSubmitToInboundTopic(
-      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);
@@ -475,7 +451,12 @@ class HCS10Client extends HCS10BaseClient {
     );
   }
   async submitPayload(topicId, payload, submitKey, requiresFee = false) {
-    const message = typeof payload === "string" ? payload : JSON.stringify(payload);
+    let message;
+    if (typeof payload === "string") {
+      message = payload;
+    } else {
+      message = JSON.stringify(payload);
+    }
     const payloadSizeInBytes = Buffer.byteLength(message, "utf8");
     if (payloadSizeInBytes > 1e3) {
       throw new PayloadSizeError(
@@ -549,27 +530,7 @@ class HCS10Client extends HCS10BaseClient {
     );
     return response;
   }
-  async recordOutboundConnectionConfirmation({
-    outboundTopicId,
-    connectionRequestId,
-    confirmedRequestId,
-    connectionTopicId,
-    operatorId,
-    memo
-  }) {
-    const payload = {
-      p: "hcs-10",
-      op: "connection_created",
-      connection_topic_id: connectionTopicId,
-      outbound_topic_id: outboundTopicId,
-      confirmed_request_id: confirmedRequestId,
-      connection_request_id: connectionRequestId,
-      operator_id: operatorId,
-      m: memo
-    };
-    return await this.submitPayload(outboundTopicId, payload);
-  }
-  async inscribeFile(buffer, fileName) {
+  async inscribeFile(buffer, fileName, options) {
     this.logger.info("Inscribing file");
     if (!this.client.operatorAccountId) {
       this.logger.error("Operator account ID is not set");
@@ -586,6 +547,14 @@ 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: {
@@ -612,8 +581,66 @@ 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;
   }
   /**
@@ -669,365 +696,6 @@ class HCS10Client extends HCS10BaseClient {
       signer: this.operatorPrivateKey
     };
   }
-  /**
-   * Checks if a user can submit to a topic and determines if a fee is required
-   * @param topicId The topic ID to check
-   * @param userAccountId The account ID of the user attempting to submit
-   * @returns Object with canSubmit, requiresFee, and optional reason
-   */
-  async canSubmitToInboundTopic(topicId, userAccountId) {
-    try {
-      const topicInfo = await this.mirrorNode.getTopicInfo(topicId);
-      if (!topicInfo) {
-        return {
-          canSubmit: false,
-          requiresFee: false,
-          reason: "Topic does not exist"
-        };
-      }
-      if (!topicInfo.submit_key?.key) {
-        return { canSubmit: true, requiresFee: false };
-      }
-      try {
-        const userPublicKey = await this.mirrorNode.getPublicKey(userAccountId);
-        if (topicInfo.submit_key._type === "ProtobufEncoded") {
-          const keyBytes = Buffer.from(topicInfo.submit_key.key, "hex");
-          const hasAccess = await this.mirrorNode.checkKeyListAccess(
-            keyBytes,
-            userPublicKey
-          );
-          if (hasAccess) {
-            return { canSubmit: true, requiresFee: false };
-          }
-        } else {
-          const topicSubmitKey = PublicKey.fromString(topicInfo.submit_key.key);
-          if (userPublicKey.toString() === topicSubmitKey.toString()) {
-            return { canSubmit: true, requiresFee: false };
-          }
-        }
-      } catch (error) {
-        this.logger.error(
-          `Key validation error: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-      if (topicInfo.fee_schedule_key?.key && topicInfo.custom_fees?.fixed_fees?.length > 0) {
-        return {
-          canSubmit: true,
-          requiresFee: true,
-          reason: "Requires fee payment via HIP-991"
-        };
-      }
-      return {
-        canSubmit: false,
-        requiresFee: false,
-        reason: "User does not have submit permission for this topic"
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logger.error(`Topic submission validation error: ${errorMessage}`);
-      return {
-        canSubmit: false,
-        requiresFee: false,
-        reason: `Error: ${errorMessage}`
-      };
-    }
-  }
-  /**
-   * 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;
   }