// DragonFire Wallet Service Identity Management
// All identity operations are managed through our secure Dragon Wallet service

// Identity Structure Overview
// - Unique Identifier: Generated and managed by the service
// - User Information: Username, display name, profile settings
// - Authentication Keys: Managed securely by the service
// - Rotation Keys: Automatic rotation handled by service
// - Metadata: Service-managed additional identity data
// - Verification Status: Multi-level verification status

// Creating a New Identity via Service
// 1. Register at https://wallets.dragonfire1.com
// 2. Complete identity verification process
// 3. Receive identity credentials for API access
// 4. Access identity through service endpoints

// Service Endpoints for Identity Management:
// - POST /api/identities/create - Create new managed identity
// - GET /api/identities/:id - Retrieve identity information
// - PUT /api/identities/:id - Update identity information
// - GET /api/identities/:id/verification - Check verification status

// Identity Verification Service
// The Dragon Wallet service handles all verification securely

// Verification Levels available through the service:
// - LEVEL_BASIC: Basic email/phone verification
// - LEVEL_STANDARD: Two-factor authentication verification
// - LEVEL_ENHANCED: Additional personal information validation
// - LEVEL_BUSINESS: Business entity verification with documentation
// - LEVEL_ENTERPRISE: Enterprise-level verification with legal validation

// Verification Service Process:
// 1. Service generates a secure challenge specific to the identity
// 2. User responds to the challenge through the secure wallet interface
// 3. Service validates the challenge response
// 4. Service updates the identity verification level
// 5. Applications can query verification status through the API

// Verification Methods Supported by the Service:
// - Knowledge factors: Passwords, security questions, PIN codes
// - Possession factors: Mobile devices, hardware tokens, email access
// - Inherence factors: Biometric verifications (where supported)
// - Document verification: ID verification, business registration
// - Third-party verification: KYC/AML compliance checks

// Verification Service Endpoints:
// - POST /api/verification/challenge - Request a verification challenge
// - POST /api/verification/response - Submit challenge response
// - GET /api/verification/status/:id - Check verification status
// - PUT /api/verification/level/:id - Request verification level upgrade

// Authenticate user with RWT token
authentication_result_t* authenticate_user(user_identity_t* identity, 
                                        rwt_token_t* token) {
    authentication_result_t* result = (authentication_result_t*)malloc(
        sizeof(authentication_result_t));
    
    // Initialize result
    result->success = false;
    result->auth_level = AUTH_NONE;
    result->session_token = NULL;
    
    // Validate token format
    if (!validate_rwt_token(token)) {
        result->error_code = AUTH_ERROR_INVALID_TOKEN;
        return result;
    }
    
    // Verify token authenticity
    if (!verify_rwt_signature(token, &identity->public_key)) {
        result->error_code = AUTH_ERROR_SIGNATURE_INVALID;
        return result;
    }
    
    // Check token rotation validity
    if (!verify_token_rotation(token, identity->rotation_key)) {
        result->error_code = AUTH_ERROR_ROTATION_INVALID;
        return result;
    }
    
    // Check token expiration
    if (is_token_expired(token)) {
        result->error_code = AUTH_ERROR_TOKEN_EXPIRED;
        return result;
    }
    
    // Authentication successful
    result->success = true;
    
    // Determine authentication level based on token claims
    result->auth_level = determine_auth_level(token);
    
    // Generate session token
    result->session_token = generate_session_token(identity, result->auth_level);
    
    // Log authentication event
    log_authentication_event(identity, result);
    
    return result;
}

// Define token types
typedef enum {
    TOKEN_DRAGONCOIN,      // Standard token for larger transactions
    TOKEN_DRAGONBREATH,    // Micro-token for small transactions
    TOKEN_EXTERNAL         // External cryptocurrency or fiat representation
} token_type_t;

// Define wallet balance structure
typedef struct {
    token_type_t token_type;         // Token type
    double amount;                   // Token amount
    char* currency_code;             // Currency code for external tokens
    exchange_rate_t* exchange_rate;  // Current exchange rate (if applicable)
} wallet_balance_t;

// Define transaction structure
typedef struct {
    uuid_t id;                      // Transaction ID
    user_identity_t* sender;        // Sender identity
    user_identity_t* recipient;     // Recipient identity
    token_type_t token_type;        // Token type
    double amount;                  // Transaction amount
    char* description;              // Transaction description
    transaction_fee_t fee;          // Transaction fee
    timestamp_t timestamp;          // Transaction timestamp
    transaction_status_t status;    // Transaction status
    signature_t signature;          // Cryptographic signature
} transaction_t;

// Create new transaction
transaction_t* create_transaction(wallet_t* sender_wallet,
                              user_identity_t* recipient,
                              token_type_t token_type,
                              double amount,
                              char* description) {
    transaction_t* tx = (transaction_t*)malloc(sizeof(transaction_t));
    
    // Generate transaction ID
    uuid_generate(tx->id);
    
    // Set sender and recipient
    tx->sender = sender_wallet->identity;
    tx->recipient = recipient;
    
    // Set transaction details
    tx->token_type = token_type;
    tx->amount = amount;
    tx->description = strdup(description);
    
    // Calculate fee based on token type and amount
    tx->fee = calculate_transaction_fee(token_type, amount);
    
    // Set timestamp
    tx->timestamp = get_current_timestamp();
    
    // Set initial status
    tx->status = TRANSACTION_PENDING;
    
    // Create transaction signature
    tx->signature = sign_transaction(tx, sender_wallet->identity->private_key);
    
    return tx;
}

// Process transaction
transaction_result_t* process_transaction(transaction_t* transaction, 
                                       processing_options_t* options) {
    transaction_result_t* result = (transaction_result_t*)malloc(
        sizeof(transaction_result_t));
    
    // Initialize result
    result->success = false;
    result->transaction_id = transaction->id;
    result->status = TRANSACTION_FAILED;
    
    // Verify transaction signature
    if (!verify_transaction_signature(transaction)) {
        result->error_code = TX_ERROR_INVALID_SIGNATURE;
        return result;
    }
    
    // Check sender balance
    wallet_t* sender_wallet = get_wallet(transaction->sender);
    if (!check_sufficient_balance(sender_wallet, 
                               transaction->token_type, 
                               transaction->amount + transaction->fee.amount)) {
        result->error_code = TX_ERROR_INSUFFICIENT_FUNDS;
        return result;
    }
    
    // Verify recipient exists
    wallet_t* recipient_wallet = get_wallet(transaction->recipient);
    if (!recipient_wallet) {
        result->error_code = TX_ERROR_INVALID_RECIPIENT;
        return result;
    }
    
    // Apply transaction limits
    if (!check_transaction_limits(transaction)) {
        result->error_code = TX_ERROR_LIMIT_EXCEEDED;
        return result;
    }
    
    // Process through secure RWT channel
    rwt_transaction_context_t* rwt_context = create_rwt_transaction_context(
        transaction, options);
    
    rwt_result_t* rwt_result = execute_rwt_transaction(rwt_context);
    
    if (!rwt_result->success) {
        result->error_code = TX_ERROR_RWT_FAILURE;
        result->status = TRANSACTION_FAILED;
        free_rwt_result(rwt_result);
        return result;
    }
    
    // Update balances
    update_sender_balance(sender_wallet, transaction);
    update_recipient_balance(recipient_wallet, transaction);
    
    // Record transaction in ledger
    record_transaction_in_ledger(transaction);
    
    // Update transaction status
    transaction->status = TRANSACTION_COMPLETED;
    
    // Update result
    result->success = true;
    result->status = TRANSACTION_COMPLETED;
    result->confirmation_code = generate_confirmation_code(transaction);
    
    // Free resources
    free_rwt_result(rwt_result);
    
    return result;
}

// Exchange between currency types
exchange_result_t* exchange_currency(wallet_t* wallet,
                                  token_type_t source_type,
                                  double source_amount,
                                  token_type_t target_type,
                                  char* target_currency_code) {
    exchange_result_t* result = (exchange_result_t*)malloc(
        sizeof(exchange_result_t));
    
    // Initialize result
    result->success = false;
    result->source_amount = source_amount;
    result->source_type = source_type;
    result->target_type = target_type;
    
    // Validate wallet
    if (!validate_wallet(wallet)) {
        result->error_code = EXCHANGE_ERROR_INVALID_WALLET;
        return result;
    }
    
    // Check sufficient balance
    if (!check_sufficient_balance(wallet, source_type, source_amount)) {
        result->error_code = EXCHANGE_ERROR_INSUFFICIENT_FUNDS;
        return result;
    }
    
    // Get current exchange rate
    exchange_rate_t* rate = get_exchange_rate(
        source_type, target_type, target_currency_code);
    
    if (!rate) {
        result->error_code = EXCHANGE_ERROR_RATE_UNAVAILABLE;
        return result;
    }
    
    // Calculate exchange result
    double exchange_fee = calculate_exchange_fee(
        source_type, source_amount, target_type);
    
    double converted_amount = (source_amount - exchange_fee) * rate->rate;
    
    // If target is external, apply additional network fees
    if (target_type == TOKEN_EXTERNAL) {
        double network_fee = get_external_network_fee(target_currency_code);
        converted_amount -= network_fee;
    }
    
    // Perform exchange
    if (!perform_currency_exchange(wallet, source_type, source_amount, 
                                 target_type, converted_amount, 
                                 target_currency_code)) {
        result->error_code = EXCHANGE_ERROR_EXECUTION_FAILED;
        return result;
    }
    
    // Update result
    result->success = true;
    result->target_amount = converted_amount;
    result->rate = rate->rate;
    result->fee = exchange_fee;
    
    // Create exchange record
    record_exchange_transaction(wallet, result);
    
    return result;
}

// Initialize Dragon Wallets
DragonWallet* dragon_wallet_init(wallet_config_t* config) {
    DragonWallet* wallet = (DragonWallet*)malloc(sizeof(DragonWallet));
    
    // Initialize based on configuration
    wallet->rwt_enabled = config ? config->use_rwt : true;
    wallet->auto_exchange = config ? config->auto_exchange : false;
    
    // Initialize identity system
    wallet->identity_system = init_identity_system();
    
    // Initialize transaction system
    wallet->transaction_system = init_transaction_system();
    
    // Initialize wallet storage
    wallet->storage = init_wallet_storage();
    
    // Connect to RWT system if enabled
    if (wallet->rwt_enabled) {
        wallet->rwt_client = connect_to_rwt(config ? config->rwt_endpoint : NULL);
    }
    
    // Initialize token types
    wallet->dragoncoin_balance = 0.0;
    wallet->dragonbreath_balance = 0.0;
    wallet->external_balances = create_balance_map();
    
    return wallet;
}

// Create new user identity
user_identity_t* dragon_wallet_create_identity(DragonWallet* wallet, 
                                           identity_params_t* params) {
    // Create identity with specified parameters
    user_identity_t* identity = create_user_identity(params->username);
    
    // Set additional parameters if provided
    if (params->email) {
        set_identity_email(identity, params->email);
    }
    
    // Store identity in wallet
    store_identity(wallet->storage, identity);
    
    // Initialize identity verification if requested
    if (params->start_verification) {
        start_identity_verification(wallet, identity);
    }
    
    return identity;
}

// Create new transaction
transaction_t* dragon_wallet_create_transaction(DragonWallet* wallet,
                                            user_identity_t* recipient,
                                            token_type_t token_type,
                                            double amount,
                                            char* description) {
    // Validate wallet state
    if (!validate_wallet_state(wallet)) {
        return NULL;
    }
    
    // Check sufficient balance
    if (!has_sufficient_balance(wallet, token_type, amount)) {
        return NULL;
    }
    
    // Create transaction
    transaction_t* transaction = create_transaction(
        wallet, recipient, token_type, amount, description);
    
    // Record pending transaction
    record_pending_transaction(wallet, transaction);
    
    return transaction;
}

// Execute transaction
transaction_result_t* dragon_wallet_execute_transaction(DragonWallet* wallet,
                                                    transaction_t* transaction) {
    // Validate transaction
    if (!validate_transaction(transaction)) {
        transaction_result_t* result = create_error_result(
            transaction->id, TX_ERROR_INVALID_TRANSACTION);
        return result;
    }
    
    // Choose processing method based on configuration
    if (wallet->rwt_enabled) {
        // Process via RWT
        processing_options_t options = {
            .use_rwt = true,
            .rwt_client = wallet->rwt_client,
            .confirm_timeout = wallet->confirm_timeout,
            .retry_count = wallet->retry_count
        };
        
        return process_transaction(transaction, &options);
    } else {
        // Process via HTTP fallback
        processing_options_t options = {
            .use_rwt = false,
            .http_endpoint = wallet->http_endpoint,
            .confirm_timeout = wallet->confirm_timeout,
            .retry_count = wallet->retry_count
        };
        
        return process_transaction(transaction, &options);
    }
}

// Initialize RWT connection for wallet
rwt_client_t* connect_to_rwt(const char* endpoint) {
    // Use default endpoint if not specified
    const char* rwt_endpoint = endpoint ? endpoint : DEFAULT_RWT_ENDPOINT;
    
    // Create RWT client configuration
    rwt_config_t config = {
        .endpoint = rwt_endpoint,
        .protocol_version = RWT_PROTOCOL_VERSION,
        .connection_timeout = 30000,  // 30 seconds
        .auto_reconnect = true,
        .ping_interval = 15000        // 15 seconds
    };
    
    // Initialize RWT client
    rwt_client_t* client = rwt_client_init(&config);
    
    // Set up token rotation handler
    rwt_set_token_rotation_handler(client, handle_token_rotation);
    
    // Configure secure channels
    rwt_channel_config_t wallet_channel = {
        .name = "wallet",
        .encryption_level = ENCRYPTION_HIGH,
        .priority = PRIORITY_HIGH
    };
    
    rwt_channel_config_t identity_channel = {
        .name = "identity",
        .encryption_level = ENCRYPTION_HIGH,
        .priority = PRIORITY_HIGH
    };
    
    // Register channels
    rwt_register_channel(client, &wallet_channel);
    rwt_register_channel(client, &identity_channel);
    
    return client;
}

// Process transaction via RWT
rwt_result_t* execute_rwt_transaction(rwt_transaction_context_t* context) {
    rwt_result_t* result = (rwt_result_t*)malloc(sizeof(rwt_result_t));
    result->success = false;
    
    // Create transaction message
    rwt_message_t* tx_message = create_transaction_message(context->transaction);
    
    // Send transaction through wallet channel
    rwt_response_t* response = rwt_send_and_wait(
        context->rwt_client,
        "wallet",
        tx_message,
        context->options->confirm_timeout);
    
    // Check for communication errors
    if (!response) {
        result->error_code = RWT_ERROR_COMMUNICATION;
        return result;
    }
    
    // Parse response
    if (response->status == RWT_STATUS_SUCCESS) {
        // Transaction successful
        result->success = true;
        result->response_data = response->data;
        result->response_size = response->data_size;
    } else {
        // Transaction failed
        result->success = false;
        result->error_code = extract_error_code(response);
    }
    
    // Free response
    rwt_free_response(response);
    
    return result;
}

// Implement secure storage for wallet data
void implement_secure_storage(DragonWallet* wallet) {
    // Platform-specific secure storage implementation
    #if defined(__ANDROID__)
        // Use Android Keystore for secure storage
        wallet->secure_storage = init_android_keystore_storage();
    #elif defined(__APPLE__)
        // Use iOS Keychain for secure storage
        wallet->secure_storage = init_ios_keychain_storage();
    #else
        // Use platform-specific or fallback secure storage
        wallet->secure_storage = init_platform_secure_storage();
    #endif
    
    // Configure secure storage parameters
    secure_storage_params_t params = {
        .encryption_algorithm = ENCRYPTION_AES_256_GCM,
        .key_derivation = KEY_DERIVATION_PBKDF2,
        .key_rotation_interval = 86400 * 30,  // 30 days
        .auto_backup = true
    };
    
    // Initialize secure storage with parameters
    configure_secure_storage(wallet->secure_storage, ¶ms);
    
    // Test secure storage
    if (!test_secure_storage(wallet->secure_storage)) {
        // Fall back to safer alternative if secure storage is unavailable
        wallet->secure_storage = init_fallback_secure_storage();
    }
}

// Integrate Dragon Wallets with DragonXOS
void integrate_with_dragonxos(DragonWallet* wallet, DragonXOS* xos) {
    // Register wallet as identity provider for XOS
    xos_identity_provider_t provider = {
        .name = "DragonWallet",
        .priority = PRIORITY_HIGH,
        .authenticate = wallet_authenticate_for_xos,
        .verify_identity = wallet_verify_for_xos,
        .check_permissions = wallet_check_permissions_for_xos,
        .context = wallet
    };
    
    // Register provider with XOS
    register_identity_provider(xos, &provider);
    
    // Set up transaction handling
    xos_transaction_handler_t tx_handler = {
        .name = "DragonWallet",
        .process_transaction = wallet_process_transaction_for_xos,
        .verify_transaction = wallet_verify_transaction_for_xos,
        .context = wallet
    };
    
    // Register transaction handler
    register_transaction_handler(xos, &tx_handler);
    
    // Initialize shared components
    init_shared_components(wallet, xos);
}

// Integrate Dragon Wallets with RWT Protocol
void integrate_with_rwt(DragonWallet* wallet, RWTSystem* rwt) {
    // Configure RWT channels for wallet
    rwt_channel_config_t wallet_channel = {
        .name = "dragon-wallet",
        .encryption_level = ENCRYPTION_HIGHEST,
        .auth_required = true,
        .message_handler = handle_wallet_messages,
        .context = wallet
    };
    
    // Register wallet channel
    rwt_register_channel(rwt, &wallet_channel);
    
    // Set up authentication handler
    rwt_auth_handler_t auth_handler = {
        .authenticate = wallet_authenticate_for_rwt,
        .generate_token = wallet_generate_token_for_rwt,
        .verify_token = wallet_verify_token_for_rwt,
        .context = wallet
    };
    
    // Register authentication handler
    rwt_register_auth_handler(rwt, &auth_handler);
    
    // Initialize rotation key synchronization
    init_rotation_key_sync(wallet, rwt);
}

// Integrate Dragon Wallets with DragonFire Kernel
void integrate_with_dragonfire_kernel(DragonWallet* wallet, DragonFireKernel* kernel) {
    // Register wallet operations with kernel
    kernel_operation_set_t ops = {
        .category = OPERATION_FINANCIAL,
        .operations = {
            {
                .opcode = OPCODE_WALLET_AUTHENTICATE,
                .handler = wallet_authenticate_kernel_handler,
                .context = wallet
            },
            {
                .opcode = OPCODE_WALLET_TRANSFER,
                .handler = wallet_transfer_kernel_handler,
                .context = wallet
            },
            {
                .opcode = OPCODE_WALLET_VERIFY,
                .handler = wallet_verify_kernel_handler,
                .context = wallet
            }
        },
        .operation_count = 3
    };
    
    // Register operations with kernel
    register_kernel_operations(kernel, &ops);
    
    // Set up secure communication channel
    setup_secure_kernel_channel(wallet, kernel);
}

#include "dragon_wallet.h"

int main() {
    // Initialize wallet with default configuration
    DragonWallet* wallet = dragon_wallet_init(NULL);
    
    printf("Initialized Dragon Wallet\n");
    
    // Create identity parameters
    identity_params_t identity_params = {
        .username = "example_user",
        .email = "user@example.com",
        .start_verification = true
    };
    
    // Create new identity
    user_identity_t* identity = dragon_wallet_create_identity(
        wallet, &identity_params);
    
    printf("Created identity for user: %s\n", identity->username);
    printf("Identity ID: %s\n", uuid_to_string(identity->id));
    
    // Check wallet balance
    wallet_balance_t* dc_balance = dragon_wallet_get_balance(
        wallet, TOKEN_DRAGONCOIN);
    
    printf("DragonCoin balance: %.2f\n", dc_balance->amount);
    
    // Create recipient identity (normally retrieved from a directory)
    user_identity_t* recipient = create_sample_recipient();
    
    // Create transaction
    transaction_t* transaction = dragon_wallet_create_transaction(
        wallet, recipient, TOKEN_DRAGONCOIN, 10.0, "Test transaction");
    
    if (transaction) {
        printf("Created transaction with ID: %s\n", uuid_to_string(transaction->id));
        
        // Execute transaction
        transaction_result_t* result = dragon_wallet_execute_transaction(
            wallet, transaction);
        
        if (result->success) {
            printf("Transaction completed successfully\n");
            printf("Confirmation code: %s\n", result->confirmation_code);
        } else {
            printf("Transaction failed: %s\n", get_error_message(result->error_code));
        }
        
        // Free result
        free_transaction_result(result);
    } else {
        printf("Failed to create transaction\n");
    }
    
    // Clean up resources
    free_wallet_balance(dc_balance);
    free_user_identity(recipient);
    dragon_wallet_free(wallet);
    
    return 0;
}

// Demonstrate identity authentication process
void demonstrate_authentication() {
    // Initialize wallet
    DragonWallet* wallet = dragon_wallet_init(NULL);
    
    printf("Initialized Dragon Wallet for authentication demo\n");
    
    // Load existing identity (or create new one if needed)
    user_identity_t* identity = load_or_create_identity(wallet);
    
    printf("Loaded identity: %s\n", identity->username);
    
    // Create RWT authentication parameters
    rwt_auth_params_t auth_params = {
        .client_id = "example_client",
        .auth_scope = "transactions identity",
        .challenge_type = CHALLENGE_STANDARD,
        .rotation_window = 300  // 5 minutes rotation window
    };
    
    // Generate RWT token for authentication
    rwt_token_t* token = generate_rwt_auth_token(wallet, identity, &auth_params);
    
    printf("Generated RWT authentication token\n");
    
    // Simulate sending token to server
    printf("Sending token to authentication server...\n");
    sleep(1);  // Simulate network delay
    
    // Simulate server-side authentication
    authentication_result_t* auth_result = simulate_server_authentication(token);
    
    // Check authentication result
    if (auth_result->success) {
        printf("Authentication successful!\n");
        printf("Authentication level: %s\n", 
               get_auth_level_string(auth_result->auth_level));
        printf("Session token received\n");
        
        // Use session token for subsequent operations
        use_session_token(wallet, auth_result->session_token);
    } else {
        printf("Authentication failed: %s\n", 
               get_auth_error_string(auth_result->error_code));
    }
    
    // Clean up resources
    free_rwt_token(token);
    free_authentication_result(auth_result);
    dragon_wallet_free(wallet);
}

// Demonstrate currency exchange functionality
void demonstrate_currency_exchange() {
    // Initialize wallet
    DragonWallet* wallet = dragon_wallet_init(NULL);
    
    printf("Initialized Dragon Wallet for currency exchange demo\n");
    
    // Initialize with some balance for demonstration
    initialize_demo_balance(wallet);
    
    // Print initial balances
    print_wallet_balances(wallet);
    
    // Exchange DragonCoin to Dragon Breath
    printf("\nExchanging 5.0 DragonCoin to Dragon Breath...\n");
    
    exchange_result_t* dc_to_db = dragon_wallet_exchange(
        wallet, TOKEN_DRAGONCOIN, 5.0, TOKEN_DRAGONBREATH, NULL);
    
    if (dc_to_db->success) {
        printf("Exchange successful!\n");
        printf("Received %.2f Dragon Breath at rate %.4f\n", 
               dc_to_db->target_amount, dc_to_db->rate);
        printf("Exchange fee: %.2f DragonCoin\n", dc_to_db->fee);
    } else {
        printf("Exchange failed: %s\n", 
               get_exchange_error_string(dc_to_db->error_code));
    }
    
    // Exchange Dragon Breath to USD (external)
    printf("\nExchanging 100.0 Dragon Breath to USD...\n");
    
    exchange_result_t* db_to_usd = dragon_wallet_exchange(
        wallet, TOKEN_DRAGONBREATH, 100.0, TOKEN_EXTERNAL, "USD");
    
    if (db_to_usd->success) {
        printf("Exchange successful!\n");
        printf("Received %.2f USD at rate %.4f\n", 
               db_to_usd->target_amount, db_to_usd->rate);
        printf("Exchange fee: %.2f Dragon Breath\n", db_to_usd->fee);
    } else {
        printf("Exchange failed: %s\n", 
               get_exchange_error_string(db_to_usd->error_code));
    }
    
    // Exchange USD to Bitcoin (external to external)
    printf("\nExchanging 10.0 USD to Bitcoin...\n");
    
    exchange_result_t* usd_to_btc = dragon_wallet_external_exchange(
        wallet, "USD", 10.0, "BTC");
    
    if (usd_to_btc->success) {
        printf("Exchange successful!\n");
        printf("Received %.8f BTC at rate %.2f\n", 
               usd_to_btc->target_amount, usd_to_btc->rate);
        printf("Exchange fee: %.2f USD\n", usd_to_btc->fee);
    } else {
        printf("Exchange failed: %s\n", 
               get_exchange_error_string(usd_to_btc->error_code));
    }
    
    // Print final balances
    printf("\nFinal balances after exchanges:\n");
    print_wallet_balances(wallet);
    
    // Clean up resources
    free_exchange_result(dc_to_db);
    free_exchange_result(db_to_usd);
    free_exchange_result(usd_to_btc);
    dragon_wallet_free(wallet);
}