Add HCS to the agent kit

package.json

@@ -19,6 +19,7 @@
     "@langchain/core": "^0.3.26",
     "@langchain/langgraph": "^0.2.34",
     "@langchain/openai": "^0.3.16",
+    "axios": "^1.7.9",
     "dotenv": "^16.4.7"
   },
   "repository": {

src/hederaConsensusService.ts

@@ -0,0 +1,93 @@
+import {
+    Client,
+    TopicCreateTransaction,
+    TopicUpdateTransaction,
+    TopicDeleteTransaction,
+    TopicMessageSubmitTransaction,
+    TopicMessageQuery,
+    TopicId,
+    TransactionReceipt
+} from "@hashgraph/sdk";
+import axios from "axios";
+
+export class HederaConsensusService {
+    client: Client;
+
+    constructor(client: Client) {
+        this.client = client;
+    }
+
+    // Create a new consensus topic with an optional memo.
+    async createTopic(topicMemo?: string): Promise<TopicId> {
+        const txResponse = await new TopicCreateTransaction()
+            .setTopicMemo(topicMemo || "Default Topic")
+            .execute(this.client);
+
+        const receipt: TransactionReceipt = await txResponse.getReceipt(this.client);
+        if (!receipt.topicId) {
+            throw new Error("Failed to create topic.");
+        }
+        return receipt.topicId;
+    }
+
+    // Update an existing topic's memo.
+    async updateTopic(topicId: string, topicMemo: string): Promise<void> {
+        await new TopicUpdateTransaction()
+            .setTopicId(topicId)
+            .setTopicMemo(topicMemo)
+            .execute(this.client);
+        // Optionally, you could retrieve the receipt to confirm the update.
+    }
+
+    // Delete an existing topic.
+    async deleteTopic(topicId: string): Promise<void> {
+        await new TopicDeleteTransaction()
+            .setTopicId(topicId)
+            .execute(this.client);
+    }
+
+    // Submit a message to a consensus topic.
+    async submitMessage(topicId: string, message: string): Promise<void> {
+        await new TopicMessageSubmitTransaction()
+            .setTopicId(topicId)
+            .setMessage(message)
+            .execute(this.client);
+    }
+
+    // Query recent messages for a consensus topic.
+    // This implementation uses axios to poll the public mirror node REST API with pagination
+    // until all available messages are retrieved.
+    async queryTopic(topicId: string, duration: number = 5000, limit: number = 10): Promise<any[]> {
+        // Determine the base URL for the mirror node REST API.
+        const baseUrl = process.env.HEDERA_NETWORK === "mainnet"
+            ? "https://mainnet.mirrornode.hedera.com"
+            : "https://testnet.mirrornode.hedera.com";
+
+        let messages: any[] = [];
+        // Construct the initial query URL.
+        let url: string | null = `${baseUrl}/api/v1/topics/${topicId}/messages?limit=${limit}`;
+
+        // Wait a short duration to ensure messages are indexed.
+        await new Promise((resolve) => setTimeout(resolve, duration));
+
+        // Loop to fetch messages until no "next" page is available.
+        while (url) {
+            try {
+                const response = await axios.get(url);
+                const data = response.data;
+
+                if (data.messages && data.messages.length > 0) {
+                    messages.push(...data.messages);
+                }
+
+                // The REST response may include a "links" object with a "next" property for pagination.
+                url = data.links && data.links.next ? baseUrl + data.links.next : null;
+            } catch (error) {
+                console.error("Error querying topic messages via REST:", error);
+                break;
+            }
+        }
+
+        return messages;
+    }
+} 

src/langchain/index.ts

@@ -1,5 +1,6 @@
 import { Tool } from "@langchain/core/tools";
 import HederaAgentKit from "../agent";
+import { HederaConsensusService } from "../hederaConsensusService";
 
 
 export class HederaCreateFungibleTokenTool extends Tool {
@@ -62,7 +63,7 @@ amount: number, the amount of tokens to transfer e.g. 100
   protected async _call(input: string): Promise<string> {
     try {
       const parsedInput = JSON.parse(input);
-      
+
       await this.hederaKit.transferToken(
         parsedInput.tokenId,
         parsedInput.toAccountId,
@@ -141,7 +142,7 @@ Example input: {
   protected async _call(input: string): Promise<string> {
     try {
       const parsedInput = JSON.parse(input);
-      
+
       await this.hederaKit.airdropToken(
         parsedInput.tokenId,
         parsedInput.recipients
@@ -164,11 +165,172 @@ Example input: {
   }
 }
 
-export function createHederaTools(hederaKit: HederaAgentKit): Tool[] {
+export class HederaCreateTopicTool extends Tool {
+  name = "hedera_create_topic";
+  description = `Create a consensus topic on Hedera.
+  Inputs (a JSON string):
+    { "topicMemo": string (optional) }
+  This tool creates a new consensus topic that allows the agent to publish messages 
+  for on-chain communications. The 'topicMemo' describes the purpose of the topic.
+  Example: { "topicMemo": "Discussion on Hedera Consensus Service" }
+  `;
+
+  constructor(private hederaConsensus: HederaConsensusService) {
+    super();
+  }
+
+  protected async _call(input: string): Promise<string> {
+    try {
+      const parsed = JSON.parse(input);
+      const topicId = await this.hederaConsensus.createTopic(parsed.topicMemo);
+      return JSON.stringify({
+        status: "success",
+        topicId: topicId.toString(),
+        memo: parsed.topicMemo || "Default Topic"
+      });
+    } catch (error: any) {
+      return JSON.stringify({
+        status: "error",
+        message: error.message
+      });
+    }
+  }
+}
+
+export class HederaUpdateTopicTool extends Tool {
+  name = "hedera_update_topic";
+  description = `Update the memo (description) of an existing Hedera consensus topic.
+  Inputs (a JSON string):
+    { "topicId": string, "topicMemo": string }
+  The new memo helps describe the purpose or context of the topic.
+  `;
+
+  constructor(private hederaConsensus: HederaConsensusService) {
+    super();
+  }
+
+  protected async _call(input: string): Promise<string> {
+    try {
+      const { topicId, topicMemo } = JSON.parse(input);
+      await this.hederaConsensus.updateTopic(topicId, topicMemo);
+      return JSON.stringify({
+        status: "success",
+        message: "Topic memo updated",
+        topicId: topicId,
+        newMemo: topicMemo
+      });
+    } catch (error: any) {
+      return JSON.stringify({
+        status: "error",
+        message: error.message
+      });
+    }
+  }
+}
+
+export class HederaDeleteTopicTool extends Tool {
+  name = "hedera_delete_topic";
+  description = `Delete an existing Hedera consensus topic.
+  Inputs (a JSON string):
+    { "topicId": string }
+  Use this tool cautiously as deleting a topic is irreversible.
+  `;
+
+  constructor(private hederaConsensus: HederaConsensusService) {
+    super();
+  }
+
+  protected async _call(input: string): Promise<string> {
+    try {
+      const { topicId } = JSON.parse(input);
+      await this.hederaConsensus.deleteTopic(topicId);
+      return JSON.stringify({
+        status: "success",
+        message: "Topic deleted",
+        topicId: topicId
+      });
+    } catch (error: any) {
+      return JSON.stringify({
+        status: "error",
+        message: error.message
+      });
+    }
+  }
+}
+
+export class HederaSubmitMessageTool extends Tool {
+  name = "hedera_submit_message";
+  description = `Submit a message to a Hedera consensus topic.
+  Inputs (a JSON string):
+    { "topicId": string, "message": string }
+  This tool posts textual updates or instructions to the specified topic.
+  `;
+
+  constructor(private hederaConsensus: HederaConsensusService) {
+    super();
+  }
+
+  protected async _call(input: string): Promise<string> {
+    try {
+      const { topicId, message } = JSON.parse(input);
+      await this.hederaConsensus.submitMessage(topicId, message);
+      return JSON.stringify({
+        status: "success",
+        message: "Message submitted to topic",
+        topicId: topicId
+      });
+    } catch (error: any) {
+      return JSON.stringify({
+        status: "error",
+        message: error.message
+      });
+    }
+  }
+}
+
+export class HederaQueryTopicTool extends Tool {
+  name = "hedera_query_topic";
+  description = `Query messages from a Hedera consensus topic.
+  Inputs (a JSON string):
+    { "topicId": string, "duration": number (optional), "limit": number (optional) }
+  This tool collects and returns messages from a topic for the specified duration and limit.
+  `;
+
+  constructor(private hederaConsensus: HederaConsensusService) {
+    super();
+  }
+
+  protected async _call(input: string): Promise<string> {
+    try {
+      const parsed = JSON.parse(input);
+      const topicId = parsed.topicId;
+      const duration = parsed.duration || 5000;
+      const limit = parsed.limit || 10;
+      const messages = await this.hederaConsensus.queryTopic(topicId, duration, limit);
+      return JSON.stringify({
+        status: "success",
+        topicId,
+        messages
+      });
+    } catch (error: any) {
+      return JSON.stringify({
+        status: "error",
+        message: error.message
+      });
+    }
+  }
+}
+
+export function createHederaTools(hederaKit: HederaAgentKit, hederaConsensus: HederaConsensusService): Tool[] {
   return [
     new HederaCreateFungibleTokenTool(hederaKit),
     new HederaTransferTokenTool(hederaKit),
     new HederaGetBalanceTool(hederaKit),
-    new HederaAirdropTokenTool(hederaKit)
+    new HederaAirdropTokenTool(hederaKit),
+    new HederaCreateTopicTool(hederaConsensus),
+    new HederaUpdateTopicTool(hederaConsensus),
+    new HederaDeleteTopicTool(hederaConsensus),
+    new HederaSubmitMessageTool(hederaConsensus),
+    new HederaQueryTopicTool(hederaConsensus)
   ]
 }