Remove coinbase v2 API support (#148387)

Co-authored-by: Joost Lekkerkerker <[email protected]>

Author: JamieMagee

homeassistant/components/coinbase/__init__.py

@@ -7,22 +7,19 @@
 
 from coinbase.rest import RESTClient
 from coinbase.rest.rest_base import HTTPError
-from coinbase.wallet.client import Client as LegacyClient
-from coinbase.wallet.error import AuthenticationError
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_API_KEY, CONF_API_TOKEN, Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers import entity_registry as er
 from homeassistant.util import Throttle
 
 from .const import (
     ACCOUNT_IS_VAULT,
     API_ACCOUNT_AMOUNT,
     API_ACCOUNT_AVALIABLE,
-    API_ACCOUNT_BALANCE,
     API_ACCOUNT_CURRENCY,
-    API_ACCOUNT_CURRENCY_CODE,
     API_ACCOUNT_HOLD,
     API_ACCOUNT_ID,
     API_ACCOUNT_NAME,
@@ -31,7 +28,6 @@
     API_DATA,
     API_RATES_CURRENCY,
     API_RESOURCE_TYPE,
-    API_TYPE_VAULT,
     API_V3_ACCOUNT_ID,
     API_V3_TYPE_VAULT,
     CONF_CURRENCIES,
@@ -68,16 +64,21 @@ async def async_unload_entry(hass: HomeAssistant, entry: CoinbaseConfigEntry) ->
 
 def create_and_update_instance(entry: CoinbaseConfigEntry) -> CoinbaseData:
     """Create and update a Coinbase Data instance."""
+
+    # Check if user is using deprecated v2 API credentials
     if "organizations" not in entry.data[CONF_API_KEY]:
-        client = LegacyClient(entry.data[CONF_API_KEY], entry.data[CONF_API_TOKEN])
-        version = "v2"
-    else:
-        client = RESTClient(
-            api_key=entry.data[CONF_API_KEY], api_secret=entry.data[CONF_API_TOKEN]
+        # Trigger reauthentication to ask user for v3 credentials
+        raise ConfigEntryAuthFailed(
+            "Your Coinbase API key appears to be for the deprecated v2 API. "
+            "Please reconfigure with a new API key created for the v3 API. "
+            "Visit https://www.coinbase.com/developer-platform to create new credentials."
         )
-        version = "v3"
+
+    client = RESTClient(
+        api_key=entry.data[CONF_API_KEY], api_secret=entry.data[CONF_API_TOKEN]
+    )
     base_rate = entry.options.get(CONF_EXCHANGE_BASE, "USD")
-    instance = CoinbaseData(client, base_rate, version)
+    instance = CoinbaseData(client, base_rate)
     instance.update()
     return instance
 
@@ -105,31 +106,9 @@ async def update_listener(
             registry.async_remove(entity.entity_id)
 
 
-def get_accounts(client, version):
+def get_accounts(client):
     """Handle paginated accounts."""
     response = client.get_accounts()
-    if version == "v2":
-        accounts = response[API_DATA]
-        next_starting_after = response.pagination.next_starting_after
-
-        while next_starting_after:
-            response = client.get_accounts(starting_after=next_starting_after)
-            accounts += response[API_DATA]
-            next_starting_after = response.pagination.next_starting_after
-
-        return [
-            {
-                API_ACCOUNT_ID: account[API_ACCOUNT_ID],
-                API_ACCOUNT_NAME: account[API_ACCOUNT_NAME],
-                API_ACCOUNT_CURRENCY: account[API_ACCOUNT_CURRENCY][
-                    API_ACCOUNT_CURRENCY_CODE
-                ],
-                API_ACCOUNT_AMOUNT: account[API_ACCOUNT_BALANCE][API_ACCOUNT_AMOUNT],
-                ACCOUNT_IS_VAULT: account[API_RESOURCE_TYPE] == API_TYPE_VAULT,
-            }
-            for account in accounts
-        ]
-
     accounts = response[API_ACCOUNTS]
     while response["has_next"]:
         response = client.get_accounts(cursor=response["cursor"])
@@ -153,37 +132,28 @@ def get_accounts(client, version):
 class CoinbaseData:
     """Get the latest data and update the states."""
 
-    def __init__(self, client, exchange_base, version):
+    def __init__(self, client, exchange_base):
         """Init the coinbase data object."""
 
         self.client = client
         self.accounts = None
         self.exchange_base = exchange_base
         self.exchange_rates = None
-        if version == "v2":
-            self.user_id = self.client.get_current_user()[API_ACCOUNT_ID]
-        else:
-            self.user_id = (
-                "v3_" + client.get_portfolios()["portfolios"][0][API_V3_ACCOUNT_ID]
-            )
-        self.api_version = version
+        self.user_id = (
+            "v3_" + client.get_portfolios()["portfolios"][0][API_V3_ACCOUNT_ID]
+        )
 
     @Throttle(MIN_TIME_BETWEEN_UPDATES)
     def update(self):
         """Get the latest data from coinbase."""
 
         try:
-            self.accounts = get_accounts(self.client, self.api_version)
-            if self.api_version == "v2":
-                self.exchange_rates = self.client.get_exchange_rates(
-                    currency=self.exchange_base
-                )
-            else:
-                self.exchange_rates = self.client.get(
-                    "/v2/exchange-rates",
-                    params={API_RATES_CURRENCY: self.exchange_base},
-                )[API_DATA]
-        except (AuthenticationError, HTTPError) as coinbase_error:
+            self.accounts = get_accounts(self.client)
+            self.exchange_rates = self.client.get(
+                "/v2/exchange-rates",
+                params={API_RATES_CURRENCY: self.exchange_base},
+            )[API_DATA]
+        except HTTPError as coinbase_error:
             _LOGGER.error(
                 "Authentication error connecting to coinbase: %s", coinbase_error
             )

homeassistant/components/coinbase/config_flow.py

@@ -2,17 +2,16 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 import logging
 from typing import Any
 
 from coinbase.rest import RESTClient
 from coinbase.rest.rest_base import HTTPError
-from coinbase.wallet.client import Client as LegacyClient
-from coinbase.wallet.error import AuthenticationError
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult, OptionsFlow
-from homeassistant.const import CONF_API_KEY, CONF_API_TOKEN, CONF_API_VERSION
+from homeassistant.const import CONF_API_KEY, CONF_API_TOKEN
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
@@ -45,9 +44,6 @@
 
 def get_user_from_client(api_key, api_token):
     """Get the user name from Coinbase API credentials."""
-    if "organizations" not in api_key:
-        client = LegacyClient(api_key, api_token)
-        return client.get_current_user()["name"]
     client = RESTClient(api_key=api_key, api_secret=api_token)
     return client.get_portfolios()["portfolios"][0]["name"]
 
@@ -59,7 +55,7 @@ async def validate_api(hass: HomeAssistant, data):
         user = await hass.async_add_executor_job(
             get_user_from_client, data[CONF_API_KEY], data[CONF_API_TOKEN]
         )
-    except (AuthenticationError, HTTPError) as error:
+    except HTTPError as error:
         if "api key" in str(error) or " 401 Client Error" in str(error):
             _LOGGER.debug("Coinbase rejected API credentials due to an invalid API key")
             raise InvalidKey from error
@@ -74,8 +70,8 @@ async def validate_api(hass: HomeAssistant, data):
         raise InvalidAuth from error
     except ConnectionError as error:
         raise CannotConnect from error
-    api_version = "v3" if "organizations" in data[CONF_API_KEY] else "v2"
-    return {"title": user, "api_version": api_version}
+
+    return {"title": user}
 
 
 async def validate_options(
@@ -85,20 +81,17 @@ async def validate_options(
 
     client = config_entry.runtime_data.client
 
-    accounts = await hass.async_add_executor_job(
-        get_accounts, client, config_entry.data.get("api_version", "v2")
-    )
+    accounts = await hass.async_add_executor_job(get_accounts, client)
 
     accounts_currencies = [
         account[API_ACCOUNT_CURRENCY]
         for account in accounts
         if not account[ACCOUNT_IS_VAULT]
     ]
-    if config_entry.data.get("api_version", "v2") == "v2":
-        available_rates = await hass.async_add_executor_job(client.get_exchange_rates)
-    else:
-        resp = await hass.async_add_executor_job(client.get, "/v2/exchange-rates")
-        available_rates = resp[API_DATA]
+
+    resp = await hass.async_add_executor_job(client.get, "/v2/exchange-rates")
+    available_rates = resp[API_DATA]
+
     if CONF_CURRENCIES in options:
         for currency in options[CONF_CURRENCIES]:
             if currency not in accounts_currencies:
@@ -117,6 +110,8 @@ class CoinbaseConfigFlow(ConfigFlow, domain=DOMAIN):
 
     VERSION = 1
 
+    reauth_entry: CoinbaseConfigEntry
+
     async def async_step_user(
         self, user_input: dict[str, str] | None = None
     ) -> ConfigFlowResult:
@@ -143,12 +138,63 @@ async def async_step_user(
             _LOGGER.exception("Unexpected exception")
             errors["base"] = "unknown"
         else:
-            user_input[CONF_API_VERSION] = info["api_version"]
             return self.async_create_entry(title=info["title"], data=user_input)
         return self.async_show_form(
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
         )
 
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Handle reauthentication flow."""
+        self.reauth_entry = self._get_reauth_entry()
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, str] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reauthentication confirmation."""
+        errors: dict[str, str] = {}
+
+        if user_input is None:
+            return self.async_show_form(
+                step_id="reauth_confirm",
+                data_schema=STEP_USER_DATA_SCHEMA,
+                description_placeholders={
+                    "account_name": self.reauth_entry.title,
+                },
+                errors=errors,
+            )
+
+        try:
+            await validate_api(self.hass, user_input)
+        except CannotConnect:
+            errors["base"] = "cannot_connect"
+        except InvalidKey:
+            errors["base"] = "invalid_auth_key"
+        except InvalidSecret:
+            errors["base"] = "invalid_auth_secret"
+        except InvalidAuth:
+            errors["base"] = "invalid_auth"
+        except Exception:
+            _LOGGER.exception("Unexpected exception")
+            errors["base"] = "unknown"
+        else:
+            return self.async_update_reload_and_abort(
+                self.reauth_entry,
+                data_updates=user_input,
+                reason="reauth_successful",
+            )
+
+        return self.async_show_form(
+            step_id="reauth_confirm",
+            data_schema=STEP_USER_DATA_SCHEMA,
+            description_placeholders={
+                "account_name": self.reauth_entry.title,
+            },
+            errors=errors,
+        )
+
     @staticmethod
     @callback
     def async_get_options_flow(

homeassistant/components/coinbase/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/coinbase",
   "iot_class": "cloud_polling",
   "loggers": ["coinbase"],
-  "requirements": ["coinbase==2.1.0", "coinbase-advanced-py==1.2.2"]
+  "requirements": ["coinbase-advanced-py==1.2.2"]
 }

homeassistant/components/coinbase/sensor.py

@@ -27,7 +27,6 @@
 _LOGGER = logging.getLogger(__name__)
 
 ATTR_NATIVE_BALANCE = "Balance in native currency"
-ATTR_API_VERSION = "API Version"
 
 CURRENCY_ICONS = {
     "BTC": "mdi:currency-btc",
@@ -71,9 +70,8 @@ async def async_setup_entry(
 
     for currency in desired_currencies:
         _LOGGER.debug(
-            "Attempting to set up %s account sensor with %s API",
+            "Attempting to set up %s account sensor",
             currency,
-            instance.api_version,
         )
         if currency not in provided_currencies:
             _LOGGER.warning(
@@ -89,9 +87,8 @@ async def async_setup_entry(
     if CONF_EXCHANGE_RATES in config_entry.options:
         for rate in config_entry.options[CONF_EXCHANGE_RATES]:
             _LOGGER.debug(
-                "Attempting to set up %s account sensor with %s API",
+                "Attempting to set up %s exchange rate sensor",
                 rate,
-                instance.api_version,
             )
             entities.append(
                 ExchangeRateSensor(
@@ -146,15 +143,13 @@ def extra_state_attributes(self) -> dict[str, str]:
         """Return the state attributes of the sensor."""
         return {
             ATTR_NATIVE_BALANCE: f"{self._native_balance} {self._coinbase_data.exchange_base}",
-            ATTR_API_VERSION: self._coinbase_data.api_version,
         }
 
     def update(self) -> None:
         """Get the latest state of the sensor."""
         _LOGGER.debug(
-            "Updating %s account sensor with %s API",
+            "Updating %s account sensor",
             self._currency,
-            self._coinbase_data.api_version,
         )
         self._coinbase_data.update()
         for account in self._coinbase_data.accounts:
@@ -210,9 +205,8 @@ def __init__(
     def update(self) -> None:
         """Get the latest state of the sensor."""
         _LOGGER.debug(
-            "Updating %s rate sensor with %s API",
+            "Updating %s rate sensor",
             self._currency,
-            self._coinbase_data.api_version,
         )
         self._coinbase_data.update()
         self._attr_native_value = round(

homeassistant/components/coinbase/strings.json

@@ -8,6 +8,14 @@
           "api_key": "[%key:common::config_flow::data::api_key%]",
           "api_token": "API secret"
         }
+      },
+      "reauth_confirm": {
+        "title": "Update Coinbase API credentials",
+        "description": "Your current Coinbase API key appears to be for the deprecated v2 API. Please reconfigure with a new API key created for the v3 API. Visit https://www.coinbase.com/developer-platform  to create new credentials for {account_name}.",
+        "data": {
+          "api_key": "[%key:common::config_flow::data::api_key%]",
+          "api_token": "API secret"
+        }
       }
     },
     "error": {
@@ -18,7 +26,8 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "reauth_successful": "Successfully updated credentials"
     }
   },
   "options": {