feat(clients/gateway): Add content compression to gateway POSTs (#3505)

* feat(gateway): Add content compression to gateway POSTs

* feat: gzip-compress payloads > 1KB

* refactor: extract gzip code into a function

* refactor(clients): some minor improvmenets

---------

Co-authored-by: Rodrigo <rodrodpino@gmail.com>

Author: brbrr

clients/gateway/gateway.go

@@ -2,6 +2,7 @@ package gateway
 
 import (
 	"bytes"
+	"compress/gzip"
 	"context"
 	"encoding/json"
 	"errors"
@@ -39,6 +40,9 @@ var (
 	InvalidProof                      ErrorCode = "StarknetErrorCode.INVALID_PROOF"
 )
 
+// Payload size threshold for Gzip compression. 1KB
+const gzipMinSize = 1024
+
 type Client struct {
 	url       string
 	client    *http.Client
@@ -79,13 +83,31 @@ func newTestServer(t *testing.T) *httptest.Server {
 		assert.Equal(t, []string{"API_KEY"}, r.Header["X-Throttling-Bypass"])
 		assert.Equal(t, []string{"Juno/v0.0.1-test Starknet Implementation"}, r.Header["User-Agent"])
 
-		b, err := io.ReadAll(r.Body)
+		var bodyReader io.Reader = r.Body
+		isGzip := r.Header.Get("Content-Encoding") == "gzip"
+		if isGzip {
+			gzReader, gzErr := gzip.NewReader(r.Body)
+			if gzErr != nil {
+				w.WriteHeader(http.StatusBadRequest)
+				w.Write([]byte(gzErr.Error())) //nolint:errcheck // That's fine for the test server
+				return
+			}
+			defer gzReader.Close()
+			bodyReader = gzReader
+		}
+
+		b, err := io.ReadAll(bodyReader)
 		if err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte(err.Error())) //nolint:errcheck
 			return
 		}
 
+		// Assert that large payloads are gzip-compressed
+		if len(b) >= gzipMinSize {
+			assert.True(t, isGzip, "expected Content-Encoding: gzip for payload of size %d", len(b))
+		}
+
 		// empty request: "{}"
 		emptyReqLen := 4
 		if string(b) == "null" {
@@ -97,7 +119,8 @@ func newTestServer(t *testing.T) *httptest.Server {
 			return
 		}
 
-		hash := new(felt.Felt).SetBytes([]byte("random"))
+		// todo(rdr): consider using a random generator here
+		hash := felt.FromBytes[felt.Felt]([]byte("random"))
 		resp := fmt.Sprintf("{\"code\": \"TRANSACTION_RECEIVED\", \"transaction_hash\": %q, \"address\": %q}", hash.String(), hash.String())
 		w.Write([]byte(resp)) //nolint:errcheck
 	}))
@@ -147,17 +170,25 @@ func (c *Client) post(ctx context.Context, url string, data any) ([]byte, error)
 // doPost performs a "POST" http request with the given URL and a JSON payload derived from the provided data
 // it returns response without additional error handling
 func (c *Client) doPost(ctx context.Context, url string, data any) (*http.Response, error) {
-	body, err := json.Marshal(data)
+	jsonBody, err := json.Marshal(data)
+	if err != nil {
+		return nil, err
+	}
+
+	bodyReader, compressed, err := prepareRequestBody(jsonBody)
 	if err != nil {
 		return nil, err
 	}
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bodyReader)
 	if err != nil {
 		return nil, err
 	}
 
 	req.Header.Set("Content-Type", "application/json")
+	if compressed {
+		req.Header.Set("Content-Encoding", "gzip")
+	}
 	if c.userAgent != "" {
 		req.Header.Set("User-Agent", c.userAgent)
 	}
@@ -173,6 +204,23 @@ func (c *Client) doPost(ctx context.Context, url string, data any) (*http.Respon
 	return resp, nil
 }
 
+func prepareRequestBody(jsonBody []byte) (io.Reader, bool, error) {
+	if len(jsonBody) <= gzipMinSize {
+		return bytes.NewReader(jsonBody), false, nil
+	}
+
+	var buf bytes.Buffer
+	gzWriter := gzip.NewWriter(&buf)
+	if _, err := gzWriter.Write(jsonBody); err != nil {
+		return nil, false, fmt.Errorf("writing gzip content: %w", err)
+	}
+	if err := gzWriter.Close(); err != nil {
+		return nil, false, fmt.Errorf("closing gzip writer: %w", err)
+	}
+
+	return &buf, true, nil
+}
+
 type ErrorCode string
 
 type Error struct {

clients/gateway/gateway_test.go

@@ -2,6 +2,7 @@ package gateway_test
 
 import (
 	"encoding/json"
+	"fmt"
 	"testing"
 
 	"github.com/NethermindEth/juno/clients/gateway"
@@ -25,6 +26,34 @@ func TestAddInvokeTx(t *testing.T) {
 		assert.NoError(t, err)
 	})
 
+	t.Run("Large requests are gzip compressed", func(t *testing.T) {
+		largeCalldata := make([]string, 200)
+		for i := range largeCalldata {
+			largeCalldata[i] = "0xcafebabe"
+		}
+
+		calldataJSON, err := json.Marshal(largeCalldata)
+		require.NoError(t, err)
+
+		invokeTx := fmt.Sprintf(
+			`{
+				"max_fee":"0x1",
+				"version":"0x1",
+				"signature":[],
+				"nonce":"0x1",
+				"type":"INVOKE",
+				"sender_address":"0x326e3db4580b94948ca9d1d87fa359f2fa047a31a34757734a86aa4231fb9bb",
+				"calldata": %s 
+			}`,
+			calldataJSON,
+		)
+		invokeTxBytes, err := json.Marshal(invokeTx)
+		require.NoError(t, err)
+
+		_, err = client.AddTransaction(t.Context(), invokeTxBytes)
+		assert.NoError(t, err)
+	})
+
 	t.Run("Incorrect empty request", func(t *testing.T) {
 		invokeTx := "{}"
 		invokeTxByte, err := json.Marshal(invokeTx)