Go websockets data gopherjs

I'm currently trying to communicate using websockets and my code is the following (im using gorilla)

buff := bytes.NewBuffer([]byte{})
binary.Write(buff, binary.LittleEndian, uint64(1))
binary.Write(buff, binary.LittleEndian, len(message))
binary.Write(buff, binary.LittleEndian, message)
client.Write <- buff.Bytes()

The c.Write channel its inside a for select loop

case msg := <-client.Write:
    buffer := &bytes.Buffer{}
	err := binary.Write(buffer, binary.LittleEndian, msg)
	if err != nil {
		return
	}
	err = client.Ws.WriteMessage(websocket.BinaryMessage, buffer.Bytes())
	if err != nil {
		return
	}
	buffer.Reset()

And client is just a struct

type Client struct {
	Ws      *websocket.Conn
	Read    chan []byte
	Write   chan []byte
	Account *models.Account
}

The message is sent successfully and I read it like this

b, err := conn.Read(buff)
if err != nil {
	utils.Log("Error while reading from socket " + err.Error())
	return
}
buffer := bytes.NewBuffer(buff[:b])
t, err := binary.ReadUvarint(buffer)
utils.Log(t)
if err != nil {
	utils.Log("Error while reading from socket " + err.Error())
	return
}
switch t {
case 1:
	roomsLen, err := binary.ReadUvarint(buffer)
	if err != nil {
		utils.Log("Error while reading rooms len " + err.Error())
	    return
	}
	utils.Log(roomsLen)
	roomsBytes := make([]byte, roomsLen)
	binary.Read(buffer, binary.LittleEndian, roomsBytes)
	rooms := []*Room{}
	err = json.Unmarshal(roomsBytes, rooms)
	if err != nil {
		utils.Log("Error while unmarshaling room list " + err.Error())
		return
	}
	utils.Log(rooms)

The utils.Log function is just this

func Log(msg interface{}) {
	n := time.Now()
	console.Call("log", fmt.Sprintf("[%v:%v:%v] %v", n.Hour(), n.Minute(),    n.Second(), msg))
}

Thing is the first uint64 is the one im waiting (1) but the second uint64 im reading is always 0 while loggin it (len(message)) gives me 52

And since its always 0 I cant unmarshal it properly

So I'm not sure what I am doing wrong or if this is not a correct way to use websockets.

Small error. You're writing uint64 but using "ReadUvarint" to read it (a varint is a different type of data).

package main

import (
	"bytes"
	"encoding/binary"
	"fmt"
)

func main() {
	b := bytes.NewBuffer([]byte{})
	e1 := binary.Write(b, binary.LittleEndian, uint64(10))
	e2 := binary.Write(b, binary.LittleEndian, uint64(20))
	
	fmt.Println("writing 10 and 20", e1, e2)

	{
		r := bytes.NewBuffer(b.Bytes())
		res, e := binary.ReadUvarint(r)
		res2, e2 := binary.ReadUvarint(r)
		fmt.Println("using readuvarint here        :", res, res2, e, e2, b.Bytes())
	}
	{
		r := bytes.NewBuffer(b.Bytes())
		var res, res2 uint64
		e := binary.Read(r, binary.LittleEndian, &res)
		e2 := binary.Read(r, binary.LittleEndian, &res2)
		fmt.Println("using read into uint64's here :", res, res2, e, e2, b.Bytes())
	}
}