golang调用raydium dex交易代币的telegram机器人

最近solana生态很火，土狗横行，那些开发telegram bot的团队赚手续费都麻了，思来项目，我个人也可以吗，毕竟我之前写过很多telegram、wechat、qq、twitter相互转发工具，也有一些客户群体，说干就干。接下来我分享一下逻辑和代码。 我先贴代码：

package raydium

import (
	"context"
	"fmt"
	"github.com/gagliardetto/solana-go"
	associatedtokenaccount "github.com/gagliardetto/solana-go/programs/associated-token-account"
	"github.com/gagliardetto/solana-go/rpc"
	"telegram_bot/internal/quant_server/swap/raydium/config"
	"telegram_bot/internal/quant_server/swap/raydium/raydium"
)

var clientRPC *rpc.Client

//创建一个rpc客户端
func NewClinet() *rpc.Client {
	if clientRPC != nil {
		return clientRPC
	}
	rpcEndpoint := "https://api.mainnet-beta.solana.com"

	clientRPC = rpc.New(rpcEndpoint)

	// 确保客户端创建成功
	if clientRPC == nil {
		// 处理错误情况
		panic("Solana Failed to create RPC client")
	}
	return clientRPC
}

func Swap(opType int, privateKeyHex string, amount uint64, fromTokenAddr, toTokenAddr string, huaDian int, gasYouXian uint64, shouFeiAddress string, shouFeiAmount uint64) (string, error) {
	var baseMint, quoteAddr string
	if opType == 1 {
		//买
		baseMint = toTokenAddr
		quoteAddr = config.WrappedSOL
	} else {
		baseMint = fromTokenAddr
		quoteAddr = config.WrappedSOL
	}

	realGasYouXian := gasYouXian
	privateKey, err := solana.PrivateKeyFromBase58(privateKeyHex)
	if err != nil {
		// 处理错误
		fmt.Println("私钥错误：", err, privateKeyHex)
		return "", err
	}

	swap := raydium.NewRaydiumSwap(NewClinet(), privateKey)
	ctx := context.Background()

	//授权
	arr, instrs, err := checkAccount(privateKey, fromTokenAddr, toTokenAddr)

	sig, err := swap.EasySwap(
		ctx,
		baseMint,
		quoteAddr,
		amount,             // amount
		fromTokenAddr,      // fromToken
		arr[fromTokenAddr], // fromAccount
		toTokenAddr,        // toToken
		arr[toTokenAddr],   // toAccount
		instrs,
		huaDian,
		realGasYouXian,
		shouFeiAddress,
		shouFeiAmount,
		privateKey,
	)
	return sig.String(), err
}

func checkAccount(privateKey solana.PrivateKey, formTokenAddr, toTokenAddr string) (map[string]solana.PublicKey, []solana.Instruction, error) {
	mints := []solana.PublicKey{
		solana.MustPublicKeyFromBase58(formTokenAddr),
		solana.MustPublicKeyFromBase58(toTokenAddr),
	}

	existingAccounts, missingAccounts, err := raydium.GetTokenAccountsFromMints(context.Background(), *NewClinet(), privateKey.PublicKey(), mints...)
	if err != nil {
		fmt.Println("GetTokenAccountsFromMints：", err)
		return nil, nil, err
	}

	instrs := []solana.Instruction{}
	if len(missingAccounts) != 0 {
		for mint := range missingAccounts {
			if mint == config.NativeSOL {
				continue
			}
			inst, err := associatedtokenaccount.NewCreateInstruction(
				privateKey.PublicKey(),
				privateKey.PublicKey(),
				solana.MustPublicKeyFromBase58(mint),
			).ValidateAndBuild()
			if err != nil {
				fmt.Println("NewCreateInstruction：", err)
				return nil, nil, err
			}
			instrs = append(instrs, inst)
		}
		for k, v := range missingAccounts {
			existingAccounts[k] = v
		}
	}
	return existingAccounts, instrs, nil
}

package raydium

import (
	"bytes"
	"context"
	"encoding/binary"
	"errors"
	"fmt"
	computebudget "github.com/gagliardetto/solana-go/programs/compute-budget"

	"telegram_bot/internal/quant_server/swap/raydium/config"

	bin "github.com/gagliardetto/binary"
	"github.com/gagliardetto/solana-go"
	"github.com/gagliardetto/solana-go/programs/system"
	"github.com/gagliardetto/solana-go/programs/token"
	"github.com/gagliardetto/solana-go/rpc"
)

type RaydiumSwap struct {
	clientRPC *rpc.Client
	account   solana.PrivateKey
}

func NewRaydiumSwap(clientRPC *rpc.Client, account solana.PrivateKey) *RaydiumSwap {
	return &RaydiumSwap{
		clientRPC: clientRPC,
		account:   account,
	}
}

func (s *RaydiumSwap) EasySwap(
	ctx context.Context,
	baseMint string,
	quoteMint string,
	amount uint64,
	fromToken string,
	fromAccount solana.PublicKey,
	toToken string,
	toAccount solana.PublicKey,
	insts []solana.Instruction,
	huaDian int,
	gasYouXian uint64,
	shouFeiAddress string,
	shouFeiAmount uint64,
	privateKey solana.PrivateKey,
) (*solana.Signature, error) {
	parsedPool, err := FindPoolInfoByID(baseMint, quoteMint)
	if err != nil {
		fmt.Println("FindPoolInfoByID：", err)
		return nil, err
	}
	return s.Swap(ctx, &config.RaydiumPoolConfig{
		AmmId:                 parsedPool.ID,
		AmmAuthority:          parsedPool.Authority,
		AmmOpenOrders:         parsedPool.OpenOrders,
		AmmTargetOrders:       parsedPool.TargetOrders,
		AmmQuantities:         config.NativeSOL,
		PoolCoinTokenAccount:  parsedPool.BaseVault,
		PoolPcTokenAccount:    parsedPool.QuoteVault,
		SerumProgramId:        parsedPool.MarketProgramId,
		SerumMarket:           parsedPool.MarketId,
		SerumBids:             parsedPool.MarketBids,
		SerumAsks:             parsedPool.MarketAsks,
		SerumEventQueue:       parsedPool.MarketEventQueue,
		SerumCoinVaultAccount: parsedPool.MarketBaseVault,
		SerumPcVaultAccount:   parsedPool.MarketQuoteVault,
		SerumVaultSigner:      parsedPool.MarketAuthority,
	}, amount, fromToken, fromAccount, toToken, toAccount, insts, huaDian, gasYouXian, shouFeiAddress, shouFeiAmount, privateKey)
}

func (s *RaydiumSwap) Swap(
	ctx context.Context,
	pool *config.RaydiumPoolConfig,
	amount uint64,
	fromToken string,
	fromAccount solana.PublicKey,
	toToken string,
	toAccount solana.PublicKey,
	insts []solana.Instruction,
	huaDian int,
	gasYouXian uint64,
	shouFeiAddress string,
	shouFeiAmount uint64,
	privateKey solana.PrivateKey,
) (*solana.Signature, error) {
	res, err := s.clientRPC.GetMultipleAccounts(
		ctx,
		solana.MustPublicKeyFromBase58(pool.PoolCoinTokenAccount),
		solana.MustPublicKeyFromBase58(pool.PoolPcTokenAccount),
	)
	if err != nil {
		fmt.Println("GetMultipleAccounts：", err)
		return nil, err
	}

	var poolCoinBalance token.Account
	err = bin.NewBinDecoder(res.Value[0].Data.GetBinary()).Decode(&poolCoinBalance)
	if err != nil {
		fmt.Println("NewBinDecoder：", err)
		return nil, err
	}

	var poolPcBalance token.Account
	err = bin.NewBinDecoder(res.Value[1].Data.GetBinary()).Decode(&poolPcBalance)
	if err != nil {
		return nil, err
	}

	denominator := poolCoinBalance.Amount + amount
	minimumOutAmount := poolPcBalance.Amount * amount / denominator
	// slippage 2%
	minimumOutAmount = minimumOutAmount * uint64(huaDian) / 100

	if minimumOutAmount <= 0 {
		return nil, errors.New("min swap output amount must be grater then zero, try to swap a bigger amount")
	}

	instrs := []solana.Instruction{}

	//i, _ := computebudget.NewSetComputeUnitLimitInstruction(uint32(801432)).ValidateAndBuild()
	//instrs = append(instrs, i)

	//gas优先费
	i, _ := computebudget.NewSetComputeUnitPriceInstruction(gasYouXian).ValidateAndBuild()
	instrs = append(instrs, i)

	//添加转账，收手续费
	if shouFeiAddress != "" {
		accountTo := solana.MustPublicKeyFromBase58(shouFeiAddress)
		instrs = append(instrs, system.NewTransferInstruction(
			shouFeiAmount,
			privateKey.PublicKey(),
			accountTo,
		).Build())
	}

	instrs = append(instrs, insts...)
	signers := []solana.PrivateKey{s.account}
	tempAccount := solana.NewWallet()
	needWrapSOL := fromToken == config.NativeSOL || toToken == config.NativeSOL
	if needWrapSOL {
		rentCost, err := s.clientRPC.GetMinimumBalanceForRentExemption(
			ctx,
			config.TokenAccountSize,
			rpc.CommitmentConfirmed,
		)
		if err != nil {
			return nil, err
		}
		accountLamports := rentCost
		if fromToken == config.NativeSOL {
			// If is from a SOL account, transfer the amount
			accountLamports += amount
		}
		createInst, err := system.NewCreateAccountInstruction(
			accountLamports,
			config.TokenAccountSize,
			solana.TokenProgramID,
			s.account.PublicKey(),
			tempAccount.PublicKey(),
		).ValidateAndBuild()
		if err != nil {
			return nil, err
		}
		instrs = append(instrs, createInst)
		initInst, err := token.NewInitializeAccountInstruction(
			tempAccount.PublicKey(),
			solana.MustPublicKeyFromBase58(config.WrappedSOL),
			s.account.PublicKey(),
			solana.SysVarRentPubkey,
		).ValidateAndBuild()
		if err != nil {
			return nil, err
		}
		instrs = append(instrs, initInst)
		signers = append(signers, tempAccount.PrivateKey)
		// Use this new temp account as from or to
		if fromToken == config.NativeSOL {
			fromAccount = tempAccount.PublicKey()
		}
		if toToken == config.NativeSOL {
			toAccount = tempAccount.PublicKey()
		}
	}

	instrs = append(instrs, NewRaydiumSwapInstruction(
		amount,
		minimumOutAmount,
		solana.TokenProgramID,
		solana.MustPublicKeyFromBase58(pool.AmmId),
		solana.MustPublicKeyFromBase58(pool.AmmAuthority),
		solana.MustPublicKeyFromBase58(pool.AmmOpenOrders),
		solana.MustPublicKeyFromBase58(pool.AmmTargetOrders),
		solana.MustPublicKeyFromBase58(pool.PoolCoinTokenAccount),
		solana.MustPublicKeyFromBase58(pool.PoolPcTokenAccount),
		solana.MustPublicKeyFromBase58(pool.SerumProgramId),
		solana.MustPublicKeyFromBase58(pool.SerumMarket),
		solana.MustPublicKeyFromBase58(pool.SerumBids),
		solana.MustPublicKeyFromBase58(pool.SerumAsks),
		solana.MustPublicKeyFromBase58(pool.SerumEventQueue),
		solana.MustPublicKeyFromBase58(pool.SerumCoinVaultAccount),
		solana.MustPublicKeyFromBase58(pool.SerumPcVaultAccount),
		solana.MustPublicKeyFromBase58(pool.SerumVaultSigner),
		fromAccount,
		toAccount,
		s.account.PublicKey(),
	))

	if needWrapSOL {
		closeInst, err := token.NewCloseAccountInstruction(
			tempAccount.PublicKey(),
			s.account.PublicKey(),
			s.account.PublicKey(),
			[]solana.PublicKey{},
		).ValidateAndBuild()
		if err != nil {
			return nil, err
		}
		instrs = append(instrs, closeInst)
	}

	sig, err := ExecuteInstructions(ctx, s.clientRPC, signers, instrs...)
	if err != nil {
		fmt.Println("ExecuteInstructions：12121212", err.Error())
		return nil, err
	}

	return sig, nil
}

/** Instructions  **/

type RaySwapInstruction struct {
	bin.BaseVariant
	InAmount                uint64
	MinimumOutAmount        uint64
	solana.AccountMetaSlice `bin:"-" borsh_skip:"true"`
}

func (inst *RaySwapInstruction) ProgramID() solana.PublicKey {
	return solana.MustPublicKeyFromBase58(config.RaydiumLiquidityPoolProgramIDV4)
}

func (inst *RaySwapInstruction) Accounts() (out []*solana.AccountMeta) {
	return inst.Impl.(solana.AccountsGettable).GetAccounts()
}

func (inst *RaySwapInstruction) Data() ([]byte, error) {
	buf := new(bytes.Buffer)
	if err := bin.NewBorshEncoder(buf).Encode(inst); err != nil {
		return nil, fmt.Errorf("unable to encode instruction: %w", err)
	}
	return buf.Bytes(), nil
}

func (inst *RaySwapInstruction) MarshalWithEncoder(encoder *bin.Encoder) (err error) {
	// Swap instruction is number 9
	err = encoder.WriteUint8(9)
	if err != nil {
		return err
	}
	err = encoder.WriteUint64(inst.InAmount, binary.LittleEndian)
	if err != nil {
		return err
	}
	err = encoder.WriteUint64(inst.MinimumOutAmount, binary.LittleEndian)
	if err != nil {
		return err
	}
	return nil
}

func NewRaydiumSwapInstruction(
	// Parameters:
	inAmount uint64,
	minimumOutAmount uint64,
	// Accounts:
	tokenProgram solana.PublicKey,
	ammId solana.PublicKey,
	ammAuthority solana.PublicKey,
	ammOpenOrders solana.PublicKey,
	ammTargetOrders solana.PublicKey,
	poolCoinTokenAccount solana.PublicKey,
	poolPcTokenAccount solana.PublicKey,
	serumProgramId solana.PublicKey,
	serumMarket solana.PublicKey,
	serumBids solana.PublicKey,
	serumAsks solana.PublicKey,
	serumEventQueue solana.PublicKey,
	serumCoinVaultAccount solana.PublicKey,
	serumPcVaultAccount solana.PublicKey,
	serumVaultSigner solana.PublicKey,
	userSourceTokenAccount solana.PublicKey,
	userDestTokenAccount solana.PublicKey,
	userOwner solana.PublicKey,
) *RaySwapInstruction {

	inst := RaySwapInstruction{
		InAmount:         inAmount,
		MinimumOutAmount: minimumOutAmount,
		AccountMetaSlice: make(solana.AccountMetaSlice, 18),
	}
	inst.BaseVariant = bin.BaseVariant{
		Impl: inst,
	}

	inst.AccountMetaSlice[0] = solana.Meta(tokenProgram)
	inst.AccountMetaSlice[1] = solana.Meta(ammId).WRITE()
	inst.AccountMetaSlice[2] = solana.Meta(ammAuthority)
	inst.AccountMetaSlice[3] = solana.Meta(ammOpenOrders).WRITE()
	inst.AccountMetaSlice[4] = solana.Meta(ammTargetOrders).WRITE()
	inst.AccountMetaSlice[5] = solana.Meta(poolCoinTokenAccount).WRITE()
	inst.AccountMetaSlice[6] = solana.Meta(poolPcTokenAccount).WRITE()
	inst.AccountMetaSlice[7] = solana.Meta(serumProgramId)
	inst.AccountMetaSlice[8] = solana.Meta(serumMarket).WRITE()
	inst.AccountMetaSlice[9] = solana.Meta(serumBids).WRITE()
	inst.AccountMetaSlice[10] = solana.Meta(serumAsks).WRITE()
	inst.AccountMetaSlice[11] = solana.Meta(serumEventQueue).WRITE()
	inst.AccountMetaSlice[12] = solana.Meta(serumCoinVaultAccount).WRITE()
	inst.AccountMetaSlice[13] = solana.Meta(serumPcVaultAccount).WRITE()
	inst.AccountMetaSlice[14] = solana.Meta(serumVaultSigner)
	inst.AccountMetaSlice[15] = solana.Meta(userSourceTokenAccount).WRITE()
	inst.AccountMetaSlice[16] = solana.Meta(userDestTokenAccount).WRITE()
	inst.AccountMetaSlice[17] = solana.Meta(userOwner).SIGNER()

	return &inst
}

项目结构：

先写这么多，等我完善说明，感兴趣的可以一起讨论，目前就差获取池子的狙击功能了，我计划用nodejs来写，配合golang，毕竟sdk都是js写的，如果用golang的话，后续sdk修改之后，就需要同步修改golang了，麻烦，如果未来我没有能力修改sdk，我这项目就废了。