fix(grpc): pre-connect channels on foreground and instrument grab timing

warmUp() was calling enterIdle() which tears down connections, causing
~1.5-3s cold connect on the first grab RPC. Changed to getState(true)
which triggers background TCP+TLS+HTTP/2 connection while idle.

Added timedTraceSuspend instrumentation to handleMultiMintScan to
identify per-step timing breakdown, channel state logging before
pollMessages, and post-grab token metadata timing.

Author: bmc08gt

services/opencode/src/main/kotlin/com/getcode/opencode/internal/network/api/MessagingApi.kt

@@ -9,6 +9,7 @@ import com.getcode.opencode.internal.annotations.OpenCodeManagedChannel
 import com.getcode.opencode.internal.network.core.GrpcApi
 import com.getcode.opencode.internal.network.extensions.asRendezvousKey
 import com.getcode.opencode.internal.network.extensions.sign
+import com.getcode.utils.trace
 import com.google.protobuf.ByteString
 import io.grpc.ManagedChannel
 import kotlinx.coroutines.Dispatchers
@@ -117,6 +118,9 @@ internal class MessagingApi @Inject constructor(
     suspend fun pollMessages(
         rendezvous: KeyPair
     ): MessagingService.PollMessagesResponse {
+        val channelState = managedChannels.first().getState(false)
+        trace(tag = "gRPC", message = "pollMessages channel state: $channelState")
+
         val request = MessagingService.PollMessagesRequest.newBuilder()
             .setRendezvousKey(rendezvous.asRendezvousKey())
             .apply { setSignature(sign(rendezvous)) }

services/opencode/src/main/kotlin/com/getcode/opencode/internal/network/core/GrpcApi.kt

@@ -20,6 +20,8 @@ abstract class GrpcApi(protected val managedChannels: List<ManagedChannel>): Def
     }
 
     private fun warmUp() {
-        managedChannels.onEach { it.enterIdle() }
+        // getState(true) requests a connection attempt if idle,
+        // pre-connecting TCP + TLS + HTTP/2 in the background
+        managedChannels.onEach { it.getState(true) }
     }
 }

services/opencode/src/main/kotlin/com/getcode/opencode/internal/transactors/GrabBillTransactor.kt

@@ -12,6 +12,7 @@ import com.getcode.opencode.model.transactions.TransactionMetadata
 import com.getcode.opencode.providers.TokenMetadataProvider
 import com.getcode.utils.CodeServerError
 import com.getcode.utils.NotifiableError
+import com.getcode.utils.timedTraceSuspend
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.cancel
 
@@ -100,35 +101,54 @@ internal class GrabBillTransactor(
     private suspend fun handleMultiMintScan(
         ownerKey: AccountCluster,
         data: OpenCodePayload
-    ): Result<TransactionMetadata.SendPublicPayment> {
+    ): Result<TransactionMetadata.SendPublicPayment> = timedTraceSuspend(
+        message = "handleMultiMintScan",
+        tag = tag,
+    ) { onStep ->
         // 1. Wait for the give request from the sender so we can determine what mint we are operating on
         val (messageId, giveRequestMint, exchangeData, mintMetadata) = messagingController.pollForGiveRequest(data.rendezvous)
             .getOrNull()
-            ?: return logAndFail(GrabTransactorError.Other(message = "No give request found for rendezvous"))
+            ?: run {
+                onStep("pollForGiveRequest")
+                return@timedTraceSuspend logAndFail(GrabTransactorError.Other(message = "No give request found for rendezvous"))
+            }
+        onStep("pollForGiveRequest")
 
         // 2. Utilize the mint from the give request to get the Token metadata
         val token = mintMetadata
             ?: (tokenProvider.getTokenMetadata(giveRequestMint)
                 .getOrNull()?.token
-                ?: return logAndFail(GrabTransactorError.Other(message = "No token found for proposed mint")))
+                ?: run {
+                    onStep("tokenMetadata")
+                    return@timedTraceSuspend logAndFail(GrabTransactorError.Other(message = "No token found for proposed mint"))
+                })
+        onStep("tokenMetadata")
 
         val tokenizedCluster = ownerKey.withTimelockForToken(token)
 
         // 3. create an account if we don't currently have one for this token
-        if (!accountController.hasAccountFor(token.address)) {
+        val needsAccount = !accountController.hasAccountFor(token.address)
+        if (needsAccount) {
             accountController.createUserAccount(
                 ownerForMint = tokenizedCluster,
                 mint = token.address
-            ).onFailure { return handleGrabError(it) }
+            ).onFailure {
+                onStep("createUserAccount (needed=true)")
+                return@timedTraceSuspend handleGrabError(it)
+            }
         }
+        onStep("createUserAccount (needed=$needsAccount)")
 
         // 4. Send grab request and wait for confirmation
-        return requestGrab<TransactionMetadata.SendPublicPayment>(tokenizedCluster, data)
+        val result = requestGrab<TransactionMetadata.SendPublicPayment>(tokenizedCluster, data)
             .map { it.copy(verifiedExchangeData = exchangeData) }
             .onSuccess {
                 // 5. Ack the receipt of the give request to clear it from the stream
                 messagingController.ackMessages(data.rendezvous, listOf(messageId))
             }
+        onStep("requestGrab+ack")
+
+        result
     }
 
     private fun handleGrabError(error: Throwable): Result<Nothing> {

services/opencode/src/main/kotlin/com/getcode/opencode/managers/BillTransactionManager.kt

@@ -21,6 +21,7 @@ import com.getcode.opencode.model.financial.LocalFiat
 import com.getcode.opencode.model.financial.Token
 import com.getcode.opencode.providers.TokenMetadataProvider
 import com.getcode.utils.ErrorUtils
+import com.getcode.utils.timedTraceSuspend
 import com.getcode.utils.trace
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -170,7 +171,10 @@ class BillTransactionManager @Inject constructor(
                     val mint = metadata.exchangeData.mint
                     val amount = LocalFiat(metadata.exchangeData)
 
-                    val token = tokenProvider.getTokenMetadata(mint).getOrNull()?.token
+                    val token = timedTraceSuspend(
+                        message = "post-grab tokenMetadata fetch",
+                        tag = "Bill",
+                    ) { tokenProvider.getTokenMetadata(mint).getOrNull()?.token }
                     if (token == null) {
                         onError(IllegalStateException("No metadata found for token $mint"))
                         return@onSuccess