max: add rewards api and example

examples/max-rewards/main.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+
+	maxapi "github.com/c9s/bbgo/pkg/exchange/max/maxapi"
+)
+
+func main() {
+
+	key := os.Getenv("MAX_API_KEY")
+	secret := os.Getenv("MAX_API_SECRET")
+
+	api := maxapi.NewRestClient(maxapi.ProductionAPIURL)
+	api.Auth(key, secret)
+
+	ctx := context.Background()
+
+	var req *maxapi.RewardsRequest
+
+	if len(os.Args) > 1 {
+		pathType := os.Args[1]
+		rewardType, err := maxapi.ParseRewardType(pathType)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		req = api.RewardService.NewRewardsByTypeRequest(rewardType)
+	} else {
+		req = api.RewardService.NewRewardsRequest()
+	}
+	// req.From(1613931192)
+	// req.From(1613240048)
+
+	rewards, err := req.Do(ctx)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for _, reward := range rewards {
+		log.Printf("%+v\n", reward)
+	}
+}

pkg/exchange/max/maxapi/datatype.go

@@ -0,0 +1,22 @@
+package max
+
+import (
+	"encoding/json"
+	"time"
+)
+
+type Timestamp time.Time
+
+func (t Timestamp) String() string {
+	return time.Time(t).String()
+}
+
+func (t *Timestamp) UnmarshalJSON(o []byte) error {
+	var timestamp int64
+	if err := json.Unmarshal(o, &timestamp); err != nil {
+		return err
+	}
+
+	*t = Timestamp(time.Unix(timestamp, 0))
+	return nil
+}

pkg/exchange/max/maxapi/restapi.go

@@ -62,6 +62,7 @@ type RestClient struct {
 	PublicService  *PublicService
 	TradeService   *TradeService
 	OrderService   *OrderService
+	RewardService  *RewardService
 	// OrderBookService *OrderBookService
 	// MaxTokenService  *MaxTokenService
 	// MaxKLineService  *KLineService
@@ -83,10 +84,9 @@ func NewRestClientWithHttpClient(baseURL string, httpClient *http.Client) *RestC
 	client.TradeService = &TradeService{client}
 	client.PublicService = &PublicService{client}
 	client.OrderService = &OrderService{client}
-	// client.OrderBookService = &OrderBookService{client}
+	client.RewardService = &RewardService{client}
+
 	// client.MaxTokenService = &MaxTokenService{client}
-	// client.MaxKLineService = &KLineService{client}
-	// client.CreditService = &CreditService{client}
 	client.initNonce()
 	return client
 }

pkg/exchange/max/maxapi/reward.go

@@ -0,0 +1,145 @@
+package max
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+type RewardType string
+
+const (
+	RewardAirdrop    = RewardType("airdrop_reward")
+	RewardCommission = RewardType("commission")
+	RewardHolding    = RewardType("holding_reward")
+	RewardMining     = RewardType("mining_reward")
+	RewardTrading    = RewardType("trading_reward")
+	RewardVipRebate  = RewardType("vip_rebate")
+)
+
+func ParseRewardType(s string) (RewardType, error) {
+	switch s {
+	case "airdrop_reward":
+		return RewardAirdrop, nil
+	case "commission":
+		return RewardCommission, nil
+	case "holding_reward":
+		return RewardHolding, nil
+	case "mining_reward":
+		return RewardMining, nil
+	case "trading_reward":
+		return RewardTrading, nil
+	case "vip_rebate":
+		return RewardVipRebate, nil
+
+	}
+
+	return RewardType(""), fmt.Errorf("unknown reward type: %s", s)
+}
+
+func (t *RewardType) UnmarshalJSON(o []byte) error {
+	var s string
+	var err = json.Unmarshal(o, &s)
+	if err != nil {
+		return err
+	}
+
+	rt, err := ParseRewardType(s)
+	if err != nil {
+		return err
+	}
+
+	*t = rt
+	return nil
+}
+
+type Reward struct {
+	UUID     string     `json:"uuid"`
+	Type     RewardType `json:"type"`
+	Currency string     `json:"currency"`
+	Amount   string     `json:"amount"`
+	State    string     `json:"state"`
+	Note     string     `json:"note"`
+
+	// Unix timestamp in seconds
+	CreatedAt Timestamp `json:"created_at"`
+}
+
+type RewardService struct {
+	client *RestClient
+}
+
+func (s *RewardService) NewRewardsRequest() *RewardsRequest {
+	return &RewardsRequest{client: s.client}
+}
+
+func (s *RewardService) NewRewardsByTypeRequest(pathType RewardType) *RewardsRequest {
+	return &RewardsRequest{client: s.client, pathType: &pathType}
+}
+
+type RewardsRequest struct {
+	client *RestClient
+
+	pathType *RewardType
+
+	currency *string
+
+	// From Unix-timestamp
+	from *int64
+
+	// To Unix-timestamp
+	to *int64
+}
+
+func (r *RewardsRequest) Currency(currency string) *RewardsRequest {
+	r.currency = &currency
+	return r
+}
+
+func (r *RewardsRequest) From(from int64) *RewardsRequest {
+	r.from = &from
+	return r
+}
+
+func (r *RewardsRequest) To(to int64) *RewardsRequest {
+	r.to = &to
+	return r
+}
+
+func (r *RewardsRequest) Do(ctx context.Context) (rewards []Reward, err error) {
+	payload := map[string]interface{}{}
+
+	if r.currency != nil {
+		payload["currency"] = r.currency
+	}
+
+	if r.to != nil {
+		payload["to"] = r.to
+	}
+
+	if r.from != nil {
+		payload["from"] = r.from
+	}
+
+	refURL := "v2/rewards"
+
+	if r.pathType != nil {
+		refURL += "/" + string(*r.pathType)
+	}
+
+	req, err := r.client.newAuthenticatedRequest("GET", refURL, payload)
+	if err != nil {
+		return rewards, err
+	}
+
+	response, err := r.client.sendRequest(req)
+	if err != nil {
+		return rewards, err
+	}
+
+	if err := response.DecodeJSON(&rewards); err != nil {
+		return rewards, err
+	}
+
+	return rewards, err
+}