fat(flipcash): update account service to allow get account with filtering

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

Author: bmc08gt

apps/flipcash/shared/payments/src/main/kotlin/com/flipcash/app/payments/internal/InternalPoolResolveDelegate.kt

@@ -16,6 +16,7 @@ import com.getcode.opencode.controllers.AccountController
 import com.getcode.opencode.controllers.TransactionController
 import com.getcode.opencode.exchange.Exchange
 import com.getcode.opencode.model.accounts.AccountCluster
+import com.getcode.opencode.model.accounts.AccountFilter
 import com.getcode.opencode.model.accounts.AccountType
 import com.getcode.opencode.model.core.ID
 import com.getcode.opencode.model.core.RandomId
@@ -97,12 +98,7 @@ class InternalPoolResolveDelegate @Inject constructor(
         val poolBalance = accountController.getAccount(
             accountOwner = owner,
             requestingOwner = owner,
-            predicate = { account ->
-                val indexMatch = account.index.toLong() == pool.derivationIndex
-                val addressMatch = account.address == pool.fundingDestination
-                val isPool = account.accountType == AccountType.Pool
-                indexMatch && addressMatch && isPool
-            },
+            filter = AccountFilter.TokenAddress(pool.fundingDestination),
         ).getOrNull()?.balance
 
         if (poolBalance == null) {

apps/flipcash/shared/pools/src/main/kotlin/com/flipcash/app/pools/PoolsCoordinator.kt

@@ -24,6 +24,7 @@ import com.flipcash.services.models.QueryOptions
 import com.flipcash.services.user.UserManager
 import com.getcode.ed25519.Ed25519.KeyPair
 import com.getcode.opencode.controllers.AccountController
+import com.getcode.opencode.model.accounts.AccountFilter
 import com.getcode.opencode.model.accounts.AccountInfo
 import com.getcode.opencode.model.accounts.AccountType
 import com.getcode.opencode.model.core.ID
@@ -137,12 +138,7 @@ class PoolsCoordinator @Inject constructor(
         return accountController.getAccount(
             accountOwner = owner,
             requestingOwner = owner,
-            predicate = { account ->
-                val indexMatch = account.index.toLong() == pool.derivationIndex
-                val addressMatch = account.address == pool.fundingDestination
-                val isPool = account.accountType == AccountType.Pool
-                indexMatch && addressMatch && isPool
-            }
+            filter = AccountFilter.TokenAddress(pool.fundingDestination)
         ).map {
             it.balance == Fiat.Zero
         }.onFailure {
@@ -177,13 +173,20 @@ class PoolsCoordinator @Inject constructor(
         resolution: PoolResolution.DecisionMade,
         rendezvous: KeyPair
     ): Result<Unit> {
-        return controller.resolvePool(
-            pool = domainToNetworkMapper.map(pool),
-            rendezvous = rendezvous,
-            resolution = PoolResolutionConverter.toPoolResolution(resolution as PoolResolution),
-        ).onSuccess {
-            dataSource.resolvePool(pool.id, resolution)
-        }
+        // ensure we are working with an up-to-date instance of a pool
+        return controller.getPool(pool.id)
+            .fold(
+                onSuccess = {
+                    controller.resolvePool(
+                        pool = domainToNetworkMapper.map(pool),
+                        rendezvous = rendezvous,
+                        resolution = PoolResolutionConverter.toPoolResolution(resolution as PoolResolution),
+                    )
+                },
+                onFailure = { Result.failure(it) }
+            ).onSuccess {
+                dataSource.resolvePool(pool.id, resolution)
+            }
     }
 
     suspend fun placeBet(

definitions/opencode/protos/src/main/proto/account/v1/account_service.proto

@@ -71,6 +71,12 @@ message GetTokenAccountInfosRequest {
     //
     // This must be set when requesting_owner is present.
     common.v1.Signature requesting_owner_signature = 4;
+
+    // Filter to apply to limit response sizes
+    oneof Filter {
+        common.v1.SolanaAccountId filter_by_token_address = 10;
+        common.v1.AccountType     filter_by_account_type  = 11;
+    }
 }
 
 message GetTokenAccountInfosResponse {

definitions/opencode/protos/src/main/proto/transaction/v2/transaction_service.proto

@@ -347,7 +347,7 @@ message ReceivePaymentsPubliclyMetadata {
 //
 // for distribution in distributions[:len(distributions)-1]
 //   actions.push_back(NoPrivacyTransferAction(POOL, distribution.destination, distributions.quarks))
-// actions.push_back(NoPrivacyWithdrawAction(POOL, distributions[:len(distributions)-1].destination, distributions[:len(distributions)-1].quarks))
+// actions.push_back(NoPrivacyWithdrawAction(POOL, distributions[len(distributions)-1].destination, distributions[len(distributions)-1].quarks))
 //
 // Notes:
 //  - All funds must distributed. The balance of the pool must be zero at the end of the intent

services/opencode/src/main/kotlin/com/getcode/opencode/controllers/AccountController.kt

@@ -4,6 +4,7 @@ import com.getcode.crypt.MnemonicPhrase
 import com.getcode.ed25519.Ed25519
 import com.getcode.opencode.internal.network.api.intents.IntentCreateAccount
 import com.getcode.opencode.model.accounts.AccountCluster
+import com.getcode.opencode.model.accounts.AccountFilter
 import com.getcode.opencode.model.accounts.AccountInfo
 import com.getcode.opencode.model.accounts.AccountResponse
 import com.getcode.opencode.model.accounts.PoolAccount
@@ -55,19 +56,12 @@ class AccountController @Inject constructor(
     suspend fun getAccount(
         accountOwner: AccountCluster,
         requestingOwner: AccountCluster,
-        predicate: (AccountInfo) -> Boolean,
+        filter: AccountFilter,
     ): Result<AccountInfo> {
-        return getAccounts(
-            accountOwner = accountOwner,
-            requestingOwner = requestingOwner,
-        ).map {
-            it.accounts.values.find(predicate)
-        }.fold(
-            onSuccess = {
-                if (it != null) Result.success(it)
-                else Result.failure(NoSuchElementException())
-            },
-            onFailure = { Result.failure(it) }
+        return accountRepository.getAccount(
+            accountOwner = accountOwner.authority.keyPair,
+            requestingOwner = requestingOwner.authority.keyPair,
+            filter = filter,
         )
     }
 }

services/opencode/src/main/kotlin/com/getcode/opencode/controllers/BalanceController.kt

@@ -137,6 +137,7 @@ class BalanceController @Inject constructor(
                 type = TraceType.Process
             )
 
+            // TODO: segment this to have balance utilize getAccount(filter: Primary) and timelock check and nextPoolIndex to be handled separately
             retryable(
                 maxRetries = 3,
                 call = suspend { accountController.getAccounts(owner, owner) }

services/opencode/src/main/kotlin/com/getcode/opencode/internal/domain/repositories/InternalAccountRepository.kt

@@ -2,6 +2,8 @@ package com.getcode.opencode.internal.domain.repositories
 
 import com.getcode.ed25519.Ed25519
 import com.getcode.opencode.internal.network.services.AccountService
+import com.getcode.opencode.model.accounts.AccountFilter
+import com.getcode.opencode.model.accounts.AccountInfo
 import com.getcode.opencode.model.accounts.AccountResponse
 import com.getcode.opencode.repositories.AccountRepository
 import javax.inject.Inject
@@ -17,4 +19,21 @@ internal class InternalAccountRepository @Inject constructor(
         accountOwner: Ed25519.KeyPair,
         requestingOwner: Ed25519.KeyPair,
     ): Result<AccountResponse> = service.getAccounts(accountOwner, requestingOwner)
+
+    override suspend fun getAccount(
+        accountOwner: Ed25519.KeyPair,
+        requestingOwner: Ed25519.KeyPair,
+        filter: AccountFilter,
+    ): Result<AccountInfo> = service.getAccounts(accountOwner, requestingOwner, filter)
+        .map { response -> response.accounts.values.firstOrNull() }
+        .fold(
+            onSuccess = {
+                if (it != null) {
+                    Result.success(it)
+                } else {
+                    Result.failure(Exception("Account not found"))
+                }
+            },
+            onFailure = { Result.failure(it) }
+        )
 }

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

@@ -7,6 +7,7 @@ import com.getcode.opencode.internal.annotations.OpenCodeManagedChannel
 import com.getcode.opencode.internal.network.core.GrpcApi
 import com.getcode.opencode.internal.network.extensions.asSolanaAccountId
 import com.getcode.opencode.internal.network.extensions.sign
+import com.getcode.opencode.model.accounts.AccountFilter
 import io.grpc.ManagedChannel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
@@ -54,16 +55,29 @@ internal class AccountApi @Inject constructor(
      *   metadata that is considered private will be provided, if applicable. An example
      *   use case includes a user owner account requesting account info for a gift card
      *   owner account.
-     *
+     * @param filter Filter to apply to limit response sizes
      * @return The [AccountService.GetTokenAccountInfosResponse] for the owner account.
      */
     suspend fun getTokenAccounts(
         accountOwner: KeyPair,
         requestingOwner: KeyPair,
+        filter: AccountFilter? = null,
     ): AccountService.GetTokenAccountInfosResponse {
         val request = AccountService.GetTokenAccountInfosRequest.newBuilder()
             .setOwner(accountOwner.asSolanaAccountId())
             .setRequestingOwner(requestingOwner.asSolanaAccountId())
+            .apply {
+                if (filter != null) {
+                    when (filter) {
+                        is AccountFilter.AccountType -> {
+                            setFilterByAccountType(filter.accountType.getAccountType())
+                        }
+                        is AccountFilter.TokenAddress -> {
+                            setFilterByTokenAddress(filter.tokenAddress.asSolanaAccountId())
+                        }
+                    }
+                }
+            }
             .apply {
                 val ownerSig = sign(accountOwner)
                 val requestingOwnerSig = sign(requestingOwner)

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

@@ -4,6 +4,7 @@ import com.codeinc.opencode.gen.account.v1.AccountService
 import com.getcode.ed25519.Ed25519.KeyPair
 import com.getcode.opencode.internal.network.api.AccountApi
 import com.getcode.opencode.internal.network.extensions.foldWithSuppression
+import com.getcode.opencode.model.accounts.AccountFilter
 import com.getcode.opencode.model.accounts.AccountInfo
 import com.getcode.opencode.model.accounts.AccountResponse
 import com.getcode.opencode.model.core.errors.CodeAccountCheckError
@@ -39,9 +40,10 @@ internal class AccountService @Inject constructor(
     suspend fun getAccounts(
         accountOwner: KeyPair,
         requestingOwner: KeyPair,
+        filter: AccountFilter? = null,
     ): Result<AccountResponse> {
         return runCatching {
-            api.getTokenAccounts(accountOwner, requestingOwner)
+            api.getTokenAccounts(accountOwner, requestingOwner, filter)
         }.foldWithSuppression(
             onSuccess = { response ->
                 when (response.result) {

services/opencode/src/main/kotlin/com/getcode/opencode/model/accounts/AccountFilter.kt

@@ -0,0 +1,8 @@
+package com.getcode.opencode.model.accounts
+
+import com.getcode.solana.keys.PublicKey
+
+sealed interface AccountFilter {
+    data class TokenAddress(val tokenAddress: PublicKey) : AccountFilter
+    data class AccountType(val accountType: com.getcode.opencode.model.accounts.AccountType) : AccountFilter
+}