feat: working version of submit tx

apis/arc/tx_status.go

@@ -40,3 +40,23 @@ func (s TxStatus) String() string {
 
 	return "Can't parse status"
 }
+
+func MapTxStatusToInt(status TxStatus) (int, bool) {
+	waitForStatusMap := map[TxStatus]int{
+		UNKNOWN:              0,
+		QUEUED:               1,
+		RECEIVED:             2,
+		STORED:               3,
+		ANNOUNCED_TO_NETWORK: 4,
+		REQUESTED_BY_NETWORK: 5,
+		SENT_TO_NETWORK:      6,
+		ACCEPTED_BY_NETWORK:  7,
+		SEEN_ON_NETWORK:      8,
+		MINED:                9,
+		CONFIRMED:            108,
+		REJECTED:             109,
+	}
+
+	value, ok := waitForStatusMap[status]
+	return value, ok
+}

examples/submit_transaction/submit_transaction.go

@@ -16,7 +16,7 @@ func main() {
 	}
 
 	// Select the miner
-	miner := client.MinerByName(minercraft.MinerTaal)
+	miner := client.MinerByName(minercraft.MinerGorillaPool)
 
 	// Submit transaction
 	var response *minercraft.SubmitTransactionResponse

request.go

@@ -86,10 +86,11 @@ type RequestResponse struct {
 
 // httpPayload is used for a httpRequest
 type httpPayload struct {
-	Method string `json:"method"`
-	URL    string `json:"url"`
-	Token  string `json:"token"`
-	Data   []byte `json:"data"`
+	Method  string            `json:"method"`
+	URL     string            `json:"url"`
+	Token   string            `json:"token"`
+	Data    []byte            `json:"data"`
+	Headers map[string]string `json:"headers"`
 }
 
 // httpRequest is a generic request wrapper that can be used without constraints.
@@ -132,6 +133,10 @@ func httpRequest(ctx context.Context, client *Client,
 		return
 	}
 
+	for key, value := range payload.Headers {
+		request.Header.Set(key, value)
+	}
+
 	// Change the header (user agent is in case they block default Go user agents)
 	request.Header.Set("User-Agent", client.Options.UserAgent)
 

submit_transaction.go

@@ -6,8 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
-	"net/url"
-	"strings"
+	"strconv"
 
 	"github.com/tonicpow/go-minercraft/apis/arc"
 	"github.com/tonicpow/go-minercraft/apis/mapi"
@@ -172,12 +171,6 @@ func (c *Client) SubmitTransaction(ctx context.Context, miner *Miner, tx *Transa
 // submitTransaction will fire the HTTP request to submit a transaction
 func submitTransaction(ctx context.Context, client *Client, miner *Miner, tx *Transaction) (*internalResult, error) {
 	result := &internalResult{Miner: miner}
-	data, err := json.Marshal(tx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshall JSON when submitting transaction %w", err)
-	}
-
-	sb := strings.Builder{}
 
 	api, err := MinerAPIByMinerID(client.minerAPIs, miner.MinerID, client.apiType)
 	if err != nil {
@@ -191,22 +184,74 @@ func submitTransaction(ctx context.Context, client *Client, miner *Miner, tx *Tr
 		return nil, err
 	}
 
-	sb.WriteString(api.URL + route)
-	submitURL, err := url.Parse(sb.String())
-	if err != nil {
-		result.Response = &RequestResponse{Error: err}
-		return nil, err
+	submitURL := api.URL + route
+	httpPayload := &httpPayload{
+		Method:  http.MethodPost,
+		URL:     submitURL,
+		Token:   api.Token,
+		Headers: make(map[string]string),
+	}
+
+	switch client.apiType {
+	case MAPI:
+		err = proceedMapi(tx, httpPayload)
+		if err != nil {
+			return nil, err
+		}
+
+	case Arc:
+		err = proceedArc(tx, httpPayload)
+		if err != nil {
+			return nil, err
+		}
+
+	default:
+		return nil, fmt.Errorf("unknown API type: %s", client.apiType)
 	}
 
-	result.Response = httpRequest(ctx, client, &httpPayload{
-		Method: http.MethodPost,
-		URL:    submitURL.String(),
-		Token:  api.Token,
-		Data:   data,
-	})
+	result.Response = httpRequest(ctx, client, httpPayload)
 	return result, nil
 }
 
+func proceedArc(tx *Transaction, httpPayload *httpPayload) error {
+	body := map[string]string{
+		"rawTx": tx.RawTx,
+	}
+	data, err := json.Marshal(body)
+	if err != nil {
+		return fmt.Errorf("failed to marshall JSON when submitting transaction: %w", err)
+	}
+	httpPayload.Data = data
+
+	if tx.MerkleProof {
+		httpPayload.Headers["X-MerkleProof"] = "true"
+	}
+
+	if tx.CallBackURL != "" {
+		httpPayload.Headers["X-CallbackUrl"] = tx.CallBackURL
+	}
+
+	if tx.CallBackToken != "" {
+		httpPayload.Headers["X-CallbackToken"] = tx.CallBackToken
+	}
+
+	if statusCode, ok := arc.MapTxStatusToInt(tx.WaitForStatus); ok {
+		httpPayload.Headers["X-WaitForStatus"] = strconv.Itoa(statusCode)
+	}
+
+	return nil
+}
+
+func proceedMapi(tx *Transaction, httpPayload *httpPayload) error {
+	data, err := json.Marshal(tx)
+	if err != nil {
+		return err
+	}
+
+	httpPayload.Data = data
+	return nil
+}
+
 func (a *SubmitTxMapiAdapter) GetSubmitTxResponse() *UnifiedSubmissionPayload {
 	return &UnifiedSubmissionPayload{
 		APIVersion:                a.APIVersion,