constructor(dragonfire: DragonFireClient, options?: WalletClientOptions)

import { DragonFireClient } from '@dragonfire/client';
import { WalletClient } from '@dragonfire/wallet-client';

// Initialize DragonFire client
const dragonfire = new DragonFireClient({
  apiKey: 'YOUR_API_KEY',
  region: 'us-west'
});
await dragonfire.connect();

// Initialize wallet client
const wallet = new WalletClient(dragonfire, {
  securityLevel: 'high',       // Security level for wallet operations
  vectorDimension: 7,          // Vector space dimension for transactions
  autoBackup: true,            // Enable automatic wallet backups
  identityVerification: true   // Enable advanced identity verification
});

async unwrapToken(wrappedToken: string, options?: UnwrapOptions): Promise

// Verify a wrapped token
const verification = await wallet.unwrapToken(wrappedToken, {
  service: 'payment-gateway',   // Service requesting verification
  permissions: ['transaction'],  // Required permissions
  strictValidation: true        // Strict validation mode
});

if (verification.valid) {
  console.log('Token verified successfully');
  console.log('User ID:', verification.userId);
  console.log('Permissions:', verification.permissions);
  console.log('Expires in:', verification.expiresIn, 'ms');
  
  // Proceed with authenticated operation
  // ...
} else {
  console.error('Token verification failed:', verification.reason);
}

async createWallet(options?: CreateWalletOptions): Promise

// Create a new wallet
const walletInfo = await wallet.createWallet({
  name: 'Primary Wallet',            // Wallet name
  securityLevel: 'high',             // Security level
  backupMethod: 'cloud',             // Backup method
  recoveryOptions: {                 // Recovery options
    email: 'user@example.com',
    phoneNumber: '+1234567890'
  },
  attributes: {                      // Custom attributes
    purpose: 'personal',
    limit: 1000
  }
});

console.log('Wallet created successfully');
console.log('Wallet ID:', walletInfo.id);
console.log('Address:', walletInfo.address);
console.log('Creation date:', new Date(walletInfo.createdAt));
console.log('Backup status:', walletInfo.backupStatus);

// Save recovery phrase securely
console.log('IMPORTANT: Save your recovery phrase securely:');
console.log(walletInfo.recoveryPhrase);

async importWallet(importData: WalletImportData, options?: ImportOptions): Promise

// Import wallet using recovery phrase
const importedWallet = await wallet.importWallet({
  recoveryPhrase: 'dragon fire quantum space vector phi golden ratio harmony',
  walletName: 'Imported Wallet'
}, {
  restoreIdentity: true,          // Restore associated identity
  overwriteExisting: false,       // Don't overwrite existing wallet
  validateBeforeImport: true      // Validate recovery phrase before import
});

console.log('Wallet imported successfully');
console.log('Wallet ID:', importedWallet.id);
console.log('Address:', importedWallet.address);
console.log('Balance:', importedWallet.balance);

async getWalletInfo(walletId?: string, options?: InfoOptions): Promise

// Get information about the active wallet
const walletInfo = await wallet.getWalletInfo(null, {
  includeBalance: true,          // Include balance information
  includeTransactions: true,     // Include recent transactions
  includeIdentity: true,         // Include identity information
  transactionLimit: 10           // Limit to 10 most recent transactions
});

console.log('Wallet information:');
console.log('ID:', walletInfo.id);
console.log('Name:', walletInfo.name);
console.log('Address:', walletInfo.address);
console.log('Balance:', walletInfo.balance);
console.log('Currency:', walletInfo.currency);
console.log('Status:', walletInfo.status);
console.log('Created:', new Date(walletInfo.createdAt));
console.log('Last accessed:', new Date(walletInfo.lastAccessedAt));
console.log('Security level:', walletInfo.securityLevel);
console.log('Backup status:', walletInfo.backupStatus);

if (walletInfo.transactions) {
  console.log('Recent transactions:');
  walletInfo.transactions.forEach(tx => {
    console.log(`- ${tx.id}: ${tx.type} ${tx.amount} ${tx.currency}`);
    console.log(`  Status: ${tx.status}, Date: ${new Date(tx.timestamp)}`);
  });
}

async createTransaction(transaction: TransactionData, options?: TransactionOptions): Promise

// Create a vector transaction
const result = await wallet.createTransaction({
  recipient: 'wallet_789',     // Recipient wallet ID or address
  amount: 50.75,               // Transaction amount
  currency: 'USD',             // Currency code
  memo: 'Payment for services' // Transaction memo
}, {
  priority: 'high',            // Transaction priority
  vectorRouting: 'phi',        // Vector routing pattern
  maxFee: 1.5,                 // Maximum fee allowed
  timeout: 30000,              // Transaction timeout (ms)
  securityLevel: 'high'        // Security level for transaction
});

console.log('Transaction created:');
console.log('Transaction ID:', result.transactionId);
console.log('Status:', result.status);
console.log('Timestamp:', new Date(result.timestamp));
console.log('Fee:', result.fee);
console.log('Confirmations required:', result.confirmationsRequired);
console.log('Estimated completion time:', new Date(result.estimatedCompletionTime));

async getTransactionStatus(transactionId: string, options?: StatusOptions): Promise

// Check transaction status
const status = await wallet.getTransactionStatus('tx_123456789', {
  includeVectorPath: true,     // Include vector path information
  includeHistory: true         // Include status history
});

console.log('Transaction status:', status.status);
console.log('Confirmations:', status.confirmations, '/', status.confirmationsRequired);
console.log('Last updated:', new Date(status.lastUpdated));

if (status.vectorPath) {
  console.log('Vector path:', status.vectorPath);
  console.log('Path efficiency:', status.pathEfficiency);
}

if (status.history) {
  console.log('Status history:');
  status.history.forEach(entry => {
    console.log(`- ${new Date(entry.timestamp)}: ${entry.status}`);
  });
}

async analyzeVectorPath(transactionId: string, options?: AnalysisOptions): Promise

// Analyze transaction vector path
const analysis = await wallet.analyzeVectorPath('tx_123456789', {
  detailLevel: 'high',           // Analysis detail level
  includeAlternatives: true,     // Include alternative paths
  optimizationSuggestions: true  // Include optimization suggestions
});

console.log('Vector path analysis:');
console.log('Path length:', analysis.pathLength);
console.log('Efficiency rating:', analysis.efficiencyRating.toFixed(2), '/10');
console.log('Mathematical pattern:', analysis.pattern);
console.log('Completion time:', analysis.completionTimeMs, 'ms');
console.log('Processing nodes:', analysis.processingNodes);

if (analysis.optimizationSuggestions) {
  console.log('Suggested optimizations:');
  analysis.optimizationSuggestions.forEach(suggestion => {
    console.log(`- ${suggestion.description}`);
    console.log(`  Efficiency improvement: ${suggestion.improvementPercent}%`);
  });
}

async createIdentity(identity: IdentityData, options?: IdentityOptions): Promise

// Create a digital identity
const identity = await wallet.createIdentity({
  displayName: 'Alice Johnson',
  email: 'alice@example.com',
  attributes: {
    country: 'US',
    birthYear: 1985,
    profession: 'Software Engineer'
  },
  verificationLevel: 'standard',
  walletId: 'wallet_123'  // Associate with specific wallet
}, {
  privacyLevel: 'high',       // Privacy protection level
  backupIdentity: true,       // Create identity backup
  allowCredentials: true      // Allow credential attachment
});

console.log('Identity created:');
console.log('Identity ID:', identity.id);
console.log('Display name:', identity.displayName);
console.log('Verification status:', identity.verificationStatus);
console.log('Created at:', new Date(identity.createdAt));
console.log('Associated wallet:', identity.walletId);

// Store the identity credential securely
console.log('Identity credential:', identity.credential);

async verifyIdentity(identityId: string, verificationData: VerificationData, options?: VerificationOptions): Promise

// Verify identity through document verification
const verificationResult = await wallet.verifyIdentity('identity_123', {
  method: 'document',              // Verification method
  documentType: 'passport',        // Document type
  documentNumber: 'AB1234567',     // Document number
  documentCountry: 'US',           // Issuing country
  expirationDate: '2030-01-01',    // Document expiration date
  documentImage: documentImageData // Document image data
}, {
  strictVerification: true,        // Use strict verification rules
  saveDocumentData: false,         // Don't save sensitive document data
  requestHumanReview: false        // Don't request human review
});

console.log('Verification result:');
console.log('Status:', verificationResult.status);
console.log('Confidence score:', verificationResult.confidenceScore);
console.log('Verification ID:', verificationResult.verificationId);
console.log('Verified fields:', verificationResult.verifiedFields);
console.log('Verification timestamp:', new Date(verificationResult.timestamp));

if (verificationResult.nextSteps) {
  console.log('Next steps for full verification:');
  verificationResult.nextSteps.forEach(step => {
    console.log(`- ${step.description}`);
  });
}

async issueCredential(identityId: string, credentialData: CredentialData, options?: CredentialOptions): Promise

// Issue a verifiable credential
const credential = await wallet.issueCredential('identity_123', {
  type: 'EducationCredential',
  issuer: {
    id: 'issuer_456',
    name: 'University of Technology'
  },
  claims: {
    degree: 'Bachelor of Science',
    field: 'Computer Science',
    graduationDate: '2020-06-15',
    gpa: 3.8
  },
  expirationDate: '2030-01-01'
}, {
  revocable: true,              // Allow credential revocation
  proofType: 'phi-signature',   // Signature proof type
  storageLocation: 'wallet',    // Store in wallet
  notifyRecipient: true         // Notify recipient
});

console.log('Credential issued:');
console.log('Credential ID:', credential.id);
console.log('Type:', credential.type);
console.log('Issuer:', credential.issuer.name);
console.log('Issuance date:', new Date(credential.issuanceDate));
console.log('Expiration date:', new Date(credential.expirationDate));
console.log('Verification method:', credential.verificationMethod);

// Proof information
console.log('Proof type:', credential.proof.type);
console.log('Proof created:', new Date(credential.proof.created));
console.log('Proof purpose:', credential.proof.purpose);

async setupMFA(mfaType: MFAType, mfaData: MFASetupData, options?: MFAOptions): Promise

// Set up TOTP (Time-based One-Time Password) authentication
const totpSetup = await wallet.setupMFA('totp', {
  label: 'Alice\'s Wallet'
}, {
  issuer: 'DragonFire Wallet',
  digits: 6,
  period: 30,
  algorithm: 'SHA-256'
});

console.log('TOTP MFA set up successfully');
console.log('Secret key:', totpSetup.secret);
console.log('QR code URL:', totpSetup.qrCodeUrl);
console.log('URI:', totpSetup.uri);

// Verify TOTP setup with a test code
const verificationResult = await wallet.verifyMFA('totp', {
  code: '123456'  // Code from authenticator app
});

if (verificationResult.verified) {
  console.log('TOTP verification successful');
} else {
  console.error('TOTP verification failed');
}

async signTransaction(transactionId: string, options?: SigningOptions): Promise

// Sign a transaction
const signingResult = await wallet.signTransaction('tx_123456789', {
  signingMethod: 'phi-vector',    // Signing method
  securityLevel: 'high',          // Security level
  includeBiometrics: true,        // Include biometric verification
  useHardwareKey: false,          // Don't use hardware key
  mfaRequired: true               // Require MFA
});

console.log('Transaction signed:');
console.log('Signature:', signingResult.signature);
console.log('Signing method:', signingResult.method);
console.log('Timestamp:', new Date(signingResult.timestamp));
console.log('Public key:', signingResult.publicKey);
console.log('Signature verification URL:', signingResult.verificationUrl);

async createRWTToken(tokenData: TokenData, options?: TokenOptions): Promise

// Create an RWT token
const token = await wallet.createRWTToken({
  purpose: 'payment-gateway',     // Token purpose
  permissions: ['transaction'],    // Token permissions
  expiresIn: 3600000,              // Token expiration (1 hour)
  metadata: {                      // Additional metadata
    service: 'e-commerce',
    transactionLimit: 500
  }
}, {
  rotationPattern: 'phi',          // Token rotation pattern
  rotationInterval: 300000,        // Rotation interval (5 minutes)
  securityLevel: 'high',           // Token security level
  wrappedToken: true               // Create wrapped token
});

console.log('RWT token created:');
console.log('Token:', token.token);
console.log('Expires at:', new Date(token.expiresAt));
console.log('Rotation count:', token.rotationCount);
console.log('Rotation interval:', token.rotationInterval);
console.log('Verification URL:', token.verificationUrl);

async verifyRWTToken(token: string, options?: VerifyOptions): Promise

// Verify an RWT token
const verification = await wallet.verifyRWTToken(token, {
  checkPermissions: ['transaction'],  // Required permissions
  service: 'payment-gateway',         // Expected service
  strictValidation: true              // Use strict validation
});

if (verification.valid) {
  console.log('Token is valid');
  console.log('User ID:', verification.userId);
  console.log('Permissions:', verification.permissions);
  console.log('Issued at:', new Date(verification.issuedAt));
  console.log('Expires at:', new Date(verification.expiresAt));
  console.log('Current rotation:', verification.currentRotation);
  
  // Proceed with authenticated operation
  // ...
} else {
  console.error('Token is invalid:', verification.reason);
}

async rotateRWTToken(token: string, options?: RotationOptions): Promise

// Rotate an RWT token
const rotationResult = await wallet.rotateRWTToken(token, {
  extendValidity: true,           // Extend the token validity
  additionalTime: 3600000,        // Add 1 hour to validity
  preservePermissions: true,      // Preserve original permissions
  updateMetadata: {               // Update metadata
    lastRotated: Date.now()
  }
});

console.log('Token rotated:');
console.log('New token:', rotationResult.newToken);
console.log('Rotation count:', rotationResult.rotationCount);
console.log('Previous token valid until:', new Date(rotationResult.previousValidUntil));
console.log('New expiration:', new Date(rotationResult.expiresAt));
console.log('Next rotation in:', rotationResult.nextRotationMs, 'ms');