cmd, codec, config, trie: ignore unexported struct fields, change trie.Genesis to genesis.GenesisData

cmd/gossamer/configcmd.go

@@ -26,6 +26,7 @@ import (
 	"github.com/ChainSafe/gossamer/cmd/utils"
 	"github.com/ChainSafe/gossamer/common"
 	cfg "github.com/ChainSafe/gossamer/config"
+	"github.com/ChainSafe/gossamer/config/genesis"
 	"github.com/ChainSafe/gossamer/core"
 	"github.com/ChainSafe/gossamer/dot"
 	"github.com/ChainSafe/gossamer/internal/api"
@@ -182,7 +183,7 @@ func setP2pConfig(ctx *cli.Context, fig *cfg.P2pCfg) {
 }
 
 // createP2PService starts a p2p network layer from provided config
-func createP2PService(fig *cfg.Config, gendata *trie.Genesis) (*p2p.Service, chan []byte) {
+func createP2PService(fig *cfg.Config, gendata *genesis.GenesisData) (*p2p.Service, chan []byte) {
 	config := p2p.Config{
 		BootstrapNodes: append(fig.P2p.BootstrapNodes, common.BytesToStringArray(gendata.Bootnodes)...),
 		Port:           fig.P2p.Port,

cmd/gossamer/configcmd_test.go

@@ -33,7 +33,6 @@ import (
 	"github.com/ChainSafe/gossamer/config/genesis"
 	"github.com/ChainSafe/gossamer/internal/api"
 	"github.com/ChainSafe/gossamer/polkadb"
-	"github.com/ChainSafe/gossamer/trie"
 	log "github.com/ChainSafe/log15"
 	"github.com/urfave/cli"
 )
@@ -245,8 +244,8 @@ func TestSetGlobalConfig(t *testing.T) {
 }
 
 func TestCreateP2PService(t *testing.T) {
-	gendata := &trie.Genesis{
-		ProtocolId: []byte("gossamer"),
+	gendata := &genesis.GenesisData{
+		ProtocolId: "gossamer",
 	}
 
 	srv, _ := createP2PService(cfg.DefaultConfig(), gendata)

cmd/gossamer/genesis.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/ChainSafe/gossamer/cmd/utils"
+	"github.com/ChainSafe/gossamer/common"
 	cfg "github.com/ChainSafe/gossamer/config"
 	"github.com/ChainSafe/gossamer/config/genesis"
 	"github.com/ChainSafe/gossamer/polkadb"
@@ -20,7 +21,7 @@ func loadGenesis(ctx *cli.Context) error {
 
 	// read genesis file
 	fp := getGenesisPath(ctx)
-	gen, err := genesis.LoadGenesisJsonFile(fp)
+	gen, err := genesis.LoadGenesisData(fp)
 	if err != nil {
 		return err
 	}
@@ -31,7 +32,7 @@ func loadGenesis(ctx *cli.Context) error {
 		return err
 	}
 
-	log.Info("🕸\t Initializing node", "genesisfile", fp, "datadir", fig.Global.DataDir, "name", gen.Name, "id", gen.Id, "protocolID", gen.ProtocolId, "bootnodes", gen.Bootnodes)
+	log.Info("🕸\t Initializing node", "genesisfile", fp, "datadir", fig.Global.DataDir, "name", gen.Name, "id", gen.Id, "protocolID", gen.ProtocolId, "bootnodes", common.BytesToStringArray(gen.Bootnodes))
 
 	err = dbSrv.Start()
 	if err != nil {
@@ -52,25 +53,24 @@ func loadGenesis(ctx *cli.Context) error {
 	// create and load storage trie with initial genesis state
 	t := trie.NewEmptyTrie(tdb)
 
-	err = t.Load(gen.Genesis.Raw)
+	err = t.Load(gen.GenesisFields().Raw)
 	if err != nil {
 		return fmt.Errorf("cannot load trie with initial state: %s", err)
 	}
 
 	// write initial genesis data to DB
 	err = t.StoreInDB()
 	if err != nil {
-		return err
+		return fmt.Errorf("cannot store genesis data in db: %s", err)
 	}
 
 	err = t.StoreHash()
 	if err != nil {
-		return err
+		return fmt.Errorf("cannot store genesis hash in db: %s", err)
 	}
 
 	// store node name, ID, p2p protocol, bootnodes in DB
-	tgen := trie.NewGenesisFromData(gen)
-	return t.Db().StoreGenesisData(tgen)
+	return t.Db().StoreGenesisData(gen)
 }
 
 // getGenesisPath gets the path to the genesis file

cmd/gossamer/genesis_test.go

@@ -60,10 +60,10 @@ func TestStoreGenesisInfo(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	expected := &trie.Genesis{
-		Name:       []byte(tmpGenesis.Name),
-		Id:         []byte(tmpGenesis.Id),
-		ProtocolId: []byte(tmpGenesis.ProtocolId),
+	expected := &genesis.GenesisData{
+		Name:       tmpGenesis.Name,
+		Id:         tmpGenesis.Id,
+		ProtocolId: tmpGenesis.ProtocolId,
 		Bootnodes:  common.StringArrayToBytes(tmpGenesis.Bootnodes),
 	}
 

codec/decode.go

@@ -383,136 +383,139 @@ func (sd *Decoder) DecodeTuple(t interface{}) (interface{}, error) {
 	for i := 0; i < v.NumField(); i++ {
 		// get the field value at i
 		field := v.Field(i)
-		fieldValue := field.Addr().Interface()
 
-		switch v.Field(i).Interface().(type) {
-		case byte:
-			b := make([]byte, 1)
-			_, err = sd.Reader.Read(b)
-
-			ptr := fieldValue.(*byte)
-			*ptr = b[0]
-		case []byte:
-			o, err = sd.DecodeByteArray()
-			if err != nil {
-				break
-			}
-
-			// get the pointer to the value and set the value
-			ptr := fieldValue.(*[]byte)
-			*ptr = o.([]byte)
-		case int8:
-			o, err = sd.DecodeFixedWidthInt(int8(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*int8)
-			*ptr = o.(int8)
-		case int16:
-			o, err = sd.DecodeFixedWidthInt(int16(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*int16)
-			*ptr = o.(int16)
-		case int32:
-			o, err = sd.DecodeFixedWidthInt(int32(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*int32)
-			*ptr = o.(int32)
-		case int64:
-			o, err = sd.DecodeFixedWidthInt(int64(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*int64)
-			*ptr = o.(int64)
-		case uint16:
-			o, err = sd.DecodeFixedWidthInt(uint16(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*uint16)
-			*ptr = o.(uint16)
-		case uint32:
-			o, err = sd.DecodeFixedWidthInt(uint32(0))
-			if err != nil {
-				break
+		if field.CanInterface() {
+			fieldValue := field.Addr().Interface()
+
+			switch v.Field(i).Interface().(type) {
+			case byte:
+				b := make([]byte, 1)
+				_, err = sd.Reader.Read(b)
+
+				ptr := fieldValue.(*byte)
+				*ptr = b[0]
+			case []byte:
+				o, err = sd.DecodeByteArray()
+				if err != nil {
+					break
+				}
+
+				// get the pointer to the value and set the value
+				ptr := fieldValue.(*[]byte)
+				*ptr = o.([]byte)
+			case int8:
+				o, err = sd.DecodeFixedWidthInt(int8(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*int8)
+				*ptr = o.(int8)
+			case int16:
+				o, err = sd.DecodeFixedWidthInt(int16(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*int16)
+				*ptr = o.(int16)
+			case int32:
+				o, err = sd.DecodeFixedWidthInt(int32(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*int32)
+				*ptr = o.(int32)
+			case int64:
+				o, err = sd.DecodeFixedWidthInt(int64(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*int64)
+				*ptr = o.(int64)
+			case uint16:
+				o, err = sd.DecodeFixedWidthInt(uint16(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*uint16)
+				*ptr = o.(uint16)
+			case uint32:
+				o, err = sd.DecodeFixedWidthInt(uint32(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*uint32)
+				*ptr = o.(uint32)
+			case uint64:
+				o, err = sd.DecodeFixedWidthInt(uint64(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*uint64)
+				*ptr = o.(uint64)
+			case int:
+				o, err = sd.DecodeFixedWidthInt(int(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*int)
+				*ptr = o.(int)
+			case uint:
+				o, err = sd.DecodeFixedWidthInt(uint(0))
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*uint)
+				*ptr = o.(uint)
+			case bool:
+				o, err = sd.DecodeBool()
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(*bool)
+				*ptr = o.(bool)
+			case *big.Int:
+				o, err = sd.DecodeBigInt()
+				if err != nil {
+					break
+				}
+
+				ptr := fieldValue.(**big.Int)
+				*ptr = o.(*big.Int)
+			case common.Hash:
+				b := make([]byte, 32)
+				_, err = sd.Reader.Read(b)
+
+				ptr := fieldValue.(*common.Hash)
+				*ptr = common.NewHash(b)
+			case string:
+				o, err = sd.DecodeByteArray()
+				if err != nil {
+					break
+				}
+
+				// get the pointer to the value and set the value
+				ptr := fieldValue.(*string)
+				*ptr = string(o.([]byte))
+			default:
+				_, err = sd.Decode(v.Field(i).Interface())
+				if err != nil {
+					break
+				}
 			}
 
-			ptr := fieldValue.(*uint32)
-			*ptr = o.(uint32)
-		case uint64:
-			o, err = sd.DecodeFixedWidthInt(uint64(0))
 			if err != nil {
 				break
 			}
-
-			ptr := fieldValue.(*uint64)
-			*ptr = o.(uint64)
-		case int:
-			o, err = sd.DecodeFixedWidthInt(int(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*int)
-			*ptr = o.(int)
-		case uint:
-			o, err = sd.DecodeFixedWidthInt(uint(0))
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*uint)
-			*ptr = o.(uint)
-		case bool:
-			o, err = sd.DecodeBool()
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(*bool)
-			*ptr = o.(bool)
-		case *big.Int:
-			o, err = sd.DecodeBigInt()
-			if err != nil {
-				break
-			}
-
-			ptr := fieldValue.(**big.Int)
-			*ptr = o.(*big.Int)
-		case common.Hash:
-			b := make([]byte, 32)
-			_, err = sd.Reader.Read(b)
-
-			ptr := fieldValue.(*common.Hash)
-			*ptr = common.NewHash(b)
-		case string:
-			o, err = sd.DecodeByteArray()
-			if err != nil {
-				break
-			}
-
-			// get the pointer to the value and set the value
-			ptr := fieldValue.(*string)
-			*ptr = string(o.([]byte))
-		default:
-			_, err = sd.Decode(v.Field(i).Interface())
-			if err != nil {
-				break
-			}
-		}
-
-		if err != nil {
-			break
 		}
 	}
 

codec/encode.go

@@ -233,10 +233,12 @@ func (se *Encoder) encodeTuple(t interface{}) (bytesEncoded int, err error) {
 		v = reflect.ValueOf(t)
 	}
 
-	values := make([]interface{}, v.NumField())
+	values := make([]interface{}, 0)
 
 	for i := 0; i < v.NumField(); i++ {
-		values[i] = v.Field(i).Interface()
+		if v.Field(i).CanInterface() {
+			values = append(values, v.Field(i).Interface())
+		}
 	}
 
 	for _, item := range values {