Device ID

import AsyncStorage from '@react-native-async-storage/async-storage';
import DeviceInfo from 'react-native-device-info';

class DeviceManager {
  static async getDeviceId() {
    try {
      let deviceId = await AsyncStorage.getItem('peere_device_id');

      if (!deviceId) {
        // Use device-specific identifier
        const uniqueId = await DeviceInfo.getUniqueId();
        deviceId = `device_${uniqueId}_${Date.now()}`;
        await AsyncStorage.setItem('peere_device_id', deviceId);
      }

      return deviceId;
    } catch (error) {
      console.error('Failed to get device ID:', error);
      return null;
    }
  }

  static async lookupCustomer() {
    const deviceId = await this.getDeviceId();

    if (!deviceId) return { found: false };

    try {
      const response = await fetch('https://api.peere.network/v1/customer/device/lookup', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${API_KEY}`
        },
        body: JSON.stringify({ deviceId })
      });

      const data = await response.json();
      return data.success ? { found: true, ...data.data } : { found: false };
    } catch (error) {
      console.error('Customer lookup failed:', error);
      return { found: false };
    }
  }
}

import 'package:shared_preferences/shared_preferences.dart';
import 'package:device_info_plus/device_info_plus.dart';
import 'package:http/http.dart' as http;
import 'dart:convert';

class DeviceManager {
static const String \_deviceIdKey = 'peere_device_id';

static Future<String?> getDeviceId() async {
final prefs = await SharedPreferences.getInstance();
String? deviceId = prefs.getString(\_deviceIdKey);

    if (deviceId == null) {
      final deviceInfo = DeviceInfoPlugin();
      String uniqueId;

      if (Platform.isAndroid) {
        final androidInfo = await deviceInfo.androidInfo;
        uniqueId = androidInfo.id;
      } else if (Platform.isIOS) {
        final iosInfo = await deviceInfo.iosInfo;
        uniqueId = iosInfo.identifierForVendor ?? '';
      } else {
        uniqueId = DateTime.now().millisecondsSinceEpoch.toString();
      }

      deviceId = 'device_${uniqueId}_${DateTime.now().millisecondsSinceEpoch}';
      await prefs.setString(_deviceIdKey, deviceId);
    }

    return deviceId;

}

static Future<Map<String, dynamic>> lookupCustomer() async {
final deviceId = await getDeviceId();

    if (deviceId == null) return {'found': false};

    try {
      final response = await http.post(
        Uri.parse('https://api.peere.network/v1/customer/device/lookup'),
        headers: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer $API_KEY',
        },
        body: jsonEncode({'deviceId': deviceId}),
      );

      final data = jsonDecode(response.body);
      return data['success'] ? {'found': true, ...data['data']} : {'found': false};
    } catch (error) {
      print('Customer lookup failed: $error');
      return {'found': false};
    }

}
}

curl -X POST "https://api.peere.network/v1/bank/customer/device/unlink" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "customerId": "customer_123",
    "phrase": "customer-phrase",
    "deviceId": "device_789"
  }'

class BatchDeviceProcessor {
  constructor() {
    this.queue = [];
    this.processing = false;
    this.batchSize = 10;
    this.batchTimeout = 1000; // 1 second
  }
  
  async lookupDevice(deviceId) {
    return new Promise((resolve, reject) => {
      this.queue.push({ deviceId, resolve, reject });
      this.processBatch();
    });
  }
  
  async processBatch() {
    if (this.processing || this.queue.length === 0) return;
    
    this.processing = true;
    
    setTimeout(async () => {
      const batch = this.queue.splice(0, this.batchSize);
      
      try {
        const deviceIds = batch.map(item => item.deviceId);
        const results = await this.batchLookup(deviceIds);
        
        batch.forEach((item, index) => {
          item.resolve(results[index]);
        });
      } catch (error) {
        batch.forEach(item => item.reject(error));
      }
      
      this.processing = false;
      
      if (this.queue.length > 0) {
        this.processBatch();
      }
    }, this.batchTimeout);
  }
}