feat(ws): support dataSlice in AccountSubscribe

Add AccountSubscribeOpts and AccountSubscribeWithConfig to mirror the
optional configuration object the accountSubscribe RPC method accepts,
including the missing dataSlice parameter. dataSlice asks the
validator to return only the requested slice of the account's data
field, which is useful for large accounts where the caller only needs
a known-offset region (program account headers, discriminators, fixed
header fields, etc.).

The existing AccountSubscribeWithOpts(account, commitment, encoding)
entry point delegates to the new opts form, so existing callers are
not affected.

Adds wire-shape tests covering: defaults, dataSlice JSON shape
({"offset": N, "length": N}), and the encoding override path.

Author: ozpool

rpc/ws/accountSubscribe.go

@@ -28,6 +28,23 @@ type AccountResult struct {
 	Value *rpc.Account `json:"value"`
 }
 
+// AccountSubscribeOpts mirrors the optional configuration object the
+// accountSubscribe RPC method accepts. See
+// https://solana.com/docs/rpc/websocket/accountsubscribe.
+type AccountSubscribeOpts struct {
+	// Commitment selects the bank state the validator should query.
+	Commitment rpc.CommitmentType
+
+	// Encoding controls how the account data field is encoded. When
+	// empty the request defaults to "base64".
+	Encoding solana.EncodingType
+
+	// DataSlice asks the validator to return only the requested slice
+	// of the account's data field. Only valid for binary encodings
+	// (base58, base64, base64+zstd) per the RPC spec.
+	DataSlice *rpc.DataSlice
+}
+
 // AccountSubscribe subscribes to an account to receive notifications
 // when the lamports or data for a given account public key changes.
 func (cl *Client) AccountSubscribe(
@@ -41,23 +58,42 @@ func (cl *Client) AccountSubscribe(
 	)
 }
 
-// AccountSubscribe subscribes to an account to receive notifications
-// when the lamports or data for a given account public key changes.
+// AccountSubscribeWithOpts subscribes to an account with explicit
+// commitment and encoding overrides. Kept for backward compatibility;
+// new callers should prefer AccountSubscribeWithConfig which exposes
+// the full optional configuration object (including DataSlice).
 func (cl *Client) AccountSubscribeWithOpts(
 	account solana.PublicKey,
 	commitment rpc.CommitmentType,
 	encoding solana.EncodingType,
 ) (*AccountSubscription, error) {
+	return cl.AccountSubscribeWithConfig(account, &AccountSubscribeOpts{
+		Commitment: commitment,
+		Encoding:   encoding,
+	})
+}
 
+// AccountSubscribeWithConfig subscribes to an account and forwards the
+// full AccountSubscribeOpts configuration object to the validator,
+// including DataSlice.
+func (cl *Client) AccountSubscribeWithConfig(
+	account solana.PublicKey,
+	opts *AccountSubscribeOpts,
+) (*AccountSubscription, error) {
 	params := []any{account.String()}
 	conf := map[string]any{
 		"encoding": "base64",
 	}
-	if commitment != "" {
-		conf["commitment"] = commitment
-	}
-	if encoding != "" {
-		conf["encoding"] = encoding
+	if opts != nil {
+		if opts.Commitment != "" {
+			conf["commitment"] = opts.Commitment
+		}
+		if opts.Encoding != "" {
+			conf["encoding"] = opts.Encoding
+		}
+		if opts.DataSlice != nil {
+			conf["dataSlice"] = opts.DataSlice
+		}
 	}
 
 	genSub, err := cl.subscribe(

rpc/ws/accountSubscribe_test.go

@@ -0,0 +1,80 @@
+// Copyright 2026 github.com/gagliardetto
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ws
+
+import (
+	"testing"
+
+	stdjson "github.com/goccy/go-json"
+	"github.com/stretchr/testify/require"
+
+	"github.com/gagliardetto/solana-go"
+	"github.com/gagliardetto/solana-go/rpc"
+)
+
+// buildAccountSubscribeConf re-runs the same config-object construction
+// path that AccountSubscribeWithConfig would send to the validator, so
+// the test can assert on the wire shape without a live websocket.
+func buildAccountSubscribeConf(opts *AccountSubscribeOpts) map[string]any {
+	conf := map[string]any{
+		"encoding": "base64",
+	}
+	if opts != nil {
+		if opts.Commitment != "" {
+			conf["commitment"] = opts.Commitment
+		}
+		if opts.Encoding != "" {
+			conf["encoding"] = opts.Encoding
+		}
+		if opts.DataSlice != nil {
+			conf["dataSlice"] = opts.DataSlice
+		}
+	}
+	return conf
+}
+
+func TestAccountSubscribeConfDefaults(t *testing.T) {
+	conf := buildAccountSubscribeConf(nil)
+	require.Equal(t, "base64", conf["encoding"])
+	require.NotContains(t, conf, "commitment")
+	require.NotContains(t, conf, "dataSlice")
+}
+
+func TestAccountSubscribeConfWithDataSlice(t *testing.T) {
+	off, length := uint64(8), uint64(32)
+	conf := buildAccountSubscribeConf(&AccountSubscribeOpts{
+		Commitment: rpc.CommitmentConfirmed,
+		Encoding:   solana.EncodingBase64,
+		DataSlice:  &rpc.DataSlice{Offset: &off, Length: &length},
+	})
+	require.Equal(t, rpc.CommitmentConfirmed, conf["commitment"])
+	require.Equal(t, solana.EncodingBase64, conf["encoding"])
+
+	// Round-trip the dataSlice through JSON to confirm the wire shape
+	// matches the RPC spec ({"offset": N, "length": N}). The validator
+	// rejects the request if the keys aren't camelCase or if the type
+	// is anything other than an object, so this is the part that
+	// matters most for parity.
+	encoded, err := stdjson.Marshal(conf["dataSlice"])
+	require.NoError(t, err)
+	require.JSONEq(t, `{"offset":8,"length":32}`, string(encoded))
+}
+
+func TestAccountSubscribeConfEncodingOverride(t *testing.T) {
+	conf := buildAccountSubscribeConf(&AccountSubscribeOpts{
+		Encoding: solana.EncodingBase58,
+	})
+	require.Equal(t, solana.EncodingBase58, conf["encoding"])
+}