docs(examples): un-stale read-path RPC examples

Several examples hardcoded signatures, blockhashes, or base64 blobs
that rotted the moment they were merged — or queried testnet where the
needed data is sparse. Reshape them to fetch fresh input on mainnet-beta
so they keep working as the cluster advances:

- getTransaction, getSignatureStatuses: pull a recent signature via
  GetSignaturesForAddressWithOpts on the SPL Token program, then
  operate on it.
- getFeeForMessage: build a real Transfer message in-code and base64
  it via tx.Message.ToBase64(), instead of a dummy string.
- isBlockhashValid: fetch a live blockhash via GetLatestBlockhash.
- getBlock: switch to mainnet-beta and pass MaxSupportedTransactionVersion,
  which is required now that v0 transactions exist in blocks.
- getProgramAccounts: swap the unbounded Metaplex query for a
  Token-2022 mint query with dataSize filter + DataSlice so the
  response stays small enough for public RPCs.
- getLeaderSchedule: switch to mainnet-beta and print a summary
  instead of spew-dumping every validator in the epoch.

Author: sonicfromnewyoke

rpc/examples/getBlock/getBlock.go

@@ -16,43 +16,48 @@ package main
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/davecgh/go-spew/spew"
 	"github.com/gagliardetto/solana-go"
 	"github.com/gagliardetto/solana-go/rpc"
 )
 
 func main() {
-	endpoint := rpc.TestNet_RPC
-	client := rpc.New(endpoint)
+	ctx := context.Background()
+	client := rpc.New(rpc.MainNetBeta_RPC)
 
-	slot, err := client.GetSlot(context.TODO(), rpc.CommitmentFinalized)
+	slot, err := client.GetSlot(ctx, rpc.CommitmentFinalized)
 	if err != nil {
 		panic(err)
 	}
 
+	// Mainnet blocks contain v0 (versioned) transactions; GetBlock
+	// requires MaxSupportedTransactionVersion or it errors out.
+	maxVersion := uint64(0)
+
 	{
-		out, err := client.GetBlock(context.TODO(), slot)
+		out, err := client.GetBlockWithOpts(ctx, slot, &rpc.GetBlockOpts{
+			MaxSupportedTransactionVersion: &maxVersion,
+		})
 		if err != nil {
 			panic(err)
 		}
-		// spew.Dump(out) // NOTE: This generates a lot of output.
-		spew.Dump(len(out.Transactions))
+		// Full block is large; just show the tx count.
+		fmt.Println("transactions in block:", len(out.Transactions))
 	}
 
 	{
 		includeRewards := false
 		out, err := client.GetBlockWithOpts(
-			context.TODO(),
+			ctx,
 			slot,
-			// You can specify more options here:
 			&rpc.GetBlockOpts{
-				Encoding:   solana.EncodingBase64,
-				Commitment: rpc.CommitmentFinalized,
-				// Get only signatures:
-				TransactionDetails: rpc.TransactionDetailsSignatures,
-				// Exclude rewards:
-				Rewards: &includeRewards,
+				Encoding:                       solana.EncodingBase64,
+				Commitment:                     rpc.CommitmentFinalized,
+				TransactionDetails:             rpc.TransactionDetailsSignatures,
+				Rewards:                        &includeRewards,
+				MaxSupportedTransactionVersion: &maxVersion,
 			},
 		)
 		if err != nil {

rpc/examples/getFeeForMessage/getFeeForMessage.go

@@ -16,22 +16,51 @@ package main
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/davecgh/go-spew/spew"
+	"github.com/gagliardetto/solana-go"
+	"github.com/gagliardetto/solana-go/programs/system"
 	"github.com/gagliardetto/solana-go/rpc"
 )
 
+// GetFeeForMessage returns the fee for a base64-encoded Solana Message
+// (not a full Transaction). Here we construct a realistic Transfer
+// message to show how the base64 argument is produced.
 func main() {
-	endpoint := rpc.TestNet_RPC
-	client := rpc.New(endpoint)
+	ctx := context.Background()
+	client := rpc.New(rpc.MainNetBeta_RPC)
 
-	example, err := client.GetFeeForMessage(
-		context.Background(),
-		"AQABAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAQAA",
+	from := solana.NewWallet().PublicKey()
+	to := solana.NewWallet().PublicKey()
+
+	recent, err := client.GetLatestBlockhash(ctx, rpc.CommitmentFinalized)
+	if err != nil {
+		panic(fmt.Errorf("get blockhash: %w", err))
+	}
+
+	tx, err := solana.NewTransaction(
+		[]solana.Instruction{
+			system.NewTransferInstruction(
+				solana.LAMPORTS_PER_SOL/1000, // 0.001 SOL
+				from,
+				to,
+			).Build(),
+		},
+		recent.Value.Blockhash,
+		solana.TransactionPayer(from),
+	)
+	if err != nil {
+		panic(fmt.Errorf("build tx: %w", err))
+	}
+
+	out, err := client.GetFeeForMessage(
+		ctx,
+		tx.Message.ToBase64(),
 		rpc.CommitmentProcessed,
 	)
 	if err != nil {
 		panic(err)
 	}
-	spew.Dump(example)
+	spew.Dump(out)
 }

rpc/examples/getLeaderSchedule/getLeaderSchedule.go

@@ -16,20 +16,29 @@ package main
 
 import (
 	"context"
+	"fmt"
 
-	"github.com/davecgh/go-spew/spew"
 	"github.com/gagliardetto/solana-go/rpc"
 )
 
 func main() {
-	endpoint := rpc.TestNet_RPC
-	client := rpc.New(endpoint)
+	ctx := context.Background()
+	client := rpc.New(rpc.MainNetBeta_RPC)
 
-	out, err := client.GetLeaderSchedule(
-		context.TODO(),
-	)
+	out, err := client.GetLeaderSchedule(ctx)
 	if err != nil {
 		panic(err)
 	}
-	spew.Dump(out) // NOTE: this creates a lot of output
+
+	// The response maps every validator in the current epoch to its
+	// scheduled slots; on mainnet this is huge. Only print a summary.
+	fmt.Println("validators in current epoch:", len(out))
+	count := 0
+	for validator, slots := range out {
+		if count >= 5 {
+			break
+		}
+		fmt.Printf("  %s -> %d slots\n", validator, len(slots))
+		count++
+	}
 }

rpc/examples/getProgramAccounts/getProgramAccounts.go

@@ -16,23 +16,43 @@ package main
 
 import (
 	"context"
+	"fmt"
 
-	"github.com/davecgh/go-spew/spew"
 	"github.com/gagliardetto/solana-go"
 	"github.com/gagliardetto/solana-go/rpc"
 )
 
+// getProgramAccounts returns every account owned by a program. Public
+// mainnet RPCs reject it without a restrictive filter because the
+// response would be too large. This example filters Token-2022 accounts
+// down to just mint accounts (82-byte data) and prints the first few.
 func main() {
-	endpoint := rpc.TestNet_RPC
-	client := rpc.New(endpoint)
+	ctx := context.Background()
+	client := rpc.New(rpc.MainNetBeta_RPC)
 
-	out, err := client.GetProgramAccounts(
-		context.TODO(),
-		solana.MustPublicKeyFromBase58("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"),
+	out, err := client.GetProgramAccountsWithOpts(
+		ctx,
+		solana.Token2022ProgramID,
+		&rpc.GetProgramAccountsOpts{
+			Commitment: rpc.CommitmentFinalized,
+			Filters: []rpc.RPCFilter{
+				{DataSize: 82}, // SPL Token mint account size
+			},
+			// Only fetch the first byte of data so the response stays small.
+			DataSlice: &rpc.DataSlice{Offset: ptrU64(0), Length: ptrU64(1)},
+		},
 	)
 	if err != nil {
 		panic(err)
 	}
-	spew.Dump(len(out))
-	spew.Dump(out) // NOTE: this can generate a lot of output
+
+	fmt.Println("Token-2022 mints found:", len(out))
+	for i, acc := range out {
+		if i >= 5 {
+			break
+		}
+		fmt.Printf("  %d: %s\n", i, acc.Pubkey)
+	}
 }
+
+func ptrU64(v uint64) *uint64 { return &v }

rpc/examples/getSignatureStatuses/getSignatureStatuses.go

@@ -16,22 +16,42 @@ package main
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/davecgh/go-spew/spew"
 	"github.com/gagliardetto/solana-go"
 	"github.com/gagliardetto/solana-go/rpc"
 )
 
 func main() {
-	endpoint := rpc.TestNet_RPC
-	client := rpc.New(endpoint)
+	ctx := context.Background()
+	client := rpc.New(rpc.MainNetBeta_RPC)
+
+	// Fetch fresh signatures so the example keeps working as the
+	// cluster advances.
+	limit := 2
+	sigs, err := client.GetSignaturesForAddressWithOpts(
+		ctx,
+		solana.TokenProgramID,
+		&rpc.GetSignaturesForAddressOpts{Limit: &limit},
+	)
+	if err != nil {
+		panic(fmt.Errorf("getSignaturesForAddress: %w", err))
+	}
+	if len(sigs) == 0 {
+		panic("no recent signatures found")
+	}
+
+	toLookup := make([]solana.Signature, 0, len(sigs))
+	for _, s := range sigs {
+		toLookup = append(toLookup, s.Signature)
+	}
+	fmt.Println("querying statuses for", len(toLookup), "signatures")
 
 	out, err := client.GetSignatureStatuses(
-		context.TODO(),
-		true,
-		// All the transactions you want the get the status for:
-		solana.MustSignatureFromBase58("2CwH8SqVZWFa1EvsH7vJXGFors1NdCuWJ7Z85F8YqjCLQ2RuSHQyeGKkfo1Tj9HitSTeLoMWnxpjxF2WsCH8nGWh"),
-		solana.MustSignatureFromBase58("5YJHZPeHZuZjhunBc1CCB1NDRNf2tTJNpdb3azGsR7PfyEncCDhr95wG8EWrvjNXBc4wCKixkheSbCxoC2NCG3X7"),
+		ctx,
+		true, // searchTransactionHistory
+		toLookup...,
 	)
 	if err != nil {
 		panic(err)

rpc/examples/getTransaction/getTransaction.go

@@ -16,6 +16,7 @@ package main
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/davecgh/go-spew/spew"
 	bin "github.com/gagliardetto/binary"
@@ -24,28 +25,34 @@ import (
 )
 
 func main() {
-	endpoint := rpc.TestNet_RPC
-	client := rpc.New(endpoint)
+	ctx := context.Background()
+	client := rpc.New(rpc.MainNetBeta_RPC)
 
-	txSig := solana.MustSignatureFromBase58("4bjVLV1g9SAfv7BSAdNnuSPRbSscADHFe4HegL6YVcuEBMY83edLEvtfjE4jfr6rwdLwKBQbaFiGgoLGtVicDzHq")
-	{
-		out, err := client.GetTransaction(
-			context.TODO(),
-			txSig,
-			nil,
-		)
-		if err != nil {
-			panic(err)
-		}
-		spew.Dump(out)
-		spew.Dump(out.Transaction.GetTransaction())
+	// Fetch a fresh signature so the example keeps working as the
+	// cluster advances. The SPL Token program always has recent activity
+	// on mainnet-beta.
+	limit := 1
+	sigs, err := client.GetSignaturesForAddressWithOpts(
+		ctx,
+		solana.TokenProgramID,
+		&rpc.GetSignaturesForAddressOpts{Limit: &limit},
+	)
+	if err != nil {
+		panic(fmt.Errorf("getSignaturesForAddress: %w", err))
+	}
+	if len(sigs) == 0 {
+		panic("no recent signatures found")
 	}
+	txSig := sigs[0].Signature
+	fmt.Println("fetching tx:", txSig)
+
+	maxVersion := uint64(0)
 	{
 		out, err := client.GetTransaction(
-			context.TODO(),
+			ctx,
 			txSig,
 			&rpc.GetTransactionOpts{
-				Encoding: solana.EncodingJSON,
+				MaxSupportedTransactionVersion: &maxVersion,
 			},
 		)
 		if err != nil {
@@ -56,24 +63,26 @@ func main() {
 	}
 	{
 		out, err := client.GetTransaction(
-			context.TODO(),
+			ctx,
 			txSig,
 			&rpc.GetTransactionOpts{
-				Encoding: solana.EncodingBase58,
+				Encoding:                       solana.EncodingJSON,
+				MaxSupportedTransactionVersion: &maxVersion,
 			},
 		)
 		if err != nil {
 			panic(err)
 		}
 		spew.Dump(out)
-		spew.Dump(out.Transaction.GetBinary())
+		spew.Dump(out.Transaction.GetTransaction())
 	}
 	{
 		out, err := client.GetTransaction(
-			context.TODO(),
+			ctx,
 			txSig,
 			&rpc.GetTransactionOpts{
-				Encoding: solana.EncodingBase64,
+				Encoding:                       solana.EncodingBase64,
+				MaxSupportedTransactionVersion: &maxVersion,
 			},
 		)
 		if err != nil {

rpc/examples/isBlockhashValid/isValidBlockhash.go

@@ -19,25 +19,29 @@ import (
 	"fmt"
 
 	"github.com/davecgh/go-spew/spew"
-	"github.com/gagliardetto/solana-go"
 	"github.com/gagliardetto/solana-go/rpc"
 )
 
 func main() {
-	endpoint := rpc.MainNetBeta_RPC
-	client := rpc.New(endpoint)
+	ctx := context.Background()
+	client := rpc.New(rpc.MainNetBeta_RPC)
+
+	// Blockhashes are only valid for ~150 blocks (~1 minute), so fetch
+	// a live one instead of hardcoding.
+	recent, err := client.GetLatestBlockhash(ctx, rpc.CommitmentFinalized)
+	if err != nil {
+		panic(fmt.Errorf("get blockhash: %w", err))
+	}
 
-	blockHash := solana.MustHashFromBase58("J7rBdM6AecPDEZp8aPq5iPSNKVkU5Q76F3oAV4eW5wsW")
 	out, err := client.IsBlockhashValid(
-		context.TODO(),
-		blockHash,
+		ctx,
+		recent.Value.Blockhash,
 		rpc.CommitmentFinalized,
 	)
 	if err != nil {
 		panic(err)
 	}
 	spew.Dump(out)
-	spew.Dump(out.Value) // true or false
 
-	fmt.Println("is blockhash valid:", out.Value)
+	fmt.Println("is blockhash valid:", out.Value) // true or false
 }