From be985da2afe80b01a6783a7a35ece3c88a32c459 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E3=81=AA=E3=82=8B=E3=81=BF?= Date: Sun, 3 Apr 2022 12:13:29 +0800 Subject: [PATCH] Add Glassnode API --- pkg/glassnode/addresses.go | 17 ++ pkg/glassnode/addresses_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/blockchain.go | 17 ++ .../blockchain_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/client.go | 140 +++++++++++++ pkg/glassnode/defi.go | 17 ++ pkg/glassnode/defi_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/derivatives.go | 17 ++ .../derivatives_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/distribution.go | 17 ++ .../distribution_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/entities.go | 17 ++ pkg/glassnode/entities_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/eth2.go | 17 ++ pkg/glassnode/eth_2_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/fees.go | 17 ++ pkg/glassnode/fees_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/indicators.go | 17 ++ .../indicators_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/institutions.go | 17 ++ .../institutions_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/lightning.go | 17 ++ pkg/glassnode/lightning_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/market.go | 17 ++ pkg/glassnode/market_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/mempool.go | 17 ++ pkg/glassnode/mempool_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/mining.go | 17 ++ pkg/glassnode/mining_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/protocols.go | 17 ++ pkg/glassnode/protocols_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/supply.go | 17 ++ pkg/glassnode/supply_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/transactions.go | 17 ++ .../transactions_request_requestgen.go | 196 ++++++++++++++++++ pkg/glassnode/types.go | 66 ++++++ 36 files changed, 3827 insertions(+) create mode 100644 pkg/glassnode/addresses.go create mode 100644 pkg/glassnode/addresses_request_requestgen.go create mode 100644 pkg/glassnode/blockchain.go create mode 100644 pkg/glassnode/blockchain_request_requestgen.go create mode 100644 pkg/glassnode/client.go create mode 100644 pkg/glassnode/defi.go create mode 100644 pkg/glassnode/defi_request_requestgen.go create mode 100644 pkg/glassnode/derivatives.go create mode 100644 pkg/glassnode/derivatives_request_requestgen.go create mode 100644 pkg/glassnode/distribution.go create mode 100644 pkg/glassnode/distribution_request_requestgen.go create mode 100644 pkg/glassnode/entities.go create mode 100644 pkg/glassnode/entities_request_requestgen.go create mode 100644 pkg/glassnode/eth2.go create mode 100644 pkg/glassnode/eth_2_request_requestgen.go create mode 100644 pkg/glassnode/fees.go create mode 100644 pkg/glassnode/fees_request_requestgen.go create mode 100644 pkg/glassnode/indicators.go create mode 100644 pkg/glassnode/indicators_request_requestgen.go create mode 100644 pkg/glassnode/institutions.go create mode 100644 pkg/glassnode/institutions_request_requestgen.go create mode 100644 pkg/glassnode/lightning.go create mode 100644 pkg/glassnode/lightning_request_requestgen.go create mode 100644 pkg/glassnode/market.go create mode 100644 pkg/glassnode/market_request_requestgen.go create mode 100644 pkg/glassnode/mempool.go create mode 100644 pkg/glassnode/mempool_request_requestgen.go create mode 100644 pkg/glassnode/mining.go create mode 100644 pkg/glassnode/mining_request_requestgen.go create mode 100644 pkg/glassnode/protocols.go create mode 100644 pkg/glassnode/protocols_request_requestgen.go create mode 100644 pkg/glassnode/supply.go create mode 100644 pkg/glassnode/supply_request_requestgen.go create mode 100644 pkg/glassnode/transactions.go create mode 100644 pkg/glassnode/transactions_request_requestgen.go create mode 100644 pkg/glassnode/types.go diff --git a/pkg/glassnode/addresses.go b/pkg/glassnode/addresses.go new file mode 100644 index 000000000..3a937c2ca --- /dev/null +++ b/pkg/glassnode/addresses.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type AddressesRequest -url "/v1/metrics/addresses/:metric" -responseType Response +type AddressesRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/addresses_request_requestgen.go b/pkg/glassnode/addresses_request_requestgen.go new file mode 100644 index 000000000..3d7ee1cea --- /dev/null +++ b/pkg/glassnode/addresses_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type AddressesRequest -url /v1/metrics/addresses/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (a *AddressesRequest) SetAsset(Asset string) *AddressesRequest { + a.Asset = Asset + return a +} + +func (a *AddressesRequest) SetSince(Since int64) *AddressesRequest { + a.Since = Since + return a +} + +func (a *AddressesRequest) SetUntil(Until int64) *AddressesRequest { + a.Until = Until + return a +} + +func (a *AddressesRequest) SetInterval(Interval Interval) *AddressesRequest { + a.Interval = Interval + return a +} + +func (a *AddressesRequest) SetFormat(Format Format) *AddressesRequest { + a.Format = Format + return a +} + +func (a *AddressesRequest) SetTimestampFormat(TimestampFormat string) *AddressesRequest { + a.TimestampFormat = TimestampFormat + return a +} + +func (a *AddressesRequest) SetMetric(Metric string) *AddressesRequest { + a.Metric = Metric + return a +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (a *AddressesRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := a.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := a.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := a.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := a.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := a.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := a.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (a *AddressesRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (a *AddressesRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := a.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (a *AddressesRequest) GetParametersJSON() ([]byte, error) { + params, err := a.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (a *AddressesRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := a.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (a *AddressesRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (a *AddressesRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := a.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (a *AddressesRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := a.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/addresses/:metric" + slugs, err := a.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = a.applySlugsToUrl(apiURL, slugs) + + req, err := a.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := a.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/blockchain.go b/pkg/glassnode/blockchain.go new file mode 100644 index 000000000..aa5630193 --- /dev/null +++ b/pkg/glassnode/blockchain.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type BlockchainRequest -url "/v1/metrics/blockchain/:metric" -responseType Response +type BlockchainRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/blockchain_request_requestgen.go b/pkg/glassnode/blockchain_request_requestgen.go new file mode 100644 index 000000000..59f73e5c1 --- /dev/null +++ b/pkg/glassnode/blockchain_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type BlockchainRequest -url /v1/metrics/blockchain/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (b *BlockchainRequest) SetAsset(Asset string) *BlockchainRequest { + b.Asset = Asset + return b +} + +func (b *BlockchainRequest) SetSince(Since int64) *BlockchainRequest { + b.Since = Since + return b +} + +func (b *BlockchainRequest) SetUntil(Until int64) *BlockchainRequest { + b.Until = Until + return b +} + +func (b *BlockchainRequest) SetInterval(Interval Interval) *BlockchainRequest { + b.Interval = Interval + return b +} + +func (b *BlockchainRequest) SetFormat(Format Format) *BlockchainRequest { + b.Format = Format + return b +} + +func (b *BlockchainRequest) SetTimestampFormat(TimestampFormat string) *BlockchainRequest { + b.TimestampFormat = TimestampFormat + return b +} + +func (b *BlockchainRequest) SetMetric(Metric string) *BlockchainRequest { + b.Metric = Metric + return b +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (b *BlockchainRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := b.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := b.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := b.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := b.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := b.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := b.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (b *BlockchainRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (b *BlockchainRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := b.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (b *BlockchainRequest) GetParametersJSON() ([]byte, error) { + params, err := b.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (b *BlockchainRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := b.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (b *BlockchainRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (b *BlockchainRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := b.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (b *BlockchainRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := b.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/blockchain/:metric" + slugs, err := b.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = b.applySlugsToUrl(apiURL, slugs) + + req, err := b.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := b.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/client.go b/pkg/glassnode/client.go new file mode 100644 index 000000000..54195ff87 --- /dev/null +++ b/pkg/glassnode/client.go @@ -0,0 +1,140 @@ +package glassnode + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "net/http" + "net/url" + "time" + + "github.com/c9s/requestgen" +) + +const defaultHTTPTimeout = time.Second * 15 +const glassnodeBaseURL = "https://api.glassnode.com" + +type RestClient struct { + BaseURL *url.URL + Client *http.Client + + apiKey string +} + +func NewClient() *RestClient { + u, err := url.Parse(glassnodeBaseURL) + if err != nil { + panic(err) + } + + client := &RestClient{ + BaseURL: u, + Client: &http.Client{ + Timeout: defaultHTTPTimeout, + }, + } + + return client +} + +func (c *RestClient) Auth(apiKey string) { + c.apiKey = apiKey +} + +func (c *RestClient) NewRequest(ctx context.Context, method string, refURL string, params url.Values, payload interface{}) (*http.Request, error) { + body, err := castPayload(payload) + if err != nil { + return nil, err + } + + rel, err := url.Parse(refURL) + if err != nil { + return nil, err + } + + if params != nil { + rel.RawQuery = params.Encode() + } + + pathURL := c.BaseURL.ResolveReference(rel) + return http.NewRequestWithContext(ctx, method, pathURL.String(), bytes.NewReader(body)) +} + +func (c *RestClient) SendRequest(req *http.Request) (*requestgen.Response, error) { + resp, err := c.Client.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + response, err := requestgen.NewResponse(resp) + if err != nil { + return response, err + } + + // Check error, if there is an error, return the ErrorResponse struct type + if response.IsError() { + return response, errors.New(string(response.Body)) + } + + return response, nil +} + +func (c *RestClient) NewAuthenticatedRequest(ctx context.Context, method, refURL string, params url.Values, payload interface{}) (*http.Request, error) { + rel, err := url.Parse(refURL) + if err != nil { + return nil, err + } + + if params != nil { + rel.RawQuery = params.Encode() + } + + pathURL := c.BaseURL.ResolveReference(rel) + + path := pathURL.Path + if rel.RawQuery != "" { + path += "?" + rel.RawQuery + } + + body, err := castPayload(payload) + if err != nil { + return nil, err + } + + req, err := http.NewRequestWithContext(ctx, method, pathURL.String(), bytes.NewReader(body)) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", "application/json") + req.Header.Add("Accept", "application/json") + + // Build authentication headers + c.attachAuthHeaders(req, method, path, body) + return req, nil +} + +func (c *RestClient) attachAuthHeaders(req *http.Request, method string, path string, body []byte) { + // Attch API Key to header. https://docs.glassnode.com/basic-api/api-key#usage + req.Header.Add("X-Api-Key", c.apiKey) +} + +func castPayload(payload interface{}) ([]byte, error) { + if payload != nil { + switch v := payload.(type) { + case string: + return []byte(v), nil + + case []byte: + return v, nil + + default: + body, err := json.Marshal(v) + return body, err + } + } + + return nil, nil +} diff --git a/pkg/glassnode/defi.go b/pkg/glassnode/defi.go new file mode 100644 index 000000000..e9269800c --- /dev/null +++ b/pkg/glassnode/defi.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type DefiRequest -url "/v1/metrics/defi/:metric" -responseType Response +type DefiRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/defi_request_requestgen.go b/pkg/glassnode/defi_request_requestgen.go new file mode 100644 index 000000000..8f51708ec --- /dev/null +++ b/pkg/glassnode/defi_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type DefiRequest -url /v1/metrics/defi/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (d *DefiRequest) SetAsset(Asset string) *DefiRequest { + d.Asset = Asset + return d +} + +func (d *DefiRequest) SetSince(Since int64) *DefiRequest { + d.Since = Since + return d +} + +func (d *DefiRequest) SetUntil(Until int64) *DefiRequest { + d.Until = Until + return d +} + +func (d *DefiRequest) SetInterval(Interval Interval) *DefiRequest { + d.Interval = Interval + return d +} + +func (d *DefiRequest) SetFormat(Format Format) *DefiRequest { + d.Format = Format + return d +} + +func (d *DefiRequest) SetTimestampFormat(TimestampFormat string) *DefiRequest { + d.TimestampFormat = TimestampFormat + return d +} + +func (d *DefiRequest) SetMetric(Metric string) *DefiRequest { + d.Metric = Metric + return d +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (d *DefiRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := d.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := d.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := d.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := d.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := d.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := d.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (d *DefiRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (d *DefiRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := d.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (d *DefiRequest) GetParametersJSON() ([]byte, error) { + params, err := d.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (d *DefiRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := d.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (d *DefiRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (d *DefiRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := d.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (d *DefiRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := d.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/defi/:metric" + slugs, err := d.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = d.applySlugsToUrl(apiURL, slugs) + + req, err := d.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := d.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/derivatives.go b/pkg/glassnode/derivatives.go new file mode 100644 index 000000000..d6f51e4df --- /dev/null +++ b/pkg/glassnode/derivatives.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type DerivativesRequest -url "/v1/metrics/derivatives/:metric" -responseType Response +type DerivativesRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/derivatives_request_requestgen.go b/pkg/glassnode/derivatives_request_requestgen.go new file mode 100644 index 000000000..3efd49ab0 --- /dev/null +++ b/pkg/glassnode/derivatives_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type DerivativesRequest -url /v1/metrics/derivatives/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (d *DerivativesRequest) SetAsset(Asset string) *DerivativesRequest { + d.Asset = Asset + return d +} + +func (d *DerivativesRequest) SetSince(Since int64) *DerivativesRequest { + d.Since = Since + return d +} + +func (d *DerivativesRequest) SetUntil(Until int64) *DerivativesRequest { + d.Until = Until + return d +} + +func (d *DerivativesRequest) SetInterval(Interval Interval) *DerivativesRequest { + d.Interval = Interval + return d +} + +func (d *DerivativesRequest) SetFormat(Format Format) *DerivativesRequest { + d.Format = Format + return d +} + +func (d *DerivativesRequest) SetTimestampFormat(TimestampFormat string) *DerivativesRequest { + d.TimestampFormat = TimestampFormat + return d +} + +func (d *DerivativesRequest) SetMetric(Metric string) *DerivativesRequest { + d.Metric = Metric + return d +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (d *DerivativesRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := d.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := d.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := d.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := d.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := d.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := d.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (d *DerivativesRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (d *DerivativesRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := d.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (d *DerivativesRequest) GetParametersJSON() ([]byte, error) { + params, err := d.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (d *DerivativesRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := d.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (d *DerivativesRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (d *DerivativesRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := d.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (d *DerivativesRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := d.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/derivatives/:metric" + slugs, err := d.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = d.applySlugsToUrl(apiURL, slugs) + + req, err := d.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := d.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/distribution.go b/pkg/glassnode/distribution.go new file mode 100644 index 000000000..02d847e06 --- /dev/null +++ b/pkg/glassnode/distribution.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type DistributionRequest -url "/v1/metrics/distribution/:metric" -responseType Response +type DistributionRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/distribution_request_requestgen.go b/pkg/glassnode/distribution_request_requestgen.go new file mode 100644 index 000000000..5a066d7a7 --- /dev/null +++ b/pkg/glassnode/distribution_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type DistributionRequest -url /v1/metrics/distribution/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (d *DistributionRequest) SetAsset(Asset string) *DistributionRequest { + d.Asset = Asset + return d +} + +func (d *DistributionRequest) SetSince(Since int64) *DistributionRequest { + d.Since = Since + return d +} + +func (d *DistributionRequest) SetUntil(Until int64) *DistributionRequest { + d.Until = Until + return d +} + +func (d *DistributionRequest) SetInterval(Interval Interval) *DistributionRequest { + d.Interval = Interval + return d +} + +func (d *DistributionRequest) SetFormat(Format Format) *DistributionRequest { + d.Format = Format + return d +} + +func (d *DistributionRequest) SetTimestampFormat(TimestampFormat string) *DistributionRequest { + d.TimestampFormat = TimestampFormat + return d +} + +func (d *DistributionRequest) SetMetric(Metric string) *DistributionRequest { + d.Metric = Metric + return d +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (d *DistributionRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := d.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := d.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := d.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := d.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := d.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := d.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (d *DistributionRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (d *DistributionRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := d.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (d *DistributionRequest) GetParametersJSON() ([]byte, error) { + params, err := d.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (d *DistributionRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := d.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (d *DistributionRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (d *DistributionRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := d.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (d *DistributionRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := d.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/distribution/:metric" + slugs, err := d.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = d.applySlugsToUrl(apiURL, slugs) + + req, err := d.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := d.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/entities.go b/pkg/glassnode/entities.go new file mode 100644 index 000000000..25d0a0101 --- /dev/null +++ b/pkg/glassnode/entities.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type EntitiesRequest -url "/v1/metrics/entities/:metric" -responseType Response +type EntitiesRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/entities_request_requestgen.go b/pkg/glassnode/entities_request_requestgen.go new file mode 100644 index 000000000..c91a1eef8 --- /dev/null +++ b/pkg/glassnode/entities_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type EntitiesRequest -url /v1/metrics/entities/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (e *EntitiesRequest) SetAsset(Asset string) *EntitiesRequest { + e.Asset = Asset + return e +} + +func (e *EntitiesRequest) SetSince(Since int64) *EntitiesRequest { + e.Since = Since + return e +} + +func (e *EntitiesRequest) SetUntil(Until int64) *EntitiesRequest { + e.Until = Until + return e +} + +func (e *EntitiesRequest) SetInterval(Interval Interval) *EntitiesRequest { + e.Interval = Interval + return e +} + +func (e *EntitiesRequest) SetFormat(Format Format) *EntitiesRequest { + e.Format = Format + return e +} + +func (e *EntitiesRequest) SetTimestampFormat(TimestampFormat string) *EntitiesRequest { + e.TimestampFormat = TimestampFormat + return e +} + +func (e *EntitiesRequest) SetMetric(Metric string) *EntitiesRequest { + e.Metric = Metric + return e +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (e *EntitiesRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := e.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := e.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := e.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := e.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := e.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := e.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (e *EntitiesRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (e *EntitiesRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := e.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (e *EntitiesRequest) GetParametersJSON() ([]byte, error) { + params, err := e.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (e *EntitiesRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := e.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (e *EntitiesRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (e *EntitiesRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := e.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (e *EntitiesRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := e.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/entities/:metric" + slugs, err := e.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = e.applySlugsToUrl(apiURL, slugs) + + req, err := e.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := e.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/eth2.go b/pkg/glassnode/eth2.go new file mode 100644 index 000000000..d7b5deb3e --- /dev/null +++ b/pkg/glassnode/eth2.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type ETH2Request -url "/v1/metrics/eth2/:metric" -responseType Response +type ETH2Request struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/eth_2_request_requestgen.go b/pkg/glassnode/eth_2_request_requestgen.go new file mode 100644 index 000000000..17bea7d8f --- /dev/null +++ b/pkg/glassnode/eth_2_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type ETH2Request -url /v1/metrics/eth2/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (e *ETH2Request) SetAsset(Asset string) *ETH2Request { + e.Asset = Asset + return e +} + +func (e *ETH2Request) SetSince(Since int64) *ETH2Request { + e.Since = Since + return e +} + +func (e *ETH2Request) SetUntil(Until int64) *ETH2Request { + e.Until = Until + return e +} + +func (e *ETH2Request) SetInterval(Interval Interval) *ETH2Request { + e.Interval = Interval + return e +} + +func (e *ETH2Request) SetFormat(Format Format) *ETH2Request { + e.Format = Format + return e +} + +func (e *ETH2Request) SetTimestampFormat(TimestampFormat string) *ETH2Request { + e.TimestampFormat = TimestampFormat + return e +} + +func (e *ETH2Request) SetMetric(Metric string) *ETH2Request { + e.Metric = Metric + return e +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (e *ETH2Request) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := e.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := e.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := e.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := e.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := e.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := e.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (e *ETH2Request) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (e *ETH2Request) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := e.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (e *ETH2Request) GetParametersJSON() ([]byte, error) { + params, err := e.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (e *ETH2Request) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := e.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (e *ETH2Request) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (e *ETH2Request) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := e.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (e *ETH2Request) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := e.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/eth2/:metric" + slugs, err := e.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = e.applySlugsToUrl(apiURL, slugs) + + req, err := e.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := e.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/fees.go b/pkg/glassnode/fees.go new file mode 100644 index 000000000..6d215fb63 --- /dev/null +++ b/pkg/glassnode/fees.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type FeesRequest -url "/v1/metrics/fees/:metric" -responseType Response +type FeesRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/fees_request_requestgen.go b/pkg/glassnode/fees_request_requestgen.go new file mode 100644 index 000000000..e269fb8ff --- /dev/null +++ b/pkg/glassnode/fees_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type FeesRequest -url /v1/metrics/fees/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (f *FeesRequest) SetAsset(Asset string) *FeesRequest { + f.Asset = Asset + return f +} + +func (f *FeesRequest) SetSince(Since int64) *FeesRequest { + f.Since = Since + return f +} + +func (f *FeesRequest) SetUntil(Until int64) *FeesRequest { + f.Until = Until + return f +} + +func (f *FeesRequest) SetInterval(Interval Interval) *FeesRequest { + f.Interval = Interval + return f +} + +func (f *FeesRequest) SetFormat(Format Format) *FeesRequest { + f.Format = Format + return f +} + +func (f *FeesRequest) SetTimestampFormat(TimestampFormat string) *FeesRequest { + f.TimestampFormat = TimestampFormat + return f +} + +func (f *FeesRequest) SetMetric(Metric string) *FeesRequest { + f.Metric = Metric + return f +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (f *FeesRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := f.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := f.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := f.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := f.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := f.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := f.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (f *FeesRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (f *FeesRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := f.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (f *FeesRequest) GetParametersJSON() ([]byte, error) { + params, err := f.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (f *FeesRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := f.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (f *FeesRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (f *FeesRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := f.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (f *FeesRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := f.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/fees/:metric" + slugs, err := f.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = f.applySlugsToUrl(apiURL, slugs) + + req, err := f.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := f.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/indicators.go b/pkg/glassnode/indicators.go new file mode 100644 index 000000000..1899b4b10 --- /dev/null +++ b/pkg/glassnode/indicators.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type IndicatorsRequest -url "/v1/metrics/indicators/:metric" -responseType Response +type IndicatorsRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/indicators_request_requestgen.go b/pkg/glassnode/indicators_request_requestgen.go new file mode 100644 index 000000000..858673cf2 --- /dev/null +++ b/pkg/glassnode/indicators_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type IndicatorsRequest -url /v1/metrics/indicators/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (i *IndicatorsRequest) SetAsset(Asset string) *IndicatorsRequest { + i.Asset = Asset + return i +} + +func (i *IndicatorsRequest) SetSince(Since int64) *IndicatorsRequest { + i.Since = Since + return i +} + +func (i *IndicatorsRequest) SetUntil(Until int64) *IndicatorsRequest { + i.Until = Until + return i +} + +func (i *IndicatorsRequest) SetInterval(Interval Interval) *IndicatorsRequest { + i.Interval = Interval + return i +} + +func (i *IndicatorsRequest) SetFormat(Format Format) *IndicatorsRequest { + i.Format = Format + return i +} + +func (i *IndicatorsRequest) SetTimestampFormat(TimestampFormat string) *IndicatorsRequest { + i.TimestampFormat = TimestampFormat + return i +} + +func (i *IndicatorsRequest) SetMetric(Metric string) *IndicatorsRequest { + i.Metric = Metric + return i +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (i *IndicatorsRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := i.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := i.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := i.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := i.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := i.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := i.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (i *IndicatorsRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (i *IndicatorsRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := i.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (i *IndicatorsRequest) GetParametersJSON() ([]byte, error) { + params, err := i.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (i *IndicatorsRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := i.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (i *IndicatorsRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (i *IndicatorsRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := i.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (i *IndicatorsRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := i.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/indicators/:metric" + slugs, err := i.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = i.applySlugsToUrl(apiURL, slugs) + + req, err := i.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := i.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/institutions.go b/pkg/glassnode/institutions.go new file mode 100644 index 000000000..fece291fb --- /dev/null +++ b/pkg/glassnode/institutions.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type InstitutionsRequest -url "/v1/metrics/institutions/:metric" -responseType Response +type InstitutionsRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/institutions_request_requestgen.go b/pkg/glassnode/institutions_request_requestgen.go new file mode 100644 index 000000000..acc40a4b9 --- /dev/null +++ b/pkg/glassnode/institutions_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type InstitutionsRequest -url /v1/metrics/institutions/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (i *InstitutionsRequest) SetAsset(Asset string) *InstitutionsRequest { + i.Asset = Asset + return i +} + +func (i *InstitutionsRequest) SetSince(Since int64) *InstitutionsRequest { + i.Since = Since + return i +} + +func (i *InstitutionsRequest) SetUntil(Until int64) *InstitutionsRequest { + i.Until = Until + return i +} + +func (i *InstitutionsRequest) SetInterval(Interval Interval) *InstitutionsRequest { + i.Interval = Interval + return i +} + +func (i *InstitutionsRequest) SetFormat(Format Format) *InstitutionsRequest { + i.Format = Format + return i +} + +func (i *InstitutionsRequest) SetTimestampFormat(TimestampFormat string) *InstitutionsRequest { + i.TimestampFormat = TimestampFormat + return i +} + +func (i *InstitutionsRequest) SetMetric(Metric string) *InstitutionsRequest { + i.Metric = Metric + return i +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (i *InstitutionsRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := i.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := i.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := i.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := i.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := i.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := i.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (i *InstitutionsRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (i *InstitutionsRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := i.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (i *InstitutionsRequest) GetParametersJSON() ([]byte, error) { + params, err := i.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (i *InstitutionsRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := i.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (i *InstitutionsRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (i *InstitutionsRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := i.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (i *InstitutionsRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := i.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/institutions/:metric" + slugs, err := i.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = i.applySlugsToUrl(apiURL, slugs) + + req, err := i.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := i.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/lightning.go b/pkg/glassnode/lightning.go new file mode 100644 index 000000000..8ab82cb36 --- /dev/null +++ b/pkg/glassnode/lightning.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type LightningRequest -url "/v1/metrics/lightning/:metric" -responseType Response +type LightningRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/lightning_request_requestgen.go b/pkg/glassnode/lightning_request_requestgen.go new file mode 100644 index 000000000..e3103de89 --- /dev/null +++ b/pkg/glassnode/lightning_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type LightningRequest -url /v1/metrics/lightning/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (l *LightningRequest) SetAsset(Asset string) *LightningRequest { + l.Asset = Asset + return l +} + +func (l *LightningRequest) SetSince(Since int64) *LightningRequest { + l.Since = Since + return l +} + +func (l *LightningRequest) SetUntil(Until int64) *LightningRequest { + l.Until = Until + return l +} + +func (l *LightningRequest) SetInterval(Interval Interval) *LightningRequest { + l.Interval = Interval + return l +} + +func (l *LightningRequest) SetFormat(Format Format) *LightningRequest { + l.Format = Format + return l +} + +func (l *LightningRequest) SetTimestampFormat(TimestampFormat string) *LightningRequest { + l.TimestampFormat = TimestampFormat + return l +} + +func (l *LightningRequest) SetMetric(Metric string) *LightningRequest { + l.Metric = Metric + return l +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (l *LightningRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := l.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := l.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := l.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := l.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := l.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := l.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (l *LightningRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (l *LightningRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := l.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (l *LightningRequest) GetParametersJSON() ([]byte, error) { + params, err := l.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (l *LightningRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := l.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (l *LightningRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (l *LightningRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := l.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (l *LightningRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := l.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/lightning/:metric" + slugs, err := l.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = l.applySlugsToUrl(apiURL, slugs) + + req, err := l.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := l.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/market.go b/pkg/glassnode/market.go new file mode 100644 index 000000000..ce9939916 --- /dev/null +++ b/pkg/glassnode/market.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type MarketRequest -url "/v1/metrics/market/:metric" -responseType Response +type MarketRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/market_request_requestgen.go b/pkg/glassnode/market_request_requestgen.go new file mode 100644 index 000000000..33896ccc1 --- /dev/null +++ b/pkg/glassnode/market_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type MarketRequest -url /v1/metrics/market/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (m *MarketRequest) SetAsset(Asset string) *MarketRequest { + m.Asset = Asset + return m +} + +func (m *MarketRequest) SetSince(Since int64) *MarketRequest { + m.Since = Since + return m +} + +func (m *MarketRequest) SetUntil(Until int64) *MarketRequest { + m.Until = Until + return m +} + +func (m *MarketRequest) SetInterval(Interval Interval) *MarketRequest { + m.Interval = Interval + return m +} + +func (m *MarketRequest) SetFormat(Format Format) *MarketRequest { + m.Format = Format + return m +} + +func (m *MarketRequest) SetTimestampFormat(TimestampFormat string) *MarketRequest { + m.TimestampFormat = TimestampFormat + return m +} + +func (m *MarketRequest) SetMetric(Metric string) *MarketRequest { + m.Metric = Metric + return m +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (m *MarketRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := m.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := m.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := m.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := m.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := m.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := m.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (m *MarketRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (m *MarketRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := m.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (m *MarketRequest) GetParametersJSON() ([]byte, error) { + params, err := m.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (m *MarketRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := m.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (m *MarketRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (m *MarketRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := m.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (m *MarketRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := m.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/market/:metric" + slugs, err := m.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = m.applySlugsToUrl(apiURL, slugs) + + req, err := m.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := m.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/mempool.go b/pkg/glassnode/mempool.go new file mode 100644 index 000000000..27cd4e744 --- /dev/null +++ b/pkg/glassnode/mempool.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type MempoolRequest -url "/v1/metrics/mempool/:metric" -responseType Response +type MempoolRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/mempool_request_requestgen.go b/pkg/glassnode/mempool_request_requestgen.go new file mode 100644 index 000000000..8c0f0ff8a --- /dev/null +++ b/pkg/glassnode/mempool_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type MempoolRequest -url /v1/metrics/mempool/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (m *MempoolRequest) SetAsset(Asset string) *MempoolRequest { + m.Asset = Asset + return m +} + +func (m *MempoolRequest) SetSince(Since int64) *MempoolRequest { + m.Since = Since + return m +} + +func (m *MempoolRequest) SetUntil(Until int64) *MempoolRequest { + m.Until = Until + return m +} + +func (m *MempoolRequest) SetInterval(Interval Interval) *MempoolRequest { + m.Interval = Interval + return m +} + +func (m *MempoolRequest) SetFormat(Format Format) *MempoolRequest { + m.Format = Format + return m +} + +func (m *MempoolRequest) SetTimestampFormat(TimestampFormat string) *MempoolRequest { + m.TimestampFormat = TimestampFormat + return m +} + +func (m *MempoolRequest) SetMetric(Metric string) *MempoolRequest { + m.Metric = Metric + return m +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (m *MempoolRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := m.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := m.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := m.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := m.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := m.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := m.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (m *MempoolRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (m *MempoolRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := m.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (m *MempoolRequest) GetParametersJSON() ([]byte, error) { + params, err := m.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (m *MempoolRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := m.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (m *MempoolRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (m *MempoolRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := m.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (m *MempoolRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := m.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/mempool/:metric" + slugs, err := m.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = m.applySlugsToUrl(apiURL, slugs) + + req, err := m.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := m.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/mining.go b/pkg/glassnode/mining.go new file mode 100644 index 000000000..3a72925dd --- /dev/null +++ b/pkg/glassnode/mining.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type MiningRequest -url "/v1/metrics/mining/:metric" -responseType Response +type MiningRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/mining_request_requestgen.go b/pkg/glassnode/mining_request_requestgen.go new file mode 100644 index 000000000..8243d4d9f --- /dev/null +++ b/pkg/glassnode/mining_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type MiningRequest -url /v1/metrics/mining/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (m *MiningRequest) SetAsset(Asset string) *MiningRequest { + m.Asset = Asset + return m +} + +func (m *MiningRequest) SetSince(Since int64) *MiningRequest { + m.Since = Since + return m +} + +func (m *MiningRequest) SetUntil(Until int64) *MiningRequest { + m.Until = Until + return m +} + +func (m *MiningRequest) SetInterval(Interval Interval) *MiningRequest { + m.Interval = Interval + return m +} + +func (m *MiningRequest) SetFormat(Format Format) *MiningRequest { + m.Format = Format + return m +} + +func (m *MiningRequest) SetTimestampFormat(TimestampFormat string) *MiningRequest { + m.TimestampFormat = TimestampFormat + return m +} + +func (m *MiningRequest) SetMetric(Metric string) *MiningRequest { + m.Metric = Metric + return m +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (m *MiningRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := m.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := m.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := m.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := m.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := m.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := m.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (m *MiningRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (m *MiningRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := m.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (m *MiningRequest) GetParametersJSON() ([]byte, error) { + params, err := m.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (m *MiningRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := m.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (m *MiningRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (m *MiningRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := m.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (m *MiningRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := m.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/mining/:metric" + slugs, err := m.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = m.applySlugsToUrl(apiURL, slugs) + + req, err := m.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := m.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/protocols.go b/pkg/glassnode/protocols.go new file mode 100644 index 000000000..e111a88a6 --- /dev/null +++ b/pkg/glassnode/protocols.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type ProtocolsRequest -url "/v1/metrics/protocols/:metric" -responseType Response +type ProtocolsRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/protocols_request_requestgen.go b/pkg/glassnode/protocols_request_requestgen.go new file mode 100644 index 000000000..29bf603dc --- /dev/null +++ b/pkg/glassnode/protocols_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type ProtocolsRequest -url /v1/metrics/protocols/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (p *ProtocolsRequest) SetAsset(Asset string) *ProtocolsRequest { + p.Asset = Asset + return p +} + +func (p *ProtocolsRequest) SetSince(Since int64) *ProtocolsRequest { + p.Since = Since + return p +} + +func (p *ProtocolsRequest) SetUntil(Until int64) *ProtocolsRequest { + p.Until = Until + return p +} + +func (p *ProtocolsRequest) SetInterval(Interval Interval) *ProtocolsRequest { + p.Interval = Interval + return p +} + +func (p *ProtocolsRequest) SetFormat(Format Format) *ProtocolsRequest { + p.Format = Format + return p +} + +func (p *ProtocolsRequest) SetTimestampFormat(TimestampFormat string) *ProtocolsRequest { + p.TimestampFormat = TimestampFormat + return p +} + +func (p *ProtocolsRequest) SetMetric(Metric string) *ProtocolsRequest { + p.Metric = Metric + return p +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (p *ProtocolsRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := p.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := p.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := p.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := p.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := p.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := p.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (p *ProtocolsRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (p *ProtocolsRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := p.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (p *ProtocolsRequest) GetParametersJSON() ([]byte, error) { + params, err := p.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (p *ProtocolsRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := p.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (p *ProtocolsRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (p *ProtocolsRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := p.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (p *ProtocolsRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := p.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/protocols/:metric" + slugs, err := p.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = p.applySlugsToUrl(apiURL, slugs) + + req, err := p.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := p.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/supply.go b/pkg/glassnode/supply.go new file mode 100644 index 000000000..a6ff4c957 --- /dev/null +++ b/pkg/glassnode/supply.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type SupplyRequest -url "/v1/metrics/supply/:metric" -responseType Response +type SupplyRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/supply_request_requestgen.go b/pkg/glassnode/supply_request_requestgen.go new file mode 100644 index 000000000..3d766d060 --- /dev/null +++ b/pkg/glassnode/supply_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type SupplyRequest -url /v1/metrics/supply/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (s *SupplyRequest) SetAsset(Asset string) *SupplyRequest { + s.Asset = Asset + return s +} + +func (s *SupplyRequest) SetSince(Since int64) *SupplyRequest { + s.Since = Since + return s +} + +func (s *SupplyRequest) SetUntil(Until int64) *SupplyRequest { + s.Until = Until + return s +} + +func (s *SupplyRequest) SetInterval(Interval Interval) *SupplyRequest { + s.Interval = Interval + return s +} + +func (s *SupplyRequest) SetFormat(Format Format) *SupplyRequest { + s.Format = Format + return s +} + +func (s *SupplyRequest) SetTimestampFormat(TimestampFormat string) *SupplyRequest { + s.TimestampFormat = TimestampFormat + return s +} + +func (s *SupplyRequest) SetMetric(Metric string) *SupplyRequest { + s.Metric = Metric + return s +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (s *SupplyRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := s.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := s.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := s.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := s.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := s.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := s.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (s *SupplyRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (s *SupplyRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := s.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (s *SupplyRequest) GetParametersJSON() ([]byte, error) { + params, err := s.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (s *SupplyRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := s.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (s *SupplyRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (s *SupplyRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := s.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (s *SupplyRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := s.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/supply/:metric" + slugs, err := s.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = s.applySlugsToUrl(apiURL, slugs) + + req, err := s.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := s.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/transactions.go b/pkg/glassnode/transactions.go new file mode 100644 index 000000000..de5283ab4 --- /dev/null +++ b/pkg/glassnode/transactions.go @@ -0,0 +1,17 @@ +package glassnode + +import "github.com/c9s/requestgen" + +//go:generate requestgen -method GET -type TransactionsRequest -url "/v1/metrics/transactions/:metric" -responseType Response +type TransactionsRequest struct { + Client requestgen.AuthenticatedAPIClient + + Asset string `param:"a,required,query"` + Since int64 `param:"s,query"` + Until int64 `param:"u,query"` + Interval Interval `param:"i,query"` + Format Format `param:"f,query"` + TimestampFormat string `param:"timestamp_format,query"` + + Metric string `param:"metric,slug"` +} diff --git a/pkg/glassnode/transactions_request_requestgen.go b/pkg/glassnode/transactions_request_requestgen.go new file mode 100644 index 000000000..dda52ceca --- /dev/null +++ b/pkg/glassnode/transactions_request_requestgen.go @@ -0,0 +1,196 @@ +// Code generated by "requestgen -method GET -type TransactionsRequest -url /v1/metrics/transactions/:metric -responseType Response"; DO NOT EDIT. + +package glassnode + +import ( + "context" + "encoding/json" + "fmt" + "net/url" + "regexp" +) + +func (t *TransactionsRequest) SetAsset(Asset string) *TransactionsRequest { + t.Asset = Asset + return t +} + +func (t *TransactionsRequest) SetSince(Since int64) *TransactionsRequest { + t.Since = Since + return t +} + +func (t *TransactionsRequest) SetUntil(Until int64) *TransactionsRequest { + t.Until = Until + return t +} + +func (t *TransactionsRequest) SetInterval(Interval Interval) *TransactionsRequest { + t.Interval = Interval + return t +} + +func (t *TransactionsRequest) SetFormat(Format Format) *TransactionsRequest { + t.Format = Format + return t +} + +func (t *TransactionsRequest) SetTimestampFormat(TimestampFormat string) *TransactionsRequest { + t.TimestampFormat = TimestampFormat + return t +} + +func (t *TransactionsRequest) SetMetric(Metric string) *TransactionsRequest { + t.Metric = Metric + return t +} + +// GetQueryParameters builds and checks the query parameters and returns url.Values +func (t *TransactionsRequest) GetQueryParameters() (url.Values, error) { + var params = map[string]interface{}{} + // check Asset field -> json key a + Asset := t.Asset + + // TEMPLATE check-required + if len(Asset) == 0 { + return nil, fmt.Errorf("a is required, empty string given") + } + // END TEMPLATE check-required + + // assign parameter of Asset + params["a"] = Asset + // check Since field -> json key s + Since := t.Since + + // assign parameter of Since + params["s"] = Since + // check Until field -> json key u + Until := t.Until + + // assign parameter of Until + params["u"] = Until + // check Interval field -> json key i + Interval := t.Interval + + // assign parameter of Interval + params["i"] = Interval + // check Format field -> json key f + Format := t.Format + + // assign parameter of Format + params["f"] = Format + // check TimestampFormat field -> json key timestamp_format + TimestampFormat := t.TimestampFormat + + // assign parameter of TimestampFormat + params["timestamp_format"] = TimestampFormat + + query := url.Values{} + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParameters builds and checks the parameters and return the result in a map object +func (t *TransactionsRequest) GetParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + + return params, nil +} + +// GetParametersQuery converts the parameters from GetParameters into the url.Values format +func (t *TransactionsRequest) GetParametersQuery() (url.Values, error) { + query := url.Values{} + + params, err := t.GetParameters() + if err != nil { + return query, err + } + + for k, v := range params { + query.Add(k, fmt.Sprintf("%v", v)) + } + + return query, nil +} + +// GetParametersJSON converts the parameters from GetParameters into the JSON format +func (t *TransactionsRequest) GetParametersJSON() ([]byte, error) { + params, err := t.GetParameters() + if err != nil { + return nil, err + } + + return json.Marshal(params) +} + +// GetSlugParameters builds and checks the slug parameters and return the result in a map object +func (t *TransactionsRequest) GetSlugParameters() (map[string]interface{}, error) { + var params = map[string]interface{}{} + // check Metric field -> json key metric + Metric := t.Metric + + // assign parameter of Metric + params["metric"] = Metric + + return params, nil +} + +func (t *TransactionsRequest) applySlugsToUrl(url string, slugs map[string]string) string { + for k, v := range slugs { + needleRE := regexp.MustCompile(":" + k + "\\b") + url = needleRE.ReplaceAllString(url, v) + } + + return url +} + +func (t *TransactionsRequest) GetSlugsMap() (map[string]string, error) { + slugs := map[string]string{} + params, err := t.GetSlugParameters() + if err != nil { + return slugs, nil + } + + for k, v := range params { + slugs[k] = fmt.Sprintf("%v", v) + } + + return slugs, nil +} + +func (t *TransactionsRequest) Do(ctx context.Context) (Response, error) { + + // no body params + var params interface{} + query, err := t.GetQueryParameters() + if err != nil { + return nil, err + } + + apiURL := "/v1/metrics/transactions/:metric" + slugs, err := t.GetSlugsMap() + if err != nil { + return nil, err + } + + apiURL = t.applySlugsToUrl(apiURL, slugs) + + req, err := t.Client.NewAuthenticatedRequest(ctx, "GET", apiURL, query, params) + if err != nil { + return nil, err + } + + response, err := t.Client.SendRequest(req) + if err != nil { + return nil, err + } + + var apiResponse Response + if err := response.DecodeJSON(&apiResponse); err != nil { + return nil, err + } + return apiResponse, nil +} diff --git a/pkg/glassnode/types.go b/pkg/glassnode/types.go new file mode 100644 index 000000000..e73b72d33 --- /dev/null +++ b/pkg/glassnode/types.go @@ -0,0 +1,66 @@ +package glassnode + +import ( + "encoding/json" + "time" +) + +type Interval string + +const ( + Interval1h Interval = "1h" + Interval24h Interval = "24h" + Interval10m Interval = "10m" + Interval1w Interval = "1w" + Interval1m Interval = "1month" +) + +type Format string + +const ( + FormatJSON Format = "JSON" + FormatCSV Format = "CSV" +) + +type Timestamp time.Time + +func (t Timestamp) Unix() float64 { + return float64(time.Time(t).Unix()) +} + +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, ×tamp); err != nil { + return err + } + + *t = Timestamp(time.Unix(timestamp, 0)) + return nil +} + +// [{"t":1614556800,"v":927789865185.0476}] +type Response []Data +type Data struct { + Timestamp Timestamp `json:"t"` + Value float64 `json:"v"` + Options map[string]float64 `json:"o"` +} + +func (s Response) Last() Data { + if len(s) == 0 { + return Data{} + } + return s[len(s)-1] +} + +func (s Response) LastValue() float64 { + return s.Last().Value +} + +func (s Response) LastOptions() map[string]float64 { + return s.Last().Options +}