@global-torque/invest-core 0.2.2

package/src/onboarding/__tests__/intents.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest';
+import {
+  buildProfileCreationHandoff,
+  buildWalletOnboardingIntent,
+  parseExactOrigin,
+  parseLocalContinuation,
+  parsePositiveProfileId,
+  parseSignupProfileType,
+  parseWalletOnboardingProfileType,
+} from '../intents';
+
+describe('onboarding intent parsing', () => {
+  it.each(['individual', 'entity', 'trust'])('accepts signup profile type %s', (value) => {
+    expect(parseSignupProfileType(value)).toBe(value);
+  });
+
+  it.each(['sdira', 'solo401k', '', 'entity<script>'])('rejects closed profile value %s', (value) => {
+    expect(parseSignupProfileType(value)).toBeNull();
+  });
+
+  it.each(['individual', 'entity', 'trust', 'sdira', 'solo401k'])(
+    'accepts wallet-onboarding profile type %s',
+    (value) => expect(parseWalletOnboardingProfileType(value)).toBe(value),
+  );
+
+  it.each([[1, 1], ['42', 42], ['profile_8', 8], ['profile:9', 9], ['investor-10', 10]])(
+    'parses exact positive profile id %s',
+    (value, expected) => expect(parsePositiveProfileId(value)).toBe(expected),
+  );
+
+  it.each([0, '0', -1, '1.5', 'profile_0', '1/next', Number.MAX_SAFE_INTEGER + 1])(
+    'rejects invalid profile id %s',
+    (value) => expect(parsePositiveProfileId(value)).toBeNull(),
+  );
+
+  it('allows only local allowlisted continuations', () => {
+    expect(parseLocalContinuation('/profile/8/wallet-otp?next=1', ['/profile'], '/fallback'))
+      .toBe('/profile/8/wallet-otp?next=1');
+    for (const hostile of ['https://evil.test/x', '//evil.test/x', '/admin', '/profile\\evil']) {
+      expect(parseLocalContinuation(hostile, ['/profile'], '/fallback')).toBe('/fallback');
+    }
+  });
+
+  it('accepts exact configured origins without paths or credentials', () => {
+    expect(parseExactOrigin('https://dashboard.example.test/path')).toBe('https://dashboard.example.test');
+    expect(parseExactOrigin('https://user:pass@example.test')).toBeNull();
+    expect(parseExactOrigin('javascript:alert(1)')).toBeNull();
+  });
+
+  it('builds exact wallet and entity handoff contracts', () => {
+    expect(buildWalletOnboardingIntent({
+      profileId: 'profile_7',
+      profileType: 'sdira',
+      nextPath: '/profile/7/kyc',
+    })).toEqual({
+      profileId: 7,
+      expectedProfileType: 'sdira',
+      nextPath: '/profile/7/kyc',
+    });
+    // Continuations outside /profile fall back to the profile account page.
+    expect(buildWalletOnboardingIntent({
+      profileId: 'profile_7',
+      profileType: 'sdira',
+      nextPath: '/investor/onboarding',
+    })).toEqual({
+      profileId: 7,
+      expectedProfileType: 'sdira',
+      nextPath: '/profile/7/account',
+    });
+    expect(buildProfileCreationHandoff({
+      profileType: 'entity',
+      nextPath: '/profile',
+      acceptedProfileId: 'profile_11',
+      firstName: ' Ada ',
+    })).toEqual({
+      onboarding: 'signup',
+      profileType: 'entity',
+      nextPath: '/profile',
+      acceptedProfileId: 11,
+      firstName: 'Ada',
+    });
+  });
+});

package/src/onboarding/intents.ts

@@ -0,0 +1,128 @@
+import {
+  SIGNUP_PROFILE_TYPES,
+  WALLET_ONBOARDING_PROFILE_TYPES,
+  type ProfileCreationHandoff,
+  type SignupProfileType,
+  type WalletOnboardingIntent,
+  type WalletOnboardingProfileType,
+} from '@global-torque/domain-types/onboardingTypes';
+
+const SIGNUP_PROFILE_TYPE_SET = new Set<string>(SIGNUP_PROFILE_TYPES);
+const WALLET_PROFILE_TYPE_SET = new Set<string>(WALLET_ONBOARDING_PROFILE_TYPES);
+const MAX_PREFILL_LENGTH = 100;
+
+export const parseSignupProfileType = (value: unknown): SignupProfileType | null => {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  return SIGNUP_PROFILE_TYPE_SET.has(normalized)
+    ? normalized as SignupProfileType
+    : null;
+};
+
+export const parseWalletOnboardingProfileType = (
+  value: unknown,
+): WalletOnboardingProfileType | null => {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  return WALLET_PROFILE_TYPE_SET.has(normalized)
+    ? normalized as WalletOnboardingProfileType
+    : null;
+};
+
+export const parsePositiveProfileId = (value: unknown): number | null => {
+  const normalized = String(value ?? '').trim().replace(/^(?:profile|investor)[_:-]/i, '');
+  if (!/^[1-9]\d*$/.test(normalized)) {
+    return null;
+  }
+  const profileId = Number(normalized);
+  return Number.isSafeInteger(profileId) ? profileId : null;
+};
+
+export const parseLocalContinuation = (
+  value: unknown,
+  allowedPrefixes: readonly string[],
+  fallback: string,
+): string => {
+  const candidate = String(value ?? '').trim();
+  if (
+    !candidate.startsWith('/')
+    || candidate.startsWith('//')
+    || candidate.includes('\\')
+    || /[\u0000-\u001f]/.test(candidate)
+  ) {
+    return fallback;
+  }
+  const pathname = candidate.split(/[?#]/, 1)[0] ?? '';
+  return allowedPrefixes.some((prefix) => (
+    pathname === prefix || pathname.startsWith(`${prefix}/`)
+  )) ? candidate : fallback;
+};
+
+export const parseExactOrigin = (value: unknown): string | null => {
+  try {
+    const url = new URL(String(value ?? '').trim());
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) {
+      return null;
+    }
+    return url.origin;
+  } catch {
+    return null;
+  }
+};
+
+export const boundedSignupPrefill = (value: unknown) => {
+  const normalized = String(value ?? '').trim();
+  return normalized && normalized.length <= MAX_PREFILL_LENGTH ? normalized : undefined;
+};
+
+export const buildWalletOnboardingIntent = ({
+  profileId,
+  profileType,
+  nextPath,
+}: {
+  profileId: unknown;
+  profileType: unknown;
+  nextPath: unknown;
+}): WalletOnboardingIntent | null => {
+  const parsedId = parsePositiveProfileId(profileId);
+  const parsedType = parseWalletOnboardingProfileType(profileType);
+  if (!parsedId || !parsedType) {
+    return null;
+  }
+  return {
+    profileId: parsedId,
+    expectedProfileType: parsedType,
+    nextPath: parseLocalContinuation(nextPath, ['/profile'], `/profile/${parsedId}/account`),
+  };
+};
+
+export const buildProfileCreationHandoff = ({
+  profileType,
+  nextPath,
+  acceptedProfileId,
+  firstName,
+  lastName,
+  email,
+}: {
+  profileType: unknown;
+  nextPath: unknown;
+  acceptedProfileId?: unknown;
+  firstName?: unknown;
+  lastName?: unknown;
+  email?: unknown;
+}): ProfileCreationHandoff | null => {
+  const parsedType = parseSignupProfileType(profileType);
+  if (parsedType !== 'entity' && parsedType !== 'trust') {
+    return null;
+  }
+  const parsedAcceptedId = acceptedProfileId == null
+    ? undefined
+    : parsePositiveProfileId(acceptedProfileId) ?? undefined;
+  return {
+    onboarding: 'signup',
+    profileType: parsedType,
+    nextPath: parseLocalContinuation(nextPath, ['/profile'], '/profile'),
+    ...(boundedSignupPrefill(firstName) && { firstName: boundedSignupPrefill(firstName) }),
+    ...(boundedSignupPrefill(lastName) && { lastName: boundedSignupPrefill(lastName) }),
+    ...(boundedSignupPrefill(email) && { email: boundedSignupPrefill(email) }),
+    ...(parsedAcceptedId && { acceptedProfileId: parsedAcceptedId }),
+  };
+};

package/src/profiles/__tests__/formatting.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import {
+  formatProfileDateToShortMonthDateYear,
+  formatProfilePhoneNumberForDisplay,
+  formatProfileUserPhoneNumber,
+} from '../formatting.ts';
+
+describe('profile formatting', () => {
+  it('keeps the existing short month account-created date format', () => {
+    expect(formatProfileDateToShortMonthDateYear(new Date(2026, 3, 8))).toBe('Apr 8, 2026');
+  });
+
+  it('formats user phone numbers only for 11-digit US numbers with a leading country code', () => {
+    expect(formatProfileUserPhoneNumber('+1 (555) 123-4567')).toBe('+1 (555) 123 - 4567');
+    expect(formatProfileUserPhoneNumber('5551234567')).toBeUndefined();
+    expect(formatProfileUserPhoneNumber('+25551234567')).toBeUndefined();
+  });
+
+  it('formats profile detail phone numbers with optional country codes', () => {
+    expect(formatProfilePhoneNumberForDisplay('+15551234567')).toBe('+1 (555) 123-4567');
+    expect(formatProfilePhoneNumberForDisplay('5559876543')).toBe('(555) 987-6543');
+    expect(formatProfilePhoneNumberForDisplay(undefined)).toBeUndefined();
+  });
+});

package/src/profiles/avatarInitial.ts

@@ -0,0 +1,5 @@
+export const getProfileAvatarInitial = (profileName?: string | null) => {
+  const trimmedProfileName = profileName?.trim();
+
+  return trimmedProfileName ? trimmedProfileName.charAt(0).toUpperCase() : '';
+};

package/src/profiles/formatting.ts

@@ -0,0 +1,38 @@
+import { formatToShortMonthDateYear } from '../formatting/dateTime.ts';
+
+export const formatProfileDateToShortMonthDateYear = formatToShortMonthDateYear;
+
+export function formatProfileUserPhoneNumber(input: string | number): string | undefined {
+  const digits = input.toString().replace(/\D/g, '');
+
+  if (digits.length !== 11 || !digits.startsWith('1')) {
+    return undefined;
+  }
+
+  const areaCode = digits.slice(1, 4);
+  const centralOfficeCode = digits.slice(4, 7);
+  const lineNumber = digits.slice(7, 11);
+
+  return `+1 (${areaCode}) ${centralOfficeCode} - ${lineNumber}`;
+}
+
+export function formatProfilePhoneNumberForDisplay(
+  input?: string | number | null,
+): string | undefined {
+  if (input === undefined || input === null || input === '') return undefined;
+
+  const cleaned = String(input).replace(/\D/g, '');
+  let countryCode = '';
+  let number = cleaned;
+
+  if (cleaned.length > 10) {
+    countryCode = `+${cleaned.slice(0, cleaned.length - 10)} `;
+    number = cleaned.slice(-10);
+  }
+
+  const areaCode = number.slice(0, 3);
+  const middlePart = number.slice(3, 6);
+  const lastPart = number.slice(6);
+
+  return `${countryCode}(${areaCode}) ${middlePart}-${lastPart}`;
+}

package/src/repository/__tests__/formatterCache.test.ts

@@ -0,0 +1,45 @@
+import {
+  describe,
+  expect,
+  it,
+  vi,
+} from 'vitest';
+import { createFormatterCache } from '../formatterCache';
+
+describe('formatterCache', () => {
+  it('reuses formatted values while item signatures are unchanged', () => {
+    const format = vi.fn((item: { id: number; value: string }) => item.value.toUpperCase());
+    const cache = createFormatterCache({
+      getKey: (item: { id: number }) => item.id,
+      getSignature: (item: { value: string }) => item.value,
+      format,
+    });
+
+    expect(cache.format({ id: 1, value: 'alpha' })).toBe('ALPHA');
+    expect(cache.format({ id: 1, value: 'alpha' })).toBe('ALPHA');
+    expect(format).toHaveBeenCalledTimes(1);
+
+    expect(cache.format({ id: 1, value: 'beta' })).toBe('BETA');
+    expect(format).toHaveBeenCalledTimes(2);
+  });
+
+  it('prunes old keys and clears the cache', () => {
+    const format = vi.fn((item: { id: number; value: string }) => item.value);
+    const cache = createFormatterCache({
+      getKey: (item: { id: number }) => item.id,
+      getSignature: (item: { value: string }) => item.value,
+      format,
+    });
+
+    cache.formatMany([
+      { id: 1, value: 'one' },
+      { id: 2, value: 'two' },
+    ]);
+    cache.prune([{ id: 1, value: 'one' }]);
+    cache.format({ id: 2, value: 'two' });
+    cache.clear();
+    cache.format({ id: 1, value: 'one' });
+
+    expect(format).toHaveBeenCalledTimes(4);
+  });
+});

package/src/repository/formatterCache.ts

@@ -0,0 +1,56 @@
+type FormatterCacheEntry<TOutput> = {
+  signature: string;
+  formatted: TOutput;
+};
+
+type FormatterCacheConfig<TInput, TOutput, TKey extends string | number> = {
+  getKey: (item: TInput) => TKey;
+  getSignature: (item: TInput) => string;
+  format: (item: TInput) => TOutput;
+};
+
+export const createFormatterCache = <
+  TInput,
+  TOutput,
+  TKey extends string | number = number,
+>(
+  config: FormatterCacheConfig<TInput, TOutput, TKey>,
+) => {
+  const cache = new Map<TKey, FormatterCacheEntry<TOutput>>();
+
+  const format = (item: TInput): TOutput => {
+    const key = config.getKey(item);
+    const signature = config.getSignature(item);
+    const cached = cache.get(key);
+
+    if (cached && cached.signature === signature) {
+      return cached.formatted;
+    }
+
+    const formatted = config.format(item);
+    cache.set(key, { signature, formatted });
+    return formatted;
+  };
+
+  const formatMany = (items: TInput[]): TOutput[] => items.map(format);
+
+  const prune = (items: TInput[]) => {
+    const keys = new Set(items.map(config.getKey));
+    for (const key of cache.keys()) {
+      if (!keys.has(key)) {
+        cache.delete(key);
+      }
+    }
+  };
+
+  const clear = () => {
+    cache.clear();
+  };
+
+  return {
+    format,
+    formatMany,
+    prune,
+    clear,
+  };
+};

package/src/wallet/__tests__/auth.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from 'vitest';
+import {
+  deriveWalletAuthEmail,
+  getWalletAuthAddressFromDetails,
+  isRecoverableWalletAuthError,
+  isWalletBackendError,
+  isWalletBackendReady,
+  isUserRejectedWalletSignatureError,
+  normalizeWalletAuthOperationIntent,
+  resolveWalletAuthErrorMessage,
+  shouldPromptWalletAuth,
+} from '../auth.ts';
+
+describe('wallet auth helpers', () => {
+  it('uses the real email for individual profiles', () => {
+    expect(deriveWalletAuthEmail('User@Mail.com', 'Acme Holdings LLC', true)).toBe('user@mail.com');
+  });
+
+  it('derives a deterministic alias for non-individual profiles', () => {
+    expect(deriveWalletAuthEmail('user@mail.com', ' Acme Holdings, LLC ', false)).toBe(
+      'user+acme-holdings-llc@mail.com',
+    );
+  });
+
+  it('treats created and verified statuses as backend-ready', () => {
+    expect(isWalletBackendReady('created')).toBe(true);
+    expect(isWalletBackendReady('verified')).toBe(true);
+    expect(isWalletBackendReady('error')).toBe(false);
+  });
+
+  it('recognizes explicit backend error statuses', () => {
+    expect(isWalletBackendError('error')).toBe(true);
+    expect(isWalletBackendError('error_retry')).toBe(true);
+    expect(isWalletBackendError('verified')).toBe(false);
+  });
+
+  it('prompts wallet auth only when KYC is approved and wallet is not ready', () => {
+    expect(shouldPromptWalletAuth({ isKycApproved: true, walletStatus: '' })).toBe(true);
+    expect(shouldPromptWalletAuth({ isKycApproved: true, walletStatus: 'verified' })).toBe(false);
+    expect(shouldPromptWalletAuth({ isKycApproved: true, walletStatus: 'error' })).toBe(false);
+    expect(shouldPromptWalletAuth({ isKycApproved: false, walletStatus: '' })).toBe(false);
+  });
+
+  it('extracts a normalized wallet address from signer auth details', () => {
+    expect(getWalletAuthAddressFromDetails({ address: ' 0xabc123 ' })).toBe('0xabc123');
+    expect(getWalletAuthAddressFromDetails({ address: '' })).toBe('');
+    expect(getWalletAuthAddressFromDetails(null)).toBe('');
+  });
+
+  it('normalizes wallet operation intent text without changing the operation shape', () => {
+    expect(normalizeWalletAuthOperationIntent({
+      source: 'exchange',
+      profileId: 7,
+      chain: ' sepolia ',
+      nonce: ' auth_1 ',
+      amount: ' 25.00 ',
+      assetAddress: ' 0xusdc ',
+      assetSymbol: ' USDC ',
+      toAssetAddress: ' 0xeth ',
+      toAssetSymbol: ' ETH ',
+      destinationAddress: ' 0xrecipient ',
+      estimatedReceiveText: ' 0.01 ETH ',
+      estimatedRateText: ' ',
+    })).toEqual({
+      source: 'exchange',
+      profileId: 7,
+      chain: 'sepolia',
+      nonce: 'auth_1',
+      amount: '25.00',
+      assetAddress: '0xusdc',
+      assetSymbol: 'USDC',
+      toAssetAddress: '0xeth',
+      toAssetSymbol: 'ETH',
+      destinationAddress: '0xrecipient',
+      estimatedReceiveText: '0.01 ETH',
+    });
+  });
+
+  it('classifies signer-auth errors as recoverable wallet-auth failures', () => {
+    expect(isRecoverableWalletAuthError(new Error('Wallet signer is not connected.'))).toBe(true);
+    expect(isRecoverableWalletAuthError(new Error('Iframe container cannot be found'))).toBe(true);
+    expect(isRecoverableWalletAuthError({
+      name: 'NotAuthenticatedError',
+      message: 'Signer not authenticated. Please authenticate to use this signer',
+    })).toBe(true);
+    expect(isRecoverableWalletAuthError(
+      new Error('Failed to sign: Key not initialized. Call init() first. Version: viem@2.54.1'),
+    )).toBe(true);
+    expect(isRecoverableWalletAuthError(new Error('User rejected signature'))).toBe(false);
+  });
+
+  it('detects explicit user-rejected signing errors', () => {
+    expect(isUserRejectedWalletSignatureError(new Error('User rejected the request.'))).toBe(true);
+    expect(isUserRejectedWalletSignatureError(new Error('Request rejected by backend.'))).toBe(false);
+  });
+
+  it('extracts the nested SDK message from structured wallet-auth errors', () => {
+    expect(resolveWalletAuthErrorMessage({
+      error: '{"code":3,"message":"Max number of OTPs have been initiated please wait and try again","details":[{"@type":"type.googleapis.com/errors.v1.TurnkeyErrorDetail","turnkeyErrorCode":"MAX_OTP_INITIATED"}],"turnkeyErrorCode":"MAX_OTP_INITIATED"}',
+    }, 'Fallback')).toBe('Max number of OTPs have been initiated please wait and try again');
+  });
+});

package/src/wallet/__tests__/operationPresentation.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+import {
+  buildChainExplorerAddressUrl,
+  buildChainExplorerTransactionUrl,
+  buildWalletAuthExplorerLink,
+  formatWalletAuthAddressValue,
+  formatWalletAuthAssetValue,
+  getWalletAuthExchangeTargetAssetAddress,
+  shortenWalletAuthOperationText,
+} from '../operationPresentation.ts';
+
+describe('wallet operation presentation helpers', () => {
+  it('builds transaction links from the deployment chain without a network default', () => {
+    expect(buildChainExplorerTransactionUrl('base', '0xabc'))
+      .toBe('https://basescan.org/tx/0xabc');
+    expect(buildChainExplorerTransactionUrl('Ethereum Sepolia', '0xdef'))
+      .toBe('https://sepolia.etherscan.io/tx/0xdef');
+    expect(buildChainExplorerTransactionUrl('unsupported', '0xdef')).toBeNull();
+  });
+
+  it('builds Vault address links only for mapped chains and valid addresses', () => {
+    const address = '0x1111111111111111111111111111111111111111';
+    expect(buildChainExplorerAddressUrl('base', address))
+      .toBe(`https://basescan.org/address/${address}`);
+    expect(buildChainExplorerAddressUrl('ethereum-sepolia', address))
+      .toBe(`https://sepolia.etherscan.io/address/${address}`);
+    expect(buildChainExplorerAddressUrl('unsupported', address)).toBeNull();
+    expect(buildChainExplorerAddressUrl('base', 'not-an-address')).toBeNull();
+    expect(buildChainExplorerAddressUrl('base', '')).toBeNull();
+  });
+
+  it('shortens long wallet operation text while leaving short text unchanged', () => {
+    expect(shortenWalletAuthOperationText(' 0x1234 ')).toBe('0x1234');
+    expect(shortenWalletAuthOperationText('0x1234567890abcdef1234567890abcdef12345678'))
+      .toBe('0x123456...345678');
+  });
+
+  it('formats addresses and asset labels for operation summaries', () => {
+    expect(formatWalletAuthAddressValue('0x1234567890abcdef')).toBe('0x1234567890abcdef');
+    expect(formatWalletAuthAddressValue('0x1234567890abcdef1234567890abcdef12345678'))
+      .toBe('0x123456...345678');
+    expect(formatWalletAuthAssetValue('USDC', '0x1234567890abcdef1234567890abcdef12345678'))
+      .toBe('USDC (0x123456...345678)');
+    expect(formatWalletAuthAssetValue('', '0x1234567890abcdef1234567890abcdef12345678'))
+      .toBe('0x123456...345678');
+  });
+
+  it('builds explorer links only when value and base URL are available', () => {
+    expect(buildWalletAuthExplorerLink({
+      baseUrl: 'https://scan.example.test/',
+      type: 'address',
+      value: '0xabc',
+      text: '0xabc',
+      ariaLabel: 'View wallet',
+    })).toEqual({
+      href: 'https://scan.example.test/address/0xabc',
+      text: '0xabc',
+      title: '0xabc',
+      ariaLabel: 'View wallet',
+    });
+    expect(buildWalletAuthExplorerLink({
+      baseUrl: '',
+      type: 'address',
+      value: '0xabc',
+      text: '0xabc',
+      ariaLabel: 'View wallet',
+    })).toBeNull();
+  });
+
+  it('returns target asset addresses only for exchange intents', () => {
+    expect(getWalletAuthExchangeTargetAssetAddress({
+      source: 'exchange',
+      profileId: 1,
+      chain: 'sepolia',
+      nonce: '1',
+      amount: '1',
+      assetAddress: '0xusdc',
+      assetSymbol: 'USDC',
+      toAssetAddress: '0xtarget',
+      toAssetSymbol: 'RWA',
+      destinationAddress: '0xdestination',
+    })).toBe('0xtarget');
+    expect(getWalletAuthExchangeTargetAssetAddress({
+      source: 'withdrawal',
+      profileId: 1,
+      chain: 'sepolia',
+      nonce: '1',
+      amount: '1',
+      assetAddress: '0xusdc',
+      assetSymbol: 'USDC',
+      destinationAddress: '0xdestination',
+    })).toBe('');
+  });
+});

package/src/wallet/__tests__/setupError.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { isWalletSetupRequiredError } from '../setupError.ts';
+
+describe('wallet setup error helpers', () => {
+  it('treats 404 wallet lookups for approved profiles as setup required', () => {
+    expect(isWalletSetupRequiredError(
+      { data: { statusCode: 404 } },
+      { isKycApproved: true, walletData: undefined },
+    )).toBe(true);
+  });
+
+  it('treats known missing-wallet backend messages as setup required', () => {
+    expect(isWalletSetupRequiredError(
+      new Error('User need to create wallet'),
+      { isKycApproved: true, walletData: undefined },
+    )).toBe(true);
+  });
+
+  it('treats incomplete wallet registration as setup required', () => {
+    expect(isWalletSetupRequiredError(
+      new Error('wallet registration is incomplete for ethereum-sepolia'),
+      { isKycApproved: true, walletData: undefined },
+    )).toBe(true);
+  });
+
+  it('does not treat generic backend failures as setup required', () => {
+    expect(isWalletSetupRequiredError(
+      { data: { statusCode: 500, responseJson: { message: 'Upstream error' } } },
+      { isKycApproved: true, walletData: undefined },
+    )).toBe(false);
+  });
+});