chore(flipcash/transactions): add processing tracing to claiming cash links

Signed-off-by: Brandon McAnsh <git@bmcreations.dev>

Author: bmc08gt

libs/logging/src/main/kotlin/com/getcode/utils/Logging.kt

@@ -7,6 +7,7 @@ import com.google.firebase.crashlytics.CustomKeysAndValues
 import com.google.firebase.crashlytics.FirebaseCrashlytics
 import timber.log.Timber
 import kotlin.time.Duration
+import kotlin.time.TimeSource
 import kotlin.time.measureTime
 
 sealed interface TraceType {
@@ -153,19 +154,33 @@ suspend fun <T> timedTraceSuspend(
     metadata: MetadataBuilder.() -> Unit = {},
     error: Throwable? = null,
     onComplete: (T, Duration) -> Unit = { _, _ -> },
-    block: suspend () -> T
+    block: suspend (onStep: (String) -> Unit) -> T
 ): T {
     var result: T
+    val breadcrumbs = mutableMapOf<String, Duration>()
+    val clock = TimeSource.Monotonic // Use monotonic clock for precise timing
+    val startMark = clock.markNow() // Mark the start of the operation
+    var previousMark = startMark
+
     val time = measureTime {
-        result = block()
+        result = block {stepName ->
+            val currentMark = clock.markNow()
+            val stepDuration = currentMark - previousMark
+            breadcrumbs[stepName] = stepDuration
+            previousMark = currentMark
+        }
     }
 
     val timedMetadata: MetadataBuilder.() -> Unit = {
         // Add the original metadata
         metadata()
-        "duration" to time.inWholeMilliseconds
+        breadcrumbs.entries.onEach {
+            it.key to it.value.inWholeMilliseconds
+        }
+        "total duration" to time.inWholeMilliseconds
     }
 
+    println("metadata=${ metadata { timedMetadata() }}")
     trace(message = message, tag = tag, type = type, metadata = timedMetadata, error = error)
     onComplete(result, time)
     return result

services/opencode/src/main/kotlin/com/getcode/opencode/internal/bidi/OpenStream.kt

@@ -22,7 +22,7 @@ suspend fun <Request, Response, StreamRef : BidirectionalStreamReference<*, *>,
     reconnectOnDeadlineExceeded: Boolean = false,
     reconnectOnCancelled: Boolean = false,
     reconnectHandler: (() -> Unit)? = null,
-    responseHandler: suspend (Response, (ResultType) -> Unit, (Request) -> Unit) -> Unit
+    responseHandler: suspend (response: Response, onResult: (ResultType) -> Unit, requestChannel: (Request) -> Unit) -> Unit
 ): ResultType {
     return suspendCancellableCoroutine { cont ->
         try {

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

@@ -241,7 +241,6 @@ internal class TransactionService @Inject constructor(
                 }
 
                 SubmitIntentResponse.ResponseCase.RESPONSE_NOT_SET -> Unit
-                else -> Unit
             }
         }
     )

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

@@ -9,8 +9,11 @@ import com.getcode.opencode.model.accounts.AccountInfo
 import com.getcode.opencode.model.accounts.GiftCardAccount
 import com.getcode.opencode.model.financial.LocalFiat
 import com.getcode.opencode.model.transactions.TransactionMetadata
+import com.getcode.solana.keys.PublicKey
 import com.getcode.utils.CodeServerError
 import com.getcode.utils.ErrorUtils
+import com.getcode.utils.timedTrace
+import com.getcode.utils.timedTraceSuspend
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.cancel
 
@@ -37,45 +40,60 @@ internal class ReceiveGiftCardTransactor(
             )
         )
 
+        return timedTraceSuspend("Gift card claim processing") { onStep ->
+
         // before we can receive the gift card
         // we need to determine the balance of it
         val accounts = accountController.getAccounts(
             accountOwner = giftCard.cluster,
             requestingOwner = ownerKey
-        ).getOrElse { return logAndFail(ReceiveGiftTransactorError.FailedToQuery()) }
-            .takeIf { it.isNotEmpty() }
-            ?: return logAndFail(ReceiveGiftTransactorError.FailedToQuery())
+        ).getOrElse {
+            onStep("account query")
+            return@timedTraceSuspend logAndFail(ReceiveGiftTransactorError.FailedToQuery())
+        }.takeIf { it.isNotEmpty() }
+            ?: run {
+                onStep("account query")
+                return@timedTraceSuspend  logAndFail(ReceiveGiftTransactorError.FailedToQuery())
+            }
 
-        val info = accounts.values.first()
+            onStep("account query")
+            val info = accounts.values.first()
 
-        if (info.claimState == AccountInfo.ClaimState.Claimed) {
-            return logAndFail(ReceiveGiftTransactorError.AlreadyClaimed())
-        }
+            if (info.claimState == AccountInfo.ClaimState.Claimed) {
+                onStep("pre-claim checks")
+                return@timedTraceSuspend logAndFail(ReceiveGiftTransactorError.AlreadyClaimed())
+            }
 
-        if (info.claimState == AccountInfo.ClaimState.Expired || info.claimState == AccountInfo.ClaimState.Unknown) {
-            return logAndFail(ReceiveGiftTransactorError.Expired())
-        }
+            if (info.claimState == AccountInfo.ClaimState.Expired || info.claimState == AccountInfo.ClaimState.Unknown) {
+                onStep("pre-claim checks")
+                return@timedTraceSuspend logAndFail(ReceiveGiftTransactorError.Expired())
+            }
 
-        if (info.isGiftCardIssuer && !claimIfOwned) {
-            return Result.failure(ReceiveGiftTransactorError.UsersGiftCard())
-        }
+            if (info.isGiftCardIssuer && !claimIfOwned) {
+                onStep("pre-claim checks")
+                return@timedTraceSuspend Result.failure(ReceiveGiftTransactorError.UsersGiftCard())
+            }
 
-        val exchangeData = info.originalExchangeData
-        val amount = LocalFiat(exchangeData)
+            val exchangeData = info.originalExchangeData
+            val amount = LocalFiat(exchangeData)
 
-        return transactionController.receiveRemotely(
-            giftCard = giftCard,
-            amount = amount,
-            owner = ownerKey
-        ).fold(
-            onSuccess = { Result.success(amount) },
-            onFailure = {
-                if (it !is ReceiveGiftTransactorError)  {
-                    ErrorUtils.handleError(it)
+            return@timedTraceSuspend transactionController.receiveRemotely(
+                giftCard = giftCard,
+                amount = amount,
+                owner = ownerKey
+            ).fold(
+                onSuccess = {
+                    onStep("intent")
+                    Result.success(amount) },
+                onFailure = {
+                    onStep("intent")
+                    if (it !is ReceiveGiftTransactorError) {
+                        ErrorUtils.handleError(it)
+                    }
+                    logAndFail(it)
                 }
-                logAndFail(it)
-            }
-        )
+            )
+        }
     }
 
     fun dispose() {