Create a Topic

import {
  Client,
  TopicCreateTransaction,
  TopicMessageSubmitTransaction,
} from "@hashgraph/sdk";

async function createTopicDemo() {
// load your operator credentials
const operatorId = process.env.OPERATOR_ID;
const operatorKey = process.env.OPERATOR_KEY;

// initialize the client for testnet
const client = Client.forTestnet().setOperator(operatorId, operatorKey);

// build & execute the topic creation transaction
const transaction = new TopicCreateTransaction().setTopicMemo(
"My first HCS topic"
);

const txResponse = await transaction.execute(client);
const receipt = await txResponse.getReceipt(client);
const topicId = receipt.topicId;

console.log(`\nTopic created: ${topicId}`);

// build & execute the message submission transaction
const message = "Hello, Hedera!";

const messageTransaction = new TopicMessageSubmitTransaction()
.setTopicId(topicId)
.setMessage(message);

await messageTransaction.execute(client);

console.log(`\nMessage submitted: ${message}`);

// wait for Mirror Node to populate data
console.log("\nWaiting for Mirror Node to update...");
await new Promise((resolve) => setTimeout(resolve, 6000));

// query messages using Mirror Node
const mirrorNodeUrl = `https://testnet.mirrornode.hedera.com/api/v1/topics/${topicId}/messages`;

const response = await fetch(mirrorNodeUrl);
const data = await response.json();

if (data.messages && data.messages.length > 0) {
const latestMessage = data.messages[data.messages.length - 1];
const messageContent = Buffer.from(latestMessage.message, "base64")
.toString("utf8")
.trim();

    console.log(`\nLatest message: ${messageContent}\n`);

} else {
console.log("No messages found yet in Mirror Node");
}

client.close();
}

createTopicDemo().catch(console.error);

import com.hedera.hashgraph.sdk.*;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.google.gson.JsonArray;

public class CreateTopicDemo {
    public static void main(String[] args ) throws Exception {
        // load your operator credentials
        String operatorId = System.getenv("OPERATOR_ID");
        String operatorKey = System.getenv("OPERATOR_KEY");

        // initialize the client for testnet
        Client client = Client.forTestnet()
            .setOperator(AccountId.fromString(operatorId), PrivateKey.fromString(operatorKey));

        // build & execute the topic creation transaction
        TopicCreateTransaction transaction = new TopicCreateTransaction()
            .setTopicMemo("My first HCS topic");

        TransactionResponse txResponse = transaction.execute(client);
        TransactionReceipt receipt = txResponse.getReceipt(client);
        TopicId topicId = receipt.topicId;

        System.out.println("\nTopic created: " + topicId);

        // build & execute the message submission transaction
        String message = "Hello, Hedera!";

        TopicMessageSubmitTransaction messageTransaction = new TopicMessageSubmitTransaction()
            .setTopicId(topicId)
            .setMessage(message);

        messageTransaction.execute(client);

        System.out.println("\nMessage submitted: " + message);

        // wait for Mirror Node to populate data
        System.out.println("\nWaiting for Mirror Node to update...");
        Thread.sleep(6000);

        // query messages using Mirror Node
        String mirrorNodeUrl = "https://testnet.mirrornode.hedera.com/api/v1/topics/" + topicId + "/messages";

        HttpClient httpClient = HttpClient.newHttpClient( );
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(mirrorNodeUrl))
            .build();

        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString( ));
        Gson gson = new Gson();
        JsonObject data = gson.fromJson(response.body(), JsonObject.class);

        if (data.has("messages") && data.getAsJsonArray("messages").size() > 0) {
            JsonArray messages = data.getAsJsonArray("messages");
            JsonObject latestMessage = messages.get(messages.size() - 1).getAsJsonObject();
            String encodedMessage = latestMessage.get("message").getAsString();
            String messageContent = new String(java.util.Base64.getDecoder().decode(encodedMessage)).trim();

            System.out.println("\nLatest message: " + messageContent + "\n");
        } else {
            System.out.println("No messages found yet in Mirror Node");
        }

        client.close();
    }
}

package main

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
	"time"

    hedera "github.com/hiero-ledger/hiero-sdk-go/v2/sdk"

)

func main() {
// load your operator credentials
operatorId, _ := hedera.AccountIDFromString(os.Getenv("OPERATOR_ID"))
operatorKey, _ := hedera.PrivateKeyFromString(os.Getenv("OPERATOR_KEY"))

    // initialize the client for testnet
    client := hedera.ClientForTestnet()
    client.SetOperator(operatorId, operatorKey)

    // build & execute the topic creation transaction
    transaction := hedera.NewTopicCreateTransaction().
    	SetTopicMemo("My first HCS topic")

    txResponse, err := transaction.Execute(client)
    if err != nil {
    	panic(err)
    }

    receipt, err := txResponse.GetReceipt(client)
    if err != nil {
    	panic(err)
    }

    topicID := *receipt.TopicID

    fmt.Println("\nTopic created:", topicID.String())

    // build & execute the message submission transaction
    message := "Hello, Hedera!"

    messageTransaction := hedera.NewTopicMessageSubmitTransaction().
    	SetTopicID(topicID).
    	SetMessage([]byte(message))

    _, err = messageTransaction.Execute(client)
    if err != nil {
    	panic(err)
    }

    fmt.Printf("\nMessage submitted: %s\n", message)

    // Wait for Mirror Node to populate data
    fmt.Println("\nWaiting for Mirror Node to update...")
    time.Sleep(6 * time.Second)

    // query messages using Mirror Node
    mirrorNodeUrl := "https://testnet.mirrornode.hedera.com/api/v1/topics/" + topicID.String() + "/messages"

    resp, err := http.Get(mirrorNodeUrl)
    if err != nil {
    	panic(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
    	panic(err)
    }

    var data struct {
    	Messages []struct {
    		Message string `json:"message"`
    	} `json:"messages"`
    }

    err = json.Unmarshal(body, &data)
    if err != nil {
    	panic(err)
    }

    if len(data.Messages) > 0 {
    	latestMessage := data.Messages[len(data.Messages)-1]
    	decodedMessage, _ := base64.StdEncoding.DecodeString(latestMessage.Message)

    	fmt.Println("\nLatest message:", strings.TrimSpace(string(decodedMessage)))
    } else {
    	fmt.Println("No messages found yet in Mirror Node")
    }

    client.Close()

}

import os
import time
import base64
import requests

from hiero_sdk_python import (
    Client,
    AccountId,
    PrivateKey,
    TopicCreateTransaction,
    TopicMessageSubmitTransaction,
)

# load your operator credentials
operatorId = AccountId.from_string(os.getenv("OPERATOR_ID", ""))
operatorKey = PrivateKey.from_string(os.getenv("OPERATOR_KEY", ""))

# initialize the client for testnet
client = Client()
client.set_operator(operatorId, operatorKey)

# build & execute the topic creation transaction
transaction = (
    TopicCreateTransaction(
        memo="My first HCS topic",
        admin_key=operatorKey.public_key()
    )
    .freeze_with(client)
    .sign(operatorKey)
)

receipt = transaction.execute(client)
topicId = receipt.topic_id

print(f"\nTopic created: {topicId}")

# build & execute the message submission transaction
message = "Hello, Hedera!"

message_transaction = (
    TopicMessageSubmitTransaction()
    .set_topic_id(topicId)
    .set_message(message)
    .freeze_with(client)
    .sign(operatorKey)
)

message_transaction.execute(client)

print(f"\nMessage submitted: {message}")

# wait for Mirror Node to populate data
print("\nWaiting for Mirror Node to update...")
time.sleep(6)

# query messages using Mirror Node
mirror_node_url = f"https://testnet.mirrornode.hedera.com/api/v1/topics/{topicId}/messages"

response = requests.get(mirror_node_url, timeout=10)
response.raise_for_status()
data = response.json()

messages = data.get("messages", [])
if messages:
    latest_message = messages[-1]
    encoded_message = latest_message.get("message", "")
    message_content = base64.b64decode(encoded_message).decode("utf-8").strip()

    print(f"\nLatest message: {message_content}\n")
else:
    print("No messages found yet in Mirror Node")

client.close()