how to get token owner of a token account

[BillInUK]

I use the following code to get owner of token account, but returned me a program id 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'。

	rpcClient := rpc.New(RpcMainNet)
	tokenMintPubKey := solana.MPK(TokenMainNetAddress)
	tokenAccountPubKey := solana.MustPublicKeyFromBase58("3XRNhFEXkV7itJEJMDBN8iRHBgwhgk83XB5K3s3re3Ew")

	tokenAccountInfo, err := rpcClient.GetAccountInfo(context.Background(), tokenAccountPubKey)
	if err != nil {
		fmt.Printf("get account info error %v\n", err)
	}
	fmt.Printf("get token account owner %v\n", tokenAccountInfo.Value)

how can i get the token owner of this token account? like below:

[theghostmac]

Here is how you do it @BillInUK:

package main

import (
	"context"
	"fmt"
	"github.com/gagliardetto/solana-go"
	"github.com/gagliardetto/solana-go/rpc"
)

func main() {
	rpcClient := rpc.New(rpc.MainNetBeta_RPC)
	tokenAccountPubKey := solana.MustPublicKeyFromBase58("3XRNhFEXkV7itJEJMDBN8iRHBgwhgk83XB5K3s3re3Ew")

	// Fetch account info
	accountInfo, err := rpcClient.GetAccountInfo(context.Background(), tokenAccountPubKey)
	if err != nil {
		fmt.Printf("Error retrieving account info: %v\n", err)
		return
	}

	owner := accountInfo.Value.Owner

	// Output the owner of the token account
	fmt.Printf("Token account owner: %v\n", owner.String())
	// OUTPUT: Token account owner: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA

	// Ensure that data is available
	if accountInfo.Value == nil || accountInfo.Value.Data.GetBinary() == nil {
		fmt.Println("Account data is not available")
		return
	}

	fmt.Println("Trying the second method...")

	data := accountInfo.Value.Data.GetBinary()

	// Check if data length is sufficient to contain Mint and Owner public keys
	if len(data) < 64 {
		fmt.Println("Account data is too short to contain required information")
		return
	}

	// Owner public key starts at byte 32 and spans 32 bytes
	ownerPubKey := solana.PublicKeyFromBytes(data[32:64])

	// Output the owner of the token account
	fmt.Printf("Token account owner from metadata: %v\n", ownerPubKey)
	// OUTPUT: Token account owner: GmKsGRytiVoeMZGmBVCWPcUzJGHVqcvzhP5K9cstdr3E
}

[BillInUK]

thanks for your help, i will try it !!!

[BillInUK]

I implemented this functionality by defining my own structure to parse the results of GetAccountInfoWithOpts. The code is as follows:

const (
	SPLTokenProgramId = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
)

type SPLTokenAccountInfo struct {
	IsNative    bool             `json:"isNative"`
	Mint        solana.PublicKey `json:"mint"`
	Owner       solana.PublicKey `json:"owner"`
	State       string           `json:"state"`
	TokenAmount struct {
		Amount      string  `json:"amount"`
		Decimals    int     `json:"decimals"`
		UIAmount    float64 `json:"uiAmount"`
		UIAmountStr string  `json:"uiAmountString"`
	} `json:"tokenAmount"`
}

type SPLTokenAccountData struct {
	TokenAccountInfo SPLTokenAccountInfo `json:"info"`
	Type             string              `json:"type"`
}

type ParsedData struct {
	Parsed  SPLTokenAccountData `json:"parsed"`
	Program string              `json:"program"`
	Space   int                 `json:"space"`
}

func TestGetTokenAccountOwner(t *testing.T) {
	client := rpc.New(DevRpc)

	pubKey := solana.MustPublicKeyFromBase58("EgyMZLY7DrHpYgmQHCrQ8fXJCv7ekfBepxNNizMST9Dh")
	out, err := client.GetAccountInfoWithOpts(
		context.TODO(),
		pubKey,
		&rpc.GetAccountInfoOpts{
			Encoding: solana.EncodingJSONParsed,
		},
	)
	if err != nil {
		panic(err)
	}
	var parsedData ParsedData
	dataBytes, _ := out.Value.Data.MarshalJSON()
	fmt.Println(string(dataBytes))

	err = json.Unmarshal(dataBytes, &parsedData)
	if err != nil {
		fmt.Println("Error parsing JSON:", err)
		return
	}
	// Access parsed data
	fmt.Println("Type:", parsedData.Parsed.Type)
	fmt.Println("Program:", parsedData.Program)
	fmt.Println("Space:", parsedData.Space)
	fmt.Println("IsNative:", parsedData.Parsed.TokenAccountInfo.IsNative)
	fmt.Println("Mint:", parsedData.Parsed.TokenAccountInfo.Mint)
	fmt.Println("Owner:", parsedData.Parsed.TokenAccountInfo.Owner)
	fmt.Println("State:", parsedData.Parsed.TokenAccountInfo.State)
	fmt.Println("Amount:", parsedData.Parsed.TokenAccountInfo.TokenAmount.Amount)
	fmt.Println("Decimals:", parsedData.Parsed.TokenAccountInfo.TokenAmount.Decimals)
	fmt.Println("UIAmount:", parsedData.Parsed.TokenAccountInfo.TokenAmount.UIAmount)
	fmt.Println("UIAmountString:", parsedData.Parsed.TokenAccountInfo.TokenAmount.UIAmountStr)
}

[BillInUK]

Overall, the code you provided is simpler, avoiding unnecessary struct definitions and JSON parsing.