Runtime error: invalid memory address or nil pointer

[astravexton]

Hi there, I'm trying to use GetUserRequest in this code but t.TDLibClient is always nil, is there something I'm overlooking? I have tried to do if t.TDLibClient != nil too

package main

import (
	"context"
	"log"
	"os"
	"os/signal"
	"path/filepath"
	"syscall"

	"github.com/zelenin/go-tdlib/client"
)

const (
	apiId   = 0
	apiHash = ""
)

type Client struct {
	TDLibClient *client.Client
}

func main() {
	tdlibParameters := &client.SetTdlibParametersRequest{
		UseTestDc:           false,
		DatabaseDirectory:   filepath.Join(".tdlib", "database"),
		FilesDirectory:      filepath.Join(".tdlib", "files"),
		UseFileDatabase:     true,
		UseChatInfoDatabase: true,
		UseMessageDatabase:  true,
		UseSecretChats:      false,
		ApiId:               apiId,
		ApiHash:             apiHash,
		SystemLanguageCode:  "en",
		DeviceModel:         "Server",
		SystemVersion:       "1.0.0",
		ApplicationVersion:  "1.0.0",
	}
	// client authorizer
	authorizer := client.ClientAuthorizer(tdlibParameters)
	go client.CliInteractor(authorizer)

	// or bot authorizer
	// botToken := "000000000:gsVCGG5YbikxYHC7bP5vRvmBqJ7Xz6vG6td"
	// authorizer := client.BotAuthorizer(tdlibParameters, botToken)

	_, err := client.SetLogVerbosityLevel(&client.SetLogVerbosityLevelRequest{
		NewVerbosityLevel: 1,
	})
	if err != nil {
		log.Fatalf("SetLogVerbosityLevel error: %s", err)
	}

	c := &Client{
		TDLibClient: &client.Client{},
	}

	c.TDLibClient, err = client.NewClient(authorizer, client.WithResultHandler(client.NewCallbackResultHandler(c.ResHandCallback)))
	if err != nil {
		log.Fatalf("NewClient error: %s", err)
	}

	// c.TDLibClient = tdlibClient

	versionOption, err := client.GetOption(&client.GetOptionRequest{
		Name: "version",
	})
	if err != nil {
		log.Fatalf("GetOption error: %s", err)
	}

	commitOption, err := client.GetOption(&client.GetOptionRequest{
		Name: "commit_hash",
	})
	if err != nil {
		log.Fatalf("GetOption error: %s", err)
	}

	log.Printf("TDLib version: %s (commit: %s)", versionOption.(*client.OptionValueString).Value, commitOption.(*client.OptionValueString).Value)

	if commitOption.(*client.OptionValueString).Value != client.TDLIB_VERSION {
		log.Printf("TDLib version supported by the library (%s) is not the same as TDLib version (%s)", client.TDLIB_VERSION, commitOption.(*client.OptionValueString).Value)
	}

	me, err := c.TDLibClient.GetMe(context.Background())
	if err != nil {
		log.Fatalf("GetMe error: %s", err)
	}

	log.Printf("Me: %s %s", me.FirstName, me.LastName)

	ch := make(chan os.Signal, 2)
	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
	<-ch
	c.TDLibClient.Close(context.Background())
	os.Exit(1)
}

func (t *Client) ResHandCallback(result client.Type) {
	switch result.GetType() {
	case client.TypeUpdate:
		if result.GetConstructor() == client.ConstructorUpdateUserStatus {
			u := result.(*client.UpdateUserStatus)
			if u.Status.UserStatusConstructor() == client.ConstructorUserStatusOnline {
				response, _ := t.TDLibClient.Send(context.Background(), &client.GetUserRequest{UserId: u.UserId})
				if user := response; user != nil {
					log.Printf("User: %+v\n", user)
				} else {
					log.Println("Unexpected response type")
				}
				log.Print("online")
			} else if u.Status.UserStatusConstructor() == client.ConstructorUserStatusOffline {
				log.Print("offline")
			}
		} else {
			log.Printf("%T\n", result)
		}
	}
}