@dynamic-labs/sdk-react-core 4.53.2 → 4.55.0

package/src/lib/utils/hooks/useWalletBackup/cloudProviders.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { WaasBackupOptionsEnum } from '@dynamic-labs/sdk-api-core';
+import { CloudBackupProvider, CloudProviderConfig } from './types';
+export type CloudProviderConfigWithIcon = CloudProviderConfig & {
+    icon: JSX.Element;
+};
+export declare const CLOUD_PROVIDER_CONFIGS: Record<CloudBackupProvider, CloudProviderConfigWithIcon>;
+export declare const getSupportedProviders: (backupOptions?: WaasBackupOptionsEnum[]) => CloudProviderConfigWithIcon[];

package/src/lib/utils/hooks/useWalletBackup/cloudProviders.js

@@ -0,0 +1,44 @@
+'use client'
+import { jsx } from 'react/jsx-runtime';
+import { ProviderEnum, WaasBackupOptionsEnum } from '@dynamic-labs/sdk-api-core';
+import 'react';
+import '@dynamic-labs/iconic';
+import '../../../context/ViewContext/ViewContext.js';
+import { ReactComponent as SvgGoogleDrive } from '../../../shared/assets/google-drive.js';
+import { ReactComponent as SvgIcloud } from '../../../shared/assets/icloud.js';
+import { CloudBackupProvider } from './types.js';
+
+const CLOUD_PROVIDER_CONFIGS = {
+    [CloudBackupProvider.GoogleDrive]: {
+        icon: jsx(SvgGoogleDrive, { className: 'waas-backup-view__provider-icon' }),
+        id: CloudBackupProvider.GoogleDrive,
+        name: 'Google Drive',
+        oauthProvider: ProviderEnum.Google,
+        requiresIframe: false,
+        requiresOAuth: true,
+    },
+    [CloudBackupProvider.ICloud]: {
+        icon: jsx(SvgIcloud, { className: 'waas-backup-view__provider-icon' }),
+        id: CloudBackupProvider.ICloud,
+        name: 'iCloud',
+        requiresIframe: true,
+        requiresOAuth: false,
+    },
+};
+// Maps WaasBackupOptionsEnum to CloudBackupProvider
+const BACKUP_OPTION_TO_PROVIDER = {
+    [WaasBackupOptionsEnum.GoogleDrive]: CloudBackupProvider.GoogleDrive,
+    [WaasBackupOptionsEnum.ICloud]: CloudBackupProvider.ICloud,
+};
+const getSupportedProviders = (backupOptions) => {
+    const allProviders = Object.values(CLOUD_PROVIDER_CONFIGS);
+    if (!backupOptions || backupOptions.length === 0) {
+        return allProviders;
+    }
+    const enabledProviderIds = new Set(backupOptions
+        .map((option) => BACKUP_OPTION_TO_PROVIDER[option])
+        .filter((id) => id !== undefined));
+    return allProviders.filter((provider) => enabledProviderIds.has(provider.id));
+};
+
+export { CLOUD_PROVIDER_CONFIGS, getSupportedProviders };

package/src/lib/utils/hooks/useWalletBackup/index.d.ts

@@ -1 +1,2 @@
 export { useWalletBackup, useBackupWallets, useDownloadKeyShares, isWalletBackedUp, type WalletToBackup, type WalletWithBackupStatus, type WalletBackupStatus, type WalletOperationState, } from './useWalletBackup';
+export { CloudBackupProvider } from './types';

package/src/lib/utils/hooks/useWalletBackup/types.cjs

@@ -0,0 +1,13 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+
+const CloudBackupProvider = {
+    GoogleDrive: sdkApiCore.WaasBackupOptionsEnum.GoogleDrive,
+    ICloud: sdkApiCore.WaasBackupOptionsEnum.ICloud,
+};
+
+exports.CloudBackupProvider = CloudBackupProvider;

package/src/lib/utils/hooks/useWalletBackup/types.d.ts

@@ -0,0 +1,18 @@
+import { ProviderEnum, WaasBackupOptionsEnum } from '@dynamic-labs/sdk-api-core';
+export type CloudBackupProvider = WaasBackupOptionsEnum.GoogleDrive | WaasBackupOptionsEnum.ICloud;
+export declare const CloudBackupProvider: {
+    readonly GoogleDrive: WaasBackupOptionsEnum.GoogleDrive;
+    readonly ICloud: WaasBackupOptionsEnum.ICloud;
+};
+export type CloudProviderConfig = {
+    id: CloudBackupProvider;
+    name: string;
+    requiresOAuth: boolean;
+    requiresIframe: boolean;
+    oauthProvider?: ProviderEnum;
+};
+export type CloudProviderBackupOptions = {
+    provider: CloudBackupProvider;
+    accountAddress: string;
+    password?: string;
+};

package/src/lib/utils/hooks/useWalletBackup/types.js

@@ -0,0 +1,9 @@
+'use client'
+import { WaasBackupOptionsEnum } from '@dynamic-labs/sdk-api-core';
+
+const CloudBackupProvider = {
+    GoogleDrive: WaasBackupOptionsEnum.GoogleDrive,
+    ICloud: WaasBackupOptionsEnum.ICloud,
+};
+
+export { CloudBackupProvider };

package/src/lib/utils/hooks/useWalletBackup/useWalletBackup.cjs

@@ -31,6 +31,7 @@ require('../../../store/state/connectedWalletsInfo/connectedWalletsInfo.cjs');
 require('../../functions/getWaasAddressTypeLabel/getWaasAddressTypeLabel.cjs');
 require('../../../events/dynamicEvents.cjs');
 var useUser = require('../../../client/extension/user/useUser/useUser.cjs');
+var useProjectSettings = require('../../../client/extension/projectSettings/useProjectSettings/useProjectSettings.cjs');
 require('../../../context/DynamicContext/DynamicContext.cjs');
 require('../../../store/state/loadingAndLifecycle/loadingAndLifecycle.cjs');
 require('../../../context/CaptchaContext/CaptchaContext.cjs');
@@ -76,8 +77,7 @@ require('qrcode');
 require('formik');
 require('../useSubdomainCheck/useSubdomainCheck.cjs');
 require('../../../context/WalletGroupContext/WalletGroupContext.cjs');
-var useDynamicWaas = require('../useDynamicWaas/useDynamicWaas.cjs');
-var useRefreshUser = require('../useRefreshUser/useRefreshUser.cjs');
+var types = require('./types.cjs');
 require('../../../context/IpConfigurationContext/IpConfigurationContext.cjs');
 require('../../../context/SocialRedirectContext/SocialRedirectContext.cjs');
 require('../../../context/ConnectWithOtpContext/ConnectWithOtpContext.cjs');
@@ -94,6 +94,8 @@ require('../useEmbeddedWallet/useSecureEnclaveEmbeddedWallet/constants.cjs');
 require('../../../views/MfaChooseDeviceView/useGetMfaOptions/useGetMfaOptions.cjs');
 require('../../../context/PasskeyContext/PasskeyContext.cjs');
 require('../../../context/OnrampContext/OnrampContext.cjs');
+var useRefreshUser = require('../useRefreshUser/useRefreshUser.cjs');
+var useDynamicWaas = require('../useDynamicWaas/useDynamicWaas.cjs');
 require('../../../store/state/sendBalances.cjs');
 require('../../../store/state/connectorsInitializing/connectorsInitializing.cjs');
 require('../../../components/OverlayCardBase/OverlayCardTarget/OverlayCardTarget.cjs');
@@ -107,7 +109,12 @@ require('../../../store/state/tokenBalances.cjs');
 require('../../../store/state/multichainBalances.cjs');
 require('../../../shared/utils/functions/getInitialUrl/getInitialUrl.cjs');
 var useInternalDynamicContext = require('../../../context/DynamicContext/useDynamicContext/useInternalDynamicContext/useInternalDynamicContext.cjs');
+var cloudProviders = require('./cloudProviders.cjs');
 
+const CLOUD_BACKUP_LOCATIONS = [
+    sdkApiCore.WaasBackupOptionsEnum.GoogleDrive,
+    sdkApiCore.WaasBackupOptionsEnum.ICloud,
+];
 const isWalletBackedUp = (cred) => {
     var _a;
     const keyShares = (_a = cred.walletProperties) === null || _a === void 0 ? void 0 : _a.keyShares;
@@ -116,15 +123,18 @@ const isWalletBackedUp = (cred) => {
     return keyShares.some((keyShare) => keyShare &&
         typeof keyShare === 'object' &&
         'backupLocation' in keyShare &&
-        keyShare.backupLocation === 'googleDrive');
+        CLOUD_BACKUP_LOCATIONS.includes(keyShare.backupLocation));
 };
 const useWalletBackup = () => {
+    var _a, _b;
     const { setShowAuthFlow } = useInternalDynamicContext.useInternalDynamicContext();
     const { pushView } = ViewContext.useViewContext();
     const user = useUser.useUser();
+    const projectSettings = useProjectSettings.useProjectSettings();
     const refresh = useRefreshUser.useRefreshUser();
     const { getWaasWalletConnector, getWaasWalletsByCredentials } = useDynamicWaas.useDynamicWaas();
     const { linkSocialAccount, isLinked } = useSocialAccounts.useSocialAccounts();
+    const backupOptions = (_b = (_a = projectSettings === null || projectSettings === void 0 ? void 0 : projectSettings.sdk) === null || _a === void 0 ? void 0 : _a.waas) === null || _b === void 0 ? void 0 : _b.backupOptions;
     const isGoogleLinked = React.useMemo(() => isLinked(sdkApiCore.ProviderEnum.Google), [isLinked]);
     const [backupState, setBackupState] = React.useState({
         currentIndex: 0,
@@ -153,7 +163,7 @@ const useWalletBackup = () => {
         return (statuses.length > 0 && statuses.every((w) => w.status === 'backed-up'));
     }, [getWalletsBackupStatus]);
     const ensureGoogleLinked = React.useCallback(() => _tslib.__awaiter(void 0, void 0, void 0, function* () {
-        var _a;
+        var _c;
         if (isGoogleLinked) {
             return true;
         }
@@ -163,7 +173,7 @@ const useWalletBackup = () => {
                 showWidgetAfterConnection: false,
             });
             const updatedUser = yield refresh();
-            const isGoogleLinkedAfterRefresh = (_a = updatedUser === null || updatedUser === void 0 ? void 0 : updatedUser.verifiedCredentials) === null || _a === void 0 ? void 0 : _a.some((cred) => cred.format === 'oauth' && cred.oauthProvider === sdkApiCore.ProviderEnum.Google);
+            const isGoogleLinkedAfterRefresh = (_c = updatedUser === null || updatedUser === void 0 ? void 0 : updatedUser.verifiedCredentials) === null || _c === void 0 ? void 0 : _c.some((cred) => cred.format === 'oauth' && cred.oauthProvider === sdkApiCore.ProviderEnum.Google);
             return Boolean(isGoogleLinkedAfterRefresh);
         }
         catch (error) {
@@ -171,7 +181,55 @@ const useWalletBackup = () => {
             return false;
         }
     }), [isGoogleLinked, linkSocialAccount, refresh]);
-    const backupWallet = React.useCallback((walletToBackup) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const showICloudAuth = React.useCallback((displayContainer, walletChain) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const waasConnector = getWaasWalletConnector(walletChain);
+            if (!waasConnector) {
+                logger.logger.warn('No WaaS connector found for showing iCloud auth', {
+                    chain: walletChain,
+                });
+                return false;
+            }
+            yield waasConnector.displayICloudSignIn({ displayContainer });
+            return true;
+        }
+        catch (error) {
+            logger.logger.warn('Error showing iCloud auth', { error });
+            return false;
+        }
+    }), [getWaasWalletConnector]);
+    const checkICloudAuth = React.useCallback((walletChain) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const waasConnector = getWaasWalletConnector(walletChain);
+            if (!waasConnector) {
+                logger.logger.warn('No WaaS connector found for checking iCloud auth', {
+                    chain: walletChain,
+                });
+                return false;
+            }
+            return yield waasConnector.isICloudAuthenticated();
+        }
+        catch (error) {
+            logger.logger.warn('Error checking iCloud auth', { error });
+            return false;
+        }
+    }), [getWaasWalletConnector]);
+    const hideICloudAuth = React.useCallback((walletChain) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const waasConnector = getWaasWalletConnector(walletChain);
+            if (!waasConnector) {
+                logger.logger.warn('No WaaS connector found for hiding iCloud auth', {
+                    chain: walletChain,
+                });
+                return;
+            }
+            yield waasConnector.hideICloudSignIn();
+        }
+        catch (error) {
+            logger.logger.warn('Error hiding iCloud auth', { error });
+        }
+    }), [getWaasWalletConnector]);
+    const backupWallet = React.useCallback((walletToBackup_1, ...args_1) => _tslib.__awaiter(void 0, [walletToBackup_1, ...args_1], void 0, function* (walletToBackup, provider = types.CloudBackupProvider.GoogleDrive, displayContainer) {
         try {
             const waasConnector = getWaasWalletConnector(walletToBackup.chain);
             if (!waasConnector) {
@@ -180,9 +238,16 @@ const useWalletBackup = () => {
                 });
                 return false;
             }
-            yield waasConnector.backupKeySharesToGoogleDrive({
-                accountAddress: walletToBackup.address,
-            });
+            if (provider === types.CloudBackupProvider.GoogleDrive) {
+                yield waasConnector.backupKeySharesToGoogleDrive({
+                    accountAddress: walletToBackup.address,
+                });
+            }
+            else if (provider === types.CloudBackupProvider.ICloud) {
+                yield waasConnector.backupKeySharesToICloud({
+                    accountAddress: walletToBackup.address,
+                });
+            }
             return true;
         }
         catch (error) {
@@ -193,14 +258,14 @@ const useWalletBackup = () => {
             return false;
         }
     }), [getWaasWalletConnector]);
-    const backupAllWallets = React.useCallback((wallets) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const backupAllWallets = React.useCallback((wallets_1, ...args_2) => _tslib.__awaiter(void 0, [wallets_1, ...args_2], void 0, function* (wallets, provider = types.CloudBackupProvider.GoogleDrive, displayContainer) {
         const walletsToProcess = wallets !== null && wallets !== void 0 ? wallets : getWalletsToBackup();
         for (const wallet of walletsToProcess) {
-            yield backupWallet(wallet);
+            yield backupWallet(wallet, provider, displayContainer);
         }
         yield refresh();
     }), [getWalletsToBackup, backupWallet, refresh]);
-    const startBackup = React.useCallback((onComplete_1, ...args_1) => _tslib.__awaiter(void 0, [onComplete_1, ...args_1], void 0, function* (onComplete, fromIndex = 0) {
+    const startBackup = React.useCallback((onComplete_1, ...args_3) => _tslib.__awaiter(void 0, [onComplete_1, ...args_3], void 0, function* (onComplete, fromIndex = 0, provider = types.CloudBackupProvider.GoogleDrive, displayContainer) {
         if (timeoutRef.current) {
             clearTimeout(timeoutRef.current);
             timeoutRef.current = null;
@@ -213,7 +278,7 @@ const useWalletBackup = () => {
         setBackupState((prev) => (Object.assign(Object.assign({}, prev), { failedIndex: null, hasError: false, isProcessing: true, totalWallets: walletsToBackup.length })));
         for (let i = fromIndex; i < walletsToBackup.length; i++) {
             setBackupState((prev) => (Object.assign(Object.assign({}, prev), { currentIndex: i + 1 })));
-            const success = yield backupWallet(walletsToBackup[i]);
+            const success = yield backupWallet(walletsToBackup[i], provider, displayContainer);
             if (!success) {
                 setBackupState((prev) => (Object.assign(Object.assign({}, prev), { failedIndex: i, hasError: true, isProcessing: false })));
                 return;
@@ -235,36 +300,102 @@ const useWalletBackup = () => {
         });
         pushView('waas-backup-progress-view');
     }, [setShowAuthFlow, pushView, user]);
+    const ensureProviderLinked = React.useCallback((provider) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const config = cloudProviders.CLOUD_PROVIDER_CONFIGS[provider];
+        if (config.requiresOAuth && config.oauthProvider) {
+            return ensureGoogleLinked();
+        }
+        return true;
+    }), [ensureGoogleLinked]);
+    const isProviderLinked = React.useCallback((provider) => {
+        const config = cloudProviders.CLOUD_PROVIDER_CONFIGS[provider];
+        if (config.requiresOAuth) {
+            return isGoogleLinked;
+        }
+        return true;
+    }, [isGoogleLinked]);
+    const backupToCloudProvider = React.useCallback((options, walletToBackup) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const { provider, password } = options;
+            const waasConnector = getWaasWalletConnector(walletToBackup.chain);
+            if (!waasConnector) {
+                logger.logger.warn('No WaaS connector found for wallet', {
+                    address: walletToBackup.address,
+                });
+                return false;
+            }
+            if (provider === types.CloudBackupProvider.GoogleDrive) {
+                yield waasConnector.backupKeySharesToGoogleDrive({
+                    accountAddress: walletToBackup.address,
+                    password,
+                });
+            }
+            else if (provider === types.CloudBackupProvider.ICloud) {
+                yield waasConnector.backupKeySharesToICloud({
+                    accountAddress: walletToBackup.address,
+                    password,
+                });
+            }
+            return true;
+        }
+        catch (error) {
+            logger.logger.warn('Error backing up to cloud provider', { error, options });
+            return false;
+        }
+    }), [getWaasWalletConnector]);
+    const getSupportedProviders = React.useCallback(() => cloudProviders.getSupportedProviders(backupOptions), [backupOptions]);
     return {
         areAllWalletsBackedUp,
         backupAllWallets,
         backupState,
+        backupToCloudProvider,
         backupWallet,
+        checkICloudAuth,
         ensureGoogleLinked,
+        ensureProviderLinked,
+        getSupportedProviders,
         getWalletsBackupStatus,
         getWalletsToBackup,
+        hideICloudAuth,
         initBackupProcess,
         isGoogleLinked,
+        isProviderLinked,
+        showICloudAuth,
         startBackup,
     };
 };
-const useBackupWallets = (onComplete) => {
+const useBackupWallets = (onComplete, provider = types.CloudBackupProvider.GoogleDrive, displayContainer) => {
     const { backupState, startBackup } = useWalletBackup();
     const hasStartedRef = React.useRef(false);
     const onCompleteRef = React.useRef(onComplete);
     onCompleteRef.current = onComplete;
-    React.useEffect(() => {
+    const config = cloudProviders.CLOUD_PROVIDER_CONFIGS[provider];
+    const start = React.useCallback(() => {
         if (hasStartedRef.current)
             return;
+        if (config.requiresIframe && !displayContainer) {
+            throw new Error(`${config.name} backup requires iframe to be ready`);
+        }
         hasStartedRef.current = true;
-        startBackup(() => onCompleteRef.current());
-    }, [startBackup]);
+        startBackup(() => onCompleteRef.current(), 0, provider, displayContainer);
+    }, [startBackup, provider, displayContainer, config]);
     const retry = React.useCallback(() => {
         var _a;
+        hasStartedRef.current = false;
         const fromIndex = (_a = backupState.failedIndex) !== null && _a !== void 0 ? _a : 0;
-        startBackup(() => onCompleteRef.current(), fromIndex);
-    }, [startBackup, backupState.failedIndex]);
-    return Object.assign(Object.assign({}, backupState), { retry });
+        hasStartedRef.current = true;
+        startBackup(() => onCompleteRef.current(), fromIndex, provider, displayContainer);
+    }, [startBackup, backupState.failedIndex, provider, displayContainer]);
+    // Auto-start for non-iframe providers (Google Drive)
+    // iCloud requires displayContainer to be ready first
+    React.useEffect(() => {
+        if (hasStartedRef.current)
+            return;
+        if (config.requiresIframe)
+            return;
+        start();
+    }, [config.requiresIframe, start]);
+    return Object.assign(Object.assign({}, backupState), { retry, start });
 };
 const useDownloadKeyShares = (onComplete) => {
     const { getWaasWalletConnector, getWaasWalletsByCredentials } = useDynamicWaas.useDynamicWaas();

package/src/lib/utils/hooks/useWalletBackup/useWalletBackup.d.ts

@@ -1,4 +1,5 @@
 import { ChainEnum, JwtVerifiedCredential } from '@dynamic-labs/sdk-api-core';
+import { CloudBackupProvider, CloudProviderBackupOptions } from './types';
 export type WalletBackupStatus = 'backed-up' | 'pending';
 export interface WalletToBackup {
     address: string;
@@ -18,18 +19,26 @@ export interface WalletOperationState {
 export declare const isWalletBackedUp: (cred: JwtVerifiedCredential) => boolean;
 export declare const useWalletBackup: () => {
     readonly areAllWalletsBackedUp: boolean;
-    readonly backupAllWallets: (wallets?: WalletToBackup[]) => Promise<void>;
+    readonly backupAllWallets: (wallets?: WalletToBackup[], provider?: CloudBackupProvider, displayContainer?: HTMLElement) => Promise<void>;
     readonly backupState: WalletOperationState;
-    readonly backupWallet: (walletToBackup: WalletToBackup) => Promise<boolean>;
+    readonly backupToCloudProvider: (options: CloudProviderBackupOptions, walletToBackup: WalletToBackup) => Promise<boolean>;
+    readonly backupWallet: (walletToBackup: WalletToBackup, provider?: CloudBackupProvider, displayContainer?: HTMLElement) => Promise<boolean>;
+    readonly checkICloudAuth: (walletChain: ChainEnum) => Promise<boolean>;
     readonly ensureGoogleLinked: () => Promise<boolean>;
+    readonly ensureProviderLinked: (provider: CloudBackupProvider) => Promise<boolean>;
+    readonly getSupportedProviders: () => import("./cloudProviders").CloudProviderConfigWithIcon[];
     readonly getWalletsBackupStatus: () => WalletWithBackupStatus[];
     readonly getWalletsToBackup: () => WalletToBackup[];
+    readonly hideICloudAuth: (walletChain: ChainEnum) => Promise<void>;
     readonly initBackupProcess: () => void;
     readonly isGoogleLinked: boolean;
-    readonly startBackup: (onComplete?: () => void, fromIndex?: number) => Promise<void>;
+    readonly isProviderLinked: (provider: CloudBackupProvider) => boolean;
+    readonly showICloudAuth: (displayContainer: HTMLElement, walletChain: ChainEnum) => Promise<boolean>;
+    readonly startBackup: (onComplete?: () => void, fromIndex?: number, provider?: CloudBackupProvider, displayContainer?: HTMLElement) => Promise<void>;
 };
-export declare const useBackupWallets: (onComplete: () => void) => {
+export declare const useBackupWallets: (onComplete: () => void, provider?: CloudBackupProvider, displayContainer?: HTMLElement) => {
     retry: () => void;
+    start: () => void;
     currentIndex: number;
     failedIndex: number | null;
     hasError: boolean;