Add support for enabling or disabling entire versions of protocols

Author: Quantumplation

calculation/calculation.go

@@ -208,8 +208,24 @@ func isPoolQualified(program types.Program, pool types.Pool, locked uint64) (boo
 	// if it's covered by one of the "eligible" criteria, we'll flip it true
 	// if it's covered by one of the "disqualified" criteria, we'll flip it back false
 	// BUT, if the "eligible" criteria lists are all null, then every pool starts eligible, so this needs to start true
-	qualified := program.EligiblePools == nil && program.EligibleAssets == nil && program.EligiblePairs == nil
+	qualified := program.EligibleVersions == nil &&
+		program.EligiblePools == nil &&
+		program.EligibleAssets == nil &&
+		program.EligiblePairs == nil
 	reason := ""
+	if program.EligibleVersions != nil {
+		found := false
+		for _, version := range program.EligibleVersions {
+			if version == pool.Version {
+				qualified = true
+				found = true
+				break
+			}
+		}
+		if !found {
+			reason += fmt.Sprintf("Program lists eligible versions, but doesn't list this version (%v); ", pool.Version)
+		}
+	}
 	if program.EligiblePools != nil {
 		found := false
 		for _, poolIdent := range program.EligiblePools {
@@ -249,6 +265,15 @@ func isPoolQualified(program types.Program, pool types.Pool, locked uint64) (boo
 			reason += "Program lists eligible pairs, but doesn't list these two assets as an eligible pair; "
 		}
 	}
+	if program.DisqualifiedVersions != nil {
+		for _, version := range program.DisqualifiedVersions {
+			if version == pool.Version {
+				qualified = false
+				reason += fmt.Sprintf("Version (%v) is explicitly disqualified; ", pool.Version)
+				break
+			}
+		}
+	}
 	if program.DisqualifiedPools != nil {
 		for _, poolIdent := range program.DisqualifiedPools {
 			if poolIdent == pool.PoolIdent {

calculation/calculation_test.go

@@ -223,9 +223,11 @@ func Test_AtLeastOnePercent(t *testing.T) {
 
 func Test_QualifiedPools(t *testing.T) {
 	program := sampleProgram(500_000)
-	poolA := types.Pool{PoolIdent: "A", AssetA: "A", AssetB: "X", TotalLPTokens: 1500}
-	poolB := types.Pool{PoolIdent: "B", AssetA: "B", AssetB: "X", TotalLPTokens: 1500}
-	poolC := types.Pool{PoolIdent: "C", AssetA: "C", AssetB: "Y", TotalLPTokens: 1500}
+	poolA := types.Pool{Version: "V1", PoolIdent: "A", AssetA: "A", AssetB: "X", TotalLPTokens: 1500}
+	poolB := types.Pool{Version: "V1", PoolIdent: "B", AssetA: "B", AssetB: "X", TotalLPTokens: 1500}
+	poolC := types.Pool{Version: "V1", PoolIdent: "C", AssetA: "C", AssetB: "Y", TotalLPTokens: 1500}
+	poolD := types.Pool{Version: "V3", PoolIdent: "D", AssetA: "A", AssetB: "X", TotalLPTokens: 1500}
+	poolE := types.Pool{Version: "V3-stable", PoolIdent: "D", AssetA: "A", AssetB: "X", TotalLPTokens: 1500}
 
 	assertQualified := func(pool types.Pool, qty uint64) {
 		actual, _ := isPoolQualified(program, pool, qty)
@@ -240,6 +242,18 @@ func Test_QualifiedPools(t *testing.T) {
 	assertQualified(poolA, 500)
 	assertDisqualified(poolA, 10)
 
+	program.EligibleVersions = []string{"V1"}
+	assertQualified(poolA, 150)
+	assertDisqualified(poolD, 150)
+	assertDisqualified(poolE, 150)
+
+	program.EligibleVersions = []string{"V1", "V3"}
+	assertQualified(poolA, 150)
+	assertQualified(poolD, 150)
+	assertDisqualified(poolE, 150)
+
+	program.EligibleVersions = nil
+
 	program.EligiblePools = []string{"A"}
 	assertQualified(poolA, 500)
 	assertDisqualified(poolB, 500)
@@ -267,6 +281,18 @@ func Test_QualifiedPools(t *testing.T) {
 	assertDisqualified(poolC, 500)
 	program.EligiblePairs = nil
 
+	program.DisqualifiedVersions = []string{"V1"}
+	assertDisqualified(poolA, 500)
+	assertQualified(poolD, 500)
+	assertQualified(poolE, 500)
+
+	program.DisqualifiedVersions = []string{"V1", "V3-stable"}
+	assertDisqualified(poolA, 500)
+	assertQualified(poolD, 500)
+	assertDisqualified(poolE, 500)
+
+	program.DisqualifiedVersions = nil
+
 	program.DisqualifiedPools = []string{"A"}
 	assertDisqualified(poolA, 500)
 	assertQualified(poolB, 500)

types/types.go

@@ -38,6 +38,8 @@ type Program struct {
 	// Any remaining emissions above this are *not* emitted, and instead rever to the treasury
 	EmissionCap uint64
 
+	// A list of eligible protocol versions
+	EligibleVersions []string
 	// A list of pools for which a delegation is considered valid
 	EligiblePools []string
 	// A list of assets for which *any* pools will be considered valid
@@ -47,6 +49,8 @@ type Program struct {
 		AssetA shared.AssetID
 		AssetB shared.AssetID
 	}
+	// A list of which protocol versions will be ignored
+	DisqualifiedVersions []string
 	// A list of pools for which delegation will be ignored
 	DisqualifiedPools []string
 	// A list of assets, for which *any* pools will be considered invalid
@@ -66,6 +70,7 @@ type Program struct {
 
 type Pool struct {
 	PoolIdent       string
+	Version         string
 	TransactionHash string
 	Slot            uint64
 	TotalLPTokens   uint64