add GetAllPriceAccounts, support commitment level and slots context

Author: Richard Patel

accounts.go

@@ -261,3 +261,24 @@ func (m *MappingAccount) ProductKeys() []solana.PublicKey {
 	}
 	return m.Products[:m.Num]
 }
+
+// ProductAccountEntry is a versioned product account and its pubkey.
+type ProductAccountEntry struct {
+	*ProductAccount
+	Pubkey solana.PublicKey `json:"pubkey"`
+	Slot   uint64           `json:"slot"`
+}
+
+// PriceAccountEntry is a versioned price account and its pubkey.
+type PriceAccountEntry struct {
+	*PriceAccount
+	Pubkey solana.PublicKey `json:"pubkey"`
+	Slot   uint64           `json:"slot"`
+}
+
+// MappingAccountEntry is a versioned mapping account and its pubkey.
+type MappingAccountEntry struct {
+	*MappingAccount
+	Pubkey solana.PublicKey `json:"pubkey"`
+	Slot   uint64           `json:"slot"`
+}

handler.go

@@ -90,9 +90,9 @@ func (p *PriceEventHandler) getComponentCallbacks(priceKey solana.PublicKey, pub
 	return res
 }
 
-func (p *PriceEventHandler) consume(updates <-chan PriceAccountUpdate) {
+func (p *PriceEventHandler) consume(updates <-chan PriceAccountEntry) {
 	for update := range updates {
-		p.processUpdate(update.Pubkey, update.Price)
+		p.processUpdate(update.Pubkey, update.PriceAccount)
 	}
 }
 

query.go

@@ -20,53 +20,70 @@ import (
 	"fmt"
 
 	"github.com/gagliardetto/solana-go"
+	"github.com/gagliardetto/solana-go/rpc"
 )
 
 // GetPriceAccount retrieves a price account from the blockchain.
-func (c *Client) GetPriceAccount(ctx context.Context, priceKey solana.PublicKey) (*PriceAccount, error) {
+func (c *Client) GetPriceAccount(ctx context.Context, priceKey solana.PublicKey, commitment rpc.CommitmentType) (PriceAccountEntry, error) {
 	price := new(PriceAccount)
-	if err := c.queryFor(ctx, price, priceKey); err != nil {
-		return nil, err
+	slot, err := c.queryFor(ctx, price, priceKey, commitment)
+	if err != nil {
+		return PriceAccountEntry{}, err
 	}
-	return price, nil
+	return PriceAccountEntry{
+		PriceAccount: price,
+		Pubkey:       priceKey,
+		Slot:         slot,
+	}, nil
 }
 
 // GetProductAccount retrieves a product account from the blockchain.
-func (c *Client) GetProductAccount(ctx context.Context, productKey solana.PublicKey) (*ProductAccount, error) {
+func (c *Client) GetProductAccount(ctx context.Context, productKey solana.PublicKey, commitment rpc.CommitmentType) (ProductAccountEntry, error) {
 	product := new(ProductAccount)
-	if err := c.queryFor(ctx, product, productKey); err != nil {
-		return nil, err
+	slot, err := c.queryFor(ctx, product, productKey, commitment)
+	if err != nil {
+		return ProductAccountEntry{}, err
 	}
-	return product, nil
+	return ProductAccountEntry{
+		ProductAccount: product,
+		Pubkey:         productKey,
+		Slot:           slot,
+	}, nil
 }
 
 // GetMappingAccount retrieves a single mapping account from the blockchain.
-func (c *Client) GetMappingAccount(ctx context.Context, mappingKey solana.PublicKey) (*MappingAccount, error) {
+func (c *Client) GetMappingAccount(ctx context.Context, mappingKey solana.PublicKey, commitment rpc.CommitmentType) (MappingAccountEntry, error) {
 	mapping := new(MappingAccount)
-	if err := c.queryFor(ctx, mapping, mappingKey); err != nil {
-		return nil, err
+	slot, err := c.queryFor(ctx, mapping, mappingKey, commitment)
+	if err != nil {
+		return MappingAccountEntry{}, err
 	}
-	return mapping, nil
+	return MappingAccountEntry{
+		MappingAccount: mapping,
+		Pubkey:         mappingKey,
+		Slot:           slot,
+	}, nil
 }
 
-func (c *Client) queryFor(ctx context.Context, acc encoding.BinaryUnmarshaler, key solana.PublicKey) error {
-	info, err := c.RPC.GetAccountInfo(ctx, key)
+func (c *Client) queryFor(ctx context.Context, acc encoding.BinaryUnmarshaler, key solana.PublicKey, commitment rpc.CommitmentType) (slot uint64, err error) {
+	info, err := c.RPC.GetAccountInfoWithOpts(ctx, key, &rpc.GetAccountInfoOpts{Commitment: commitment})
 	if err != nil {
-		return err
+		return 0, err
 	}
 
+	slot = info.Context.Slot
 	data := info.Value.Data.GetBinary()
-	return acc.UnmarshalBinary(data)
+	return slot, acc.UnmarshalBinary(data)
 }
 
 // GetAllProductKeys lists all mapping accounts for product account pubkeys.
-func (c *Client) GetAllProductKeys(ctx context.Context) ([]solana.PublicKey, error) {
+func (c *Client) GetAllProductKeys(ctx context.Context, commitment rpc.CommitmentType) ([]solana.PublicKey, error) {
 	var products []solana.PublicKey
 	next := c.Env.Mapping
 
 	const maxAccounts = 128 // arbitrary limit on the mapping account list length
 	for i := 0; i < maxAccounts && !next.IsZero(); i++ {
-		acc, err := c.GetMappingAccount(ctx, next)
+		acc, err := c.GetMappingAccount(ctx, next, commitment)
 		if err != nil {
 			return products, fmt.Errorf("error getting mapping account %s (#%d): %w", next, i+1, err)
 		}
@@ -77,17 +94,11 @@ func (c *Client) GetAllProductKeys(ctx context.Context) ([]solana.PublicKey, err
 	return products, nil
 }
 
-// ProductAccountEntry is a product account and its pubkey.
-type ProductAccountEntry struct {
-	ProductAccount
-	Pubkey solana.PublicKey `json:"pubkey"`
-}
-
-// GetAllProducts returns all product accounts.
+// GetAllProductAccounts returns all product accounts.
 //
 // Aborts and returns an error if any product account failed to fetch.
-func (c *Client) GetAllProducts(ctx context.Context) ([]ProductAccountEntry, error) {
-	keys, err := c.GetAllProductKeys(ctx)
+func (c *Client) GetAllProductAccounts(ctx context.Context, commitment rpc.CommitmentType) ([]ProductAccountEntry, error) {
+	keys, err := c.GetAllProductKeys(ctx, commitment)
 	if err != nil {
 		return nil, err
 	}
@@ -103,16 +114,21 @@ func (c *Client) GetAllProducts(ctx context.Context) ([]ProductAccountEntry, err
 			keys = nil
 		}
 
-		if err := c.getProductsPage(ctx, &accs, nextKeys); err != nil {
+		if err := c.getProductAccountsPage(ctx, &accs, nextKeys, commitment); err != nil {
 			return accs, err
 		}
 	}
 
 	return accs, nil
 }
 
-func (c *Client) getProductsPage(ctx context.Context, accs *[]ProductAccountEntry, keys []solana.PublicKey) error {
-	res, err := c.RPC.GetMultipleAccounts(ctx, keys...)
+func (c *Client) getProductAccountsPage(
+	ctx context.Context,
+	accs *[]ProductAccountEntry, // accounts out
+	keys []solana.PublicKey,     // keys in
+	commitment rpc.CommitmentType,
+) error {
+	res, err := c.RPC.GetMultipleAccountsWithOpts(ctx, keys, &rpc.GetMultipleAccountsOpts{Commitment: commitment})
 	if err != nil {
 		return err
 	}
@@ -123,13 +139,101 @@ func (c *Client) getProductsPage(ctx context.Context, accs *[]ProductAccountEntr
 
 	for i, info := range res.Value {
 		accountData := info.Data.GetBinary()
-		var acc ProductAccount
+		acc := new(ProductAccount)
 		if err := acc.UnmarshalBinary(accountData); err != nil {
 			return fmt.Errorf("failed to retrieve product account %s: %w", keys[i], err)
 		}
 		*accs = append(*accs, ProductAccountEntry{
 			ProductAccount: acc,
 			Pubkey:         keys[i],
+			Slot:           res.Context.Slot,
+		})
+	}
+
+	return nil
+}
+
+// GetAllPriceAccounts returns all price accounts.
+//
+// Aborts and returns an error if any product account failed to fetch.
+func (c *Client) GetAllPriceAccounts(ctx context.Context, commitment rpc.CommitmentType) ([]PriceAccountEntry, error) {
+	// Start by enumerating all product accounts. They contain the first price account of each product.
+	products, err := c.GetAllProductAccounts(ctx, commitment)
+	if err != nil {
+		return nil, err
+	}
+
+	// List of keys that we need to fetch.
+	keys := make([]solana.PublicKey, 0, len(products))
+	for _, product := range products {
+		if !product.FirstPrice.IsZero() {
+			keys = append(keys, product.FirstPrice)
+		}
+	}
+
+	return c.GetPriceAccountsRecursive(ctx, commitment, keys...)
+}
+
+// GetPriceAccountsRecursive retrieves the price accounts of the given public keys.
+//
+// If these price accounts have successors, their contents will be fetched as well, recursively.
+// When called with the ProductAccountHeader.FirstPrice, it will fetch all price accounts of a product.
+func (c *Client) GetPriceAccountsRecursive(ctx context.Context, commitment rpc.CommitmentType, priceKeys ...solana.PublicKey) ([]PriceAccountEntry, error) {
+	// Set of accounts seen to prevent infinite loops of price account linked lists.
+	// Technically, infinite loops should never occur. But you never know.
+	seen := make(map[solana.PublicKey]struct{})
+
+	var accs []PriceAccountEntry
+	for len(priceKeys) > 0 {
+		// Get next block of keys from list.
+		nextKeys := priceKeys
+		if len(nextKeys) > c.AccountsBatchSize {
+			nextKeys = nextKeys[:c.AccountsBatchSize]
+			priceKeys = priceKeys[c.AccountsBatchSize:]
+		} else {
+			priceKeys = nil
+		}
+
+		if err := c.getPriceAccountsPage(ctx, &accs, nextKeys, &priceKeys, seen, commitment); err != nil {
+			return accs, err
+		}
+	}
+
+	return accs, nil
+}
+
+func (c *Client) getPriceAccountsPage(
+	ctx context.Context,
+	accs *[]PriceAccountEntry,                 // accounts out
+	nextKeys []solana.PublicKey,               // keys in
+	allKeys *[]solana.PublicKey,               // keys out
+	visitedKeys map[solana.PublicKey]struct{}, // keys seen
+	commitment rpc.CommitmentType,
+) error {
+	res, err := c.RPC.GetMultipleAccountsWithOpts(ctx, nextKeys, &rpc.GetMultipleAccountsOpts{Commitment: commitment})
+	if err != nil {
+		return err
+	}
+
+	if len(res.Value) != len(nextKeys) {
+		return fmt.Errorf("unexpected number of price accounts, asked for %d but got %d", len(nextKeys), len(res.Value))
+	}
+
+	for i, info := range res.Value {
+		accountData := info.Data.GetBinary()
+		acc := new(PriceAccount)
+		if err := acc.UnmarshalBinary(accountData); err != nil {
+			return fmt.Errorf("failed to retrieve product account %s: %w", nextKeys[i], err)
+		}
+		_, seen := visitedKeys[acc.Next]
+		if !seen && !acc.Next.IsZero() {
+			*allKeys = append(*allKeys, acc.Next)
+			visitedKeys[acc.Next] = struct{}{}
+		}
+		*accs = append(*accs, PriceAccountEntry{
+			PriceAccount: acc,
+			Pubkey:       nextKeys[i],
+			Slot:         res.Context.Slot,
 		})
 	}