Look at accepted transfer offers in sweep trigger

apps/wallet/src/main/scala/org/lfdecentralizedtrust/splice/wallet/automation/WalletTransferOfferSweepTrigger.scala

@@ -39,14 +39,16 @@ class WalletTransferOfferSweepTrigger(
       currentAmuletConfig: AmuletConfig[USD],
   )(implicit tc: TraceContext): scala.concurrent.Future[BigDecimal] = {
     for {
-      filteredTransferOffers <- store.getOutstandingTransferOffers(
-        None,
-        Some(config.receiver),
-      )
-    } yield filteredTransferOffers
-      .map(c => {
-        BigDecimal(ccToDollars(c.payload.amount.amount, amuletPrice)) + computeTransferFees(
-          BigDecimal(c.payload.amount.amount),
+      (filteredTransferOffers, filteredAcceptedTransferOffers) <- store
+        .getOutstandingTransferOffers(
+          None,
+          Some(config.receiver),
+        )
+    } yield (filteredTransferOffers.map(_.payload.amount.amount) ++ filteredAcceptedTransferOffers
+      .map(_.payload.amount.amount))
+      .map(amount => {
+        BigDecimal(ccToDollars(amount, amuletPrice)) + computeTransferFees(
+          BigDecimal(amount),
           currentAmuletConfig.transferConfig.transferFee,
         ) + computeCreateFees(currentAmuletConfig)
       })
@@ -64,12 +66,15 @@ class WalletTransferOfferSweepTrigger(
       amountToSendAfterFeesCC: java.math.BigDecimal,
   )(implicit tc: TraceContext): Future[Unit] = {
     for {
-      filteredTransferOffers <- store.getOutstandingTransferOffers(
-        None,
-        Some(config.receiver),
-      )
+      (filteredTransferOffers, acceptedFilteredTransferOffers) <- store
+        .getOutstandingTransferOffers(
+          None,
+          Some(config.receiver),
+        )
       transferOfferAlreadyExists = filteredTransferOffers.exists(
         _.payload.trackingId == task.trackingId
+      ) || acceptedFilteredTransferOffers.exists(
+        _.payload.trackingId == task.trackingId
       )
       install <- store.getInstall()
       _ <-

apps/wallet/src/main/scala/org/lfdecentralizedtrust/splice/wallet/store/UserWalletStore.scala

@@ -344,14 +344,25 @@ trait UserWalletStore extends TxLogAppStore[TxLogEntry] with TransferInputStore
   )(implicit
       tc: TraceContext,
       ec: ExecutionContext,
-  ): Future[Seq[AssignedContract[
-    transferOffersCodegen.TransferOffer.ContractId,
-    transferOffersCodegen.TransferOffer,
-  ]]] = {
+  ): Future[
+    (
+        Seq[AssignedContract[
+          transferOffersCodegen.TransferOffer.ContractId,
+          transferOffersCodegen.TransferOffer,
+        ]],
+        Seq[AssignedContract[
+          transferOffersCodegen.AcceptedTransferOffer.ContractId,
+          transferOffersCodegen.AcceptedTransferOffer,
+        ]],
+    )
+  ] = {
     for {
       transferOffers <- multiDomainAcsStore.listAssignedContracts(
         transferOffersCodegen.TransferOffer.COMPANION
       )
+      acceptedTransferOffers <- multiDomainAcsStore.listAssignedContracts(
+        transferOffersCodegen.AcceptedTransferOffer.COMPANION
+      )
     } yield {
       val offersFilteredFrom = fromParty match {
         case None => transferOffers
@@ -363,7 +374,18 @@ trait UserWalletStore extends TxLogAppStore[TxLogEntry] with TransferInputStore
         case Some(toParty) =>
           offersFilteredFrom.filter(_.payload.receiver == toParty.toProtoPrimitive)
       }
-      offersFilteredTo
+
+      val acceptedOffersFilteredFrom = fromParty match {
+        case None => acceptedTransferOffers
+        case Some(fromParty) =>
+          acceptedTransferOffers.filter(_.payload.sender == fromParty.toProtoPrimitive)
+      }
+      val acceptedOffersFilteredTo = toParty match {
+        case None => acceptedOffersFilteredFrom
+        case Some(toParty) =>
+          acceptedOffersFilteredFrom.filter(_.payload.receiver == toParty.toProtoPrimitive)
+      }
+      (offersFilteredTo, acceptedOffersFilteredTo)
     }
   }
 

apps/wallet/src/test/scala/org/lfdecentralizedtrust/splice/store/db/UserWalletStoreTest.scala

@@ -945,35 +945,51 @@ abstract class UserWalletStoreTest extends TransferInputStoreTest with HasExecut
     for {
       store <- mkStore(user1)
       offer1 = transferOffer(user1, user2, 10.0, paymentCodegen.Unit.AMULETUNIT, time(1))
+      acceptedOffer = acceptedTransferOffer(
+        user1,
+        user2,
+        10.0,
+        paymentCodegen.Unit.AMULETUNIT,
+        time(1),
+      )
       _ <- dummyDomain.create(offer1, createdEventSignatories = Seq(user1))(
         store.multiDomainAcsStore
       )
-      unfiltered <- store.getOutstandingTransferOffers(
+      _ <- dummyDomain.create(acceptedOffer, createdEventSignatories = Seq(user1))(
+        store.multiDomainAcsStore
+      )
+      (unfiltered, unfilteredAccepted) <- store.getOutstandingTransferOffers(
         None,
         None,
       )
-      filteredSenderMatch <- store.getOutstandingTransferOffers(
+      (filteredSenderMatch, filteredSenderMatchAccepted) <- store.getOutstandingTransferOffers(
         Some(user1),
         None,
       )
-      filteredSenderNoMatch <- store.getOutstandingTransferOffers(
+      (filteredSenderNoMatch, filteredSenderNoMatchAccepted) <- store.getOutstandingTransferOffers(
         Some(user2),
         None,
       )
-      filteredReceiverMatch <- store.getOutstandingTransferOffers(
+      (filteredReceiverMatch, filteredReceiverMatchAccepted) <- store.getOutstandingTransferOffers(
         None,
         Some(user2),
       )
-      filteredReceiverNoMatch <- store.getOutstandingTransferOffers(
-        None,
-        Some(user1),
-      )
+      (filteredReceiverNoMatch, filteredReceiverNoMatchAccepted) <- store
+        .getOutstandingTransferOffers(
+          None,
+          Some(user1),
+        )
     } yield {
       unfiltered.map(_.contractId) shouldBe Seq(offer1.contractId)
+      unfilteredAccepted.map(_.contractId) shouldBe Seq(acceptedOffer.contractId)
       filteredSenderMatch.map(_.contractId) shouldBe Seq(offer1.contractId)
+      filteredSenderMatchAccepted.map(_.contractId) shouldBe Seq(acceptedOffer.contractId)
       filteredSenderNoMatch.map(_.contractId) shouldBe Seq()
+      filteredSenderNoMatchAccepted.map(_.contractId) shouldBe Seq()
       filteredReceiverMatch.map(_.contractId) shouldBe Seq(offer1.contractId)
+      filteredReceiverMatchAccepted.map(_.contractId) shouldBe Seq(acceptedOffer.contractId)
       filteredReceiverNoMatch.map(_.contractId) shouldBe Seq()
+      filteredReceiverNoMatchAccepted.map(_.contractId) shouldBe Seq()
     }
   }