worldland/beta : Add Beta Network with ECCBeta Consensus

.gitignore

@@ -47,3 +47,4 @@ profile.cov
 /dashboard/assets/package-lock.json
 
 **/yarn-error.log
+beta-data/

cmd/utils/flags.go

@@ -166,6 +166,10 @@ var (
 		Name:  "mio",
 		Usage: "Mio network: Error-Correction Codes Proof-of-Work Test Network",
 	}
+	BetaFlag = &cli.BoolFlag{
+		Name:  "beta",
+		Usage: "Beta network: ECCBeta Proof-of-Work Network",
+	}
 
 	// Dev mode
 	DeveloperFlag = &cli.BoolFlag{
@@ -1002,6 +1006,7 @@ var (
 		KilnFlag,*/
 		GwangjuFlag,
 		MioFlag,
+		BetaFlag,
 	}
 	// NetworkFlags is the flag group of all built-in supported networks.
 	NetworkFlags = append([]cli.Flag{
@@ -1048,6 +1053,9 @@ func MakeDataDir(ctx *cli.Context) string {
 		if ctx.Bool(MioFlag.Name) {
 			return filepath.Join(path, "mio")
 		}
+		if ctx.Bool(BetaFlag.Name) {
+			return filepath.Join(path, "beta")
+		}
 		return path
 	}
 	Fatalf("Cannot determine default data directory, please set manually (--datadir)")
@@ -1110,7 +1118,8 @@ func setBootstrapNodes(ctx *cli.Context, cfg *p2p.Config) {
 		urls = params.GwangjuBootnodes
 	case ctx.Bool(MioFlag.Name):
 		urls = params.MioBootnodes
-
+	case ctx.Bool(BetaFlag.Name):
+		urls = params.BetaBootnodes
 	}
 
 	// don't apply defaults if BootstrapNodes is already set
@@ -1575,6 +1584,8 @@ func SetDataDir(ctx *cli.Context, cfg *node.Config) {
 		cfg.DataDir = filepath.Join(node.DefaultDataDir(), "gwangju")
 	case ctx.Bool(MioFlag.Name) && cfg.DataDir == node.DefaultDataDir():
 		cfg.DataDir = filepath.Join(node.DefaultDataDir(), "mio")
+	case ctx.Bool(BetaFlag.Name) && cfg.DataDir == node.DefaultDataDir():
+		cfg.DataDir = filepath.Join(node.DefaultDataDir(), "beta")
 	}
 
 }
@@ -1968,6 +1979,13 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 		cfg.Genesis = core.DefaultMioGenesisBlock()
 		SetDNSDiscoveryDefaults(cfg, params.MioGenesisHash)
 
+	case ctx.Bool(BetaFlag.Name):
+		if !ctx.IsSet(NetworkIdFlag.Name) {
+			cfg.NetworkId = 91510
+		}
+		cfg.Genesis = core.DefaultBetaGenesisBlock()
+		SetDNSDiscoveryDefaults(cfg, params.BetaGenesisHash)
+
 	case ctx.Bool(DeveloperFlag.Name):
 		if !ctx.IsSet(NetworkIdFlag.Name) {
 			cfg.NetworkId = 1337
@@ -2225,6 +2243,8 @@ func MakeGenesis(ctx *cli.Context) *core.Genesis {
 		genesis = core.DefaultGwangjuGenesisBlock()
 	case ctx.Bool(MioFlag.Name):
 		genesis = core.DefaultMioGenesisBlock()
+	case ctx.Bool(BetaFlag.Name):
+		genesis = core.DefaultBetaGenesisBlock()
 	case ctx.Bool(DeveloperFlag.Name):
 		Fatalf("Developer chains are ephemeral")
 	}
@@ -2249,13 +2269,17 @@ func MakeChain(ctx *cli.Context, stack *node.Node) (*core.BlockChain, ethdb.Data
 	if err != nil {
 		Fatalf("%v", err)
 	}
+	eccbetaConfig, err := core.LoadEccbetaConfig(chainDb, gspec)
+	if err != nil {
+		Fatalf("%v", err)
+	}
 
 	ethashConfig := ethconfig.Defaults.Ethash
 	if ctx.Bool(FakePoWFlag.Name) {
 		ethashConfig.PowMode = ethash.ModeFake
 	}
 
-	engine := ethconfig.CreateConsensusEngine(stack, &ethashConfig, cliqueConfig, eccpowConfig, kaijuConfig, nil, false, chainDb)
+	engine := ethconfig.CreateConsensusEngine(stack, &ethashConfig, cliqueConfig, eccpowConfig, kaijuConfig, eccbetaConfig, nil, false, chainDb)
 	if gcmode := ctx.String(GCModeFlag.Name); gcmode != "full" && gcmode != "archive" {
 		Fatalf("--%s must be either 'full' or 'archive'", GCModeFlag.Name)
 	}

cmd/worldland/main.go

@@ -299,6 +299,9 @@ func prepare(ctx *cli.Context) {
 	case ctx.IsSet(utils.MioFlag.Name):
 		log.Info("Starting Worldland on Mio testnet ...")
 
+	case ctx.IsSet(utils.BetaFlag.Name):
+		log.Info("Starting Worldland on Beta network ...")
+
 	case ctx.IsSet(utils.DeveloperFlag.Name):
 		log.Info("Starting Worldland in ephemeral dev mode...")
 		log.Warn(`You are running Worldland in --dev mode. Please note the following:

consensus/eccbeta/LDPCDecoder.go

@@ -0,0 +1,210 @@
+package eccbeta
+
+import (
+	"encoding/binary"
+	"math"
+
+	"github.com/cryptoecc/WorldLand/core/types"
+	"github.com/cryptoecc/WorldLand/crypto"
+)
+
+//OptimizedDecoding return hashVector, outputWord, LRrtl
+func OptimizedDecoding(parameters Parameters, hashVector []int, H, rowInCol, colInRow [][]int) ([]int, []int, [][]float64) {
+	outputWord := make([]int, parameters.n)
+	LRqtl := make([][]float64, parameters.n)
+	LRrtl := make([][]float64, parameters.n)
+	LRft := make([]float64, parameters.n)
+
+	for i := 0; i < parameters.n; i++ {
+		LRqtl[i] = make([]float64, parameters.m)
+		LRrtl[i] = make([]float64, parameters.m)
+		LRft[i] = math.Log((1-crossErr)/crossErr) * float64((hashVector[i]*2 - 1))
+	}
+	LRpt := make([]float64, parameters.n)
+
+	for ind := 1; ind <= maxIter; ind++ {
+		for t := 0; t < parameters.n; t++ {
+			temp3 := 0.0
+
+			for mp := 0; mp < parameters.wc; mp++ {
+				temp3 = infinityTest(temp3 + LRrtl[t][rowInCol[mp][t]])
+			}
+			for m := 0; m < parameters.wc; m++ {
+				temp4 := temp3
+				temp4 = infinityTest(temp4 - LRrtl[t][rowInCol[m][t]])
+				LRqtl[t][rowInCol[m][t]] = infinityTest(LRft[t] + temp4)
+			}
+		}
+
+		for k := 0; k < parameters.wr; k++ {
+			for l := 0; l < parameters.wr; l++ {
+				temp3 := 0.0
+				sign := 1.0
+				tempSign := 0.0
+				for m := 0; m < parameters.wr; m++ {
+					if m != l {
+						temp3 = temp3 + funcF(math.Abs(LRqtl[colInRow[m][k]][k]))
+						if LRqtl[colInRow[m][k]][k] > 0.0 {
+							tempSign = 1.0
+						} else {
+							tempSign = -1.0
+						}
+						sign = sign * tempSign
+					}
+				}
+				magnitude := funcF(temp3)
+				LRrtl[colInRow[l][k]][k] = infinityTest(sign * magnitude)
+			}
+		}
+
+		for t := 0; t < parameters.n; t++ {
+			LRpt[t] = infinityTest(LRft[t])
+			for k := 0; k < parameters.wc; k++ {
+				LRpt[t] += LRrtl[t][rowInCol[k][t]]
+				LRpt[t] = infinityTest(LRpt[t])
+			}
+
+			/*
+			if LRpt[t] >= 0 {
+				outputWord[t] = 1
+			} else {
+				outputWord[t] = 0
+			}*/
+		}
+	}
+
+	for t := 0; t < parameters.n; t++ {
+		if LRpt[t] >= 0 {
+			outputWord[t] = 1
+		} else {
+			outputWord[t] = 0
+		}
+	}
+
+	return hashVector, outputWord, LRrtl
+}
+
+//OptimizedDecoding return hashVector, outputWord, LRrtl
+func OptimizedDecodingSeoul(parameters Parameters, hashVector []int, H, rowInCol, colInRow [][]int) ([]int, []int, [][]float64) {
+	outputWord := make([]int, parameters.n)
+	LRqtl := make([][]float64, parameters.n)
+	LRrtl := make([][]float64, parameters.n)
+	LRft := make([]float64, parameters.n)
+
+	for i := 0; i < parameters.n; i++ {
+		LRqtl[i] = make([]float64, parameters.m)
+		LRrtl[i] = make([]float64, parameters.m)
+		LRft[i] = math.Log((1-crossErr)/crossErr) * float64((hashVector[i]*2 - 1))
+	}
+	LRpt := make([]float64, parameters.n)
+
+	for ind := 1; ind <= maxIter; ind++ {
+		for t := 0; t < parameters.n; t++ {
+			temp3 := 0.0
+
+			for mp := 0; mp < parameters.wc; mp++ {
+				temp3 = infinityTest(temp3 + LRrtl[t][rowInCol[mp][t]])
+			}
+			for m := 0; m < parameters.wc; m++ {
+				temp4 := temp3
+				temp4 = infinityTest(temp4 - LRrtl[t][rowInCol[m][t]])
+				LRqtl[t][rowInCol[m][t]] = infinityTest(LRft[t] + temp4)
+			}
+		}
+
+		for k := 0; k < parameters.m; k++ {
+			for l := 0; l < parameters.wr; l++ {
+				temp3 := 0.0
+				sign := 1.0
+				tempSign := 0.0
+				for m := 0; m < parameters.wr; m++ {
+					if m != l {
+						temp3 = temp3 + funcF(math.Abs(LRqtl[colInRow[m][k]][k]))
+						if LRqtl[colInRow[m][k]][k] > 0.0 {
+							tempSign = 1.0
+						} else {
+							tempSign = -1.0
+						}
+						sign = sign * tempSign
+					}
+				}
+				magnitude := funcF(temp3)
+				LRrtl[colInRow[l][k]][k] = infinityTest(sign * magnitude)
+			}
+		}
+
+		for t := 0; t < parameters.n; t++ {
+			LRpt[t] = infinityTest(LRft[t])
+			for k := 0; k < parameters.wc; k++ {
+				LRpt[t] += LRrtl[t][rowInCol[k][t]]
+				LRpt[t] = infinityTest(LRpt[t])
+			}
+
+
+			if LRpt[t] >= 0 {
+				outputWord[t] = 1
+			} else {
+				outputWord[t] = 0
+			}
+		}
+	}
+	/*
+	for t := 0; t < parameters.n; t++ {
+		if LRpt[t] >= 0 {
+			outputWord[t] = 1
+		} else {
+			outputWord[t] = 0
+		}
+	}*/
+
+	return hashVector, outputWord, LRrtl
+}
+
+
+//VerifyOptimizedDecoding return bool, hashVector, outputword, digest which are used for validation
+func VerifyOptimizedDecoding(header *types.Header, hash []byte) (bool, []int, []int, []byte) {
+	parameters, _ := setParameters(header)
+	H := generateH(parameters)
+	colInRow, rowInCol := generateQ(parameters, H)
+
+	seed := make([]byte, 40)
+	copy(seed, hash)
+	binary.LittleEndian.PutUint64(seed[32:], header.Nonce.Uint64())
+	seed = crypto.Keccak512(seed)
+
+	hashVector := generateHv(parameters, seed)
+	hashVectorOfVerification, outputWordOfVerification, _ := OptimizedDecoding(parameters, hashVector, H, rowInCol, colInRow)
+	//hashVectorOfVerification, outputWordOfVerification, _ := OptimizedDecodingSeoul(parameters, hashVector, H, rowInCol, colInRow)
+
+	flag , _ := MakeDecision(header, colInRow, outputWordOfVerification)
+
+	if  flag {
+		return true, hashVectorOfVerification, outputWordOfVerification, seed
+	}
+
+	return false, hashVectorOfVerification, outputWordOfVerification, seed
+}
+
+//VerifyOptimizedDecoding return bool, hashVector, outputword, digest which are used for validation
+func VerifyOptimizedDecodingSeoul(header *types.Header, hash []byte) (bool, []int, []int, []byte) {
+	parameters, _ := setParameters_Seoul(header)
+	H := generateH(parameters)
+	colInRow, rowInCol := generateQ(parameters, H)
+
+	seed := make([]byte, 40)
+	copy(seed, hash)
+	binary.LittleEndian.PutUint64(seed[32:], header.Nonce.Uint64())
+	seed = crypto.Keccak512(seed)
+
+	hashVector := generateHv(parameters, seed)
+	//hashVectorOfVerification, outputWordOfVerification, _ := OptimizedDecoding(parameters, hashVector, H, rowInCol, colInRow)
+	hashVectorOfVerification, outputWordOfVerification, _ := OptimizedDecodingSeoul(parameters, hashVector, H, rowInCol, colInRow)
+
+	flag , _ := MakeDecision_Seoul(header, colInRow, outputWordOfVerification)
+
+	if  flag {
+		return true, hashVectorOfVerification, outputWordOfVerification, seed
+	}
+
+	return false, hashVectorOfVerification, outputWordOfVerification, seed
+}

consensus/eccbeta/LDPCDecoder_test.go

@@ -0,0 +1,79 @@
+package eccbeta
+
+import (
+	"math/rand"
+	"reflect"
+	"testing"
+
+	"github.com/cryptoecc/WorldLand/core/types"
+)
+
+func TestNonceDecoding(t *testing.T) {
+	LDPCNonce := generateRandomNonce()
+	EncodedNonce := types.EncodeNonce(LDPCNonce)
+	DecodedNonce := EncodedNonce.Uint64()
+
+	if LDPCNonce == DecodedNonce {
+		t.Logf("LDPCNonce : %v\n", LDPCNonce)
+		t.Logf("Decoded Nonce : %v\n", DecodedNonce)
+	} else {
+		t.Errorf("LDPCNonce : %v\n", LDPCNonce)
+		t.Errorf("Decoded Nonce : %v\n", DecodedNonce)
+	}
+}
+
+func TestGenerateH(t *testing.T) {
+	for i := 0; i < 10; i++ {
+		header := new(types.Header)
+		header.Difficulty = ProbToDifficulty(Table[0].miningProb)
+
+		parameters, _ := setParameters(header)
+
+		H1 := generateH(parameters)
+		H2 := generateH(parameters)
+
+		if !reflect.DeepEqual(H1, H2) {
+			t.Error("Wrong")
+		}
+	}
+}
+
+func TestRandShuffle(t *testing.T) {
+	for attempt := 0; attempt < 100; attempt++ {
+		var hSeed int64
+		var colOrder []int
+
+		for i := 1; i < 4; i++ {
+			colOrder = nil
+			for j := 0; j < 32; j++ {
+				colOrder = append(colOrder, j)
+			}
+
+			rand.Seed(hSeed)
+			rand.Shuffle(len(colOrder), func(i, j int) {
+				colOrder[i], colOrder[j] = colOrder[j], colOrder[i]
+			})
+			hSeed--
+		}
+
+		var hSeed2 int64
+		var colOrder2 []int
+
+		for i := 1; i < 4; i++ {
+			colOrder2 = nil
+			for j := 0; j < 32; j++ {
+				colOrder2 = append(colOrder2, j)
+			}
+
+			rand.Seed(hSeed2)
+			rand.Shuffle(len(colOrder2), func(i, j int) {
+				colOrder2[i], colOrder2[j] = colOrder2[j], colOrder2[i]
+			})
+			hSeed2--
+		}
+
+		if !reflect.DeepEqual(colOrder, colOrder2) {
+			t.Error("Wrong")
+		}
+	}
+}