The problem Airchainpay solves

AirChainPay addresses a critical gap in the cryptocurrency payment ecosystem by solving the fundamental problem of offline and limited-connectivity crypto payments.

The Core Problem
Traditional cryptocurrency payments require constant internet connectivity to:
Access blockchain networks
Sign and broadcast transactions
Verify payment confirmations
Check wallet balances

This creates significant barriers in real-world scenarios where:
Internet connectivity is unreliable or unavailable (remote areas, underground locations, disaster zones)

Network congestion causes high fees and slow confirmations
Privacy concerns with online transaction broadcasting
Cross-border payments face regulatory and infrastructure challenges

AirChainPay's Solution
AirChainPay creates a hybrid offline-online payment system that enables:

1. Offline Payment Capability
   Bluetooth Low Energy (BLE) peer-to-peer transfers between devices
   Offline transaction signing and queuing
   Secure local storage of pending transactions
   QR code-based payment initiation

2. Multi-Chain Interoperability
   Support for Core Testnet, Base Sepolia, Lisk Sepolia, and Morph Holesky
   Cross-chain compatibility through standardized smart contracts
   Token support for USDC, USDT, and native currencies

3. Security-First Architecture
   Rust-based wallet core for maximum security and memory safety
   Hardware-backed storage (iOS Keychain, Android Keystore)
   Zero memory exposure for private keys
   Encrypted BLE communication

4. Reliable Infrastructure
   High-performance Rust relay server for transaction processing
   Background task scheduling for offline transaction broadcasting
   Multi-level caching and data compression
   Comprehensive monitoring and health checks

Real-World Applications
This solution enables crypto payments in scenarios where traditional methods fail:
Retail environments with poor connectivity
Emergency situations where infrastructure is compromised
International travel with connectivity issues
Privacy-conscious transactions requiring offline signing
Disaster relief in areas with damaged infrastructure
Remote commerce in underserved regions

Key Innovation
AirChainPay's breakthrough is combining offline transaction capability with real blockchain integration, creating a seamless bridge between offline convenience and on-chain security. Users can initiate payments offline, queue them securely, and have them automatically broadcast when connectivity is restored.

This addresses the fundamental tension between cryptocurrency's digital nature and real-world payment scenarios where internet connectivity cannot be guaranteed.

Challenges I ran into

Major BLE Challenges & Solutions

1. Android BLE Advertising Limitations
   Problem: Android's BLE advertising is severely restricted - apps cannot advertise as peripherals in the background, and the advertising API is limited.

Evidence in Code:
// From BluetoothManager.ts
if (Platform.OS !== 'android') {
console.log('[BLE] Non-Android platform detected, using fallback advertising');
await this.startFallbackAdvertising(paymentData);
return { success: true };
}

Solution: Implemented a hybrid approach using tp-rn-ble-advertiser library with fallback mechanisms and retry logic.

Android Permission Hell
Problem: Android 12+ requires multiple Bluetooth permissions that are often denied or need manual settings intervention.
Evidence in Code:

// Complex permission handling with detailed feedback
const criticalPermissionStatus = await this.hasCriticalPermissions();
if (!criticalPermissionStatus.granted) {
const missingPermissions = criticalPermissionStatus.missing.map(perm => {
switch (perm) {
case PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN:
return 'Bluetooth Scan';
case PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT:
return 'Bluetooth Connect';
case PermissionsAndroid.PERMISSIONS.BLUETOOTH_ADVERTISE:
return 'Bluetooth Advertise';
default:
return perm;
}
});
}

Solution: Created comprehensive permission management with user-friendly error messages and settings redirects.

Rust BLE Implementation Challenges
Problem: The Rust wallet core couldn't implement full BLE functionality due to platform limitations.

Evidence in Code:
// From wallet-core/src/core/ble/mod.rs
#[cfg(target_os = "android")]
{
return Err(WalletError::ble("BLE functionality is not yet implemented for Android (JNI required for Adapter::new)".to_string()));
}

Solution: Moved BLE implementation to React Native layer while keeping cryptographic operations in Rust.

Advertising Retry Logic
Problem: BLE advertising often fails on first attempt due to timing or state issues.
Evidence in Code:

// Retry mechanism with exponential backoff
private async startAdvertisingWithRetry(advertisingMessage: string): Promise<void> {
const maxRetries = 3;
let lastError: Error | null = null;

for (let attempt = 1; attempt <= maxRetries; attempt++) {
try {
this.advertiser.startBroadcast(advertisingMessage);
await new Promise(resolve => setTimeout(resolve, 1000));
this.isAdvertising = true;
return;
} catch (error) {
if (attempt < maxRetries) {
await new Promise(resolve => setTimeout(resolve, 2000));
}
}
}
}

Solution: Implemented robust retry logic with proper error handling and state management.

Cross-Platform Compatibility
Problem: BLE behavior differs significantly between iOS and Android, requiring platform-specific implementations.

Evidence in Code:
// Platform-specific initialization
if (Platform.OS === 'android') {
console.log('[BLE] Initializing ReactNativeBleAdvertiser for Android...');
this.initializeBleAdvertiser();
}

Solution: Created platform-agnostic interfaces with platform-specific implementations and fallbacks.

State Management Complexity
Problem: BLE state changes are asynchronous and can cause race conditions.

Evidence in Code:
// State change listener with proper handling
this.stateSubscription = this.manager.onStateChange((state) => {
console.log('[BLE] State changed:', state);
if (state === State.PoweredOn) {
this.bleAvailable = true;
} else {
this.bleAvailable = false;
}
}, true);

Solution: Implemented proper state management with listeners and connection tracking.

Key Lessons Learned
Android BLE is fundamentally broken for app-to-app communication
Permission handling requires extensive user guidance
Retry logic is essential for BLE operations
Platform-specific code is unavoidable for BLE
Graceful degradation is crucial when BLE fails
State management must handle asynchronous BLE events properly