BIP: 68
  Title: Consensus-enforced transaction replacement signaled via sequence numbers (relative lock-time)
  Author: Mark Friedenbach 
  Status: Draft
  Type: Standards Track
  Created: 2015-05-28

    enum {
        /* Interpret sequence numbers as relative lock-time constraints. */
        LOCKTIME_VERIFY_SEQUENCE = (1 << 0),
    };
    
    /* Setting nSequence to this value for every input in a transaction
     * disables nLockTime. */
    const uint32_t CTxIn::SEQUENCE_FINAL = 0xffffffff;
    /* Threshold for CTxIn::nSequence: below this value it is interpreted
     * as arelative lock-time, otherwise ignored. */
    const uint32_t CTxIn::SEQUENCE_LOCKTIME_THRESHOLD = (1 << 31);
     /* Threshold for CTxIn::nSequence when interpreted as a relative
      * lock-time: below this value it has units of blocks, otherwise
      * seconds. */
    const uint32_t CTxIn::SEQUENCE_UNITS_THRESHOLD = (1 << 30);
    /* Number of reserved low-order bits (depending on units used) which
     * are shifted out prior to relative lock-time constraint checking. */
    const int CTxIn::SEQUENCE_BLOCKS_OFFSET = 14;
    const int CTxIn::SEQUENCE_SECONDS_OFFSET = 5;
    
    int64_t LockTime(const CTransaction &tx,
                     int flags, const CCoinsView* pCoinsView,
                     int nBlockHeight, int64_t nBlockTime)
    {
        CCoins coins;
    
        bool fEnforceBIP68 = tx.nVersion >= 2
                          && flags & LOCKTIME_VERIFY_SEQUENCE;
    
        // Will be set to the equivalent height- and time-based nLockTime
        // values that would be necessary to satisfy all relative lock-
        // time constraints given our view of block chain history.
        int nMinHeight = 0;
        int64_t nMinTime = 0;
        // Will remain equal to true if all inputs are finalized
        // (CTxIn::SEQUENCE_FINAL).
        bool fFinalized = true;
    
        BOOST_FOREACH(const CTxIn& txin, tx.vin) {
            // Set a flag if we witness an input that isn't finalized.
            if (CTxIn::SEQUENCE_FINAL == txin.nSequence)
                continue;
            else
                fFinalized = false;
    
            // Do not enforce sequence numbers as a relative lock time
            // unless we have been instructed to.
            if (!fEnforceBIP68)
                continue;
    
            // Sequence numbers equal to or above the locktime threshold
            // are not treated as relative lock-times, nor are they given
            // any consensus-enforced meaning at this point.
            if (txin.nSequence >= CTxIn::SEQUENCE_LOCKTIME_THRESHOLD)
                continue;
    
            // Skip this input if it is not in the UTXO set. Aside from
            // the coinbase input, this should only ever happen in non-
            // consensus code.
            if (!pCoinsView->GetCoins(txin.prevout.hash, coins))
                continue;
    
            if (txin.nSequence < CTxIn::SEQUENCE_UNITS_THRESHOLD)
                // We subtract 1 from relative lock-times because a lock-
                // time of 0 has the semantics of "same block," so a lock-
                // time of 1 should mean "next block," but nLockTime has
                // the semantics of "last invalid block height."
                nMinHeight = std::max(nMinHeight,
                      coins.nHeight
                    + (int)(txin.nSequence >> CTxIn::SEQUENCE_BLOCKS_OFFSET)
                    - 1);
            else
                // Time-based relative lock-times are measured from the
                // smallest allowed timestamp of the block containing the
                // txout being spent, which is the median time past of the
                // block prior. We subtract one for the same reason as
                // above.
                nMinTime = std::max(nMinTime,
                      pindexBestHeader->GetAncestor(coins.nHeight-1)->GetMedianTimePast()
                    + (int64_t)((txin.nSequence ^ CTxIn::SEQUENCE_UNITS_THRESHOLD) >> CTxIn::SEQUENCE_SECONDS_OFFSET)
                    - 1);
        }
    
        // If all sequence numbers are CTxIn::SEQUENCE_FINAL, the
        // transaction is considered final and nLockTime constraints
        // are not enforced.
        if (fFinalized)
            return 0;
    
        if ((int64_t)tx.nLockTime < LOCKTIME_THRESHOLD)
            nMinHeight = std::max(nMinHeight, (int)tx.nLockTime);
        else
            nMinTime = std::max(nMinTime, (int64_t)tx.nLockTime);
    
        if (nMinHeight >= nBlockHeight)
            return nMinHeight;
        if (nMinTime >= nBlockTime)
            return nMinTime;
    
        return 0;
    }
    
    int64_t CheckLockTime(const CTransaction &tx, int flags)
    {
        AssertLockHeld(cs_main);
    
        // By convention a negative value for flags indicates that the
        // current network-enforced consensus rules should be used.
        flags = std::max(flags, 0);
    
        // pcoinsTip contains the UTXO set for chainActive.Tip()
        const CCoinsView *pCoinsView = pcoinsTip;
    
        // CheckLockTime() uses chainActive.Height()+1 to evaluate
        // nLockTime because when LockTime() is called within
        // CBlock::AcceptBlock(), the height of the block *being*
        // evaluated is what is used. Thus if we want to know if a
        // transaction can be part of the *next* block, we need to call
        // LockTime() with one more than chainActive.Height().
        const int nBlockHeight = chainActive.Height() + 1;
    
        // Timestamps on the other hand don't get any special treatment,
        // because we can't know what timestamp the next block will have,
        // and there aren't timestamp applications where it matters.
        const int64_t nBlockTime = GetAdjustedTime();
    
        return LockTime(tx, flags, pCoinsView, nBlockHeight, nBlockTime);
    }

    // 0 <= nHeight < 65,535 blocks (1.25 years)
    nSequence = nHeight << 14;
    nHeight = nSequence >> 14;
    
    // 0 <= nTime < 33,554,431 seconds (1.06 years)
    nSequence = 1<<30 | (nTime << 5);
    nTime = (nSequence ^ 1<<30) >> 5;