import { Vault, type EncryptedData } from 'p-sdk-wallet';

// Create a new vault with a fresh mnemonic
const { vault, encryptedVault } = await Vault.createNew('your-secure-password');

// Save encryptedVault securely (iOS Keychain, AsyncStorage, etc.)
await saveToSecureStorage(encryptedVault);

console.log('Vault created with accounts:', vault.getAccounts());

// Load vault from encrypted data
const encryptedVault: EncryptedData = await loadFromSecureStorage();
const vault = await Vault.load('your-secure-password', encryptedVault);

console.log('Vault loaded successfully');

// Get the current encrypted vault data for backup
const encryptedVault = vault.exportEncryptedVault();
console.log('Encrypted vault data:', encryptedVault);

// Add a new HD account derived from the mnemonic
const newAccount = await vault.addNewHDAccount();
console.log('New HD Account:', {
  address: newAccount.address,
  name: newAccount.name,
  type: newAccount.type
});

// Import an existing account using private key
const privateKey = '0x1234567890abcdef...'; // 64-character hex string
const importedAccount = await vault.importAccount(privateKey);

console.log('Imported Account:', {
  address: importedAccount.address,
  name: importedAccount.name,
  type: importedAccount.type
});

// Get all accounts (HD + imported)
const allAccounts = vault.getAccounts();
console.log('All accounts:', allAccounts);

// Filter by account type
const hdAccounts = allAccounts.filter(acc => acc.type === 'HD');
const importedAccounts = allAccounts.filter(acc => acc.type === 'Simple');

// Remove an imported account (HD accounts cannot be removed)
const accountToRemove = vault.getAccounts().find(acc => acc.type === 'Simple');
if (accountToRemove) {
  vault.removeAccount(accountToRemove.address);
  console.log('Account removed:', accountToRemove.address);
}

// Export the 24-word mnemonic phrase (requires password verification)
try {
  const mnemonic = await vault.exportMnemonic('your-secure-password');
  console.log('Recovery phrase:', mnemonic);
  
  // IMPORTANT: Show this to user securely and never log it
  // User should write it down and store it safely
} catch (error) {
  console.error('Failed to export mnemonic:', error.message);
}

// Get private key for a specific account (vault must be unlocked)
const accountAddress = '0x1234...';
const privateKey = vault.getPrivateKeyFor(accountAddress);
console.log('Private key:', privateKey);

// WARNING: Handle private key securely, never expose it

// Check if vault is unlocked
const isUnlocked = vault.isUnlocked();
console.log('Vault unlocked:', isUnlocked);

// Get vault information
const vaultInfo = vault.getVaultInfo();
console.log('Vault info:', vaultInfo);

import { type ChainId } from 'p-sdk-wallet';
import { ethers } from 'ethers';

const accountAddress = '0x1234...';
const chainId: ChainId = '1'; // Ethereum mainnet

// Get native token balance (ETH, BNB, MATIC, etc.)
const balance = await vault.getNativeBalance(accountAddress, chainId);
console.log('Balance:', ethers.formatEther(balance), 'ETH');

const tokenAddress = '0xA0b86a33E6441b8c4C8C8C8C8C8C8C8C8C8C8C8C'; // USDC
const tokenBalance = await vault.getTokenBalance(accountAddress, tokenAddress, chainId);
console.log('Token balance:', tokenBalance.toString());

// Get token metadata (name, symbol, decimals)
const tokenInfo = await vault.getTokenInfo(tokenAddress, chainId);
console.log('Token info:', {
  name: tokenInfo.name,
  symbol: tokenInfo.symbol,
  decimals: tokenInfo.decimals,
  totalSupply: tokenInfo.totalSupply.toString()
});

const senderAddress = '0x1234...';
const recipientAddress = '0x5678...';
const amount = '0.01'; // 0.01 ETH
const chainId: ChainId = '1';

try {
  const txResponse = await vault.sendNativeToken(
    senderAddress,
    recipientAddress,
    amount,
    chainId
  );
  
  console.log('Transaction sent:', {
    hash: txResponse.hash,
    from: txResponse.from,
    to: txResponse.to,
    value: txResponse.value.toString()
  });
  
  // Wait for confirmation
  const receipt = await txResponse.wait();
  console.log('Transaction confirmed:', receipt.blockNumber);
} catch (error) {
  console.error('Transaction failed:', error.message);
}

const tokenAddress = '0xA0b86a33E6441b8c4C8C8C8C8C8C8C8C8C8C8C8C'; // USDC
const amount = '100'; // 100 USDC

try {
  const txResponse = await vault.sendToken(
    senderAddress,
    recipientAddress,
    tokenAddress,
    amount,
    chainId
  );
  
  console.log('Token transaction sent:', txResponse.hash);
} catch (error) {
  console.error('Token transaction failed:', error.message);
}

// Get recent transactions for an account
const transactions = await vault.getTransactionHistory(accountAddress, chainId);
console.log('Transaction history:', transactions);

import { SUPPORTED_CHAINS } from 'p-sdk-wallet';

console.log('Supported chains:', SUPPORTED_CHAINS);
// Output:
// {
//   '1': { name: 'Ethereum', symbol: 'ETH', ... },
//   '56': { name: 'BNB Smart Chain', symbol: 'BNB', ... },
//   '137': { name: 'Polygon', symbol: 'MATIC', ... },
//   '42161': { name: 'Arbitrum One', symbol: 'ETH', ... },
//   '10': { name: 'Optimism', symbol: 'ETH', ... },
//   '8453': { name: 'Base', symbol: 'ETH', ... }
// }

// Work with multiple chains simultaneously
const ethereumBalance = await vault.getNativeBalance(accountAddress, '1');
const bscBalance = await vault.getNativeBalance(accountAddress, '56');
const polygonBalance = await vault.getNativeBalance(accountAddress, '137');

console.log('Multi-chain balances:', {
  ethereum: ethers.formatEther(ethereumBalance),
  bsc: ethers.formatEther(bscBalance),
  polygon: ethers.formatEther(polygonBalance)
});

// Generate a wallet where the first account address starts with '0xaaa' (default from config)
const { mnemonic, vault, encryptedVault, address, attempts, elapsedMs } = await Vault.generateVanityHDWallet({
  password: 'password'
});

console.log('Vanity address:', address);
console.log('Attempts:', attempts);
console.log('Time taken:', elapsedMs, 'ms');
// Output: 0xaaa1234567890abcdef...

// Generate with custom prefix
const { mnemonic, vault, encryptedVault, address } = await Vault.generateVanityHDWallet({
  prefix: 'dead', // Custom prefix (without 0x)
  password: 'password'
});

console.log('Custom vanity address:', address);
// Output: 0xdead1234567890abcdef...

// Full control over vanity generation
const { mnemonic, vault, encryptedVault, address } = await Vault.generateVanityHDWallet({
  prefix: 'cool',
  password: 'password',
  maxAttempts: 50000,
  caseSensitive: false,
  onProgress: (attempts: number, elapsedMs: number) => {
    console.log(`Attempt ${attempts}, elapsed: ${elapsedMs}ms`);
  }
});

const handleWalletOperations = async () => {
  try {
    // Create or load vault
    const vault = await Vault.load(password, encryptedVault);
    
    // Add account
    const account = await vault.addNewHDAccount();
    
    // Get balance
    const balance = await vault.getNativeBalance(account.address, '1');
    
    // Send transaction
    const tx = await vault.sendNativeToken(
      account.address,
      recipientAddress,
      '0.01',
      '1'
    );
    
    console.log('All operations successful');
    
  } catch (error) {
    if (error instanceof Error) {
      switch (error.message) {
        case 'Decryption failed':
          console.error('Incorrect password');
          break;
        case 'Insufficient balance':
          console.error('Not enough funds for transaction');
          break;
        case 'Invalid address':
          console.error('Invalid recipient address');
          break;
        case 'Network error':
          console.error('Network connection issue');
          break;
        default:
          console.error('Unknown error:', error.message);
      }
    }
  }
};

// The exportMnemonic function has built-in rate limiting
// It will throw an error if called too frequently
try {
  const mnemonic = await vault.exportMnemonic(password);
  // Success
} catch (error) {
  if (error.message.includes('Rate limit exceeded')) {
    console.error('Please wait before trying again');
  }
}

// Perform multiple operations efficiently
const batchOperations = async (vault: Vault) => {
  const accounts = vault.getAccounts();
  const chainId: ChainId = '1';
  
  // Get balances for all accounts
  const balancePromises = accounts.map(account => 
    vault.getNativeBalance(account.address, chainId)
  );
  
  const balances = await Promise.all(balancePromises);
  
  accounts.forEach((account, index) => {
    console.log(`${account.name}: ${ethers.formatEther(balances[index])} ETH`);
  });
};

// Complete backup process
const backupWallet = async (vault: Vault, password: string) => {
  // Export encrypted vault
  const encryptedVault = vault.exportEncryptedVault();
  
  // Export mnemonic (for recovery)
  const mnemonic = await vault.exportMnemonic(password);
  
  // Save both securely
  const backup = {
    encryptedVault,
    mnemonic,
    timestamp: Date.now(),
    version: '1.0.0'
  };
  
  return backup;
};

// Restore from backup
const restoreWallet = async (backup: any, password: string) => {
  const vault = await Vault.load(password, backup.encryptedVault);
  return vault;
};

// Secure wallet initialization
const secureWalletInit = async () => {
  // 1. Generate strong password
  const password = generateStrongPassword();
  
  // 2. Create vault with vanity address (uses default config)
  const { mnemonic, vault, encryptedVault, address } = await Vault.generateVanityHDWallet({
    password: password
  });
  
  // 3. Save encrypted vault securely
  await saveToSecureStorage(encryptedVault);
  
  // 4. Export and display mnemonic securely
  const exportedMnemonic = await vault.exportMnemonic(password);
  displayMnemonicSecurely(exportedMnemonic);
  
  // 5. Clear sensitive data from memory
  clearSensitiveData();
  
  return vault;
};

import { 
  Vault, 
  type Account, 
  type ChainId, 
  type EncryptedData,
  type TokenInfo,
  type TransactionResponse,
  type VaultInfo
} from 'p-sdk-wallet';

// Use types for better development experience
const accounts: Account[] = vault.getAccounts();
const chainId: ChainId = '1';
const tokenInfo: TokenInfo = await vault.getTokenInfo(tokenAddress, chainId);

import { Vault, type EncryptedData } from 'p-sdk-wallet';
import * as Keychain from 'react-native-keychain';

class WalletManager {
  private static readonly VAULT_KEY = 'pwc-wallet-vault';
  private static readonly VAULT_SERVICE = 'com.pwc.wallet';

  /**
   * Save the encrypted vault to iOS Keychain
   */
  static async saveVault(encryptedVault: EncryptedData): Promise<void> {
    try {
      const vaultData = JSON.stringify(encryptedVault);
      
      await Keychain.setGenericPassword(
        this.VAULT_KEY,
        vaultData,
        {
          service: this.VAULT_SERVICE,
          accessControl: Keychain.ACCESS_CONTROL.BIOMETRIC_ANY,
          accessible: Keychain.ACCESSIBLE.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
          authenticationType: Keychain.AUTHENTICATION_TYPE.BIOMETRICS,
        }
      );
      
      console.log('Vault saved to Keychain successfully');
    } catch (error) {
      console.error('Failed to save vault to Keychain:', error);
      throw new Error('Failed to save wallet securely');
    }
  }

  /**
   * Load the encrypted vault from iOS Keychain
   */
  static async loadVault(password: string): Promise<Vault> {
    try {
      // Retrieve the encrypted vault from Keychain
      const credentials = await Keychain.getGenericPassword({
        service: this.VAULT_SERVICE,
        authenticationPrompt: {
          title: 'Unlock Wallet',
          subtitle: 'Use Face ID or Touch ID to access your wallet',
          description: 'Authenticate to unlock your wallet',
          cancel: 'Cancel',
        },
      });

      if (!credentials || !credentials.password) {
        throw new Error('No wallet found. Please create a new wallet first.');
      }

      // Parse the encrypted vault data
      const encryptedVault: EncryptedData = JSON.parse(credentials.password);

      // Load the vault using the provided password
      const vault = await Vault.load(password, encryptedVault);
      
      console.log('Vault loaded successfully');
      return vault;
    } catch (error) {
      if (error instanceof Error) {
        if (error.message.includes('Decryption failed')) {
          throw new Error('Incorrect password. Please try again.');
        }
        if (error.message.includes('No wallet found')) {
          throw new Error('No wallet found. Please create a new wallet first.');
        }
      }
      
      console.error('Failed to load vault:', error);
      throw new Error('Failed to load wallet. Please try again.');
    }
  }

  /**
   * Check if a wallet exists on the device
   */
  static async hasExistingWallet(): Promise<boolean> {
    try {
      const credentials = await Keychain.getGenericPassword({
        service: this.VAULT_SERVICE,
      });
      return !!credentials && !!credentials.password;
    } catch (error) {
      return false;
    }
  }

  /**
   * Delete the wallet from Keychain (for logout/reset)
   */
  static async deleteVault(): Promise<void> {
    try {
      await Keychain.resetGenericPassword({
        service: this.VAULT_SERVICE,
      });
      console.log('Vault deleted from Keychain');
    } catch (error) {
      console.error('Failed to delete vault:', error);
      throw new Error('Failed to delete wallet');
    }
  }
}

// Usage Example:
const initializeWallet = async (password: string) => {
  try {
    // Check if wallet exists
    const hasWallet = await WalletManager.hasExistingWallet();
    
    if (hasWallet) {
      // Load existing wallet
      const vault = await WalletManager.loadVault(password);
      console.log('Wallet loaded:', vault.getAccounts());
      return vault;
    } else {
      // Create new wallet
      const { vault: newVault, encryptedVault } = await Vault.createNew(password);
      await WalletManager.saveVault(encryptedVault);
      console.log('New wallet created:', vault.getAccounts());
      return vault;
    }
  } catch (error) {
    console.error('Wallet initialization failed:', error);
    throw error;
  }
};

import React, { useState, useEffect } from 'react';
import { View, Text, TextInput, TouchableOpacity, Alert } from 'react-native';
import { Vault } from 'p-sdk-wallet';
import { WalletManager } from './WalletManager';

const WalletScreen: React.FC = () => {
  const [password, setPassword] = useState('');
  const [vault, setVault] = useState<Vault | null>(null);
  const [loading, setLoading] = useState(false);

  useEffect(() => {
    checkExistingWallet();
  }, []);

  const checkExistingWallet = async () => {
    const hasWallet = await WalletManager.hasExistingWallet();
    if (!hasWallet) {
      Alert.alert(
        'Welcome!',
        'No wallet found. Please create a new wallet to get started.',
        [{ text: 'OK' }]
      );
    }
  };

  const handleUnlockWallet = async () => {
    if (!password.trim()) {
      Alert.alert('Error', 'Please enter your password');
      return;
    }

    setLoading(true);
    try {
      const loadedVault = await WalletManager.loadVault(password);
      setVault(loadedVault);
      setPassword('');
      
      const accounts = loadedVault.getAccounts();
      Alert.alert('Success', `Wallet unlocked! Found ${accounts.length} account(s)`);
    } catch (error) {
      Alert.alert('Error', error instanceof Error ? error.message : 'Failed to unlock wallet');
    } finally {
      setLoading(false);
    }
  };

  const handleCreateWallet = async () => {
    if (!password.trim()) {
      Alert.alert('Error', 'Please enter a password');
      return;
    }

    setLoading(true);
    try {
      const { vault: newVault, encryptedVault } = await Vault.createNew(password);
      await WalletManager.saveVault(encryptedVault);
      setVault(newVault);
      setPassword('');
      
      Alert.alert(
        'Wallet Created!',
        'Your wallet has been created successfully. Please save your recovery phrase in a secure location.',
        [{ text: 'OK' }]
      );
    } catch (error) {
      Alert.alert('Error', 'Failed to create wallet');
    } finally {
      setLoading(false);
    }
  };

  return (
    <View style={{ flex: 1, padding: 20 }}>
      <Text style={{ fontSize: 24, marginBottom: 20 }}>PWC Wallet</Text>
      
      <TextInput
        style={{ borderWidth: 1, borderColor: '#ccc', padding: 10, marginBottom: 20 }}
        placeholder="Enter password"
        value={password}
        onChangeText={setPassword}
        secureTextEntry
      />
      
      <TouchableOpacity
        style={{ backgroundColor: '#007AFF', padding: 15, marginBottom: 10 }}
        onPress={handleUnlockWallet}
        disabled={loading}
      >
        <Text style={{ color: 'white', textAlign: 'center' }}>
          {loading ? 'Loading...' : 'Unlock Wallet'}
        </Text>
      </TouchableOpacity>
      
      <TouchableOpacity
        style={{ backgroundColor: '#34C759', padding: 15 }}
        onPress={handleCreateWallet}
        disabled={loading}
      >
        <Text style={{ color: 'white', textAlign: 'center' }}>
          {loading ? 'Creating...' : 'Create New Wallet'}
        </Text>
      </TouchableOpacity>
      
      {vault && (
        <View style={{ marginTop: 20 }}>
          <Text style={{ fontSize: 18, marginBottom: 10 }}>Your Accounts:</Text>
          {vault.getAccounts().map((account, index) => (
            <Text key={index} style={{ marginBottom: 5 }}>
              {account.name}: {account.address}
            </Text>
          ))}
        </View>
      )}
    </View>
  );
};

export default WalletScreen;

import { Vault } from 'pwc-wallet-sdk';

// Create a new wallet (EVM by default)
const { vault, encryptedVault } = await Vault.createNew('your-password');

// Create a new Solana wallet
const { vault: solanaVault, encryptedVault: solanaEncryptedVault } = 
  await Vault.createNew('your-password', 'solana');

// Load existing wallet
const loadedVault = await Vault.load('your-password', encryptedVault);

// Get all accounts
const accounts = vault.getAccounts();
console.log('Accounts:', accounts);

// Create new EVM vault
const { vault, encryptedVault } = await Vault.createNew('password');

// Create new Solana vault
const { vault, encryptedVault } = await Vault.createNew('password', 'solana');

// Create from existing mnemonic (EVM)
const { vault, encryptedVault } = await Vault.createFromMnemonic(
  'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about',
  'password'
);

// Create from existing mnemonic (Solana)
const { vault, encryptedVault } = await Vault.createFromMnemonic(
  'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about',
  'password',
  'solana'
);

// Load encrypted vault
const vault = await Vault.load('password', encryptedVault);

// Add new HD account (EVM)
const newAccount = await vault.addNewHDAccount();

// Add new Solana account
const newSolanaAccount = await vault.addNewSolanaAccount();

// Import account from private key
const importedAccount = await vault.importAccount('0x123...');

// Get all accounts
const accounts = vault.getAccounts();
// Returns: [
//   { address: '0x123...', type: 'HD', name: 'Account 1' },
//   { address: 'ABC123...', type: 'Solana', name: 'Solana 1' },
//   { address: '0x456...', type: 'Simple', name: 'Imported 1' }
// ]

// Get native balance (works for both EVM and Solana)
const ethBalance = await vault.getNativeBalance('0x123...', '1'); // Ethereum
const solBalance = await vault.getNativeBalance('ABC123...', 'solana'); // Solana

// Send native tokens
const tx = await vault.sendNativeToken(
  '0x123...', // from address
  '0x456...', // to address
  '0.1', // amount
  '1' // chain ID (Ethereum)
);

const solTx = await vault.sendNativeToken(
  'ABC123...', // from address
  'DEF456...', // to address
  '0.5', // amount in SOL
  'solana' // chain ID (Solana)
);

// Get token info
const tokenInfo = await vault.getTokenInfo('0x123...', '1'); // ERC-20
const splTokenInfo = await vault.getTokenInfo('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', 'solana'); // SPL

// Get token balance
const balance = await vault.getTokenBalance('0x123...', '0x456...', '1');
const splBalance = await vault.getTokenBalance('ABC123...', 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', 'solana');

// Send tokens
const tokenTx = await vault.sendToken(
  '0x123...', // from address
  '0x456...', // to address
  '100', // amount
  '0x789...', // token contract address
  '1' // chain ID
);

const splTx = await vault.sendToken(
  'ABC123...', // from address
  'DEF456...', // to address
  '50', // amount
  'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // SPL token address
  'solana' // chain ID
);

// Generate vanity wallet with prefix
const { vault, encryptedVault, attempts, foundAddress } = await Vault.generateVanityHDWallet(
  'aaa', // prefix (without 0x)
  'password',
  'evm',
  1000000, // max attempts
  false, // case sensitive
  (attempts, address) => {
    console.log(`Attempt ${attempts}: ${address}`);
  }
);

console.log(`Found address: ${foundAddress} after ${attempts} attempts`);

// Generate Solana vanity wallet
const { vault, encryptedVault, attempts, foundAddress } = await Vault.generateVanityHDWallet(
  'abc', // prefix
  'password',
  'solana',
  1000000, // max attempts
  false, // case sensitive
  (attempts, address) => {
    console.log(`Attempt ${attempts}: ${address}`);
  }
);

console.log(`Found Solana address: ${foundAddress} after ${attempts} attempts`);

// Export mnemonic with password verification
const mnemonic = await vault.exportMnemonic('password');
console.log('Mnemonic:', mnemonic);

// Get private key for specific address (vault must be unlocked)
const privateKey = await vault.getPrivateKeyFor('0x123...');
console.log('Private key:', privateKey);

import * as Keychain from 'react-native-keychain';
import { Vault } from 'pwc-wallet-sdk';

class WalletManager {
  static async saveVault(encryptedVault: any, password: string): Promise<void> {
    try {
      await Keychain.setInternetCredentials(
        'pwc-wallet-vault',
        'user',
        JSON.stringify(encryptedVault)
      );
    } catch (error) {
      console.error('Failed to save vault:', error);
      throw error;
    }
  }

  static async loadVault(password: string): Promise<Vault> {
    try {
      const credentials = await Keychain.getInternetCredentials('pwc-wallet-vault');
      if (!credentials || !credentials.password) {
        throw new Error('No vault found');
      }

      const encryptedVault = JSON.parse(credentials.password);
      return await Vault.load(password, encryptedVault);
    } catch (error) {
      console.error('Failed to load vault:', error);
      throw error;
    }
  }

  static async deleteVault(): Promise<void> {
    try {
      await Keychain.resetInternetCredentials('pwc-wallet-vault');
    } catch (error) {
      console.error('Failed to delete vault:', error);
      throw error;
    }
  }
}

import React, { useState, useEffect } from 'react';
import { View, Text, Button, Alert } from 'react-native';
import { Vault } from 'pwc-wallet-sdk';
import { WalletManager } from './WalletManager';

const WalletScreen: React.FC = () => {
  const [vault, setVault] = useState<Vault | null>(null);
  const [accounts, setAccounts] = useState<any[]>([]);

  const createWallet = async () => {
    try {
      const { vault: newVault, encryptedVault } = await Vault.createNew('my-password');
      await WalletManager.saveVault(encryptedVault, 'my-password');
      setVault(newVault);
      setAccounts(newVault.getAccounts());
    } catch (error) {
      Alert.alert('Error', 'Failed to create wallet');
    }
  };

  const loadWallet = async () => {
    try {
      const loadedVault = await WalletManager.loadVault('my-password');
      setVault(loadedVault);
      setAccounts(loadedVault.getAccounts());
    } catch (error) {
      Alert.alert('Error', 'Failed to load wallet');
    }
  };

  const addSolanaAccount = async () => {
    if (!vault) return;
    try {
      const newAccount = await vault.addNewSolanaAccount();
      setAccounts(vault.getAccounts());
    } catch (error) {
      Alert.alert('Error', 'Failed to add Solana account');
    }
  };

  return (
    <View>
      <Text>Wallet Accounts:</Text>
      {accounts.map((account, index) => (
        <Text key={index}>
          {account.name}: {account.address} ({account.type})
        </Text>
      ))}
      
      <Button title="Create Wallet" onPress={createWallet} />
      <Button title="Load Wallet" onPress={loadWallet} />
      <Button title="Add Solana Account" onPress={addSolanaAccount} />
    </View>
  );
};

import { VANITY_WALLET_CONFIG } from 'pwc-wallet-sdk';

// Default configuration
console.log(VANITY_WALLET_CONFIG);
// {
//   DEFAULT_PREFIX: 'aaa',
//   DEFAULT_MAX_ATTEMPTS: 1000000,
//   DEFAULT_CASE_SENSITIVE: false,
//   PROGRESS_UPDATE_INTERVAL: 1000,
//   NON_BLOCKING_INTERVAL: 10000,
//   MAX_PREFIX_LENGTH: 10,
//   MAX_ATTEMPTS_LIMIT: 10000000
// }

try {
  const vault = await Vault.load('wrong-password', encryptedVault);
} catch (error) {
  if (error.message.includes('Invalid password')) {
    console.log('Wrong password provided');
  } else if (error.message.includes('Corrupted vault')) {
    console.log('Vault data is corrupted');
  }
}

try {
  const mnemonic = await vault.exportMnemonic('password');
} catch (error) {
  if (error.message.includes('Rate limit exceeded')) {
    console.log('Too many export attempts');
  } else if (error.message.includes('Invalid password')) {
    console.log('Wrong password');
  }
}