Support transfers with 24h validity period

Signed-off-by: Moritz Kiefer <moritz.kiefer@purelyfunctional.org>

Author: cocreature

daml/dars.lock

@@ -146,4 +146,4 @@ splitwell 0.1.6 872da0dd7986fd768930f85d6a7310a94a0ef924e7fbb7bb7a4e149f2b5feb74
 splitwell 0.1.7 841d1c9c86b5c8f3a39059459ecd8febedf7703e18f117300bb0ebf4423db096
 splitwell 0.1.8 63b8153a08ceb4bf40d807acc5712372c3eac548c266be4d5e92470b4f655515
 splitwell 0.1.9 b6267905698d2798b9ef171e27d49fb88e052ec0ec0e0675a3a1b275c7d037d4
-splitwell-test 0.1.19 37cafd5988552e48ae5dfd17e2a192eb8d165ae4dcaf1ddb0589c9ac49090aed
+splitwell-test 0.1.19 37cafd5988552e48ae5dfd17e2a192eb8d165ae4dcaf1ddb0589c9ac49090aed

daml/splice-amulet-test/daml/Splice/Scripts/TestAmuletBurn.daml

@@ -11,14 +11,16 @@ import Splice.ValidatorLicense
 
 import Splice.Scripts.Util
 
+import Splice.Testing.Registries.AmuletRegistry (advanceToNextRoundChange)
+
 -- | Note to readers: try commenting suffixes of this script out to
 -- see the various steps in action.
 testAmuletBurn : Script ()
 testAmuletBurn = do
   -- bootstrap app
   app <- setupApp
 
-  advanceToNextRoundChange app
+  advanceToNextRoundChange app.dso
 
   -- -- start issuing
   runNextIssuance app

daml/splice-amulet-test/daml/Splice/Scripts/TestAmuletRulesTransfer.daml

@@ -19,6 +19,7 @@ import Splice.AmuletRules
 import Splice.Expiry
 import Splice.Fees
 import Splice.Testing.Registries.AmuletRegistry.Parameters
+import Splice.Testing.Registries.AmuletRegistry (convertAllFeaturedAppActivityMarkers)
 import Splice.Scripts.Util
 
 testUsageFees: Script ()
@@ -467,6 +468,8 @@ testAppRewardBeneficiaries = do
       context = context.context
       expectedDso = Some app.dso
 
+    convertAllFeaturedAppActivityMarkers app.dso
+
     if featured
       then do
         [(rewardCid, aliceAppRewardCouponUnfeaturedNoBeneficiary)] <- query @AppRewardCoupon alice.primaryParty
@@ -492,6 +495,8 @@ testAppRewardBeneficiaries = do
             context = context.context
             expectedDso = Some app.dso
 
+        convertAllFeaturedAppActivityMarkers app.dso
+
         [(rewardCid1, aliceAppRewardCouponUnfeaturedBeneficiary)] <- queryFilter @AppRewardCoupon alice.primaryParty (\r -> r.beneficiary == Some alice.primaryParty)
 
         [(rewardCid2, bobAppRewardCouponUnfeaturedBeneficiary)] <- queryFilter @AppRewardCoupon bob.primaryParty (\r -> r.beneficiary == Some bob.primaryParty)

daml/splice-amulet-test/daml/Splice/Scripts/TestComputeFees.daml

@@ -4,6 +4,7 @@
 module Splice.Scripts.TestComputeFees where
 
 import DA.Assert
+import DA.Time
 import DA.TextMap as TextMap
 import Daml.Script
 
@@ -46,10 +47,16 @@ testScaledHoldingFees = do
 
   -- skip 202 rounds so that the amulet expires
   skipNRounds app 202
+  -- advance external party config state contracts to current
+  -- rounds
+  updateExternalPartyConfigState app
+  passTime (hours 24)
+  updateExternalPartyConfigState app
 
-  openRoundCid <- getLatestActiveOpenRound app
-  result <- submit app.dso $ exerciseCmd curAmuletCid Amulet_Expire with
-    roundCid = openRoundCid._1
+  (config0Cid, config1Cid) <- getExternalPartyConfigStates app
+  result <- submit app.dso $ exerciseCmd curAmuletCid Amulet_ExpireV2 with
+    externalPartyConfigState0Cid = config0Cid
+    externalPartyConfigState1Cid = config1Cid
 
   -- Check the expire result. In particular, actual holding fee should be based
   -- on the amulet price when the amulet was created, not the current one.
@@ -58,7 +65,7 @@ testScaledHoldingFees = do
         round = curAmulet.amount.createdAt
         changeToInitialAmountAsOfRoundZero = negate (getValueAsOfRound0 curAmulet.amount)
         changeToHoldingFeesRate = negate scaledHoldingFee
-      expectedMeta = Some $ Metadata $ TextMap.fromList
+      expectedMeta = Metadata $ TextMap.fromList
         [ ("splice.lfdecentralizedtrust.org/burned", show curAmulet.amount.initialAmount)
         , ("splice.lfdecentralizedtrust.org/tx-kind","expire-dust")
         ]

daml/splice-amulet-test/daml/Splice/Scripts/TestDesignExample.daml

@@ -16,6 +16,7 @@ import Splice.Expiry
 import Splice.Types
 import Splice.Fees
 import Splice.Scripts.Util
+import Splice.Testing.Registries.AmuletRegistry (convertAllFeaturedAppActivityMarkers)
 
 arbiterPaymentAmount : Decimal
 arbiterPaymentAmount = 1.0
@@ -36,8 +37,8 @@ template Escrow
       controller p
       do LockedAmulet{lock,amulet=locked} <- fetchButArchiveLater (ForOwner with dso; owner = p) lockedAmulet -- archived as part of unlocking
          require "lock holder matches locked amulet " ([arbiter] == lock.holders)
-         result <- exercise lockedAmulet (LockedAmulet_Unlock transferContext.openMiningRound)
-         let cid = result.amuletSum.amulet
+         result <- exercise lockedAmulet LockedAmulet_UnlockV2
+         let cid = result.amuletCid
          let transfer = Transfer with
                sender = p
                provider = arbiter
@@ -128,7 +129,6 @@ test_designExample = do
       holdingFees = 0.0 -- no holding fees charged on transfer
       inputAmuletHoldingFees = transferConfig.holdingFee.rate * 2.0 -- there are 2 input amulets
       outputAmuletHoldingFees = transferConfig.holdingFee.rate * 3.0  -- there are 2 output amulets + 1 amulet for the change
-      outputFees = [lockedAmuletFee, transferredAmuletFee]
       senderChangeAmount =
         refreshAmuletAmount
         - arbiterPaymentAmount
@@ -148,7 +148,7 @@ test_designExample = do
     inputAmuletAmount = refreshAmuletAmount + lockedAmuletAmount
     balanceChanges = Map.empty
     holdingFees
-    outputFees
+    outputFees = [0.0, 0.0]
     senderChangeAmount
     senderChangeFee = transferConfig.createFee.fee
     amuletPrice = 1.0
@@ -190,6 +190,7 @@ test_designExample = do
       in expiringAmount transferConfig.holdingFee amount c2.round
 
   -- check app reward issued by the escrow refresh
+  convertAllFeaturedAppActivityMarkers app.dso
   [(_, appRewardCoupon)] <- queryFilter @AppRewardCoupon app.dso (\reward -> reward.round.number == 50002)
   appRewardCoupon === AppRewardCoupon with
     dso = app.dso
@@ -198,14 +199,14 @@ test_designExample = do
     featured = True
     amount =
       -- rewards are issued for all output fees, but not the senderChangeFee
-      sum outputFees +
       transferConfig.extraFeaturedAppRewardAmount
     round = Round 50002
 
   -- the 'arbiter' also receives featured app rewards when he's the sender and provider of a transfer
   runNextIssuance app
   let reimbursementAmount = 0.5
   pay app arbiter alice.primaryParty reimbursementAmount
+  convertAllFeaturedAppActivityMarkers app.dso
 
   [(_, appReward)] <- queryFilter @AppRewardCoupon app.dso (\reward -> reward.round.number == 50003)
   appReward === AppRewardCoupon with

daml/splice-amulet-test/daml/Splice/Scripts/TestLockAndAmuletExpiry.daml

@@ -16,9 +16,8 @@ import Splice.Fees
 import Splice.Expiry
 import Splice.Round
 import Splice.Types
-import Splice.RelRound
-import Splice.Schedule
 import Splice.Testing.Registries.AmuletRegistry.Parameters
+import Splice.Testing.Registries.AmuletRegistry (advanceToNextRoundChange)
 import Splice.Scripts.Util
 
 import DA.Foldable (forA_)
@@ -34,39 +33,14 @@ scaleAmuletConfig amuletPrice config = AmuletConfig with
   transferPreapprovalFee = fmap (/ amuletPrice) config.transferPreapprovalFee
   featuredAppActivityMarkerAmount = fmap (/ amuletPrice) config.featuredAppActivityMarkerAmount
   optDevelopmentFundManager = config.optDevelopmentFundManager
+  externalPartyConfigStateTickDuration = config.externalPartyConfigStateTickDuration
 
 test : Script ()
 test = script do
   DefaultAppWithUsers{..} <- setupDefaultAppWithUsers
-  advanceToNextRoundChange app -- advance time so we're out of the initial mining round
-  currentTime <- getTime
+  advanceToNextRoundChange app.dso -- advance time so we're out of the initial mining round
   let amuletPrice = 2.5
       config = scaleAmuletConfig amuletPrice defaultAmuletConfig
-      tickDuration = config.tickDuration
-
-      t00_00 = currentTime
-      t05_00 = addRelRoundN 2 currentTime tickDuration
-      t07_30 = addRelRoundN 3 currentTime tickDuration
-      t12_30 = addRelRoundN 5 currentTime tickDuration
-      t15_00 = addRelRoundN 6 currentTime tickDuration
-      t17_30 = addRelRoundN 7 currentTime tickDuration
-
-      issuingFor0 = days 0
-      issuingFor3 = issuingFor0 + tickDuration + tickDuration + tickDuration
-
-      amuletConfigUsd = defaultAmuletConfig
-      transferConfigUsd = amuletConfigUsd.transferConfig
-      issuanceConfig0 = getValueAsOf issuingFor0 amuletConfigUsd.issuanceCurve
-      issuanceConfig3 = getValueAsOf issuingFor3 amuletConfigUsd.issuanceCurve
-      openRound0 = OpenMiningRound with dso = app.dso; round = Round 0; amuletPrice; opensAt = t00_00; targetClosesAt = t05_00; issuingFor = issuingFor0; transferConfigUsd; issuanceConfig = issuanceConfig0; tickDuration
-      openRound3 = openRound0 with round = Round 3; opensAt = t07_30 ; targetClosesAt = t12_30; issuanceConfig = issuanceConfig3
-
-  -- Lock expires at T00:12:30
-  let lockExpiresAt12_30 = TimeLock with holders = [alice.primaryParty]; expiresAt = t12_30; optContext = None
-  -- Lock expires at T00:15:00
-  let lockExpiresAt15_00 = TimeLock with holders = [alice.primaryParty]; expiresAt = t15_00; optContext = None
-  -- Lock expires at T00:17:30
-  let lockExpiresAt17_30 = TimeLock with holders = [alice.primaryParty]; expiresAt = t17_30; optContext = None
 
   -- This amulet is estimated to expire at round 5.
   -- we exploit that there are exactly three open rounds active at any point in time.
@@ -76,105 +50,63 @@ test = script do
   let amountExpiresAtRound5 = ExpiringAmount with initialAmount = config.transferConfig.holdingFee.rate * 3.5; createdAt = Round 1; ratePerRound = config.transferConfig.holdingFee
   let bounded = amountExpiresAt amountExpiresAtRound5
   bounded === Singleton (Round 5)
-  let (Singleton r) = bounded
-  estimateOpenRoundCreatedAt config.tickDuration openRound3 (Singleton(addRelRound r (RelRound 2))) === Some (Singleton t15_00)
-
-  -- lock expires at T00:12:30 before amulet expires at T00:15:00
-  let lockExpireBeforeAmulet = doesLockExpireBeforeAmulet openRound3 lockExpiresAt12_30 amountExpiresAtRound5 config.tickDuration
-  assert lockExpireBeforeAmulet
-
-  -- lock expires at T00:15:00 while amulet expires at T00:15:00
-  let lockExpiresAsAmulet = doesLockExpireBeforeAmulet openRound3 lockExpiresAt15_00 amountExpiresAtRound5 config.tickDuration
-  assert $ not lockExpiresAsAmulet
-
-  -- lock expires at T00:17:30 after amulet expires at T00:15:00
-  let lockExpiresAfterAmulet = doesLockExpireBeforeAmulet openRound3 lockExpiresAt17_30 amountExpiresAtRound5 config.tickDuration
-  assert $ not lockExpiresAfterAmulet
-
-  let largeAmount = ExpiringAmount with initialAmount = 10000.0; createdAt = Round 1; ratePerRound = config.transferConfig.holdingFee
-  -- lock expires at T00:12:30 before amulet with large amount, which is regarded as never expires (EstimatedTime.AfterMaxTime)
-  let lockExpiresBeforeLargeAmulet = doesLockExpireBeforeAmulet openRound3 lockExpiresAt12_30 largeAmount config.tickDuration
-  assert lockExpiresBeforeLargeAmulet
-
-  pure ()
-
--- From #2336, This test case is to make sure we handle DA.Time overflow
--- in estimateOpenRoundCreatedAt when the amulet amount is too large
-testLargeAmuletExpiry : Script ()
-testLargeAmuletExpiry = script do
-  DefaultAppWithUsers{..} <- setupDefaultAppWithUsers
-  now <- getTime
-
-  let amuletPrice = 2.5
-      configUsd = defaultAmuletConfig
-      transferConfigAmulet = scaleFees (1.0 / amuletPrice) configUsd.transferConfig
-      e = ExpiringAmount with initialAmount = 10000.0; createdAt = Round 1; ratePerRound = transferConfigAmulet.holdingFee
-      Singleton r = amountExpiresAt e
-      expiringRound = Singleton $ addRelRound r (RelRound 2)
-      issuingFor = minutes 5
-      currentMiningRound = OpenMiningRound with
-        dso = app.dso
-        round = Round 1
-        amuletPrice = 1.0
-        opensAt = now
-        targetClosesAt = addRelTime now (minutes 5)
-        issuingFor
-        transferConfigUsd = configUsd.transferConfig
-        issuanceConfig = getValueAsOf issuingFor configUsd.issuanceCurve
-        tickDuration = configUsd.tickDuration
-
-  estimateOpenRoundCreatedAt configUsd.tickDuration currentMiningRound expiringRound === Some AfterMaxBound
   pure ()
 
 testExpireLockedAmulet : Script ()
 testExpireLockedAmulet = do
   DefaultAppWithUsers{..} <- setupDefaultAppWithUsers
-  advanceToNextRoundChange app -- advance time so we're out of the initial mining round
+  advanceToNextRoundChange app.dso -- advance time so we're out of the initial mining round
   passTime (minutes 10) -- pass enough time so that round 2 expires in 10 minutes
 
-  -- Locking the amulet with with initialAmount 0.000005 and created at round 2 but with a
-  -- lock for 10 minutes should fail, as round 2 ends in 10 minutes
-  getLockedAmuletMustFail app alice bob.primaryParty defaultTransferConfig.holdingFee.rate (minutes 10)
+  -- We don't enforce that locks expire before the underlying amulet does so locking an amulet with with initialAmount 0.000005 and created at round 2 but with a
+  -- lock for 10 minutes should succeed even if round 2 ends in 10 minutes.
+  cid0 <- getLockedAmulet app alice bob.primaryParty defaultTransferConfig.holdingFee.rate (minutes 10)
   -- Lock the amulet with initialAmount 0.000005 and created at round 2
   -- As the amulet amount is equal to one round's holding fee, it will be expired at round 3
   cid <- getLockedAmulet app alice bob.primaryParty defaultTransferConfig.holdingFee.rate (seconds 90 - convertMicrosecondsToRelTime 1)
   Some(lockedAmulet) <- queryContractId @LockedAmulet alice.primaryParty cid
 
-  roundCid <- advanceRound app (Round 3)
+  _ <- advanceRound app (Round 3)
+  updateExternalPartyConfigState app
+  passTime (hours 24)
+  updateExternalPartyConfigState app
 
   -- Lock is not yet expired
   -- DSO party fails to expire the amulet
+  (externalPartyConfigState0Cid, externalPartyConfigState1Cid) <- getExternalPartyConfigStates app
   testChoiceFailed [app.dso] [app.dso] $
-    exerciseCmd cid (LockedAmulet_ExpireAmulet roundCid)
+    exerciseCmd cid (LockedAmulet_ExpireAmuletV2 with
+      externalPartyConfigState0Cid
+      externalPartyConfigState1Cid)
 
-  -- Current round is 4
-  roundCid <- advanceRound app (Round 4)
+  debug "past first"
 
-  -- Amulet is not yet expired
-  -- 2 rounds before current round = 4 - 2 = 2 which is before round 3 when the amulet expires
-  -- DSO party fails to expire the amulet
-  testChoiceFailed [app.dso] [app.dso] $
-    exerciseCmd cid (LockedAmulet_ExpireAmulet roundCid)
-
-  -- Current round is 5
-  roundCid <- advanceRound app (Round 5)
+  -- Current round is 4
+  _ <- advanceRound app (Round 4)
+  passTime (hours 24)
+  updateExternalPartyConfigState app
+  passTime (hours 24)
+  updateExternalPartyConfigState app
 
   normalizedBalanceBeforeExpiry <- getNormalizedBalance app.dso
 
   -- Amulet is expired
   -- 2 rounds before current round => 5 - 2 = 3 which is equal to round 3 when the amulet expires
   -- DSO party expires the amulet
-  result <- checkTxMetadata app TxKind_ExpireDust alice.primaryParty $
+  (externalPartyConfigState0Cid, externalPartyConfigState1Cid) <- getExternalPartyConfigStates app
+  result <- checkTxMetadata' app TxKind_ExpireDust alice.primaryParty $
     testChoice [app.dso] [app.dso] $
-      exerciseCmd cid (LockedAmulet_ExpireAmulet roundCid)
+      exerciseCmd cid $ LockedAmulet_ExpireAmuletV2 with
+        externalPartyConfigState0Cid
+        externalPartyConfigState1Cid
   let expireSummary = result.expireSum
 
   normalizedBalanceAfterExpiry <- getNormalizedBalance app.dso
   expireSummary.changeToInitialAmountAsOfRoundZero === normalizedBalanceAfterExpiry - normalizedBalanceBeforeExpiry
   expireSummary.changeToHoldingFeesRate === - (lockedAmulet.amulet.amount.ratePerRound.rate)
 
   lockedAmulets <- query @LockedAmulet bob.primaryParty
-  lockedAmulets === []
+  map fst lockedAmulets === [cid0]
 
   pure ()
 
@@ -195,41 +127,51 @@ testExpireAmulet = do
   amulet.amount.createdAt === Round 1
 
   -- current latest active round is 3
-  latestActiveRoundCid <- advanceRound app (Round 3)
+  _ <- advanceRound app (Round 3)
+  updateExternalPartyConfigState app
+  passTime (hours 24)
+  updateExternalPartyConfigState app
 
   -- 2 rounds before latest active round = 3 - 2 = 1 which is before round 3 when the amulet expires
   -- DSO party fails to expire the amulet
+  (externalPartyConfigState0Cid, externalPartyConfigState1Cid) <- getExternalPartyConfigStates app
   testChoiceFailed [app.dso] [app.dso] $
-    exerciseCmd cid (Amulet_Expire latestActiveRoundCid)
+    exerciseCmd cid Amulet_ExpireV2 with
+      externalPartyConfigState0Cid
+      externalPartyConfigState1Cid
 
   -- current latest active round is 4
-  latestActiveRoundCid <- advanceRound app (Round 4)
-
-  -- 2 rounds before current latest active round => 4 - 2 = 2 which is before round 3 when the amulet expires
-  -- DSO party fails to expire the amulet
-  testChoiceFailed [app.dso] [app.dso] $
-    exerciseCmd cid (Amulet_Expire latestActiveRoundCid)
-
-  -- current latest active round is 5
-  latestActiveRoundCid <- advanceRound app (Round 5)
+  _ <- advanceRound app (Round 4)
+  passTime (hours 24)
+  updateExternalPartyConfigState app
+  passTime (hours 24)
+  updateExternalPartyConfigState app
 
   normalizedBalanceBeforeExpiry <- getNormalizedBalance app.dso
 
+  passTime (hours 24)
+  updateExternalPartyConfigState app
+  passTime (hours 24)
+  updateExternalPartyConfigState app
+
   -- 2 rounds before current latest active round => 5 - 2 = 3 which is equal to round 3 when the amulet expires
   -- DSO party expires the amulet
-  result <- checkTxMetadata app TxKind_ExpireDust alice.primaryParty $
+  (externalPartyConfigState0Cid, externalPartyConfigState1Cid) <- getExternalPartyConfigStates app
+  result <- checkTxMetadata' app TxKind_ExpireDust alice.primaryParty $
     testChoice [app.dso] [app.dso] $
-    exerciseCmd cid (Amulet_Expire latestActiveRoundCid)
+    exerciseCmd cid $ Amulet_ExpireV2 with
+      externalPartyConfigState0Cid
+      externalPartyConfigState1Cid
   let expireSummary = result.expireSum
 
   normalizedBalanceAfterExpiry <- getNormalizedBalance app.dso
   expireSummary.changeToInitialAmountAsOfRoundZero === normalizedBalanceAfterExpiry - normalizedBalanceBeforeExpiry
   expireSummary.changeToHoldingFeesRate === - (amulet.amount.ratePerRound.rate)
 
-  -- current active current mining round is 3, 4 and 5
+  -- current active current mining round is 2, 3 and 4
   allActiveOpenMiningRoundCids <- query @OpenMiningRound app.dso
   forA_ allActiveOpenMiningRoundCids $ \(_, openRound) -> do
-    assert $ openRound.round.number >= 3 && openRound.round.number <= 5
+    assert $ openRound.round.number >= 2 && openRound.round.number <= 4
 
   -- alice now only owns a amulet with initial amount of 1.0
   [(_, onlyAmulet)] <- query @Amulet alice.primaryParty