remove reserve t0

Author: kpinter-iohk

.changes/unreleased/Changed-20250124-095024.yaml

@@ -0,0 +1,3 @@
+kind: Changed
+body: updated offchain code to match onchain types
+time: 2025-01-24T09:50:24.917518792+01:00

.changes/unreleased/Removed-20250124-094950.yaml

@@ -0,0 +1,3 @@
+kind: Removed
+body: t0 field from reserve immutable settings smart-contract
+time: 2025-01-24T09:49:50.092863529+01:00

offchain/README.md

@@ -314,7 +314,6 @@ candidates and add new ones in a single transaction. Just provide
 ```
 nix run .#pc-contracts-cli -- reserve-create \
    --total-accrued-function-script-hash SCRIPT-HASH \
-   --reserve-posixtime-t0 POSIXTIME \
    --reserve-asset-script-hash ASSET-SCRIPT-HASH \
    --reserve-asset-name RESERVE_ASSET_NAME \
    --reserve-initial-deposit-amount RESERVE-DEPOSIT-AMOUNT

offchain/src/TrustlessSidechain/DParameter.purs

@@ -102,9 +102,8 @@ mkInsertDParameterLookupsAndConstraints
 
     constraints :: TxConstraints
     constraints =
-      Constraints.mustMintCurrencyWithRedeemer
+      Constraints.mustMintCurrency
         dParameterMintingPolicyHash
-        (RedeemerDatum $ PlutusData.unit)
         dParameterTokenName
         (Int.fromInt 1)
         <> Constraints.mustPayToScript dParameterValidatorHash datum

offchain/src/TrustlessSidechain/NativeTokenManagement/Reserve.purs

@@ -32,9 +32,6 @@ import Contract.PlutusData
   , toData
   )
 import Contract.ScriptLookups as Lookups
-import Contract.Time
-  ( POSIXTime
-  )
 import Contract.Time as Time
 import Contract.Transaction
   ( ScriptRef(..)
@@ -51,25 +48,16 @@ import Contract.Utxos (UtxoMap)
 import Contract.Value (add, minus, singleton) as Value
 import Data.Array as Array
 import Data.Bifunctor (lmap)
-import Data.DateTime.Instant (unInstant)
-import Data.Int (floor)
 import Data.Map as Map
-import Data.Time.Duration (Milliseconds(..))
-import Effect.Now as Now
-import Effect.Unsafe (unsafePerformEffect)
 import JS.BigInt as BigInt
-import Partial.Unsafe (unsafePartial)
-import Run (EFFECT, Run, liftEffect)
 import Run (Run)
 import Run.Except (EXCEPT, throw)
-import TrustlessSidechain.Effects.App (APP, BASE)
-import TrustlessSidechain.Effects.Contract (CONTRACT, liftContract)
+import TrustlessSidechain.Effects.App (APP)
 import TrustlessSidechain.Effects.Time (getCurrentEra, getSystemStart)
 import TrustlessSidechain.Effects.Transaction (TRANSACTION, getUtxo, utxosAt)
 import TrustlessSidechain.Effects.Util (fromEitherThrow, fromMaybeThrow)
 import TrustlessSidechain.Effects.Wallet (WALLET)
 import TrustlessSidechain.Error (OffchainError(..))
-import TrustlessSidechain.Error (OffchainError(GenericInternalError))
 import TrustlessSidechain.Governance.Utils as Governance
 import TrustlessSidechain.NativeTokenManagement.Types
   ( ImmutableReserveSettings
@@ -318,9 +306,8 @@ initialiseReserveUtxo
         governanceConstraints
           <> reserveAuthConstraints
           <> reserveConstraints
-          <> TxConstraints.mustMintCurrencyWithRedeemerUsingScriptRef
+          <> TxConstraints.mustMintCurrencyUsingScriptRef
             reserveAuthCurrencySymbol
-            (RedeemerDatum $ toData unit)
             reserveAuthTokenName
             (Int.fromInt 1)
             ( RefInput $ TransactionUnspentOutput
@@ -440,8 +427,7 @@ depositToReserve genesisUtxo asset amount = do
           DatumInline
           newValue
         <> TxConstraints.mustSpendScriptOutputUsingScriptRef (fst utxo)
-          ( RedeemerDatum $ toData $ DepositToReserve
-              { governanceVersion: BigInt.fromInt 1 }
+          ( RedeemerDatum $ toData DepositToReserve
           )
           ( RefInput $ TransactionUnspentOutput
               { input: reserveValidatorTxInput
@@ -489,12 +475,13 @@ updateReserveUtxo genesisUtxo updatedMutableSettings utxo = do
   versionOracleConfig <- Versioning.getVersionOracleConfig genesisUtxo
   reserveValidator' <- reserveValidator versionOracleConfig
 
+  let txOutput = snd utxo
+
   genericDatum <-
     fromMaybeThrow (InvalidData "Reserve does not carry inline datum")
       $ pure
       $ extractReserveDatum
-      $ snd
-      $ utxo
+      $ txOutput
 
   let
     updatedReserveDatum = ReserveDatum $ (unwrap $ getDatum genericDatum)
@@ -510,7 +497,7 @@ updateReserveUtxo genesisUtxo updatedMutableSettings utxo = do
           , version
           }
 
-    value = unwrap >>> _.amount $ snd utxo
+    value = unwrap >>> _.amount $ txOutput
 
     lookups :: Lookups.ScriptLookups
     lookups =
@@ -526,20 +513,19 @@ updateReserveUtxo genesisUtxo updatedMutableSettings utxo = do
         <> icsConstraints
         <> reserveAuthConstraints
         <> reserveConstraints
-        <> TxConstraints.mustPayToScript
-          (PlutusScript.hash reserveValidator')
-          (toData updatedDatum)
-          DatumInline
-          value
         <> TxConstraints.mustSpendScriptOutputUsingScriptRef (fst utxo)
-          ( RedeemerDatum $ toData $ UpdateReserve
-              { governanceVersion: BigInt.fromInt 1 }
+          ( RedeemerDatum $ toData UpdateReserve
           )
           ( RefInput $ TransactionUnspentOutput
               { input: reserveValidatorTxInput
               , output: reserveValidatorTxOutput
               }
           )
+        <> TxConstraints.mustPayToScript
+          (PlutusScript.hash reserveValidator')
+          (toData updatedDatum)
+          DatumInline
+          value
 
   balanceSignAndSubmit
     "Update reserve mutable settings"
@@ -822,18 +808,15 @@ handover
           toHandover
         <> TxConstraints.mustSpendScriptOutputUsingScriptRef
           (fst utxo)
-          ( RedeemerDatum $ toData $ Handover
-              { governanceVersion: BigInt.fromInt 1 }
+          ( RedeemerDatum $ toData Handover
           )
           ( RefInput $ TransactionUnspentOutput
               { input: reserveRefTxInput
               , output: reserveRefTxOutput
               }
           )
-        <> TxConstraints.mustMintCurrencyWithRedeemerUsingScriptRef
+        <> TxConstraints.mustMintCurrencyUsingScriptRef
           (PlutusScript.hash reserveAuthPolicy')
-          ( RedeemerDatum $ toData $ unit
-          )
           emptyAssetName
           (Int.fromInt (-1))
           ( RefInput $ TransactionUnspentOutput

offchain/src/TrustlessSidechain/NativeTokenManagement/Types.purs

@@ -16,11 +16,10 @@ import Cardano.Types.ScriptHash (ScriptHash)
 import Contract.PlutusData
   ( class FromData
   , class ToData
-  , PlutusData(Constr, Integer, List)
+  , PlutusData(Constr, Integer)
   , fromData
   , toData
   )
-import Ctl.Internal.Types.Interval (POSIXTime)
 import Data.ByteArray as ByteArray
 import TrustlessSidechain.Utils.Data
   ( productFromData2
@@ -30,8 +29,7 @@ import TrustlessSidechain.Utils.Data
   )
 
 newtype ImmutableReserveSettings = ImmutableReserveSettings
-  { t0 :: POSIXTime
-  , tokenKind :: Asset
+  { tokenKind :: Asset
   }
 
 derive instance Generic ImmutableReserveSettings _
@@ -40,28 +38,27 @@ derive newtype instance Eq ImmutableReserveSettings
 derive newtype instance Show ImmutableReserveSettings
 
 instance ToData ImmutableReserveSettings where
-  toData (ImmutableReserveSettings { t0, tokenKind: Asset cs tn }) =
-    productToData2 t0 (Constr (BigNum.fromInt 0) [ toData cs, toData tn ])
-  toData (ImmutableReserveSettings { t0, tokenKind: AdaAsset }) =
-    productToData2 t0
+  toData (ImmutableReserveSettings { tokenKind: Asset cs tn }) =
+    toData (Constr (BigNum.fromInt 0) [ toData cs, toData tn ])
+  toData (ImmutableReserveSettings { tokenKind: AdaAsset }) =
+    toData
       ( Constr (BigNum.fromInt 0)
           [ toData $ ByteArray.hexToByteArrayUnsafe ""
           , toData $ ByteArray.hexToByteArrayUnsafe ""
           ]
       )
 
 instance FromData ImmutableReserveSettings where
-  fromData (List [ t0', Constr _ [ cs', tn' ] ]) = do
+  fromData (Constr _ [ cs', tn' ]) = do
     csB <- fromData cs'
     tnB <- fromData tn'
-    t0 <- fromData t0'
     let emptyByteString = ByteArray.hexToByteArrayUnsafe ""
     if (csB /\ tnB) == (emptyByteString /\ emptyByteString) then Just $
-      ImmutableReserveSettings { t0, tokenKind: AdaAsset }
+      ImmutableReserveSettings { tokenKind: AdaAsset }
     else do
       cs <- fromData cs'
       tn <- fromData tn'
-      Just $ ImmutableReserveSettings { t0, tokenKind: Asset cs tn }
+      Just $ ImmutableReserveSettings { tokenKind: Asset cs tn }
   fromData _ = Nothing
 
 newtype MutableReserveSettings = MutableReserveSettings
@@ -133,12 +130,9 @@ instance FromData ReserveDatum where
 
 data ReserveRedeemer
   = DepositToReserve
-      { governanceVersion :: BigInt.BigInt }
   | TransferToIlliquidCirculationSupply
   | UpdateReserve
-      { governanceVersion :: BigInt.BigInt }
   | Handover
-      { governanceVersion :: BigInt.BigInt }
 
 derive instance Eq ReserveRedeemer
 
@@ -148,28 +142,25 @@ instance Show ReserveRedeemer where
   show = genericShow
 
 instance ToData ReserveRedeemer where
-  toData (DepositToReserve { governanceVersion }) =
-    Constr (BigNum.fromInt 0) [ toData governanceVersion ]
+  toData DepositToReserve =
+    Constr (BigNum.fromInt 0) []
   toData TransferToIlliquidCirculationSupply =
     Constr (BigNum.fromInt 1) []
-  toData (UpdateReserve { governanceVersion }) =
-    Constr (BigNum.fromInt 2) [ toData governanceVersion ]
-  toData (Handover { governanceVersion }) =
-    Constr (BigNum.fromInt 3) [ toData governanceVersion ]
+  toData UpdateReserve =
+    Constr (BigNum.fromInt 2) []
+  toData Handover =
+    Constr (BigNum.fromInt 3) []
 
 instance FromData ReserveRedeemer where
   fromData = case _ of
-    Constr tag [ arg ] | tag == BigNum.fromInt 0 -> do
-      governanceVersion <- fromData arg
-      pure $ DepositToReserve { governanceVersion }
+    Constr tag [] | tag == BigNum.fromInt 0 -> pure
+      DepositToReserve
     Constr tag [] | tag == BigNum.fromInt 1 -> pure
       TransferToIlliquidCirculationSupply
-    Constr tag [ arg ] | tag == BigNum.fromInt 2 -> do
-      governanceVersion <- fromData arg
-      pure $ UpdateReserve { governanceVersion }
-    Constr tag [ arg ] | tag == BigNum.fromInt 3 -> do
-      governanceVersion <- fromData arg
-      pure $ Handover { governanceVersion }
+    Constr tag [] | tag == BigNum.fromInt 2 -> pure
+      UpdateReserve
+    Constr tag [] | tag == BigNum.fromInt 3 -> pure
+      Handover
     _ -> Nothing
 
 data IlliquidCirculationSupplyRedeemer

offchain/src/TrustlessSidechain/Options/Specs.purs

@@ -14,7 +14,6 @@ import Contract.Config
   , testnetConfig
   )
 import Contract.Prim.ByteArray (ByteArray)
-import Contract.Time (POSIXTime)
 import Contract.Transaction (TransactionInput)
 import Contract.Value (AssetName)
 import Contract.Wallet
@@ -589,17 +588,6 @@ parseIncentiveAmount =
           ]
       )
 
--- `parsePOSIXTime`
-parserT0 :: Parser POSIXTime
-parserT0 = option Parsers.posixTime
-  ( fold
-      [ long "reserve-posixtime-t0"
-      , metavar "POSIXTIME"
-      , help
-          "Partner chain POSIX timestamp of the moment the reserve is launched"
-      ]
-  )
-
 parseAssetName :: Parser AssetName
 parseAssetName =
   ( option
@@ -644,9 +632,8 @@ parseAsset long' metavar' =
 
 parseImmutableReserveSettings :: Parser ImmutableReserveSettings
 parseImmutableReserveSettings = ado
-  t0 <- parserT0
   tokenKind <- parseAsset "reserve-asset-script-hash" "ASSET-SCRIPT-HASH"
-  in ImmutableReserveSettings { t0, tokenKind }
+  in ImmutableReserveSettings { tokenKind }
 
 parseMutableReserveSettings :: Parser MutableReserveSettings
 parseMutableReserveSettings = ado