fix(icons): compare every render-affecting prop in AssetIcon's memo

AssetIcon's custom memo comparator only compared the icon map and the two
security flags, so a surviving instance whose asset changed while the icon map
stayed deeply equal kept the previous asset's logo or loading state on
screen. That gap predates this branch — the comparator already ignored the
code the native check used to depend on — and now that the check also reads
the issuer, both halves of the asset's identity have to be compared. Compare
code, issuer, icon and the shape flags alongside the icon map; the retry
callback stays excluded because its identity is unstable and it does not
affect the render. Two rerender tests pin an identity change over an equal
icon map in both directions.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: CassioMG

extension/src/popup/components/account/AccountAssets/__tests__/AssetIcon.test.tsx

@@ -45,4 +45,57 @@ describe("AssetIcon", () => {
       FETCHED_ICON,
     );
   });
+
+  // The component is memoised with a custom comparator. When only the asset's
+  // identity changes on a surviving instance — the icon map staying deeply
+  // equal — the comparator must still let the render through, or the previous
+  // asset's logo stays on screen.
+  describe("re-rendering a surviving instance with a new asset identity", () => {
+    const wrap = (props: {
+      code: string;
+      issuerKey?: string;
+      assetIcons: Record<string, string>;
+    }) => (
+      <Wrapper state={{}} routes={["/"]}>
+        <AssetIcon {...props} />
+      </Wrapper>
+    );
+
+    it("re-renders when the native asset becomes a classic asset using the native code", () => {
+      const { rerender } = renderIcon({ code: "XLM", assetIcons: {} });
+      expect(screen.getByAltText("XLM logo")).toHaveAttribute(
+        "src",
+        BUNDLED_LOGO,
+      );
+
+      rerender(
+        wrap({ code: "XLM", issuerKey: XLM_CODED_ISSUER, assetIcons: {} }),
+      );
+
+      // Same (empty) icon map, different identity: no bundled logo any more —
+      // the icon now has to be looked up, so the loading state shows.
+      expect(screen.queryByAltText("XLM logo")).not.toBeInTheDocument();
+      expect(
+        screen.getByTestId("AccountAssets__asset--loading"),
+      ).toBeInTheDocument();
+    });
+
+    it("re-renders when a classic asset using the native code becomes the native asset", () => {
+      const { rerender } = renderIcon({
+        code: "XLM",
+        issuerKey: XLM_CODED_ISSUER,
+        assetIcons: {},
+      });
+      expect(
+        screen.getByTestId("AccountAssets__asset--loading"),
+      ).toBeInTheDocument();
+
+      rerender(wrap({ code: "XLM", assetIcons: {} }));
+
+      expect(screen.getByAltText("XLM logo")).toHaveAttribute(
+        "src",
+        BUNDLED_LOGO,
+      );
+    });
+  });
 });

extension/src/popup/components/account/AccountAssets/index.tsx

@@ -63,11 +63,23 @@ interface AssetIconProps {
   isModal?: boolean;
 }
 
+// Skip a re-render only when nothing that affects the rendered icon changed.
+// `assetIcons` is compared deeply because callers build it per render; the
+// retry callback is left out because its identity is unstable and it does not
+// affect what is rendered. Every other prop feeds the render — the asset's
+// identity (code + issuer) decides between the bundled native logo, a Soroban
+// placeholder and an icon lookup — so each has to be compared.
 const shouldAssetIconSkipUpdate = (
   prevProps: AssetIconProps,
   nextProps: AssetIconProps,
 ) =>
   isEqual(prevProps.assetIcons, nextProps.assetIcons) &&
+  prevProps.code === nextProps.code &&
+  prevProps.issuerKey === nextProps.issuerKey &&
+  prevProps.icon === nextProps.icon &&
+  prevProps.isLPShare === nextProps.isLPShare &&
+  prevProps.isSorobanToken === nextProps.isSorobanToken &&
+  prevProps.isModal === nextProps.isModal &&
   prevProps.isSuspicious === nextProps.isSuspicious &&
   prevProps.isMalicious === nextProps.isMalicious;