Fix preset theme + custom policy override precedence

packages/controller/src/iframe/keychain.ts

@@ -93,17 +93,24 @@ export class KeychainIFrame extends IFrame<Keychain> {
       _url.searchParams.set("username", encodeURIComponent(username));
     }
 
+    if (preset) {
+      _url.searchParams.set("preset", preset);
+    }
+
+    if (shouldOverridePresetPolicies) {
+      _url.searchParams.set("should_override_preset_policies", "true");
+    }
+
     // Policy precedence logic:
     // 1. If shouldOverridePresetPolicies is true and policies are provided, use policies
-    // 2. Otherwise, if preset is defined, use empty object (let preset take precedence)
-    // 3. Otherwise, use provided policies or empty object
+    // 2. Otherwise, if preset is defined, ignore provided policies
+    // 3. Otherwise, use provided policies
     if ((!preset || shouldOverridePresetPolicies) && policies) {
       _url.searchParams.set(
         "policies",
         encodeURIComponent(JSON.stringify(policies)),
       );
     } else if (preset) {
-      _url.searchParams.set("preset", preset);
       if (policies) {
         console.warn(
           "[Controller] Both `preset` and `policies` provided to ControllerProvider. " +

packages/keychain/src/hooks/connection.test.ts

@@ -1,6 +1,14 @@
-import { isOriginVerified } from "./connection";
+import { isOriginVerified, resolvePolicies } from "./connection";
 import { vi } from "vitest";
 
+vi.mock("@cartridge/controller", async () => {
+  const actual = await vi.importActual("@cartridge/controller");
+  return {
+    ...actual,
+    getPresetSessionPolicies: vi.fn(() => undefined),
+  };
+});
+
 describe("isOriginVerified", () => {
   const allowedOrigins = ["example.com", "*.example.com", "sub.test.com"];
 
@@ -325,6 +333,63 @@ describe("Config Loading and Verification Separation", () => {
   });
 });
 
+describe("resolvePolicies", () => {
+  const encodedPolicies = encodeURIComponent(
+    JSON.stringify({
+      contracts: {
+        "0x1": {
+          methods: [{ entrypoint: "transfer" }],
+        },
+      },
+    }),
+  );
+
+  it("uses URL policies when shouldOverridePresetPolicies is true", () => {
+    const result = resolvePolicies({
+      policiesStr: encodedPolicies,
+      preset: "some-preset",
+      shouldOverridePresetPolicies: true,
+      configData: null,
+      chainId: undefined,
+      verified: false,
+      isConfigLoading: true,
+    });
+
+    expect(result.isPoliciesResolved).toBe(true);
+    expect(result.policies).toBeDefined();
+  });
+
+  it("falls back to URL policies when preset has no chain policies", () => {
+    const result = resolvePolicies({
+      policiesStr: encodedPolicies,
+      preset: "some-preset",
+      shouldOverridePresetPolicies: false,
+      configData: {},
+      chainId: "0x534e5f534550",
+      verified: true,
+      isConfigLoading: false,
+    });
+
+    expect(result.isPoliciesResolved).toBe(true);
+    expect(result.policies).toBeDefined();
+  });
+
+  it("waits for config when preset is present and override is not active", () => {
+    const result = resolvePolicies({
+      policiesStr: encodedPolicies,
+      preset: "some-preset",
+      shouldOverridePresetPolicies: false,
+      configData: null,
+      chainId: undefined,
+      verified: true,
+      isConfigLoading: true,
+    });
+
+    expect(result.isPoliciesResolved).toBe(false);
+    expect(result.policies).toBeUndefined();
+  });
+});
+
 describe("URL rpc_url priority over stored controller rpcUrl", () => {
   beforeEach(() => {
     vi.clearAllMocks();

packages/keychain/src/hooks/connection.ts

@@ -168,6 +168,53 @@ function getConfigChainPolicies(
   return undefined;
 }
 
+export function resolvePolicies({
+  policiesStr,
+  preset,
+  shouldOverridePresetPolicies,
+  configData,
+  chainId,
+  verified,
+  isConfigLoading,
+}: {
+  policiesStr: string | null;
+  preset: string | null;
+  shouldOverridePresetPolicies: boolean;
+  configData: Record<string, unknown> | null;
+  chainId: string | undefined;
+  verified: boolean;
+  isConfigLoading: boolean;
+}): {
+  policies: ParsedSessionPolicies | undefined;
+  isPoliciesResolved: boolean;
+} {
+  const urlPolicies = parseUrlPolicies(policiesStr);
+
+  if (shouldOverridePresetPolicies && urlPolicies) {
+    return { policies: urlPolicies, isPoliciesResolved: true };
+  }
+
+  if (preset) {
+    if (isConfigLoading || !chainId) {
+      return { policies: undefined, isPoliciesResolved: false };
+    }
+
+    const configPolicies = getConfigChainPolicies(
+      configData,
+      chainId,
+      verified,
+    );
+    if (configPolicies) {
+      return { policies: configPolicies, isPoliciesResolved: true };
+    }
+
+    // Preset exists but has no policies for this chain; fall back to URL policies.
+    return { policies: urlPolicies, isPoliciesResolved: true };
+  }
+
+  return { policies: urlPolicies, isPoliciesResolved: true };
+}
+
 export function useConnectionValue() {
   const { navigate } = useNavigation();
   const [parent, setParent] = useState<ParentMethods>();
@@ -249,6 +296,7 @@ export function useConnectionValue() {
     theme: string | null;
     preset: string | null;
     policies: string | null;
+    shouldOverridePresetPolicies: boolean;
     version: string | null;
     project: string | null;
     namespace: string | null;
@@ -267,6 +315,8 @@ export function useConnectionValue() {
       : urlParams.get("preset");
     const rpcUrl = urlParams.get("rpc_url");
     const policies = urlParams.get("policies");
+    const shouldOverridePresetPolicies =
+      urlParams.get("should_override_preset_policies") === "true";
     const version = urlParams.get("v");
     const project = urlParams.get("ps");
     const namespace = urlParams.get("ns");
@@ -302,6 +352,10 @@ export function useConnectionValue() {
       theme: theme || urlParamsRef.current?.theme || null,
       preset: preset || urlParamsRef.current?.preset || null,
       policies: policies || urlParamsRef.current?.policies || null,
+      shouldOverridePresetPolicies:
+        shouldOverridePresetPolicies ||
+        urlParamsRef.current?.shouldOverridePresetPolicies ||
+        false,
       version: version || urlParamsRef.current?.version || null,
       project: project || urlParamsRef.current?.project || null,
       namespace: namespace || urlParamsRef.current?.namespace || null,
@@ -605,38 +659,24 @@ export function useConnectionValue() {
 
   // Handle policies configuration
   useEffect(() => {
-    const { policies, preset } = urlParams;
-
-    // Always prioritize preset policies over URL policies
-    if (preset) {
-      if (isConfigLoading || !chainId) {
-        setIsPoliciesResolved(false);
-        return;
-      }
-
-      const configPolicies = getConfigChainPolicies(
+    const {
+      policies: policyStr,
+      preset,
+      shouldOverridePresetPolicies,
+    } = urlParams;
+    const { policies: resolvedPolicies, isPoliciesResolved: resolved } =
+      resolvePolicies({
+        policiesStr: policyStr,
+        preset,
+        shouldOverridePresetPolicies,
         configData,
         chainId,
         verified,
-      );
-
-      if (configPolicies) {
-        setPolicies(configPolicies);
-        setIsPoliciesResolved(true);
-        return;
-      }
-
-      setIsPoliciesResolved(true);
-      return;
-    }
-
-    // Fall back to URL policies if no preset or preset has no policies
-    const urlPolicies = parseUrlPolicies(policies);
-    if (urlPolicies) {
-      setPolicies(urlPolicies);
-    }
+        isConfigLoading,
+      });
 
-    setIsPoliciesResolved(true);
+    setPolicies(resolvedPolicies);
+    setIsPoliciesResolved(resolved);
   }, [urlParams, chainId, verified, configData, isConfigLoading]);
 
   useThemeEffect({ theme, assetUrl: "" });