Merge remote-tracking branch 'benma/send-to-self-version-check' into staging-send-to-self-dropdown

Author: benma

backend/devices/bitbox02/keystore.go

@@ -556,3 +556,10 @@ func (keystore *keystore) SupportsPaymentRequests() error {
 	}
 	return keystorePkg.ErrFirmwareUpgradeRequired
 }
+
+// Features reports optional capabilities supported by the BitBox02 keystore.
+func (keystore *keystore) Features() *keystorePkg.Features {
+	return &keystorePkg.Features{
+		SupportsSendToSelf: keystore.device.Version().AtLeast(semver.NewSemVer(9, 22, 0)),
+	}
+}

backend/handlers/handlers.go

@@ -219,6 +219,7 @@ func NewHandlers(
 	getAPIRouterNoError(apiRouter)("/dev-servers", handlers.getDevServers).Methods("GET")
 	getAPIRouterNoError(apiRouter)("/account-add", handlers.postAddAccount).Methods("POST")
 	getAPIRouterNoError(apiRouter)("/keystores", handlers.getKeystores).Methods("GET")
+	getAPIRouterNoError(apiRouter)("/keystore/{rootFingerprint}/features", handlers.getKeystoreFeatures).Methods("GET")
 	getAPIRouterNoError(apiRouter)("/accounts", handlers.getAccounts).Methods("GET")
 	getAPIRouter(apiRouter)("/accounts/balance-summary", handlers.getAccountsBalanceSummary).Methods("GET")
 	getAPIRouterNoError(apiRouter)("/set-account-active", handlers.postSetAccountActive).Methods("POST")
@@ -605,6 +606,55 @@ func (handlers *Handlers) getKeystores(*http.Request) interface{} {
 	return keystores
 }
 
+func (handlers *Handlers) getKeystoreFeatures(r *http.Request) interface{} {
+	type response struct {
+		Success      bool               `json:"success"`
+		ErrorMessage string             `json:"errorMessage,omitempty"`
+		Features     *keystore.Features `json:"features,omitempty"`
+	}
+
+	rootFingerprintHex := mux.Vars(r)["rootFingerprint"]
+	rootFingerprint, err := hex.DecodeString(rootFingerprintHex)
+	if err != nil {
+		handlers.log.WithError(err).Error("invalid root fingerprint for features request")
+		return response{
+			Success:      false,
+			ErrorMessage: err.Error(),
+		}
+	}
+
+	connectedKeystore := handlers.backend.Keystore()
+	if connectedKeystore == nil {
+		handlers.log.Warn("features requested but no keystore connected")
+		return response{
+			Success:      false,
+			ErrorMessage: "keystore not connected",
+		}
+	}
+
+	connectedRootFingerprint, err := connectedKeystore.RootFingerprint()
+	if err != nil {
+		handlers.log.WithError(err).Error("could not determine connected keystore root fingerprint")
+		return response{
+			Success:      false,
+			ErrorMessage: err.Error(),
+		}
+	}
+
+	if !bytes.Equal(rootFingerprint, connectedRootFingerprint) {
+		handlers.log.WithField("requested", rootFingerprintHex).Warn("features requested for non-connected keystore")
+		return response{
+			Success:      false,
+			ErrorMessage: "wrong keystore connected",
+		}
+	}
+
+	return response{
+		Success:  true,
+		Features: connectedKeystore.Features(),
+	}
+}
+
 func (handlers *Handlers) getAccounts(*http.Request) interface{} {
 	persistedAccounts := handlers.backend.Config().AccountsConfig()
 

backend/keystore/keystore.go

@@ -150,4 +150,14 @@ type Keystore interface {
 
 	// SupportsPaymentRequests returns nil if the device supports silent payments, or an error indicating why it is not supported.
 	SupportsPaymentRequests() error
+
+	// Features reports optional capabilities supported by this keystore.
+	Features() *Features
+}
+
+// Features enumerates optional capabilities that can differ per keystore implementation.
+type Features struct {
+	// SupportsSendToSelf indicates whether the keystore can explicitly verify outputs that belong to
+	// the same keystore (used for the send-to-self recipient dropdown flow).
+	SupportsSendToSelf bool `json:"supportsSendToSelf"`
 }

backend/keystore/mocks/keystore.go

@@ -201,6 +201,13 @@ func (keystore *Keystore) BTCXPubs(
 	return xpubs, nil
 }
 
+// Features reports optional capabilities supported by the software keystore.
+func (keystore *Keystore) Features() *keystorePkg.Features {
+	return &keystorePkg.Features{
+		SupportsSendToSelf: true,
+	}
+}
+
 func (keystore *Keystore) signBTCTransaction(btcProposedTx *btc.ProposedTransaction) error {
 	keystore.log.Info("Sign transaction.")
 	transaction := btcProposedTx.TXProposal.Psbt.UnsignedTx

backend/keystore/software/software.go

@@ -22,6 +22,16 @@ export type { TUnsubscribe };
 type TKeystore = { type: 'hardware' | 'software' };
 export type TKeystores = TKeystore[];
 
+export type TKeystoreFeatures = {
+  supportsSendToSelf: boolean;
+};
+
+export type TKeystoreFeaturesResponse = {
+  success: boolean;
+  features?: TKeystoreFeatures | null;
+  errorMessage?: string;
+};
+
 export const subscribeKeystores = (
   cb: (keystores: TKeystores) => void
 ) => {
@@ -43,3 +53,7 @@ export const deregisterTest = (): Promise<null> => {
 export const connectKeystore = (rootFingerprint: string): Promise<{ success: boolean; }> => {
   return apiPost('connect-keystore', { rootFingerprint });
 };
+
+export const getKeystoreFeatures = (rootFingerprint: string): Promise<TKeystoreFeaturesResponse> => {
+  return apiGet(`keystore/${rootFingerprint}/features`);
+};

frontends/web/src/api/keystores.ts

@@ -216,7 +216,6 @@ export const App = () => {
             <AppRouter
               accounts={accounts}
               activeAccounts={activeAccounts}
-              deviceIDs={deviceIDs}
               devices={devices}
               devicesKey={devicesKey}
             />

frontends/web/src/app.tsx

@@ -0,0 +1,64 @@
+/**
+ * Copyright 2025 Shift Crypto AG
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { useCallback, useContext } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { useTranslation } from 'react-i18next';
+import { Dialog, DialogButtons } from './dialog';
+import { getDeviceList } from '@/api/devices';
+import { syncDeviceList } from '@/api/devicessync';
+import { useSync } from '@/hooks/api';
+import { useDefault } from '@/hooks/default';
+import { Button } from '@/components/forms';
+import { AppContext } from '@/contexts/AppContext';
+
+type TFirmwareUpgradeRequiredDialogProps = {
+  open: boolean;
+  onClose: () => void;
+};
+
+export const FirmwareUpgradeRequiredDialog = ({ open, onClose }: TFirmwareUpgradeRequiredDialogProps) => {
+  const { t } = useTranslation();
+  const navigate = useNavigate();
+  const { setFirmwareUpdateDialogOpen } = useContext(AppContext);
+  const devices = useDefault(useSync(getDeviceList, syncDeviceList), {});
+  const deviceIDs = Object.keys(devices);
+
+  const handleUpgrade = useCallback(() => {
+    setFirmwareUpdateDialogOpen(true);
+    if (deviceIDs && deviceIDs.length > 0) {
+      navigate(`/settings/device-settings/${deviceIDs[0] as string}`);
+    }
+    onClose();
+  }, [setFirmwareUpdateDialogOpen, deviceIDs, navigate, onClose]);
+
+  return (
+    <Dialog
+      title={t('upgradeFirmware.title')}
+      open={open}
+      onClose={onClose}>
+      <p>{t('device.firmwareUpgradeRequired')}</p>
+      <DialogButtons>
+        <Button primary onClick={handleUpgrade}>
+          {t('upgradeFirmware.button')}
+        </Button>
+        <Button secondary onClick={onClose}>
+          {t('dialog.cancel')}
+        </Button>
+      </DialogButtons>
+    </Dialog>
+  );
+};