backend: replace ratelimiter with x/time/rate.

Removes the ratelimiter package and replaces its
usages with x/time/rate.

Author: bznein

backend/backend.go

@@ -51,7 +51,6 @@ import (
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/logging"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/observable"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/observable/action"
-	"github.com/BitBoxSwiss/bitbox-wallet-app/util/ratelimit"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/socksproxy"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/ethereum/go-ethereum/params"
@@ -279,7 +278,7 @@ func NewBackend(arguments *arguments.Arguments, environment Environment) (*Backe
 	backend.notifier = notifier
 	backend.socksProxy = backendProxy
 	backend.httpClient = hclient
-	backend.etherScanHTTPClient = ratelimit.FromTransport(hclient.Transport, etherscan.CallInterval)
+	backend.etherScanHTTPClient = hclient
 
 	ratesCache := filepath.Join(arguments.CacheDirectoryPath(), "exchangerates")
 	if err := os.MkdirAll(ratesCache, 0700); err != nil {

backend/coins/eth/etherscan/etherscan.go

@@ -35,11 +35,13 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
+	"golang.org/x/time/rate"
 )
 
-// CallInterval is the duration between etherscan requests.
+// CallsPerSec is thenumber of etherscanr equests allowed
+// per second.
 // Etherscan rate limits to one request per 0.2 seconds.
-var CallInterval = 260 * time.Millisecond
+var CallsPerSec = 3.8
 
 const apiKey = "X3AFAGQT2QCAFTFPIH9VJY88H9PIQ2UWP7"
 
@@ -50,17 +52,22 @@ const ERC20GasErr = "insufficient funds for gas * price + value"
 type EtherScan struct {
 	url        string
 	httpClient *http.Client
+	limiter    *rate.Limiter
 }
 
 // NewEtherScan creates a new instance of EtherScan.
 func NewEtherScan(url string, httpClient *http.Client) *EtherScan {
 	return &EtherScan{
 		url:        url,
 		httpClient: httpClient,
+		limiter:    rate.NewLimiter(rate.Limit(CallsPerSec), 1),
 	}
 }
 
 func (etherScan *EtherScan) call(params url.Values, result interface{}) error {
+	if err := etherScan.limiter.Wait(context.TODO()); err != nil {
+		return errp.WithStack(err)
+	}
 	params.Set("apikey", apiKey)
 	response, err := etherScan.httpClient.Get(etherScan.url + "?" + params.Encode())
 	if err != nil {

backend/rates/gecko.go

@@ -16,21 +16,21 @@ const (
 	maxGeckoRange = 364 * 24 * time.Hour
 )
 
-// apiRateLimit specifies the minimal interval between equally spaced API calls
+// apiRateLimit specifies the maximum number of API calls per second
 // to one of the supported exchange rates providers.
-func apiRateLimit(baseURL string) time.Duration {
+func apiRateLimit(baseURL string) float64 {
 	switch baseURL {
 	default:
-		return time.Second // arbitrary; localhost, staging, etc.
+		return 1 // arbitrary; localhost, staging, etc.
 	case coingeckoAPIV3:
 		// API calls. From https://www.coingecko.com/en/api:
 		// > Generous rate limits with up to 100 requests/minute
 		// We use slightly lower value.
-		return 2 * time.Second
+		return 0.5
 	case shiftGeckoMirrorAPIV3:
 		// Avoid zero to prevent unexpected panics like in time.NewTicker
 		// and leave some room to breathe.
-		return 10 * time.Millisecond
+		return 100
 	}
 }
 

backend/rates/history.go

@@ -278,38 +278,38 @@ func (updater *RateUpdater) fetchGeckoMarketRange(ctx context.Context, coin, fia
 	}
 
 	// Make the call, abiding the upstream rate limits.
-	msg := fmt.Sprintf("fetch coingecko coin=%s fiat=%s start=%s", coin, fiat, timeRange.start)
 	var jsonBody struct{ Prices [][2]float64 } // [timestamp in milliseconds, value]
-	callErr := updater.geckoLimiter.Call(ctx, msg, func() error {
-		param := url.Values{
-			"from":        {strconv.FormatInt(timeRange.start.Unix(), 10)},
-			"to":          {strconv.FormatInt(timeRange.end().Unix(), 10)},
-			"vs_currency": {gfiat},
-		}
-		endpoint := fmt.Sprintf("%s/coins/%s/market_chart/range?%s", updater.coingeckoURL, gcoin, param.Encode())
-		req, err := http.NewRequest(http.MethodGet, endpoint, nil)
-		if err != nil {
-			return err
-		}
+	if err := updater.geckoLimiter.Wait(ctx); err != nil {
+		return nil, err
+	}
 
-		ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
-		defer cancel()
-		res, err := updater.httpClient.Do(req.WithContext(ctx))
-		if err != nil {
-			return err
-		}
-		defer res.Body.Close() //nolint:errcheck
-		if res.StatusCode != http.StatusOK {
-			return fmt.Errorf("fetchGeckoMarketRange: bad response code %d", res.StatusCode)
-		}
-		// 1Mb is more than enough for a single response, but make sure initial
-		// download with empty cache fits here. See maxGeckoRange.
-		return json.NewDecoder(io.LimitReader(res.Body, 1<<20)).Decode(&jsonBody)
-	})
-	if callErr != nil {
-		return nil, callErr
+	param := url.Values{
+		"from":        {strconv.FormatInt(timeRange.start.Unix(), 10)},
+		"to":          {strconv.FormatInt(timeRange.end().Unix(), 10)},
+		"vs_currency": {gfiat},
+	}
+	endpoint := fmt.Sprintf("%s/coins/%s/market_chart/range?%s", updater.coingeckoURL, gcoin, param.Encode())
+	req, err := http.NewRequest(http.MethodGet, endpoint, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel()
+	res, err := updater.httpClient.Do(req.WithContext(ctx))
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close() //nolint:errcheck
+	if res.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("fetchGeckoMarketRange: bad response code %d", res.StatusCode)
 	}
 
+	// 1Mb is more than enough for a single response, but make sure initial
+	// download with empty cache fits here. See maxGeckoRange
+	if err := json.NewDecoder(io.LimitReader(res.Body, 1<<20)).Decode(&jsonBody); err != nil {
+		return nil, err
+	}
 	// Transform the response into a usable result.
 	rates := make([]exchangeRate, len(jsonBody.Prices))
 	for i, v := range jsonBody.Prices {

backend/rates/rates.go

@@ -27,11 +27,12 @@ import (
 	"sync"
 	"time"
 
+	"golang.org/x/time/rate"
+
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/errp"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/logging"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/observable"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/observable/action"
-	"github.com/BitBoxSwiss/bitbox-wallet-app/util/ratelimit"
 	"github.com/sirupsen/logrus"
 	"go.etcd.io/bbolt"
 )
@@ -119,15 +120,15 @@ type RateUpdater struct {
 	// See https://www.coingecko.com/en/api for details.
 	coingeckoURL string
 	// All requests to coingeckoURL are rate-limited using geckoLimiter.
-	geckoLimiter *ratelimit.LimitedCall
+	geckoLimiter *rate.Limiter
 }
 
 // NewRateUpdater returns a new rates updater.
 // The dbdir argument is the location of a historical rates database cache.
 // The returned updater can function without a valid database cache but may be
 // impacted by rate limits. The database cache is transparent to the updater users.
 // To stay within acceptable rate limits defined by CoinGeckoRateLimit, callers can
-// use util/ratelimit package.
+// use https://pkg.go.dev/golang.org/x/time/rate package.
 //
 // Both Last and PriceAt of the newly created updater always return zero values
 // until data is fetched from the external APIs. To make the updater start fetching data
@@ -155,7 +156,7 @@ func NewRateUpdater(client *http.Client, dbdir string) *RateUpdater {
 		log:          log,
 		httpClient:   client,
 		coingeckoURL: apiURL,
-		geckoLimiter: ratelimit.NewLimitedCall(apiRateLimit(apiURL)),
+		geckoLimiter: rate.NewLimiter(rate.Limit(apiRateLimit(apiURL)), 1),
 	}
 }
 
@@ -275,36 +276,42 @@ func (updater *RateUpdater) updateLast(ctx context.Context) {
 	}
 
 	var geckoRates map[string]map[string]float64
-	callErr := updater.geckoLimiter.Call(ctx, "updateLast", func() error {
-		ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
-		defer cancel()
-		res, err := updater.httpClient.Do(req.WithContext(ctx))
-		if err != nil {
-			return errp.WithStack(err)
-		}
-		defer res.Body.Close() //nolint:errcheck
-		if res.StatusCode != http.StatusOK {
-			return errp.Newf("bad response code %d", res.StatusCode)
-		}
-		const max = 10240
-		responseBody, err := io.ReadAll(io.LimitReader(res.Body, max+1))
-		if err != nil {
-			return errp.WithStack(err)
-		}
-		if len(responseBody) > max {
-			return errp.Newf("rates response too long (> %d bytes)", max)
-		}
-		if err := json.Unmarshal(responseBody, &geckoRates); err != nil {
-			return errp.WithMessage(err,
-				fmt.Sprintf("could not parse rates response: %s", string(responseBody)))
-		}
-		return nil
-	})
-	if callErr != nil {
-		updater.log.WithError(callErr).Errorf("updateLast")
+	if err := updater.geckoLimiter.Wait(ctx); err != nil {
+		updater.log.WithError(err).Error("could not wait for rate limiter")
+		updater.last = nil
+		return
+	}
+
+	res, err := updater.httpClient.Do(req.WithContext(ctx))
+	if err != nil {
+		updater.log.WithError(err).Error("could not make request")
+		updater.last = nil
+		return
+	}
+	defer res.Body.Close() //nolint:errcheck
+	if res.StatusCode != http.StatusOK {
+		updater.log.Errorf("bad response code %d", res.StatusCode)
 		updater.last = nil
 		return
 	}
+	const max = 10240
+	responseBody, err := io.ReadAll(io.LimitReader(res.Body, max+1))
+	if err != nil {
+		updater.log.WithError(err).Error("could not read response")
+		updater.last = nil
+		return
+	}
+	if len(responseBody) > max {
+		updater.last = nil
+		updater.log.Errorf("rates response too long (> %d bytes)", max)
+		return
+	}
+	if err := json.Unmarshal(responseBody, &geckoRates); err != nil {
+		updater.last = nil
+		updater.log.Errorf("could not parse rates response: %s", string(responseBody))
+		return
+	}
+
 	// Convert the map with coingecko coin/fiat codes to a map of coin/fiat units.
 	rates := map[string]map[string]float64{}
 	for coin, val := range geckoRates {

go.mod

@@ -22,6 +22,7 @@ require (
 	golang.org/x/crypto v0.32.0
 	golang.org/x/mobile v0.0.0-20240716161057-1ad2df20a8b6
 	golang.org/x/net v0.34.0
+	golang.org/x/time v0.5.0
 )
 
 require (