@magicred-1/ble-mesh 1.3.7 → 1.3.8

package/android/src/main/java/com/blemesh/BleMeshModule.kt

@@ -87,6 +87,14 @@ class BleMeshModule(reactContext: ReactApplicationContext) : ReactContextBaseJav
         val chunks: MutableMap<Int, ByteArray> = mutableMapOf()
     )
 
+    // Transaction queuing for pending sessions
+    private val pendingTransactions = mutableMapOf<String, MutableList<PendingTransaction>>()
+    private data class PendingTransaction(
+        val txId: String,
+        val payload: ByteArray,
+        val maxPayloadSize: Int
+    )
+
     // Coroutines
     private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
 
@@ -482,7 +490,10 @@ class BleMeshModule(reactContext: ReactApplicationContext) : ReactContextBaseJav
                     if (sessions.containsKey(recipientPeerId)) {
                         sendTransactionToPeer(txId, payload, recipientPeerId, maxPayloadSize)
                     } else {
-                        // No session, initiate handshake first
+                        // No session, queue transaction and initiate handshake
+                        Log.d(TAG, "No session for $recipientPeerId, queuing transaction $txId and initiating handshake")
+                        val pending = PendingTransaction(txId, payload, maxPayloadSize)
+                        pendingTransactions.getOrPut(recipientPeerId) { mutableListOf() }.add(pending)
                         initiateHandshakeInternal(recipientPeerId)
                     }
                 } else {
@@ -513,6 +524,7 @@ class BleMeshModule(reactContext: ReactApplicationContext) : ReactContextBaseJav
         val encrypted = encryptPayload(encryptedPayload, recipientPeerId)
         
         if (encrypted != null) {
+            Log.d(TAG, "Sending transaction $txId to $recipientPeerId (encrypted size: ${encrypted.size}, max: $maxPayloadSize)")
             if (encrypted.size <= maxPayloadSize) {
                 // Small enough for single packet
                 val packet = createPacket(
@@ -521,11 +533,14 @@ class BleMeshModule(reactContext: ReactApplicationContext) : ReactContextBaseJav
                     recipientId = hexStringToByteArray(recipientPeerId)
                 )
                 broadcastPacket(packet)
+                Log.d(TAG, "✅ Sent encrypted transaction $txId as single packet")
             } else {
                 // Need to chunk large transaction
                 Log.d(TAG, "Transaction too large (${encrypted.size} bytes), using chunking")
                 sendChunkedTransaction(txId, encrypted, recipientPeerId)
             }
+        } else {
+            Log.e(TAG, "❌ Failed to encrypt transaction $txId - no session with $recipientPeerId")
         }
     }
 
@@ -1237,6 +1252,18 @@ class BleMeshModule(reactContext: ReactApplicationContext) : ReactContextBaseJav
                 peers[senderId] = peer.copy(noisePublicKey = packet.payload)
             }
 
+            // Send queued transactions for this peer
+            val queuedTransactions = pendingTransactions.remove(senderId)
+            if (!queuedTransactions.isNullOrEmpty()) {
+                Log.d(TAG, "Sending ${queuedTransactions.size} queued transaction(s) to $senderId")
+                scope.launch {
+                    queuedTransactions.forEach { pending ->
+                        sendTransactionToPeer(pending.txId, pending.payload, senderId, pending.maxPayloadSize)
+                        delay(50) // Small delay between transactions
+                    }
+                }
+            }
+
             // Send response handshake
             if (packet.recipientId == null || packet.recipientId.contentEquals(myPeerIdBytes)) {
                 Log.d(TAG, "Sending handshake response to $senderId")
@@ -1254,16 +1281,31 @@ class BleMeshModule(reactContext: ReactApplicationContext) : ReactContextBaseJav
     private fun handleNoiseEncrypted(packet: BitchatPacket, senderId: String) {
         // Check if message is for us
         if (packet.recipientId != null && !packet.recipientId.contentEquals(myPeerIdBytes)) {
+            Log.d(TAG, "Encrypted packet not for us")
             return
         }
 
-        val sessionKey = sessions[senderId] ?: return
-        val decrypted = decryptPayload(packet.payload, sessionKey) ?: return
+        val sessionKey = sessions[senderId]
+        if (sessionKey == null) {
+            Log.w(TAG, "❌ No session key for $senderId, cannot decrypt")
+            return
+        }
+        
+        val decrypted = decryptPayload(packet.payload, sessionKey)
+        if (decrypted == null) {
+            Log.e(TAG, "❌ Failed to decrypt payload from $senderId")
+            return
+        }
 
-        if (decrypted.isEmpty()) return
+        if (decrypted.isEmpty()) {
+            Log.w(TAG, "Empty decrypted payload from $senderId")
+            return
+        }
 
         val payloadType = NoisePayloadType.fromValue(decrypted[0])
         val payloadData = decrypted.copyOfRange(1, decrypted.size)
+        
+        Log.d(TAG, "📬 Decrypted message from $senderId, type: $payloadType, data size: ${payloadData.size}")
 
         when (payloadType) {
             NoisePayloadType.PRIVATE_MESSAGE -> handlePrivateMessage(payloadData, senderId)
@@ -1281,9 +1323,12 @@ class BleMeshModule(reactContext: ReactApplicationContext) : ReactContextBaseJav
                     putString("fromPeerId", senderId)
                 })
             }
-            NoisePayloadType.SOLANA_TRANSACTION -> handleSolanaTransaction(payloadData, senderId)
+            NoisePayloadType.SOLANA_TRANSACTION -> {
+                Log.d(TAG, "🔐 Processing encrypted Solana transaction")
+                handleSolanaTransaction(payloadData, senderId)
+            }
             NoisePayloadType.TRANSACTION_RESPONSE -> handleTransactionResponse(payloadData, senderId)
-            else -> {}
+            else -> Log.w(TAG, "Unknown payload type: $payloadType")
         }
     }
 
@@ -1330,6 +1375,7 @@ class BleMeshModule(reactContext: ReactApplicationContext) : ReactContextBaseJav
     }
 
     private fun handleSolanaTransaction(data: ByteArray, senderId: String) {
+        Log.d(TAG, "📨 Received Solana transaction from $senderId, data size: ${data.size}")
         // Parse TLV Solana transaction
         var txId: String? = null
         var serializedTransaction: String? = null
@@ -1351,16 +1397,31 @@ class BleMeshModule(reactContext: ReactApplicationContext) : ReactContextBaseJav
             offset += length
 
             when (tag.toInt()) {
-                0x01 -> txId = String(value, Charsets.UTF_8)
-                0x02 -> serializedTransaction = String(value, Charsets.UTF_8)
-                0x03 -> firstSignerPublicKey = String(value, Charsets.UTF_8)
-                0x04 -> secondSignerPublicKey = String(value, Charsets.UTF_8)
-                0x05 -> description = String(value, Charsets.UTF_8)
+                0x01 -> {
+                    txId = String(value, Charsets.UTF_8)
+                    Log.d(TAG, "  TX ID: $txId")
+                }
+                0x02 -> {
+                    serializedTransaction = String(value, Charsets.UTF_8)
+                    Log.d(TAG, "  Serialized TX size: ${value.size} bytes")
+                }
+                0x03 -> {
+                    firstSignerPublicKey = String(value, Charsets.UTF_8)
+                    Log.d(TAG, "  First signer: $firstSignerPublicKey")
+                }
+                0x04 -> {
+                    secondSignerPublicKey = String(value, Charsets.UTF_8)
+                    Log.d(TAG, "  Second signer: $secondSignerPublicKey")
+                }
+                0x05 -> {
+                    description = String(value, Charsets.UTF_8)
+                    Log.d(TAG, "  Description: $description")
+                }
             }
         }
 
         if (txId == null || serializedTransaction == null || firstSignerPublicKey == null) {
-            Log.e(TAG, "Invalid Solana transaction data")
+            Log.e(TAG, "❌ Invalid Solana transaction data (txId=$txId, tx=${serializedTransaction != null}, signer=${firstSignerPublicKey != null})")
             return
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magicred-1/ble-mesh",
-  "version": "1.3.7",
+  "version": "1.3.8",
   "description": "BLE Mesh networking library for React Native with seamless permissions",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",