backend: replace ratelimiter with x/time/rate.

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

Author: bznein

CHANGELOG.md

@@ -9,6 +9,8 @@
 - Display the hide amount button by default and remove its settings
 - Linux: add support for Wayland
 - Fix the copy buttons in the Pocket order confirmation page
+- Android: handle device disconnect while the app is in the background
+- Improve send result view show relevant infos and options to make a new transaction or go back
 
 # 4.46.3
 - Fix camera access on linux

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"
@@ -193,6 +192,8 @@ type Backend struct {
 
 	devices map[string]device.Interface
 
+	usbManager *usb.Manager
+
 	accountsAndKeystoreLock locker.Locker
 	accounts                AccountsList
 	// keystore is nil if no keystore is connected.
@@ -277,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 {
@@ -612,13 +613,14 @@ func (backend *Backend) OnDeviceUninit(f func(string)) {
 // Start starts the background services. It returns a channel of events to handle by the library
 // client.
 func (backend *Backend) Start() <-chan interface{} {
-	usb.NewManager(
+	backend.usbManager = usb.NewManager(
 		backend.arguments.MainDirectoryPath(),
 		backend.arguments.BitBox02DirectoryPath(),
 		backend.socksProxy,
 		backend.environment.DeviceInfos,
 		backend.Register,
-		backend.Deregister).Start()
+		backend.Deregister)
+	backend.usbManager.Start()
 
 	httpClient, err := backend.socksProxy.GetHTTPClient()
 	if err != nil {
@@ -638,6 +640,13 @@ func (backend *Backend) Start() <-chan interface{} {
 	return backend.events
 }
 
+// UsbUpdate triggers a scan of the USB devices to detect connects/disconnects.
+func (backend *Backend) UsbUpdate() {
+	if backend.usbManager != nil {
+		backend.usbManager.Update()
+	}
+}
+
 // DevicesRegistered returns a map of device IDs to device of registered devices.
 func (backend *Backend) DevicesRegistered() map[string]device.Interface {
 	return backend.devices

backend/bridgecommon/bridgecommon.go

@@ -359,3 +359,13 @@ func Shutdown() {
 		log.Info("Shutdown called, but backend not running")
 	}
 }
+
+// UsbUpdate wraps backend.UsbUpdate.
+func UsbUpdate() {
+	mu.RLock()
+	defer mu.RUnlock()
+	if globalBackend == nil {
+		return
+	}
+	globalBackend.UsbUpdate()
+}

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 {
+func (etherScan *EtherScan) call(ctx context.Context, params url.Values, result interface{}) error {
+	if err := etherScan.limiter.Wait(ctx); err != nil {
+		return errp.WithStack(err)
+	}
 	params.Set("apikey", apiKey)
 	response, err := etherScan.httpClient.Get(etherScan.url + "?" + params.Encode())
 	if err != nil {
@@ -323,7 +330,7 @@ func (etherScan *EtherScan) Transactions(
 	result := struct {
 		Result []*Transaction
 	}{}
-	if err := etherScan.call(params, &result); err != nil {
+	if err := etherScan.call(context.TODO(), params, &result); err != nil {
 		return nil, err
 	}
 	isERC20 := erc20Token != nil
@@ -338,7 +345,7 @@ func (etherScan *EtherScan) Transactions(
 		resultInternal := struct {
 			Result []*Transaction
 		}{}
-		if err := etherScan.call(params, &resultInternal); err != nil {
+		if err := etherScan.call(context.TODO(), params, &resultInternal); err != nil {
 			return nil, err
 		}
 		var err error
@@ -353,7 +360,7 @@ func (etherScan *EtherScan) Transactions(
 
 // ----- RPC node proxy methods follow
 
-func (etherScan *EtherScan) rpcCall(params url.Values, result interface{}) error {
+func (etherScan *EtherScan) rpcCall(ctx context.Context, params url.Values, result interface{}) error {
 	params.Set("module", "proxy")
 
 	var wrapped struct {
@@ -364,7 +371,7 @@ func (etherScan *EtherScan) rpcCall(params url.Values, result interface{}) error
 		} `json:"error"`
 		Result *json.RawMessage `json:"result"`
 	}
-	if err := etherScan.call(params, &wrapped); err != nil {
+	if err := etherScan.call(ctx, params, &wrapped); err != nil {
 		return err
 	}
 	if wrapped.Error != nil {
@@ -389,7 +396,7 @@ func (etherScan *EtherScan) TransactionReceiptWithBlockNumber(
 	params.Set("action", "eth_getTransactionReceipt")
 	params.Set("txhash", hash.Hex())
 	var result *rpcclient.RPCTransactionReceipt
-	if err := etherScan.rpcCall(params, &result); err != nil {
+	if err := etherScan.rpcCall(ctx, params, &result); err != nil {
 		return nil, err
 	}
 	return result, nil
@@ -402,7 +409,7 @@ func (etherScan *EtherScan) TransactionByHash(
 	params.Set("action", "eth_getTransactionByHash")
 	params.Set("txhash", hash.Hex())
 	var result rpcclient.RPCTransaction
-	if err := etherScan.rpcCall(params, &result); err != nil {
+	if err := etherScan.rpcCall(ctx, params, &result); err != nil {
 		return nil, false, err
 	}
 	return &result.Transaction, result.BlockNumber == nil, nil
@@ -415,7 +422,7 @@ func (etherScan *EtherScan) BlockNumber(ctx context.Context) (*big.Int, error) {
 	params.Set("tag", "latest")
 	params.Set("boolean", "false")
 	var header *types.Header
-	if err := etherScan.rpcCall(params, &header); err != nil {
+	if err := etherScan.rpcCall(ctx, params, &header); err != nil {
 		return nil, err
 	}
 	return header.Number, nil
@@ -434,7 +441,7 @@ func (etherScan *EtherScan) Balance(ctx context.Context, account common.Address)
 	params.Set("action", "balance")
 	params.Set("address", account.Hex())
 	params.Set("tag", "latest")
-	if err := etherScan.call(params, &result); err != nil {
+	if err := etherScan.call(ctx, params, &result); err != nil {
 		return nil, err
 	}
 	if result.Status != "1" {
@@ -461,7 +468,7 @@ func (etherScan *EtherScan) ERC20Balance(account common.Address, erc20Token *erc
 	params.Set("address", account.Hex())
 	params.Set("contractaddress", erc20Token.ContractAddress().Hex())
 	params.Set("tag", "latest")
-	if err := etherScan.call(params, &result); err != nil {
+	if err := etherScan.call(context.TODO(), params, &result); err != nil {
 		return nil, err
 	}
 	if result.Status != "1" {
@@ -485,7 +492,7 @@ func (etherScan *EtherScan) CallContract(ctx context.Context, msg ethereum.CallM
 		panic("not implemented")
 	}
 	var result hexutil.Bytes
-	if err := etherScan.rpcCall(params, &result); err != nil {
+	if err := etherScan.rpcCall(ctx, params, &result); err != nil {
 		return nil, err
 	}
 	return result, nil
@@ -515,7 +522,7 @@ func (etherScan *EtherScan) EstimateGas(ctx context.Context, msg ethereum.CallMs
 	callMsgParams(&params, msg)
 
 	var result hexutil.Uint64
-	if err := etherScan.rpcCall(params, &result); err != nil {
+	if err := etherScan.rpcCall(ctx, params, &result); err != nil {
 		return 0, err
 	}
 	return uint64(result), nil
@@ -528,7 +535,7 @@ func (etherScan *EtherScan) PendingNonceAt(ctx context.Context, account common.A
 	params.Set("address", account.Hex())
 	params.Set("tag", "pending")
 	var result hexutil.Uint64
-	if err := etherScan.rpcCall(params, &result); err != nil {
+	if err := etherScan.rpcCall(ctx, params, &result); err != nil {
 		return 0, err
 	}
 	return uint64(result), nil
@@ -544,15 +551,15 @@ func (etherScan *EtherScan) SendTransaction(ctx context.Context, tx *types.Trans
 	params := url.Values{}
 	params.Set("action", "eth_sendRawTransaction")
 	params.Set("hex", hexutil.Encode(encodedTx))
-	return etherScan.rpcCall(params, nil)
+	return etherScan.rpcCall(ctx, params, nil)
 }
 
 // SuggestGasPrice implements rpc.Interface.
 func (etherScan *EtherScan) SuggestGasPrice(ctx context.Context) (*big.Int, error) {
 	params := url.Values{}
 	params.Set("action", "eth_gasPrice")
 	var result hexutil.Big
-	if err := etherScan.rpcCall(params, &result); err != nil {
+	if err := etherScan.rpcCall(ctx, params, &result); err != nil {
 		return nil, err
 	}
 	return (*big.Int)(&result), nil
@@ -581,7 +588,7 @@ func (etherScan *EtherScan) FeeTargets(ctx context.Context) ([]*ethtypes.FeeTarg
 	params := url.Values{}
 	params.Set("module", "gastracker")
 	params.Set("action", "gasoracle")
-	if err := etherScan.call(params, &result); err != nil {
+	if err := etherScan.call(ctx, params, &result); err != nil {
 		return nil, err
 	}
 	// Convert string fields to int64

backend/devices/usb/manager.go

@@ -86,6 +86,8 @@ type Manager struct {
 	onRegister   func(device.Interface) error
 	onUnregister func(string)
 
+	updateCh chan struct{}
+
 	socksProxy socksproxy.SocksProxy
 
 	log *logrus.Entry
@@ -111,6 +113,7 @@ func NewManager(
 		deviceInfos:       deviceInfos,
 		onRegister:        onRegister,
 		onUnregister:      onUnregister,
+		updateCh:          make(chan struct{}),
 		socksProxy:        socksProxy,
 
 		log: logging.Get().WithGroup("manager"),
@@ -255,8 +258,19 @@ func (manager *Manager) checkIfRemoved(deviceID string) bool {
 	return true
 }
 
+// Update triggers a scan of the USB devices to detect connects/disconnects.
+func (manager *Manager) Update() {
+	go func() {
+		manager.updateCh <- struct{}{}
+	}()
+}
+
 func (manager *Manager) listen() {
 	for {
+		select {
+		case <-manager.updateCh:
+		case <-time.After(time.Second):
+		}
 		for deviceID, device := range manager.devices {
 			// Check if device was removed.
 			if manager.checkIfRemoved(deviceID) {
@@ -310,11 +324,11 @@ func (manager *Manager) listen() {
 				manager.log.WithError(err).Error("Failed to execute on-register")
 			}
 		}
-		time.Sleep(time.Second)
 	}
 }
 
 // Start listens for inserted/removed devices forever.
 func (manager *Manager) Start() {
 	go manager.listen()
+	manager.Update()
 }

backend/mobileserver/mobileserver.go

@@ -155,6 +155,11 @@ func UsingMobileDataChanged() {
 	bridgecommon.UsingMobileDataChanged()
 }
 
+// UsbUpdate exposes `bridgecommon.UsbUpdate` to Java/Kotlin.
+func UsbUpdate() {
+	bridgecommon.UsbUpdate()
+}
+
 type goLogHook struct {
 }
 

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
 	}
 }