@hashgraphonline/standards-sdk 0.0.30 → 0.0.32

package/dist/es/hcs-10/base-client.d.ts

@@ -1,6 +1,6 @@
+import { AccountResponse, HederaMirrorNode, TopicInfo } from '../services/mirror-node';
 import { Logger, LogLevel } from '../utils/logger';
 import { Registration } from './registrations';
-import { HederaMirrorNode, TopicInfo, AccountResponse } from '../services/mirror-node';
 export interface HCS10Config {
     network: 'mainnet' | 'testnet';
     logLevel?: LogLevel;
@@ -23,6 +23,13 @@ export interface HCSMessage {
     sequence_number: number;
     operator_id?: string;
 }
+export interface ProfileResponse {
+    profile: any;
+    topicInfo?: TopicInfo;
+    profileTopicId?: string;
+    success: boolean;
+    error?: string;
+}
 export declare abstract class HCS10BaseClient extends Registration {
     protected network: string;
     protected logger: Logger;
@@ -42,10 +49,17 @@ export declare abstract class HCS10BaseClient extends Registration {
     getAccountMemo(accountId: string): Promise<string | null>;
     protected getTopicInfoFromMemo(memo: string): Promise<TopicInfo | null>;
     getTopicInfo(accountId: string): Promise<TopicInfo | null>;
+    retrieveProfile(accountId: string): Promise<ProfileResponse>;
     retrieveOutboundConnectTopic(accountId: string): Promise<TopicInfo>;
     retrieveOutboundMessages(agentAccountId: string): Promise<HCSMessage[]>;
     hasConnectionCreated(agentAccountId: string, connectionId: number): Promise<boolean>;
     clearCache(): void;
+    /**
+     * Gets message content, resolving any HRL references if needed
+     * @param data The message data which might be an HRL reference
+     * @returns The resolved content
+     */
+    getMessageContent(data: string): Promise<string>;
 }
 export declare class HCS10Cache {
     private static instance;

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

@@ -15311,176 +15311,6 @@ const {
   getAdapter,
   mergeConfig
 } = axios;
-class Registration {
-  async checkRegistrationStatus(transactionId, network, baseUrl, logger) {
-    try {
-      const response = await fetch(`${baseUrl}/api/request-confirm`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Network": network
-        },
-        body: JSON.stringify({ transaction_id: transactionId })
-      });
-      if (!response.ok) {
-        const error = `Failed to confirm registration: ${response.statusText}`;
-        if (logger) {
-          logger.error(error);
-        }
-        throw new Error(error);
-      }
-      return await response.json();
-    } catch (error) {
-      if (logger) {
-        logger.error(`Error checking registration status: ${error.message}`);
-      }
-      throw error;
-    }
-  }
-  async waitForRegistrationConfirmation(transactionId, network, baseUrl, maxAttempts = 60, delayMs = 2e3, logger) {
-    let attempts = 0;
-    while (attempts < maxAttempts) {
-      if (logger) {
-        logger.info(
-          `Checking registration status. Attempt ${attempts + 1}/${maxAttempts}`
-        );
-      }
-      const status = await this.checkRegistrationStatus(
-        transactionId,
-        network,
-        baseUrl,
-        logger
-      );
-      if (status.status === "success") {
-        if (logger) {
-          logger.info("Registration confirmed successfully");
-        }
-        return true;
-      }
-      if (status.status === "failed") {
-        if (logger) {
-          logger.error("Registration confirmation failed");
-        }
-        throw new Error("Registration confirmation failed");
-      }
-      if (logger) {
-        logger.info(
-          `Registration still pending. Waiting ${delayMs}ms before next attempt`
-        );
-      }
-      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
-      attempts++;
-    }
-    if (logger) {
-      logger.warn(`Registration not confirmed after ${maxAttempts} attempts`);
-    }
-    return false;
-  }
-  async executeRegistration(accountId, inboundTopicId, network, baseUrl, logger, metadata = { tags: [] }) {
-    var _a;
-    try {
-      if (logger) {
-        logger.info("Registering agent with guarded registry");
-      }
-      const response = await fetch(`${baseUrl}/api/request-register`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "*/*",
-          "Accept-Language": "en;q=0.5",
-          Origin: baseUrl,
-          Referer: `${baseUrl}/`,
-          "X-Network": network
-        },
-        body: JSON.stringify({
-          accountId,
-          inboundTopicId,
-          metadata
-        })
-      });
-      const data = await response.json();
-      if (!response.ok) {
-        if (((_a = data.details) == null ? void 0 : _a.length) > 0) {
-          return {
-            validationErrors: data.details,
-            error: data.error || "Validation failed",
-            success: false
-          };
-        }
-        return {
-          error: data.error || "Failed to register agent",
-          success: false
-        };
-      }
-      if (logger) {
-        logger.info(
-          `Created new registration request. Transaction ID: ${data.transaction_id}`
-        );
-      }
-      return {
-        transactionId: data.transaction_id,
-        transaction: data.transaction,
-        success: true
-      };
-    } catch (error) {
-      return {
-        error: `Error during registration request: ${error.message}`,
-        success: false
-      };
-    }
-  }
-  async findRegistrations(options = {}, baseUrl = "https://hcs-10.hashgraphonline.com") {
-    var _a;
-    try {
-      const queryParams = new URLSearchParams();
-      (_a = options.tags) == null ? void 0 : _a.forEach((tag) => queryParams.append("tags", tag));
-      if (options.accountId) {
-        queryParams.append("accountId", options.accountId);
-      }
-      if (options.network) {
-        queryParams.append("network", options.network);
-      }
-      const response = await fetch(
-        `${baseUrl}/api/registrations?${queryParams}`,
-        {
-          headers: {
-            Accept: "*/*",
-            "Accept-Language": "en;q=0.5",
-            Origin: baseUrl,
-            Referer: `${baseUrl}/`
-          }
-        }
-      );
-      if (!response.ok) {
-        const error = await response.text();
-        return {
-          registrations: [],
-          error: error || "Failed to fetch registrations",
-          success: false
-        };
-      }
-      const data = await response.json();
-      if (data.error) {
-        return {
-          registrations: [],
-          error: data.error,
-          success: false
-        };
-      }
-      return {
-        registrations: data.registrations || [],
-        success: true
-      };
-    } catch (e) {
-      const error = e;
-      return {
-        registrations: [],
-        error: `Error fetching registrations: ${error.message}`,
-        success: false
-      };
-    }
-  }
-}
 class HederaMirrorNode {
   constructor(network, logger) {
     this.network = network;
@@ -15670,6 +15500,176 @@ class HederaMirrorNode {
     }
   }
 }
+class Registration {
+  async checkRegistrationStatus(transactionId, network, baseUrl, logger) {
+    try {
+      const response = await fetch(`${baseUrl}/api/request-confirm`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Network": network
+        },
+        body: JSON.stringify({ transaction_id: transactionId })
+      });
+      if (!response.ok) {
+        const error = `Failed to confirm registration: ${response.statusText}`;
+        if (logger) {
+          logger.error(error);
+        }
+        throw new Error(error);
+      }
+      return await response.json();
+    } catch (error) {
+      if (logger) {
+        logger.error(`Error checking registration status: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  async waitForRegistrationConfirmation(transactionId, network, baseUrl, maxAttempts = 60, delayMs = 2e3, logger) {
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+      if (logger) {
+        logger.info(
+          `Checking registration status. Attempt ${attempts + 1}/${maxAttempts}`
+        );
+      }
+      const status = await this.checkRegistrationStatus(
+        transactionId,
+        network,
+        baseUrl,
+        logger
+      );
+      if (status.status === "success") {
+        if (logger) {
+          logger.info("Registration confirmed successfully");
+        }
+        return true;
+      }
+      if (status.status === "failed") {
+        if (logger) {
+          logger.error("Registration confirmation failed");
+        }
+        throw new Error("Registration confirmation failed");
+      }
+      if (logger) {
+        logger.info(
+          `Registration still pending. Waiting ${delayMs}ms before next attempt`
+        );
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+      attempts++;
+    }
+    if (logger) {
+      logger.warn(`Registration not confirmed after ${maxAttempts} attempts`);
+    }
+    return false;
+  }
+  async executeRegistration(accountId, inboundTopicId, network, baseUrl, logger, metadata = { tags: [] }) {
+    var _a;
+    try {
+      if (logger) {
+        logger.info("Registering agent with guarded registry");
+      }
+      const response = await fetch(`${baseUrl}/api/request-register`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "*/*",
+          "Accept-Language": "en;q=0.5",
+          Origin: baseUrl,
+          Referer: `${baseUrl}/`,
+          "X-Network": network
+        },
+        body: JSON.stringify({
+          accountId,
+          inboundTopicId,
+          metadata
+        })
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        if (((_a = data.details) == null ? void 0 : _a.length) > 0) {
+          return {
+            validationErrors: data.details,
+            error: data.error || "Validation failed",
+            success: false
+          };
+        }
+        return {
+          error: data.error || "Failed to register agent",
+          success: false
+        };
+      }
+      if (logger) {
+        logger.info(
+          `Created new registration request. Transaction ID: ${data.transaction_id}`
+        );
+      }
+      return {
+        transactionId: data.transaction_id,
+        transaction: data.transaction,
+        success: true
+      };
+    } catch (error) {
+      return {
+        error: `Error during registration request: ${error.message}`,
+        success: false
+      };
+    }
+  }
+  async findRegistrations(options = {}, baseUrl = "https://hcs-10.hashgraphonline.com") {
+    var _a;
+    try {
+      const queryParams = new URLSearchParams();
+      (_a = options.tags) == null ? void 0 : _a.forEach((tag) => queryParams.append("tags", tag));
+      if (options.accountId) {
+        queryParams.append("accountId", options.accountId);
+      }
+      if (options.network) {
+        queryParams.append("network", options.network);
+      }
+      const response = await fetch(
+        `${baseUrl}/api/registrations?${queryParams}`,
+        {
+          headers: {
+            Accept: "*/*",
+            "Accept-Language": "en;q=0.5",
+            Origin: baseUrl,
+            Referer: `${baseUrl}/`
+          }
+        }
+      );
+      if (!response.ok) {
+        const error = await response.text();
+        return {
+          registrations: [],
+          error: error || "Failed to fetch registrations",
+          success: false
+        };
+      }
+      const data = await response.json();
+      if (data.error) {
+        return {
+          registrations: [],
+          error: data.error,
+          success: false
+        };
+      }
+      return {
+        registrations: data.registrations || [],
+        success: true
+      };
+    } catch (e) {
+      const error = e;
+      return {
+        registrations: [],
+        error: `Error fetching registrations: ${error.message}`,
+        success: false
+      };
+    }
+  }
+}
 class HCS10BaseClient extends Registration {
   constructor(config) {
     super();
@@ -15746,25 +15746,31 @@ class HCS10BaseClient extends Registration {
     }
     return topicInfo;
   }
-  async retrieveOutboundConnectTopic(accountId) {
-    this.logger.info(`Retrieving topics for account: ${accountId}`);
-    const cachedInfo = await this.getTopicInfo(accountId);
-    if (cachedInfo) return cachedInfo;
+  async retrieveProfile(accountId) {
+    this.logger.info(`Retrieving profile for account: ${accountId}`);
     try {
       const accountMemo = await this.getAccountMemo(accountId);
       if (!accountMemo) {
-        throw new Error(`Failed to retrieve memo for account ID: ${accountId}`);
+        return {
+          profile: null,
+          success: false,
+          error: `Failed to retrieve memo for account ID: ${accountId}`
+        };
       }
       if (!accountMemo.startsWith("hcs-11:")) {
-        throw new Error(
-          `Invalid memo format: ${accountMemo}. Memo must start with 'hcs-11:'`
-        );
+        return {
+          profile: null,
+          success: false,
+          error: `Invalid memo format: ${accountMemo}. Memo must start with 'hcs-11:'`
+        };
       }
       const hrlMatch = accountMemo.match(/^hcs-11:hcs:\/\/(\d+)\/(.+)$/);
       if (!hrlMatch) {
-        throw new Error(
-          `Invalid HCS-11 memo format: ${accountMemo}. Expected format: hcs-11:hcs://{standard}/{topicId}`
-        );
+        return {
+          profile: null,
+          success: false,
+          error: `Invalid HCS-11 memo format: ${accountMemo}. Expected format: hcs-11:hcs://{standard}/{topicId}`
+        };
       }
       const [, standard, profileTopicId] = hrlMatch;
       this.logger.info(
@@ -15773,11 +15779,47 @@ class HCS10BaseClient extends Registration {
       const cdnUrl = `https://kiloscribe.com/api/inscription-cdn/${profileTopicId}?network=${this.network}`;
       const profileResponse = await axios.get(cdnUrl);
       if (!profileResponse.data) {
-        throw new Error(
-          `Failed to fetch profile from topic: ${profileTopicId}`
-        );
+        return {
+          profile: null,
+          success: false,
+          error: `Failed to fetch profile from topic: ${profileTopicId}`
+        };
       }
       const profile = profileResponse.data;
+      let topicInfo = null;
+      if (profile.inboundTopicId && profile.outboundTopicId) {
+        topicInfo = {
+          inboundTopic: profile.inboundTopicId,
+          outboundTopic: profile.outboundTopicId
+        };
+        const cacheKey = `${accountId}-${this.network}`;
+        HCS10Cache.getInstance().set(cacheKey, topicInfo);
+      }
+      return {
+        profile,
+        topicInfo,
+        profileTopicId,
+        success: true
+      };
+    } catch (error) {
+      this.logger.error("Failed to retrieve profile:", error);
+      return {
+        profile: null,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async retrieveOutboundConnectTopic(accountId) {
+    this.logger.info(`Retrieving topics for account: ${accountId}`);
+    const cachedInfo = await this.getTopicInfo(accountId);
+    if (cachedInfo) return cachedInfo;
+    try {
+      const profileResponse = await this.retrieveProfile(accountId);
+      if (!profileResponse.success) {
+        throw new Error(profileResponse.error);
+      }
+      const profile = profileResponse.profile;
       if (!profile.inboundTopicId || !profile.outboundTopicId) {
         throw new Error(
           `Invalid HCS-11 profile for HCS-10 agent: missing inboundTopicId or outboundTopicId`
@@ -15797,9 +15839,7 @@ class HCS10BaseClient extends Registration {
   }
   async retrieveOutboundMessages(agentAccountId) {
     try {
-      const topicInfo = await this.retrieveOutboundConnectTopic(
-        agentAccountId
-      );
+      const topicInfo = await this.retrieveOutboundConnectTopic(agentAccountId);
       if (!topicInfo) {
         this.logger.warn(
           `No outbound connect topic found for agentAccountId: ${agentAccountId}`
@@ -15834,6 +15874,37 @@ class HCS10BaseClient extends Registration {
   clearCache() {
     HCS10Cache.getInstance().clear();
   }
+  /**
+   * Gets message content, resolving any HRL references if needed
+   * @param data The message data which might be an HRL reference
+   * @returns The resolved content
+   */
+  async getMessageContent(data) {
+    const hrlPattern = /^hcs:\/\/(\d+)\/([0-9.]+)$/;
+    const match = data.match(hrlPattern);
+    if (!match) {
+      return data;
+    }
+    const [_, standard, topicId] = match;
+    this.logger.info(
+      `Resolving HRL reference: standard=${standard}, topicId=${topicId}`
+    );
+    try {
+      const cdnUrl = `https://kiloscribe.com/api/inscription-cdn/${topicId}?network=${this.network}`;
+      const response = await axios.get(cdnUrl);
+      if (!response.data) {
+        throw new Error(`Failed to fetch content from topic: ${topicId}`);
+      }
+      return response.data.content || response.data.text || JSON.stringify(response.data);
+    } catch (error) {
+      this.logger.error(
+        `Error resolving HRL reference: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      throw new Error(
+        `Failed to resolve HRL reference: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
 }
 class HCS10Cache {
   constructor() {
@@ -32410,6 +32481,35 @@ class HCS10Client extends HCS10BaseClient {
       data,
       m: memo
     };
+    const payloadString = JSON.stringify(payload);
+    const isLargePayload = Buffer2.from(payloadString).length > 1e3;
+    if (isLargePayload) {
+      this.logger.info(
+        "Message payload exceeds 1000 bytes, storing via inscription"
+      );
+      try {
+        const contentBuffer = Buffer2.from(data);
+        const fileName = `message-${Date.now()}.json`;
+        const inscriptionResult = await this.inscribeFile(
+          contentBuffer,
+          fileName
+        );
+        if (inscriptionResult == null ? void 0 : 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,
@@ -32467,9 +32567,9 @@ class HCS10Client extends HCS10BaseClient {
   async submitPayload(topicId, payload, submitKey, requiresFee = false) {
     const message = typeof payload === "string" ? payload : JSON.stringify(payload);
     const payloadSizeInBytes = Buffer2.byteLength(message, "utf8");
-    if (payloadSizeInBytes > 1024) {
+    if (payloadSizeInBytes > 1e3) {
       throw new PayloadSizeError(
-        "Payload size exceeds 1 KB limit",
+        "Payload size exceeds 1000 bytes limit",
         payloadSizeInBytes
       );
     }
@@ -33056,6 +33156,34 @@ class BrowserHCSClient extends HCS10BaseClient {
       data,
       m: memo
     };
+    const payloadString = JSON.stringify(payload);
+    const isLargePayload = Buffer2.from(payloadString).length > 1e3;
+    if (isLargePayload) {
+      this.logger.info(
+        "Message payload exceeds 1000 bytes, storing via inscription"
+      );
+      try {
+        const contentBuffer = Buffer2.from(data);
+        const fileName = `message-${Date.now()}.json`;
+        const inscriptionResult = await this.inscribeFile(
+          contentBuffer,
+          fileName
+        );
+        if (inscriptionResult == null ? void 0 : 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"}`
+        );
+      }
+    }
     await this.submitPayload(connectionTopicId, payload);
   }
   async submitConnectionRequest(inboundTopicId, requestingAccountId, operatorId, memo) {