[planning] Hard-fork Activation Support

[aslesarenko]

Problem

The hard-fork activation will be implemented according to EIP-9.
To support activation protocol, sigma code should support both ErgoTree v0 and v1 versions at the same time (even in the same transaction). This means we cannot accumulate changes in a separate branch (as we normally do) and then release them all at once (which would replace v0 version with v1 version implementation).

Support of both versions simultaneously requires a discipline in how the protocol related changes are introduced into the code.

Solution

Roughly, the idea is that the code changes should be protected by version checking conditions like the following:

if (currVersion == v1) {
  // new code
} else if (currVersion == v0) {
  // old code
} else {
  // unsupported version
}

This will makes the code:

1. support both the old ErgoTree v0 and the new ErgoTree v1 and
2. switch the version conditionally based on the value of currVersion.

Existing v4.0 branch has already accumulated many protocol related changes, however those are without version checking conditions.

[aslesarenko]

It seems we will have a lot of places with versioned code for 5.0.

The easiest way I see to implement it is to pass VersionContext (or something like this) to all those places using DynamicVariable, which is based on java.lang.InheritableThreadLocal (since JDK 1.2 for passing UserID, TransactionID kind of things).
What is required is that verifier.verify(...) is called under correctly constructed VersionContext (which is part of HF Activation Protocol).

That said, I don't expect problems with versioned implementation of anything in Sigma, as long as verify is called under correct VersionContext.

It can then be used in a versioned code fragment like the following:

currentVersionContext match {
  case Version(3, x) | Version(4, 0) => 
    //  code of version 3.x where x is bound to the actual value or version 4.0
    // existing code goes here
  case Version(4, x) =>
   // this case of version 4.x code (can be added later in a soft-fork release) where x > 0
  case _ => 
    // unknown version is interpreted as soft-fork condition 
    // (i.e. this is the old code which is executed in the network after new version was activated)
    // by throwing this exception we signal the validator, to accept the script without validation
    throw new ValidationException(versionedFragmentId)
}

Any such Versioned Code Fragment is easily made soft-forkable by just throwing ValidationException when executed under unknown VersionContext. Here versionedFragmentId is a unique code of this code fragment (they all can be enumerated if necessary).

ValidationException in turn can be checked for soft-fork condition in the verifier.

NOTE:
We don't need to provide new implementation (besides the existing) for any Versioned Code Fragment as part of v4.0 HF.
All we need to do is to refactor any existing code we know we want to change into a versioned code fragment like the above and thus making it soft-forkable.

[aslesarenko]

Possible AOT -> JIT switch via version increment and soft-fork activation:

1. we will increment script version in ErgoTree header (now it is 0, and will be 1).

2. The 4.0 node, after soft-fork 5.0 is activated will check the version, and if it is > 0 it will accept the script without validation (at this point the majority of nodes will be 5.0)

3. after soft-fork 5.0 is activated, all 5.0 nodes will execute v0 scripts using current AOT based interpreter, and v1 script using JIT based interpreter

4. before soft-fork is activated all nodes (4.0 and 5.0 releases) will execute only v0 scripts using AOT based interpreter and will reject v1 scripts

5. both v0 and v1 scripts will be supported by the network and applications may create transactions with both v0 and v1 scripts.

6. Since we are going to fix some bugs, the behaviour of v0 and v1 scripts in general not required to be precisely equivalent. So while old apps are supported unchanged, new apps are encouraged to use new ErgoScript frontend which will compile v1 scripts