BIP Standards

import * as bip39 from '@scure/bip39';
import { wordlist } from '@scure/bip39/wordlists/english';

async function generateMnemonic(): Promise<string> {
  try {
    // Generate 128 bits of entropy (16 bytes) for a 12-word mnemonic
    const entropy = new Uint8Array(16);
    crypto.getRandomValues(entropy);

    // Generate mnemonic from entropy
    const mnemonic = bip39.entropyToMnemonic(entropy, wordlist);

    console.log('Generated new mnemonic');
    return mnemonic;
  } catch (error) {
    console.error('Failed to generate mnemonic:', error);
    throw new Error('Failed to generate mnemonic');
  }
}

import * as SecureStore from 'expo-secure-store';

const IOS_SECURE_OPTIONS = {
  requireAuthentication: false,
  authenticatePrompt: 'Authenticate to access your Sovran wallet',
};

export async function storeMnemonic(mnemonic: string): Promise<boolean> {
  try {
    if (!mnemonic || typeof mnemonic !== 'string') {
      throw new Error('Invalid mnemonic provided');
    }

    // Validate it's a 12-word mnemonic
    const words = mnemonic.trim().split(' ');
    if (words.length !== 12) {
      throw new Error('Mnemonic must be exactly 12 words');
    }

    const options = Platform.OS === 'ios' ? IOS_SECURE_OPTIONS : {};
    await SecureStore.setItemAsync(STORAGE_KEYS.USER_MNEMONIC, mnemonic, options);

    return true;
  } catch (error) {
    console.error('Failed to store mnemonic:', error);
    return false;
  }
}

export async function retrieveMnemonic(): Promise<string | null> {
  try {
    const options = Platform.OS === 'ios' ? IOS_SECURE_OPTIONS : {};
    const mnemonic = await SecureStore.getItemAsync(STORAGE_KEYS.USER_MNEMONIC, options);
    return mnemonic;
  } catch (error) {
    console.error('Failed to retrieve mnemonic:', error);
    return null;
  }
}

let mnemonicToUse = mnemonic;

// If no mnemonic from secure storage, try Redux fallback first
if (!mnemonicToUse) {
  mnemonicToUse = getMnemonicFromRedux();

  if (mnemonicToUse) {
    // Migrate to SecureStore
    const { storeMnemonic } = await import('../helper/secureStorage');
    await storeMnemonic(mnemonicToUse);
  }
}

if (!mnemonicToUse) {
  // Generate new mnemonic
  mnemonicToUse = await ensureMnemonicExists();

  if (!mnemonicToUse) {
    throw new Error('Failed to generate or retrieve mnemonic');
  }
}

import * as nip06 from 'nostr-tools/nip06';
import { nip19 } from 'nostr-tools';

export function deriveNostrKeys(mnemonic: string, accountIndex: number = 0): DerivedNostrKeys {
  const { privateKey: sk, publicKey: pk } = nip06.accountFromSeedWords(
    mnemonic,
    undefined,
    accountIndex
  );

  return {
    npub: nip19.npubEncode(pk),
    nsec: nip19.nsecEncode(sk),
    pubkey: pk,
    privateKey: sk,
  };
}

import { HDKey } from '@scure/bip32';
import * as bip39 from '@scure/bip39';
import { wordlist } from '@scure/bip39/wordlists/english';

const CASHU_DERIVATION_PREFIX = `m/44'/129372'`;

export function deriveCashuMnemonic(mnemonic: string, accountIndex: number = 0): string {
  const seed = bip39.mnemonicToSeedSync(mnemonic);
  const root = HDKey.fromMasterSeed(seed);
  const path = `${CASHU_DERIVATION_PREFIX}/0'/${accountIndex}'/0/0`;
  const child = root.derive(path);
  return bip39.entropyToMnemonic(child.privateKey as Uint8Array, wordlist);
}

export function deriveCashuWalletSeed(cashuMnemonic: string): Uint8Array {
  return bip39.mnemonicToSeedSync(cashuMnemonic, '');
}

export function deriveCashuWalletSeedFromRoot(
  mnemonic: string,
  accountIndex: number = 0
): Uint8Array {
  return deriveCashuWalletSeed(deriveCashuMnemonic(mnemonic, accountIndex));
}

Root Mnemonic (12 words)
  ↓ BIP-32 derivation (m/44'/129372'/0'/<accountIndex>'/0/0)
Cashu Mnemonic (24 words)
  ↓ BIP-39 to seed
64-byte Wallet Seed

export interface CachedDerivedKeys {
  npub: string;
  nsec: string;
  pubkey: string;
  privateKeyHex: string;
  mnemonicHash: string; // For cache invalidation
}

export function hashMnemonic(mnemonic: string): string {
  let hash = 0;
  for (let i = 0; i < mnemonic.length; i++) {
    hash = (hash * 31 + mnemonic.charCodeAt(i)) | 0;
  }
  return hash.toString(36);
}

const mHash = hashMnemonic(mnemonicToUse);

// Try loading cached keys from SecureStore
const [cachedDerived, cachedCashu] = await Promise.all([
  retrieveDerivedKeys(defaultAccountIndex),
  retrieveCashuMnemonic(defaultAccountIndex),
]);

const cacheValid =
  cachedDerived?.mnemonicHash === mHash && cachedCashu?.mnemonicHash === mHash;

if (cacheValid && cachedDerived && cachedCashu) {
  // Use cached keys (fast path)
  defaultKeys = {
    npub: cachedDerived.npub,
    nsec: cachedDerived.nsec,
    pubkey: cachedDerived.pubkey,
    privateKey: hexToBytes(cachedDerived.privateKeyHex),
  };
  defaultCashuMnemonic = cachedCashu.value;
} else {
  // Derive from scratch and cache
  defaultKeys = deriveNostrKeys(mnemonicToUse, defaultAccountIndex);
  defaultCashuMnemonic = deriveCashuMnemonicPure(mnemonicToUse, defaultAccountIndex);
  // Background cache write...
}

const getKeysForAccount = async (accountIndex: number): Promise<NostrKeys | null> => {
  try {
    return await deriveKeys(accountIndex);
  } catch (err) {
    const errorMessage = err instanceof Error ? err.message : 'Failed to get keys for account';
    setError(errorMessage);
    return null;
  }
};

const getCashuMnemonicForAccount = async (accountIndex: number): Promise<string | null> => {
  try {
    return await deriveCashuMnemonic(accountIndex);
  } catch (err) {
    const errorMessage =
      err instanceof Error ? err.message : 'Failed to get cashu mnemonic for account';
    setError(errorMessage);
    return null;
  }
};

/** BIP-44 account index used for key derivation */
accountIndex: number;

const restoreMint = async (mintUrl: string) => {
  // 1. Derive Cashu mnemonic from root seed
  // 2. Derive wallet seed from Cashu mnemonic
  // 3. Restore proofs from mint using NUT-09
  // 4. Track progress and display status
};

Seed Phrase Entry
  ↓
Validate BIP-39 Mnemonic
  ↓
Derive Cashu Mnemonic (per account)
  ↓
Restore from Each Mint
  ↓
Display Recovered Balance

const IOS_SECURE_OPTIONS = {
  requireAuthentication: false, // Set to true in production
  authenticatePrompt: 'Authenticate to access your Sovran wallet',
};

export async function clearAllSecureData(maxAccountIndex: number = 10): Promise<boolean> {
  try {
    const keysToDelete: string[] = [
      STORAGE_KEYS.USER_MNEMONIC,
      STORAGE_KEYS.MIGRATIONS_COMPLETE_LEGACY,
    ];

    // Per-account keys for every possible account index
    for (let i = 0; i <= maxAccountIndex; i++) {
      keysToDelete.push(migrationsCompleteKey(i), derivedKeysKey(i), cashuMnemonicKey(i));
    }

    const clearPromises = keysToDelete.map((key) =>
      SecureStore.deleteItemAsync(key, options).catch((error) => {
        console.warn(`Failed to clear ${key}:`, error);
        return false;
      })
    );

    await Promise.all(clearPromises);
    return true;
  } catch (error) {
    console.error('Failed to clear secure storage:', error);
    return false;
  }
}

// package.json:64-65,97
{
  "@scure/bip32": "^1.3.3",
  "@scure/bip39": "^1.2.2",
  "expo-secure-store": "~55.0.8"
}