feat(lib/runtime): Implement ext_offchain_http_request_add_header_version_1 host function

lib/runtime/constants.go

@@ -47,7 +47,7 @@ const (
 	// v0.9 test API wasm
 	HOST_API_TEST_RUNTIME     = "hostapi_runtime"
 	HOST_API_TEST_RUNTIME_FP  = "hostapi_runtime.compact.wasm"
-	HOST_API_TEST_RUNTIME_URL = "https://github.com/ChainSafe/polkadot-spec/blob/b94d8c58ad6ea8bf827b0cae1645a999719c2bc7/test/runtimes/hostapi/hostapi_runtime.compact.wasm?raw=true"
+	HOST_API_TEST_RUNTIME_URL = "https://github.com/ChainSafe/polkadot-spec/blob/7edb16fa9df0b93e59489bf85d958a564d2787ec/test/runtimes/hostapi/hostapi_runtime.compact.wasm?raw=true"
 
 	// v0.8 substrate runtime with modified name and babe C=(1, 1)
 	DEV_RUNTIME     = "dev_runtime"

lib/runtime/offchain/httpset.go

@@ -2,6 +2,7 @@ package offchain
 
 import (
 	"errors"
+	"fmt"
 	"net/http"
 	"sync"
 )
@@ -12,6 +13,9 @@ var (
 	errIntBufferEmpty        = errors.New("int buffer exhausted")
 	errIntBufferFull         = errors.New("int buffer is full")
 	errRequestIDNotAvailable = errors.New("request id not available")
+	errInvalidRequest        = errors.New("request is invalid")
+	errRequestAlreadyStarted = errors.New("request has already started")
+	errInvalidHeaderKey      = errors.New("invalid header key")
 )
 
 // requestIDBuffer created to control the amount of available non-duplicated ids
@@ -45,10 +49,35 @@ func (b requestIDBuffer) put(i int16) error {
 	}
 }
 
+// Request holds the request object and update the invalid and waiting status whenever
+// the request starts or is waiting to be read
+type Request struct {
+	Request          *http.Request
+	invalid, waiting bool
+}
+
+// AddHeader add a new header into @req property only if request is valid or has not started yet
+func (r *Request) AddHeader(k, v string) error {
+	if r.invalid {
+		return errInvalidRequest
+	}
+
+	if r.waiting {
+		return errRequestAlreadyStarted
+	}
+
+	if k == "" {
+		return fmt.Errorf("%w: %s", errInvalidHeaderKey, "empty header key")
+	}
+
+	r.Request.Header.Add(k, v)
+	return nil
+}
+
 // HTTPSet holds a pool of concurrent http request calls
 type HTTPSet struct {
 	*sync.Mutex
-	reqs   map[int16]*http.Request
+	reqs   map[int16]*Request
 	idBuff requestIDBuffer
 }
 
@@ -57,7 +86,7 @@ type HTTPSet struct {
 func NewHTTPSet() *HTTPSet {
 	return &HTTPSet{
 		new(sync.Mutex),
-		make(map[int16]*http.Request),
+		make(map[int16]*Request),
 		newIntBuffer(maxConcurrentRequests),
 	}
 }
@@ -82,7 +111,12 @@ func (p *HTTPSet) StartRequest(method, uri string) (int16, error) {
 		return 0, err
 	}
 
-	p.reqs[id] = req
+	p.reqs[id] = &Request{
+		Request: req,
+		invalid: false,
+		waiting: false,
+	}
+
 	return id, nil
 }
 
@@ -97,7 +131,7 @@ func (p *HTTPSet) Remove(id int16) error {
 }
 
 // Get returns a request or nil if request not found
-func (p *HTTPSet) Get(id int16) *http.Request {
+func (p *HTTPSet) Get(id int16) *Request {
 	p.Lock()
 	defer p.Unlock()
 

lib/runtime/offchain/httpset_test.go

@@ -1,6 +1,7 @@
 package offchain
 
 import (
+	"fmt"
 	"net/http"
 	"testing"
 
@@ -25,7 +26,7 @@ func TestHTTPSet_StartRequest_NotAvailableID(t *testing.T) {
 	t.Parallel()
 
 	set := NewHTTPSet()
-	set.reqs[1] = &http.Request{}
+	set.reqs[1] = &Request{}
 
 	_, err := set.StartRequest(http.MethodGet, defaultTestURI)
 	require.ErrorIs(t, errRequestIDNotAvailable, err)
@@ -42,6 +43,53 @@ func TestHTTPSetGet(t *testing.T) {
 	req := set.Get(id)
 	require.NotNil(t, req)
 
-	require.Equal(t, http.MethodGet, req.Method)
-	require.Equal(t, defaultTestURI, req.URL.String())
+	require.Equal(t, http.MethodGet, req.Request.Method)
+	require.Equal(t, defaultTestURI, req.Request.URL.String())
+}
+
+func TestOffchainRequest_AddHeader(t *testing.T) {
+	t.Parallel()
+
+	cases := map[string]struct {
+		offReq           Request
+		err              error
+		headerK, headerV string
+	}{
+		"should return invalid request": {
+			offReq: Request{invalid: true},
+			err:    errInvalidRequest,
+		},
+		"should return request already started": {
+			offReq: Request{waiting: true},
+			err:    errRequestAlreadyStarted,
+		},
+		"should add header": {
+			offReq:  Request{Request: &http.Request{Header: make(http.Header)}},
+			headerK: "key",
+			headerV: "value",
+		},
+		"should return invalid empty header": {
+			offReq:  Request{Request: &http.Request{Header: make(http.Header)}},
+			headerK: "",
+			headerV: "value",
+			err:     fmt.Errorf("%w: %s", errInvalidHeaderKey, "empty header key"),
+		},
+	}
+
+	for name, tc := range cases {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			err := tc.offReq.AddHeader(tc.headerK, tc.headerV)
+
+			if tc.err != nil {
+				require.Error(t, err)
+				require.Equal(t, tc.err.Error(), err.Error())
+				return
+			}
+
+			got := tc.offReq.Request.Header.Get(tc.headerK)
+			require.Equal(t, tc.headerV, got)
+		})
+	}
 }

lib/runtime/wasmer/imports.go

@@ -90,6 +90,7 @@ package wasmer
 // extern int64_t ext_offchain_timestamp_version_1(void *context);
 // extern void ext_offchain_sleep_until_version_1(void *context, int64_t a);
 // extern int64_t ext_offchain_http_request_start_version_1(void *context, int64_t a, int64_t b, int64_t c);
+// extern int64_t ext_offchain_http_request_add_header_version_1(void *context, int32_t a, int64_t k, int64_t v);
 //
 // extern void ext_storage_append_version_1(void *context, int64_t a, int64_t b);
 // extern int64_t ext_storage_changes_root_version_1(void *context, int64_t a);
@@ -1742,6 +1743,32 @@ func ext_offchain_http_request_start_version_1(context unsafe.Pointer, methodSpa
 	return C.int64_t(ptr)
 }
 
+//export ext_offchain_http_request_add_header_version_1
+func ext_offchain_http_request_add_header_version_1(context unsafe.Pointer, reqID C.int32_t, keySpan, valueSpan C.int64_t) C.int64_t {
+	logger.Debug("executing...")
+	instanceContext := wasm.IntoInstanceContext(context)
+
+	key := asMemorySlice(instanceContext, keySpan)
+	value := asMemorySlice(instanceContext, valueSpan)
+
+	runtimeCtx := instanceContext.Data().(*runtime.Context)
+	offchainReq := runtimeCtx.OffchainHTTPSet.Get(int16(reqID))
+
+	result := scale.NewResult(nil, nil)
+	err := offchainReq.AddHeader(string(key), string(value))
+	if err != nil {
+		logger.Errorf("failed to add request header: %s", err)
+		_ = result.Set(scale.Err, nil)
+	} else {
+		_ = result.Set(scale.OK, nil)
+	}
+
+	enc, _ := scale.Marshal(result)
+	ptr, _ := toWasmMemory(instanceContext, enc)
+
+	return C.int64_t(ptr)
+}
+
 func storageAppend(storage runtime.Storage, key, valueToAppend []byte) error {
 	nextLength := big.NewInt(1)
 	var valueRes []byte
@@ -2414,6 +2441,10 @@ func ImportsNodeRuntime() (*wasm.Imports, error) { //nolint
 	if err != nil {
 		return nil, err
 	}
+	_, err = imports.Append("ext_offchain_http_request_add_header_version_1", ext_offchain_http_request_add_header_version_1, C.ext_offchain_http_request_add_header_version_1)
+	if err != nil {
+		return nil, err
+	}
 	_, err = imports.Append("ext_sandbox_instance_teardown_version_1", ext_sandbox_instance_teardown_version_1, C.ext_sandbox_instance_teardown_version_1)
 	if err != nil {
 		return nil, err

lib/runtime/wasmer/imports_test.go

@@ -20,6 +20,7 @@ import (
 	"bytes"
 	"encoding/binary"
 	"io/ioutil"
+	"net/http"
 	"os"
 	"sort"
 	"testing"
@@ -296,6 +297,76 @@ func Test_ext_offchain_http_request_start_version_1(t *testing.T) {
 	require.Equal(t, int16(3), requestNumber)
 }
 
+func Test_ext_offchain_http_request_add_header(t *testing.T) {
+	t.Parallel()
+
+	inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME)
+
+	cases := map[string]struct {
+		key, value  string
+		expectedErr bool
+	}{
+		"should add headers without problems": {
+			key:         "SOME_HEADER_KEY",
+			value:       "SOME_HEADER_VALUE",
+			expectedErr: false,
+		},
+
+		"should return a result error": {
+			key:         "",
+			value:       "",
+			expectedErr: true,
+		},
+	}
+
+	for tname, tcase := range cases {
+		t.Run(tname, func(t *testing.T) {
+			t.Parallel()
+
+			reqID, err := inst.ctx.OffchainHTTPSet.StartRequest(http.MethodGet, "http://uri.example")
+			require.NoError(t, err)
+
+			encID, err := scale.Marshal(uint32(reqID))
+			require.NoError(t, err)
+
+			encHeaderKey, err := scale.Marshal(tcase.key)
+			require.NoError(t, err)
+
+			encHeaderValue, err := scale.Marshal(tcase.value)
+			require.NoError(t, err)
+
+			params := append([]byte{}, encID...)
+			params = append(params, encHeaderKey...)
+			params = append(params, encHeaderValue...)
+
+			ret, err := inst.Exec("rtm_ext_offchain_http_request_add_header_version_1", params)
+			require.NoError(t, err)
+
+			gotResult := scale.NewResult(nil, nil)
+			err = scale.Unmarshal(ret, &gotResult)
+			require.NoError(t, err)
+
+			ok, err := gotResult.Unwrap()
+			if tcase.expectedErr {
+				require.Error(t, err)
+
+				offchainReq := inst.ctx.OffchainHTTPSet.Get(reqID)
+				gotValue := offchainReq.Request.Header.Get(tcase.key)
+				require.Empty(t, gotValue)
+
+			} else {
+				require.NoError(t, err)
+
+				offchainReq := inst.ctx.OffchainHTTPSet.Get(reqID)
+				gotValue := offchainReq.Request.Header.Get(tcase.key)
+				require.Equal(t, tcase.value, gotValue)
+			}
+
+			require.Nil(t, ok)
+		})
+	}
+}
+
 func Test_ext_storage_clear_prefix_version_1_hostAPI(t *testing.T) {
 	t.Parallel()
 	inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME)