How do I transfer tokens

[scottywm]

Is there a way that I can use this library to send tokens from one wallet to another?

If so please tell me where.

[jxad]

Old question but could be useful to someone

import (
	"context"
	"fmt"
	"math"
	"strconv"

	"github.com/gagliardetto/solana-go"
	associatedtokenaccount "github.com/gagliardetto/solana-go/programs/associated-token-account"
	"github.com/gagliardetto/solana-go/programs/token"
	"github.com/gagliardetto/solana-go/rpc"
)

func tokenTransfer(sender solana.PrivateKey, receiver solana.PublicKey, tokenMint solana.PublicKey) (solana.Signature, error) {
	httpClient := rpc.New(rpc.DevNet_RPC)
	ixs := []solana.Instruction{}
	tokenAta := solana.PublicKey{}

	//get list of ata associated to the token mint address
	atas, err := httpClient.GetTokenAccountsByOwner(
		context.TODO(),
		receiver,
		&rpc.GetTokenAccountsConfig{
			Mint: &tokenMint,
		},
		&rpc.GetTokenAccountsOpts{})

	//create new ata if none found
	if err != nil || len(atas.Value) == 0 {
		if err != nil {
			panic(err)
		}

		ix, err := associatedtokenaccount.NewCreateInstruction(
			sender.PublicKey(),
			receiver,
			tokenMint).ValidateAndBuild()
		if err != nil {
			panic(err)
		}
		ixs = append(ixs, ix)
		tokenAta = ix.Accounts()[1].PublicKey
	} else {
		//if token atas found i just get the first one
		tokenAta = atas.Value[0].Pubkey
	}

	//transfer instruction
	amount := uint64(10 * math.Pow10(9)) //Sending n10 tokens of a token that has 9 decimals
	fromAccountAtas, err := httpClient.GetTokenAccountsByOwner(
		context.TODO(),
		sender.PublicKey(),
		&rpc.GetTokenAccountsConfig{
			Mint: &tokenMint,
		},
		&rpc.GetTokenAccountsOpts{})
	if err != nil {
		panic(err)
	}
	if len(fromAccountAtas.Value) == 0 {
		panic(fmt.Errorf("sender does not have any tokens"))
	}

	//get sender wallet token ata + check if sender have enough tokens
	fromAccountAta := solana.PublicKey{}
	hasEnoughTokens := true
	for _, ata := range fromAccountAtas.Value {
		hasEnoughTokens = true
		balance, err := httpClient.GetTokenAccountBalance(context.TODO(), ata.Pubkey, rpc.CommitmentFinalized)
		if err != nil {
			continue
		}
		a, err := strconv.ParseUint(balance.Value.Amount, 10, 64)
		if err != nil {
			continue
		}
		if a < amount {
			hasEnoughTokens = false
			continue
		}
		fromAccountAta = ata.Pubkey
		break
	}

	if fromAccountAta == solana.SystemProgramID {
		if !hasEnoughTokens {
			err = fmt.Errorf("sender does not have enough tokens")
		}
		panic(err)
	}

	//transfer instruction
	ix := token.NewTransferInstruction(
		amount,
		fromAccountAta,
		tokenAta,
		sender.PublicKey(),
		[]solana.PublicKey{}).Build()
	ixs = append(ixs, ix)

	recentBlockHash, err := httpClient.GetRecentBlockhash(context.TODO(), rpc.CommitmentFinalized)
	if err != nil {
		panic(err)
	}
	tx, err := solana.NewTransaction(
		ixs,
		recentBlockHash.Value.Blockhash,
		solana.TransactionPayer(sender.PublicKey()),
	)
	if err != nil {
		panic(err)
	}

	//sign transaction
	_, err = tx.Sign(
		func(key solana.PublicKey) *solana.PrivateKey {
			if sender.PublicKey().Equals(key) {
				return &sender
			}
			return nil
		},
	)
	if err != nil {
		panic(err)
	}

	//send transaction
	sig, err := httpClient.SendTransaction(
		context.TODO(),
		tx,
	)
	if err != nil {
		panic(err)
	}

	// send transaction and wait for confirmation
	// import confirm "github.com/gagliardetto/solana-go/rpc/sendAndConfirmTransaction"
	// sig, err := confirm.SendAndConfirmTransaction(
	// 	context.TODO(),
	// 	httpClient,
	// 	wsClient,
	// 	tx,
	//   )
	return sig, nil
}

[A-Lazar-A]

doesnt work for me
i have empty transaction idk why
2AtiEsBtknVgEhNL4Hv8a3hq6Z7GiL4x4hmx64ZVg7CZmkZnXpQPtNX68amYnvhrCkcWwvCDhj4kMnnTyjGUb2Y6