@dynamic-labs/sdk-react-core 4.84.0 → 4.84.1

package/src/lib/utils/hooks/usePrivateTokenBalances/usePrivateTokenBalances.js

@@ -0,0 +1,15 @@
+'use client'
+import { useAleoShieldedBalances } from '../useAleoShieldedBalances/useAleoShieldedBalances.js';
+
+const usePrivateTokenBalances = () => {
+    const { tokenBalances, isLoading, error, refetch, supportsShielded } = useAleoShieldedBalances();
+    return {
+        error,
+        isLoading,
+        refetch,
+        supportsPrivateBalances: supportsShielded,
+        tokenBalances,
+    };
+};
+
+export { usePrivateTokenBalances };

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

@@ -41,6 +41,14 @@ var useDynamicWaas = require('../useDynamicWaas/useDynamicWaas.cjs');
 var useRefreshAuth = require('../useRefreshAuth/useRefreshAuth.cjs');
 var DelegationError = require('./DelegationError.cjs');
 
+// Pre-share-set backends mark delegation via keyShares[].backupLocation='delegated';
+// share-set backends use otherShareSets[].shareSetType='delegated' instead.
+const isWalletDelegated = (walletProperties) => {
+    var _a, _b;
+    const hasDelegatedKeyShare = (_a = walletProperties === null || walletProperties === void 0 ? void 0 : walletProperties.keyShares) === null || _a === void 0 ? void 0 : _a.some((keyShare) => keyShare.backupLocation === 'delegated');
+    const hasDelegatedShareSet = (_b = walletProperties === null || walletProperties === void 0 ? void 0 : walletProperties.otherShareSets) === null || _b === void 0 ? void 0 : _b.some((shareSet) => shareSet.shareSetType === 'delegated');
+    return Boolean(hasDelegatedKeyShare || hasDelegatedShareSet);
+};
 /**
  * Gets pending wallets that are eligible for delegation.
  * If wallets are provided and not empty, converts them to WalletWithStatus[] with pending status.
@@ -87,15 +95,11 @@ const useWalletDelegation = () => {
         const waasCredentials = user.verifiedCredentials.filter((vc) => vc.walletName === 'dynamicwaas' &&
             vc.format === sdkApiCore.JwtVerifiedCredentialFormatEnum.Blockchain);
         const hasWalletNeedingDelegation = waasCredentials.some((vc) => {
-            var _a, _b, _c, _d, _e;
-            // Check if already delegated (has delegated keyShare)
-            const hasDelegatedKeyShare = (_b = (_a = vc.walletProperties) === null || _a === void 0 ? void 0 : _a.keyShares) === null || _b === void 0 ? void 0 : _b.some((keyShare) => keyShare.backupLocation === 'delegated');
-            // Check if denied
-            const hasDeniedAccess = ((_d = (_c = vc.walletProperties) === null || _c === void 0 ? void 0 : _c.settings) === null || _d === void 0 ? void 0 : _d.hasDeniedDelegatedAccess) === true;
-            // Check if dismissed this session
-            const isDismissedThisSession = (_e = sessionState === null || sessionState === void 0 ? void 0 : sessionState.dismissedWallets) === null || _e === void 0 ? void 0 : _e.includes(vc.id);
-            // Needs delegation if: not delegated, not denied, and not dismissed this session
-            return (!hasDelegatedKeyShare && !hasDeniedAccess && !isDismissedThisSession);
+            var _a, _b, _c;
+            const isDelegated = isWalletDelegated(vc.walletProperties);
+            const hasDeniedAccess = ((_b = (_a = vc.walletProperties) === null || _a === void 0 ? void 0 : _a.settings) === null || _b === void 0 ? void 0 : _b.hasDeniedDelegatedAccess) === true;
+            const isDismissedThisSession = (_c = sessionState === null || sessionState === void 0 ? void 0 : sessionState.dismissedWallets) === null || _c === void 0 ? void 0 : _c.includes(vc.id);
+            return !isDelegated && !hasDeniedAccess && !isDismissedThisSession;
         });
         return hasWalletNeedingDelegation;
     }, [user === null || user === void 0 ? void 0 : user.verifiedCredentials, delegatedAccessEnabled, promptUsersOnSignIn]);
@@ -129,20 +133,18 @@ const useWalletDelegation = () => {
         // Map credentials to wallets with status
         return waasCredentials
             .map((vc) => {
-            var _a, _b, _c, _d, _e;
+            var _a, _b, _c;
             let status = 'pending';
-            // Check if wallet has delegated keyShare
-            const hasDelegatedKeyShare = (_b = (_a = vc.walletProperties) === null || _a === void 0 ? void 0 : _a.keyShares) === null || _b === void 0 ? void 0 : _b.some((keyShare) => keyShare.backupLocation === 'delegated');
-            // Check if user has denied delegation
-            const hasDeniedAccess = ((_d = (_c = vc.walletProperties) === null || _c === void 0 ? void 0 : _c.settings) === null || _d === void 0 ? void 0 : _d.hasDeniedDelegatedAccess) === true;
-            if (hasDelegatedKeyShare) {
+            const isDelegated = isWalletDelegated(vc.walletProperties);
+            const hasDeniedAccess = ((_b = (_a = vc.walletProperties) === null || _a === void 0 ? void 0 : _a.settings) === null || _b === void 0 ? void 0 : _b.hasDeniedDelegatedAccess) === true;
+            if (isDelegated) {
                 status = 'delegated';
             }
             else if (hasDeniedAccess) {
                 status = 'denied';
             }
             // Check if dismissed this session (UI state only)
-            const isDismissedThisSession = (_e = sessionState === null || sessionState === void 0 ? void 0 : sessionState.dismissedWallets) === null || _e === void 0 ? void 0 : _e.includes(vc.id);
+            const isDismissedThisSession = (_c = sessionState === null || sessionState === void 0 ? void 0 : sessionState.dismissedWallets) === null || _c === void 0 ? void 0 : _c.includes(vc.id);
             // Find corresponding wallet from userWallets
             const wallet = userWallets.find((w) => w.address === vc.address);
             if (!wallet) {
@@ -309,4 +311,5 @@ const useWalletDelegation = () => {
 };
 
 exports.getWalletsToDelegate = getWalletsToDelegate;
+exports.isWalletDelegated = isWalletDelegated;
 exports.useWalletDelegation = useWalletDelegation;

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

@@ -5,6 +5,14 @@ export type WalletWithStatus = Wallet & {
     status: WalletDelegationStatus;
     isDismissedThisSession?: boolean;
 };
+export declare const isWalletDelegated: (walletProperties: {
+    keyShares?: Array<{
+        backupLocation?: string;
+    }>;
+    otherShareSets?: Array<{
+        shareSetType?: string;
+    }>;
+} | null | undefined) => boolean;
 /**
  * Gets pending wallets that are eligible for delegation.
  * If wallets are provided and not empty, converts them to WalletWithStatus[] with pending status.

package/src/lib/utils/hooks/useWalletDelegation/useWalletDelegation.js

@@ -37,6 +37,14 @@ import { useDynamicWaas } from '../useDynamicWaas/useDynamicWaas.js';
 import { useRefreshAuth } from '../useRefreshAuth/useRefreshAuth.js';
 import { DelegationError } from './DelegationError.js';
 
+// Pre-share-set backends mark delegation via keyShares[].backupLocation='delegated';
+// share-set backends use otherShareSets[].shareSetType='delegated' instead.
+const isWalletDelegated = (walletProperties) => {
+    var _a, _b;
+    const hasDelegatedKeyShare = (_a = walletProperties === null || walletProperties === void 0 ? void 0 : walletProperties.keyShares) === null || _a === void 0 ? void 0 : _a.some((keyShare) => keyShare.backupLocation === 'delegated');
+    const hasDelegatedShareSet = (_b = walletProperties === null || walletProperties === void 0 ? void 0 : walletProperties.otherShareSets) === null || _b === void 0 ? void 0 : _b.some((shareSet) => shareSet.shareSetType === 'delegated');
+    return Boolean(hasDelegatedKeyShare || hasDelegatedShareSet);
+};
 /**
  * Gets pending wallets that are eligible for delegation.
  * If wallets are provided and not empty, converts them to WalletWithStatus[] with pending status.
@@ -83,15 +91,11 @@ const useWalletDelegation = () => {
         const waasCredentials = user.verifiedCredentials.filter((vc) => vc.walletName === 'dynamicwaas' &&
             vc.format === JwtVerifiedCredentialFormatEnum.Blockchain);
         const hasWalletNeedingDelegation = waasCredentials.some((vc) => {
-            var _a, _b, _c, _d, _e;
-            // Check if already delegated (has delegated keyShare)
-            const hasDelegatedKeyShare = (_b = (_a = vc.walletProperties) === null || _a === void 0 ? void 0 : _a.keyShares) === null || _b === void 0 ? void 0 : _b.some((keyShare) => keyShare.backupLocation === 'delegated');
-            // Check if denied
-            const hasDeniedAccess = ((_d = (_c = vc.walletProperties) === null || _c === void 0 ? void 0 : _c.settings) === null || _d === void 0 ? void 0 : _d.hasDeniedDelegatedAccess) === true;
-            // Check if dismissed this session
-            const isDismissedThisSession = (_e = sessionState === null || sessionState === void 0 ? void 0 : sessionState.dismissedWallets) === null || _e === void 0 ? void 0 : _e.includes(vc.id);
-            // Needs delegation if: not delegated, not denied, and not dismissed this session
-            return (!hasDelegatedKeyShare && !hasDeniedAccess && !isDismissedThisSession);
+            var _a, _b, _c;
+            const isDelegated = isWalletDelegated(vc.walletProperties);
+            const hasDeniedAccess = ((_b = (_a = vc.walletProperties) === null || _a === void 0 ? void 0 : _a.settings) === null || _b === void 0 ? void 0 : _b.hasDeniedDelegatedAccess) === true;
+            const isDismissedThisSession = (_c = sessionState === null || sessionState === void 0 ? void 0 : sessionState.dismissedWallets) === null || _c === void 0 ? void 0 : _c.includes(vc.id);
+            return !isDelegated && !hasDeniedAccess && !isDismissedThisSession;
         });
         return hasWalletNeedingDelegation;
     }, [user === null || user === void 0 ? void 0 : user.verifiedCredentials, delegatedAccessEnabled, promptUsersOnSignIn]);
@@ -125,20 +129,18 @@ const useWalletDelegation = () => {
         // Map credentials to wallets with status
         return waasCredentials
             .map((vc) => {
-            var _a, _b, _c, _d, _e;
+            var _a, _b, _c;
             let status = 'pending';
-            // Check if wallet has delegated keyShare
-            const hasDelegatedKeyShare = (_b = (_a = vc.walletProperties) === null || _a === void 0 ? void 0 : _a.keyShares) === null || _b === void 0 ? void 0 : _b.some((keyShare) => keyShare.backupLocation === 'delegated');
-            // Check if user has denied delegation
-            const hasDeniedAccess = ((_d = (_c = vc.walletProperties) === null || _c === void 0 ? void 0 : _c.settings) === null || _d === void 0 ? void 0 : _d.hasDeniedDelegatedAccess) === true;
-            if (hasDelegatedKeyShare) {
+            const isDelegated = isWalletDelegated(vc.walletProperties);
+            const hasDeniedAccess = ((_b = (_a = vc.walletProperties) === null || _a === void 0 ? void 0 : _a.settings) === null || _b === void 0 ? void 0 : _b.hasDeniedDelegatedAccess) === true;
+            if (isDelegated) {
                 status = 'delegated';
             }
             else if (hasDeniedAccess) {
                 status = 'denied';
             }
             // Check if dismissed this session (UI state only)
-            const isDismissedThisSession = (_e = sessionState === null || sessionState === void 0 ? void 0 : sessionState.dismissedWallets) === null || _e === void 0 ? void 0 : _e.includes(vc.id);
+            const isDismissedThisSession = (_c = sessionState === null || sessionState === void 0 ? void 0 : sessionState.dismissedWallets) === null || _c === void 0 ? void 0 : _c.includes(vc.id);
             // Find corresponding wallet from userWallets
             const wallet = userWallets.find((w) => w.address === vc.address);
             if (!wallet) {
@@ -304,4 +306,4 @@ const useWalletDelegation = () => {
     };
 };
 
-export { getWalletsToDelegate, useWalletDelegation };
+export { getWalletsToDelegate, isWalletDelegated, useWalletDelegation };

package/src/lib/widgets/DynamicWidget/components/ActiveWalletBalance/ActiveWalletBalance.cjs

@@ -127,6 +127,7 @@ require('../../views/ReceiveWalletFunds/ReceiveWalletFunds.cjs');
 require('../../../../store/state/multichainBalances.cjs');
 require('@dynamic-labs/store');
 require('../../../../shared/utils/functions/getInitialUrl/getInitialUrl.cjs');
+var optimisticShield = require('./optimisticShield.cjs');
 var TokenBalanceList = require('./TokenBalanceList/TokenBalanceList.cjs');
 
 /** Component to display token balances for the primary wallet */
@@ -153,6 +154,57 @@ const ActiveWalletBalance = ({ isLoading = false, }) => {
         includeNativeBalance: true,
     });
     const { tokenBalances: shieldedTokenBalances, isLoading: isLoadingShielded, refetch: refetchShielded, supportsShielded, } = useAleoShieldedBalances.useAleoShieldedBalances();
+    // Optimistic shield ledger. A shield broadcast resolves before the
+    //  public-balance mapping flips and well before the RecordScanner
+    //  index reflects the new private record, so naively trusting the
+    //  server feed shows a stale unshielded balance and an unchanged
+    //  shielded balance for ~10–90s after the user clicks. Pushing an
+    //  entry here deducts the burned amount from unshielded and prepends
+    //  / bumps the matching shielded row, then `reconcileOptimisticShields`
+    //  drops the entry as soon as either server feed catches up.
+    const [optimisticShields, setOptimisticShields] = React.useState([]);
+    const effectiveUnshieldedTokenBalances = React.useMemo(() => optimisticShield.applyOptimisticUnshieldedDeductions(unshieldedTokenBalances !== null && unshieldedTokenBalances !== void 0 ? unshieldedTokenBalances : [], optimisticShields), [unshieldedTokenBalances, optimisticShields]);
+    const effectiveShieldedTokenBalances = React.useMemo(() => optimisticShield.applyOptimisticShieldedAdditions(shieldedTokenBalances, optimisticShields), [shieldedTokenBalances, optimisticShields]);
+    // Reconcile + GC optimistic entries whenever either server feed
+    //  updates. The reconciler is pure; we short-circuit the state write
+    //  when nothing changed so downstream memos don't churn on every
+    //  refresh tick.
+    React.useEffect(() => {
+        setOptimisticShields((current) => {
+            if (current.length === 0)
+                return current;
+            const next = optimisticShield.reconcileOptimisticShields(current, unshieldedTokenBalances !== null && unshieldedTokenBalances !== void 0 ? unshieldedTokenBalances : [], shieldedTokenBalances, Date.now());
+            return next.length === current.length ? current : next;
+        });
+    }, [unshieldedTokenBalances, shieldedTokenBalances]);
+    // Push helper used by both the manual Shield Manually CTA and the
+    //  auto-shield hook so the optimistic UI semantics are identical
+    //  whichever flow dispatches the broadcast.
+    const recordOptimisticShield = React.useCallback((info) => {
+        const { token, amount } = info;
+        const matchingShielded = shieldedTokenBalances.find((t) => token.isNative
+            ? Boolean(t.isNative)
+            : !t.isNative && t.address === token.address);
+        setOptimisticShields((current) => {
+            var _a, _b, _c, _d;
+            return [
+                ...current,
+                {
+                    amount,
+                    createdAtMs: Date.now(),
+                    decimals: (_a = token.decimals) !== null && _a !== void 0 ? _a : 0,
+                    isNative: Boolean(token.isNative),
+                    logoURI: (_b = token.logoURI) !== null && _b !== void 0 ? _b : '',
+                    name: token.name,
+                    preShieldShieldedRaw: BigInt(Math.round((_c = matchingShielded === null || matchingShielded === void 0 ? void 0 : matchingShielded.rawBalance) !== null && _c !== void 0 ? _c : 0)),
+                    preShieldUnshieldedRaw: BigInt(Math.round((_d = token.rawBalance) !== null && _d !== void 0 ? _d : 0)),
+                    price: token.price,
+                    symbol: token.symbol,
+                    tokenAddress: token.address,
+                },
+            ];
+        });
+    }, [shieldedTokenBalances]);
     /**
      * Tab state for chains that have a shielded/unshielded split. Defaults to
      * shielded so Aleo wallets land on their primary balance type. Other
@@ -197,11 +249,22 @@ const ActiveWalletBalance = ({ isLoading = false, }) => {
     //  Manually CTA, which prompts the user-paid confirmation modal.
     const { isShielding: isAutoShielding, currentlyShieldingTokenKeys: autoShieldingTokenKeys, } = useAleoAutoShieldSponsoredTokens.useAleoAutoShieldSponsoredTokens({
         accountAddress: primaryWallet === null || primaryWallet === void 0 ? void 0 : primaryWallet.address,
-        onShielded: React.useCallback(() => _tslib.__awaiter(void 0, void 0, void 0, function* () {
-            yield fetchAccountBalances(true);
-            yield refetchShielded();
+        onShieldDispatched: recordOptimisticShield,
+        onShielded: React.useCallback(
+        // Parallel refresh — same reasoning as the manual shield path:
+        //  shield ops move value across both tabs, and serializing the
+        //  two refreshes doubled the visible latency for the Shielded
+        //  tab in the common case.
+        () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+            return Promise.all([fetchAccountBalances(true), refetchShielded()]).then(() => undefined);
         }), [fetchAccountBalances, refetchShielded]),
         shieldHandle: aleoShieldHandle,
+        // Auto-shield reads the raw server feed (not the optimistic one):
+        //  once we deduct optimistically the to-be-shielded token drops to
+        //  zero in the effective list, which would suppress the next
+        //  auto-shield run before this one finishes. The auto-shield hook
+        //  has its own per-session idempotency (`seenKeys`) so it won't
+        //  re-fire for the same token anyway.
         unshieldedTokenBalances: unshieldedTokenBalances,
     });
     // Liveness handle for the manual post-shield poll — set to true when
@@ -214,12 +277,25 @@ const ActiveWalletBalance = ({ isLoading = false, }) => {
             isUnmountedRef.current = true;
         };
     }, []);
+    // Latest server-side unshielded list mirrored into a ref so the
+    //  post-shield convergence check can read the freshest value after
+    //  each polled refresh. `unshieldedTokenBalances` is closure-captured
+    //  by `handleShieldToken` at callback construction time, so without
+    //  this ref the predicate would read the pre-shield list forever and
+    //  the poll would never exit early. Reads from the raw server feed,
+    //  NOT the optimistic one — convergence means "on-chain effect
+    //  observed", which is only meaningful against the actual server
+    //  state.
+    const unshieldedTokenBalancesRef = React.useRef(unshieldedTokenBalances);
+    React.useEffect(() => {
+        unshieldedTokenBalancesRef.current = unshieldedTokenBalances;
+    }, [unshieldedTokenBalances]);
     // Token currently awaiting user-paid fee confirmation. Set when
     //  Shield Manually is clicked on a token Feemaster doesn't sponsor;
     //  cleared on Cancel or after the modal's Shield button dispatches.
     const [pendingShieldToken, setPendingShieldToken] = React.useState(null);
     const handleShieldToken = React.useCallback((token) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
-        var _f;
+        var _f, _g;
         if (!aleoShieldHandle || shieldingAddress)
             return;
         // `rawBalance` is the atomic-units count redcoast surfaces (number).
@@ -229,6 +305,14 @@ const ActiveWalletBalance = ({ isLoading = false, }) => {
         const atomic = BigInt(Math.round((_f = token.rawBalance) !== null && _f !== void 0 ? _f : 0));
         if (atomic <= BigInt(0))
             return;
+        // Snapshot the pre-shield unshielded balance for the convergence
+        //  predicate below. Aleo's `transfer_public_to_private` burns the
+        //  public mapping value, so a successful shield must show up as a
+        //  drop in this token's `rawBalance`. Polling exits early once
+        //  that drop materializes — no need to keep refreshing on the
+        //  long-tail schedule when we've already observed the on-chain
+        //  effect.
+        const preShieldRawBalance = (_g = token.rawBalance) !== null && _g !== void 0 ? _g : 0;
         setShieldingAddress(token.address);
         let didBroadcast = false;
         try {
@@ -238,11 +322,22 @@ const ActiveWalletBalance = ({ isLoading = false, }) => {
                 tokenAddress: token.address,
             });
             didBroadcast = true;
-            // Refresh the unshielded list so the just-shielded balance drops to
-            // 0 in the redcoast feed. The shielded side will pick the new
-            // record up on its own polling once the RecordScanner indexes.
-            yield fetchAccountBalances(true);
-            yield refetchShielded();
+            // Optimistic balance update: deduct the burned amount from
+            //  unshielded and bump (or synthesise) the matching shielded
+            //  row before the server-side feeds catch up. Without this the
+            //  Shield Manually CTA flickers back into view during the
+            //  indexing tail and a fast user can issue a second shield
+            //  that fails server-side (validator rejects the now-zero
+            //  public balance) and looks to them like the first one
+            //  failed.
+            recordOptimisticShield({ amount: atomic, token });
+            // Refresh both tabs in parallel. Shield moves value across the
+            //  shielded/unshielded boundary, so both lists need to
+            //  converge. Running them in parallel (vs. sequential) halves
+            //  the visible refresh latency and shortens the window where
+            //  `useTokenBalances`' `isLoading` guard could drop a
+            //  concurrent fetch.
+            yield Promise.all([fetchAccountBalances(true), refetchShielded()]);
         }
         catch (err) {
             logger.logger.debug('[ActiveWalletBalance] shieldToken failed', err);
@@ -253,7 +348,7 @@ const ActiveWalletBalance = ({ isLoading = false, }) => {
         // The relay-accepted broadcast resolves *before* the
         //  public→private transition finalizes on-chain, so the immediate
         //  refresh above sees the pre-confirmation balance. Re-poll on the
-        //  shared backoff so the Unshielded row visibly drops to 0 and the
+        //  shared backoff so the Unshielded row visibly drops and the
         //  Shielded row picks the new record up without a manual reload.
         //  Polling is best-effort — errors are swallowed inside
         //  `pollOnShielded`. Skip when the broadcast itself failed; there's
@@ -261,10 +356,27 @@ const ActiveWalletBalance = ({ isLoading = false, }) => {
         if (!didBroadcast)
             return;
         yield pollOnShielded.pollOnShielded(() => _tslib.__awaiter(void 0, void 0, void 0, function* () {
-            yield fetchAccountBalances(true);
-            yield refetchShielded();
-        }), () => isUnmountedRef.current);
-    }), [aleoShieldHandle, fetchAccountBalances, refetchShielded, shieldingAddress]);
+            yield Promise.all([fetchAccountBalances(true), refetchShielded()]);
+        }), () => isUnmountedRef.current, () => {
+            var _a, _b;
+            // Convergence: the just-shielded token's unshielded raw
+            //  balance has dropped below the pre-shield value. We read
+            //  via the ref so we see whatever the store published after
+            //  the most recent poll, not the closure-captured list from
+            //  callback construction time. We don't require an exact 0
+            //  — additional unshielded credits could land between scans;
+            //  any decrease is sufficient evidence the burn took effect.
+            const current = (_a = unshieldedTokenBalancesRef.current) === null || _a === void 0 ? void 0 : _a.find((t) => t.address === token.address && t.isNative === token.isNative);
+            const currentRaw = (_b = current === null || current === void 0 ? void 0 : current.rawBalance) !== null && _b !== void 0 ? _b : 0;
+            return currentRaw < preShieldRawBalance;
+        });
+    }), [
+        aleoShieldHandle,
+        fetchAccountBalances,
+        recordOptimisticShield,
+        refetchShielded,
+        shieldingAddress,
+    ]);
     const getSecondaryAction = React.useCallback((token) => {
         // Only on the Unshielded tab, only when the connector exposes shield
         // helpers, only for tokens registered as shieldable, only for tokens
@@ -327,12 +439,12 @@ const ActiveWalletBalance = ({ isLoading = false, }) => {
         shieldingAddress,
     ]);
     const tokenBalances = React.useMemo(() => supportsShielded && activeShieldTab === 'shielded'
-        ? shieldedTokenBalances
-        : unshieldedTokenBalances, [
+        ? effectiveShieldedTokenBalances
+        : effectiveUnshieldedTokenBalances, [
         activeShieldTab,
-        shieldedTokenBalances,
+        effectiveShieldedTokenBalances,
+        effectiveUnshieldedTokenBalances,
         supportsShielded,
-        unshieldedTokenBalances,
     ]);
     const filteredTokenBalances = React.useMemo(() => (tokenBalances === null || tokenBalances === void 0 ? void 0 : tokenBalances.filter((token) => token.name)) || [], [tokenBalances]);
     const totalValue = React.useMemo(() => filteredTokenBalances.reduce((acc, token) => acc + ((token === null || token === void 0 ? void 0 : token.marketValue) || 0), 0), [filteredTokenBalances]);
@@ -375,8 +487,14 @@ const ActiveWalletBalance = ({ isLoading = false, }) => {
         setIsRefreshing(true);
         setIsSuccess(false);
         try {
-            if (supportsShielded && activeShieldTab === 'shielded') {
-                yield refetchShielded();
+            // Chains with a shielded/unshielded split (Aleo) refresh BOTH
+            //  tabs on a single click. A shield op moves value across the
+            //  boundary, so refreshing only the active tab leaves the other
+            //  visibly stale — the original complaint that drove this fix.
+            //  Other chains never had `refetchShielded` (no-op fallback) so
+            //  they still just hit `fetchAccountBalances` here.
+            if (supportsShielded) {
+                yield Promise.all([refetchShielded(), fetchAccountBalances(true)]);
             }
             else {
                 yield fetchAccountBalances(true);
@@ -400,7 +518,6 @@ const ActiveWalletBalance = ({ isLoading = false, }) => {
         fetchAccountBalances,
         refetchShielded,
         supportsShielded,
-        activeShieldTab,
     ]);
     const primaryWalletNativeBalance = () => {
         if (!primaryWallet ||