Submit Message to Private Topic

import com.hedera.hashgraph.sdk.*;
import io.github.cdimascio.dotenv.Dotenv;

import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class CreateTopicTutorial {
public static void main(String[] args) throws TimeoutException, PrecheckStatusException, ReceiptStatusException, InterruptedException {

        // Grab your Hedera testnet account ID and private key
        AccountId operatorId = AccountId.fromString(Dotenv.load().get("OPERATOR_ID"));
        PrivateKey operatorKey = PrivateKey.fromString(Dotenv.load().get("OPERATOR_KEY"));

        // Build your Hedera client
        Client client = Client.forTestnet();
        client.setOperator(operatorId, operatorKey);

        // Create a new topic
        TransactionResponse txResponse = new TopicCreateTransaction()
                .setSubmitKey(operatorKey.getPublicKey())
                .execute(client);

        // Get the receipt
        TransactionReceipt receipt = txResponse.getReceipt(client);

        // Get the topic ID
        TopicId topicId = receipt.topicId;

        // Log the topic ID
        System.out.println("Your topic ID is: " +topicId);

        // Wait 5 seconds between consensus topic creation and subscription creation
        Thread.sleep(5000);

        // Subscribe to the topic
        new TopicMessageQuery()
                .setTopicId(topicId)
                .subscribe(client, resp -> {
                    String messageAsString = new String(resp.contents, StandardCharsets.UTF_8);
                    System.out.println(resp.consensusTimestamp + " received topic message: " + messageAsString);
                });

        // Send message to private topic
        TransactionResponse submitMessage = new TopicMessageSubmitTransaction()
              .setTopicId(topicId)
              .setMessage("Submitkey set!")
              .freezeWith(client)
              .sign(operatorKey)
              .execute(client)

        // Get the receipt of the transaction
        TransactionReceipt receipt2 = submitMessage.getReceipt(client);

        // Wait before the main thread exits to return the topic message to the console
        Thread.sleep(30000);
    }

}

console.clear();
import dotenv from "dotenv";
dotenv.config();

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

// Grab the OPERATOR_ID and OPERATOR_KEY from the .env file
const operatorId = process.env.OPERATOR_ID;
const operatorKeyStr = process.env.OPERATOR_KEY;

// Parse the private key because we use .publicKey and .sign(...)
const operatorKey = PrivateKey.fromString(operatorKeyStr);

// Build Hedera testnet and mirror node client
const client = Client.forTestnet();
client.setOperator(AccountId.fromString(operatorId), operatorKey);

async function submitPrivateMessage() {
  // create a new topic with a submit key
  const txResponse = await new TopicCreateTransaction()
    .setSubmitKey(operatorKey.publicKey)
    .execute(client);

  const receipt = await txResponse.getReceipt(client);
  const topicId = receipt.topicId;
  console.log(`Your topic ID is: ${topicId}`);

  // give the mirror a moment before subscribing
  await new Promise((resolve) => setTimeout(resolve, 5000));

  // subscribe
  new TopicMessageQuery()
    .setTopicId(topicId)
    .subscribe(client, null, (message) => {
      const messageAsString = Buffer.from(message.contents).toString("utf8");
      console.log(
        `${message.consensusTimestamp.toDate()} Received: ${messageAsString}`
      );
    });

  // send message to private topic
  const submitMsgTx = await new TopicMessageSubmitTransaction({
    topicId,
    message: "Submitkey set!",
  })
    .freezeWith(client)
    .sign(operatorKey);

  const submitMsgTxSubmit = await submitMsgTx.execute(client);
  const getReceipt = await submitMsgTxSubmit.getReceipt(client);

  // status
  const transactionStatus = getReceipt.status;
  console.log(
    "The message transaction status: " + transactionStatus.toString()
  );
}

submitPrivateMessage();

package main

import (
	"fmt"
	"os"
	"time"

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

)

func main() {

    // Loads the .env file and throws an error if it cannot load the variables from that file corectly
    err := godotenv.Load(".env")
    if err != nil {
    	panic(fmt.Errorf("Unable to load enviroment variables from .env file. Error:n%v\n", err))
    }

    // Grab your testnet account ID and private key from the .env file
    operatorId, err := hedera.AccountIDFromString(os.Getenv("OPERATOR_ID"))
    if err != nil {
    	panic(err)
    }

    operatorKey, err := hedera.PrivateKeyFromString(os.Getenv("OPERATOR_KEY"))
    if err != nil {
    	panic(err)
    }

    // Create your testnet client
    client := hedera.ClientForTestnet()
    client.SetOperator(operatorId, operatorKey)

    // Create a new topic
    transactionResponse, err := hedera.NewTopicCreateTransaction().
    	SetSubmitKey(operatorKey.PublicKey()).
    	Execute(client)

    if err != nil {
    	println(err.Error(), ": error creating topic")
    	return
    }

    // Get the topic create transaction receipt
    transactionReceipt, err := transactionResponse.GetReceipt(client)

    if err != nil {
    	println(err.Error(), ": error getting topic create receipt")
    	return
    }

    // Get the topic ID from the transaction receipt
    topicID := *transactionReceipt.TopicID

    // Log the topic ID to the console
    fmt.Printf("topicID: %v\n", topicID)

    //Create the query to subscribe to a topic
    _, err = hedera.NewTopicMessageQuery().
    	SetTopicID(topicID).
    	Subscribe(client, func(message hedera.TopicMessage) {
    		fmt.Println(message.ConsensusTimestamp.String(), "received topic message ", string(message.Contents), "\r")
    	})

        // Prepare message to send to private topic
    submitMessageTx, err := hedera.NewTopicMessageSubmitTransaction().
    	SetMessage([]byte("Submitkey set!")).
    	SetTopicID(topicID).
    	FreezeWith(client)

    if err != nil {
    	println(err.Error(), ": error freezing topic message submit transaction")
    	return
    }

    // Sign message with submit key
    submitMessageTx.Sign(operatorKey)

    // Submit message
    submitTxResponse, err := submitMessageTx.Execute(client)
    if err != nil {
    	println(err.Error(), ": error submitting to topic")
    	return
    }

    // Get the receipt of the transaction
    receipt, err := submitTxResponse.GetReceipt(client)

    // Get the transaction status
    transactionStatus := receipt.Status
    fmt.Println("The message transaction status " + transactionStatus.String())

    // Prevent the program from exiting to display the message from the mirror node to the console
    time.Sleep(30 * time.Second)
    }