Mark depricated parts of the TxEnv as obsolete

These fields are only used to implement broken jets.
They only remain here because they are not part of consensus and cannot be removed.

Author: roconnor-blockstream

C/elements/elementsJets.c

@@ -153,12 +153,12 @@ static uint_fast32_t lockTime(const elementsTransaction* tx) {
   return !tx->isFinal && 500000000U <= tx->lockTime ? tx->lockTime : 0;
 }
 
-static uint_fast16_t lockDistance(const elementsTransaction* tx) {
-  return 2 <= tx->version ? tx->lockDistance : 0;
+static uint_fast16_t obsolete_lockDistance(const elementsTransaction* tx) {
+  return 2 <= tx->version ? tx->obsolete_lockDistance : 0;
 }
 
-static uint_fast16_t lockDuration(const elementsTransaction* tx) {
-  return 2 <= tx->version ? tx->lockDuration : 0;
+static uint_fast16_t obsolete_lockDuration(const elementsTransaction* tx) {
+  return 2 <= tx->version ? tx->obsolete_lockDuration : 0;
 }
 
 static bool isFee(const sigOutput* output) {
@@ -735,14 +735,14 @@ bool simplicity_tx_lock_time(frameItem* dst, frameItem src, const txEnv* env) {
 /* tx_lock_distance : ONE |- TWO^16 */
 bool simplicity_broken_do_not_use_tx_lock_distance(frameItem* dst, frameItem src, const txEnv* env) {
   (void) src; // src is unused;
-  simplicity_write16(dst, lockDistance(env->tx));
+  simplicity_write16(dst, obsolete_lockDistance(env->tx));
   return true;
 }
 
 /* tx_lock_duration : ONE |- TWO^16 */
 bool simplicity_broken_do_not_use_tx_lock_duration(frameItem* dst, frameItem src, const txEnv* env) {
   (void) src; // src is unused;
-  simplicity_write16(dst, lockDuration(env->tx));
+  simplicity_write16(dst, obsolete_lockDuration(env->tx));
   return true;
 }
 
@@ -764,14 +764,14 @@ bool simplicity_check_lock_time(frameItem* dst, frameItem src, const txEnv* env)
 bool simplicity_broken_do_not_use_check_lock_distance(frameItem* dst, frameItem src, const txEnv* env) {
   (void) dst; // dst is unused;
   uint_fast16_t x = simplicity_read16(&src);
-  return x <= lockDistance(env->tx);
+  return x <= obsolete_lockDistance(env->tx);
 }
 
 /* check_lock_duration : TWO^16 |- ONE */
 bool simplicity_broken_do_not_use_check_lock_duration(frameItem* dst, frameItem src, const txEnv* env) {
   (void) dst; // dst is unused;
   uint_fast16_t x = simplicity_read16(&src);
-  return x <= lockDuration(env->tx);
+  return x <= obsolete_lockDuration(env->tx);
 }
 
 /* calculate_issuance_entropy : TWO^256 * TWO^32 * TWO^256 |- TWO^256 */

C/elements/env.c

@@ -408,12 +408,12 @@ extern elementsTransaction* simplicity_elements_mallocTransaction(const rawEleme
       copyInput(&input[i], &rawTx->input[i]);
       if (input[i].sequence < 0xffffffff) { tx->isFinal = false; }
       if (input[i].sequence < 0x80000000) {
-         const uint_fast16_t maskedSequence = input[i].sequence & 0xffff;
-         if (input[i].sequence & ((uint_fast32_t)1 << 22)) {
-            if (tx->lockDuration < maskedSequence) tx->lockDuration = maskedSequence;
-         } else {
-            if (tx->lockDistance < maskedSequence) tx->lockDistance = maskedSequence;
-         }
+        const uint_fast16_t maskedSequence = input[i].sequence & 0xffff;
+        if (input[i].sequence & ((uint_fast32_t)1 << 22)) {
+          if (tx->obsolete_lockDuration < maskedSequence) tx->obsolete_lockDuration = maskedSequence;
+        } else {
+          if (tx->obsolete_lockDistance < maskedSequence) tx->obsolete_lockDistance = maskedSequence;
+        }
       }
       if (input[i].isPegin) {
         sha256_uchar(&ctx_inputOutpointsHash, 1);

C/elements/txEnv.h

@@ -224,11 +224,9 @@ typedef struct elementsTransaction {
   uint_fast32_t numFees;
   uint_fast32_t version;
   uint_fast32_t lockTime;
-  /* lockDuration and lockDistance values are set even when the version is 0 or 1.
-   * This is similar to lockTime whose value is also set, even when the transaction is final.
-   */
-  uint_fast16_t lockDistance;
-  uint_fast16_t lockDuration; /* Units of 512 seconds */
+  /* These two fields are used to implement broken jets and only remain here for consensus purposes. */
+  uint_fast16_t obsolete_lockDistance;
+  uint_fast16_t obsolete_lockDuration;
   bool isFinal;
 } elementsTransaction;
 

Haskell/Elements/Simplicity/Elements/DataTypes.hs

@@ -23,7 +23,7 @@ module Simplicity.Elements.DataTypes
   , SigTx(SigTx), sigTxVersion, sigTxIn, sigTxOut, sigTxLock
   , putNoWitnessTx, txid
   , TapEnv(..)
-  , txIsFinal, txLockDistance, txLockDuration
+  , txIsFinal, txLockBrokenDistance, txLockBrokenDuration
   , calculateIssuanceEntropy, calculateAsset, calculateToken
   , outputAmountsHash, outputNoncesHash, outputScriptsHash
   , outputRangeProofsHash, outputSurjectionProofsHash, outputsHash, outputHash
@@ -322,17 +322,19 @@ txIsFinal tx = all finalSequence (sigTxIn tx)
  where
   finalSequence sigin = sigTxiSequence sigin == maxBound
 
-txLockDistance :: SigTx -> Word16
-txLockDistance tx | sigTxVersion tx < 2 = 0
+-- | This function is used in a specification of broken relative timelock jets and should not be used other than for previous consensus reasons.
+txLockBrokenDistance :: SigTx -> Word16
+txLockBrokenDistance tx | sigTxVersion tx < 2 = 0
                   | otherwise = getMax . foldMap distance $ sigTxIn tx
  where
   distance sigin = case parseSequence (sigTxiSequence sigin) of
                      Just (Left x) -> Max x
                      _ -> mempty
 
-txLockDuration :: SigTx -> Word16
-txLockDuration tx | sigTxVersion tx < 2 = 0
-                  | otherwise = getMax . foldMap duration $ sigTxIn tx
+-- | This function is used in a specification of broken relative timelock jets and should not be used other than for previous consensus reasons.
+txLockBrokenDuration :: SigTx -> Word16
+txLockBrokenDuration tx | sigTxVersion tx < 2 = 0
+                        | otherwise = getMax . foldMap duration $ sigTxIn tx
  where
   duration sigin = case parseSequence (sigTxiSequence sigin) of
                      Just (Right x) -> Max x

Haskell/Simplicity/Elements/Jets.hs

@@ -249,12 +249,12 @@ specificationSigHash BuildTaptweak = Prog.buildTaptweak
 specificationTimeLock :: (Assert term, Primitive term) => TimeLockJet a b -> term a b
 specificationTimeLock CheckLockHeight = TimeLock.checkLockHeight
 specificationTimeLock CheckLockTime = TimeLock.checkLockTime
-specificationTimeLock BrokenDoNotUseCheckLockDistance = TimeLock.checkLockDistance
-specificationTimeLock BrokenDoNotUseCheckLockDuration = TimeLock.checkLockDuration
+specificationTimeLock BrokenDoNotUseCheckLockDistance = TimeLock.brokenCheckLockDistance
+specificationTimeLock BrokenDoNotUseCheckLockDuration = TimeLock.brokenCheckLockDuration
 specificationTimeLock TxLockHeight = TimeLock.txLockHeight
 specificationTimeLock TxLockTime = TimeLock.txLockTime
-specificationTimeLock BrokenDoNotUseTxLockDistance = TimeLock.txLockDistance
-specificationTimeLock BrokenDoNotUseTxLockDuration = TimeLock.txLockDuration
+specificationTimeLock BrokenDoNotUseTxLockDistance = TimeLock.brokenTxLockDistance
+specificationTimeLock BrokenDoNotUseTxLockDuration = TimeLock.brokenTxLockDuration
 specificationTimeLock TxIsFinal = TimeLock.txIsFinal
 
 specificationIssuance :: (Assert term, Primitive term) => IssuanceJet a b -> term a b
@@ -420,9 +420,9 @@ implementationTimeLock CheckLockTime env x | txIsFinal (envTx env) = guard $ fro
                                            | otherwise = guard $ fromWord32 x <= 0
  where
   lock = fromIntegral . sigTxLock . envTx $ env
-implementationTimeLock BrokenDoNotUseCheckLockDistance env x | fromWord16 x <= fromIntegral (txLockDistance (envTx env)) = Just ()
+implementationTimeLock BrokenDoNotUseCheckLockDistance env x | fromWord16 x <= fromIntegral (txLockBrokenDistance (envTx env)) = Just ()
                                                              | otherwise = Nothing
-implementationTimeLock BrokenDoNotUseCheckLockDuration env x | fromWord16 x <= fromIntegral (txLockDuration (envTx env)) = Just ()
+implementationTimeLock BrokenDoNotUseCheckLockDuration env x | fromWord16 x <= fromIntegral (txLockBrokenDuration (envTx env)) = Just ()
                                                              | otherwise = Nothing
 implementationTimeLock TxLockHeight env () | txIsFinal (envTx env) = Just (toWord32 0)
                                            | Left l <- parseLock lock = Just . toWord32 $ fromIntegral l
@@ -434,8 +434,8 @@ implementationTimeLock TxLockTime env () | txIsFinal (envTx env) = Just (toWord3
                                          | otherwise = Just (toWord32 0)
  where
   lock = fromIntegral . sigTxLock . envTx $ env
-implementationTimeLock BrokenDoNotUseTxLockDistance env () = Just . toWord16 . fromIntegral $ txLockDistance (envTx env)
-implementationTimeLock BrokenDoNotUseTxLockDuration env () = Just . toWord16 . fromIntegral $ txLockDuration (envTx env)
+implementationTimeLock BrokenDoNotUseTxLockDistance env () = Just . toWord16 . fromIntegral $ txLockBrokenDistance (envTx env)
+implementationTimeLock BrokenDoNotUseTxLockDuration env () = Just . toWord16 . fromIntegral $ txLockBrokenDuration (envTx env)
 implementationTimeLock TxIsFinal env () = Just $ toBit (txIsFinal (envTx env))
 
 implementationIssuance :: IssuanceJet a b -> PrimEnv -> a -> Maybe b

Haskell/Simplicity/Elements/Programs/TimeLock.hs

@@ -2,9 +2,9 @@
 module Simplicity.Elements.Programs.TimeLock
  ( txIsFinal
  , txLockHeight, txLockTime
- , txLockDistance, txLockDuration
+ , brokenTxLockDistance, brokenTxLockDuration
  , checkLockHeight, checkLockTime
- , checkLockDistance, checkLockDuration
+ , brokenCheckLockDistance, brokenCheckLockDuration
  , module Simplicity.Programs.TimeLock
  , Bit
  ) where
@@ -43,16 +43,16 @@ bip68VersionCheck :: (Core term, Primitive term) => term () Bit
 bip68VersionCheck = scribe (toWord32 2) &&& primitive Version >>> le word32
 
 -- | Implements 'Simplicity.Elements.DataTypes.txLockDistance'.
-txLockDistance :: (Core term, Primitive term) => term () Distance
-txLockDistance = bip68VersionCheck &&& zero word16
+brokenTxLockDistance :: (Core term, Primitive term) => term () Distance
+brokenTxLockDistance = bip68VersionCheck &&& zero word16
              >>> match ih (forWhile word32 body >>> copair iden iden)
  where
   body = take (drop (primitive InputSequence)) &&& ih
      >>> match (injl ih) (injr (take parseSequence &&& ih >>> match ih (match (max word16) ih)))
 
 -- | Implements 'Simplicity.Elements.DataTypes.txLockDuration'.
-txLockDuration :: (Core term, Primitive term) => term () Duration
-txLockDuration = bip68VersionCheck &&& zero word16
+brokenTxLockDuration :: (Core term, Primitive term) => term () Duration
+brokenTxLockDuration = bip68VersionCheck &&& zero word16
              >>> match ih (forWhile word32 body >>> copair iden iden)
  where
   body = take (drop (primitive InputSequence)) &&& ih
@@ -67,9 +67,9 @@ checkLockTime :: (Assert term, Primitive term) => term Time ()
 checkLockTime = assert (iden &&& (unit >>> txLockTime) >>> le word32)
 
 -- | Asserts that the input is less than or equal to the value returned by 'txLockDistance'.
-checkLockDistance :: (Assert term, Primitive term) => term Distance ()
-checkLockDistance = assert (iden &&& (unit >>> txLockDistance) >>> le word16)
+brokenCheckLockDistance :: (Assert term, Primitive term) => term Distance ()
+brokenCheckLockDistance = assert (iden &&& (unit >>> brokenTxLockDistance) >>> le word16)
 
 -- | Asserts that the input is less than or equal to the value returned by 'txLockDuration'.
-checkLockDuration :: (Assert term, Primitive term) => term Duration ()
-checkLockDuration = assert (iden &&& (unit >>> txLockDuration) >>> le word16)
+brokenCheckLockDuration :: (Assert term, Primitive term) => term Duration ()
+brokenCheckLockDuration = assert (iden &&& (unit >>> brokenTxLockDuration) >>> le word16)

Haskell/Tests/Simplicity/Elements/Tests.hs

@@ -207,12 +207,12 @@ prop_check_lock_time = checkJet (ElementsJet (TimeLockJet CheckLockTime))
 
 prop_check_lock_distance :: Property
 prop_check_lock_distance = checkJet (ElementsJet (TimeLockJet BrokenDoNotUseCheckLockDistance))
-                         $ \check -> forallPrimEnv $ \env -> forAll (genBoundaryCases . txLockDistance $ envTx env)
+                         $ \check -> forallPrimEnv $ \env -> forAll (genBoundaryCases . txLockBrokenDistance $ envTx env)
                                                    $ \w -> check env (toW16 w)
 
 prop_check_lock_duration :: Property
 prop_check_lock_duration = checkJet (ElementsJet (TimeLockJet BrokenDoNotUseCheckLockDuration))
-                         $ \check -> forallPrimEnv $ \env -> forAll (genBoundaryCases . txLockDuration $ envTx env)
+                         $ \check -> forallPrimEnv $ \env -> forAll (genBoundaryCases . txLockBrokenDuration $ envTx env)
                                                    $ \w -> check env (toW16 w)
 
 prop_calculate_issuance_entropy :: Outpoint -> HashElement -> Bool