@oxyhq/services 28.0.0 → 30.0.0

package/src/ui/session/sharedDeviceCredentialStore.ts

@@ -0,0 +1,318 @@
+/**
+ * The platform half of the shared native DeviceSession credential.
+ *
+ * `@oxyhq/core` owns the rules (`sharedDeviceCredential.ts`: when to adopt, when
+ * to publish, and above all that an unreadable slot is never an empty one). This
+ * module owns only where the bytes live, which is genuinely different per
+ * platform:
+ *
+ *  - **iOS** — one `expo-secure-store` item in the approved Keychain Access Group
+ *    `group.so.oxy.shared`, under its OWN `keychainService`
+ *    ({@link IOS_DEVICE_SESSION_KEYCHAIN_SERVICE}). Every identity slot uses a
+ *    different service (`oxy_identity`, `oxy_identity_backup`,
+ *    `oxy_identity_mnemonic`) and the legacy cross-app identity keypair uses the
+ *    same group with NO service at all — so this item cannot alias any of them.
+ *    That separation is the point of the whole phase: the group-shared identity
+ *    key and the group-shared device-session credential are different secrets
+ *    with different blast radii and must not be conflated.
+ *  - **Android** — the signature-protected `OxyDeviceSession` broker (its own
+ *    EncryptedSharedPreferences file, its own ContentProvider, its own
+ *    `signature`-level permission). It carries a session credential; it can NOT
+ *    reach the identity keypair, which lives in a different file behind a
+ *    different provider.
+ *  - **web / anything else** — no shared slot. Each origin is its own device by
+ *    design, so the factory returns `null` and the cold boot simply omits the
+ *    lane.
+ *
+ * ## What is written here, and what is not
+ *
+ * Only `{deviceId, deviceSecret}`. No access token, no account id, no user id,
+ * and never any identity key material.
+ *
+ * ## Accessibility
+ *
+ * `WHEN_UNLOCKED_THIS_DEVICE_ONLY`: a device credential must not travel to
+ * another handset in an iCloud/encrypted backup restore — the restored device is
+ * a different device and has to establish its own session. It also keeps the item
+ * out of reach while the phone is locked, which is why a read can legitimately
+ * fail and why the `unavailable` verdict exists at all.
+ */
+import { Platform } from 'react-native';
+import { requireOptionalNativeModule } from 'expo-modules-core';
+import {
+  normalizeSharedDeviceSessionRead,
+  type SharedDeviceCredential,
+  type SharedDeviceCredentialRead,
+  type SharedDeviceCredentialStore,
+} from '@oxyhq/core';
+
+/**
+ * The iOS Keychain Access Group every official Oxy app declares in its
+ * entitlements. Shared with the identity slots — the group is the app-group
+ * boundary, not the secret's identity.
+ */
+export const IOS_KEYCHAIN_ACCESS_GROUP = 'group.so.oxy.shared';
+
+/**
+ * The iOS `keychainService` for the DEVICE SESSION credential. Deliberately
+ * distinct from every identity and recovery service; do not reuse one of those
+ * here, and do not drop it (an item written with no service shares the legacy
+ * identity slot's namespace inside the group).
+ */
+export const IOS_DEVICE_SESSION_KEYCHAIN_SERVICE = 'oxy_device_session';
+
+/** The single key holding the JSON-encoded `{deviceId, deviceSecret}` pair. */
+export const SHARED_DEVICE_SESSION_STORAGE_KEY = 'oxy_shared_device_session_v1';
+
+// Variable indirection so Metro's static analyzer never traces expo-secure-store
+// into the web bundle; the module is native-only and optional.
+const SECURE_STORE_MODULE = 'expo-secure-store';
+
+/**
+ * The subset of `expo-secure-store` this module needs. Unlike the adapter in
+ * `nativeSecureStorage.ts` it must pass OPTIONS — the access group and the
+ * dedicated service are the entire mechanism here, so an options-less wrapper
+ * would silently write a package-private item that no sibling app can see.
+ */
+interface KeychainGroupStore {
+  getItemAsync(key: string, options?: object): Promise<string | null>;
+  setItemAsync(key: string, value: string, options?: object): Promise<void>;
+  deleteItemAsync(key: string, options?: object): Promise<void>;
+  readonly WHEN_UNLOCKED_THIS_DEVICE_ONLY: number;
+}
+
+let keychainStorePromise: Promise<KeychainGroupStore | null> | null = null;
+
+function loadKeychainGroupStore(): Promise<KeychainGroupStore | null> {
+  if (!keychainStorePromise) {
+    const moduleName = SECURE_STORE_MODULE;
+    keychainStorePromise = import(moduleName)
+      .then((mod: Partial<KeychainGroupStore>) => {
+        if (
+          typeof mod.getItemAsync === 'function' &&
+          typeof mod.setItemAsync === 'function' &&
+          typeof mod.deleteItemAsync === 'function' &&
+          typeof mod.WHEN_UNLOCKED_THIS_DEVICE_ONLY === 'number'
+        ) {
+          return {
+            getItemAsync: mod.getItemAsync.bind(mod),
+            setItemAsync: mod.setItemAsync.bind(mod),
+            deleteItemAsync: mod.deleteItemAsync.bind(mod),
+            WHEN_UNLOCKED_THIS_DEVICE_ONLY: mod.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
+          } satisfies KeychainGroupStore;
+        }
+        return null;
+      })
+      .catch(() => null);
+  }
+  return keychainStorePromise;
+}
+
+/** Parse the stored JSON into a credential, or `null` for anything malformed. */
+function parseStoredCredential(raw: string | null): SharedDeviceCredential | null {
+  if (!raw) {
+    return null;
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    return null;
+  }
+  const candidate = parsed as Record<string, unknown>;
+  if (
+    typeof candidate.deviceId !== 'string' ||
+    candidate.deviceId.length === 0 ||
+    typeof candidate.deviceSecret !== 'string' ||
+    candidate.deviceSecret.length === 0
+  ) {
+    return null;
+  }
+  return { deviceId: candidate.deviceId, deviceSecret: candidate.deviceSecret };
+}
+
+/**
+ * The iOS store: one keychain item in the shared access group.
+ *
+ * A THROWN read is `unavailable`, a `null` read is `absent`. That mapping is the
+ * whole safety contract — `expo-secure-store` returns `null` for a genuinely
+ * missing item and throws when the keychain itself refuses, and collapsing the
+ * two is what would let a locked phone look like a device that never had a
+ * session.
+ */
+function createKeychainGroupCredentialStore(): SharedDeviceCredentialStore {
+  const readOptions = {
+    keychainService: IOS_DEVICE_SESSION_KEYCHAIN_SERVICE,
+    keychainAccessGroup: IOS_KEYCHAIN_ACCESS_GROUP,
+  };
+
+  return {
+    read: async (): Promise<SharedDeviceCredentialRead> => {
+      const store = await loadKeychainGroupStore();
+      if (!store) {
+        return { state: 'unsupported' };
+      }
+      let raw: string | null;
+      try {
+        raw = await store.getItemAsync(SHARED_DEVICE_SESSION_STORAGE_KEY, readOptions);
+      } catch (error) {
+        return { state: 'unavailable', cause: error };
+      }
+      if (raw === null) {
+        return { state: 'absent' };
+      }
+      const credential = parseStoredCredential(raw);
+      if (!credential) {
+        // Something IS stored and we cannot read it. Reporting `absent` would
+        // authorise overwriting whatever a newer build put there.
+        return {
+          state: 'unavailable',
+          cause: new Error('shared device session item is present but not parseable'),
+        };
+      }
+      return { state: 'present', credential };
+    },
+
+    publish: async (credential): Promise<boolean> => {
+      const store = await loadKeychainGroupStore();
+      if (!store) {
+        return false;
+      }
+      const value = JSON.stringify(credential);
+      try {
+        await store.setItemAsync(SHARED_DEVICE_SESSION_STORAGE_KEY, value, {
+          ...readOptions,
+          keychainAccessible: store.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
+        });
+        // Read-back verify. A keychain write can resolve without the item having
+        // landed under the access group (a missing entitlement is the usual
+        // cause), and a phantom credential would send a fresh install into a mint
+        // that can never succeed.
+        return (await store.getItemAsync(SHARED_DEVICE_SESSION_STORAGE_KEY, readOptions)) === value;
+      } catch {
+        return false;
+      }
+    },
+
+    clear: async (): Promise<void> => {
+      const store = await loadKeychainGroupStore();
+      if (!store) {
+        return;
+      }
+      try {
+        await store.deleteItemAsync(SHARED_DEVICE_SESSION_STORAGE_KEY, readOptions);
+      } catch {
+        // Best-effort: the slot is a join point, not a source of truth.
+      }
+    },
+  };
+}
+
+/**
+ * The Android broker's JS surface. `read` returns an UNTRUSTED payload that
+ * {@link normalizeSharedDeviceSessionRead} narrows; `write` reports whether the
+ * native read-back confirmed the bytes.
+ */
+interface OxyDeviceSessionNativeModule {
+  read(): Promise<unknown>;
+  write(deviceId: string, deviceSecret: string): Promise<boolean>;
+  clear(): Promise<void>;
+}
+
+let brokerModule: OxyDeviceSessionNativeModule | null | undefined;
+
+/**
+ * Resolve the `OxyDeviceSession` broker, or `null` when it is not autolinked.
+ *
+ * `requireOptionalNativeModule` (a static import Metro always resolves) rather
+ * than a dynamic `import(moduleName)`: the latter compiles to `require(variable)`
+ * in the CJS build, which Metro cannot resolve inside a consuming app — it
+ * silently returns `null` there, which is exactly how the cross-app identity
+ * bridge broke once. Same reasoning as `backgroundSession.ts` next door.
+ */
+function loadBrokerModule(): OxyDeviceSessionNativeModule | null {
+  if (brokerModule === undefined) {
+    const native = requireOptionalNativeModule<Partial<OxyDeviceSessionNativeModule>>('OxyDeviceSession');
+    brokerModule =
+      native && typeof native.read === 'function' && typeof native.write === 'function' && typeof native.clear === 'function'
+        ? {
+            read: native.read.bind(native),
+            write: native.write.bind(native),
+            clear: native.clear.bind(native),
+          }
+        : null;
+  }
+  return brokerModule;
+}
+
+/**
+ * The Android store: the signature-protected `OxyDeviceSession` broker.
+ *
+ * The broker already answers with an explicit status, so the only work here is
+ * narrowing an UNTRUSTED payload — `normalizeSharedDeviceSessionRead` resolves
+ * anything it does not recognise to `unavailable`, never `absent`.
+ */
+function createBrokerCredentialStore(): SharedDeviceCredentialStore {
+  return {
+    read: async (): Promise<SharedDeviceCredentialRead> => {
+      const broker = loadBrokerModule();
+      if (!broker) {
+        return { state: 'unsupported' };
+      }
+      try {
+        return normalizeSharedDeviceSessionRead(await broker.read());
+      } catch (error) {
+        return { state: 'unavailable', cause: error };
+      }
+    },
+
+    publish: async (credential): Promise<boolean> => {
+      const broker = loadBrokerModule();
+      if (!broker) {
+        return false;
+      }
+      try {
+        // The broker read-back-verifies natively and returns the verdict.
+        return await broker.write(credential.deviceId, credential.deviceSecret);
+      } catch {
+        return false;
+      }
+    },
+
+    clear: async (): Promise<void> => {
+      const broker = loadBrokerModule();
+      if (!broker) {
+        return;
+      }
+      try {
+        await broker.clear();
+      } catch {
+        // Best-effort — see the iOS store.
+      }
+    },
+  };
+}
+
+/**
+ * The shared DeviceSession credential slot for this runtime, or `null` when
+ * there is none.
+ *
+ * The branch is on the PLATFORM, not on which module happens to load, because
+ * `expo-secure-store` loads perfectly well on Android — it would just quietly
+ * ignore `keychainAccessGroup` and read a package-private item, which looks
+ * exactly like an empty shared slot. This is the same iOS-vs-Android split
+ * `KeyManager` makes for the shared identity, for the same reason.
+ *
+ * Any other native platform gets the broker, which answers `unsupported` when
+ * the module is not linked — so the lane is simply off, which is the safe
+ * direction.
+ */
+export function createPlatformSharedDeviceCredentialStore(): SharedDeviceCredentialStore | null {
+  if (Platform.OS === 'web') {
+    return null;
+  }
+  return Platform.OS === 'ios' ? createKeychainGroupCredentialStore() : createBrokerCredentialStore();
+}

package/src/ui/stores/authStore.ts

@@ -1,63 +1,191 @@
-import { create } from 'zustand';
-import { createLogger, normalizeUserIdentity } from '@oxyhq/core';
+import { useCallback, useRef, useSyncExternalStore } from 'react';
 import type { User } from '@oxyhq/core';
+import type { OxyRuntime } from '../runtime';
 
-const log = createLogger('AuthStore');
-
+/**
+ * The signed-in user, as a zustand-shaped read/write surface.
+ *
+ * It used to BE a zustand store, and that made it a second owner of the
+ * session: the provider wrote `user`/`isAuthenticated` here, `SessionClient`
+ * wrote the same facts into its device state, and nothing reconciled them —
+ * when they disagreed, which one was right was not answerable. It is now a
+ * projection of the ONE `OxyRuntime` (ADR 0004): reads come off the runtime
+ * snapshot and writes go into the runtime, so there is nothing left to drift.
+ *
+ * The zustand SHAPE is kept deliberately — `useAuthStore(selector)`,
+ * `.getState()`, `.setState()`, `.subscribe()` — because a dozen call sites
+ * across this package and the Commons app read the user out of band, from
+ * mutation success handlers and cache helpers that are not inside a render.
+ * Rewriting them is Phase 8's cut, not this one's.
+ *
+ * `fetchUser` and `lastUserFetch` are GONE rather than projected: they were a
+ * five-minute profile cache with zero readers anywhere in the monorepo, and the
+ * Query cache has owned that job since long before this change.
+ */
 export interface AuthState {
   user: User | null;
   isAuthenticated: boolean;
   isLoading: boolean;
   error: string | null;
-  lastUserFetch: number | null; // Timestamp of last user fetch for caching
-  
+
   loginSuccess: (user: User) => void;
   loginFailure: (error: string) => void;
   logout: () => void;
-  fetchUser: (oxyServices: { getCurrentUser: () => Promise<User> }, forceRefresh?: boolean) => Promise<void>;
-  setUser: (user: User) => void; // Direct user setter for caching
+  /** Replace the signed-in profile after a write (a rename, a new avatar). */
+  setUser: (user: User) => void;
 }
 
-export const useAuthStore = create<AuthState>((set: (state: Partial<AuthState>) => void, get: () => AuthState) => ({
+/** The subset of `AuthState` a caller may push back in through `setState`. */
+export type AuthStatePatch = Partial<Pick<AuthState, 'user' | 'isLoading' | 'error'>>;
+
+let boundRuntime: OxyRuntime | null = null;
+let unbindRuntime: (() => void) | null = null;
+const listeners = new Set<() => void>();
+
+const loginSuccess = (user: User): void => {
+  boundRuntime?.setAccount(user);
+};
+
+const loginFailure = (error: string): void => {
+  boundRuntime?.batch(() => {
+    boundRuntime?.setLoading(false);
+    boundRuntime?.setError(error);
+  });
+};
+
+const logout = (): void => {
+  boundRuntime?.clearSession();
+};
+
+const setUser = (user: User): void => {
+  boundRuntime?.setAccount(user);
+};
+
+const SIGNED_OUT: AuthState = Object.freeze({
   user: null,
   isAuthenticated: false,
   isLoading: false,
   error: null,
-  lastUserFetch: null,
-
-  loginSuccess: (user: User) => set({
-    isLoading: false,
-    isAuthenticated: true,
-    user: normalizeUserIdentity(user),
-    lastUserFetch: Date.now(),
-  }),
-  loginFailure: (error: string) => set({ isLoading: false, error }),
-  logout: () => set({
-    user: null,
-    isAuthenticated: false,
-    lastUserFetch: null,
-  }),
-  setUser: (user: User) => set({ user: normalizeUserIdentity(user), lastUserFetch: Date.now() }),
-  fetchUser: async (oxyServices, forceRefresh = false) => {
-    const state = get();
-    const now = Date.now();
-    const cacheAge = state.lastUserFetch ? now - state.lastUserFetch : Number.POSITIVE_INFINITY;
-    const cacheValid = cacheAge < 5 * 60 * 1000; // 5 minutes cache
-
-    // Use cached data if available and not forcing refresh
-    if (!forceRefresh && state.user && cacheValid) {
-      log.info('Using cached user data', { cacheAge });
+  loginSuccess,
+  loginFailure,
+  logout,
+  setUser,
+});
+
+let state: AuthState = SIGNED_OUT;
+
+function project(runtime: OxyRuntime | null): AuthState {
+  if (runtime === null) {
+    return SIGNED_OUT;
+  }
+  const snapshot = runtime.getSnapshot();
+  return Object.freeze({
+    user: snapshot.account,
+    isAuthenticated: snapshot.account !== null,
+    isLoading: snapshot.isLoading,
+    error: snapshot.error?.message ?? null,
+    loginSuccess,
+    loginFailure,
+    logout,
+    setUser,
+  });
+}
+
+function republish(): void {
+  const next = project(boundRuntime);
+  if (
+    next.user === state.user &&
+    next.isAuthenticated === state.isAuthenticated &&
+    next.isLoading === state.isLoading &&
+    next.error === state.error
+  ) {
+    return;
+  }
+  state = next;
+  for (const listener of [...listeners]) {
+    listener();
+  }
+}
+
+/**
+ * Point this surface at the provider's runtime. Called once by
+ * `OxyRuntimeProvider`; the returned function detaches it again on unmount.
+ *
+ * With nothing bound, reads answer signed-out and writes are dropped. That is
+ * the honest answer for the two places it happens — the SSR shim, and a unit
+ * test poking the store with no provider mounted — and it is why binding is an
+ * explicit call rather than a lazily-created default runtime, which is exactly
+ * the fabricated-forever-loading runtime ADR 0004 deleted.
+ */
+export function bindAuthStoreToRuntime(runtime: OxyRuntime): () => void {
+  unbindRuntime?.();
+  boundRuntime = runtime;
+  unbindRuntime = runtime.subscribe(republish);
+  republish();
+  return () => {
+    if (boundRuntime !== runtime) {
       return;
     }
+    unbindRuntime?.();
+    unbindRuntime = null;
+    boundRuntime = null;
+    republish();
+  };
+}
 
-    set({ isLoading: true, error: null });
-    try {
-      const user = normalizeUserIdentity(await oxyServices.getCurrentUser());
-      set({ user, isLoading: false, isAuthenticated: true, lastUserFetch: now });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Failed to fetch user';
-      log.error('Error fetching user', error);
-      set({ error: errorMessage, isLoading: false });
+const getState = (): AuthState => state;
+
+const setState = (patch: AuthStatePatch): void => {
+  boundRuntime?.batch(() => {
+    if (patch.isLoading !== undefined) {
+      boundRuntime?.setLoading(patch.isLoading);
+    }
+    if (patch.error !== undefined) {
+      boundRuntime?.setError(patch.error);
+    }
+    if (patch.user !== undefined) {
+      if (patch.user === null) {
+        boundRuntime?.clearSession();
+      } else {
+        boundRuntime?.setAccount(patch.user);
+      }
     }
-  },
-}));
+  });
+};
+
+const subscribe = (listener: () => void): (() => void) => {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+
+function useAuthStoreHook<T>(selector: (state: AuthState) => T): T {
+  // The selection is cached against the state object it came from, so a
+  // selector returning a fresh object cannot make `useSyncExternalStore` see a
+  // new value on every call and loop.
+  const cache = useRef<{ state: AuthState; value: T } | null>(null);
+  const getSelection = useCallback((): T => {
+    const cached = cache.current;
+    if (cached !== null && cached.state === state) {
+      return cached.value;
+    }
+    const value = selector(state);
+    cache.current = { state, value };
+    return value;
+  }, [selector]);
+  return useSyncExternalStore(subscribe, getSelection, getSelection);
+}
+
+/**
+ * Read the signed-in user. Zustand-shaped, projected from the runtime.
+ *
+ * A selector that builds an object must be wrapped in `useShallow` (as every
+ * call site here already does) — otherwise a structurally-equal result reads as
+ * a change on every publish.
+ */
+export const useAuthStore = Object.assign(useAuthStoreHook, {
+  getState,
+  setState,
+  subscribe,
+});

package/src/ui/types/navigation.ts

@@ -143,4 +143,30 @@ export interface OxyProviderProps {
      * @default false
      */
     backgroundSession?: boolean;
+    /**
+     * Whether this origin/app may persist the durable device credential
+     * (`deviceId` + `deviceSecret`) at all.
+     *
+     * `'persistent'` (the default, and every app's behaviour) stores it — web
+     * localStorage per origin, SecureStore per app on native — so the SDK can
+     * re-mint an access token on the next cold boot.
+     *
+     * `'ephemeral'` stores NOTHING durable: the session lives in memory for the
+     * lifetime of the page and is gone on reload. It exists for ONE caller,
+     * `auth.oxy.so` with the browser hub enabled (issue #937 Phase 5, ADR 0003),
+     * where the durable credential for the browser profile is the server-side
+     * DeviceSession behind the `__Host-oxy-device` handle. Two durable
+     * credentials for one origin is the dual authority that phase exists to
+     * remove — revoking the hub while a localStorage secret still mints would
+     * make a sign-out look like it worked — so the way to let the hub be
+     * authoritative is to stop persisting the other one, not to consult it
+     * second.
+     *
+     * Do NOT reach for this to make an app "more private". A relying-party
+     * origin set to `'ephemeral'` simply signs the user out on every reload,
+     * because nothing else on that origin remembers the device.
+     *
+     * @default 'persistent'
+     */
+    deviceCredentialStorage?: 'persistent' | 'ephemeral';
 }

package/src/ui/utils/avatarUtils.ts

@@ -1,7 +1,6 @@
 import { authenticatedApiCall } from '@oxyhq/core';
 import type { OxyServices, User } from '@oxyhq/core';
 import type { UserProfileUpdate } from '@oxyhq/contracts';
-import { useAccountStore } from '../stores/accountStore';
 import { useAuthStore } from '../stores/authStore';
 import type { QueryClient } from '@tanstack/react-query';
 import { queryKeys, invalidateUserQueries, invalidateAccountQueries } from '../hooks/queries/queryKeys';
@@ -11,28 +10,8 @@ import {
 } from '../hooks/queries/userCache';
 
 /**
- * Refreshes avatar in accountStore with cache-busted URL to force image reload.
- *
- * @param sessionId - The session ID for the account to update
- * @param avatarFileId - The new avatar file ID
- * @param oxyServices - OxyServices instance to generate download URL
- */
-export function refreshAvatarInStore(
-  sessionId: string,
-  avatarFileId: string,
-  oxyServices: OxyServices
-): void {
-  const { updateAccount } = useAccountStore.getState();
-  const cacheBustedUrl = `${oxyServices.getFileDownloadUrl(avatarFileId, 'thumb')}?t=${Date.now()}`;
-  updateAccount(sessionId, {
-    avatar: avatarFileId,
-    avatarUrl: cacheBustedUrl,
-  });
-}
-
-/**
- * Updates user profile with avatar and handles all side effects (query invalidation, accountStore update).
- * This function can be used from within OxyContext provider without requiring useOxy hook.
+ * Updates user profile with avatar and handles all side effects (cache writes,
+ * query invalidation). Usable from inside the provider without `useOxy`.
  *
  * @param updates - Profile updates including avatar
  * @param oxyServices - OxyServices instance
@@ -69,20 +48,6 @@ export async function updateProfileWithAvatar(
     cleared: cleared.length > 0 ? cleared : undefined,
   });
 
-  // If avatar was updated, refresh accountStore with a cache-busted URL. An
-  // EMPTY avatar is a removal: clear both fields so the switcher falls back to
-  // initials instead of pointing at a download URL for the empty file id.
-  if (typeof updates.avatar === 'string' && activeSessionId) {
-    if (updates.avatar) {
-      refreshAvatarInStore(activeSessionId, updates.avatar, oxyServices);
-    } else {
-      useAccountStore.getState().updateAccount(activeSessionId, {
-        avatar: undefined,
-        avatarUrl: undefined,
-      });
-    }
-  }
-
   // Invalidate all related queries to refresh everywhere
   invalidateUserQueries(queryClient);
   invalidateAccountQueries(queryClient);

package/lib/commonjs/assets/OxyLogo.svg

@@ -1 +0,0 @@
-<svg display="block" role="presentation" viewBox="0 0 41 22" xmlns="http://www.w3.org/2000/svg"><g><path d="M 9.492 0.03 C 8.39 0.157 7.368 0.958 6.758 2.163 C 6.451 2.772 6.247 3.55 6.205 4.266 L 6.186 4.615 L 5.908 4.472 C 5.119 4.068 4.411 3.892 3.561 3.889 C 2.811 3.885 2.281 3.999 1.722 4.279 C 0.869 4.709 0.329 5.377 0.084 6.298 C -0.007 6.64 -0.016 7.376 0.064 7.747 C 0.252 8.588 0.669 9.359 1.292 10.014 C 1.603 10.336 2.107 10.75 2.378 10.903 C 2.449 10.945 2.511 10.987 2.511 10.997 C 2.511 11.007 2.453 11.049 2.382 11.092 C 2.104 11.251 1.606 11.662 1.299 11.984 C -0.055 13.401 -0.388 15.283 0.478 16.621 C 0.963 17.37 1.729 17.859 2.721 18.054 C 3.119 18.132 3.93 18.132 4.366 18.054 C 4.903 17.956 5.394 17.79 5.901 17.533 L 6.195 17.383 L 6.195 17.572 C 6.195 18.008 6.305 18.63 6.473 19.142 C 7.146 21.193 8.878 22.346 10.604 21.893 C 11.405 21.682 12.171 21.092 12.691 20.281 C 13.137 19.584 13.438 18.627 13.49 17.735 L 13.509 17.39 L 13.797 17.536 C 14.611 17.947 15.306 18.116 16.182 18.113 C 17 18.109 17.597 17.956 18.234 17.582 C 18.567 17.386 19.055 16.901 19.249 16.575 C 19.566 16.045 19.679 15.621 19.682 14.973 C 19.685 14.309 19.595 13.922 19.284 13.257 C 18.91 12.459 18.176 11.636 17.404 11.154 C 17.284 11.079 17.184 11.01 17.184 11.001 C 17.184 10.991 17.284 10.922 17.404 10.848 C 17.95 10.506 18.59 9.88 18.945 9.34 C 19.52 8.47 19.779 7.532 19.676 6.683 C 19.501 5.266 18.499 4.25 16.974 3.947 C 16.544 3.859 15.733 3.866 15.261 3.96 C 14.769 4.058 14.362 4.195 13.897 4.423 L 13.499 4.615 L 13.499 4.429 C 13.499 3.511 13.124 2.335 12.591 1.573 C 11.964 0.684 11.124 0.15 10.158 0.027 C 9.87 -0.009 9.838 -0.009 9.492 0.03 Z" fill="currentColor"/><path d="M 15.54 19.794 C 14.425 19.874 13.421 19.654 12.528 19.133 C 11.706 18.654 11.013 17.991 10.448 17.143 C 9.93 16.365 9.523 15.464 9.229 14.438 C 8.951 13.466 8.773 12.44 8.697 11.361 C 8.625 10.346 8.663 9.31 8.812 8.255 C 8.967 7.155 9.255 6.145 9.678 5.223 C 10.132 4.235 10.742 3.403 11.509 2.728 C 12.378 1.963 13.43 1.537 14.664 1.448 C 15.89 1.36 16.961 1.634 17.878 2.269 C 18.689 2.83 19.351 3.575 19.866 4.502 C 20.329 5.337 20.683 6.273 20.929 7.311 C 21.16 8.287 21.31 9.269 21.38 10.257 C 21.459 11.38 21.423 12.455 21.271 13.482 C 21.11 14.563 20.814 15.537 20.382 16.405 C 19.915 17.344 19.29 18.112 18.51 18.71 C 17.672 19.351 16.682 19.712 15.54 19.794 Z" fill="currentColor"/><path d="M 31.928 3.669 C 31.925 4.125 31.844 4.596 31.686 5.082 C 31.559 5.471 31.403 5.862 31.216 6.255 C 31.045 6.614 30.862 6.967 30.665 7.313 C 30.505 7.595 30.344 7.877 30.18 8.157 L 28.754 7.312 L 30.21 8.105 L 29.317 9.767 C 29.002 10.357 28.67 10.938 28.322 11.509 L 26.912 10.636 L 28.342 9.798 C 28.517 10.101 28.739 10.508 29.007 11.017 C 29.281 11.537 29.547 12.084 29.806 12.656 C 30.071 13.242 30.302 13.815 30.5 14.377 C 30.746 15.076 30.867 15.691 30.863 16.221 C 30.859 16.798 30.701 17.334 30.388 17.828 C 30.154 18.196 29.849 18.477 29.47 18.67 C 29.123 18.847 28.742 18.934 28.328 18.931 C 27.59 18.925 26.895 18.65 26.243 18.105 C 25.802 17.736 25.39 17.303 25.006 16.807 C 24.66 16.36 24.342 15.901 24.053 15.431 C 23.787 15.001 23.576 14.651 23.418 14.382 L 24.843 13.535 L 26.145 14.563 C 25.915 14.858 25.68 15.149 25.44 15.436 C 25.226 15.691 25.017 15.95 24.812 16.213 L 24.289 16.87 C 24.053 17.165 23.796 17.454 23.519 17.736 C 23.199 18.063 22.866 18.341 22.518 18.571 C 21.989 18.921 21.443 19.094 20.879 19.09 C 20.387 19.086 19.951 18.959 19.571 18.707 C 19.253 18.496 18.995 18.225 18.796 17.891 C 18.633 17.619 18.517 17.323 18.447 17.003 C 18.39 16.742 18.362 16.476 18.364 16.209 C 18.368 15.63 18.467 15.053 18.662 14.478 C 18.827 13.991 19.02 13.537 19.242 13.113 L 20.705 13.891 L 19.213 13.17 C 19.86 11.811 20.539 10.468 21.248 9.141 L 22.705 9.931 L 21.207 10.64 C 21.054 10.311 20.868 9.866 20.648 9.304 C 20.433 8.754 20.221 8.178 20.014 7.576 C 19.799 6.956 19.615 6.351 19.462 5.761 C 19.281 5.071 19.193 4.485 19.196 4.003 C 19.201 3.312 19.378 2.689 19.727 2.132 C 19.987 1.718 20.333 1.407 20.766 1.197 C 21.143 1.015 21.562 0.925 22.021 0.928 C 22.562 0.932 23.063 1.079 23.524 1.368 C 23.858 1.577 24.16 1.837 24.431 2.146 C 24.663 2.41 24.87 2.695 25.049 2.997 C 25.215 3.277 25.35 3.543 25.456 3.796 L 23.93 4.442 L 25.429 3.736 L 26.071 5.12 C 26.3 5.611 26.515 6.12 26.717 6.647 L 25.174 7.248 L 23.744 6.411 C 23.85 6.227 23.994 5.979 24.178 5.668 C 24.375 5.332 24.6 4.977 24.85 4.604 C 25.1 4.233 25.369 3.856 25.658 3.473 C 25.972 3.057 26.296 2.679 26.63 2.34 C 27 1.964 27.382 1.65 27.775 1.399 C 28.338 1.039 28.909 0.861 29.489 0.866 C 29.946 0.869 30.358 0.988 30.727 1.224 C 31.091 1.457 31.372 1.778 31.572 2.188 C 31.813 2.681 31.931 3.175 31.928 3.669 Z" fill="currentColor"/><path d="M 40.986 4.834 C 40.933 5.517 40.79 6.249 40.557 7.031 C 40.34 7.757 40.079 8.484 39.773 9.214 C 39.475 9.924 39.159 10.612 38.823 11.279 C 38.495 11.932 38.191 12.51 37.912 13.013 C 37.77 13.27 37.593 13.602 37.38 14.008 C 37.153 14.44 36.902 14.898 36.626 15.384 C 36.341 15.884 36.044 16.378 35.736 16.864 C 35.396 17.401 35.047 17.882 34.688 18.309 C 34.291 18.781 33.882 19.17 33.461 19.476 C 32.82 19.942 32.152 20.147 31.456 20.092 C 30.985 20.055 30.567 19.922 30.2 19.693 C 29.785 19.434 29.471 19.078 29.258 18.625 C 28.983 18.042 28.872 17.417 28.924 16.749 C 28.964 16.227 29.09 15.692 29.302 15.145 C 29.483 14.676 29.701 14.215 29.956 13.762 C 30.199 13.33 30.464 12.911 30.75 12.508 C 31.013 12.138 31.257 11.805 31.483 11.51 L 32.794 12.527 L 32.268 14.107 C 31.831 13.96 31.421 13.731 31.038 13.42 C 30.587 13.053 30.259 12.617 30.055 12.11 L 30.044 12.083 L 30.034 12.056 C 29.854 11.56 29.673 11.005 29.491 10.392 C 29.306 9.766 29.145 9.133 29.01 8.495 C 28.873 7.847 28.767 7.201 28.692 6.558 C 28.61 5.857 28.592 5.209 28.639 4.613 C 28.665 4.28 28.727 3.928 28.826 3.558 C 28.94 3.129 29.109 2.732 29.333 2.366 C 29.595 1.938 29.927 1.585 30.33 1.307 C 30.861 0.94 31.467 0.784 32.147 0.838 C 32.536 0.869 32.901 0.973 33.241 1.151 C 33.567 1.322 33.857 1.553 34.111 1.845 C 34.464 2.251 34.759 2.737 34.995 3.303 C 35.203 3.8 35.369 4.342 35.494 4.93 C 35.605 5.453 35.696 5.969 35.768 6.478 C 35.838 6.977 35.891 7.436 35.927 7.855 C 35.958 8.208 35.987 8.478 36.016 8.664 L 34.381 8.917 L 32.82 8.363 C 32.894 8.154 33.01 7.847 33.17 7.444 C 33.331 7.038 33.522 6.592 33.741 6.107 C 33.966 5.61 34.219 5.103 34.5 4.585 C 34.795 4.041 35.102 3.546 35.423 3.098 C 35.792 2.584 36.186 2.159 36.605 1.823 C 37.245 1.31 37.928 1.082 38.654 1.139 C 38.981 1.165 39.284 1.254 39.565 1.406 C 39.849 1.559 40.091 1.767 40.293 2.029 C 40.541 2.351 40.722 2.717 40.835 3.124 C 40.924 3.444 40.977 3.772 40.992 4.104 C 41.004 4.38 41.003 4.624 40.986 4.834 Z" fill="currentColor"/></g><g><path d="M 5.106 15.637 C 4.33 15.692 3.641 15.545 3.04 15.195 C 2.439 14.845 1.928 14.353 1.505 13.719 C 1.083 13.086 0.749 12.339 0.502 11.48 C 0.256 10.621 0.099 9.71 0.031 8.748 C -0.033 7.85 0.002 6.932 0.134 5.994 C 0.266 5.056 0.509 4.201 0.864 3.427 C 1.219 2.654 1.691 2.007 2.281 1.488 C 2.872 0.968 3.6 0.678 4.466 0.615 C 5.306 0.555 6.026 0.733 6.625 1.148 C 7.224 1.562 7.717 2.12 8.106 2.82 C 8.495 3.521 8.794 4.315 9.004 5.202 C 9.214 6.09 9.351 6.983 9.414 7.881 C 9.485 8.881 9.453 9.834 9.319 10.74 C 9.184 11.646 8.941 12.454 8.588 13.162 C 8.235 13.871 7.77 14.446 7.194 14.887 C 6.617 15.328 5.921 15.578 5.106 15.637 Z M 4.576 4.882 C 4.334 4.9 4.134 5.011 3.975 5.216 C 3.817 5.42 3.692 5.684 3.6 6.006 C 3.508 6.329 3.45 6.688 3.427 7.083 C 3.403 7.478 3.406 7.874 3.434 8.272 C 3.466 8.722 3.526 9.17 3.615 9.612 C 3.704 10.057 3.818 10.455 3.958 10.806 C 4.098 11.157 4.262 11.436 4.449 11.641 C 4.637 11.847 4.852 11.941 5.094 11.924 C 5.373 11.904 5.586 11.747 5.731 11.453 C 5.877 11.159 5.983 10.809 6.051 10.405 C 6.118 10 6.153 9.585 6.155 9.159 C 6.157 8.734 6.148 8.38 6.128 8.097 C 6.103 7.751 6.055 7.387 5.983 7.005 C 5.911 6.624 5.813 6.273 5.688 5.953 C 5.563 5.633 5.41 5.37 5.229 5.164 C 5.048 4.958 4.83 4.864 4.576 4.882 Z M 19.958 1.162 C 19.956 1.445 19.902 1.747 19.798 2.068 C 19.694 2.388 19.564 2.712 19.408 3.039 C 19.254 3.362 19.089 3.68 18.913 3.991 C 18.757 4.267 18.599 4.542 18.439 4.816 C 18.14 5.37 17.843 5.924 17.547 6.479 C 17.246 7.042 16.929 7.596 16.597 8.141 C 16.76 8.425 16.971 8.812 17.23 9.303 C 17.488 9.793 17.74 10.31 17.985 10.852 C 18.23 11.394 18.443 11.923 18.625 12.439 C 18.806 12.954 18.895 13.379 18.893 13.713 C 18.891 13.971 18.819 14.212 18.677 14.436 C 18.536 14.66 18.318 14.771 18.025 14.769 C 17.68 14.766 17.333 14.619 16.984 14.327 C 16.635 14.036 16.306 13.689 15.996 13.288 C 15.686 12.887 15.401 12.477 15.143 12.057 C 14.884 11.637 14.679 11.298 14.527 11.04 C 14.31 11.319 14.088 11.594 13.86 11.865 C 13.634 12.135 13.412 12.41 13.195 12.689 C 13.025 12.904 12.854 13.118 12.683 13.332 C 12.483 13.582 12.264 13.828 12.026 14.071 C 11.789 14.313 11.545 14.517 11.294 14.682 C 11.044 14.848 10.804 14.93 10.574 14.928 C 10.408 14.927 10.271 14.89 10.163 14.819 C 10.055 14.748 9.967 14.654 9.897 14.537 C 9.828 14.421 9.778 14.292 9.748 14.15 C 9.717 14.011 9.701 13.868 9.702 13.725 C 9.705 13.327 9.775 12.925 9.911 12.521 C 10.049 12.117 10.208 11.742 10.389 11.396 C 11.025 10.06 11.692 8.74 12.389 7.436 C 12.25 7.139 12.078 6.726 11.871 6.198 C 11.664 5.669 11.46 5.115 11.26 4.534 C 11.06 3.954 10.889 3.39 10.746 2.842 C 10.602 2.295 10.532 1.854 10.534 1.519 C 10.537 1.146 10.628 0.816 10.809 0.528 C 10.99 0.24 11.285 0.097 11.694 0.1 C 11.923 0.102 12.137 0.165 12.334 0.288 C 12.53 0.412 12.711 0.567 12.876 0.755 C 13.04 0.941 13.186 1.142 13.312 1.356 C 13.439 1.569 13.539 1.766 13.615 1.946 C 13.827 2.408 14.041 2.87 14.256 3.33 C 14.47 3.789 14.671 4.263 14.859 4.753 C 14.962 4.573 15.104 4.33 15.285 4.022 C 15.466 3.715 15.672 3.389 15.905 3.043 C 16.137 2.698 16.388 2.346 16.658 1.988 C 16.929 1.63 17.206 1.307 17.488 1.02 C 17.771 0.732 18.057 0.496 18.346 0.312 C 18.634 0.127 18.906 0.035 19.161 0.037 C 19.442 0.039 19.646 0.169 19.771 0.428 C 19.897 0.686 19.959 0.931 19.958 1.162 Z M 29.021 2.208 C 28.977 2.772 28.855 3.388 28.656 4.057 C 28.457 4.724 28.216 5.396 27.933 6.07 C 27.651 6.744 27.35 7.398 27.032 8.031 C 26.713 8.664 26.42 9.221 26.153 9.703 C 26.003 9.975 25.82 10.318 25.602 10.733 C 25.384 11.148 25.142 11.59 24.874 12.06 C 24.602 12.537 24.319 13.009 24.025 13.473 C 23.725 13.946 23.421 14.367 23.11 14.735 C 22.8 15.104 22.489 15.402 22.177 15.629 C 21.865 15.856 21.563 15.958 21.27 15.935 C 20.863 15.903 20.585 15.73 20.436 15.414 C 20.288 15.099 20.228 14.756 20.257 14.385 C 20.285 14.026 20.375 13.649 20.528 13.255 C 20.68 12.86 20.864 12.472 21.079 12.089 C 21.293 11.708 21.527 11.339 21.779 10.983 C 22.031 10.629 22.264 10.312 22.478 10.032 C 22.228 9.948 21.989 9.812 21.76 9.627 C 21.531 9.441 21.369 9.228 21.272 8.988 C 21.104 8.523 20.933 8 20.761 7.419 C 20.588 6.836 20.438 6.247 20.312 5.652 C 20.186 5.055 20.088 4.46 20.019 3.868 C 19.95 3.276 19.934 2.736 19.973 2.249 C 19.99 2.018 20.035 1.767 20.108 1.495 C 20.18 1.223 20.286 0.973 20.425 0.745 C 20.564 0.518 20.739 0.332 20.949 0.187 C 21.158 0.043 21.41 -0.018 21.703 0.005 C 22.033 0.031 22.316 0.179 22.551 0.449 C 22.786 0.719 22.987 1.054 23.154 1.455 C 23.322 1.854 23.457 2.297 23.56 2.783 C 23.663 3.269 23.748 3.746 23.814 4.216 C 23.88 4.685 23.929 5.115 23.963 5.505 C 23.997 5.894 24.031 6.2 24.064 6.422 C 24.131 6.234 24.239 5.949 24.391 5.567 C 24.542 5.186 24.722 4.765 24.93 4.304 C 25.139 3.843 25.374 3.372 25.636 2.89 C 25.898 2.407 26.168 1.97 26.448 1.58 C 26.728 1.189 27.018 0.873 27.319 0.632 C 27.619 0.392 27.916 0.283 28.209 0.306 C 28.399 0.321 28.553 0.404 28.669 0.555 C 28.786 0.706 28.872 0.88 28.927 1.078 C 28.982 1.277 29.014 1.481 29.023 1.686 C 29.032 1.893 29.032 2.067 29.021 2.208 Z" fill="#fff" transform="translate(10.316 2.495)"/></g></svg>