Creating a perpetual token

In other words, a token that is guaranteed to exist forever, unless it gets garbage-collected!

    {
      val isPerpetual = {(b: Box) =>
        b.propositionBytes == SELF.propositionBytes && b.tokens == SELF.tokens
      }

      sigmaProp(OUTPUTS.exists(isPerpetual))
    }

To be precise, this is a perpetual collection of tokens (possibly of size zero). But if you protect a singleton token with this script, then it guarantees the token will never be destroyed other than by garbage collection

See this thread for the full discussion.

I apologize for the confusion. Here's the explanation with more details and code blocks to make it easier for a beginner programmer to understand:

Multi-Stage Protocols

Multi-stage protocols are used in scenarios where multiple scripts interact with each other. In these protocols, one script can reference the script of a subsequent stage.

Consider the following example:

In script1, we have the statement:

hash(OUTPUTS(0).propositionBytes) == script2Hash

This means that script1 is checking whether the hash of the first output's propositionBytes equals the hash of script2.

However, if we also want script2 to refer back to script1, as in the example below:

hash(OUTPUTS(0).propositionBytes) == script1Hash

We encounter a cyclic reference issue, as both scripts are referring to each other.

To resolve this, we can store script1Hash in a register of the box containing script2. Additionally, we need to modify script1 to ensure that the corresponding register of any box containing script2 is equal to hash(SELF.propositionBytes).

While this "vanilla" perpetual token is interesting, a more powerful and flexible approach is the "max-once-per-block-use" perpetual token, which should be considered a separate design pattern.