[ci] Update Splice from CCI

Signed-off-by: DA Automation <splice-maintainers@digitalasset.com>

Author: DA Automation

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

@@ -39,16 +39,14 @@ class WalletTransferOfferSweepTrigger(
       currentAmuletConfig: AmuletConfig[USD],
   )(implicit tc: TraceContext): scala.concurrent.Future[BigDecimal] = {
     for {
-      (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),
+      filteredTransferOffers <- store.getOutstandingTransferOffers(
+        None,
+        Some(config.receiver),
+      )
+    } yield filteredTransferOffers
+      .map(c => {
+        BigDecimal(ccToDollars(c.payload.amount.amount, amuletPrice)) + computeTransferFees(
+          BigDecimal(c.payload.amount.amount),
           currentAmuletConfig.transferConfig.transferFee,
         ) + computeCreateFees(currentAmuletConfig)
       })
@@ -66,15 +64,12 @@ class WalletTransferOfferSweepTrigger(
       amountToSendAfterFeesCC: java.math.BigDecimal,
   )(implicit tc: TraceContext): Future[Unit] = {
     for {
-      (filteredTransferOffers, acceptedFilteredTransferOffers) <- store
-        .getOutstandingTransferOffers(
-          None,
-          Some(config.receiver),
-        )
+      filteredTransferOffers <- 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,25 +344,14 @@ trait UserWalletStore extends TxLogAppStore[TxLogEntry] with TransferInputStore
   )(implicit
       tc: TraceContext,
       ec: ExecutionContext,
-  ): Future[
-    (
-        Seq[AssignedContract[
-          transferOffersCodegen.TransferOffer.ContractId,
-          transferOffersCodegen.TransferOffer,
-        ]],
-        Seq[AssignedContract[
-          transferOffersCodegen.AcceptedTransferOffer.ContractId,
-          transferOffersCodegen.AcceptedTransferOffer,
-        ]],
-    )
-  ] = {
+  ): Future[Seq[AssignedContract[
+    transferOffersCodegen.TransferOffer.ContractId,
+    transferOffersCodegen.TransferOffer,
+  ]]] = {
     for {
       transferOffers <- multiDomainAcsStore.listAssignedContracts(
         transferOffersCodegen.TransferOffer.COMPANION
       )
-      acceptedTransferOffers <- multiDomainAcsStore.listAssignedContracts(
-        transferOffersCodegen.AcceptedTransferOffer.COMPANION
-      )
     } yield {
       val offersFilteredFrom = fromParty match {
         case None => transferOffers
@@ -374,18 +363,7 @@ trait UserWalletStore extends TxLogAppStore[TxLogEntry] with TransferInputStore
         case Some(toParty) =>
           offersFilteredFrom.filter(_.payload.receiver == toParty.toProtoPrimitive)
       }
-
-      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)
+      offersFilteredTo
     }
   }
 

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

@@ -945,51 +945,35 @@ 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
       )
-      _ <- dummyDomain.create(acceptedOffer, createdEventSignatories = Seq(user1))(
-        store.multiDomainAcsStore
-      )
-      (unfiltered, unfilteredAccepted) <- store.getOutstandingTransferOffers(
+      unfiltered <- store.getOutstandingTransferOffers(
         None,
         None,
       )
-      (filteredSenderMatch, filteredSenderMatchAccepted) <- store.getOutstandingTransferOffers(
+      filteredSenderMatch <- store.getOutstandingTransferOffers(
         Some(user1),
         None,
       )
-      (filteredSenderNoMatch, filteredSenderNoMatchAccepted) <- store.getOutstandingTransferOffers(
+      filteredSenderNoMatch <- store.getOutstandingTransferOffers(
         Some(user2),
         None,
       )
-      (filteredReceiverMatch, filteredReceiverMatchAccepted) <- store.getOutstandingTransferOffers(
+      filteredReceiverMatch <- store.getOutstandingTransferOffers(
         None,
         Some(user2),
       )
-      (filteredReceiverNoMatch, filteredReceiverNoMatchAccepted) <- store
-        .getOutstandingTransferOffers(
-          None,
-          Some(user1),
-        )
+      filteredReceiverNoMatch <- 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()
     }
   }