Private key dependency about solana-go-sdk HOT 9 CLOSED

"github.com/mr-tron/base58"
"github.com/portto/solana-go-sdk/client"
"github.com/portto/solana-go-sdk/common"
"github.com/portto/solana-go-sdk/pkg/pointer"
"github.com/portto/solana-go-sdk/program/assotokenprog"
"github.com/portto/solana-go-sdk/program/metaplex/tokenmeta"
"github.com/portto/solana-go-sdk/program/sysprog"
"github.com/portto/solana-go-sdk/program/tokenprog"
"github.com/portto/solana-go-sdk/rpc"
"github.com/portto/solana-go-sdk/types"

//var feePayer, _ = types.AccountFromBase58("")
   var feePayer1 = common.PublicKeyFromString("43xqaQkf8N95Af64ZqafbcQsPWdKqy5BRWxH7FFYomqX")

c := client.NewClient(rpc.DevnetRPCEndpoint)


mint := types.NewAccount()
fmt.Printf("NFT: %v\n", mint.PublicKey.ToBase58())
assTokAdrr, _, _ := common.FindAssociatedTokenAddress(**feePayer1**, mint.PublicKey)
fmt.Println("assTokAdrr", assTokAdrr.ToBase58())
collection := types.NewAccount()
fmt.Println(base58.Encode(collection.PrivateKey))
fmt.Printf("collection: %v\n", collection.PublicKey.ToBase58())

ata, _, err := common.FindAssociatedTokenAddress(feePayer1, mint.PublicKey)
if err != nil {
	log.Fatalf("failed to find a valid ata, err: %v", err)
}

fmt.Println("ata", ata)

tokenMetadataPubkey, err := tokenmeta.GetTokenMetaPubkey(mint.PublicKey)
fmt.Println("tokenMetadataPubkey", tokenMetadataPubkey.ToBase58())

if err != nil {
	log.Fatalf("failed to find a valid token metadata, err: %v", err)

}
tokenMasterEditionPubkey, err := tokenmeta.GetMasterEdition(mint.PublicKey)
fmt.Println("tokenMasterEditionPubkey", tokenMasterEditionPubkey.ToBase58())

if err != nil {
	log.Fatalf("failed to find a valid master edition, err: %v", err)
}

mintAccountRent, err := c.GetMinimumBalanceForRentExemption(context.Background(), tokenprog.MintAccountSize)
if err != nil {
	log.Fatalf("failed to get mint account rent, err: %v", err)
}

recentBlockhashResponse, err := c.GetRecentBlockhash(context.Background())
if err != nil {
	log.Fatalf("failed to get recent blockhash, err: %v", err)
}

fmt.Println("Signers--------------------->", []types.Account{mint})

tx, err := types.NewTransaction(types.NewTransactionParam{
	//Signers: []types.Account{mint, feePayer1},
	Message: types.NewMessage(types.NewMessageParam{
		FeePayer:        feePayer1,
		RecentBlockhash: recentBlockhashResponse.Blockhash,
		Instructions: []types.Instruction{
			sysprog.CreateAccount(sysprog.CreateAccountParam{
				From:     feePayer1,
				New:      mint.PublicKey,
				Owner:    common.TokenProgramID,
				Lamports: mintAccountRent,
				Space:    tokenprog.MintAccountSize,
			}),
			tokenprog.InitializeMint(tokenprog.InitializeMintParam{
				Decimals: 0,
				Mint:     mint.PublicKey,
				MintAuth: feePayer1,
			}),
			tokenmeta.CreateMetadataAccountV2(tokenmeta.CreateMetadataAccountV2Param{
				Metadata:                tokenMetadataPubkey,
				Mint:                    mint.PublicKey,
				MintAuthority:           feePayer1,
				Payer:                   feePayer1,
				UpdateAuthority:         feePayer1,
				UpdateAuthorityIsSigner: true,
				IsMutable:               true,
				Data: tokenmeta.DataV2{
					Name:                 "test",
					Symbol:               "tset",
					Uri:                  "https://ipfs.infura.io/ipfs/QmVyceJtRJVY8E8kCmXUPK3vs2XdwzTtrtWrGpwjWVWhMX",
					SellerFeeBasisPoints: 100,
					Creators: &[]tokenmeta.Creator{
						{
							Address:  feePayer1,
							Verified: true,
							Share:    100,
						},
					},
					Collection: &tokenmeta.Collection{
						Verified: false,
						Key:      collection.PublicKey,
					},
					Uses: &tokenmeta.Uses{
						UseMethod: tokenmeta.Burn,
						Remaining: 10,
						Total:     10,
					},
				},
			}),
			assotokenprog.CreateAssociatedTokenAccount(assotokenprog.CreateAssociatedTokenAccountParam{
				Funder:                 feePayer1,
				Owner:                  feePayer1,
				Mint:                   mint.PublicKey,
				AssociatedTokenAccount: ata,
			}),
			tokenprog.MintTo(tokenprog.MintToParam{
				Mint:   mint.PublicKey,
				To:     ata,
				Auth:   feePayer1,
				Amount: 1,
			}),
			tokenmeta.CreateMasterEditionV3(tokenmeta.CreateMasterEditionParam{
				Edition:         tokenMasterEditionPubkey,
				Mint:            mint.PublicKey,
				UpdateAuthority: feePayer1,
				MintAuthority:   feePayer1,
				Metadata:        tokenMetadataPubkey,
				Payer:           feePayer1,
				MaxSupply:       pointer.Uint64(0),
			}),
		},
	}),
})

if err != nil {
	log.Fatalf("failed to new a tx, err: %v", err)
}

sig, err := c.SendTransaction(context.Background(), tx)
if err != nil {
	log.Fatalf("failed to send tx, err: %v", err)
}

fmt.Println(sig)