diff --git a/README.md b/README.md
index 17572ed..629b04f 100644
--- a/README.md
+++ b/README.md
@@ -276,7 +276,7 @@ func main() {
     if err != nil { log.Fatal(err) }
     fmt.Printf("Network: %s\n", health.Network)
 
-    result, err := client.DataPutPublic(ctx, []byte("Hello, Autonomi!"))
+    result, err := client.DataPutPublic(ctx, []byte("Hello, Autonomi!"), antd.PaymentModeAuto)
     if err != nil { log.Fatal(err) }
     fmt.Printf("Address: %s\n", result.Address)
 
diff --git a/antd-go/README.md b/antd-go/README.md
index 2ea591d..19c938e 100644
--- a/antd-go/README.md
+++ b/antd-go/README.md
@@ -34,11 +34,11 @@ func main() {
         health.OK, health.Network, health.Version, health.EvmNetwork)
 
     // Store data
-    result, err := client.DataPutPublic(ctx, []byte("Hello, Autonomi!"))
+    result, err := client.DataPutPublic(ctx, []byte("Hello, Autonomi!"), antd.PaymentModeAuto)
     if err != nil {
         log.Fatal(err)
     }
-    fmt.Printf("Stored at %s (cost: %s atto)\n", result.Address, result.Cost)
+    fmt.Printf("Stored at %s (chunks: %d, mode: %s)\n", result.Address, result.ChunksStored, result.PaymentModeUsed)
 
     // Retrieve data
     data, err := client.DataGetPublic(ctx, result.Address)
@@ -75,13 +75,23 @@ client := antd.NewClient(antd.DefaultBaseURL, antd.WithTimeout(30 * time.Second)
 // Custom HTTP client
 client := antd.NewClient(antd.DefaultBaseURL, antd.WithHTTPClient(myHTTPClient))
 
-// Payment mode for uploads (defaults to "auto")
-result, _ := client.DataPutPublic(ctx, data, antd.WithPaymentMode("merkle"))
-// "auto" = merkle for 64+ chunks, single otherwise
-// "merkle" = force batch payments (saves gas, min 2 chunks)
-// "single" = per-chunk payments
+// Payment mode is a typed enum passed positionally to put/cost methods.
+result, _ := client.DataPutPublic(ctx, data, antd.PaymentModeMerkle)
+// antd.PaymentModeAuto   — server picks merkle for 64+ chunks, single otherwise
+// antd.PaymentModeMerkle — force batch payments (saves gas, min 2 chunks)
+// antd.PaymentModeSingle — per-chunk payments
 ```
 
+### Put/Get naming convention
+
+Methods follow a "private by default" convention: the unqualified verb is the
+private variant; the `_public` suffix marks the public variant.
+
+- `DataPut` / `DataGet` — private. Returns/consumes a caller-held DataMap.
+- `DataPutPublic` / `DataGetPublic` — public. Stores/fetches the DataMap on-network.
+- `FilePut` / `FileGet` — private file upload/download.
+- `FilePutPublic` / `FileGetPublic` — public file upload/download.
+
 ## API Reference
 
 All methods take a `context.Context` as the first parameter for cancellation and timeout control.
@@ -94,11 +104,11 @@ All methods take a `context.Context` as the first parameter for cancellation and
 ### Data (Immutable)
 | Method | Description |
 |--------|-------------|
-| `DataPutPublic(ctx, data)` | Store public data |
-| `DataGetPublic(ctx, address)` | Retrieve public data |
-| `DataPutPrivate(ctx, data)` | Store encrypted private data |
-| `DataGetPrivate(ctx, dataMap)` | Retrieve private data |
-| `DataCost(ctx, data)` | Estimate storage cost — returns `*UploadCostEstimate` with size, chunks, gas, payment mode |
+| `DataPut(ctx, data, paymentMode)` | Store encrypted private data; returns the caller-held DataMap |
+| `DataGet(ctx, dataMap)` | Retrieve private data from a caller-held DataMap |
+| `DataPutPublic(ctx, data, paymentMode)` | Store public data; returns the on-network DataMap address |
+| `DataGetPublic(ctx, address)` | Retrieve public data by address |
+| `DataCost(ctx, data, paymentMode)` | Estimate storage cost — returns `*UploadCostEstimate` |
 
 ### Chunks
 | Method | Description |
@@ -109,9 +119,11 @@ All methods take a `context.Context` as the first parameter for cancellation and
 ### Files
 | Method | Description |
 |--------|-------------|
-| `FileUploadPublic(ctx, path)` | Upload a file |
-| `FileDownloadPublic(ctx, address, destPath)` | Download a file |
-| `FileCost(ctx, path, isPublic)` | Estimate upload cost — returns `*UploadCostEstimate` with size, chunks, gas, payment mode |
+| `FilePut(ctx, path, paymentMode)` | Upload a file privately; returns the caller-held DataMap |
+| `FileGet(ctx, dataMap, destPath)` | Download a private file from a caller-held DataMap |
+| `FilePutPublic(ctx, path, paymentMode)` | Upload a file publicly; returns the on-network DataMap address |
+| `FileGetPublic(ctx, address, destPath)` | Download a public file by address |
+| `FileCost(ctx, path, isPublic, paymentMode)` | Estimate upload cost — returns `*UploadCostEstimate` |
 
 ## gRPC Transport
 
diff --git a/antd-go/client.go b/antd-go/client.go
index 069ad1b..f8616f9 100644
--- a/antd-go/client.go
+++ b/antd-go/client.go
@@ -8,7 +8,6 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"net/url"
 	"strings"
 	"time"
 )
@@ -199,48 +198,56 @@ const (
 
 // --- Data ---
 
-// DataPutPublic stores public immutable data on the network.
-func (c *Client) DataPutPublic(ctx context.Context, data []byte, paymentMode ...PaymentMode) (*PutResult, error) {
-	body := map[string]any{
-		"data": b64Encode(data),
-	}
-	if len(paymentMode) > 0 && paymentMode[0] != "" {
-		body["payment_mode"] = string(paymentMode[0])
-	}
-	j, _, err := c.doJSON(ctx, http.MethodPost, "/v1/data/public", body)
+// DataPut stores private encrypted data on the network and returns the
+// caller-held DataMap (hex). The DataMap is NOT stored on-network — the caller
+// keeps it as the only retrieval handle.
+func (c *Client) DataPut(ctx context.Context, data []byte, paymentMode PaymentMode) (*DataPutResult, error) {
+	j, _, err := c.doJSON(ctx, http.MethodPost, "/v1/data", map[string]any{
+		"data":         b64Encode(data),
+		"payment_mode": string(paymentMode),
+	})
 	if err != nil {
 		return nil, err
 	}
-	return &PutResult{Cost: str(j, "cost"), Address: str(j, "address")}, nil
+	return &DataPutResult{
+		DataMap:         str(j, "data_map"),
+		ChunksStored:    unum64(j, "chunks_stored"),
+		PaymentModeUsed: str(j, "payment_mode_used"),
+	}, nil
 }
 
-// DataGetPublic retrieves public data by address.
-func (c *Client) DataGetPublic(ctx context.Context, address string) ([]byte, error) {
-	j, _, err := c.doJSON(ctx, http.MethodGet, "/v1/data/public/"+address, nil)
+// DataGet retrieves private data from a caller-held DataMap (hex).
+func (c *Client) DataGet(ctx context.Context, dataMap string) ([]byte, error) {
+	j, _, err := c.doJSON(ctx, http.MethodPost, "/v1/data/get", map[string]any{
+		"data_map": dataMap,
+	})
 	if err != nil {
 		return nil, err
 	}
 	return b64Decode(str(j, "data"))
 }
 
-// DataPutPrivate stores private encrypted data on the network.
-func (c *Client) DataPutPrivate(ctx context.Context, data []byte, paymentMode ...PaymentMode) (*PutResult, error) {
-	body := map[string]any{
-		"data": b64Encode(data),
-	}
-	if len(paymentMode) > 0 && paymentMode[0] != "" {
-		body["payment_mode"] = string(paymentMode[0])
-	}
-	j, _, err := c.doJSON(ctx, http.MethodPost, "/v1/data/private", body)
+// DataPutPublic stores public immutable data on the network. The DataMap is
+// stored on-network as an extra chunk; the returned address is the shareable
+// retrieval handle.
+func (c *Client) DataPutPublic(ctx context.Context, data []byte, paymentMode PaymentMode) (*DataPutPublicResult, error) {
+	j, _, err := c.doJSON(ctx, http.MethodPost, "/v1/data/public", map[string]any{
+		"data":         b64Encode(data),
+		"payment_mode": string(paymentMode),
+	})
 	if err != nil {
 		return nil, err
 	}
-	return &PutResult{Cost: str(j, "cost"), Address: str(j, "data_map")}, nil
+	return &DataPutPublicResult{
+		Address:         str(j, "address"),
+		ChunksStored:    unum64(j, "chunks_stored"),
+		PaymentModeUsed: str(j, "payment_mode_used"),
+	}, nil
 }
 
-// DataGetPrivate retrieves private data using a data map.
-func (c *Client) DataGetPrivate(ctx context.Context, dataMap string) ([]byte, error) {
-	j, _, err := c.doJSON(ctx, http.MethodGet, "/v1/data/private?data_map="+url.QueryEscape(dataMap), nil)
+// DataGetPublic retrieves public data by address.
+func (c *Client) DataGetPublic(ctx context.Context, address string) ([]byte, error) {
+	j, _, err := c.doJSON(ctx, http.MethodGet, "/v1/data/public/"+address, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -251,9 +258,10 @@ func (c *Client) DataGetPrivate(ctx context.Context, dataMap string) ([]byte, er
 //
 // The server samples a small number of chunk addresses and extrapolates —
 // much faster than quoting every chunk on slow networks. Gas is advisory.
-func (c *Client) DataCost(ctx context.Context, data []byte) (*UploadCostEstimate, error) {
+func (c *Client) DataCost(ctx context.Context, data []byte, paymentMode PaymentMode) (*UploadCostEstimate, error) {
 	j, _, err := c.doJSON(ctx, http.MethodPost, "/v1/data/cost", map[string]any{
-		"data": b64Encode(data),
+		"data":         b64Encode(data),
+		"payment_mode": string(paymentMode),
 	})
 	if err != nil {
 		return nil, err
@@ -360,19 +368,45 @@ func (c *Client) FinalizeChunkUpload(ctx context.Context, uploadID string, txHas
 
 // --- Files ---
 
-// FileUploadPublic uploads a local file to the network.
-func (c *Client) FileUploadPublic(ctx context.Context, path string, paymentMode ...PaymentMode) (*FileUploadResult, error) {
-	body := map[string]any{
-		"path": path,
-	}
-	if len(paymentMode) > 0 && paymentMode[0] != "" {
-		body["payment_mode"] = string(paymentMode[0])
+// FilePut uploads a local file as a private upload and returns the caller-held
+// DataMap (hex). The DataMap is NOT stored on-network.
+func (c *Client) FilePut(ctx context.Context, path string, paymentMode PaymentMode) (*FilePutResult, error) {
+	j, _, err := c.doJSON(ctx, http.MethodPost, "/v1/files", map[string]any{
+		"path":         path,
+		"payment_mode": string(paymentMode),
+	})
+	if err != nil {
+		return nil, err
 	}
-	j, _, err := c.doJSON(ctx, http.MethodPost, "/v1/files/upload/public", body)
+	return &FilePutResult{
+		DataMap:         str(j, "data_map"),
+		StorageCostAtto: str(j, "storage_cost_atto"),
+		GasCostWei:      str(j, "gas_cost_wei"),
+		ChunksStored:    unum64(j, "chunks_stored"),
+		PaymentModeUsed: str(j, "payment_mode_used"),
+	}, nil
+}
+
+// FileGet downloads a private file from a caller-held DataMap (hex) into destPath.
+func (c *Client) FileGet(ctx context.Context, dataMap, destPath string) error {
+	_, _, err := c.doJSON(ctx, http.MethodPost, "/v1/files/get", map[string]any{
+		"data_map":  dataMap,
+		"dest_path": destPath,
+	})
+	return err
+}
+
+// FilePutPublic uploads a local file as a public upload. The DataMap is stored
+// on-network as an extra chunk; the returned address is the shareable handle.
+func (c *Client) FilePutPublic(ctx context.Context, path string, paymentMode PaymentMode) (*FilePutPublicResult, error) {
+	j, _, err := c.doJSON(ctx, http.MethodPost, "/v1/files/public", map[string]any{
+		"path":         path,
+		"payment_mode": string(paymentMode),
+	})
 	if err != nil {
 		return nil, err
 	}
-	return &FileUploadResult{
+	return &FilePutPublicResult{
 		Address:         str(j, "address"),
 		StorageCostAtto: str(j, "storage_cost_atto"),
 		GasCostWei:      str(j, "gas_cost_wei"),
@@ -381,9 +415,9 @@ func (c *Client) FileUploadPublic(ctx context.Context, path string, paymentMode
 	}, nil
 }
 
-// FileDownloadPublic downloads a file from the network to a local path.
-func (c *Client) FileDownloadPublic(ctx context.Context, address, destPath string) error {
-	_, _, err := c.doJSON(ctx, http.MethodPost, "/v1/files/download/public", map[string]any{
+// FileGetPublic downloads a public file from an on-network DataMap address into destPath.
+func (c *Client) FileGetPublic(ctx context.Context, address, destPath string) error {
+	_, _, err := c.doJSON(ctx, http.MethodPost, "/v1/files/public/get", map[string]any{
 		"address":   address,
 		"dest_path": destPath,
 	})
@@ -394,10 +428,11 @@ func (c *Client) FileDownloadPublic(ctx context.Context, address, destPath strin
 //
 // The server samples a small number of chunk addresses and extrapolates —
 // much faster than quoting every chunk on slow networks. Gas is advisory.
-func (c *Client) FileCost(ctx context.Context, path string, isPublic bool) (*UploadCostEstimate, error) {
+func (c *Client) FileCost(ctx context.Context, path string, isPublic bool, paymentMode PaymentMode) (*UploadCostEstimate, error) {
 	j, _, err := c.doJSON(ctx, http.MethodPost, "/v1/files/cost", map[string]any{
-		"path":      path,
-		"is_public": isPublic,
+		"path":         path,
+		"is_public":    isPublic,
+		"payment_mode": string(paymentMode),
 	})
 	if err != nil {
 		return nil, err
diff --git a/antd-go/client_test.go b/antd-go/client_test.go
index 6d1fafd..f946b5a 100644
--- a/antd-go/client_test.go
+++ b/antd-go/client_test.go
@@ -41,18 +41,18 @@ func mockDaemon(t *testing.T) *httptest.Server {
 
 		// Data put public
 		case r.Method == "POST" && r.URL.Path == "/v1/data/public":
-			writeJSON(w, map[string]any{"cost": "100", "address": "abc123"})
+			writeJSON(w, map[string]any{"address": "abc123", "chunks_stored": float64(3), "payment_mode_used": "auto"})
 
 		// Data get public
 		case r.Method == "GET" && r.URL.Path == "/v1/data/public/abc123":
 			writeJSON(w, map[string]any{"data": base64.StdEncoding.EncodeToString([]byte("hello"))})
 
-		// Data put private
-		case r.Method == "POST" && r.URL.Path == "/v1/data/private":
-			writeJSON(w, map[string]any{"cost": "200", "data_map": "dm123"})
+		// Data put private (POST /v1/data)
+		case r.Method == "POST" && r.URL.Path == "/v1/data":
+			writeJSON(w, map[string]any{"data_map": "dm123", "chunks_stored": float64(2), "payment_mode_used": "merkle"})
 
-		// Data get private
-		case r.Method == "GET" && r.URL.Path == "/v1/data/private":
+		// Data get private (POST /v1/data/get)
+		case r.Method == "POST" && r.URL.Path == "/v1/data/get":
 			writeJSON(w, map[string]any{"data": base64.StdEncoding.EncodeToString([]byte("secret"))})
 
 		// Data cost
@@ -72,7 +72,17 @@ func mockDaemon(t *testing.T) *httptest.Server {
 			writeJSON(w, map[string]any{"data": base64.StdEncoding.EncodeToString([]byte("chunkdata"))})
 
 		// Files
-		case r.Method == "POST" && r.URL.Path == "/v1/files/upload/public":
+		case r.Method == "POST" && r.URL.Path == "/v1/files":
+			writeJSON(w, map[string]any{
+				"data_map":          "filedm1",
+				"storage_cost_atto": "500",
+				"gas_cost_wei":      "21",
+				"chunks_stored":     float64(2),
+				"payment_mode_used": "single",
+			})
+		case r.Method == "POST" && r.URL.Path == "/v1/files/get":
+			w.WriteHeader(200)
+		case r.Method == "POST" && r.URL.Path == "/v1/files/public":
 			writeJSON(w, map[string]any{
 				"address":           "file1",
 				"storage_cost_atto": "1000",
@@ -80,7 +90,7 @@ func mockDaemon(t *testing.T) *httptest.Server {
 				"chunks_stored":     float64(3),
 				"payment_mode_used": "auto",
 			})
-		case r.Method == "POST" && r.URL.Path == "/v1/files/download/public":
+		case r.Method == "POST" && r.URL.Path == "/v1/files/public/get":
 			w.WriteHeader(200)
 		case r.Method == "POST" && r.URL.Path == "/v1/files/cost":
 			writeJSON(w, map[string]any{
@@ -164,11 +174,11 @@ func TestDataPublic(t *testing.T) {
 	c := NewClient(srv.URL)
 	ctx := context.Background()
 
-	put, err := c.DataPutPublic(ctx, []byte("hello"))
+	put, err := c.DataPutPublic(ctx, []byte("hello"), PaymentModeAuto)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if put.Address != "abc123" || put.Cost != "100" {
+	if put.Address != "abc123" || put.ChunksStored != 3 || put.PaymentModeUsed != "auto" {
 		t.Fatalf("unexpected put: %+v", put)
 	}
 
@@ -187,15 +197,15 @@ func TestDataPrivate(t *testing.T) {
 	c := NewClient(srv.URL)
 	ctx := context.Background()
 
-	put, err := c.DataPutPrivate(ctx, []byte("secret"))
+	put, err := c.DataPut(ctx, []byte("secret"), PaymentModeMerkle)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if put.Address != "dm123" || put.Cost != "200" {
+	if put.DataMap != "dm123" || put.ChunksStored != 2 || put.PaymentModeUsed != "merkle" {
 		t.Fatalf("unexpected put: %+v", put)
 	}
 
-	data, err := c.DataGetPrivate(ctx, "dm123")
+	data, err := c.DataGet(ctx, "dm123")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -208,7 +218,7 @@ func TestDataCost(t *testing.T) {
 	srv := mockDaemon(t)
 	defer srv.Close()
 	c := NewClient(srv.URL)
-	est, err := c.DataCost(context.Background(), []byte("test"))
+	est, err := c.DataCost(context.Background(), []byte("test"), PaymentModeSingle)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -222,7 +232,7 @@ func TestFileCost(t *testing.T) {
 	srv := mockDaemon(t)
 	defer srv.Close()
 	c := NewClient(srv.URL)
-	est, err := c.FileCost(context.Background(), "/tmp/file.bin", true)
+	est, err := c.FileCost(context.Background(), "/tmp/file.bin", true, PaymentModeAuto)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -261,7 +271,7 @@ func TestFiles(t *testing.T) {
 	c := NewClient(srv.URL)
 	ctx := context.Background()
 
-	put, err := c.FileUploadPublic(ctx, "/tmp/test.txt")
+	put, err := c.FilePutPublic(ctx, "/tmp/test.txt", PaymentModeAuto)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -269,12 +279,24 @@ func TestFiles(t *testing.T) {
 		t.Fatalf("unexpected file upload: %+v", put)
 	}
 
-	err = c.FileDownloadPublic(ctx, "file1", "/tmp/out.txt")
+	err = c.FileGetPublic(ctx, "file1", "/tmp/out.txt")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	est, err := c.FileCost(ctx, "/tmp/test.txt", true)
+	privPut, err := c.FilePut(ctx, "/tmp/test.txt", PaymentModeSingle)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if privPut.DataMap != "filedm1" || privPut.StorageCostAtto != "500" || privPut.ChunksStored != 2 || privPut.PaymentModeUsed != "single" {
+		t.Fatalf("unexpected private file upload: %+v", privPut)
+	}
+
+	if err := c.FileGet(ctx, "filedm1", "/tmp/out.txt"); err != nil {
+		t.Fatal(err)
+	}
+
+	est, err := c.FileCost(ctx, "/tmp/test.txt", true, PaymentModeAuto)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -395,6 +417,74 @@ func TestFinalizeUpload(t *testing.T) {
 	}
 }
 
+// TestPaymentModeWiresIntoRequestBody verifies the PaymentMode argument
+// reaches the REST `payment_mode` field on every put/cost endpoint. Captures
+// the body of each request and asserts the serialized value.
+func TestPaymentModeWiresIntoRequestBody(t *testing.T) {
+	captured := map[string]string{}
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var body map[string]any
+		_ = json.NewDecoder(r.Body).Decode(&body)
+		if pm, ok := body["payment_mode"].(string); ok {
+			captured[r.URL.Path] = pm
+		}
+		w.Header().Set("Content-Type", "application/json")
+		switch r.URL.Path {
+		case "/v1/data":
+			writeJSON(w, map[string]any{"data_map": "dm"})
+		case "/v1/data/public":
+			writeJSON(w, map[string]any{"address": "addr"})
+		case "/v1/data/cost":
+			writeJSON(w, map[string]any{})
+		case "/v1/files":
+			writeJSON(w, map[string]any{"data_map": "fdm"})
+		case "/v1/files/public":
+			writeJSON(w, map[string]any{"address": "faddr"})
+		case "/v1/files/cost":
+			writeJSON(w, map[string]any{})
+		default:
+			w.WriteHeader(404)
+		}
+	}))
+	defer srv.Close()
+
+	c := NewClient(srv.URL)
+	ctx := context.Background()
+
+	if _, err := c.DataPut(ctx, []byte("x"), PaymentModeMerkle); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := c.DataPutPublic(ctx, []byte("x"), PaymentModeSingle); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := c.DataCost(ctx, []byte("x"), PaymentModeAuto); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := c.FilePut(ctx, "/tmp/x", PaymentModeMerkle); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := c.FilePutPublic(ctx, "/tmp/x", PaymentModeSingle); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := c.FileCost(ctx, "/tmp/x", false, PaymentModeAuto); err != nil {
+		t.Fatal(err)
+	}
+
+	want := map[string]string{
+		"/v1/data":         "merkle",
+		"/v1/data/public":  "single",
+		"/v1/data/cost":    "auto",
+		"/v1/files":        "merkle",
+		"/v1/files/public": "single",
+		"/v1/files/cost":   "auto",
+	}
+	for path, expected := range want {
+		if got := captured[path]; got != expected {
+			t.Errorf("%s: payment_mode = %q, want %q", path, got, expected)
+		}
+	}
+}
+
 func TestErrorMapping(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "application/json")
diff --git a/antd-go/examples/02-data/main.go b/antd-go/examples/02-data/main.go
index d0a7460..e01d9f7 100644
--- a/antd-go/examples/02-data/main.go
+++ b/antd-go/examples/02-data/main.go
@@ -14,11 +14,11 @@ func main() {
 	ctx := context.Background()
 
 	// Store public data
-	result, err := client.DataPutPublic(ctx, []byte("Hello, Autonomi!"))
+	result, err := client.DataPutPublic(ctx, []byte("Hello, Autonomi!"), antd.PaymentModeAuto)
 	if err != nil {
 		log.Fatal(err)
 	}
-	fmt.Printf("Stored public data at %s (cost: %s atto)\n", result.Address, result.Cost)
+	fmt.Printf("Stored public data at %s (chunks: %d, mode: %s)\n", result.Address, result.ChunksStored, result.PaymentModeUsed)
 
 	// Retrieve it
 	data, err := client.DataGetPublic(ctx, result.Address)
@@ -28,14 +28,14 @@ func main() {
 	fmt.Printf("Retrieved: %s\n", data)
 
 	// Store private data
-	privResult, err := client.DataPutPrivate(ctx, []byte("Secret message"))
+	privResult, err := client.DataPut(ctx, []byte("Secret message"), antd.PaymentModeAuto)
 	if err != nil {
 		log.Fatal(err)
 	}
-	fmt.Printf("Stored private data (data_map: %s, cost: %s atto)\n", privResult.Address, privResult.Cost)
+	fmt.Printf("Stored private data (data_map: %s, chunks: %d, mode: %s)\n", privResult.DataMap, privResult.ChunksStored, privResult.PaymentModeUsed)
 
 	// Retrieve private data
-	privData, err := client.DataGetPrivate(ctx, privResult.Address)
+	privData, err := client.DataGet(ctx, privResult.DataMap)
 	if err != nil {
 		log.Fatal(err)
 	}
diff --git a/antd-go/examples/03-files/main.go b/antd-go/examples/03-files/main.go
index 2f9d8f6..1c1c230 100644
--- a/antd-go/examples/03-files/main.go
+++ b/antd-go/examples/03-files/main.go
@@ -27,14 +27,14 @@ func main() {
 		log.Fatalf("write source: %v", err)
 	}
 
-	est, err := client.FileCost(ctx, srcPath, true)
+	est, err := client.FileCost(ctx, srcPath, true, antd.PaymentModeAuto)
 	if err != nil {
 		log.Fatalf("file cost: %v", err)
 	}
 	fmt.Printf("Estimate: %d bytes in %d chunks, storage %s atto, gas %s wei, mode %s\n",
 		est.FileSize, est.ChunkCount, est.Cost, est.EstimatedGasCostWei, est.PaymentMode)
 
-	result, err := client.FileUploadPublic(ctx, srcPath)
+	result, err := client.FilePutPublic(ctx, srcPath, antd.PaymentModeAuto)
 	if err != nil {
 		log.Fatalf("file upload: %v", err)
 	}
@@ -42,7 +42,7 @@ func main() {
 		result.Address, result.StorageCostAtto, result.GasCostWei, result.ChunksStored, result.PaymentModeUsed)
 
 	dstPath := srcPath + ".downloaded"
-	if err := client.FileDownloadPublic(ctx, result.Address, dstPath); err != nil {
+	if err := client.FileGetPublic(ctx, result.Address, dstPath); err != nil {
 		log.Fatalf("file download: %v", err)
 	}
 	fmt.Printf("Downloaded to: %s\n", dstPath)
diff --git a/antd-go/examples/07-external-signer/main.go b/antd-go/examples/07-external-signer/main.go
index 05a9971..82db3c9 100644
--- a/antd-go/examples/07-external-signer/main.go
+++ b/antd-go/examples/07-external-signer/main.go
@@ -187,7 +187,7 @@ func main() {
 		fileFin.DataMapAddress, fileFin.ChunksStored)
 
 	dstPath := srcPath + ".downloaded"
-	if err := client.FileDownloadPublic(ctx, fileFin.DataMapAddress, dstPath); err != nil {
+	if err := client.FileGetPublic(ctx, fileFin.DataMapAddress, dstPath); err != nil {
 		log.Fatalf("file download: %v", err)
 	}
 	got, err := os.ReadFile(dstPath)
diff --git a/antd-go/grpc_client.go b/antd-go/grpc_client.go
index 08ab16a..5ca7a96 100644
--- a/antd-go/grpc_client.go
+++ b/antd-go/grpc_client.go
@@ -168,54 +168,60 @@ func (c *GrpcClient) Health(ctx context.Context) (*HealthStatus, error) {
 
 // --- Data (5 methods) ---
 
-// DataPutPublic stores public immutable data on the network.
-func (c *GrpcClient) DataPutPublic(ctx context.Context, data []byte) (*PutResult, error) {
+// DataPut stores private encrypted data on the network and returns the
+// caller-held DataMap (hex).
+func (c *GrpcClient) DataPut(ctx context.Context, data []byte, paymentMode PaymentMode) (*DataPutResult, error) {
 	ctx, cancel := c.ctx(ctx)
 	defer cancel()
 
-	resp, err := c.data.PutPublic(ctx, &pb.PutPublicDataRequest{Data: data})
+	resp, err := c.data.Put(ctx, &pb.PutDataRequest{
+		Data:        data,
+		PaymentMode: string(paymentMode),
+	})
 	if err != nil {
 		return nil, errorFromGrpc(err)
 	}
-	return &PutResult{
-		Cost:    resp.GetCost().GetAttoTokens(),
-		Address: resp.GetAddress(),
+	return &DataPutResult{
+		DataMap: resp.GetDataMap(),
 	}, nil
 }
 
-// DataGetPublic retrieves public data by address.
-func (c *GrpcClient) DataGetPublic(ctx context.Context, address string) ([]byte, error) {
+// DataGet retrieves private data from a caller-held DataMap (hex).
+func (c *GrpcClient) DataGet(ctx context.Context, dataMap string) ([]byte, error) {
 	ctx, cancel := c.ctx(ctx)
 	defer cancel()
 
-	resp, err := c.data.GetPublic(ctx, &pb.GetPublicDataRequest{Address: address})
+	resp, err := c.data.Get(ctx, &pb.GetDataRequest{DataMap: dataMap})
 	if err != nil {
 		return nil, errorFromGrpc(err)
 	}
 	return resp.GetData(), nil
 }
 
-// DataPutPrivate stores private encrypted data on the network.
-func (c *GrpcClient) DataPutPrivate(ctx context.Context, data []byte) (*PutResult, error) {
+// DataPutPublic stores public immutable data on the network and returns the
+// on-network DataMap address.
+func (c *GrpcClient) DataPutPublic(ctx context.Context, data []byte, paymentMode PaymentMode) (*DataPutPublicResult, error) {
 	ctx, cancel := c.ctx(ctx)
 	defer cancel()
 
-	resp, err := c.data.PutPrivate(ctx, &pb.PutPrivateDataRequest{Data: data})
+	resp, err := c.data.PutPublic(ctx, &pb.PutPublicDataRequest{
+		Data:        data,
+		PaymentMode: string(paymentMode),
+	})
 	if err != nil {
 		return nil, errorFromGrpc(err)
 	}
-	return &PutResult{
-		Cost:    resp.GetCost().GetAttoTokens(),
-		Address: resp.GetDataMap(),
+	return &DataPutPublicResult{
+		Address: resp.GetAddress(),
 	}, nil
 }
 
-// DataGetPrivate retrieves private data using a data map.
-func (c *GrpcClient) DataGetPrivate(ctx context.Context, dataMap string) ([]byte, error) {
+// DataGetPublic retrieves public data by address.
+func (c *GrpcClient) DataGetPublic(ctx context.Context, address string) ([]byte, error) {
 	ctx, cancel := c.ctx(ctx)
 	defer cancel()
 
-	resp, err := c.data.GetPrivate(ctx, &pb.GetPrivateDataRequest{DataMap: dataMap})
+	resp, err := c.data.GetPublic(ctx, &pb.GetPublicDataRequest{Address: address})
 	if err != nil {
 		return nil, errorFromGrpc(err)
 	}
@@ -226,11 +232,14 @@ func (c *GrpcClient) DataGetPrivate(ctx context.Context, dataMap string) ([]byte
 //
 // The server samples a small number of chunk addresses and extrapolates —
 // much faster than quoting every chunk on slow networks. Gas is advisory.
-func (c *GrpcClient) DataCost(ctx context.Context, data []byte) (*UploadCostEstimate, error) {
+func (c *GrpcClient) DataCost(ctx context.Context, data []byte, paymentMode PaymentMode) (*UploadCostEstimate, error) {
 	ctx, cancel := c.ctx(ctx)
 	defer cancel()
 
-	resp, err := c.data.GetCost(ctx, &pb.DataCostRequest{Data: data})
+	resp, err := c.data.Cost(ctx, &pb.DataCostRequest{
+		Data:        data,
+		PaymentMode: string(paymentMode),
+	})
 	if err != nil {
 		return nil, errorFromGrpc(err)
 	}
@@ -274,16 +283,55 @@ func (c *GrpcClient) ChunkGet(ctx context.Context, address string) ([]byte, erro
 
 // --- Files (5 methods) ---
 
-// FileUploadPublic uploads a local file to the network.
-func (c *GrpcClient) FileUploadPublic(ctx context.Context, path string) (*FileUploadResult, error) {
+// FilePut uploads a local file as a private upload and returns the caller-held
+// DataMap (hex).
+func (c *GrpcClient) FilePut(ctx context.Context, path string, paymentMode PaymentMode) (*FilePutResult, error) {
+	ctx, cancel := c.ctx(ctx)
+	defer cancel()
+
+	resp, err := c.file.Put(ctx, &pb.PutFileRequest{
+		Path:        path,
+		PaymentMode: string(paymentMode),
+	})
+	if err != nil {
+		return nil, errorFromGrpc(err)
+	}
+	return &FilePutResult{
+		DataMap:         resp.GetDataMap(),
+		StorageCostAtto: resp.GetStorageCostAtto(),
+		GasCostWei:      resp.GetGasCostWei(),
+		ChunksStored:    resp.GetChunksStored(),
+		PaymentModeUsed: resp.GetPaymentModeUsed(),
+	}, nil
+}
+
+// FileGet downloads a private file from a caller-held DataMap into destPath.
+func (c *GrpcClient) FileGet(ctx context.Context, dataMap, destPath string) error {
 	ctx, cancel := c.ctx(ctx)
 	defer cancel()
 
-	resp, err := c.file.UploadPublic(ctx, &pb.UploadFileRequest{Path: path})
+	_, err := c.file.Get(ctx, &pb.GetFileRequest{
+		DataMap:  dataMap,
+		DestPath: destPath,
+	})
+	return errorFromGrpc(err)
+}
+
+// FilePutPublic uploads a local file as a public upload. The DataMap is
+// stored on-network as an extra chunk; the returned address is the shareable
+// retrieval handle.
+func (c *GrpcClient) FilePutPublic(ctx context.Context, path string, paymentMode PaymentMode) (*FilePutPublicResult, error) {
+	ctx, cancel := c.ctx(ctx)
+	defer cancel()
+
+	resp, err := c.file.PutPublic(ctx, &pb.PutFileRequest{
+		Path:        path,
+		PaymentMode: string(paymentMode),
+	})
 	if err != nil {
 		return nil, errorFromGrpc(err)
 	}
-	return &FileUploadResult{
+	return &FilePutPublicResult{
 		Address:         resp.GetAddress(),
 		StorageCostAtto: resp.GetStorageCostAtto(),
 		GasCostWei:      resp.GetGasCostWei(),
@@ -292,12 +340,12 @@ func (c *GrpcClient) FileUploadPublic(ctx context.Context, path string) (*FileUp
 	}, nil
 }
 
-// FileDownloadPublic downloads a file from the network to a local path.
-func (c *GrpcClient) FileDownloadPublic(ctx context.Context, address, destPath string) error {
+// FileGetPublic downloads a public file from an on-network DataMap address into destPath.
+func (c *GrpcClient) FileGetPublic(ctx context.Context, address, destPath string) error {
 	ctx, cancel := c.ctx(ctx)
 	defer cancel()
 
-	_, err := c.file.DownloadPublic(ctx, &pb.DownloadPublicRequest{
+	_, err := c.file.GetPublic(ctx, &pb.GetFilePublicRequest{
 		Address:  address,
 		DestPath: destPath,
 	})
@@ -308,13 +356,14 @@ func (c *GrpcClient) FileDownloadPublic(ctx context.Context, address, destPath s
 //
 // The server samples a small number of chunk addresses and extrapolates —
 // much faster than quoting every chunk on slow networks. Gas is advisory.
-func (c *GrpcClient) FileCost(ctx context.Context, path string, isPublic bool) (*UploadCostEstimate, error) {
+func (c *GrpcClient) FileCost(ctx context.Context, path string, isPublic bool, paymentMode PaymentMode) (*UploadCostEstimate, error) {
 	ctx, cancel := c.ctx(ctx)
 	defer cancel()
 
-	resp, err := c.file.GetFileCost(ctx, &pb.FileCostRequest{
-		Path:     path,
-		IsPublic: isPublic,
+	resp, err := c.file.Cost(ctx, &pb.FileCostRequest{
+		Path:        path,
+		IsPublic:    isPublic,
+		PaymentMode: string(paymentMode),
 	})
 	if err != nil {
 		return nil, errorFromGrpc(err)
diff --git a/antd-go/grpc_client_test.go b/antd-go/grpc_client_test.go
index 09a5483..5cd2c0f 100644
--- a/antd-go/grpc_client_test.go
+++ b/antd-go/grpc_client_test.go
@@ -42,9 +42,15 @@ type mockDataService struct {
 	pb.UnimplementedDataServiceServer
 }
 
-func (m *mockDataService) PutPublic(_ context.Context, _ *pb.PutPublicDataRequest) (*pb.PutPublicDataResponse, error) {
+// lastPaymentMode captures the payment_mode value seen by the most recent
+// data/file request, so tests can assert that the enum wires through to the
+// proto field at the boundary. Reset per-call by callers.
+var lastPaymentMode string
+
+func (m *mockDataService) PutPublic(_ context.Context, req *pb.PutPublicDataRequest) (*pb.PutPublicDataResponse, error) {
+	lastPaymentMode = req.GetPaymentMode()
 	return &pb.PutPublicDataResponse{
-		Cost:    &pb.Cost{AttoTokens: "100"},
+		Cost:    &pb.Cost{AttoTokens: ""},
 		Address: "abc123",
 	}, nil
 }
@@ -53,18 +59,20 @@ func (m *mockDataService) GetPublic(_ context.Context, _ *pb.GetPublicDataReques
 	return &pb.GetPublicDataResponse{Data: []byte("hello")}, nil
 }
 
-func (m *mockDataService) PutPrivate(_ context.Context, _ *pb.PutPrivateDataRequest) (*pb.PutPrivateDataResponse, error) {
-	return &pb.PutPrivateDataResponse{
-		Cost:    &pb.Cost{AttoTokens: "200"},
+func (m *mockDataService) Put(_ context.Context, req *pb.PutDataRequest) (*pb.PutDataResponse, error) {
+	lastPaymentMode = req.GetPaymentMode()
+	return &pb.PutDataResponse{
+		Cost:    &pb.Cost{AttoTokens: ""},
 		DataMap: "dm123",
 	}, nil
 }
 
-func (m *mockDataService) GetPrivate(_ context.Context, _ *pb.GetPrivateDataRequest) (*pb.GetPrivateDataResponse, error) {
-	return &pb.GetPrivateDataResponse{Data: []byte("secret")}, nil
+func (m *mockDataService) Get(_ context.Context, _ *pb.GetDataRequest) (*pb.GetDataResponse, error) {
+	return &pb.GetDataResponse{Data: []byte("secret")}, nil
 }
 
-func (m *mockDataService) GetCost(_ context.Context, _ *pb.DataCostRequest) (*pb.Cost, error) {
+func (m *mockDataService) Cost(_ context.Context, req *pb.DataCostRequest) (*pb.Cost, error) {
+	lastPaymentMode = req.GetPaymentMode()
 	return &pb.Cost{
 		AttoTokens:          "50",
 		FileSize:            4,
@@ -95,8 +103,24 @@ type mockFileService struct {
 	pb.UnimplementedFileServiceServer
 }
 
-func (m *mockFileService) UploadPublic(_ context.Context, _ *pb.UploadFileRequest) (*pb.UploadPublicResponse, error) {
-	return &pb.UploadPublicResponse{
+func (m *mockFileService) Put(_ context.Context, req *pb.PutFileRequest) (*pb.PutFileResponse, error) {
+	lastPaymentMode = req.GetPaymentMode()
+	return &pb.PutFileResponse{
+		DataMap:         "filedm1",
+		StorageCostAtto: "500",
+		GasCostWei:      "21",
+		ChunksStored:    2,
+		PaymentModeUsed: "single",
+	}, nil
+}
+
+func (m *mockFileService) Get(_ context.Context, _ *pb.GetFileRequest) (*pb.GetFileResponse, error) {
+	return &pb.GetFileResponse{}, nil
+}
+
+func (m *mockFileService) PutPublic(_ context.Context, req *pb.PutFileRequest) (*pb.PutFilePublicResponse, error) {
+	lastPaymentMode = req.GetPaymentMode()
+	return &pb.PutFilePublicResponse{
 		Address:         "file1",
 		StorageCostAtto: "1000",
 		GasCostWei:      "42",
@@ -105,11 +129,12 @@ func (m *mockFileService) UploadPublic(_ context.Context, _ *pb.UploadFileReques
 	}, nil
 }
 
-func (m *mockFileService) DownloadPublic(_ context.Context, _ *pb.DownloadPublicRequest) (*pb.DownloadResponse, error) {
-	return &pb.DownloadResponse{}, nil
+func (m *mockFileService) GetPublic(_ context.Context, _ *pb.GetFilePublicRequest) (*pb.GetFileResponse, error) {
+	return &pb.GetFileResponse{}, nil
 }
 
-func (m *mockFileService) GetFileCost(_ context.Context, _ *pb.FileCostRequest) (*pb.Cost, error) {
+func (m *mockFileService) Cost(_ context.Context, req *pb.FileCostRequest) (*pb.Cost, error) {
+	lastPaymentMode = req.GetPaymentMode()
 	return &pb.Cost{
 		AttoTokens:          "1000",
 		FileSize:            4096,
@@ -222,13 +247,17 @@ func TestGrpcHealth(t *testing.T) {
 
 func TestGrpcDataPutPublic(t *testing.T) {
 	c := startMockServer(t)
-	put, err := c.DataPutPublic(context.Background(), []byte("hello"))
+	lastPaymentMode = ""
+	put, err := c.DataPutPublic(context.Background(), []byte("hello"), PaymentModeMerkle)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if put.Address != "abc123" || put.Cost != "100" {
+	if put.Address != "abc123" {
 		t.Fatalf("unexpected put: %+v", put)
 	}
+	if lastPaymentMode != "merkle" {
+		t.Fatalf("payment_mode did not wire through: got %q, want %q", lastPaymentMode, "merkle")
+	}
 }
 
 func TestGrpcDataGetPublic(t *testing.T) {
@@ -242,20 +271,24 @@ func TestGrpcDataGetPublic(t *testing.T) {
 	}
 }
 
-func TestGrpcDataPutPrivate(t *testing.T) {
+func TestGrpcDataPut(t *testing.T) {
 	c := startMockServer(t)
-	put, err := c.DataPutPrivate(context.Background(), []byte("secret"))
+	lastPaymentMode = ""
+	put, err := c.DataPut(context.Background(), []byte("secret"), PaymentModeSingle)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if put.Address != "dm123" || put.Cost != "200" {
+	if put.DataMap != "dm123" {
 		t.Fatalf("unexpected put: %+v", put)
 	}
+	if lastPaymentMode != "single" {
+		t.Fatalf("payment_mode did not wire through: got %q, want %q", lastPaymentMode, "single")
+	}
 }
 
-func TestGrpcDataGetPrivate(t *testing.T) {
+func TestGrpcDataGet(t *testing.T) {
 	c := startMockServer(t)
-	data, err := c.DataGetPrivate(context.Background(), "dm123")
+	data, err := c.DataGet(context.Background(), "dm123")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -266,7 +299,8 @@ func TestGrpcDataGetPrivate(t *testing.T) {
 
 func TestGrpcDataCost(t *testing.T) {
 	c := startMockServer(t)
-	est, err := c.DataCost(context.Background(), []byte("test"))
+	lastPaymentMode = ""
+	est, err := c.DataCost(context.Background(), []byte("test"), PaymentModeAuto)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -274,6 +308,9 @@ func TestGrpcDataCost(t *testing.T) {
 		est.EstimatedGasCostWei != "150000000000000" || est.PaymentMode != "single" {
 		t.Fatalf("unexpected estimate: %+v", est)
 	}
+	if lastPaymentMode != "auto" {
+		t.Fatalf("payment_mode did not wire through: got %q, want %q", lastPaymentMode, "auto")
+	}
 }
 
 func TestGrpcChunkPut(t *testing.T) {
@@ -298,28 +335,55 @@ func TestGrpcChunkGet(t *testing.T) {
 	}
 }
 
-func TestGrpcFileUploadPublic(t *testing.T) {
+func TestGrpcFilePutPublic(t *testing.T) {
 	c := startMockServer(t)
-	put, err := c.FileUploadPublic(context.Background(), "/tmp/test.txt")
+	lastPaymentMode = ""
+	put, err := c.FilePutPublic(context.Background(), "/tmp/test.txt", PaymentModeAuto)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if put.Address != "file1" || put.StorageCostAtto != "1000" || put.GasCostWei != "42" || put.ChunksStored != 3 || put.PaymentModeUsed != "auto" {
 		t.Fatalf("unexpected file upload: %+v", put)
 	}
+	if lastPaymentMode != "auto" {
+		t.Fatalf("payment_mode did not wire through: got %q, want %q", lastPaymentMode, "auto")
+	}
+}
+
+func TestGrpcFileGetPublic(t *testing.T) {
+	c := startMockServer(t)
+	err := c.FileGetPublic(context.Background(), "file1", "/tmp/out.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
 }
 
-func TestGrpcFileDownloadPublic(t *testing.T) {
+func TestGrpcFilePut(t *testing.T) {
 	c := startMockServer(t)
-	err := c.FileDownloadPublic(context.Background(), "file1", "/tmp/out.txt")
+	lastPaymentMode = ""
+	put, err := c.FilePut(context.Background(), "/tmp/test.txt", PaymentModeMerkle)
 	if err != nil {
 		t.Fatal(err)
 	}
+	if put.DataMap != "filedm1" || put.StorageCostAtto != "500" || put.GasCostWei != "21" || put.ChunksStored != 2 || put.PaymentModeUsed != "single" {
+		t.Fatalf("unexpected file put: %+v", put)
+	}
+	if lastPaymentMode != "merkle" {
+		t.Fatalf("payment_mode did not wire through: got %q, want %q", lastPaymentMode, "merkle")
+	}
+}
+
+func TestGrpcFileGet(t *testing.T) {
+	c := startMockServer(t)
+	if err := c.FileGet(context.Background(), "filedm1", "/tmp/out.txt"); err != nil {
+		t.Fatal(err)
+	}
 }
 
 func TestGrpcFileCost(t *testing.T) {
 	c := startMockServer(t)
-	est, err := c.FileCost(context.Background(), "/tmp/test.txt", true)
+	lastPaymentMode = ""
+	est, err := c.FileCost(context.Background(), "/tmp/test.txt", true, PaymentModeSingle)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -327,6 +391,9 @@ func TestGrpcFileCost(t *testing.T) {
 		est.EstimatedGasCostWei != "150000000000000" || est.PaymentMode != "auto" {
 		t.Fatalf("unexpected estimate: %+v", est)
 	}
+	if lastPaymentMode != "single" {
+		t.Fatalf("payment_mode did not wire through: got %q, want %q", lastPaymentMode, "single")
+	}
 }
 
 // --- gRPC error mapping tests ---
diff --git a/antd-go/integration_test.go b/antd-go/integration_test.go
index 34839fd..956eea7 100644
--- a/antd-go/integration_test.go
+++ b/antd-go/integration_test.go
@@ -46,7 +46,7 @@ func TestIntegration_Health(t *testing.T) {
 
 func TestIntegration_DataPutPublic_NoWallet(t *testing.T) {
 	c := integrationClient(t)
-	_, err := c.DataPutPublic(context.Background(), []byte("hello"))
+	_, err := c.DataPutPublic(context.Background(), []byte("hello"), PaymentModeAuto)
 	if err == nil {
 		t.Fatal("expected error from DataPutPublic without wallet")
 	}
@@ -125,7 +125,7 @@ func TestIntegration_FinalizeUpload_InvalidID(t *testing.T) {
 
 func TestIntegration_DataCost_NoPeers(t *testing.T) {
 	c := integrationClient(t)
-	_, err := c.DataCost(context.Background(), []byte("test data"))
+	_, err := c.DataCost(context.Background(), []byte("test data"), PaymentModeAuto)
 	if err == nil {
 		t.Fatal("expected error from DataCost without peers")
 	}
diff --git a/antd-go/models.go b/antd-go/models.go
index e4d51f6..baee89f 100644
--- a/antd-go/models.go
+++ b/antd-go/models.go
@@ -12,16 +12,47 @@ type HealthStatus struct {
 	PaymentVaultAddress string `json:"payment_vault_address"`
 }
 
-// PutResult is the result of a put/create operation.
+// PutResult is the result of a single-chunk put (ChunkPut).
 type PutResult struct {
 	Cost    string `json:"cost"`    // atto tokens as string
 	Address string `json:"address"` // hex
 }
 
-// FileUploadResult is the result of a public file upload.
-// Returned by FileUploadPublic on both REST and gRPC clients.
-type FileUploadResult struct {
-	Address         string `json:"address"`           // hex network address
+// DataPutResult is the result of a private data put. The DataMap is returned
+// to the caller; it is NOT stored on-network. ChunksStored and PaymentModeUsed
+// are populated by the REST transport; the gRPC transport currently leaves
+// them empty (proto PutDataResponse only carries data_map).
+type DataPutResult struct {
+	DataMap         string `json:"data_map"`          // hex
+	ChunksStored    uint64 `json:"chunks_stored"`     // number of chunks stored on the network
+	PaymentModeUsed string `json:"payment_mode_used"` // "auto", "merkle", or "single"
+}
+
+// DataPutPublicResult is the result of a public data put. The DataMap is
+// stored on-network as an additional chunk; the returned address is the
+// shareable retrieval handle. ChunksStored and PaymentModeUsed are populated
+// by REST; the gRPC transport currently leaves them empty.
+type DataPutPublicResult struct {
+	Address         string `json:"address"`           // hex
+	ChunksStored    uint64 `json:"chunks_stored"`     // number of chunks stored on the network
+	PaymentModeUsed string `json:"payment_mode_used"` // "auto", "merkle", or "single"
+}
+
+// FilePutResult is the result of a private file upload. The DataMap is
+// returned to the caller; it is NOT stored on-network.
+type FilePutResult struct {
+	DataMap         string `json:"data_map"`          // hex-encoded rmp_serde-serialized DataMap
+	StorageCostAtto string `json:"storage_cost_atto"` // total storage cost in atto, "0" if all chunks already existed
+	GasCostWei      string `json:"gas_cost_wei"`      // total gas cost in wei as decimal string
+	ChunksStored    uint64 `json:"chunks_stored"`     // number of chunks stored on the network
+	PaymentModeUsed string `json:"payment_mode_used"` // "auto", "merkle", or "single"
+}
+
+// FilePutPublicResult is the result of a public file upload. The DataMap is
+// stored on-network as an additional chunk; the returned address is the
+// shareable retrieval handle.
+type FilePutPublicResult struct {
+	Address         string `json:"address"`           // hex network address of the stored DataMap
 	StorageCostAtto string `json:"storage_cost_atto"` // total storage cost in atto, "0" if all chunks already existed
 	GasCostWei      string `json:"gas_cost_wei"`      // total gas cost in wei as decimal string
 	ChunksStored    uint64 `json:"chunks_stored"`     // number of chunks stored on the network
diff --git a/antd-go/proto/antd/v1/common.pb.go b/antd-go/proto/antd/v1/common.pb.go
index 4939f69..fb0bd61 100644
--- a/antd-go/proto/antd/v1/common.pb.go
+++ b/antd-go/proto/antd/v1/common.pb.go
@@ -229,58 +229,6 @@ func (x *SecretKeyProto) GetHex() string {
 	return ""
 }
 
-type GraphDescendant struct {
-	state         protoimpl.MessageState `protogen:"open.v1"`
-	PublicKey     string                 `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"` // hex
-	Content       string                 `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`                      // hex, 32 bytes
-	unknownFields protoimpl.UnknownFields
-	sizeCache     protoimpl.SizeCache
-}
-
-func (x *GraphDescendant) Reset() {
-	*x = GraphDescendant{}
-	mi := &file_antd_v1_common_proto_msgTypes[4]
-	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-	ms.StoreMessageInfo(mi)
-}
-
-func (x *GraphDescendant) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*GraphDescendant) ProtoMessage() {}
-
-func (x *GraphDescendant) ProtoReflect() protoreflect.Message {
-	mi := &file_antd_v1_common_proto_msgTypes[4]
-	if x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use GraphDescendant.ProtoReflect.Descriptor instead.
-func (*GraphDescendant) Descriptor() ([]byte, []int) {
-	return file_antd_v1_common_proto_rawDescGZIP(), []int{4}
-}
-
-func (x *GraphDescendant) GetPublicKey() string {
-	if x != nil {
-		return x.PublicKey
-	}
-	return ""
-}
-
-func (x *GraphDescendant) GetContent() string {
-	if x != nil {
-		return x.Content
-	}
-	return ""
-}
-
 var File_antd_v1_common_proto protoreflect.FileDescriptor
 
 const file_antd_v1_common_proto_rawDesc = "" +
@@ -299,11 +247,7 @@ const file_antd_v1_common_proto_rawDesc = "" +
 	"\x0ePublicKeyProto\x12\x10\n" +
 	"\x03hex\x18\x01 \x01(\tR\x03hex\"\"\n" +
 	"\x0eSecretKeyProto\x12\x10\n" +
-	"\x03hex\x18\x01 \x01(\tR\x03hex\"J\n" +
-	"\x0fGraphDescendant\x12\x1d\n" +
-	"\n" +
-	"public_key\x18\x01 \x01(\tR\tpublicKey\x12\x18\n" +
-	"\acontent\x18\x02 \x01(\tR\acontentBDZ8github.com/WithAutonomi/ant-sdk/antd-go/proto/antd/v1;v1\xaa\x02\aAntd.V1b\x06proto3"
+	"\x03hex\x18\x01 \x01(\tR\x03hexBDZ8github.com/WithAutonomi/ant-sdk/antd-go/proto/antd/v1;v1\xaa\x02\aAntd.V1b\x06proto3"
 
 var (
 	file_antd_v1_common_proto_rawDescOnce sync.Once
@@ -317,13 +261,12 @@ func file_antd_v1_common_proto_rawDescGZIP() []byte {
 	return file_antd_v1_common_proto_rawDescData
 }
 
-var file_antd_v1_common_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
+var file_antd_v1_common_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
 var file_antd_v1_common_proto_goTypes = []any{
-	(*Cost)(nil),            // 0: antd.v1.Cost
-	(*Address)(nil),         // 1: antd.v1.Address
-	(*PublicKeyProto)(nil),  // 2: antd.v1.PublicKeyProto
-	(*SecretKeyProto)(nil),  // 3: antd.v1.SecretKeyProto
-	(*GraphDescendant)(nil), // 4: antd.v1.GraphDescendant
+	(*Cost)(nil),           // 0: antd.v1.Cost
+	(*Address)(nil),        // 1: antd.v1.Address
+	(*PublicKeyProto)(nil), // 2: antd.v1.PublicKeyProto
+	(*SecretKeyProto)(nil), // 3: antd.v1.SecretKeyProto
 }
 var file_antd_v1_common_proto_depIdxs = []int32{
 	0, // [0:0] is the sub-list for method output_type
@@ -344,7 +287,7 @@ func file_antd_v1_common_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: unsafe.Slice(unsafe.StringData(file_antd_v1_common_proto_rawDesc), len(file_antd_v1_common_proto_rawDesc)),
 			NumEnums:      0,
-			NumMessages:   5,
+			NumMessages:   4,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
diff --git a/antd-go/proto/antd/v1/data.pb.go b/antd-go/proto/antd/v1/data.pb.go
index c29b1ab..238e895 100644
--- a/antd-go/proto/antd/v1/data.pb.go
+++ b/antd-go/proto/antd/v1/data.pb.go
@@ -110,8 +110,12 @@ func (x *GetPublicDataResponse) GetData() []byte {
 }
 
 type PutPublicDataRequest struct {
-	state         protoimpl.MessageState `protogen:"open.v1"`
-	Data          []byte                 `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+	state protoimpl.MessageState `protogen:"open.v1"`
+	Data  []byte                 `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+	// Optional payment mode: "auto" (default), "merkle", or "single". Empty
+	// string is treated as "auto" so old clients omitting the field stay
+	// wire-compatible.
+	PaymentMode   string `protobuf:"bytes,2,opt,name=payment_mode,json=paymentMode,proto3" json:"payment_mode,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
@@ -153,6 +157,13 @@ func (x *PutPublicDataRequest) GetData() []byte {
 	return nil
 }
 
+func (x *PutPublicDataRequest) GetPaymentMode() string {
+	if x != nil {
+		return x.PaymentMode
+	}
+	return ""
+}
+
 type PutPublicDataResponse struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	Cost          *Cost                  `protobuf:"bytes,1,opt,name=cost,proto3" json:"cost,omitempty"`
@@ -293,27 +304,27 @@ func (x *DataChunk) GetData() []byte {
 	return nil
 }
 
-type GetPrivateDataRequest struct {
+type GetDataRequest struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	DataMap       string                 `protobuf:"bytes,1,opt,name=data_map,json=dataMap,proto3" json:"data_map,omitempty"` // hex
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *GetPrivateDataRequest) Reset() {
-	*x = GetPrivateDataRequest{}
+func (x *GetDataRequest) Reset() {
+	*x = GetDataRequest{}
 	mi := &file_antd_v1_data_proto_msgTypes[6]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *GetPrivateDataRequest) String() string {
+func (x *GetDataRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*GetPrivateDataRequest) ProtoMessage() {}
+func (*GetDataRequest) ProtoMessage() {}
 
-func (x *GetPrivateDataRequest) ProtoReflect() protoreflect.Message {
+func (x *GetDataRequest) ProtoReflect() protoreflect.Message {
 	mi := &file_antd_v1_data_proto_msgTypes[6]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -325,39 +336,39 @@ func (x *GetPrivateDataRequest) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use GetPrivateDataRequest.ProtoReflect.Descriptor instead.
-func (*GetPrivateDataRequest) Descriptor() ([]byte, []int) {
+// Deprecated: Use GetDataRequest.ProtoReflect.Descriptor instead.
+func (*GetDataRequest) Descriptor() ([]byte, []int) {
 	return file_antd_v1_data_proto_rawDescGZIP(), []int{6}
 }
 
-func (x *GetPrivateDataRequest) GetDataMap() string {
+func (x *GetDataRequest) GetDataMap() string {
 	if x != nil {
 		return x.DataMap
 	}
 	return ""
 }
 
-type GetPrivateDataResponse struct {
+type GetDataResponse struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	Data          []byte                 `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *GetPrivateDataResponse) Reset() {
-	*x = GetPrivateDataResponse{}
+func (x *GetDataResponse) Reset() {
+	*x = GetDataResponse{}
 	mi := &file_antd_v1_data_proto_msgTypes[7]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *GetPrivateDataResponse) String() string {
+func (x *GetDataResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*GetPrivateDataResponse) ProtoMessage() {}
+func (*GetDataResponse) ProtoMessage() {}
 
-func (x *GetPrivateDataResponse) ProtoReflect() protoreflect.Message {
+func (x *GetDataResponse) ProtoReflect() protoreflect.Message {
 	mi := &file_antd_v1_data_proto_msgTypes[7]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -369,39 +380,43 @@ func (x *GetPrivateDataResponse) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use GetPrivateDataResponse.ProtoReflect.Descriptor instead.
-func (*GetPrivateDataResponse) Descriptor() ([]byte, []int) {
+// Deprecated: Use GetDataResponse.ProtoReflect.Descriptor instead.
+func (*GetDataResponse) Descriptor() ([]byte, []int) {
 	return file_antd_v1_data_proto_rawDescGZIP(), []int{7}
 }
 
-func (x *GetPrivateDataResponse) GetData() []byte {
+func (x *GetDataResponse) GetData() []byte {
 	if x != nil {
 		return x.Data
 	}
 	return nil
 }
 
-type PutPrivateDataRequest struct {
-	state         protoimpl.MessageState `protogen:"open.v1"`
-	Data          []byte                 `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+type PutDataRequest struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	Data  []byte                 `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+	// Optional payment mode: "auto" (default), "merkle", or "single". Empty
+	// string is treated as "auto" so old clients omitting the field stay
+	// wire-compatible.
+	PaymentMode   string `protobuf:"bytes,2,opt,name=payment_mode,json=paymentMode,proto3" json:"payment_mode,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *PutPrivateDataRequest) Reset() {
-	*x = PutPrivateDataRequest{}
+func (x *PutDataRequest) Reset() {
+	*x = PutDataRequest{}
 	mi := &file_antd_v1_data_proto_msgTypes[8]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *PutPrivateDataRequest) String() string {
+func (x *PutDataRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*PutPrivateDataRequest) ProtoMessage() {}
+func (*PutDataRequest) ProtoMessage() {}
 
-func (x *PutPrivateDataRequest) ProtoReflect() protoreflect.Message {
+func (x *PutDataRequest) ProtoReflect() protoreflect.Message {
 	mi := &file_antd_v1_data_proto_msgTypes[8]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -413,19 +428,26 @@ func (x *PutPrivateDataRequest) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use PutPrivateDataRequest.ProtoReflect.Descriptor instead.
-func (*PutPrivateDataRequest) Descriptor() ([]byte, []int) {
+// Deprecated: Use PutDataRequest.ProtoReflect.Descriptor instead.
+func (*PutDataRequest) Descriptor() ([]byte, []int) {
 	return file_antd_v1_data_proto_rawDescGZIP(), []int{8}
 }
 
-func (x *PutPrivateDataRequest) GetData() []byte {
+func (x *PutDataRequest) GetData() []byte {
 	if x != nil {
 		return x.Data
 	}
 	return nil
 }
 
-type PutPrivateDataResponse struct {
+func (x *PutDataRequest) GetPaymentMode() string {
+	if x != nil {
+		return x.PaymentMode
+	}
+	return ""
+}
+
+type PutDataResponse struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	Cost          *Cost                  `protobuf:"bytes,1,opt,name=cost,proto3" json:"cost,omitempty"`
 	DataMap       string                 `protobuf:"bytes,2,opt,name=data_map,json=dataMap,proto3" json:"data_map,omitempty"` // hex
@@ -433,20 +455,20 @@ type PutPrivateDataResponse struct {
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *PutPrivateDataResponse) Reset() {
-	*x = PutPrivateDataResponse{}
+func (x *PutDataResponse) Reset() {
+	*x = PutDataResponse{}
 	mi := &file_antd_v1_data_proto_msgTypes[9]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *PutPrivateDataResponse) String() string {
+func (x *PutDataResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*PutPrivateDataResponse) ProtoMessage() {}
+func (*PutDataResponse) ProtoMessage() {}
 
-func (x *PutPrivateDataResponse) ProtoReflect() protoreflect.Message {
+func (x *PutDataResponse) ProtoReflect() protoreflect.Message {
 	mi := &file_antd_v1_data_proto_msgTypes[9]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -458,19 +480,19 @@ func (x *PutPrivateDataResponse) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use PutPrivateDataResponse.ProtoReflect.Descriptor instead.
-func (*PutPrivateDataResponse) Descriptor() ([]byte, []int) {
+// Deprecated: Use PutDataResponse.ProtoReflect.Descriptor instead.
+func (*PutDataResponse) Descriptor() ([]byte, []int) {
 	return file_antd_v1_data_proto_rawDescGZIP(), []int{9}
 }
 
-func (x *PutPrivateDataResponse) GetCost() *Cost {
+func (x *PutDataResponse) GetCost() *Cost {
 	if x != nil {
 		return x.Cost
 	}
 	return nil
 }
 
-func (x *PutPrivateDataResponse) GetDataMap() string {
+func (x *PutDataResponse) GetDataMap() string {
 	if x != nil {
 		return x.DataMap
 	}
@@ -478,8 +500,11 @@ func (x *PutPrivateDataResponse) GetDataMap() string {
 }
 
 type DataCostRequest struct {
-	state         protoimpl.MessageState `protogen:"open.v1"`
-	Data          []byte                 `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+	state protoimpl.MessageState `protogen:"open.v1"`
+	Data  []byte                 `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+	// Optional payment mode the estimate should reflect: "auto" (default),
+	// "merkle", or "single". Empty string is treated as "auto".
+	PaymentMode   string `protobuf:"bytes,2,opt,name=payment_mode,json=paymentMode,proto3" json:"payment_mode,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
@@ -521,6 +546,13 @@ func (x *DataCostRequest) GetData() []byte {
 	return nil
 }
 
+func (x *DataCostRequest) GetPaymentMode() string {
+	if x != nil {
+		return x.PaymentMode
+	}
+	return ""
+}
+
 var File_antd_v1_data_proto protoreflect.FileDescriptor
 
 const file_antd_v1_data_proto_rawDesc = "" +
@@ -529,36 +561,37 @@ const file_antd_v1_data_proto_rawDesc = "" +
 	"\x14GetPublicDataRequest\x12\x18\n" +
 	"\aaddress\x18\x01 \x01(\tR\aaddress\"+\n" +
 	"\x15GetPublicDataResponse\x12\x12\n" +
-	"\x04data\x18\x01 \x01(\fR\x04data\"*\n" +
+	"\x04data\x18\x01 \x01(\fR\x04data\"M\n" +
 	"\x14PutPublicDataRequest\x12\x12\n" +
-	"\x04data\x18\x01 \x01(\fR\x04data\"T\n" +
+	"\x04data\x18\x01 \x01(\fR\x04data\x12!\n" +
+	"\fpayment_mode\x18\x02 \x01(\tR\vpaymentMode\"T\n" +
 	"\x15PutPublicDataResponse\x12!\n" +
 	"\x04cost\x18\x01 \x01(\v2\r.antd.v1.CostR\x04cost\x12\x18\n" +
 	"\aaddress\x18\x02 \x01(\tR\aaddress\"3\n" +
 	"\x17StreamPublicDataRequest\x12\x18\n" +
 	"\aaddress\x18\x01 \x01(\tR\aaddress\"\x1f\n" +
 	"\tDataChunk\x12\x12\n" +
-	"\x04data\x18\x01 \x01(\fR\x04data\"2\n" +
-	"\x15GetPrivateDataRequest\x12\x19\n" +
-	"\bdata_map\x18\x01 \x01(\tR\adataMap\",\n" +
-	"\x16GetPrivateDataResponse\x12\x12\n" +
 	"\x04data\x18\x01 \x01(\fR\x04data\"+\n" +
-	"\x15PutPrivateDataRequest\x12\x12\n" +
-	"\x04data\x18\x01 \x01(\fR\x04data\"V\n" +
-	"\x16PutPrivateDataResponse\x12!\n" +
+	"\x0eGetDataRequest\x12\x19\n" +
+	"\bdata_map\x18\x01 \x01(\tR\adataMap\"%\n" +
+	"\x0fGetDataResponse\x12\x12\n" +
+	"\x04data\x18\x01 \x01(\fR\x04data\"G\n" +
+	"\x0ePutDataRequest\x12\x12\n" +
+	"\x04data\x18\x01 \x01(\fR\x04data\x12!\n" +
+	"\fpayment_mode\x18\x02 \x01(\tR\vpaymentMode\"O\n" +
+	"\x0fPutDataResponse\x12!\n" +
 	"\x04cost\x18\x01 \x01(\v2\r.antd.v1.CostR\x04cost\x12\x19\n" +
-	"\bdata_map\x18\x02 \x01(\tR\adataMap\"%\n" +
+	"\bdata_map\x18\x02 \x01(\tR\adataMap\"H\n" +
 	"\x0fDataCostRequest\x12\x12\n" +
-	"\x04data\x18\x01 \x01(\fR\x04data2\xbf\x03\n" +
-	"\vDataService\x12J\n" +
-	"\tGetPublic\x12\x1d.antd.v1.GetPublicDataRequest\x1a\x1e.antd.v1.GetPublicDataResponse\x12J\n" +
-	"\tPutPublic\x12\x1d.antd.v1.PutPublicDataRequest\x1a\x1e.antd.v1.PutPublicDataResponse\x12F\n" +
-	"\fStreamPublic\x12 .antd.v1.StreamPublicDataRequest\x1a\x12.antd.v1.DataChunk0\x01\x12M\n" +
-	"\n" +
-	"GetPrivate\x12\x1e.antd.v1.GetPrivateDataRequest\x1a\x1f.antd.v1.GetPrivateDataResponse\x12M\n" +
-	"\n" +
-	"PutPrivate\x12\x1e.antd.v1.PutPrivateDataRequest\x1a\x1f.antd.v1.PutPrivateDataResponse\x122\n" +
-	"\aGetCost\x12\x18.antd.v1.DataCostRequest\x1a\r.antd.v1.CostBDZ8github.com/WithAutonomi/ant-sdk/antd-go/proto/antd/v1;v1\xaa\x02\aAntd.V1b\x06proto3"
+	"\x04data\x18\x01 \x01(\fR\x04data\x12!\n" +
+	"\fpayment_mode\x18\x02 \x01(\tR\vpaymentMode2\x92\x03\n" +
+	"\vDataService\x128\n" +
+	"\x03Put\x12\x17.antd.v1.PutDataRequest\x1a\x18.antd.v1.PutDataResponse\x12J\n" +
+	"\tPutPublic\x12\x1d.antd.v1.PutPublicDataRequest\x1a\x1e.antd.v1.PutPublicDataResponse\x128\n" +
+	"\x03Get\x12\x17.antd.v1.GetDataRequest\x1a\x18.antd.v1.GetDataResponse\x12J\n" +
+	"\tGetPublic\x12\x1d.antd.v1.GetPublicDataRequest\x1a\x1e.antd.v1.GetPublicDataResponse\x12F\n" +
+	"\fStreamPublic\x12 .antd.v1.StreamPublicDataRequest\x1a\x12.antd.v1.DataChunk0\x01\x12/\n" +
+	"\x04Cost\x12\x18.antd.v1.DataCostRequest\x1a\r.antd.v1.CostBDZ8github.com/WithAutonomi/ant-sdk/antd-go/proto/antd/v1;v1\xaa\x02\aAntd.V1b\x06proto3"
 
 var (
 	file_antd_v1_data_proto_rawDescOnce sync.Once
@@ -580,28 +613,28 @@ var file_antd_v1_data_proto_goTypes = []any{
 	(*PutPublicDataResponse)(nil),   // 3: antd.v1.PutPublicDataResponse
 	(*StreamPublicDataRequest)(nil), // 4: antd.v1.StreamPublicDataRequest
 	(*DataChunk)(nil),               // 5: antd.v1.DataChunk
-	(*GetPrivateDataRequest)(nil),   // 6: antd.v1.GetPrivateDataRequest
-	(*GetPrivateDataResponse)(nil),  // 7: antd.v1.GetPrivateDataResponse
-	(*PutPrivateDataRequest)(nil),   // 8: antd.v1.PutPrivateDataRequest
-	(*PutPrivateDataResponse)(nil),  // 9: antd.v1.PutPrivateDataResponse
+	(*GetDataRequest)(nil),          // 6: antd.v1.GetDataRequest
+	(*GetDataResponse)(nil),         // 7: antd.v1.GetDataResponse
+	(*PutDataRequest)(nil),          // 8: antd.v1.PutDataRequest
+	(*PutDataResponse)(nil),         // 9: antd.v1.PutDataResponse
 	(*DataCostRequest)(nil),         // 10: antd.v1.DataCostRequest
 	(*Cost)(nil),                    // 11: antd.v1.Cost
 }
 var file_antd_v1_data_proto_depIdxs = []int32{
 	11, // 0: antd.v1.PutPublicDataResponse.cost:type_name -> antd.v1.Cost
-	11, // 1: antd.v1.PutPrivateDataResponse.cost:type_name -> antd.v1.Cost
-	0,  // 2: antd.v1.DataService.GetPublic:input_type -> antd.v1.GetPublicDataRequest
+	11, // 1: antd.v1.PutDataResponse.cost:type_name -> antd.v1.Cost
+	8,  // 2: antd.v1.DataService.Put:input_type -> antd.v1.PutDataRequest
 	2,  // 3: antd.v1.DataService.PutPublic:input_type -> antd.v1.PutPublicDataRequest
-	4,  // 4: antd.v1.DataService.StreamPublic:input_type -> antd.v1.StreamPublicDataRequest
-	6,  // 5: antd.v1.DataService.GetPrivate:input_type -> antd.v1.GetPrivateDataRequest
-	8,  // 6: antd.v1.DataService.PutPrivate:input_type -> antd.v1.PutPrivateDataRequest
-	10, // 7: antd.v1.DataService.GetCost:input_type -> antd.v1.DataCostRequest
-	1,  // 8: antd.v1.DataService.GetPublic:output_type -> antd.v1.GetPublicDataResponse
+	6,  // 4: antd.v1.DataService.Get:input_type -> antd.v1.GetDataRequest
+	0,  // 5: antd.v1.DataService.GetPublic:input_type -> antd.v1.GetPublicDataRequest
+	4,  // 6: antd.v1.DataService.StreamPublic:input_type -> antd.v1.StreamPublicDataRequest
+	10, // 7: antd.v1.DataService.Cost:input_type -> antd.v1.DataCostRequest
+	9,  // 8: antd.v1.DataService.Put:output_type -> antd.v1.PutDataResponse
 	3,  // 9: antd.v1.DataService.PutPublic:output_type -> antd.v1.PutPublicDataResponse
-	5,  // 10: antd.v1.DataService.StreamPublic:output_type -> antd.v1.DataChunk
-	7,  // 11: antd.v1.DataService.GetPrivate:output_type -> antd.v1.GetPrivateDataResponse
-	9,  // 12: antd.v1.DataService.PutPrivate:output_type -> antd.v1.PutPrivateDataResponse
-	11, // 13: antd.v1.DataService.GetCost:output_type -> antd.v1.Cost
+	7,  // 10: antd.v1.DataService.Get:output_type -> antd.v1.GetDataResponse
+	1,  // 11: antd.v1.DataService.GetPublic:output_type -> antd.v1.GetPublicDataResponse
+	5,  // 12: antd.v1.DataService.StreamPublic:output_type -> antd.v1.DataChunk
+	11, // 13: antd.v1.DataService.Cost:output_type -> antd.v1.Cost
 	8,  // [8:14] is the sub-list for method output_type
 	2,  // [2:8] is the sub-list for method input_type
 	2,  // [2:2] is the sub-list for extension type_name
diff --git a/antd-go/proto/antd/v1/data_grpc.pb.go b/antd-go/proto/antd/v1/data_grpc.pb.go
index b244e31..a930e4b 100644
--- a/antd-go/proto/antd/v1/data_grpc.pb.go
+++ b/antd-go/proto/antd/v1/data_grpc.pb.go
@@ -19,24 +19,27 @@ import (
 const _ = grpc.SupportPackageIsVersion9
 
 const (
-	DataService_GetPublic_FullMethodName    = "/antd.v1.DataService/GetPublic"
+	DataService_Put_FullMethodName          = "/antd.v1.DataService/Put"
 	DataService_PutPublic_FullMethodName    = "/antd.v1.DataService/PutPublic"
+	DataService_Get_FullMethodName          = "/antd.v1.DataService/Get"
+	DataService_GetPublic_FullMethodName    = "/antd.v1.DataService/GetPublic"
 	DataService_StreamPublic_FullMethodName = "/antd.v1.DataService/StreamPublic"
-	DataService_GetPrivate_FullMethodName   = "/antd.v1.DataService/GetPrivate"
-	DataService_PutPrivate_FullMethodName   = "/antd.v1.DataService/PutPrivate"
-	DataService_GetCost_FullMethodName      = "/antd.v1.DataService/GetCost"
+	DataService_Cost_FullMethodName         = "/antd.v1.DataService/Cost"
 )
 
 // DataServiceClient is the client API for DataService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type DataServiceClient interface {
-	GetPublic(ctx context.Context, in *GetPublicDataRequest, opts ...grpc.CallOption) (*GetPublicDataResponse, error)
+	// Private = unqualified verb (the DataMap is returned to the caller; it is
+	// NOT stored on the network). Public = `_public` suffix (the DataMap is
+	// additionally stored on-network and the call returns the resulting address).
+	Put(ctx context.Context, in *PutDataRequest, opts ...grpc.CallOption) (*PutDataResponse, error)
 	PutPublic(ctx context.Context, in *PutPublicDataRequest, opts ...grpc.CallOption) (*PutPublicDataResponse, error)
+	Get(ctx context.Context, in *GetDataRequest, opts ...grpc.CallOption) (*GetDataResponse, error)
+	GetPublic(ctx context.Context, in *GetPublicDataRequest, opts ...grpc.CallOption) (*GetPublicDataResponse, error)
 	StreamPublic(ctx context.Context, in *StreamPublicDataRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[DataChunk], error)
-	GetPrivate(ctx context.Context, in *GetPrivateDataRequest, opts ...grpc.CallOption) (*GetPrivateDataResponse, error)
-	PutPrivate(ctx context.Context, in *PutPrivateDataRequest, opts ...grpc.CallOption) (*PutPrivateDataResponse, error)
-	GetCost(ctx context.Context, in *DataCostRequest, opts ...grpc.CallOption) (*Cost, error)
+	Cost(ctx context.Context, in *DataCostRequest, opts ...grpc.CallOption) (*Cost, error)
 }
 
 type dataServiceClient struct {
@@ -47,10 +50,10 @@ func NewDataServiceClient(cc grpc.ClientConnInterface) DataServiceClient {
 	return &dataServiceClient{cc}
 }
 
-func (c *dataServiceClient) GetPublic(ctx context.Context, in *GetPublicDataRequest, opts ...grpc.CallOption) (*GetPublicDataResponse, error) {
+func (c *dataServiceClient) Put(ctx context.Context, in *PutDataRequest, opts ...grpc.CallOption) (*PutDataResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	out := new(GetPublicDataResponse)
-	err := c.cc.Invoke(ctx, DataService_GetPublic_FullMethodName, in, out, cOpts...)
+	out := new(PutDataResponse)
+	err := c.cc.Invoke(ctx, DataService_Put_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -67,49 +70,49 @@ func (c *dataServiceClient) PutPublic(ctx context.Context, in *PutPublicDataRequ
 	return out, nil
 }
 
-func (c *dataServiceClient) StreamPublic(ctx context.Context, in *StreamPublicDataRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[DataChunk], error) {
+func (c *dataServiceClient) Get(ctx context.Context, in *GetDataRequest, opts ...grpc.CallOption) (*GetDataResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	stream, err := c.cc.NewStream(ctx, &DataService_ServiceDesc.Streams[0], DataService_StreamPublic_FullMethodName, cOpts...)
+	out := new(GetDataResponse)
+	err := c.cc.Invoke(ctx, DataService_Get_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &grpc.GenericClientStream[StreamPublicDataRequest, DataChunk]{ClientStream: stream}
-	if err := x.ClientStream.SendMsg(in); err != nil {
-		return nil, err
-	}
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	return x, nil
+	return out, nil
 }
 
-// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
-type DataService_StreamPublicClient = grpc.ServerStreamingClient[DataChunk]
-
-func (c *dataServiceClient) GetPrivate(ctx context.Context, in *GetPrivateDataRequest, opts ...grpc.CallOption) (*GetPrivateDataResponse, error) {
+func (c *dataServiceClient) GetPublic(ctx context.Context, in *GetPublicDataRequest, opts ...grpc.CallOption) (*GetPublicDataResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	out := new(GetPrivateDataResponse)
-	err := c.cc.Invoke(ctx, DataService_GetPrivate_FullMethodName, in, out, cOpts...)
+	out := new(GetPublicDataResponse)
+	err := c.cc.Invoke(ctx, DataService_GetPublic_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *dataServiceClient) PutPrivate(ctx context.Context, in *PutPrivateDataRequest, opts ...grpc.CallOption) (*PutPrivateDataResponse, error) {
+func (c *dataServiceClient) StreamPublic(ctx context.Context, in *StreamPublicDataRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[DataChunk], error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	out := new(PutPrivateDataResponse)
-	err := c.cc.Invoke(ctx, DataService_PutPrivate_FullMethodName, in, out, cOpts...)
+	stream, err := c.cc.NewStream(ctx, &DataService_ServiceDesc.Streams[0], DataService_StreamPublic_FullMethodName, cOpts...)
 	if err != nil {
 		return nil, err
 	}
-	return out, nil
+	x := &grpc.GenericClientStream[StreamPublicDataRequest, DataChunk]{ClientStream: stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
 }
 
-func (c *dataServiceClient) GetCost(ctx context.Context, in *DataCostRequest, opts ...grpc.CallOption) (*Cost, error) {
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type DataService_StreamPublicClient = grpc.ServerStreamingClient[DataChunk]
+
+func (c *dataServiceClient) Cost(ctx context.Context, in *DataCostRequest, opts ...grpc.CallOption) (*Cost, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Cost)
-	err := c.cc.Invoke(ctx, DataService_GetCost_FullMethodName, in, out, cOpts...)
+	err := c.cc.Invoke(ctx, DataService_Cost_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -120,12 +123,15 @@ func (c *dataServiceClient) GetCost(ctx context.Context, in *DataCostRequest, op
 // All implementations must embed UnimplementedDataServiceServer
 // for forward compatibility.
 type DataServiceServer interface {
-	GetPublic(context.Context, *GetPublicDataRequest) (*GetPublicDataResponse, error)
+	// Private = unqualified verb (the DataMap is returned to the caller; it is
+	// NOT stored on the network). Public = `_public` suffix (the DataMap is
+	// additionally stored on-network and the call returns the resulting address).
+	Put(context.Context, *PutDataRequest) (*PutDataResponse, error)
 	PutPublic(context.Context, *PutPublicDataRequest) (*PutPublicDataResponse, error)
+	Get(context.Context, *GetDataRequest) (*GetDataResponse, error)
+	GetPublic(context.Context, *GetPublicDataRequest) (*GetPublicDataResponse, error)
 	StreamPublic(*StreamPublicDataRequest, grpc.ServerStreamingServer[DataChunk]) error
-	GetPrivate(context.Context, *GetPrivateDataRequest) (*GetPrivateDataResponse, error)
-	PutPrivate(context.Context, *PutPrivateDataRequest) (*PutPrivateDataResponse, error)
-	GetCost(context.Context, *DataCostRequest) (*Cost, error)
+	Cost(context.Context, *DataCostRequest) (*Cost, error)
 	mustEmbedUnimplementedDataServiceServer()
 }
 
@@ -136,23 +142,23 @@ type DataServiceServer interface {
 // pointer dereference when methods are called.
 type UnimplementedDataServiceServer struct{}
 
-func (UnimplementedDataServiceServer) GetPublic(context.Context, *GetPublicDataRequest) (*GetPublicDataResponse, error) {
-	return nil, status.Error(codes.Unimplemented, "method GetPublic not implemented")
+func (UnimplementedDataServiceServer) Put(context.Context, *PutDataRequest) (*PutDataResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method Put not implemented")
 }
 func (UnimplementedDataServiceServer) PutPublic(context.Context, *PutPublicDataRequest) (*PutPublicDataResponse, error) {
 	return nil, status.Error(codes.Unimplemented, "method PutPublic not implemented")
 }
-func (UnimplementedDataServiceServer) StreamPublic(*StreamPublicDataRequest, grpc.ServerStreamingServer[DataChunk]) error {
-	return status.Error(codes.Unimplemented, "method StreamPublic not implemented")
+func (UnimplementedDataServiceServer) Get(context.Context, *GetDataRequest) (*GetDataResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method Get not implemented")
 }
-func (UnimplementedDataServiceServer) GetPrivate(context.Context, *GetPrivateDataRequest) (*GetPrivateDataResponse, error) {
-	return nil, status.Error(codes.Unimplemented, "method GetPrivate not implemented")
+func (UnimplementedDataServiceServer) GetPublic(context.Context, *GetPublicDataRequest) (*GetPublicDataResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method GetPublic not implemented")
 }
-func (UnimplementedDataServiceServer) PutPrivate(context.Context, *PutPrivateDataRequest) (*PutPrivateDataResponse, error) {
-	return nil, status.Error(codes.Unimplemented, "method PutPrivate not implemented")
+func (UnimplementedDataServiceServer) StreamPublic(*StreamPublicDataRequest, grpc.ServerStreamingServer[DataChunk]) error {
+	return status.Error(codes.Unimplemented, "method StreamPublic not implemented")
 }
-func (UnimplementedDataServiceServer) GetCost(context.Context, *DataCostRequest) (*Cost, error) {
-	return nil, status.Error(codes.Unimplemented, "method GetCost not implemented")
+func (UnimplementedDataServiceServer) Cost(context.Context, *DataCostRequest) (*Cost, error) {
+	return nil, status.Error(codes.Unimplemented, "method Cost not implemented")
 }
 func (UnimplementedDataServiceServer) mustEmbedUnimplementedDataServiceServer() {}
 func (UnimplementedDataServiceServer) testEmbeddedByValue()                     {}
@@ -175,20 +181,20 @@ func RegisterDataServiceServer(s grpc.ServiceRegistrar, srv DataServiceServer) {
 	s.RegisterService(&DataService_ServiceDesc, srv)
 }
 
-func _DataService_GetPublic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetPublicDataRequest)
+func _DataService_Put_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PutDataRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(DataServiceServer).GetPublic(ctx, in)
+		return srv.(DataServiceServer).Put(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: DataService_GetPublic_FullMethodName,
+		FullMethod: DataService_Put_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(DataServiceServer).GetPublic(ctx, req.(*GetPublicDataRequest))
+		return srv.(DataServiceServer).Put(ctx, req.(*PutDataRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -211,67 +217,67 @@ func _DataService_PutPublic_Handler(srv interface{}, ctx context.Context, dec fu
 	return interceptor(ctx, in, info, handler)
 }
 
-func _DataService_StreamPublic_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(StreamPublicDataRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(DataServiceServer).StreamPublic(m, &grpc.GenericServerStream[StreamPublicDataRequest, DataChunk]{ServerStream: stream})
-}
-
-// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
-type DataService_StreamPublicServer = grpc.ServerStreamingServer[DataChunk]
-
-func _DataService_GetPrivate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetPrivateDataRequest)
+func _DataService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetDataRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(DataServiceServer).GetPrivate(ctx, in)
+		return srv.(DataServiceServer).Get(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: DataService_GetPrivate_FullMethodName,
+		FullMethod: DataService_Get_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(DataServiceServer).GetPrivate(ctx, req.(*GetPrivateDataRequest))
+		return srv.(DataServiceServer).Get(ctx, req.(*GetDataRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _DataService_PutPrivate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(PutPrivateDataRequest)
+func _DataService_GetPublic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetPublicDataRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(DataServiceServer).PutPrivate(ctx, in)
+		return srv.(DataServiceServer).GetPublic(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: DataService_PutPrivate_FullMethodName,
+		FullMethod: DataService_GetPublic_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(DataServiceServer).PutPrivate(ctx, req.(*PutPrivateDataRequest))
+		return srv.(DataServiceServer).GetPublic(ctx, req.(*GetPublicDataRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _DataService_GetCost_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _DataService_StreamPublic_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(StreamPublicDataRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(DataServiceServer).StreamPublic(m, &grpc.GenericServerStream[StreamPublicDataRequest, DataChunk]{ServerStream: stream})
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type DataService_StreamPublicServer = grpc.ServerStreamingServer[DataChunk]
+
+func _DataService_Cost_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(DataCostRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(DataServiceServer).GetCost(ctx, in)
+		return srv.(DataServiceServer).Cost(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: DataService_GetCost_FullMethodName,
+		FullMethod: DataService_Cost_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(DataServiceServer).GetCost(ctx, req.(*DataCostRequest))
+		return srv.(DataServiceServer).Cost(ctx, req.(*DataCostRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -284,24 +290,24 @@ var DataService_ServiceDesc = grpc.ServiceDesc{
 	HandlerType: (*DataServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
-			MethodName: "GetPublic",
-			Handler:    _DataService_GetPublic_Handler,
+			MethodName: "Put",
+			Handler:    _DataService_Put_Handler,
 		},
 		{
 			MethodName: "PutPublic",
 			Handler:    _DataService_PutPublic_Handler,
 		},
 		{
-			MethodName: "GetPrivate",
-			Handler:    _DataService_GetPrivate_Handler,
+			MethodName: "Get",
+			Handler:    _DataService_Get_Handler,
 		},
 		{
-			MethodName: "PutPrivate",
-			Handler:    _DataService_PutPrivate_Handler,
+			MethodName: "GetPublic",
+			Handler:    _DataService_GetPublic_Handler,
 		},
 		{
-			MethodName: "GetCost",
-			Handler:    _DataService_GetCost_Handler,
+			MethodName: "Cost",
+			Handler:    _DataService_Cost_Handler,
 		},
 	},
 	Streams: []grpc.StreamDesc{
diff --git a/antd-go/proto/antd/v1/files.pb.go b/antd-go/proto/antd/v1/files.pb.go
index 202059e..c51a0e9 100644
--- a/antd-go/proto/antd/v1/files.pb.go
+++ b/antd-go/proto/antd/v1/files.pb.go
@@ -21,27 +21,31 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
-type UploadFileRequest struct {
-	state         protoimpl.MessageState `protogen:"open.v1"`
-	Path          string                 `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` // local filesystem path
+type PutFileRequest struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	Path  string                 `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` // local filesystem path
+	// Optional payment mode: "auto" (default), "merkle", or "single". Empty
+	// string is treated as "auto" so old clients omitting the field stay
+	// wire-compatible.
+	PaymentMode   string `protobuf:"bytes,2,opt,name=payment_mode,json=paymentMode,proto3" json:"payment_mode,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *UploadFileRequest) Reset() {
-	*x = UploadFileRequest{}
+func (x *PutFileRequest) Reset() {
+	*x = PutFileRequest{}
 	mi := &file_antd_v1_files_proto_msgTypes[0]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *UploadFileRequest) String() string {
+func (x *PutFileRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*UploadFileRequest) ProtoMessage() {}
+func (*PutFileRequest) ProtoMessage() {}
 
-func (x *UploadFileRequest) ProtoReflect() protoreflect.Message {
+func (x *PutFileRequest) ProtoReflect() protoreflect.Message {
 	mi := &file_antd_v1_files_proto_msgTypes[0]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -53,21 +57,28 @@ func (x *UploadFileRequest) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use UploadFileRequest.ProtoReflect.Descriptor instead.
-func (*UploadFileRequest) Descriptor() ([]byte, []int) {
+// Deprecated: Use PutFileRequest.ProtoReflect.Descriptor instead.
+func (*PutFileRequest) Descriptor() ([]byte, []int) {
 	return file_antd_v1_files_proto_rawDescGZIP(), []int{0}
 }
 
-func (x *UploadFileRequest) GetPath() string {
+func (x *PutFileRequest) GetPath() string {
 	if x != nil {
 		return x.Path
 	}
 	return ""
 }
 
-type UploadPublicResponse struct {
+func (x *PutFileRequest) GetPaymentMode() string {
+	if x != nil {
+		return x.PaymentMode
+	}
+	return ""
+}
+
+type PutFilePublicResponse struct {
 	state   protoimpl.MessageState `protogen:"open.v1"`
-	Address string                 `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` // hex
+	Address string                 `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` // hex — the DataMap's chunk address on the network
 	// Total storage cost paid in token units (atto). "0" if all chunks already existed.
 	StorageCostAtto string `protobuf:"bytes,3,opt,name=storage_cost_atto,json=storageCostAtto,proto3" json:"storage_cost_atto,omitempty"`
 	// Total gas cost paid in wei, as a decimal string (u128 exceeds JSON safe-integer range).
@@ -80,20 +91,20 @@ type UploadPublicResponse struct {
 	sizeCache       protoimpl.SizeCache
 }
 
-func (x *UploadPublicResponse) Reset() {
-	*x = UploadPublicResponse{}
+func (x *PutFilePublicResponse) Reset() {
+	*x = PutFilePublicResponse{}
 	mi := &file_antd_v1_files_proto_msgTypes[1]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *UploadPublicResponse) String() string {
+func (x *PutFilePublicResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*UploadPublicResponse) ProtoMessage() {}
+func (*PutFilePublicResponse) ProtoMessage() {}
 
-func (x *UploadPublicResponse) ProtoReflect() protoreflect.Message {
+func (x *PutFilePublicResponse) ProtoReflect() protoreflect.Message {
 	mi := &file_antd_v1_files_proto_msgTypes[1]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -105,68 +116,77 @@ func (x *UploadPublicResponse) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use UploadPublicResponse.ProtoReflect.Descriptor instead.
-func (*UploadPublicResponse) Descriptor() ([]byte, []int) {
+// Deprecated: Use PutFilePublicResponse.ProtoReflect.Descriptor instead.
+func (*PutFilePublicResponse) Descriptor() ([]byte, []int) {
 	return file_antd_v1_files_proto_rawDescGZIP(), []int{1}
 }
 
-func (x *UploadPublicResponse) GetAddress() string {
+func (x *PutFilePublicResponse) GetAddress() string {
 	if x != nil {
 		return x.Address
 	}
 	return ""
 }
 
-func (x *UploadPublicResponse) GetStorageCostAtto() string {
+func (x *PutFilePublicResponse) GetStorageCostAtto() string {
 	if x != nil {
 		return x.StorageCostAtto
 	}
 	return ""
 }
 
-func (x *UploadPublicResponse) GetGasCostWei() string {
+func (x *PutFilePublicResponse) GetGasCostWei() string {
 	if x != nil {
 		return x.GasCostWei
 	}
 	return ""
 }
 
-func (x *UploadPublicResponse) GetChunksStored() uint64 {
+func (x *PutFilePublicResponse) GetChunksStored() uint64 {
 	if x != nil {
 		return x.ChunksStored
 	}
 	return 0
 }
 
-func (x *UploadPublicResponse) GetPaymentModeUsed() string {
+func (x *PutFilePublicResponse) GetPaymentModeUsed() string {
 	if x != nil {
 		return x.PaymentModeUsed
 	}
 	return ""
 }
 
-type DownloadPublicRequest struct {
-	state         protoimpl.MessageState `protogen:"open.v1"`
-	Address       string                 `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`                   // hex
-	DestPath      string                 `protobuf:"bytes,2,opt,name=dest_path,json=destPath,proto3" json:"dest_path,omitempty"` // local filesystem path
-	unknownFields protoimpl.UnknownFields
-	sizeCache     protoimpl.SizeCache
+type PutFileResponse struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// Hex-encoded rmp_serde-serialized DataMap. The caller keeps this; it is
+	// NOT stored on the network. Same shape as `PutDataResponse.data_map`.
+	DataMap string `protobuf:"bytes,1,opt,name=data_map,json=dataMap,proto3" json:"data_map,omitempty"`
+	// Total storage cost paid in token units (atto). "0" if all chunks already existed.
+	StorageCostAtto string `protobuf:"bytes,2,opt,name=storage_cost_atto,json=storageCostAtto,proto3" json:"storage_cost_atto,omitempty"`
+	// Total gas cost paid in wei, as a decimal string (u128 exceeds JSON safe-integer range).
+	GasCostWei string `protobuf:"bytes,3,opt,name=gas_cost_wei,json=gasCostWei,proto3" json:"gas_cost_wei,omitempty"`
+	// Number of chunks stored on the network.
+	ChunksStored uint64 `protobuf:"varint,4,opt,name=chunks_stored,json=chunksStored,proto3" json:"chunks_stored,omitempty"`
+	// Which payment mode was actually used ("auto", "merkle", or "single").
+	PaymentModeUsed string `protobuf:"bytes,5,opt,name=payment_mode_used,json=paymentModeUsed,proto3" json:"payment_mode_used,omitempty"`
+	unknownFields   protoimpl.UnknownFields
+	sizeCache       protoimpl.SizeCache
 }
 
-func (x *DownloadPublicRequest) Reset() {
-	*x = DownloadPublicRequest{}
+func (x *PutFileResponse) Reset() {
+	*x = PutFileResponse{}
 	mi := &file_antd_v1_files_proto_msgTypes[2]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *DownloadPublicRequest) String() string {
+func (x *PutFileResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*DownloadPublicRequest) ProtoMessage() {}
+func (*PutFileResponse) ProtoMessage() {}
 
-func (x *DownloadPublicRequest) ProtoReflect() protoreflect.Message {
+func (x *PutFileResponse) ProtoReflect() protoreflect.Message {
 	mi := &file_antd_v1_files_proto_msgTypes[2]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -178,45 +198,68 @@ func (x *DownloadPublicRequest) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use DownloadPublicRequest.ProtoReflect.Descriptor instead.
-func (*DownloadPublicRequest) Descriptor() ([]byte, []int) {
+// Deprecated: Use PutFileResponse.ProtoReflect.Descriptor instead.
+func (*PutFileResponse) Descriptor() ([]byte, []int) {
 	return file_antd_v1_files_proto_rawDescGZIP(), []int{2}
 }
 
-func (x *DownloadPublicRequest) GetAddress() string {
+func (x *PutFileResponse) GetDataMap() string {
 	if x != nil {
-		return x.Address
+		return x.DataMap
 	}
 	return ""
 }
 
-func (x *DownloadPublicRequest) GetDestPath() string {
+func (x *PutFileResponse) GetStorageCostAtto() string {
 	if x != nil {
-		return x.DestPath
+		return x.StorageCostAtto
+	}
+	return ""
+}
+
+func (x *PutFileResponse) GetGasCostWei() string {
+	if x != nil {
+		return x.GasCostWei
 	}
 	return ""
 }
 
-type DownloadResponse struct {
+func (x *PutFileResponse) GetChunksStored() uint64 {
+	if x != nil {
+		return x.ChunksStored
+	}
+	return 0
+}
+
+func (x *PutFileResponse) GetPaymentModeUsed() string {
+	if x != nil {
+		return x.PaymentModeUsed
+	}
+	return ""
+}
+
+type GetFilePublicRequest struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
+	Address       string                 `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`                   // hex — DataMap chunk address
+	DestPath      string                 `protobuf:"bytes,2,opt,name=dest_path,json=destPath,proto3" json:"dest_path,omitempty"` // local filesystem path
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *DownloadResponse) Reset() {
-	*x = DownloadResponse{}
+func (x *GetFilePublicRequest) Reset() {
+	*x = GetFilePublicRequest{}
 	mi := &file_antd_v1_files_proto_msgTypes[3]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *DownloadResponse) String() string {
+func (x *GetFilePublicRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*DownloadResponse) ProtoMessage() {}
+func (*GetFilePublicRequest) ProtoMessage() {}
 
-func (x *DownloadResponse) ProtoReflect() protoreflect.Message {
+func (x *GetFilePublicRequest) ProtoReflect() protoreflect.Message {
 	mi := &file_antd_v1_files_proto_msgTypes[3]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -228,22 +271,129 @@ func (x *DownloadResponse) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use DownloadResponse.ProtoReflect.Descriptor instead.
-func (*DownloadResponse) Descriptor() ([]byte, []int) {
+// Deprecated: Use GetFilePublicRequest.ProtoReflect.Descriptor instead.
+func (*GetFilePublicRequest) Descriptor() ([]byte, []int) {
 	return file_antd_v1_files_proto_rawDescGZIP(), []int{3}
 }
 
-type FileCostRequest struct {
+func (x *GetFilePublicRequest) GetAddress() string {
+	if x != nil {
+		return x.Address
+	}
+	return ""
+}
+
+func (x *GetFilePublicRequest) GetDestPath() string {
+	if x != nil {
+		return x.DestPath
+	}
+	return ""
+}
+
+type GetFileRequest struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
-	Path          string                 `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
-	IsPublic      bool                   `protobuf:"varint,2,opt,name=is_public,json=isPublic,proto3" json:"is_public,omitempty"`
+	DataMap       string                 `protobuf:"bytes,1,opt,name=data_map,json=dataMap,proto3" json:"data_map,omitempty"`    // hex — rmp_serde-serialized DataMap
+	DestPath      string                 `protobuf:"bytes,2,opt,name=dest_path,json=destPath,proto3" json:"dest_path,omitempty"` // local filesystem path
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GetFileRequest) Reset() {
+	*x = GetFileRequest{}
+	mi := &file_antd_v1_files_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GetFileRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetFileRequest) ProtoMessage() {}
+
+func (x *GetFileRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_antd_v1_files_proto_msgTypes[4]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetFileRequest.ProtoReflect.Descriptor instead.
+func (*GetFileRequest) Descriptor() ([]byte, []int) {
+	return file_antd_v1_files_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *GetFileRequest) GetDataMap() string {
+	if x != nil {
+		return x.DataMap
+	}
+	return ""
+}
+
+func (x *GetFileRequest) GetDestPath() string {
+	if x != nil {
+		return x.DestPath
+	}
+	return ""
+}
+
+// Shared by GetPublic and Get — the file is written to dest_path, the response
+// itself is empty (success = file written, failure = RPC error).
+type GetFileResponse struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GetFileResponse) Reset() {
+	*x = GetFileResponse{}
+	mi := &file_antd_v1_files_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GetFileResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetFileResponse) ProtoMessage() {}
+
+func (x *GetFileResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_antd_v1_files_proto_msgTypes[5]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetFileResponse.ProtoReflect.Descriptor instead.
+func (*GetFileResponse) Descriptor() ([]byte, []int) {
+	return file_antd_v1_files_proto_rawDescGZIP(), []int{5}
+}
+
+type FileCostRequest struct {
+	state    protoimpl.MessageState `protogen:"open.v1"`
+	Path     string                 `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
+	IsPublic bool                   `protobuf:"varint,2,opt,name=is_public,json=isPublic,proto3" json:"is_public,omitempty"`
+	// Optional payment mode the estimate should reflect: "auto" (default),
+	// "merkle", or "single". Empty string is treated as "auto".
+	PaymentMode   string `protobuf:"bytes,3,opt,name=payment_mode,json=paymentMode,proto3" json:"payment_mode,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
 
 func (x *FileCostRequest) Reset() {
 	*x = FileCostRequest{}
-	mi := &file_antd_v1_files_proto_msgTypes[4]
+	mi := &file_antd_v1_files_proto_msgTypes[6]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -255,7 +405,7 @@ func (x *FileCostRequest) String() string {
 func (*FileCostRequest) ProtoMessage() {}
 
 func (x *FileCostRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_antd_v1_files_proto_msgTypes[4]
+	mi := &file_antd_v1_files_proto_msgTypes[6]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -268,7 +418,7 @@ func (x *FileCostRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use FileCostRequest.ProtoReflect.Descriptor instead.
 func (*FileCostRequest) Descriptor() ([]byte, []int) {
-	return file_antd_v1_files_proto_rawDescGZIP(), []int{4}
+	return file_antd_v1_files_proto_rawDescGZIP(), []int{6}
 }
 
 func (x *FileCostRequest) GetPath() string {
@@ -285,33 +435,52 @@ func (x *FileCostRequest) GetIsPublic() bool {
 	return false
 }
 
+func (x *FileCostRequest) GetPaymentMode() string {
+	if x != nil {
+		return x.PaymentMode
+	}
+	return ""
+}
+
 var File_antd_v1_files_proto protoreflect.FileDescriptor
 
 const file_antd_v1_files_proto_rawDesc = "" +
 	"\n" +
-	"\x13antd/v1/files.proto\x12\aantd.v1\x1a\x14antd/v1/common.proto\"'\n" +
-	"\x11UploadFileRequest\x12\x12\n" +
-	"\x04path\x18\x01 \x01(\tR\x04path\"\xdb\x01\n" +
-	"\x14UploadPublicResponse\x12\x18\n" +
+	"\x13antd/v1/files.proto\x12\aantd.v1\x1a\x14antd/v1/common.proto\"G\n" +
+	"\x0ePutFileRequest\x12\x12\n" +
+	"\x04path\x18\x01 \x01(\tR\x04path\x12!\n" +
+	"\fpayment_mode\x18\x02 \x01(\tR\vpaymentMode\"\xdc\x01\n" +
+	"\x15PutFilePublicResponse\x12\x18\n" +
 	"\aaddress\x18\x02 \x01(\tR\aaddress\x12*\n" +
 	"\x11storage_cost_atto\x18\x03 \x01(\tR\x0fstorageCostAtto\x12 \n" +
 	"\fgas_cost_wei\x18\x04 \x01(\tR\n" +
 	"gasCostWei\x12#\n" +
 	"\rchunks_stored\x18\x05 \x01(\x04R\fchunksStored\x12*\n" +
-	"\x11payment_mode_used\x18\x06 \x01(\tR\x0fpaymentModeUsedJ\x04\b\x01\x10\x02R\x04cost\"N\n" +
-	"\x15DownloadPublicRequest\x12\x18\n" +
+	"\x11payment_mode_used\x18\x06 \x01(\tR\x0fpaymentModeUsedJ\x04\b\x01\x10\x02R\x04cost\"\xcb\x01\n" +
+	"\x0fPutFileResponse\x12\x19\n" +
+	"\bdata_map\x18\x01 \x01(\tR\adataMap\x12*\n" +
+	"\x11storage_cost_atto\x18\x02 \x01(\tR\x0fstorageCostAtto\x12 \n" +
+	"\fgas_cost_wei\x18\x03 \x01(\tR\n" +
+	"gasCostWei\x12#\n" +
+	"\rchunks_stored\x18\x04 \x01(\x04R\fchunksStored\x12*\n" +
+	"\x11payment_mode_used\x18\x05 \x01(\tR\x0fpaymentModeUsed\"M\n" +
+	"\x14GetFilePublicRequest\x12\x18\n" +
 	"\aaddress\x18\x01 \x01(\tR\aaddress\x12\x1b\n" +
-	"\tdest_path\x18\x02 \x01(\tR\bdestPath\"\x12\n" +
-	"\x10DownloadResponse\"B\n" +
+	"\tdest_path\x18\x02 \x01(\tR\bdestPath\"H\n" +
+	"\x0eGetFileRequest\x12\x19\n" +
+	"\bdata_map\x18\x01 \x01(\tR\adataMap\x12\x1b\n" +
+	"\tdest_path\x18\x02 \x01(\tR\bdestPath\"\x11\n" +
+	"\x0fGetFileResponse\"e\n" +
 	"\x0fFileCostRequest\x12\x12\n" +
 	"\x04path\x18\x01 \x01(\tR\x04path\x12\x1b\n" +
-	"\tis_public\x18\x02 \x01(\bR\bisPublic2\xfb\x02\n" +
-	"\vFileService\x12I\n" +
-	"\fUploadPublic\x12\x1a.antd.v1.UploadFileRequest\x1a\x1d.antd.v1.UploadPublicResponse\x12K\n" +
-	"\x0eDownloadPublic\x12\x1e.antd.v1.DownloadPublicRequest\x1a\x19.antd.v1.DownloadResponse\x12L\n" +
-	"\x0fDirUploadPublic\x12\x1a.antd.v1.UploadFileRequest\x1a\x1d.antd.v1.UploadPublicResponse\x12N\n" +
-	"\x11DirDownloadPublic\x12\x1e.antd.v1.DownloadPublicRequest\x1a\x19.antd.v1.DownloadResponse\x126\n" +
-	"\vGetFileCost\x12\x18.antd.v1.FileCostRequest\x1a\r.antd.v1.CostBDZ8github.com/WithAutonomi/ant-sdk/antd-go/proto/antd/v1;v1\xaa\x02\aAntd.V1b\x06proto3"
+	"\tis_public\x18\x02 \x01(\bR\bisPublic\x12!\n" +
+	"\fpayment_mode\x18\x03 \x01(\tR\vpaymentMode2\xbe\x02\n" +
+	"\vFileService\x128\n" +
+	"\x03Put\x12\x17.antd.v1.PutFileRequest\x1a\x18.antd.v1.PutFileResponse\x12D\n" +
+	"\tPutPublic\x12\x17.antd.v1.PutFileRequest\x1a\x1e.antd.v1.PutFilePublicResponse\x128\n" +
+	"\x03Get\x12\x17.antd.v1.GetFileRequest\x1a\x18.antd.v1.GetFileResponse\x12D\n" +
+	"\tGetPublic\x12\x1d.antd.v1.GetFilePublicRequest\x1a\x18.antd.v1.GetFileResponse\x12/\n" +
+	"\x04Cost\x12\x18.antd.v1.FileCostRequest\x1a\r.antd.v1.CostBDZ8github.com/WithAutonomi/ant-sdk/antd-go/proto/antd/v1;v1\xaa\x02\aAntd.V1b\x06proto3"
 
 var (
 	file_antd_v1_files_proto_rawDescOnce sync.Once
@@ -325,26 +494,28 @@ func file_antd_v1_files_proto_rawDescGZIP() []byte {
 	return file_antd_v1_files_proto_rawDescData
 }
 
-var file_antd_v1_files_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
+var file_antd_v1_files_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
 var file_antd_v1_files_proto_goTypes = []any{
-	(*UploadFileRequest)(nil),     // 0: antd.v1.UploadFileRequest
-	(*UploadPublicResponse)(nil),  // 1: antd.v1.UploadPublicResponse
-	(*DownloadPublicRequest)(nil), // 2: antd.v1.DownloadPublicRequest
-	(*DownloadResponse)(nil),      // 3: antd.v1.DownloadResponse
-	(*FileCostRequest)(nil),       // 4: antd.v1.FileCostRequest
-	(*Cost)(nil),                  // 5: antd.v1.Cost
+	(*PutFileRequest)(nil),        // 0: antd.v1.PutFileRequest
+	(*PutFilePublicResponse)(nil), // 1: antd.v1.PutFilePublicResponse
+	(*PutFileResponse)(nil),       // 2: antd.v1.PutFileResponse
+	(*GetFilePublicRequest)(nil),  // 3: antd.v1.GetFilePublicRequest
+	(*GetFileRequest)(nil),        // 4: antd.v1.GetFileRequest
+	(*GetFileResponse)(nil),       // 5: antd.v1.GetFileResponse
+	(*FileCostRequest)(nil),       // 6: antd.v1.FileCostRequest
+	(*Cost)(nil),                  // 7: antd.v1.Cost
 }
 var file_antd_v1_files_proto_depIdxs = []int32{
-	0, // 0: antd.v1.FileService.UploadPublic:input_type -> antd.v1.UploadFileRequest
-	2, // 1: antd.v1.FileService.DownloadPublic:input_type -> antd.v1.DownloadPublicRequest
-	0, // 2: antd.v1.FileService.DirUploadPublic:input_type -> antd.v1.UploadFileRequest
-	2, // 3: antd.v1.FileService.DirDownloadPublic:input_type -> antd.v1.DownloadPublicRequest
-	4, // 4: antd.v1.FileService.GetFileCost:input_type -> antd.v1.FileCostRequest
-	1, // 5: antd.v1.FileService.UploadPublic:output_type -> antd.v1.UploadPublicResponse
-	3, // 6: antd.v1.FileService.DownloadPublic:output_type -> antd.v1.DownloadResponse
-	1, // 7: antd.v1.FileService.DirUploadPublic:output_type -> antd.v1.UploadPublicResponse
-	3, // 8: antd.v1.FileService.DirDownloadPublic:output_type -> antd.v1.DownloadResponse
-	5, // 9: antd.v1.FileService.GetFileCost:output_type -> antd.v1.Cost
+	0, // 0: antd.v1.FileService.Put:input_type -> antd.v1.PutFileRequest
+	0, // 1: antd.v1.FileService.PutPublic:input_type -> antd.v1.PutFileRequest
+	4, // 2: antd.v1.FileService.Get:input_type -> antd.v1.GetFileRequest
+	3, // 3: antd.v1.FileService.GetPublic:input_type -> antd.v1.GetFilePublicRequest
+	6, // 4: antd.v1.FileService.Cost:input_type -> antd.v1.FileCostRequest
+	2, // 5: antd.v1.FileService.Put:output_type -> antd.v1.PutFileResponse
+	1, // 6: antd.v1.FileService.PutPublic:output_type -> antd.v1.PutFilePublicResponse
+	5, // 7: antd.v1.FileService.Get:output_type -> antd.v1.GetFileResponse
+	5, // 8: antd.v1.FileService.GetPublic:output_type -> antd.v1.GetFileResponse
+	7, // 9: antd.v1.FileService.Cost:output_type -> antd.v1.Cost
 	5, // [5:10] is the sub-list for method output_type
 	0, // [0:5] is the sub-list for method input_type
 	0, // [0:0] is the sub-list for extension type_name
@@ -364,7 +535,7 @@ func file_antd_v1_files_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: unsafe.Slice(unsafe.StringData(file_antd_v1_files_proto_rawDesc), len(file_antd_v1_files_proto_rawDesc)),
 			NumEnums:      0,
-			NumMessages:   5,
+			NumMessages:   7,
 			NumExtensions: 0,
 			NumServices:   1,
 		},
diff --git a/antd-go/proto/antd/v1/files_grpc.pb.go b/antd-go/proto/antd/v1/files_grpc.pb.go
index d689ae9..d0031b0 100644
--- a/antd-go/proto/antd/v1/files_grpc.pb.go
+++ b/antd-go/proto/antd/v1/files_grpc.pb.go
@@ -19,22 +19,25 @@ import (
 const _ = grpc.SupportPackageIsVersion9
 
 const (
-	FileService_UploadPublic_FullMethodName      = "/antd.v1.FileService/UploadPublic"
-	FileService_DownloadPublic_FullMethodName    = "/antd.v1.FileService/DownloadPublic"
-	FileService_DirUploadPublic_FullMethodName   = "/antd.v1.FileService/DirUploadPublic"
-	FileService_DirDownloadPublic_FullMethodName = "/antd.v1.FileService/DirDownloadPublic"
-	FileService_GetFileCost_FullMethodName       = "/antd.v1.FileService/GetFileCost"
+	FileService_Put_FullMethodName       = "/antd.v1.FileService/Put"
+	FileService_PutPublic_FullMethodName = "/antd.v1.FileService/PutPublic"
+	FileService_Get_FullMethodName       = "/antd.v1.FileService/Get"
+	FileService_GetPublic_FullMethodName = "/antd.v1.FileService/GetPublic"
+	FileService_Cost_FullMethodName      = "/antd.v1.FileService/Cost"
 )
 
 // FileServiceClient is the client API for FileService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type FileServiceClient interface {
-	UploadPublic(ctx context.Context, in *UploadFileRequest, opts ...grpc.CallOption) (*UploadPublicResponse, error)
-	DownloadPublic(ctx context.Context, in *DownloadPublicRequest, opts ...grpc.CallOption) (*DownloadResponse, error)
-	DirUploadPublic(ctx context.Context, in *UploadFileRequest, opts ...grpc.CallOption) (*UploadPublicResponse, error)
-	DirDownloadPublic(ctx context.Context, in *DownloadPublicRequest, opts ...grpc.CallOption) (*DownloadResponse, error)
-	GetFileCost(ctx context.Context, in *FileCostRequest, opts ...grpc.CallOption) (*Cost, error)
+	// Private = unqualified verb (the DataMap is returned to the caller; it is
+	// NOT stored on the network). Public = `_public` suffix (the DataMap is
+	// additionally stored on-network and the call returns the resulting address).
+	Put(ctx context.Context, in *PutFileRequest, opts ...grpc.CallOption) (*PutFileResponse, error)
+	PutPublic(ctx context.Context, in *PutFileRequest, opts ...grpc.CallOption) (*PutFilePublicResponse, error)
+	Get(ctx context.Context, in *GetFileRequest, opts ...grpc.CallOption) (*GetFileResponse, error)
+	GetPublic(ctx context.Context, in *GetFilePublicRequest, opts ...grpc.CallOption) (*GetFileResponse, error)
+	Cost(ctx context.Context, in *FileCostRequest, opts ...grpc.CallOption) (*Cost, error)
 }
 
 type fileServiceClient struct {
@@ -45,50 +48,50 @@ func NewFileServiceClient(cc grpc.ClientConnInterface) FileServiceClient {
 	return &fileServiceClient{cc}
 }
 
-func (c *fileServiceClient) UploadPublic(ctx context.Context, in *UploadFileRequest, opts ...grpc.CallOption) (*UploadPublicResponse, error) {
+func (c *fileServiceClient) Put(ctx context.Context, in *PutFileRequest, opts ...grpc.CallOption) (*PutFileResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	out := new(UploadPublicResponse)
-	err := c.cc.Invoke(ctx, FileService_UploadPublic_FullMethodName, in, out, cOpts...)
+	out := new(PutFileResponse)
+	err := c.cc.Invoke(ctx, FileService_Put_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *fileServiceClient) DownloadPublic(ctx context.Context, in *DownloadPublicRequest, opts ...grpc.CallOption) (*DownloadResponse, error) {
+func (c *fileServiceClient) PutPublic(ctx context.Context, in *PutFileRequest, opts ...grpc.CallOption) (*PutFilePublicResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	out := new(DownloadResponse)
-	err := c.cc.Invoke(ctx, FileService_DownloadPublic_FullMethodName, in, out, cOpts...)
+	out := new(PutFilePublicResponse)
+	err := c.cc.Invoke(ctx, FileService_PutPublic_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *fileServiceClient) DirUploadPublic(ctx context.Context, in *UploadFileRequest, opts ...grpc.CallOption) (*UploadPublicResponse, error) {
+func (c *fileServiceClient) Get(ctx context.Context, in *GetFileRequest, opts ...grpc.CallOption) (*GetFileResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	out := new(UploadPublicResponse)
-	err := c.cc.Invoke(ctx, FileService_DirUploadPublic_FullMethodName, in, out, cOpts...)
+	out := new(GetFileResponse)
+	err := c.cc.Invoke(ctx, FileService_Get_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *fileServiceClient) DirDownloadPublic(ctx context.Context, in *DownloadPublicRequest, opts ...grpc.CallOption) (*DownloadResponse, error) {
+func (c *fileServiceClient) GetPublic(ctx context.Context, in *GetFilePublicRequest, opts ...grpc.CallOption) (*GetFileResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	out := new(DownloadResponse)
-	err := c.cc.Invoke(ctx, FileService_DirDownloadPublic_FullMethodName, in, out, cOpts...)
+	out := new(GetFileResponse)
+	err := c.cc.Invoke(ctx, FileService_GetPublic_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *fileServiceClient) GetFileCost(ctx context.Context, in *FileCostRequest, opts ...grpc.CallOption) (*Cost, error) {
+func (c *fileServiceClient) Cost(ctx context.Context, in *FileCostRequest, opts ...grpc.CallOption) (*Cost, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Cost)
-	err := c.cc.Invoke(ctx, FileService_GetFileCost_FullMethodName, in, out, cOpts...)
+	err := c.cc.Invoke(ctx, FileService_Cost_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -99,11 +102,14 @@ func (c *fileServiceClient) GetFileCost(ctx context.Context, in *FileCostRequest
 // All implementations must embed UnimplementedFileServiceServer
 // for forward compatibility.
 type FileServiceServer interface {
-	UploadPublic(context.Context, *UploadFileRequest) (*UploadPublicResponse, error)
-	DownloadPublic(context.Context, *DownloadPublicRequest) (*DownloadResponse, error)
-	DirUploadPublic(context.Context, *UploadFileRequest) (*UploadPublicResponse, error)
-	DirDownloadPublic(context.Context, *DownloadPublicRequest) (*DownloadResponse, error)
-	GetFileCost(context.Context, *FileCostRequest) (*Cost, error)
+	// Private = unqualified verb (the DataMap is returned to the caller; it is
+	// NOT stored on the network). Public = `_public` suffix (the DataMap is
+	// additionally stored on-network and the call returns the resulting address).
+	Put(context.Context, *PutFileRequest) (*PutFileResponse, error)
+	PutPublic(context.Context, *PutFileRequest) (*PutFilePublicResponse, error)
+	Get(context.Context, *GetFileRequest) (*GetFileResponse, error)
+	GetPublic(context.Context, *GetFilePublicRequest) (*GetFileResponse, error)
+	Cost(context.Context, *FileCostRequest) (*Cost, error)
 	mustEmbedUnimplementedFileServiceServer()
 }
 
@@ -114,20 +120,20 @@ type FileServiceServer interface {
 // pointer dereference when methods are called.
 type UnimplementedFileServiceServer struct{}
 
-func (UnimplementedFileServiceServer) UploadPublic(context.Context, *UploadFileRequest) (*UploadPublicResponse, error) {
-	return nil, status.Error(codes.Unimplemented, "method UploadPublic not implemented")
+func (UnimplementedFileServiceServer) Put(context.Context, *PutFileRequest) (*PutFileResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method Put not implemented")
 }
-func (UnimplementedFileServiceServer) DownloadPublic(context.Context, *DownloadPublicRequest) (*DownloadResponse, error) {
-	return nil, status.Error(codes.Unimplemented, "method DownloadPublic not implemented")
+func (UnimplementedFileServiceServer) PutPublic(context.Context, *PutFileRequest) (*PutFilePublicResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method PutPublic not implemented")
 }
-func (UnimplementedFileServiceServer) DirUploadPublic(context.Context, *UploadFileRequest) (*UploadPublicResponse, error) {
-	return nil, status.Error(codes.Unimplemented, "method DirUploadPublic not implemented")
+func (UnimplementedFileServiceServer) Get(context.Context, *GetFileRequest) (*GetFileResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method Get not implemented")
 }
-func (UnimplementedFileServiceServer) DirDownloadPublic(context.Context, *DownloadPublicRequest) (*DownloadResponse, error) {
-	return nil, status.Error(codes.Unimplemented, "method DirDownloadPublic not implemented")
+func (UnimplementedFileServiceServer) GetPublic(context.Context, *GetFilePublicRequest) (*GetFileResponse, error) {
+	return nil, status.Error(codes.Unimplemented, "method GetPublic not implemented")
 }
-func (UnimplementedFileServiceServer) GetFileCost(context.Context, *FileCostRequest) (*Cost, error) {
-	return nil, status.Error(codes.Unimplemented, "method GetFileCost not implemented")
+func (UnimplementedFileServiceServer) Cost(context.Context, *FileCostRequest) (*Cost, error) {
+	return nil, status.Error(codes.Unimplemented, "method Cost not implemented")
 }
 func (UnimplementedFileServiceServer) mustEmbedUnimplementedFileServiceServer() {}
 func (UnimplementedFileServiceServer) testEmbeddedByValue()                     {}
@@ -150,92 +156,92 @@ func RegisterFileServiceServer(s grpc.ServiceRegistrar, srv FileServiceServer) {
 	s.RegisterService(&FileService_ServiceDesc, srv)
 }
 
-func _FileService_UploadPublic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(UploadFileRequest)
+func _FileService_Put_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PutFileRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(FileServiceServer).UploadPublic(ctx, in)
+		return srv.(FileServiceServer).Put(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: FileService_UploadPublic_FullMethodName,
+		FullMethod: FileService_Put_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(FileServiceServer).UploadPublic(ctx, req.(*UploadFileRequest))
+		return srv.(FileServiceServer).Put(ctx, req.(*PutFileRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _FileService_DownloadPublic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(DownloadPublicRequest)
+func _FileService_PutPublic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PutFileRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(FileServiceServer).DownloadPublic(ctx, in)
+		return srv.(FileServiceServer).PutPublic(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: FileService_DownloadPublic_FullMethodName,
+		FullMethod: FileService_PutPublic_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(FileServiceServer).DownloadPublic(ctx, req.(*DownloadPublicRequest))
+		return srv.(FileServiceServer).PutPublic(ctx, req.(*PutFileRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _FileService_DirUploadPublic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(UploadFileRequest)
+func _FileService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetFileRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(FileServiceServer).DirUploadPublic(ctx, in)
+		return srv.(FileServiceServer).Get(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: FileService_DirUploadPublic_FullMethodName,
+		FullMethod: FileService_Get_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(FileServiceServer).DirUploadPublic(ctx, req.(*UploadFileRequest))
+		return srv.(FileServiceServer).Get(ctx, req.(*GetFileRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _FileService_DirDownloadPublic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(DownloadPublicRequest)
+func _FileService_GetPublic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetFilePublicRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(FileServiceServer).DirDownloadPublic(ctx, in)
+		return srv.(FileServiceServer).GetPublic(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: FileService_DirDownloadPublic_FullMethodName,
+		FullMethod: FileService_GetPublic_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(FileServiceServer).DirDownloadPublic(ctx, req.(*DownloadPublicRequest))
+		return srv.(FileServiceServer).GetPublic(ctx, req.(*GetFilePublicRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
-func _FileService_GetFileCost_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _FileService_Cost_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(FileCostRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(FileServiceServer).GetFileCost(ctx, in)
+		return srv.(FileServiceServer).Cost(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: FileService_GetFileCost_FullMethodName,
+		FullMethod: FileService_Cost_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(FileServiceServer).GetFileCost(ctx, req.(*FileCostRequest))
+		return srv.(FileServiceServer).Cost(ctx, req.(*FileCostRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -248,24 +254,24 @@ var FileService_ServiceDesc = grpc.ServiceDesc{
 	HandlerType: (*FileServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
-			MethodName: "UploadPublic",
-			Handler:    _FileService_UploadPublic_Handler,
+			MethodName: "Put",
+			Handler:    _FileService_Put_Handler,
 		},
 		{
-			MethodName: "DownloadPublic",
-			Handler:    _FileService_DownloadPublic_Handler,
+			MethodName: "PutPublic",
+			Handler:    _FileService_PutPublic_Handler,
 		},
 		{
-			MethodName: "DirUploadPublic",
-			Handler:    _FileService_DirUploadPublic_Handler,
+			MethodName: "Get",
+			Handler:    _FileService_Get_Handler,
 		},
 		{
-			MethodName: "DirDownloadPublic",
-			Handler:    _FileService_DirDownloadPublic_Handler,
+			MethodName: "GetPublic",
+			Handler:    _FileService_GetPublic_Handler,
 		},
 		{
-			MethodName: "GetFileCost",
-			Handler:    _FileService_GetFileCost_Handler,
+			MethodName: "Cost",
+			Handler:    _FileService_Cost_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},
diff --git a/llms-full.txt b/llms-full.txt
index b2f66f9..dda1e0e 100644
--- a/llms-full.txt
+++ b/llms-full.txt
@@ -650,23 +650,26 @@ client := antd.NewClient(antd.DefaultBaseURL)        // localhost:8082
 // Health
 func (c *Client) Health(ctx context.Context) (*HealthStatus, error)
 
-// Data
-func (c *Client) DataPutPublic(ctx context.Context, data []byte) (*PutResult, error)
+// PaymentMode is a typed enum passed to every put/cost method.
+// antd.PaymentModeAuto | antd.PaymentModeMerkle | antd.PaymentModeSingle
+
+// Data — private = unqualified verb, public = _public suffix.
+func (c *Client) DataPut(ctx context.Context, data []byte, paymentMode PaymentMode) (*DataPutResult, error)
+func (c *Client) DataGet(ctx context.Context, dataMap string) ([]byte, error)
+func (c *Client) DataPutPublic(ctx context.Context, data []byte, paymentMode PaymentMode) (*DataPutPublicResult, error)
 func (c *Client) DataGetPublic(ctx context.Context, address string) ([]byte, error)
-func (c *Client) DataPutPrivate(ctx context.Context, data []byte) (*PutResult, error)
-func (c *Client) DataGetPrivate(ctx context.Context, dataMap string) ([]byte, error)
-func (c *Client) DataCost(ctx context.Context, data []byte) (*UploadCostEstimate, error)
+func (c *Client) DataCost(ctx context.Context, data []byte, paymentMode PaymentMode) (*UploadCostEstimate, error)
 
-// Chunks
+// Chunks (no payment_mode — single-chunk primitive, no batch to optimize)
 func (c *Client) ChunkPut(ctx context.Context, data []byte) (*PutResult, error)
 func (c *Client) ChunkGet(ctx context.Context, address string) ([]byte, error)
 
-
-
 // Files
-func (c *Client) FileUploadPublic(ctx context.Context, path string) (*PutResult, error)
-func (c *Client) FileDownloadPublic(ctx context.Context, address string, destPath string) error
-func (c *Client) FileCost(ctx context.Context, path string, isPublic bool) (*UploadCostEstimate, error)
+func (c *Client) FilePut(ctx context.Context, path string, paymentMode PaymentMode) (*FilePutResult, error)
+func (c *Client) FileGet(ctx context.Context, dataMap string, destPath string) error
+func (c *Client) FilePutPublic(ctx context.Context, path string, paymentMode PaymentMode) (*FilePutPublicResult, error)
+func (c *Client) FileGetPublic(ctx context.Context, address string, destPath string) error
+func (c *Client) FileCost(ctx context.Context, path string, isPublic bool, paymentMode PaymentMode) (*UploadCostEstimate, error)
 
 // Wallet
 func (c *Client) WalletAddress(ctx context.Context) (*WalletAddress, error)
diff --git a/llms.txt b/llms.txt
index f8f73f2..3935225 100644
--- a/llms.txt
+++ b/llms.txt
@@ -86,7 +86,7 @@ data = client.data_get_public(result.address)
 
 ## Examples
 
-- [Go examples](antd-go/examples/) — 5 runnable examples (01-connect through 05-files)
+- [Go examples](antd-go/examples/) — 4 runnable examples (01-connect, 02-data, 03-files, 07-external-signer)
 - [JS/TS examples](antd-js/examples/) — 10 runnable scripts (01-connect.ts through 10-private-data.ts)
 - [Python examples](antd-py/examples/) — 10 runnable scripts (01_connect.py through 10_private_data.py)
 - [C# examples](antd-csharp/Examples/) — 10 examples in a single console app