feat: Migrate from substrate to polkadot-sdk repo + Implement genesis builder

.gitmodules

@@ -7,6 +7,6 @@
 [submodule "goscale"]
 	path = goscale
 	url = git@github.com:LimeChain/goscale.git
-[submodule "substrate"]
-	path = substrate
-	url = git@github.com:LimeChain/substrate.git
+[submodule "polkadot-sdk"]
+	path = polkadot-sdk
+	url = git@github.com:LimeChain/polkadot-sdk.git

Makefile

@@ -78,11 +78,11 @@ build-dev: build-tinygo
 	WASMOPT="$(CURRENT_DIR)/$(WASMOPT_PATH)" $(TINYGO_BUILD_COMMAND) -o=$(BUILD_PATH) runtime/runtime.go
 
 start-network:
-	cp build/runtime.wasm substrate/bin/node-template/runtime.wasm; \
-	cd substrate/bin/node-template; \
+	cp build/runtime.wasm polkadot-sdk/substrate/bin/node-template/runtime.wasm; \
+	cd polkadot-sdk/substrate/bin/node-template/node; \
 	cargo build --release; \
-	cd ../..; \
-	WASMTIME_BACKTRACE_DETAILS=1 RUST_LOG=runtime=trace ./target/release/node-template --dev --execution Wasm
+	cd ../../../..; \
+	WASMTIME_BACKTRACE_DETAILS=1 RUST_LOG=runtime=trace ./target/release/node-template --dev --execution=wasm
 
 test: test-unit test-integration
 

api/genesis_builder/module.go

@@ -0,0 +1,95 @@
+package genesisbuilder
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+
+	sc "github.com/LimeChain/goscale"
+	"github.com/LimeChain/gosemble/primitives/hashing"
+	"github.com/LimeChain/gosemble/primitives/log"
+	primitives "github.com/LimeChain/gosemble/primitives/types"
+	"github.com/LimeChain/gosemble/utils"
+)
+
+const (
+	ApiModuleName = "GenesisBuilder"
+	apiVersion    = 1
+)
+
+type GenesisBuilder interface {
+	CreateDefaultConfig() ([]byte, error)
+	BuildConfig(config []byte) error
+}
+
+type Module struct {
+	modules  []primitives.Module
+	memUtils utils.WasmMemoryTranslator
+}
+
+func New(modules []primitives.Module) Module {
+	return Module{
+		modules:  modules,
+		memUtils: utils.NewMemoryTranslator(),
+	}
+}
+
+func (m Module) Name() string {
+	return ApiModuleName
+}
+
+func (m Module) Item() primitives.ApiItem {
+	hash := hashing.MustBlake2b8([]byte(ApiModuleName))
+	return primitives.NewApiItem(hash, apiVersion)
+}
+
+func (m Module) CreateDefaultConfig() int64 {
+	gcs := []string{}
+	for _, m := range m.modules {
+		genesisBuilder, ok := m.(GenesisBuilder)
+		if !ok {
+			continue
+		}
+
+		gcJsonBytes, err := genesisBuilder.CreateDefaultConfig()
+		if err != nil {
+			log.Critical(err.Error())
+		}
+
+		// gcJsonBytes[1:len(gcJsonBytes)-1] trims first and last characters which represent start and end of the json
+		// CreateDefaultConfig returns a valid json (e.g. {"system":{}}), and here we need it as a json field
+		gcs = append(gcs, string(gcJsonBytes[1:len(gcJsonBytes)-1]))
+	}
+
+	gcJson := []byte(fmt.Sprintf("{%s}", strings.Join(gcs, ",")))
+
+	return m.memUtils.BytesToOffsetAndSize(sc.BytesToSequenceU8(gcJson).Bytes())
+}
+
+func (m Module) BuildConfig(dataPtr int32, dataLen int32) int64 {
+	gcJsonBytes := m.memUtils.GetWasmMemorySlice(dataPtr, dataLen)
+	gcDecoded, err := sc.DecodeSequence[sc.U8](bytes.NewBuffer(gcJsonBytes))
+	if err != nil {
+		log.Critical(err.Error())
+	}
+
+	gcDecodedBytes := sc.SequenceU8ToBytes(gcDecoded)
+
+	for _, m := range m.modules {
+		genesisBuilder, ok := m.(GenesisBuilder)
+		if !ok {
+			continue
+		}
+
+		if err := genesisBuilder.BuildConfig(gcDecodedBytes); err != nil {
+			log.Critical(err.Error())
+		}
+	}
+
+	return m.memUtils.BytesToOffsetAndSize([]byte{0})
+}
+
+// todo metadata
+// func (m Module) Metadata() primitives.RuntimeApiMetadata {
+// 	return primitives.RuntimeApiMetadata{}
+// }

api/genesis_builder/module_test.go

@@ -0,0 +1,92 @@
+package genesisbuilder
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/ChainSafe/gossamer/lib/common"
+	sc "github.com/LimeChain/goscale"
+	"github.com/LimeChain/gosemble/mocks"
+	"github.com/LimeChain/gosemble/primitives/types"
+	"github.com/stretchr/testify/assert"
+)
+
+var (
+	genesis         = []byte("{\"module\":{\"field\":[]}}")
+	genesisSequence = sc.BytesToSequenceU8(genesis).Bytes()
+)
+
+var (
+	target          Module
+	mockModule      *mocks.Module
+	mockMemoryUtils *mocks.MemoryTranslator
+)
+
+func setup() {
+	mockModule = new(mocks.Module)
+	mockMemoryUtils = new(mocks.MemoryTranslator)
+
+	target = New([]types.Module{mockModule})
+	target.memUtils = mockMemoryUtils
+}
+
+func Test_Module_Name(t *testing.T) {
+	setup()
+	result := target.Name()
+	assert.Equal(t, ApiModuleName, result)
+}
+
+func Test_Module_Item(t *testing.T) {
+	setup()
+	hexName := common.MustBlake2b8([]byte(ApiModuleName))
+	expect := types.NewApiItem(hexName, apiVersion)
+	result := target.Item()
+	assert.Equal(t, expect, result)
+}
+
+func Test_CreateDefaultConfig(t *testing.T) {
+	setup()
+	mockModule.On("CreateDefaultConfig").Return(genesis, nil)
+	mockMemoryUtils.On("BytesToOffsetAndSize", genesisSequence).Return(int64(0))
+
+	target.CreateDefaultConfig()
+
+	mockModule.AssertCalled(t, "CreateDefaultConfig")
+	mockMemoryUtils.AssertCalled(t, "BytesToOffsetAndSize", genesisSequence)
+}
+
+func Test_CreateDefaultConfig_Error(t *testing.T) {
+	setup()
+	mockModule.On("CreateDefaultConfig").Return(genesis, errors.New("err"))
+	mockMemoryUtils.On("BytesToOffsetAndSize", genesisSequence).Return(int64(0))
+
+	assert.PanicsWithValue(t,
+		errors.New("err").Error(),
+		func() { target.CreateDefaultConfig() },
+	)
+}
+
+func Test_BuildConfig(t *testing.T) {
+	setup()
+	mockModule.On("BuildConfig", genesis).Return(nil)
+	mockMemoryUtils.On("GetWasmMemorySlice", int32(0), int32(0)).Return(genesisSequence)
+	mockMemoryUtils.On("BytesToOffsetAndSize", []byte{0}).Return(int64(0))
+
+	target.BuildConfig(0, 0)
+
+	mockMemoryUtils.AssertCalled(t, "GetWasmMemorySlice", int32(0), int32(0))
+	mockModule.AssertCalled(t, "BuildConfig", genesis)
+	mockMemoryUtils.AssertCalled(t, "BytesToOffsetAndSize", []byte{0})
+}
+
+func Test_BuildConfig_Error(t *testing.T) {
+	setup()
+	mockModule.On("BuildConfig", genesis).Return(errors.New("err"))
+	mockMemoryUtils.On("GetWasmMemorySlice", int32(0), int32(0)).Return(genesisSequence)
+	mockMemoryUtils.On("BytesToOffsetAndSize", []byte{0}).Return(int64(0))
+
+	assert.PanicsWithValue(t,
+		errors.New("err").Error(),
+		func() { target.BuildConfig(0, 0) },
+	)
+}

frame/aura/genesis_builder.go

@@ -0,0 +1,90 @@
+package aura
+
+import (
+	"encoding/json"
+	"errors"
+
+	sc "github.com/LimeChain/goscale"
+	"github.com/LimeChain/gosemble/primitives/types"
+	"github.com/vedhavyas/go-subkey"
+)
+
+var (
+	errAuthoritiesAlreadyInitialized   = errors.New("Authorities are already initialized!")
+	errAuthoritiesExceedMaxAuthorities = errors.New("Initial authority set must be less than MaxAuthorities")
+)
+
+type GenesisConfig struct {
+	Authorities sc.Sequence[types.Sr25519PublicKey]
+}
+
+type genesisConfigJsonStruct struct {
+	AuraGenesisConfig struct {
+		Authorities []string `json:"authorities"`
+	} `json:"aura"`
+}
+
+func (gc *GenesisConfig) UnmarshalJSON(data []byte) error {
+	gcJson := genesisConfigJsonStruct{}
+
+	if err := json.Unmarshal(data, &gcJson); err != nil {
+		return err
+	}
+
+	addrExists := map[string]bool{}
+	for _, a := range gcJson.AuraGenesisConfig.Authorities {
+		if addrExists[a] {
+			continue
+		}
+
+		_, pubKeyBytes, err := subkey.SS58Decode(a)
+		if err != nil {
+			return err
+		}
+
+		pubKey, err := types.NewSr25519PublicKey(sc.BytesToSequenceU8(pubKeyBytes)...)
+		if err != nil {
+			return err
+		}
+
+		gc.Authorities = append(gc.Authorities, pubKey)
+		addrExists[a] = true
+	}
+
+	return nil
+}
+
+func (m Module) CreateDefaultConfig() ([]byte, error) {
+	gc := genesisConfigJsonStruct{}
+	gc.AuraGenesisConfig.Authorities = []string{}
+
+	return json.Marshal(gc)
+}
+
+func (m Module) BuildConfig(config []byte) error {
+	gc := GenesisConfig{}
+	if err := json.Unmarshal(config, &gc); err != nil {
+		return err
+	}
+
+	if len(gc.Authorities) == 0 {
+		return nil
+	}
+
+	totalAuthorities, err := m.storage.Authorities.DecodeLen()
+	if err != nil {
+		return err
+	}
+
+	if totalAuthorities.HasValue {
+		return errAuthoritiesAlreadyInitialized
+	}
+
+	if len(gc.Authorities) > int(m.config.MaxAuthorities) {
+		return errAuthoritiesExceedMaxAuthorities
+	}
+
+	m.storage.Authorities.Put(gc.Authorities)
+
+	return nil
+}