sd

Meeting.sol

@@ -52,7 +52,7 @@ contract Meeting {
     address private owner;
 
     // Events
-    event RoomCreated(string roomId, string name, address owner);
+    event RoomCreated(string roomId, string name, string metadata ,address owner ,uint256 timestamp, bool isActive);
     event JoinedRoom(string roomId, address user);
     event LeftRoom(string roomId, address user);
     event TrackPublished(string roomId, address participant, string trackName);
@@ -139,9 +139,11 @@ contract Meeting {
         rooms[roomId].isActive = true;
 
         roomIds.push(roomId);
-        emit RoomCreated(roomId, name, msg.sender);
+
+        emit RoomCreated(roomId, name, metadata , msg.sender, rooms[roomId].createdAt , true);
     }
 
+
     function setRoomStatus(string memory roomId, bool isActive) public roomMustExist(roomId) {
         require(rooms[roomId].owner == msg.sender || users[msg.sender].isModerator, "Not authorized");
         
@@ -193,6 +195,7 @@ contract Meeting {
         return bytes(rooms[roomId].name).length > 0;
     }
 
+
     // Participant management
     function joinRoom(string memory roomId) public roomMustExist(roomId) {
         require(rooms[roomId].participants[msg.sender].user == address(0), "Already joined");

callSM.go

@@ -0,0 +1,533 @@
+// package main
+
+// import (
+// 	"context"
+// 	"crypto/ecdsa"
+// 	"fmt"
+// 	"log"
+// 	"math/big"
+// 	"os"
+// 	"strings"
+
+// 	"github.com/ethereum/go-ethereum"
+// 	"github.com/ethereum/go-ethereum/accounts/abi"
+// 	"github.com/ethereum/go-ethereum/common"
+// 	"github.com/ethereum/go-ethereum/core/types"
+// 	"github.com/ethereum/go-ethereum/crypto"
+// 	"github.com/ethereum/go-ethereum/ethclient"
+// 	"github.com/joho/godotenv"
+// )
+
+// // Global variables
+// var (
+// 	client          *ethclient.Client
+// 	contractAddress common.Address
+// 	parsedABI       abi.ABI
+// 	privateKey      *ecdsa.PrivateKey
+// 	fromAddress     common.Address
+// 	chainID         *big.Int
+// )
+
+// func init() {
+// 	// Load environment variables
+// 	if err := godotenv.Load(); err != nil {
+// 		log.Fatal("Error loading .env file")
+// 	}
+
+// 	// Connect to the blockchain
+// 	var err error
+// 	client, err = ethclient.Dial("https://bsc-testnet.publicnode.com") // BSC Testnet
+// 	if err != nil {
+// 		log.Fatalf("Failed to connect to the blockchain: %v", err)
+// 	}
+
+// 	// Load contract information
+// 	contractAddress = common.HexToAddress(os.Getenv("CONTRACT_ADDRESS"))
+// 	parsedABI, err = abi.JSON(strings.NewReader(os.Getenv("ABI_JSON")))
+// 	if err != nil {
+// 		log.Fatalf("Failed to parse ABI: %v", err)
+// 	}
+
+// 	// Load private key
+// 	privateKey, err = crypto.HexToECDSA(os.Getenv("PRIVATE_KEY"))
+// 	if err != nil {
+// 		log.Fatalf("Failed to parse private key: %v", err)
+// 	}
+
+// 	// Get public key and address
+// 	publicKey := privateKey.Public()
+// 	publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
+// 	if !ok {
+// 		log.Fatal("Error converting public key")
+// 	}
+// 	fromAddress = crypto.PubkeyToAddress(*publicKeyECDSA)
+
+// 	// Set chain ID for BSC Testnet
+// 	chainID = big.NewInt(97)
+
+// 	fmt.Printf("Connected to blockchain with address: %s\n", fromAddress.Hex())
+// }
+
+// // Read function example - getAllRooms
+// func getAllRooms() {
+// 	callData, err := parsedABI.Pack("getAllRooms")
+// 	if err != nil {
+// 		log.Fatalf("Failed to pack call data: %v", err)
+// 	}
+
+// 	result, err := client.CallContract(context.Background(), ethereum.CallMsg{
+// 		To:   &contractAddress,
+// 		Data: callData,
+// 	}, nil)
+// 	if err != nil {
+// 		log.Fatalf("Failed to call getAllRooms: %v", err)
+// 	}
+
+// 	var roomIds []string
+// 	err = parsedABI.UnpackIntoInterface(&roomIds, "getAllRooms", result)
+// 	if err != nil {
+// 		log.Fatalf("Failed to unpack result: %v", err)
+// 	}
+
+// 	fmt.Println("All Room IDs:")
+// 	for i, roomId := range roomIds {
+// 		fmt.Printf("%d. %s\n", i+1, roomId)
+// 	}
+// }
+
+// // Read function - getRoomDetails
+// func getRoomDetails(roomId string) {
+// 	callData, err := parsedABI.Pack("getRoomDetails", roomId)
+// 	if err != nil {
+// 		log.Fatalf("Failed to pack call data: %v", err)
+// 	}
+
+// 	result, err := client.CallContract(context.Background(), ethereum.CallMsg{
+// 		To:   &contractAddress,
+// 		Data: callData,
+// 	}, nil)
+// 	if err != nil {
+// 		log.Fatalf("Failed to call getRoomDetails: %v", err)
+// 	}
+
+// 	// Unpack result
+// 	output, err := parsedABI.Unpack("getRoomDetails", result)
+// 	if err != nil {
+// 		log.Fatalf("Failed to unpack result: %v", err)
+// 	}
+
+// 	// Process output
+// 	if len(output) == 6 {
+// 		fmt.Println("Room Details:")
+// 		fmt.Printf("ID: %s\n", output[0].(string))
+// 		fmt.Printf("Name: %s\n", output[1].(string))
+// 		fmt.Printf("Metadata: %s\n", output[2].(string))
+// 		fmt.Printf("Owner: %s\n", output[3].(common.Address).Hex())
+// 		fmt.Printf("Created At: %s\n", output[4].(*big.Int).String())
+// 		fmt.Printf("Is Active: %t\n", output[5].(bool))
+// 	} else {
+// 		fmt.Println("Unexpected output format")
+// 	}
+// }
+
+// // Read function - getRoomParticipants
+// func getRoomParticipants(roomId string) {
+// 	callData, err := parsedABI.Pack("getRoomParticipants", roomId)
+// 	if err != nil {
+// 		log.Fatalf("Failed to pack call data: %v", err)
+// 	}
+
+// 	result, err := client.CallContract(context.Background(), ethereum.CallMsg{
+// 		To:   &contractAddress,
+// 		Data: callData,
+// 	}, nil)
+// 	if err != nil {
+// 		log.Fatalf("Failed to call getRoomParticipants: %v", err)
+// 	}
+
+// 	var participants []common.Address
+// 	err = parsedABI.UnpackIntoInterface(&participants, "getRoomParticipants", result)
+// 	if err != nil {
+// 		log.Fatalf("Failed to unpack result: %v", err)
+// 	}
+
+// 	fmt.Printf("Participants in room %s:\n", roomId)
+// 	for i, address := range participants {
+// 		fmt.Printf("%d. %s\n", i+1, address.Hex())
+// 	}
+// }
+
+// // Read function - getIceServers
+// func getIceServers() {
+// 	callData, err := parsedABI.Pack("getIceServers")
+// 	if err != nil {
+// 		log.Fatalf("Failed to pack call data: %v", err)
+// 	}
+
+// 	result, err := client.CallContract(context.Background(), ethereum.CallMsg{
+// 		To:   &contractAddress,
+// 		Data: callData,
+// 	}, nil)
+// 	if err != nil {
+// 		log.Fatalf("Failed to call getIceServers: %v", err)
+// 	}
+
+// 	// This is a bit trickier due to struct array return type
+// 	// Just showing raw result for now
+// 	fmt.Printf("ICE Servers Raw Result: %x\n", result)
+// }
+
+// // Write function - createRoom
+// func createRoom(roomId, name, metadata string) {
+// 	nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
+// 	if err != nil {
+// 		log.Fatalf("Failed to get nonce: %v", err)
+// 	}
+
+// 	gasPrice, err := client.SuggestGasPrice(context.Background())
+// 	if err != nil {
+// 		log.Fatalf("Failed to get gas price: %v", err)
+// 	}
+
+// 	// Pack the data for the function call
+// 	data, err := parsedABI.Pack("createRoom", roomId, name, metadata)
+// 	if err != nil {
+// 		log.Fatalf("Failed to pack transaction data: %v", err)
+// 	}
+
+// 	// Estimate gas
+// 	gasLimit := uint64(500000) // Default high value
+// 	estimatedGas, err := client.EstimateGas(context.Background(), ethereum.CallMsg{
+// 		From:  fromAddress,
+// 		To:    &contractAddress,
+// 		Value: big.NewInt(0),
+// 		Data:  data,
+// 	})
+
+// 	if err == nil {
+// 		// Add 20% buffer to estimated gas
+// 		gasLimit = uint64(float64(estimatedGas) * 1.2)
+// 		fmt.Printf("Gas estimate: %d, using: %d\n", estimatedGas, gasLimit)
+// 	} else {
+// 		fmt.Printf("Gas estimation failed: %v. Using default: %d\n", err, gasLimit)
+// 	}
+
+// 	// Create the transaction
+// 	tx := types.NewTransaction(nonce, contractAddress, big.NewInt(0), gasLimit, gasPrice, data)
+
+// 	// Sign the transaction
+// 	signedTx, err := types.SignTx(tx, types.NewLondonSigner(chainID), privateKey)
+// 	if err != nil {
+// 		log.Fatalf("Failed to sign transaction: %v", err)
+// 	}
+
+// 	// Send the transaction
+// 	err = client.SendTransaction(context.Background(), signedTx)
+// 	if err != nil {
+// 		log.Fatalf("Failed to send transaction: %v", err)
+// 	}
+
+// 	fmt.Printf("Transaction sent! Hash: %s\n", signedTx.Hash().Hex())
+// 	fmt.Println("Room creation initiated. Wait for the transaction to be mined.")
+// }
+
+// // Write function - joinRoom
+// func joinRoom(roomId string) {
+// 	nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
+// 	if err != nil {
+// 		log.Fatalf("Failed to get nonce: %v", err)
+// 	}
+
+// 	gasPrice, err := client.SuggestGasPrice(context.Background())
+// 	if err != nil {
+// 		log.Fatalf("Failed to get gas price: %v", err)
+// 	}
+
+// 	// Pack the data for the function call
+// 	data, err := parsedABI.Pack("joinRoom", roomId)
+// 	if err != nil {
+// 		log.Fatalf("Failed to pack transaction data: %v", err)
+// 	}
+
+// 	gasLimit := uint64(300000)
+
+// 	// Create the transaction
+// 	tx := types.NewTransaction(nonce, contractAddress, big.NewInt(0), gasLimit, gasPrice, data)
+
+// 	// Sign the transaction
+// 	signedTx, err := types.SignTx(tx, types.NewLondonSigner(chainID), privateKey)
+// 	if err != nil {
+// 		log.Fatalf("Failed to sign transaction: %v", err)
+// 	}
+
+// 	// Send the transaction
+// 	err = client.SendTransaction(context.Background(), signedTx)
+// 	if err != nil {
+// 		log.Fatalf("Failed to send transaction: %v", err)
+// 	}
+
+// 	fmt.Printf("Transaction sent! Hash: %s\n", signedTx.Hash().Hex())
+// 	fmt.Println("Room join initiated. Wait for the transaction to be mined.")
+// }
+
+// // Write function - leaveRoom
+// func leaveRoom(roomId string) {
+// 	nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
+// 	if err != nil {
+// 		log.Fatalf("Failed to get nonce: %v", err)
+// 	}
+
+// 	gasPrice, err := client.SuggestGasPrice(context.Background())
+// 	if err != nil {
+// 		log.Fatalf("Failed to get gas price: %v", err)
+// 	}
+
+// 	// Pack the data for the function call
+// 	data, err := parsedABI.Pack("leaveRoom", roomId)
+// 	if err != nil {
+// 		log.Fatalf("Failed to pack transaction data: %v", err)
+// 	}
+
+// 	gasLimit := uint64(300000)
+
+// 	// Create the transaction
+// 	tx := types.NewTransaction(nonce, contractAddress, big.NewInt(0), gasLimit, gasPrice, data)
+
+// 	// Sign the transaction
+// 	signedTx, err := types.SignTx(tx, types.NewLondonSigner(chainID), privateKey)
+// 	if err != nil {
+// 		log.Fatalf("Failed to sign transaction: %v", err)
+// 	}
+
+// 	// Send the transaction
+// 	err = client.SendTransaction(context.Background(), signedTx)
+// 	if err != nil {
+// 		log.Fatalf("Failed to send transaction: %v", err)
+// 	}
+
+// 	fmt.Printf("Transaction sent! Hash: %s\n", signedTx.Hash().Hex())
+// 	fmt.Println("Room leave initiated. Wait for the transaction to be mined.")
+// }
+
+// // Write function - saveSessionID
+// func saveSessionID(roomId, sessionID string) {
+// 	nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
+// 	if err != nil {
+// 		log.Fatalf("Failed to get nonce: %v", err)
+// 	}
+
+// 	gasPrice, err := client.SuggestGasPrice(context.Background())
+// 	if err != nil {
+// 		log.Fatalf("Failed to get gas price: %v", err)
+// 	}
+
+// 	// Pack the data for the function call
+// 	data, err := parsedABI.Pack("saveSessionID", roomId, sessionID)
+// 	if err != nil {
+// 		log.Fatalf("Failed to pack transaction data: %v", err)
+// 	}
+
+// 	gasLimit := uint64(300000)
+
+// 	// Create the transaction
+// 	tx := types.NewTransaction(nonce, contractAddress, big.NewInt(0), gasLimit, gasPrice, data)
+
+// 	// Sign the transaction
+// 	signedTx, err := types.SignTx(tx, types.NewLondonSigner(chainID), privateKey)
+// 	if err != nil {
+// 		log.Fatalf("Failed to sign transaction: %v", err)
+// 	}
+
+// 	// Send the transaction
+// 	err = client.SendTransaction(context.Background(), signedTx)
+// 	if err != nil {
+// 		log.Fatalf("Failed to send transaction: %v", err)
+// 	}
+
+// 	fmt.Printf("Transaction sent! Hash: %s\n", signedTx.Hash().Hex())
+// 	fmt.Println("Session ID save initiated. Wait for the transaction to be mined.")
+// }
+
+// // Write function - updateRoomMetadata
+// func updateRoomMetadata(roomId, key, value string) {
+// 	nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
+// 	if err != nil {
+// 		log.Fatalf("Failed to get nonce: %v", err)
+// 	}
+
+// 	gasPrice, err := client.SuggestGasPrice(context.Background())
+// 	if err != nil {
+// 		log.Fatalf("Failed to get gas price: %v", err)
+// 	}
+
+// 	// Pack the data for the function call
+// 	data, err := parsedABI.Pack("updateRoomMetadata", roomId, key, value)
+// 	if err != nil {
+// 		log.Fatalf("Failed to pack transaction data: %v", err)
+// 	}
+
+// 	gasLimit := uint64(300000)
+
+// 	// Create the transaction
+// 	tx := types.NewTransaction(nonce, contractAddress, big.NewInt(0), gasLimit, gasPrice, data)
+
+// 	// Sign the transaction
+// 	signedTx, err := types.SignTx(tx, types.NewLondonSigner(chainID), privateKey)
+// 	if err != nil {
+// 		log.Fatalf("Failed to sign transaction: %v", err)
+// 	}
+
+// 	// Send the transaction
+// 	err = client.SendTransaction(context.Background(), signedTx)
+// 	if err != nil {
+// 		log.Fatalf("Failed to send transaction: %v", err)
+// 	}
+
+// 	fmt.Printf("Transaction sent! Hash: %s\n", signedTx.Hash().Hex())
+// 	fmt.Println("Metadata update initiated. Wait for the transaction to be mined.")
+// }
+
+// // Write function - setRoomStatus
+// func setRoomStatus(roomId string, isActive bool) {
+// 	nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
+// 	if err != nil {
+// 		log.Fatalf("Failed to get nonce: %v", err)
+// 	}
+
+// 	gasPrice, err := client.SuggestGasPrice(context.Background())
+// 	if err != nil {
+// 		log.Fatalf("Failed to get gas price: %v", err)
+// 	}
+
+// 	// Pack the data for the function call
+// 	data, err := parsedABI.Pack("setRoomStatus", roomId, isActive)
+// 	if err != nil {
+// 		log.Fatalf("Failed to pack transaction data: %v", err)
+// 	}
+
+// 	gasLimit := uint64(300000)
+
+// 	// Create the transaction
+// 	tx := types.NewTransaction(nonce, contractAddress, big.NewInt(0), gasLimit, gasPrice, data)
+
+// 	// Sign the transaction
+// 	signedTx, err := types.SignTx(tx, types.NewLondonSigner(chainID), privateKey)
+// 	if err != nil {
+// 		log.Fatalf("Failed to sign transaction: %v", err)
+// 	}
+
+// 	// Send the transaction
+// 	err = client.SendTransaction(context.Background(), signedTx)
+// 	if err != nil {
+// 		log.Fatalf("Failed to send transaction: %v", err)
+// 	}
+
+// 	fmt.Printf("Transaction sent! Hash: %s\n", signedTx.Hash().Hex())
+// 	fmt.Println("Room status update initiated. Wait for the transaction to be mined.")
+// }
+
+// func main() {
+// 	fmt.Println("Smart Contract Testing Tool")
+// 	fmt.Println("===========================")
+
+// 	for {
+// 		fmt.Println("\nSelect an operation:")
+// 		fmt.Println("Read Operations:")
+// 		fmt.Println("1. Get All Rooms")
+// 		fmt.Println("2. Get Room Details")
+// 		fmt.Println("3. Get Room Participants")
+// 		fmt.Println("4. Get ICE Servers")
+// 		fmt.Println("\nWrite Operations:")
+// 		fmt.Println("5. Create Room")
+// 		fmt.Println("6. Join Room")
+// 		fmt.Println("7. Leave Room")
+// 		fmt.Println("8. Save Session ID")
+// 		fmt.Println("9. Update Room Metadata")
+// 		fmt.Println("10. Set Room Status")
+// 		fmt.Println("\n0. Exit")
+
+// 		var choice int
+// 		fmt.Print("\nEnter your choice: ")
+// 		fmt.Scan(&choice)
+
+// 		switch choice {
+// 		case 0:
+// 			fmt.Println("Exiting...")
+// 			return
+
+// 		case 1: // Get All Rooms
+// 			getAllRooms()
+
+// 		case 2: // Get Room Details
+// 			var roomId string
+// 			fmt.Print("Enter Room ID: ")
+// 			fmt.Scan(&roomId)
+// 			getRoomDetails(roomId)
+
+// 		case 3: // Get Room Participants
+// 			var roomId string
+// 			fmt.Print("Enter Room ID: ")
+// 			fmt.Scan(&roomId)
+// 			getRoomParticipants(roomId)
+
+// 		case 4: // Get ICE Servers
+// 			getIceServers()
+
+// 		case 5: // Create Room
+// 			var roomId, name, metadata string
+// 			fmt.Print("Enter Room ID: ")
+// 			fmt.Scan(&roomId)
+// 			fmt.Print("Enter Room Name: ")
+// 			fmt.Scan(&name)
+// 			fmt.Print("Enter Metadata (JSON string): ")
+// 			fmt.Scan(&metadata)
+// 			createRoom(roomId, name, metadata)
+
+// 		case 6: // Join Room
+// 			var roomId string
+// 			fmt.Print("Enter Room ID: ")
+// 			fmt.Scan(&roomId)
+// 			joinRoom(roomId)
+
+// 		case 7: // Leave Room
+// 			var roomId string
+// 			fmt.Print("Enter Room ID: ")
+// 			fmt.Scan(&roomId)
+// 			leaveRoom(roomId)
+
+// 		case 8: // Save Session ID
+// 			var roomId, sessionID string
+// 			fmt.Print("Enter Room ID: ")
+// 			fmt.Scan(&roomId)
+// 			fmt.Print("Enter Session ID: ")
+// 			fmt.Scan(&sessionID)
+// 			saveSessionID(roomId, sessionID)
+
+// 		case 9: // Update Room Metadata
+// 			var roomId, key, value string
+// 			fmt.Print("Enter Room ID: ")
+// 			fmt.Scan(&roomId)
+// 			fmt.Print("Enter Metadata Key: ")
+// 			fmt.Scan(&key)
+// 			fmt.Print("Enter Metadata Value: ")
+// 			fmt.Scan(&value)
+// 			updateRoomMetadata(roomId, key, value)
+
+// 		case 10: // Set Room Status
+// 			var roomId string
+// 			var status int
+// 			fmt.Print("Enter Room ID: ")
+// 			fmt.Scan(&roomId)
+// 			fmt.Print("Enter Status (1 for active, 0 for inactive): ")
+// 			fmt.Scan(&status)
+// 			isActive := status == 1
+// 			setRoomStatus(roomId, isActive)
+
+// 		default:
+// 			fmt.Println("Invalid choice. Please try again.")
+// 		}
+
+// 		fmt.Println("\nPress Enter to continue...")
+// 		fmt.Scanln() // Wait for Enter
+// 	}
+// }

luonghoatdong.md

@@ -0,0 +1,18 @@
+graph LR
+    A[Client (Frontend)] --> B(Backend Server - Go package main)
+    B --> C[Cloudflare Calls API]
+    B <--> D[WebSocket Connections]
+    B --> E[Data Storage (In-memory)]
+
+    subgraph "Backend Server (Go)"
+        B -- Gin HTTP Routes --> B1[Route Handlers]
+        B -- WebSocket Endpoint --> B2[WebSocket Handler]
+        B1 --> B3[Cloudflare API Functions]
+        B2 --> B4[Broadcast Functions]
+        B1 & B2 --> E
+    end
+
+    style B fill:#f9f,stroke:#333,stroke-width:2px
+    style C fill:#ccf,stroke:#333,stroke-width:1px
+    style D fill:#ccf,stroke:#333,stroke-width:1px
+    style E fill:#eee,stroke:#333,stroke-width:1px

main.go

@@ -3,7 +3,6 @@ package main
 import (
 	"bytes"
 	"context"
-	"crypto/ecdsa"
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/base64"
@@ -11,7 +10,6 @@ import (
 	"fmt"
 	"io"
 	"log"
-	"math/big"
 	"net/http"
 	"os"
 	"strconv"
@@ -19,10 +17,10 @@ import (
 	"sync"
 	"time"
 
+	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/gin-gonic/gin"
 	"github.com/golang-jwt/jwt/v5"
@@ -614,22 +612,12 @@ func serializeRoom(roomId string, room *Room) gin.H {
 
 // --- Route Handlers ---
 
-func createRoom(c *gin.Context) {
-	roomId := uuid.NewString()
-	var req struct {
-		Name     string                 `json:"name"`
-		Metadata map[string]interface{} `json:"metadata"`
-	}
-
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
+func createRoom(c *gin.Context, roomId string, name string, metadata map[string]interface{}) {
 
 	room := &Room{
 		RoomId:       roomId, // Thêm trường này
-		Name:         req.Name,
-		Metadata:     req.Metadata,
+		Name:         name,
+		Metadata:     metadata,
 		Participants: []*Participant{},
 		CreatedAt:    time.Now().Unix(),
 	}
@@ -638,13 +626,6 @@ func createRoom(c *gin.Context) {
 	rooms.m[roomId] = room
 	rooms.Unlock()
 
-	// Update data on the smart contract
-	err := updateRoomOnContract(roomId, req.Name, req.Metadata)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update smart contract", "details": err.Error()})
-		return
-	}
-
 	log.Printf("Room metadata: %s", room.Metadata)
 
 	// Trả về format giống Express
@@ -655,66 +636,7 @@ func createRoom(c *gin.Context) {
 		"participantCount": len(room.Participants),
 		"createdAt":        room.CreatedAt,
 	})
-}
-
-func updateRoomOnContract(roomId string, name string, metadata map[string]interface{}) error {
-	client, err := ethclient.Dial(RPC_URL)
-	if err != nil {
-		return fmt.Errorf("failed to connect to blockchain: %v", err)
-	}
-	defer client.Close()
-
-	contractAddress := common.HexToAddress(CONTRACT_ADDRESS)
-	parsedABI, err := abi.JSON(strings.NewReader(ABI_JSON))
-	if err != nil {
-		return fmt.Errorf("failed to parse ABI: %v", err)
-	}
-
-	privateKey, err := crypto.HexToECDSA(PRIVATE_KEY)
-	if err != nil {
-		return fmt.Errorf("failed to parse private key: %v", err)
-	}
-	publicKey := privateKey.Public()
-	publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
-	if !ok {
-		return fmt.Errorf("error converting public key")
-	}
-	fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
-
-	nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
-	if err != nil {
-		return fmt.Errorf("failed to get nonce: %v", err)
-	}
-	gasLimit := uint64(300000)
-	gasPrice, err := client.SuggestGasPrice(context.Background())
-	if err != nil {
-		return fmt.Errorf("failed to get gas price: %v", err)
-	}
-
-	metadataJSON, err := json.Marshal(metadata)
-	if err != nil {
-		return fmt.Errorf("failed to marshal metadata: %v", err)
-	}
-
-	data, err := parsedABI.Pack("createRoom", roomId, name, string(metadataJSON))
-	if err != nil {
-		return fmt.Errorf("failed to pack transaction data: %v", err)
-	}
 
-	tx := types.NewTransaction(nonce, contractAddress, big.NewInt(0), gasLimit, gasPrice, data)
-	chainID := big.NewInt(97) // BSC Testnet chain ID
-	signedTx, err := types.SignTx(tx, types.NewLondonSigner(chainID), privateKey)
-	if err != nil {
-		return fmt.Errorf("failed to sign transaction: %v", err)
-	}
-
-	err = client.SendTransaction(context.Background(), signedTx)
-	if err != nil {
-		return fmt.Errorf("failed to send transaction: %v", err)
-	}
-
-	log.Printf("Transaction sent! Hash: %s", signedTx.Hash().Hex())
-	return nil
 }
 
 func inspectRooms(c *gin.Context) {
@@ -1859,7 +1781,7 @@ func main() {
 	api := r.Group("/api", verifyToken)
 	{
 		// Match Express routes
-		api.POST("/rooms", createRoom)
+		// api.POST("/rooms", createRoom)
 		api.GET("/rooms", getRooms)
 		api.GET("/inspect-rooms", inspectRooms)
 		api.POST("/rooms/:roomId/join", joinRoom)
@@ -1887,4 +1809,48 @@ func main() {
 	if err := r.Run(":" + port); err != nil {
 		log.Fatal("Failed to start server:", err)
 	}
+
+	// Tạo Phòng và lắng nghe smrtract
+	client, err := ethclient.Dial(RPC_URL)
+	if err != nil {
+		log.Fatalf("Không thể kết nối đến BSC Testnet: %v", err)
+	}
+	fmt.Println("Đã kết nối đến BSC Testnet!")
+
+	contractAddress := common.HexToAddress(CONTRACT_ADDRESS)
+	query := ethereum.FilterQuery{
+		Addresses: []common.Address{contractAddress},
+	}
+
+	contractAbi, err := abi.JSON(strings.NewReader(ABI_JSON))
+	if err != nil {
+		log.Fatalf("Không thể phân tích ABI: %v", err)
+	}
+
+	logs := make(chan types.Log)
+	sub, err := client.SubscribeFilterLogs(context.Background(), query, logs)
+	fmt.Println("Đã kết nối đến BSC Testnet!", sub)
+	if err != nil {
+		log.Fatalf("Không thể đăng ký lắng nghe sự kiện: %v", err)
+	}
+	fmt.Println("Đang lắng nghe sự kiện RoomCreated...")
+
+	type RoomCreatedEvent struct {
+		RoomId    string         `abi:"roomId"`
+		Name      string         `abi:"name"`
+		Metadata  string         `abi:"metadata"`
+		Owner     common.Address `abi:"owner"`
+		Timestamp int64          `abi:"timestamp"`
+		IsActive  bool           `abi:"isActive"`
+	}
+	go func() {
+		for eventLog := range logs {
+			event := new(RoomCreatedEvent)
+			if err := contractAbi.UnpackIntoInterface(event, "RoomCreated", eventLog.Data); err != nil {
+				log.Printf("Lỗi giải mã sự kiện: %v", err)
+				continue
+			}
+			fmt.Printf("Sự kiện RoomCreated: RoomId=%s, Name=%s, Owner=%s\n", event.RoomId, event.Name, event.Owner.Hex())
+		}
+	}()
 }