React to gateway option changes without a remount

Enabling 'Fetch IPFS content through a gateway' had no effect on NFTs
already on screen: useNFTVerifyHash never re-ran (nothing depended on
the preference), and a failed ipfs metadata fetch stayed cached in the
NFT provider, so those NFTs kept looking broken until a full app
reload (Bugbot, PR Chia-Network#3029).

- Both verification effects in useNFTVerifyHash now list the
  preference as a dependency, so flipping it re-checks data and
  preview URIs immediately.
- useMetadataData retries cached metadata failures when the preference
  flips - only failures: successfully fetched metadata is hash-verified
  content and unaffected by how it was fetched. The retry goes through
  invalidate, whose refetch notifies mounted subscribers.

The cache layer needs no matching change: gateway-disabled fetch
refusals are never persisted, so the re-run's fresh requests go
through cleanly.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017NXWAjaHb9SFafLeguTHd8

Author: jlobue10

packages/gui/src/components/nfts/provider/hooks/useMetadataData.ts

@@ -2,12 +2,13 @@ import { EventEmitter } from 'events';
 
 import { type NFTInfo } from '@chia-network/api';
 import debug from 'debug';
-import { useState, useCallback, useMemo } from 'react';
+import { useState, useCallback, useEffect, useMemo, useRef } from 'react';
 
 import type Metadata from '../../../../@types/Metadata';
 import type MetadataOnDemand from '../../../../@types/MetadataOnDemand';
 import type MetadataState from '../../../../@types/MetadataState';
 import useFetchAndProcessMetadata from '../../../../hooks/useFetchAndProcessMetadata';
+import useIpfsGateway from '../../../../hooks/useIpfsGateway';
 import getNFTId from '../../../../util/getNFTId';
 
 const log = debug('chia-gui:NFTProvider:useMetadataData');
@@ -159,6 +160,30 @@ export default function useMetadataData(props: UseMetadataDataProps) {
     [getMetadata /* immutable */, metadatasOnDemand /* immutable */],
   );
 
+  const [ipfsGateway] = useIpfsGateway();
+  const lastIpfsGatewayRef = useRef(ipfsGateway);
+
+  useEffect(() => {
+    if (lastIpfsGatewayRef.current === ipfsGateway) {
+      return;
+    }
+    lastIpfsGatewayRef.current = ipfsGateway;
+
+    // Flipping the gateway option changes which URIs the main process will
+    // fetch, so cached failures are stale — without this, a failed ipfs
+    // metadata fetch stayed cached here and its NFT kept looking broken
+    // after enabling the option, until a full app reload. Only failures are
+    // retried: successfully fetched metadata is hash-verified content and
+    // unaffected by how it was fetched.
+    metadatasOnDemand.forEach((metadataOnDemand, nftId) => {
+      if (metadataOnDemand.error) {
+        invalidate(nftId).catch((e) => {
+          log(`Error retrying metadata for nftId: ${nftId}`, e);
+        });
+      }
+    });
+  }, [ipfsGateway, invalidate /* immutable */, metadatasOnDemand /* immutable */]);
+
   // immutable function
   const subscribeToMetadataChanges = useCallback(
     (id: string | undefined, callback: (nftState: MetadataState) => void) => {

packages/gui/src/hooks/useNFTVerifyHash.ts

@@ -7,6 +7,7 @@ import compareChecksums from '../util/compareChecksums';
 
 import selectNFTPreviewState, { type NFTPreviewState } from './selectNFTPreviewState';
 import useCache from './useCache';
+import useIpfsGateway from './useIpfsGateway';
 import useNFT from './useNFT';
 import useNFTMetadata from './useNFTMetadata';
 
@@ -21,6 +22,11 @@ export default function useNFTVerifyHash(nftId?: string, options: UseNFTVerifyHa
   const { preview = false, ignoreSizeLimit = false } = options;
 
   const { getChecksum } = useCache();
+  // Not read directly: the value changes which URIs the main process will
+  // fetch at all, so both verification effects list it as a dependency and
+  // re-run when the user flips the option — without this, NFTs already on
+  // screen would keep their failed state until a remount.
+  const [ipfsGateway] = useIpfsGateway();
 
   const { nft, isLoading: isLoadingNFT, error: errorNFT } = useNFT(nftId);
   const { isLoading: isLoadingMetadata, metadata, error: errorMetadata } = useNFTMetadata(nftId);
@@ -201,7 +207,7 @@ export default function useNFTVerifyHash(nftId?: string, options: UseNFTVerifyHa
         dataGeneration.current += 1;
       }
     };
-  }, [nft, isLoadingNFT, validateData]);
+  }, [nft, isLoadingNFT, validateData, ipfsGateway]);
 
   useEffect(() => {
     const generation = previewGeneration.current + 1;
@@ -227,7 +233,7 @@ export default function useNFTVerifyHash(nftId?: string, options: UseNFTVerifyHa
         previewGeneration.current += 1;
       }
     };
-  }, [preview, nft, metadata, isLoadingNFT, isLoadingMetadata, validatePreview]);
+  }, [preview, nft, metadata, isLoadingNFT, isLoadingMetadata, validatePreview, ipfsGateway]);
 
   const previewState = useMemo(
     () =>